Game Art Terms Explained

The marker that decides where things appear

The 3D Cursor is the red and white marker in Blender's viewport. New objects appear where it is, it can be used as the pivot for rotation and scaling, and Set Origin can place an object's origin on it. Shift+right-click places it, Shift+S opens the snap menu to move it to a selection or to the world origin, and Shift+C resets it and frames everything. It is one of the most useful and most confusing tools for beginners.

Layering motion on top of other animation

Additive animation stores the difference between a pose and a reference pose, and adds that difference on top of another animation instead of replacing it. This lets effects such as breathing, leaning into a turn, aiming up and down, flinching from a hit or a damaged limp be layered over locomotion without making a new clip for each combination. It reduces the number of animations, and works in Unreal Engine through additive settings, and in Unity through additive layers.

Two ways particles combine with the scene

Additive and alpha blending are the two main ways particles are combined with what is behind them. Additive adds the particle's color to the image, so it can only brighten, which suits fire, sparks, lasers, glows and magic, and the result does not depend on the drawing order. Alpha blending mixes the particle with the background by opacity, so it can also darken, which suits smoke, dust, mist and clouds, but it needs correct sorting and costs overdraw.

Using image generators in the ideation stage

AI-assisted concept art means using image generators such as Midjourney, Stable Diffusion, Flux or Adobe Firefly to produce ideas, moods, color studies and references at speed. Artists use them mainly in early exploration, to see many directions fast, and then design the final piece by hand with their own composition, drawing and painting. Studios have different policies, and questions about training data, copyright and credit are still unsettled, so artists need to check the rules of their client or employer.

Base colour without lighting

Albedo is the base colour of a surface in a PBR workflow, representing the surface's pure pigment with no baked-in lighting, shadows, or reflections. A correct albedo map looks flat and even — almost dull on its own — because all lighting comes from the engine at render time. Baking light into albedo (a common beginner mistake) double-shades the material when the scene's own lights hit it.

Fourth channel that stores transparency or a mask

An alpha channel is a fourth channel stored with a texture's red, green and blue channels, usually describing transparency, where white is opaque and black is transparent. In game art it is used for cutouts such as leaves, fences and hair, for opacity masks and also to hold extra data, such as smoothness in Unity's metallic map or a mask in a packed texture. Not all file formats store alpha, but PNG, TGA and EXR do.

Soft contact shadows

Ambient occlusion (AO) is a shading effect that darkens recessed crevices and contact points where ambient light would naturally have a harder time reaching. As a texture channel it is baked from the high-poly mesh and used to subtly tint the albedo and roughness, grounding the model visually. Real-time engines also compute screen-space AO (SSAO) at runtime to add contact shadows that a static map cannot capture.

Bony points and muscle groups that guide a sculpt

Anatomy landmarks are the bony points and large muscle groups that show on the surface of the body, and that artists use to place forms correctly. Examples are the collarbones, the points of the shoulder and hip, the knee and elbow, the ribcage and the pelvis, and they stay visible in most poses. Human proportions are often taught as about seven and a half to eight heads tall, and knowing these landmarks helps to keep a character believable, even when the style is exaggerated.

Interpolate poses between clips

Animation blending interpolates between two or more poses (usually weighted by gameplay variables like speed and direction) to produce a single output pose. A 1D blend space transitions between walk and run by speed; a 2D blend space adds strafing by direction. Additive blends layer a partial pose (an aim offset, a reload) on top of a base. Smooth blending is what separates a "stiff" character from a "responsive" one.

Reducing animation memory with a small error

Animation compression reduces the memory used by animation data by removing keys, simplifying curves and storing values with less precision, within an allowed error. Characters have many bones and animations, so without compression the data would use a lot of memory and streaming bandwidth. Engines apply it automatically on import, with settings such as error thresholds and per-bone rules, and too much compression leads to visible jitter, foot sliding or drifting poses.

Which frame rate to animate and export at

Animation frame rate is the number of frames per second at which animation is authored and sampled. Film is traditionally 24 frames per second, television and many games use 30, and fast or competitive games use 60 or more. Game animation is often authored at 30 and then interpolated by the engine, which plays it at any display rate, so the animation does not have to match the game's frame rate. What matters is consistency between the authoring tool, the export and the engine.

Node-based runtime animation evaluation

An animation graph is the per-frame node graph that evaluates pose data and produces a final skeleton pose ready for rendering. Inputs are state machines, blend spaces, and live data (IK targets, lookAt); outputs are bone transforms. Unreal’s AnimGraph and Unity’s Animator Controller graph are the two most common implementations. Most live animation logic — additive layers, IK, foot placement — lives in this graph rather than in the source clips.

Motion plays differently than in Maya or Blender

Animation looks different in the engine than in your 3D tool when the frame rate, scale, skeleton or compression do not match. Export at the project's frame rate and bake the animation so every frame has keys, use the same skeleton and bind pose in both places, check that the units and scale are correct, and reduce lossy animation compression for key clips. Root motion and bone axis settings also change how the movement plays.

Unreal asset for playing action sequences from gameplay

An animation montage is an Unreal Engine asset that wraps one or more animation sequences so that gameplay can play them on demand and control them. A montage can have named sections, such as wind-up, strike and recovery, which can be jumped to or looped, and slots that decide in which part of the animation graph it plays, such as the upper body only. It is the standard tool for attacks, abilities, reloads and interactions, which are triggered by game logic.

Triggers placed on specific frames of an animation

Animation notifies, called animation events in Unity, are markers placed on specific frames of an animation that trigger something in the game when the animation passes them. Typical uses are footstep sounds and dust at foot contacts, spawning a muzzle flash on the frame of a shot, opening a damage window during a sword swing and playing a reload sound. Unreal Engine also has notify states, which span a range of frames, for things like an active hitbox or a trail effect.

Sudden jumps when switching animations

Animation pops when the engine switches between two clips that have very different poses and has no time to blend them. Set a blend duration on the transition, typically a tenth to a quarter of a second, make sure the end pose of one clip is close to the start pose of the next, and use a blend space or an additive layer where the motion is continuous. Check the transition conditions so states do not flip back and forth.

Transferring animation between skeletons

Animation retargeting transfers a clip recorded on one skeleton onto another with different proportions or bone count. The retargeter matches bone names or a manual mapping, then re-calculates the animation to preserve the original intent (foot placement, hand contact) despite skeletal differences. Without retargeting, every character would need its own animation library — with it, one Mixamo run cycle plays on a tall thin character and a short stocky one alike.

Graph of animation states and transitions

An animation state machine is a graph where each node represents an animation clip or sub-machine and edges represent transitions guarded by conditions (speed, isJumping, isGrounded). It is how engines decide which clip to play and how to blend between them. Both Unity’s Animator and Unreal’s Animation Blueprint expose state machines as the top-level structure of any non-trivial character.

Direction-dependent reflection

Anisotropic shading produces reflections that stretch along a specific surface direction — the long horizontal highlight on brushed metal, the radial shimmer on a vinyl record, the streaked specular on hair. Standard PBR is isotropic (reflections are circular); anisotropic shading adds a tangent direction the highlight stretches along. Essential for hair, brushed metals, fabric with directional weave.

Smoothing jagged edges

Anti-aliasing smooths the jagged, stair-stepped edges that appear when a 3D scene is drawn on a grid of pixels. Methods include supersampling, which renders at a higher resolution and scales down, MSAA, which samples extra points along geometry edges, FXAA and SMAA, which blur edges in a post-process, TAA, which blends several frames over time, and upscalers such as DLSS and FSR that combine reconstruction with anti-aliasing. Each method trades quality, sharpness and performance differently.

Hide repetition in tileable textures

Anti-tiling is the umbrella term for techniques that break up the visible repetition of a tiled texture across large surfaces: stochastic sampling, randomized UV offsets per cell, vertex-color masks blending a second variant, or hand-painted decals layered on top. Without it, ground and wall textures show obvious grid patterns at any distance — a classic environment-art tell.

Fix stretched bevels and uneven modifier results

If a bevel looks uneven, a texture is stretched or an Array, Solidify or physics modifier behaves strangely, the object probably has a scale other than 1. In Object Mode press Ctrl+A and choose Scale, or All Transforms, to apply it. The object keeps its shape, but the mesh now holds the real size and the scale returns to 1, 1, 1.

Blender's skeleton object

An armature is Blender's skeleton object, made of bones that you build in Edit Mode and pose in Pose Mode. A mesh follows the bones through an Armature modifier, which uses vertex groups for the weights. Parenting with Ctrl+P and Automatic Weights creates the groups and a first set of weights, which you then refine in Weight Paint Mode. Bone constraints, IK and drivers turn a skeleton into an animation rig.

Maya's default path-traced renderer

Arnold is a path-traced renderer, built into Maya as its default, that simulates light physically to produce realistic images. It supports global illumination, soft shadows, reflections, refraction and subsurface scattering, and runs on the CPU, with a GPU mode in newer versions. It is used in film, animation and for portfolio renders of game models, as it needs little setup for good-looking results, though renders can be slow and noisy at low sample counts.

Repeats an object in a line or around a shape

The Array modifier repeats an object a set number of times, or until it fills a length or follows a curve. Relative Offset moves each copy by a fraction of the object's size, Constant Offset by a fixed distance, and Object Offset by another object's transform, which is how circular arrays are made. With Merge on, copies whose edges touch join into one continuous mesh. It is used for fences, chains, stairs, tiles and railings.

Who decides the look and who manages the team

An art director sets and protects the visual vision of a game, deciding its style, mood and quality bar, and approving the work of the team. Lead artists manage a group of artists in a discipline, such as environments or characters, checking quality, giving feedback, planning tasks and solving problems with the pipeline. Producers manage the schedule, budget and communication across the project. A technical art director takes care of the tools and technical standards. Together, they keep the team's work consistent and on time.

The practical assignment in a studio hiring process

An art test is a practical task that a studio gives a candidate during hiring, to see how they work on a real brief. A concept artist might be asked to design a character or environment from a short description, a 3D artist to model, texture and present a prop, and a texture artist to texture a given model in the studio's style. Studios judge not only the final image, but also the process, the use of references, readability, following the brief and meeting the deadline.

Blender's built-in library for reusable assets

The Asset Browser is Blender's built-in library for reusable assets such as objects, materials, poses, collections, node groups and worlds. You mark an item as an asset, give it a preview and tags, and store it in an asset library on disk, then drag it into any scene. Libraries can be shared by a team, which makes it a simple way to keep a kit of props, materials and presets organized.

Mobile-era GPU texture compression

ASTC is the modern texture-compression standard used on mobile GPUs (Adreno, Mali, Apple) and increasingly on console. Unlike BC formats which have fixed block sizes, ASTC supports variable block sizes from 4×4 up to 12×12, letting artists trade quality for size at per-texture granularity. ASTC 6×6 at 8 bits/pixel gives quality close to BC7 at the same bitrate; ASTC 8×8 halves memory at acceptable quality for non-hero textures.

Data stored on points, primitives and vertices

Attributes in Houdini are named values stored on a geometry's points, vertices, primitives or on the geometry as a whole, called detail. Position (P), color (Cd), normal (N) and UV are standard attributes, and you can create your own, such as height, age, density or a random value. Nodes read and write attributes to drive effects, so a color can control scale, or a noise value can control which points get copied objects.

Unity's bone mapping for humanoid animation

An Avatar is the data Unity uses to map a character's bones onto a standard humanoid skeleton. When a model's rig type is Humanoid, Unity builds an Avatar so any humanoid animation can drive any humanoid character, which is called retargeting. The character needs at least the main bones of a human body: hips, spine, head, arms and legs. Generic rigs do not use an Avatar and play animation only on a skeleton with matching bone names.

Why faces vanish when seen from behind

Backface culling is a rendering optimization where the GPU skips faces that point away from the camera, so a single-sided plane or wall becomes invisible when you view its back. A face's front is decided by its normal, so a mesh with flipped normals shows its inside and hides its outside. To see the back, enable the engine's two-sided or render-both-faces option, or fix the normals if they point the wrong way.

Spots, streaks and skewed detail after baking

Bake artifacts in Substance Painter appear when the baking rays hit the wrong part of the high-poly model. Lower Max Frontal Distance and Max Rear Distance so rays only reach the matching surface, bake by mesh name so each low-poly part sees only its own high-poly partner, and use a cage or explode the parts if they overlap. Check for overlapping UVs and bad normals, and raise Antialiasing to remove jagged lines.

Envelope mesh that controls ray distance

A bake cage is an inflated copy of the low-poly mesh used as the outer boundary for normal/AO/curvature bake rays. For each surface point on the low-poly, the baker traces a ray from inside the cage through that point and out — the first high-poly surface it hits becomes the source for the baked data. A correct cage avoids both ray "misses" (too tight, geometry skips) and "skews" (too loose, picks up wrong details).

Pairs a low-poly with its high-poly in Toolbag

A bake group in Marmoset Toolbag is a container that holds one low-poly mesh and the high-poly meshes that should be baked onto it. Each group is baked separately, with its own settings for resolution, samples, cage and offset, and a project can have several groups. Separate groups stop one part of an asset from picking up detail from another, and they make it easy to bake a whole kit in one go.

Precomputed or calculated every frame

Baked lighting is calculated ahead of time and stored in lightmaps and probes, while realtime lighting is calculated every frame. Baked light is cheap to run and can include soft bounced light, but it cannot move or change. Realtime light reacts to moving objects and changes of day and night, but costs performance. Mixed lighting combines the two, with baked indirect light and some realtime direct light and shadows. Unity sets this per light with the Light Mode.

High-poly detail → low-poly texture

Baking is the process of transferring information from a high-resolution source (a sculpt, a procedural shader, or a lighting setup) onto a 2D texture mapped to a lower-resolution mesh. Common bakes are normal, ambient occlusion, curvature, position, thickness, and ID maps — each captures a different property of the high-poly that the low-poly cannot represent geometrically.

Simple model used as the start of a sculpt or model

A base mesh is a simple, low-poly model with clean topology that serves as the starting point of a character or creature, instead of starting from a sphere. A human base mesh has the correct proportions and edge flow for the face, hands and joints, so it can be subdivided, sculpted and later rigged without much cleanup. Artists use a base mesh to save time, keep consistent proportions across a cast, and start sculpts that already deform well.

GPU texture compression formats

BC (Block Compression) is the family of lossy GPU texture formats — BC1 through BC7 — that decode in hardware at zero runtime cost while using 4-8× less memory than uncompressed textures. BC1 (formerly DXT1) compresses to 4 bits/pixel for RGB; BC5 stores two channels at high quality (ideal for normal maps); BC7 gives near-uncompressed quality at 8 bits/pixel for hero textures. Every modern game ships almost exclusively in BC-compressed textures.

Rounded or chamfered edge

A bevel replaces a sharp 90-degree edge with a small chamfer or rounded strip of faces. Real objects rarely have perfectly sharp edges, and a bevel catches light as a thin highlight that makes a model read as solid, finished and believable. Bevels also help baking, because they give the normal map a smooth transition to work with. In Blender the shortcut for a bevel is Ctrl+B, or you can use the Bevel modifier.

The neutral pose a mesh is skinned in

The bind pose (or rest pose) is the canonical pose in which a mesh is skinned to a skeleton — usually T-pose or A-pose. Every joint transform later applied during animation is computed as a delta from this reference. Re-binding a character in a different pose is a non-trivial fix: weights, deformation, and rig controls all assume the original bind. A-pose binds usually give better shoulder deformation; T-pose binds are simpler for retargeting.

8-bit, 16-bit and 32-bit textures

Bit depth is the number of bits used to store each color channel, which sets how many different values it can hold. An 8-bit channel has 256 levels, which is enough for most color textures, while 16-bit has 65,536 levels and avoids visible banding in smooth gradients. Height maps, displacement and some normal maps benefit from 16-bit, because small steps in a smooth surface show as terraces at 8 bits. 32-bit floating-point is used for HDR data.

Dark halos on leaves, hair and fences

Dark halos around leaves, hair cards and fences happen when the color behind the transparent pixels is black, because filtering and mipmaps blend that black into the visible edge. The fix is to extend the real colors outward past the alpha edge before export, a step called dilation or edge padding, so the blended pixels are leaf-colored instead of black. Do it in your painting tool or in Photoshop before saving.

How a material combines with what is behind it

A material's Blend Mode in Unreal Engine decides how its output is combined with the pixels already drawn behind it. The common modes are Opaque, Masked, which cuts pixels fully on or off using an Opacity Mask, and Translucent, which blends smoothly by opacity. Epic's documentation also lists Additive, Modulate, Alpha Composite and Alpha Holdout. Opaque is the default and the cheapest, so choosing another mode is a trade of quality against cost.

Mesh-deformation key

A blend shape is a saved mesh deformation that can be applied to the base mesh on a slider from 0 to 100%. The most common use is facial animation: dozens of blend shapes capture mouth shapes (visemes), brow positions, eye states, with the animator dialling a combination per frame. Skinning bones handles body deformation; blend shapes handle the subtle face work that bones can't reach.

Mixing animations by a parameter such as speed

A blend space, called a blend tree in Unity, mixes several animations based on one or two parameters, so the character's movement changes smoothly. A one-dimensional blend space blends idle, walk and run by speed, and a two-dimensional one adds direction for forward, backward and strafe movement. The engine calculates the in-between pose for any parameter value, which creates many variations from a small set of clips. They are the standard way to build locomotion.

Keys do nothing or do something unexpected

Blender shortcuts act on the area under the mouse cursor, so the most common reason a key does nothing is that the cursor is over the wrong editor. Hover over the 3D viewport before pressing a key. Next check the mode, since many shortcuts differ between Object Mode and Edit Mode, and make sure no text field is active.

Slow viewport and low frame rate while working

A slow Blender viewport usually comes from too many subdivision levels, heavy modifiers, high-resolution textures or an expensive shading mode. Lower the Viewport level of the Subdivision Surface modifier and keep the Render level high, switch to Solid shading while modeling, hide heavy collections, and turn on Simplify in Render Properties to limit subdivision and texture size.

Multiply, Overlay, Color and other layer modes

Blending modes change how a layer combines with the layers below, and are a basic tool of digital painting in Photoshop and Krita. Multiply darkens by multiplying colors, and is used for shadows and for shading flat color. Overlay and Soft Light increase contrast and tint while keeping the underlying values, Screen and Color Dodge brighten for glows and highlights, and Color applies hue and saturation while keeping the values. Used with care, they speed up lighting, color adjustments and effects.

Rough mass + scale placeholder

A blockout is the rough, untextured first pass of a 3D scene or asset built from primitive shapes — boxes, cylinders, simple meshes — sized to establish scale, composition, and gameplay flow before detailed art begins. Studios block out levels for weeks of playtesting before any final mesh is built. The blockout phase is where mistakes are cheap; in textured-detail phase they're catastrophic.

Soft glow around bright pixels

Bloom is a post-processing effect that simulates how very bright light sources bleed and glow in real cameras and human vision. The renderer extracts pixels above a brightness threshold, blurs them, and adds the blur back over the scene. Used subtly, bloom adds physical realism — neon signs, sun reflections, character magic effects. Overused, it produces the infamous "2007 game" look where everything bright is wrapped in a fog of glow.

Unreal Engine visual scripting

Blueprint is Unreal Engine's visual scripting system, where logic is built by connecting nodes instead of writing code. A Blueprint class can bundle meshes, lights, collision and behavior into one reusable object, such as a door that opens or a torch that flickers, and it uses the BP_ prefix. Artists use Blueprints to set up interactive props, material changes and simple effects without a programmer.

Soft textures at a distance or on screen

Textures look blurry in Unity when the import settings or quality settings reduce the texture's resolution. Select the texture and raise Max Size, make sure compression is not too aggressive, and turn on Generate Mip Maps with an Aniso Level of 4 to 16 so textures stay sharp at oblique angles. Then check Edit > Project Settings > Quality and set the Global Mipmap Limit to full resolution.

Low-res mips that never sharpen

Textures look blurry in Unreal Engine when the engine shows a low mip level instead of the full-resolution one, usually because the texture streaming pool is full or the texture is set to stream aggressively. The quick fixes are to increase the streaming pool size, enable Never Stream on important textures, and check that the texture's LOD Bias is 0. Also confirm that the source image is large enough for the size of the object on screen.

Combine meshes via volume operations

A Boolean operation combines two meshes through volume math: union (A+B), difference (A-B), intersection (A∩B). Booleans are the fastest way to create complex hard-surface forms — drilling holes, cutting panel lines, merging mechanical parts — without manually placing every edge. The catch is that Boolean output produces dense, messy n-gon-heavy topology that almost always needs retopology before final use.

Shadows with more detail near the camera

Cascaded shadow maps are a technique for shadows from a directional light such as the sun. The view is divided into zones, called cascades, from near to far, and each gets its own shadow map, so shadows close to the camera are sharp and distant shadows use lower resolution. The number of cascades and the shadow distance trade quality against performance, and visible lines can appear where one cascade changes to the next.

Fine crevice shadows

A cavity map captures small-scale surface concavities — the tight crevices where AO doesn't reach because of its broader sampling radius. Where AO darkens a deep cavity, cavity darkens the micro-detail inside it: scratches, fabric weave, screw threads. Multiplying cavity over albedo or roughness adds a layer of contact realism that purely AO-based shading misses.

Flat-shaded stylization

Cel shading is a non-photorealistic rendering technique that makes 3D models look like 2D animation by replacing smooth lighting falloff with hard, stepped bands of colour. Combined with ink-style outlines, cel shading produces the look seen in Genshin Impact, Borderlands, Hi-Fi Rush, and Disney Infinity. Implementation in modern engines uses a custom shader (lighting via a ramp texture) plus a screen-space or inverted-hull outline pass.

One texture, multiple maps

Channel packing is the practice of storing multiple grayscale maps inside the R, G, and B channels of a single texture, reducing texture lookups in the shader and saving GPU memory. The most common scheme is ORM: Occlusion (R), Roughness (G), Metalness (B). Glossiness or height can take the alpha channel.

Pinching, collapsing or spiking at elbows, shoulders and knees

A character pinches, collapses or spikes at the joints when the topology or the skin weights cannot support the movement. Add two or three edge loops around elbows, knees and shoulders so the mesh has geometry to bend, clean up the weights so each vertex follows the right bones and sums to one, and add corrective shapes or helper joints for extreme poses. Always test with extreme poses, not just the bind pose.

Proportions and symmetry problems in a face sculpt

A face looks off when its proportions drift from the basic guidelines or it is perfectly mirrored. Check that the eyes sit about halfway down the head, with roughly one eye width between them, that the bottom of the nose is about halfway between the eyes and the chin, and that the mouth sits in the lower third. Then check from the front, side and three-quarter views, and break symmetry slightly, since real faces are never exact mirrors.

The stages a game character goes through

The character pipeline is the sequence of stages that turns a design into a playable game character. It usually runs from concept art and a model sheet, to a base mesh and high-poly sculpt, then retopology, UVs, baking, texturing, rigging and skinning, and finally export and setup in the engine with materials, LODs and animation. Each stage hands its result to the next, so problems that are not fixed early, such as bad topology or UVs, multiply later in the process.

Skin that reads as rubber or wax

Skin looks plastic when the roughness is uniform, the subsurface scattering is missing and the color has no variation. Vary roughness across the face, with oilier forehead and nose and drier cheeks, use the engine's skin or subsurface shading so light scatters softly into the surface, add fine detail such as pores through a normal or displacement map, and add subtle color variation, such as more redness around the nose, cheeks and ears.

Animation does not play on the character

A character stays in a T-pose in Unity when the Animator has no controller or clip to play, or when the animation does not match the character's rig. Check that the Animator component has an Animator Controller with a state that contains a clip, that the clip's rig type matches the model (Humanoid with a valid Avatar, or Generic with the same bone names), and that the clip is actually the entry state.

Edge flow that supports deformation

Character topology is the layout of edges and polygons on a character, designed to support animation and shading. Good character topology uses mostly quads, follows the muscles and the forms of the body, and places concentric edge loops around the eyes and mouth, and several loops around joints such as the shoulders, elbows and knees, so they can bend without collapsing. Density is highest where the surface deforms or has detail, and lower on flat areas.

Model shown in plain matte gray

A clay render shows a 3D model in a single plain, matte gray material, with no textures or colors, so the form can be judged on its own. Light and shadow show the shapes, proportions and silhouette, which makes it the standard way to review a sculpt, a blockout or an environment before texturing. Many portfolios show the clay render next to the textured result to prove the quality of the modeling.

How fabric wrinkles and drapes

Cloth folds are the wrinkles and creases that fabric forms when it hangs, stretches, compresses or is held by the body. Common types are pipe folds, which hang from a point like tubes, zigzag folds from compression at a bend, spiral folds around a limb, half-lock folds at a bend, drop folds from a hanging point, and diaper folds between two supports. Gravity and tension decide where they appear, and the thickness and stiffness of the material decide their size and softness.

Physical simulation of fabric

Cloth simulation calculates how fabric moves and drapes under gravity, wind and collisions. Offline tools such as Marvelous Designer, designed for garments with patterns and seams, and the cloth simulation in Blender and Houdini produce realistic drapes for sculpts, film and cinematics. In games, real-time cloth, such as Chaos Cloth in Unreal Engine, simulates capes, skirts and banners on characters at a low cost, by simplifying the mesh and limiting how far the cloth can move.

Group objects and control their visibility

A collection in Blender is a group of objects, shown in the Outliner, that you can hide, exclude from the view layer, disable in renders or instance elsewhere. Collections replace the old groups and layers and are the way to organize a scene: environment, props, lights and cameras each get their own. A Collection Instance places a linked copy of a whole collection many times, and changing the original updates every copy.

Simplified geometry used for physics

A collision mesh is a simplified shape that the physics engine uses in place of a model's visible geometry. In Unreal Engine, a Static Mesh can use simple collision (boxes, spheres, capsules or convex hulls) or complex collision based on its render triangles. Simple collision is far cheaper and is the normal choice. You can generate it in the editor or author it in your 3D package and import it together with the mesh.

Visible steps in gradients and skies

Color banding is the visible stepping in smooth gradients, such as skies, fog and vignettes, caused by too few color levels in 8-bit images. Add dithering or film grain so the steps become noise, use 16-bit sources for smooth textures such as height maps and gradients, and keep post-processing in higher precision. In Unity URP, switch on Dithering in the camera settings, and in Unreal use a little film grain or quantization.

Final color and contrast look of the image

Color grading is the final adjustment of color, contrast and saturation across the whole image to give it a particular look, such as warm and golden, cold and desaturated, or high contrast and punchy. In games it is done in post-processing with controls for lift, gamma and gain, saturation and white balance, or with a lookup table, or LUT, a small image that maps input colors to graded colors and can be made in Photoshop or similar tools.

Linear light, color spaces and view transforms

Color management is the system that keeps colors consistent from creation to the screen. Renders are calculated in linear light, textures are converted from sRGB, and a view transform maps the high range of a render to a display. ACES is a standard color pipeline from the film industry with a wide gamut and a built-in look. Blender offers Filmic and AgX view transforms, with AgX the default since version 4.0, and engines apply their own tonemappers.

Color plan for a story or a game

A color script is a sequence of small, simple images, one per scene or moment, that plans how color and light change across a film or a game. Used first in animation, it shows the mood and emotional arc through palette: for example warm and safe at the start, cold and tense in the middle, bright and open at the end. In games, a color script helps different levels or biomes keep a clear identity and stay consistent as a whole.

The ID-based mask picks nothing

The Color Selection mask in Substance Painter needs a baked Color ID map, which stores a color for each part of the model. Bake the Color ID mesh map in Texture Set Settings, using vertex colors, polygroups or material IDs as the source, and then add the Color Selection effect to a mask and pick the colors. If it still selects nothing, the colors were not assigned in the original mesh.

Warm and cool light measured in Kelvin

Color temperature describes the color of a light source in Kelvin, a scale where low numbers are warm and orange, and high numbers are cool and blue. A candle is about 1900 K, a tungsten bulb about 2700 to 3200 K, midday daylight about 5600 to 6500 K and an overcast sky or shade higher. Engines let you set lights by temperature, and post-processing white balance shifts the whole image to make a scene feel warmer or cooler.

Combining render layers into the final image

Compositing is combining several images, such as render passes, backgrounds and effects, into one final picture, and adjusting them with color correction, blur, glow and other operations. In 3D work it is the last stage after rendering, where artists balance the passes, add depth of field and atmosphere, and fix problems without rerendering. Tools include Nuke, Blender's Compositor, After Effects and Photoshop for stills.

Arranging shapes to guide the eye

Composition is how the elements of an image are arranged to guide the eye and communicate an idea. Common tools are the rule of thirds, which places key elements on lines that divide the frame into thirds, leading lines that point toward the focal point, framing, overlap, and contrast of size, value and color. The goal is a clear focal point, a balanced image and a path for the eye, rather than a fixed formula. These rules are guides that can be broken on purpose.

The eye wanders or the image feels unbalanced

A composition feels off when the eye does not know where to look or the image is lopsided. Decide one focal point and give it the highest contrast, the strongest detail and the most saturated color, then lead the eye to it with lines, shapes and edges. Balance the image by weighing large shapes against small, strong ones, and check the thumbnail at a tiny size, where a weak composition becomes obvious right away.

Visual design before 3D production

Concept art is the 2D visual exploration that defines how characters, environments, and props should look before the 3D production team starts modeling. Strong concept art saves weeks of 3D iteration by locking proportions, silhouette, materials, and mood up front. In the AAA pipeline, concept artists typically produce 5-10 iterations per asset before approval, and the final concept becomes the brief for the 3D modeller.

Maya keeps a record of every operation

Construction history in Maya is the record of the operations applied to an object, such as extrudes, bevels and polygon reductions, stored as nodes in a chain. It lets you go back and change an earlier step, but it adds data to the scene, can slow Maya, and can cause strange results when an object is cleaned or exported. Delete History, in Edit > Delete by Type, removes the nodes and keeps the current shape.

Fine shadows where objects touch surfaces

Contact shadows are short, sharp shadows that appear where objects touch or come near a surface, such as under a rock, around a brick edge or in a crack. They are computed in screen space, by marching a short ray through the depth buffer from each pixel toward the light, so they capture small details that a normal shadow map misses. They only work for what the camera sees, and only over a short distance.

Unreal Engine node-based rigging and animation

Control Rig is Unreal Engine's node-based system for rigging and animating characters directly inside the engine. It lets technical artists build animator controls, IK and FK setups and procedural behavior with a graph, and animators can pose and key characters in Sequencer without leaving Unreal. It can also run at runtime to drive procedural motion such as foot placement, look-at and aim, and it works with Unreal's retargeting and animation tools.

Scatter objects across points in Houdini

Copy to Points is a Houdini node that places a copy of an object on each point of another piece of geometry. It is the basic scattering tool: scatter points on a surface, set attributes such as scale, orientation and a random value on them, and copy trees, rocks, grass or props onto the points. Because the points carry attributes, each copy can differ in size, rotation or variant, which gives natural variation and quick results.

Blend shapes that fix joint deformation

Corrective shapes are blend shapes that fix the deformation of a skinned mesh in extreme poses. When weights alone cannot give a good shape, such as a collapsed elbow, a flat shoulder or a muscle that should bulge, a corrective shape is sculpted for that pose and activated automatically as the joint rotates. They are driven by joint angles through set driven keys, drivers or pose-space systems, and are common in high-quality character rigs and film.

Which processor limits the frame rate

A game is CPU bound when the processor takes the longest to prepare each frame, and GPU bound when the graphics card takes the longest to draw it. The slower one decides the frame rate. A CPU bound game is held back by gameplay code, animation, physics and the number of draw calls, and a GPU bound game by pixel shading, resolution, overdraw, shadows and lighting. The first step in any optimization is to find out which one limits you.

360-degree environment captured as six faces

A cubemap stores a full 360-degree view of an environment as six square faces of a cube, sampled by direction rather than UV. Cubemaps are the data behind reflection probes, sky lighting, and image-based lighting (IBL) in PBR. HDRIs are typically converted to cubemaps at import. When SSR cannot find a reflection on-screen, the engine falls back to the nearest cubemap.

Edge highlight + cavity shadow data

A curvature map is a baked texture encoding how convex or concave each pixel of a surface is. Convex edges (peaks) are stored as bright values, concave creases (valleys) as dark. Substance Painter's smart materials use this channel heavily to drive edge wear, dust accumulation in crevices, and paint chipping along ridges — effects that look procedurally correct because they follow the model's actual geometry.

F-curve / graph editor for animation timing

The curve editor is the view in any DCC where animators edit F-curves — the interpolation between keyframes — for individual properties over time. It is where the difference between "moves" and "feels alive" actually happens: easing, overshoot, anticipation, and follow-through are all curve work. Maya’s Graph Editor and Blender’s F-Curve view are the standards; understanding tangent handles is non-negotiable for any serious animator.

Projected texture detail on existing surfaces

A decal is a texture (with alpha) projected onto existing geometry to add detail without retexturing the underlying surface — bullet holes, blood splatters, graffiti, scorch marks, signage. Decals decouple wear and storytelling detail from base materials, letting one neutral wall texture host hundreds of unique surface stories at runtime. Used everywhere in modern game environments to break up modular kit repetition.

Reduces polygon count automatically

The Decimate modifier lowers the polygon count of a mesh automatically. Collapse, the main mode, merges vertices to reach a Ratio, such as 0.5 for half the faces. Un-Subdivide reverses a subdivision, and Planar merges flat areas based on an angle. It is quick and works on any mesh, but it ignores edge flow, so the result is triangulated, uneven and unsuitable for animation or clean game assets.

Reduces ZBrush polygon counts while keeping detail

Decimation Master is a ZBrush plugin that reduces the polygon count of a sculpt while keeping its visual detail. It first pre-processes the mesh and then decimates it to a percentage, producing a lighter version that looks nearly the same. It is used to make a dense sculpt small enough to export for baking, to share or to use as a high-poly in another program, and it has an option to keep UVs.

Shade once per pixel, after geometry

Deferred rendering splits the frame into two phases: first, geometry attributes (albedo, normal, roughness, depth) are written to a G-Buffer; then lighting is computed once per screen pixel, regardless of how many objects overlap. This makes the cost of dynamic lights nearly independent of geometry complexity, which is why Unreal’s default path and Unity’s HDRP are deferred. The cost is higher memory bandwidth and awkward MSAA support.

A short video of your best work

A demo reel is a short video, usually 30 to 90 seconds, that shows your best work in motion. It is standard for animators, VFX artists and technical artists, and also useful for environment artists with fly-throughs and for character artists with turntables. Studios watch the first few seconds, so the strongest work goes first, and the reel should be tightly edited, with clear labels of what you did and which tools you used, and a breakdown at the end of the most important pieces.

Cleaning noise from low-sample renders

Denoising removes the grain from images made with few samples, such as path-traced renders and ray traced games. A denoiser studies the noisy image, often with extra information such as normals, albedo and depth, and reconstructs a smooth result. Common ones are Intel Open Image Denoise and NVIDIA OptiX, with AI-based versions in game technologies. It makes a render with far fewer samples usable, saving a lot of time.

Per-pixel distance used to sort what is visible

The depth buffer, or Z-buffer, is an image that stores the distance from the camera to the nearest surface at every pixel. When a new surface is drawn, the GPU compares its depth to the stored value and keeps only the closer one, which is how objects hide each other without sorting. The depth buffer is also used by effects such as depth of field, fog, ambient occlusion and soft particles. Its precision is limited, which causes z-fighting when two surfaces are very close.

Fades a surface where it meets other geometry

Depth fade, called soft particles in Unity, is a technique that fades a translucent surface out as it approaches the geometry behind it. The shader compares the depth of the particle with the depth buffer, and reduces opacity when the difference is small. It removes the hard cut line where a sprite meets the floor or a wall, and is also used for water edges, fog volumes and light shafts. In Unreal Engine it is the DepthFade material node.

Cinematic camera focus blur

Depth of field (DoF) is the post-process that simulates a camera lens focusing on one distance and blurring everything closer or farther. Cinematic DoF with shaped bokeh sells "this is a movie shot," while a subtle DoF nudge separates a character from the background. It is a render-budget item — high-quality DoF samples a lot of pixels — so games usually only enable strong DoF in cinematics or vehicle scopes.

The shared rules that make a world feel consistent

A design language is the set of shared visual rules that makes the characters, props, architecture and effects of a game look like they belong to one world. It covers shapes, proportions, materials, colors, level of detail and ornament, and can differ between factions, cultures or biomes. A clear design language makes a world recognizable and its elements readable, and lets many artists work on the same game and produce a consistent result.

Fix a painting that lacks depth and punch

A digital painting looks flat when its values, the lights and darks, are too close together or spread evenly across the image. Convert the picture to grayscale to check it, then group the values into three to five big masses, with the lightest lights and darkest darks reserved for the focal point. Add atmospheric perspective, with distant objects lighter and lower in contrast, and keep the contrast in the background lower than in the subject.

Which way the green channel points

DirectX and OpenGL normal maps are the two conventions for the green (Y) channel of a tangent-space normal map. OpenGL maps (Y+) treat green as pointing up, while DirectX maps (Y-) treat it as pointing down, so the green channel is inverted between them. Unreal Engine expects DirectX-style normals; Blender, Maya and Unity use OpenGL-style. A map in the wrong convention still loads, but its bumps look inverted under light.

Actual geometry from a texture

A displacement map actually moves vertices along their normal at render time, generating real geometry where a normal map only fakes lighting. Used heavily in offline rendering (film) and in real-time when GPU tessellation is available — terrain detail, snow accumulation, parallax-correct stone. Unlike normal maps, displacement produces correct silhouettes from any viewing angle but is far more expensive to render.

Surface that burns or fades away with a glowing edge

A dissolve effect makes an object appear to burn, fade or disintegrate away along a noisy edge, often with a glowing rim. The shader compares a noise texture with a threshold value: pixels where the noise is below the threshold become transparent or are clipped away, and pixels near the threshold get an emissive color that forms the glowing edge. Animating the threshold from 0 to 1 plays the dissolve, and the effect is used for spawns, deaths, teleports and fades.

Hide objects beyond a set distance

Distance culling stops the engine from drawing objects beyond a set distance from the camera, because they are too small to matter. Small props, grass, debris and details can disappear much closer than large buildings. Unreal Engine provides a maximum draw distance on meshes and Cull Distance Volumes that set it by object size, and Unity has per-layer culling distances on the camera. It saves draw calls and triangles, at the cost of visible pop-in if the distance is too short.

Bending the image behind a surface

Distortion effects bend or warp the image behind a surface, to create heat haze, shockwaves, energy fields, glass and water refraction. The shader samples the scene behind the object with its UV coordinates offset by a normal map or a noise texture, so the background seems pushed around. In Unreal Engine this is done through the refraction input of a translucent material, and in Unity by sampling the opaque texture, which must be enabled in the pipeline asset.

AI / spatial upscaling for higher framerates

DLSS (NVIDIA), FSR (AMD), and XeSS (Intel) are upscalers that render the frame internally at a lower resolution and reconstruct a higher-resolution image. DLSS uses an AI model and motion vectors; FSR 1 is spatial-only, FSR 2/3 is temporal like DLSS. For art teams, this means the engine resolves much finer detail than the raw render budget would suggest — but it also means LODs, normal maps, and shader detail need to hold up under aggressive temporal reconstruction.

GPU rendering command

A draw call is a single GPU command that renders one mesh with one material. Each draw call has CPU overhead (preparing the data) that adds up — most games target under 1000 draw calls per frame for 60 FPS, under 2000 for 30 FPS. Optimization tactics include combining meshes that share materials, atlasing textures to share materials across props, and using instancing for repeated geometry like foliage.

ZBrush dynamic re-meshing

DynaMesh is a ZBrush feature that re-meshes a sculpt on demand, producing a uniform polygon distribution that supports aggressive deformation. Unlike normal subdivision, DynaMesh has no UV or topology constraints — push, pull, and merge geometry freely, then hit Ctrl-drag to rebuild a clean evenly-spaced mesh ready for further sculpting.

Fine detail disappears after remeshing

DynaMesh loses detail when its Resolution is too low for the sculpt, because the new, evenly spaced polygons cannot hold the old detail. Raise the Resolution slider in the DynaMesh settings and remesh again, and turn on Project so ZBrush projects the previous shape onto the new mesh. Use DynaMesh only in the early block-out stage and move to subdivision levels for fine detail.

Smoothed preview without extra polygons

Dynamic Subdivision is a ZBrush display mode that previews a smoothed, subdivided version of a low-poly mesh without actually adding polygons to it. It is switched on in the Geometry palette, with the shortcut Shift+D, and the result updates live as you edit the low-poly. It is mainly used with ZModeler and with creases, where you shape a low-poly model and see the smooth, high-resolution result at the same time.

Direction of polygon edges across a surface

Edge flow describes the directional pattern of edges across a mesh surface — how loops curve, where they converge, and how they relate to the form's underlying anatomy or function. Good edge flow follows the natural lines of force: muscle bundles on a character, panel breaks on a vehicle, structural framing on architecture. It is the topology equivalent of composition in 2D art — invisible when correct, glaringly wrong when broken.

Continuous ring of edges

An edge loop is a continuous chain of edges around a mesh, ideally returning to itself in a closed loop. Edge loops define where deformation will fold — placing a loop around an elbow joint means the elbow bends along that loop. Good character topology has loops following anatomical features: muscles, mouth, eye sockets, finger joints.

Blender's two basic ways of working

Object Mode and Edit Mode are the two basic Blender modes. In Object Mode you work on whole objects: move, rotate, scale, add modifiers, set materials and apply transforms. In Edit Mode you work on the mesh itself, selecting and moving vertices, edges and faces. Tab switches between them. Other modes such as Sculpt, Texture Paint, Weight Paint and Pose Mode are chosen from the mode menu.

Blender's real-time and path-traced renderers

Eevee and Cycles are Blender's two main render engines. Eevee is a real-time engine that rasterizes the scene like a game engine, so it is fast and good for previews, stylized looks, animation and quick turnarounds. Cycles is a path tracer that simulates light physically, so it gives more accurate reflections, refraction and global illumination but takes longer and needs more samples to avoid noise. Both use the same materials.

Texture for glowing surfaces

An emissive map is a texture that marks which parts of a surface glow and in what color, such as screens, lava, runes, windows and neon lights. It plugs into the Emissive Color input in Unreal Engine (Emission in Unity and Blender) and is visible without any light. Values brighter than white make a surface bloom, and in engines with dynamic global illumination a bright emissive surface can also cast light onto nearby geometry.

Bright material does not bloom

An emissive material does not glow when its brightness is not high enough or bloom is switched off. Increase the emissive intensity above 1, for example by multiplying the color in Unreal Engine or using an HDR color in Unity, and make sure Bloom is enabled in post-processing, in a Post Process Volume or a Volume with a threshold below the emissive brightness. Check the exposure too, since a bright scene hides the glow.

Copy-pasted props and visible tiling

An environment looks repetitive when the same assets, textures and placement patterns are repeated too visibly. Break it up by varying the scale, rotation and mirroring of props within sensible limits, using several variants of the most common pieces, adding vertex painting or macro variation to the materials, and placing decals, moss, dirt and debris that differ from instance to instance. Hand-place the areas the player looks at most, and use tools for the background.

No sense of depth or scale

An environment scene looks flat when its elements sit at one level of detail, value and color, without layers of depth. Divide the view into foreground, midground and background, give the foreground the darkest values and the sharpest detail, make distant elements lighter, bluer and lower in contrast with atmospheric perspective and fog, and use light and shadow to model shapes. Overlapping shapes and a strong focal point also add depth.

Telling the story of a place through its objects

Environment storytelling is the practice of conveying story and information through the objects, layout and state of a space instead of through text or dialogue. A campfire with two cups, a barricaded door, a trail of blood or a child's drawing on a wall tell the player who was here and what happened. It adds depth and mood to a world, rewards exploration and guides players without interrupting the gameplay.

The small set of brushes most sculptors use

Most ZBrush work uses a small set of brushes. Move changes large shapes, Clay Buildup and ClayTubes add and build up volume, Standard and Inflate add or push surfaces, DamStandard cuts creases and lines, hPolish and TrimDynamic flatten and clean hard surfaces, Pinch sharpens edges, and Smooth softens. Learning these few brushes well, with the right Draw Size and Intensity, is more useful than collecting dozens of custom ones.

Save bitmaps or an SBSAR from a graph

To export textures from Substance Designer, right-click the graph in the Explorer and choose Export Outputs as Bitmaps, then pick a folder, file format and size. Each output node, such as base color, normal and roughness, becomes a file. To keep the material parametric, publish an SBSAR instead with Publish .sbsar file, which can be used in Substance Painter and in engines that have a Substance plugin.

Overall brightness of the camera image

Exposure is the overall brightness of a rendered image, set by how much light the virtual camera lets in. In photography it combines aperture, shutter speed and ISO, summed up as an exposure value or EV. Game engines use automatic exposure, also called eye adaptation, which brightens dark scenes and darkens bright ones over time, or a fixed manual exposure. The tonemapper then maps the result to the screen.

Pull new geometry out of a selection

Extrude pulls new geometry out of selected vertices, edges or faces, creating connected faces that follow the selection. In Blender press E in Edit Mode and move the mouse, and use the axis keys to constrain the direction. Faces can be extruded along their normals with Alt+E, and Inset, on the I key, creates a smaller face inside a selected one. These two tools, with loop cuts, build most hard-surface and architectural shapes.

Smooth mesh looks flat-shaded in the engine

A smooth model looks faceted or blocky after import when the engine did not receive its smoothing information. Export smoothing from your 3D tool (in Blender's FBX exporter set Smoothing to Face or Normals Only), and in Unreal's import options choose Import Normals so the engine keeps your normals instead of computing its own. If a mesh is smooth in the 3D tool but flat in the engine, this is almost always the cause.

Blend shapes and joints for facial expressions

Facial rigging is building the controls that let a character's face move and show expressions. The usual methods are blend shapes, which store each expression as a shape of the whole face, and joints, which move the lips, brows and eyes like a skeleton, and many rigs combine both. FACS, the Facial Action Coding System, is a standard catalog of facial muscle movements that artists use to plan shapes, and Apple's ARKit uses a set of about 52 blend shapes that many pipelines follow for face capture.

The standard 3D exchange format for games

FBX is Autodesk's file format for exchanging 3D data between tools, and the standard way to move meshes, skeletons, skin weights and animations from Blender, Maya or 3ds Max into game engines such as Unreal and Unity. A single FBX can contain geometry, UVs, normals, smoothing, material slots, bones, animations and cameras, but it does not carry full materials or textures reliably, so those are set up in the engine.

Models arrive 100 times too big or too small

A model arrives 100 times too big or too small in Unity because the file's units differ from Unity's, where one unit is one meter. Fix it in the model's import settings by checking Convert Units or changing the Scale Factor, and fix it at the source by exporting with consistent units. From Blender, set Apply Scalings to FBX Units Scale in the FBX exporter and keep the scene unit scale at 1.

How artists improve with other people’s eyes

Feedback and critique are how artists find their weaknesses and improve faster than they could alone. Useful feedback is specific, such as pointing out that the silhouette is weak, the values are flat or the texel density is uneven, and often comes with an example or a paintover. Artists receive it from mentors, art directors, peers and communities, and in studios it is part of every review. Learning to ask for it and to apply it is one of the most important professional skills.

Layer that fills a texture set with channel values

A fill layer in Substance Painter is a layer that fills the whole texture set, or the part not hidden by its mask, with values or textures for each channel, such as base color, roughness, metallic and normal. Fill layers are the base of material-based texturing, where each material, like paint, bare metal or dirt, is one fill layer controlled by a mask. A fill layer can use a projection mode, tiling and procedural effects, and stack with others.

How many pixels the GPU can shade per second

Fill rate is the number of pixels a GPU can shade and write per second, and a game is fill-rate bound when the total pixel work is the limit. Every pixel costs more with a higher resolution, expensive shaders, many lights and layers of transparency drawn on top of each other, which is overdraw. Fill rate is especially limited on mobile and standalone VR devices, where large transparent particles and full-screen effects can quickly use up the budget.

Animated texture made of a grid of frames

A flipbook is a texture made of a grid of animation frames, played one after another on a particle or a surface, like the pages of a flip book. It is the main way to give realistic, hand-crafted motion to smoke, fire, explosions and magic without simulating them in real time. Flipbooks are rendered from a simulation in Houdini or similar tools, or painted by hand, and packed into a sheet such as 8 by 8 frames. Unreal Engine calls it SubUV and Unity calls it a Texture Sheet Animation.

Smoke and fire jump between frames

A flipbook looks choppy when the particle jumps from one frame of the sprite sheet to the next. Turn on frame blending, which fades between neighbouring frames, so the animation looks smooth even at a low frame count. In Unreal Engine use the SubUV animation with blending, and in Unity use Flip-Book Blending in the particle shader along with the Texture Sheet Animation module. A higher frame count and a lower playback speed also help.

Faces pointing inside out

Flipped normals are faces whose normals point into the model instead of out of it, which makes them render dark, shade backwards or vanish because of backface culling. The fix is to recalculate or flip the normals so they point outward. In Blender, turn on the Face Orientation overlay (blue is outside, red is inside), select the red faces and use Mesh > Normals > Recalculate Outside.

Designer node that identifies each shape

Flood Fill is a Substance Designer node that detects each separate shape in a black and white mask and gives each one its own information. Companion nodes read its output to create a random gray value for each shape, a gradient across each shape, the bounding box or the center of each. This lets you vary height, color or roughness per stone, tile or leaf, and is the key to realistic variation in procedural materials.

Texture that tells a surface which way to flow

A flow map is a texture that stores a direction in its red and green channels, used to move another texture along that direction over time. It lets water run around rocks, lava creep downhill, smoke swirl and cloth-like effects follow a shape, with the direction painted or generated by a tool instead of being one constant scroll. The shader blends two offset samples in a repeating cycle to avoid stretching, and gives the flowing motion without simulation.

How wide the camera sees

Focal length and field of view describe how wide a camera sees. A short focal length, such as 20 mm, gives a wide field of view with strong perspective distortion, a long one such as 85 mm gives a narrow field of view and a flatter look. Games usually specify the field of view as an angle, often between 60 and 100 degrees, and renders use focal length in millimeters, with 50 mm a neutral choice close to the eye.

Alpha-textured planes that form leaves and plants

Foliage cards are flat polygons with an alpha-textured image of leaves, branches or whole plants, used to build vegetation cheaply. A tree is made of a trunk mesh with clusters of leaf cards arranged in volume, grass is made of cards with blades painted on them, and distant trees are reduced to billboards. The cards use a masked material, and two-sided shading so both faces show, and they are placed and rotated to hide their flat shape.

Plants that read as flat cards or have wrong lighting

Foliage looks fake when the leaf cards are flat and uniform, the lighting is wrong for thin surfaces or the movement is mechanical. Use two-sided foliage shading so light passes through leaves, shape and layer the cards in volume with varied angles and sizes, use softened or spherical normals on leaf clusters so lighting looks like a soft mass, add color variation and a little translucency, and drive wind with World Position Offset and vertex color.

Planting feet on uneven ground

Foot IK, or foot placement, adjusts a character's feet at runtime so they sit correctly on uneven ground, slopes and stairs, instead of floating or sinking through the surface. The engine casts rays down from each foot to find the ground, then uses inverse kinematics to bend the legs and lower the hips so that both feet touch. It also helps lock planted feet in place to prevent sliding. It is a standard feature of third-person character controllers in Unreal Engine, Unity and other engines.

Feet glide over the ground while walking

Foot sliding happens when the speed a character moves through the world does not match the speed of the feet in the animation, so the planted foot drifts over the ground. Match the character's movement speed to the speed the animation was made for, or scale the playback rate to fit, blend between walk and run cycles in a blend space, and use root motion or stride warping so the animation drives or follows the movement. Foot IK can lock planted feet in place.

The character does not read or stand out

A forgettable character usually has a weak silhouette and no clear shape language. Fill the character with solid black and check that it is still recognizable and different from other characters in the game. Then choose a dominant shape, such as circles for friendly, squares for sturdy or triangles for dangerous, exaggerate the proportions, and add one or two distinctive features, instead of many small details that disappear at game size.

Shade each fragment per light, in one pass

Forward rendering shades each visible fragment against every active light in a single pass. It is simple, MSAA-friendly, and cheap when light counts are low — which is why it is the default in URP and Unreal’s forward mode. The downside is cost scaling: ten dynamic lights touching one object means ten shading evaluations per pixel, so heavy multi-light scenes prefer deferred rendering instead.

FPS in milliseconds

Frame rate is how many images a game draws each second, in frames per second, and frame time is the time one image takes in milliseconds. They are linked: frame time equals 1000 divided by fps, so 30 fps is 33.3 ms, 60 fps is 16.6 ms, 90 fps is 11.1 ms and 120 fps is 8.3 ms. Performance work uses frame time, because the savings add up in milliseconds, and a frame budget is the time each system, such as rendering and gameplay, is allowed to take.

Working for studios and clients on a project basis

Freelancing in game art means working for studios and clients on a project or contract basis, instead of as a full-time employee. Freelancers make assets, concepts and effects for indie teams, outsourcing studios and marketplaces, and manage their own time, clients and business. It gives flexibility and variety, but requires finding work, communicating clearly, estimating time and handling contracts and payments. A strong portfolio with a clear specialization and a track record of delivering on time is what brings clients.

Edge-on reflection increase

Fresnel describes how a surface's reflectivity increases as the viewing angle approaches grazing — looking at water from above shows mostly the bottom, but at a glancing angle it becomes a near-mirror. PBR shaders compute Fresnel automatically per pixel using the surface normal and view direction. Artists use Fresnel masks in shader graphs to drive rim lighting, hologram effects, soft falloffs on transparent materials, and stylised wind on foliage.

Skip what the camera can’t see

Frustum culling discards objects whose bounding volumes lie entirely outside the camera frustum before they reach the GPU. It is the cheapest, most automatic optimization in any engine — but it is only as good as the bounding volumes of your assets. Hero assets with tight bounds cull well; assets with stretched dummy bones, rigid-bind animations, or oversized particle emitters break culling and stay drawn off-screen.

Designer node that spawns patterns iteratively

The FX-Map is a Substance Designer node that builds images by spawning patterns step by step, using a small graph made of Quadrant, Iterate and Switch nodes. Quadrant divides the image into smaller areas, Iterate repeats a pattern a set number of times, and Switch picks between options. It powers many of the library's pattern generators and can create more complex layouts than the Tile Sampler, such as cracked ground, brick patterns and organic distributions, with control over every step.

Geometry data cached for deferred lighting

The G-Buffer (geometry buffer) is the set of full-screen render targets a deferred renderer writes during its geometry pass — typically world-space normals, albedo, roughness, metalness, and depth. Lighting and post-processing then sample these textures to compute the final image. Understanding the G-Buffer matters when debugging shading bugs, custom decals, or any effect that reads scene attributes mid-frame.

The collection of work that gets you hired

A game art portfolio is the collection of your best work that studios look at when they decide whether to hire you. It should show three to five finished, high-quality pieces focused on the role you want, presented with strong hero images, close-ups, and breakdowns of the process. Studios check quickly, often in a minute or two, so the best work should come first, and the style and quality should match the games the studio makes. ArtStation and a personal website are the usual homes.

The main jobs in a game art team

Game art teams are made up of specialists. Concept artists define the look and design, environment artists build the worlds and levels, character artists model and texture characters and creatures, prop and hard-surface artists create weapons, vehicles and objects, technical artists build shaders, tools and pipelines, VFX artists create effects, animators bring things to life, and lighting artists set the mood of scenes. Smaller studios may hire generalists who cover several roles, and large ones have many people in each role.

A short event to make a game as a team

A game jam is an event where individuals and small teams make a complete game in a short time, often a weekend, around a theme given at the start. Jams are held online and in person, with well-known events such as Global Game Jam, and games are shared on sites such as itch.io. For artists they are a way to practice working fast, collaborate with programmers and designers, and finish something playable, which shows studios that you can deliver and work in a team.

How to tell what is limiting the frame rate

To find out why a game runs slowly, lower the render resolution and watch the frame rate: if it rises a lot, the game is GPU bound, and if it barely changes, it is CPU bound. A GPU bound game needs cheaper shading, fewer pixels, less overdraw or lighter lighting. A CPU bound game needs fewer draw calls, simpler scripts, fewer active objects and less animation. Then confirm with a profiler before changing anything.

Asset prepared to run in a real-time engine

A game-ready asset is a 3D model prepared to run in a real-time engine: clean topology within a polygon budget, non-overlapping UVs at the right texel density, PBR textures, correct scale, pivot and naming, and usually LODs and collision. It is the finished version of a model that started as a high-poly sculpt or a scan. Game-ready also means it fits the project's style and technical limits, not just that it is low-poly.

Scenes made of splats instead of polygons

3D Gaussian Splatting is a way of representing and rendering a captured scene as millions of small, soft, colored 3D blobs called Gaussians instead of polygons. It is created from photos or video, like photogrammetry, and renders in real time with realistic soft detail such as reflections and fine foliage. Unlike a mesh it has no clean surface, UVs or material, so it cannot be used as a normal game asset without conversion.

Procedural mask effect driven by mesh maps

A generator in Substance Painter is a procedural effect that creates a mask from the baked mesh maps of a model. Common generators include Dirt, which collects in crevices using ambient occlusion, Metal Edge Wear, which reveals bare metal on edges using curvature, and Mask Editor, which combines several mesh maps. You add a generator to a layer's mask, adjust its settings, and the result adapts to the shape of the model.

Blender's node-based procedural modeling system

Geometry Nodes is Blender's node-based system for procedural modeling. You connect nodes in a graph that creates, changes and instances geometry, and the result updates whenever you change a parameter. It is used as a modifier, so it can scatter rocks and grass, build procedural buildings, fences and cables, and create variations from one setup. Because it is non-destructive, artists can change proportions, counts or seeds long after the first build.

Light bouncing between surfaces

Global illumination (GI) is the simulation of light that bounces from surface to surface, so a red wall tints the floor beside it and a sunlit room lights its dark corners. It is what makes a scene look natural instead of flat, because direct lights alone leave shadows pitch black. Games get it from baked lightmaps, light probes or real-time systems such as Unreal Engine 5's Lumen.

Open standard for 3D delivery

glTF is an open 3D file format from the Khronos Group, often called the JPEG of 3D, designed for fast delivery and loading on the web and in apps. It stores meshes, PBR metal/roughness materials, textures, skeletons and animation, either as a .gltf file with separate resources or as a single binary .glb. It is supported by Blender, Sketchfab, Godot, web viewers and many AR tools.

One-click bridge between ZBrush and other programs

GoZ is the one-click bridge that sends a model between ZBrush and other programs such as Maya, 3ds Max, Blender, Cinema 4D and Photoshop. You click GoZ in ZBrush, the model opens in the other program, and when you send it back, ZBrush updates the same mesh, keeping its subdivision levels and polypaint where possible. It avoids repeated exports and imports, and keeps your project connected while you move between tools.

One mesh, many instances, one draw call

GPU instancing renders many copies of the same mesh in a single draw call, with each instance having its own transform (and optionally per-instance colours, scales etc). Without instancing, 1000 trees = 1000 draw calls; with it, 1000 trees = 1 draw call. Foliage, debris, modular kit pieces, and crowd characters all rely on instancing to be performant at scale.

Where particle simulation runs

Particles can be simulated on the CPU or on the GPU. CPU simulation is flexible, supports events and interaction with game logic and collision, and suits small and medium effects. GPU simulation runs on the graphics card and can handle hundreds of thousands or millions of particles cheaply, but it is more limited in how it talks to the game and needs hardware support. Niagara offers both simulation targets, and Unity's VFX Graph is GPU-based, while the older Particle System runs on the CPU.

Turns grayscale values into color

A Gradient Map is a Substance Designer node that converts a grayscale image into color using a gradient: black maps to the first color in the gradient, white to the last, and the grays in between to the colors along it. It is the standard way to turn height or noise into a base color for rock, soil, wood, leaves and many other materials, with a few colors in the gradient giving a controlled, art-directed result.

Blender's 2D drawing and animation in 3D space

Grease Pencil is Blender's toolset for drawing and animating 2D strokes inside a 3D scene. Drawings are stored as strokes on layers and frames, with their own materials and effects, so you can combine hand-drawn characters, storyboards and line art with 3D models and cameras. Blender 4.3 rebuilt Grease Pencil with a new system, so features and file compatibility differ between older and newer versions.

Dirt and scratch pattern used as a mask

A grunge map is a grayscale texture of dirt, scratches, stains or blotches, used as a mask or modulation layer to break up uniform surfaces. Plugged into a mask in Substance Painter or Designer, it decides where wear, dust or color variation shows, and different grunge maps give different looks. Substance Painter includes a library of them, and you can also author your own.

Hair that reads as flat strips

Hair cards look flat when they are placed as evenly spaced, parallel strips with the same length and width. Layer the cards from the scalp outward, with a solid base layer under the surface cards, vary their length, width and rotation, follow the natural flow of the hair, and add a few loose flyaway strands. Use a texture with soft, varied strands, a gradient of color from root to tip, and correct highlights.

Two ways to make hair in real time

Hair cards and strand-based hair are the two ways to build hair for real-time characters. Hair cards are flat, textured polygon strips that look like clumps of hair, and are cheap and widely used in games. Strand-based hair, called grooms in Unreal Engine, renders thousands of individual curves with proper lighting and shadows, giving a more realistic look at a much higher cost. Many projects use cards for the in-game version and strands for cinematics or high-end hardware.

Painted lighting baked into albedo

Hand-painted texturing is a stylized workflow where lighting, shadows, and highlights are painted directly into the albedo map, rather than calculated at runtime via PBR. This is the style of World of Warcraft, Hearthstone, Torchlight, and most mobile RPGs. The look is consciously flat and graphic; a hand-painted asset retains its appearance under any lighting because there is no separate lighting computation reading PBR channels.

Visible cut lines where a sprite intersects a surface

Hard lines appear where a particle sprite intersects the floor or a wall because the flat sprite is cut by the surface. Fix it with soft particles, also called depth fade, which fade the particle's opacity out as it gets close to the geometry behind it. In Unreal Engine, use the DepthFade node in the material's opacity, and in Unity enable Soft Particles in the particle shader, which also needs the depth texture enabled in the render pipeline asset.

Mechanical, geometric subject matter

Hard surface refers to modeling and texturing of mechanical, manufactured, or geometric subjects — weapons, vehicles, architecture, mechs, environment props. The defining characteristic is precise edges, clean panel work, and CAD-like accuracy as opposed to the flowing organic forms of character or creature sculpting. Hard-surface workflows lean heavily on Booleans, SubD modeling, and chamfered edges to read as manufactured rather than hand-crafted.

High Dynamic Range Image lighting

An HDRI (High Dynamic Range Image) is a 360-degree photographic capture of a real environment with full lighting information, used to light 3D scenes via image-based lighting (IBL). HDRIs deliver realistic ambient lighting and accurate reflections in a single asset — open-sky HDRIs make outdoor scenes look correct without manually placing light sources.

Unity’s High Definition Render Pipeline

HDRP (High Definition Render Pipeline) is Unity’s deferred-renderer-based pipeline aimed at photoreal projects on PC and console. It supports volumetric lighting, screen-space reflections, physically-based sky, area lights, ray-traced effects, and a richer material system than URP. HDRP demands far more from hardware than URP — it is not a drop-in upgrade and projects do not switch lightly.

Fog that is denser near the ground

Height fog is fog whose density falls off with height, so it is thickest near the ground and thins out above, as in a misty valley or at dawn. In Unreal Engine it is the Exponential Height Fog actor, with controls for density, height falloff, color, start distance and an optional volumetric fog that catches light and creates visible light shafts. Fog adds depth, hides distant pop-in and helps set a mood.

Blending materials using their height maps

Height-based material blending mixes two materials using their height maps, so the blend follows the shape of the surface instead of fading evenly. Where the blend value is low, the material with the higher surface at that point shows through, so soil settles in the cracks of a stone wall, moss grows in the gaps of cobblestones and snow collects on the high points. It gives much more natural transitions than a plain gradient, and it is widely used with vertex painting and landscape layers.

Spending detail where the player looks

A hero asset is an object that the player sees up close or that is important to the scene, such as a key prop, a landmark or the centerpiece of a room, and it gets the highest level of detail in modeling, texturing and shading. Background assets are the filler around it, such as walls, rubble or distant props, and use lower resolution, reuse trim sheets and shared materials, and take less time. Dividing assets this way lets a small team cover a large environment within its budget.

The detail source for baking

A high-poly model is the detailed source mesh — typically millions of polygons created in ZBrush — that holds all the surface detail you want to appear in the final asset. The high-poly is never imported into the engine; instead, its details are baked into normal, AO, curvature, and other maps applied to a much lighter low-poly counterpart.

Designer node for controlling gray values and masks

Histogram Scan is a Substance Designer node that picks a range of gray values from an image and stretches it, so it works as an adjustable threshold, a mask maker and a contrast control. Position sets which gray level is selected, Contrast sets how sharp the edge is, and Invert flips the result. Used on noise or a height map, it turns a soft gradient into a mask with a clean, controllable edge, which is why it appears in almost every graph.

Merged proxy for distant groups of meshes

HLOD, or Hierarchical Level of Detail, replaces a group of distant objects with one merged proxy mesh and material, so the engine draws one object instead of hundreds. Normal LODs simplify a single mesh as it moves away, while HLODs simplify whole clusters such as a village or the edge of a forest, which is where most draw calls are saved in big worlds. In Unreal Engine 5 they are built per cell with World Partition.

Packaged Houdini network with parameters

A Houdini Digital Asset, or HDA, is a network of nodes packaged into a single node with its own parameters, so it can be reused, shared and used in other projects. An HDA hides the complexity of a procedural setup behind sliders and inputs, such as a building generator with a number of floors, or a fence tool with a length and style. It is saved as a file and can be loaded into any Houdini scene, or into Unreal Engine and Unity through Houdini Engine.

Run Houdini tools inside Unreal and Unity

Houdini Engine is a plugin that lets other programs, including Unreal Engine, Unity, Maya and 3ds Max, run Houdini's procedural tools inside them. Artists load a Houdini Digital Asset, adjust its parameters in the other program's interface, and Houdini Engine cooks the result in the background as geometry in the scene. It brings the power of procedural generation to level and environment artists without needing the full Houdini application on every machine.

The viewport is empty or shows the wrong node

Geometry does not show in Houdini when the node you want to see does not have its Display flag turned on. In the network editor, click the blue circle on the right side of the node so the viewport shows its result, and the purple Render flag decides what is used when rendering. Also check that the yellow Bypass flag is off, because it skips the node, and press Home in the viewport to frame everything.

A practical path from learning to a junior role

To get a first game art job, choose one specialization, learn its fundamentals, build three to five strong portfolio pieces with breakdowns, get feedback from working artists, show your work on ArtStation and LinkedIn, and apply to junior and associate roles, internships and outsourcing studios. Practice art tests under time limits, and show that you can finish projects and work in a team, for example through game jams and small collaborations.

Real-world sizes used to keep assets consistent

Human scale is the use of real-world dimensions, based on the size of a person, to keep the objects in a game consistent. Unreal Engine counts one unit as one centimeter and Unity counts one unit as one meter, and a standard adult character is about 1.7 to 1.8 meters tall, with a door around 2 meters, a stair step 15 to 18 centimeters, a table about 75 centimeters and a ceiling 2.4 to 3 meters. Artists keep a reference mannequin in their scenes to check the scale of everything they build.

Maya's material and shading network editor

Hypershade is Maya's editor for creating and editing materials and shading networks. It shows the shaders, textures and utility nodes in a scene and lets you connect them in a graph, assign materials to objects and preview the result. With the Arnold renderer, the main material is the aiStandardSurface, a physically based shader with base color, metalness, roughness, normal and emission inputs, similar to Principled BSDF in Blender.

Material region mask

An ID map is a baked texture where each material region of a model is filled with a flat solid colour. Substance Painter uses ID maps to auto-mask material assignments: a green pixel becomes leather, blue becomes metal, red becomes fabric. This turns a tedious manual selection step into one click, especially for models with many distinct material zones like character costumes or vehicles.

Inverse vs Forward Kinematics

IK (Inverse Kinematics) and FK (Forward Kinematics) are the two modes of joint animation. FK rotates each joint independently — animate the shoulder, then elbow, then wrist, then fingers — giving precise arc control. IK works backwards: place the hand where you want it and the rig solves where the elbow and shoulder need to be. IK is fast for placing limbs (foot on the ground, hand on a sword); FK is better for arcs in mid-air motion.

Lighting a scene from an environment image

Image-based lighting, or IBL, lights a scene using an image of an environment, usually an HDRI or cubemap, as the light source. The image gives both soft diffuse light from every direction and sharp reflections on shiny surfaces, with brighter parts of the image acting as stronger lights. It is a fast way to get realistic, natural-looking lighting and reflections, and is the base of most previews in Substance Painter, Marmoset Toolbag and Blender.

Insert Multi Mesh brush for placing prefab details

An IMM brush, short for Insert Multi Mesh, is a ZBrush brush that places a library of premade meshes onto a model with a click or a drag. Each mesh in the brush, such as a rivet, a screw, a pipe or a piece of armor, is inserted as a new SubTool or as part of the current one. IMM brushes speed up kitbashing and detailing, and Curve variants repeat a mesh along a curve, which is useful for chains, stitches and rivets.

How light fades with distance

Inverse-square falloff is the rule that the brightness of a light falls with the square of the distance from it: twice as far means a quarter of the light. It is how real lights behave and what physically based engines use. Because the light never reaches exactly zero, engines add an attenuation radius, a distance after which the light is cut off, so that distant lights are skipped and performance is saved.

Stair-stepped outlines on geometry

Jagged, stair-stepped edges are aliasing, and the fix is to turn on anti-aliasing and give it enough resolution to work with. Pick a method that suits your renderer: MSAA in forward rendering, TAA or TSR in deferred engines such as Unreal Engine 5, SMAA or FXAA as cheap options, and DLSS or FSR as upscaling anti-aliasing. Raising the render resolution or screen percentage also reduces jaggies.

What studios expect at each stage

Game artists are usually graded as junior, mid-level and senior, and the level shows how independent and experienced they are. A junior artist does assigned tasks with guidance and needs feedback, a mid-level artist works independently and delivers consistent quality on time, and a senior artist handles complex problems, mentors others, improves the pipeline and sets standards. Beyond that are lead artists, who manage a part of the team, and art directors, who set the vision. Titles and expectations vary between studios.

Houdini's built-in renderer

Karma is Houdini's own renderer, built on USD and used through Solaris, Houdini's lighting and look-development context. It comes in two versions, Karma CPU and Karma XPU, which uses the CPU and GPU together, and renders physically based images with global illumination, volumes and motion blur. It is used for effects, procedural scenes and final renders from Houdini, where the scene is described in USD.

The main promotional illustration of a game

Key art is the main illustration that represents a game, used on store pages, posters, packaging and in advertising. It shows the characters, setting and mood in a single striking image, and has to work at a small thumbnail size as well as in large formats. Splash art, the term used in many online games, is similar, with a strong focus on a character. Key art is usually painted by experienced illustrators and has more polish than production concept art.

Poses in time and how the computer fills in between

A keyframe stores the value of a property, such as a bone's position or rotation, at a specific time. The software fills in the frames between keys by interpolation, which can be stepped, where the value jumps from key to key, linear, which moves at a constant speed, or spline and Bezier, which ease in and out along a smooth curve. Animators shape these curves in a graph editor, and the way they are set strongly affects the feel of the motion.

Composing detail from pre-made parts

Kitbashing is the technique of assembling new 3D assets out of pre-made parts — borrowed from a personal kit or commercial library — by combining, scaling, and rearranging them. A sci-fi spaceship hull might be assembled from a kit of 200 panels, vents, cables, and antennas dropped on a base shape. Kitbashing dramatically accelerates hard-surface concepting and is the standard production method for sci-fi/mech environments where detail density matters more than per-asset uniqueness.

Painting materials onto terrain

Landscape layers are the materials that are painted onto terrain, such as grass, rock, soil and snow, each with its own set of textures. In Unreal Engine the Landscape material uses a Layer Blend node, where each layer has a weight painted on the terrain, and the weights can be blended by simple weight or by height so rocks poke through soil. Unity Terrain uses terrain layers with painted masks. Layers can also drive the automatic spawning of grass and other foliage on top of them.

Repeating patterns on terrain from a distance

Landscape textures show tiling when the same texture repeats at one scale across a large area. Sample each layer at two or more different scales and blend them with distance, add a large, low-frequency macro variation texture that changes the color and brightness across the terrain, use noise to break up the edges between layers, and rotate or offset the samples. Layer Blend nodes with height-based blending also help hide repetition.

Load and unload parts of the world as you move

Level streaming loads and unloads parts of a game world while the player moves, so only the nearby parts are in memory, and large worlds fit in limited resources. In Unreal Engine, streaming can use sublevels and, in Unreal Engine 5, World Partition, which streams by distance in a grid. In Unity, additive scene loading and Addressables stream chunks of content. Well-planned streaming removes loading screens and keeps memory use under control.

Light showing through walls and corners

Light leaks are bright lines or patches where light seems to pass through walls, floors and corners. In Unreal Engine they usually appear when walls are single planes or very thin, or when meshes meet with a gap, because global illumination cannot tell that the surface is solid. The standard fix is to give walls real thickness, close the gaps and overlap pieces at the seams.

Baked light sampled for moving objects

A light probe is a point in a scene that stores the baked lighting around it, so objects that move can be lit by the same bounced light as the static scene. Lightmaps only work for static objects, so characters, props and vehicles sample nearby probes and blend between them. In Unity you place Light Probe Groups by hand, and Unity 6 adds Adaptive Probe Volumes that place and bake probes automatically.

Directional, point, spot and area lights

The main light types in 3D are directional, point, spot and area. A directional light is like the sun, with parallel rays and no distance falloff. A point light shines in all directions from a position and fades with distance. A spot light is a cone with an angle and softness. An area light, called a rect light in Unreal Engine, emits from a surface, so it gives soft shadows and realistic reflections, but costs more or only works baked in some pipelines.

Pre-baked indirect lighting

A lightmap is a texture baked offline that stores the result of complex indirect lighting calculations (bounce light, ambient occlusion, area lights), applied at runtime as a tinted overlay on each surface. Lightmaps deliver film-quality lighting at zero runtime cost — but only for static geometry that doesn't move. UE5's Lumen has replaced lightmaps for most projects, but mobile titles and stylized games still rely on baking.

Second UV channel for baked lighting

A lightmap UV is a second UV channel used to store baked lighting on a mesh. Unlike texture UVs, it must not overlap: every face needs its own space inside the 0 to 1 area, and islands need padding between them. In Unreal Engine it is UV channel 1 by default. Overlapping or missing lightmap UVs cause black blotches, streaks and incorrect shadows in baked lighting.

Black, dark or blotchy baked lighting

Unity lightmaps look black or blotchy when the mesh has no usable lightmap UVs or is not set to contribute to baked lighting. Turn on Generate Lightmap UVs in the model's import settings, enable Contribute GI on the object (Static), set the light's mode to Baked or Mixed and then run Generate Lighting from the Lighting window. Overlapping UVs and a low lightmap resolution cause the blotches.

Non-destructive Boolean operations in ZBrush

Live Boolean is a ZBrush mode that previews Boolean operations between SubTools in real time. You set each SubTool to Add, Subtract or Intersect in the SubTool palette, turn on Live Boolean, and the combined result shows immediately while the SubTools stay editable. When the result is right, Make Boolean Mesh creates a real, new mesh from it. It is a fast way to cut shapes and build hard-surface forms.

Level of Detail

LOD (Level of Detail) is the technique of swapping a mesh for progressively simpler versions as the camera moves further away. A typical chain has LOD0 (full quality, close-up), LOD1 (50% triangles, mid-range), LOD2 (25%, distant), LOD3 (billboarded sprite, far horizon). Without LODs, distant assets waste GPU drawing detail no player can see.

Unity component that switches mesh detail by distance

A LOD Group is a Unity component that switches between several versions of a mesh depending on how large the object appears on screen. Each level has a threshold given as a percentage of screen height, and when the object shrinks below it, Unity swaps to a cheaper mesh and finally to nothing or a billboard. If meshes are named with _LOD0, _LOD1 and _LOD2 suffixes, Unity creates the LOD Group when it imports the model.

Add an edge loop around a mesh

A loop cut adds a new loop of edges around a mesh, running across quads. In Blender press Ctrl+R in Edit Mode, hover over the mesh to preview the loop, scroll to add several loops, click to confirm and then move the mouse to slide it, with a right-click to keep it centered. Loop cuts add the extra geometry needed for details, sharper edges under Subdivision and control of shape.

A stutter at the point where a cycle repeats

A looping animation hitches when its first and last frames show the same pose, so the pose is held for two frames at the loop point. Remove the duplicate last frame, for example by setting the end of the range one frame earlier, so the last frame leads naturally into the first. Also check that the curves have matching tangents at both ends and that the root does not jump or drift between the end and the start.

Game-ready mesh

A low-poly model is the game-ready version of an asset with a polygon count tuned for real-time rendering — typically thousands of triangles, not millions. The low-poly preserves the silhouette of the original sculpt but relies on baked normal maps to convey surface detail. Polycount budgets depend on platform: mobile budgets stay under 10k tris per character, PC and console hero characters can run 30k–100k.

UE5 dynamic global illumination

Lumen is Unreal Engine 5's real-time global illumination and reflection system. It computes indirect lighting and reflections dynamically — moving a light source updates bounce lighting and mirrored reflections immediately, without baking. Lumen replaces UE4's lightmass workflow for most projects and is what gives recent UE5 titles their cinematic look.

Streaks and skewed detail in a Toolbag bake

Bake artifacts in Marmoset Toolbag appear when the baking rays do not follow the surface correctly. Put the low-poly and high-poly into a bake group so each part only sees its partner, use a cage or adjust the Offset so rays start and end in the right place, and use Paint Skew to fix streaks and skewed detail by hand. Also check normals, overlapping UVs and the smoothing of the low-poly.

Protect areas of the mesh and extract shapes

Masking in ZBrush protects parts of a mesh from being changed, so the area you are sculpting stays separate from the rest. Hold Ctrl and drag to paint a mask, Ctrl-click on empty canvas to invert it, and Ctrl-click on a masked edge to blur or sharpen it. Masked areas appear dark. The same mask can be used to transform a part, to hide it, or to Extract it into a new SubTool, which is how clothing and armor shells are often made.

Parent material that spawns instances

A master material is a general-purpose parent Material in Unreal Engine that exposes its settings as parameters, so artists create many Material Instances from it instead of building a new graph for every asset. Changing a parameter value on an instance does not recompile shaders, which keeps iteration fast. A typical master exposes textures (base color, normal, ORM), tints, tiling, roughness controls and optional layers such as snow or wetness.

Lit-sphere material that needs no lights

A MatCap, short for material capture, is a texture of a lit sphere that is applied to a mesh according to the direction of its surface normals, so the model appears shaded and lit without any lights or real material calculations. It is cheap and fast, and gives a stable look from any angle, which is why sculpting tools use it. ZBrush uses MatCaps for its viewport shading, and Blender's Solid mode can use them, with a different image for different looks.

Bake setting that pairs low and high poly parts

Match by Mesh Name is a baking option in Substance Painter that pairs each low-poly part with the high-poly part that has the same name. Name the parts with the same base name and suffixes, such as barrel_low and barrel_high, and Painter bakes each pair separately, so a part never picks up details from a neighbouring object. The alternative, Always, uses the whole high-poly for every low-poly part.

Reusable node graph for materials

A Material Function is a reusable network of material nodes in Unreal Engine that you build once and call from many materials, like a subroutine. It has defined inputs and outputs, and when you edit the function every material that uses it updates. Typical functions handle world-aligned texturing, snow or moss coverage, tiling breakup and detail normals. Functions keep large materials readable and stop the same nodes being copied into every graph.

Lightweight material variant

A material instance is a child of a parent shader graph that overrides only specific parameters — different base colour, different roughness scalar, different texture set — without recompiling the underlying shader. This lets a single shader power hundreds of visual variants while staying GPU-efficient: switching a material instance is free, switching a fully different shader incurs a draw-call break.

Ray length settings in Painter baking

Max Frontal Distance and Max Rear Distance are baking settings in Substance Painter that limit how far the rays travel when projecting detail from the high-poly onto the low-poly. Frontal is the distance outward from the low-poly surface, and Rear is the distance inward. Rays only pick up detail inside that range, so too small a value misses detail and too large a value catches neighbouring parts and creates streaks.

Dark or invisible faces from reversed normals

Faces look black or inside out in Maya when their normals point the wrong way. Select the mesh and use Mesh Display > Reverse to flip them, or Mesh Display > Conform to make the normals consistent, and turn on Display > Polygons > Face Normals to see which way they point. If some faces disappear, check Shading > Backface Culling, because culling hides faces that point away from the camera.

Wrong model size after export from Maya

A model arrives at the wrong size from Maya when the scene units and the engine's units do not match. Set Maya's working units to centimeters in Preferences > Settings, which matches Unreal Engine's one unit equals one centimeter, and export the FBX with the same units. In Unity, check the model's import settings for Convert Units and Scale Factor. Freeze transformations first, so the object has a scale of 1.

Fix odd scale, rotation and tool behavior

If a Maya model behaves strangely, with uneven bevels, wrong rotation or odd results in tools and exports, clean it up before continuing. Choose Modify > Freeze Transformations to reset translate and rotate to 0 and scale to 1 without changing the shape, then Edit > Delete by Type > History to remove construction history. Use Modify > Center Pivot if the pivot is in the wrong place.

The model vanished or cannot be seen

When an object disappears in Maya, first select it and press F to frame it. If it is still missing, turn off Isolate Select under the Show menu, check that nothing is hidden in the Outliner, and look at the camera's near and far clip planes in the Attribute Editor, since an object outside that range is not drawn. Also check display layers and the Show menu, which can hide whole object types.

Soften and harden edges

In Maya, a mesh looks faceted when its edges are hard and too smooth when they are soft. Select the edges or the whole object and use Mesh Display > Soften Edge to make shading smooth, or Harden Edge to make it crisp, and set the edges between faces that should look sharp to hard. For control by angle, use Mesh Display > Set Normal Angle. Smoothing the preview with 3 is not the same as softening normals.

The model looks empty or strokes do not appear

A model looks black or cannot be painted in Substance Painter when it has no usable UVs, when its UVs lie outside the 0 to 1 square without UDIM enabled, or when the wrong Texture Set is selected. Check the UV map in your 3D tool, move the islands into the 0 to 1 space, or create the project with UV Tile Workflow if the model uses UDIM tiles. Then select the right Texture Set in the Texture Set List.

Maps baked from the model that drive generators

Mesh maps are textures baked from a 3D model in Substance Painter, such as normal, world space normal, ambient occlusion, curvature, position, thickness and ID. They are not exported as final textures. They are the data that generators, smart masks and smart materials read to find edges, crevices and upward-facing surfaces. Without baked mesh maps those tools have nothing to work from and produce flat or empty results.

Particles drawn as 3D models

Mesh particles are particles drawn as small 3D meshes instead of flat sprites. They are used for debris, rocks, shards, leaves, crystals, coins and other objects that need to be seen from every angle, with real shape, lighting and shadows. Both Niagara's mesh renderer and Unity's Mesh render mode support them, and the mesh can rotate, tumble and use a normal material. They look more solid than sprites and cost more per particle.

Epic's framework for realistic digital humans

MetaHuman is Epic Games' framework for creating high-fidelity digital humans for Unreal Engine. It provides ready-made, fully rigged characters with realistic skin, eyes, teeth and hair grooms, tools to customize them, and tools that can build a MetaHuman from a scan or a mesh. MetaHumans come with facial rigs that work with animation and performance capture, and they are used for games, film, virtual production and visualization.

The two PBR texture workflows

Metal/roughness and specular/glossiness are the two PBR texture workflows. Metal/roughness uses base color, a metallic mask and a roughness map, and is the default in Unreal Engine, Unity, glTF and Substance Painter. Specular/glossiness uses diffuse color, a specular color map and a glossiness map, which is the inverse of roughness. Both can describe the same materials, but they are not interchangeable without conversion.

Conductor vs dielectric switch

A metalness map is a grayscale texture that tells the shader which parts of a surface are metal (white, 1) and which are non-metal (black, 0). Metals and non-metals reflect light fundamentally differently in physics, so a binary mask is sufficient for almost all real materials — grey intermediate values usually indicate either dust over metal or a baking artefact.

Pre-filtered texture down-sampling chain

A mipmap is a chain of progressively smaller, pre-filtered versions of a texture, generated automatically at import. When the GPU samples a textured surface at a distance, it picks the appropriately-sized mip level rather than the full-resolution texture — avoiding both shimmering on distant surfaces and wasteful GPU bandwidth. Each level is 1/4 the area of the previous (half on each axis), so a 1024×1024 texture's mip chain totals about 1.33× the base size.

Gap in the middle or doubled geometry

A Mirror modifier shows a gap or doubled geometry in the middle when the object's origin is not on the mirror axis or the center vertices are not exactly on it. Set the origin to the center, place the center vertices at zero on the mirror axis, and turn on Clipping and Merge in the modifier so vertices on the axis stay stuck together while you edit.

Add Height, Emissive or Opacity channels

To add a missing channel such as Height, Emissive or Opacity in Substance Painter, open Texture Set Settings, go to Channels and press the plus button to add it, then choose the format. New channels appear on every layer. A channel only exports if the export preset includes a map that uses it, so check the Export window as well, and add or edit the output maps there.

Pink textures after moving or opening a file

A pink texture in Blender means the image file cannot be found at the path stored in the .blend file. Use File > External Data > Find Missing Files and point Blender at the folder that contains the textures, and it will relink them. To prevent it, use Make Paths Relative before moving a project, or Pack Resources to embed the images inside the .blend file.

Auto-rigger fails or the character looks wrong

Mixamo's auto-rigger works best with a clean, single, human-shaped character standing in a T-pose, arms straight out, facing forward. If the result bends wrongly, check the pose and the placement of the markers for the chin, wrists, elbows, knees and groin. If textures are missing after upload, zip the FBX or OBJ together with the texture files, and download with Skin selected to get the mesh back with the rig.

Art budgets for phones and tablets

Mobile optimization is making game art run well on phones and tablets, which have less memory, less power and often heat limits. The main rules are to keep textures small and compressed with ASTC, use few materials and draw calls, keep triangle counts moderate, bake lighting where possible, and avoid transparency, large particles and heavy post-processing, which use up the limited fill rate. Simple, stylized art with baked lighting suits mobile hardware very well.

Object lies on its side with a -90 rotation

A model imports rotated by 90 degrees in Unity because 3D tools use different up axes: Blender and 3ds Max are Z-up and Unity is Y-up. The quickest fix is to check Bake Axis Conversion in the model's import settings so the rotation is baked into the mesh and the object gets a clean rotation of 0, 0, 0. Exporting with matching Forward and Up axes from Blender gives the same result.

Orthographic views of a character or prop

A model sheet, or turnaround, shows a character, creature or prop from several standard views, typically front, side, back and three-quarter, drawn to the same scale and proportions. It is the reference that 3D modelers, riggers and animators work from, so it has to be consistent, clear and complete, with a neutral pose such as a T-pose or A-pose. It often includes callouts for costume details, materials, colors and accessories.

Non-destructive operation in Blender

A modifier is a non-destructive operation in Blender that changes how an object looks without changing the underlying mesh. Modifiers are stacked and run from top to bottom, so their order matters, and each one can be turned on or off for the viewport and the render. Common ones are Subdivision Surface, Mirror, Bevel, Array, Solidify, Boolean and Decimate. When you are happy, Apply makes the result permanent.

Reusable building blocks for environments

A modular kit is a curated set of mesh pieces designed to snap together on a grid to build large environments without authoring every wall, floor, and corner uniquely. A typical kit has 8-20 hero pieces (corner, straight wall, doorway, window, archway, floor variations) plus decorative props that combine into infinite layouts. Modular kits are the only practical way to build AAA-scale environments — even an open-world map of 100km² is mostly modular pieces dressed differently.

Collected references that set the look of a project

A mood board is a collection of reference images that captures the look, color, atmosphere and style a project aims for. Concept artists and art directors build it at the start, with photographs, paintings, screenshots, materials and shapes, to agree on a direction before making art. It keeps the team's work consistent and helps explain ideas without long descriptions. PureRef is the most popular tool for assembling references on a canvas, and Pinterest and ArtStation are common sources.

Blur fast-moving pixels along their path

Motion blur smears pixels along the direction of motion to mimic a camera shutter integrating light over a frame interval. Per-object motion blur uses motion vectors from the G-Buffer and gives the strongest cinematic feel; camera-only motion blur is cheaper but less convincing. It is almost always paired with TAA, which depends on the same motion vector buffer.

Recording real-actor motion

Motion capture records the movement of a real actor's body and face, then applies it to a 3D character's rig. Modern systems range from full optical studios (Vicon, OptiTrack) costing six figures, to inertial suits (Rokoko, Xsens) for indie budgets, to AI-from-video tools (Move.ai, Rokoko Vision) that need only a single camera. Mocap delivers animation volume that keyframe alone cannot match, especially for cinematic sequences.

Choosing animation frames from a database to match movement

Motion matching is an animation technique in which the engine searches a large database of motion capture or authored animation, every frame, for the pose that best matches the character's current motion and where the player wants to go, and plays from there. Instead of hand-built state machines and blend spaces, the result is very fluid movement with fewer transitions, because many small variations are in the data. Unreal Engine 5 provides it through Pose Search, and it is used in many modern games.

Hardware-level edge anti-aliasing

MSAA (Multisample Anti-Aliasing) is a hardware-accelerated technique that samples geometry edges multiple times per pixel without re-running the fragment shader. It produces clean, stable silhouettes and works well in forward renderers, but it does not anti-alias shader aliasing (specular highlights, alpha-tested foliage) and costs significant memory bandwidth. Modern AAA titles often skip MSAA in favor of TAA, which handles shader aliasing too.

Dull, grey-brown colors after painting

Colors turn muddy when too many hues are mixed together, or when opposite colors are blended in equal amounts, which cancels the color into a dull gray-brown. Limit the palette to a few main colors, choose one dominant hue and one or two accents, and keep temperature shifts, warm light and cool shadow, instead of darkening with gray or black. Paint shadows with a saturated, shifted hue rather than adding black.

Maya tool for cutting and adding edges

The Multi-Cut tool is Maya's main tool for adding edges to a mesh. It can cut across faces, insert edge loops, split faces and delete edges with the same tool, using click and drag on edges and with snapping to useful points. It replaced several older tools and is the standard way to add detail, support loops and change edge flow in Maya, and it is found in the Mesh Tools menu.

Sculpt at several subdivision levels

The Multiresolution, or Multires, modifier subdivides a mesh into several levels and lets you sculpt on each of them, so you can block out big forms on a low level and add fine detail on a high one while the base mesh stays intact. You can switch levels at any time and the edits on the lower levels carry up. It is a classic way to sculpt in Blender and to prepare a high-poly for baking.

Polygon with 5+ sides

An n-gon is a polygon with five or more sides, generally avoided in production meshes. N-gons triangulate unpredictably (the engine chooses which diagonals to use), can cause shading artefacts, and break edge-loop flow needed for animation. Some n-gons are acceptable in flat, undeformed areas of hard-surface props; never in deforming character geometry.

UE5 virtualized geometry

Nanite is Unreal Engine 5's virtualized geometry system that streams and renders meshes with effectively unlimited polygon density. Artists can drop multi-million polygon ZBrush sculpts directly into UE5 without manual LOD chains — Nanite handles dynamic decimation and streaming per-frame based on screen size. Nanite changed environment art production by removing the need to bake high-poly detail into normal maps for most static props.

UE5 particle and VFX system

Niagara is Unreal Engine's real-time visual effects system, replacing the older Cascade module. It runs on a node graph with emitters and modules — particle behaviours like spawn rate, velocity, colour curves, collision, GPU computation. Niagara handles everything from simple sparks to full destruction simulations, fluid dynamics, and ribbon trails. Almost every modern UE5 game VFX shot is built in Niagara.

Grain and white dots in Cycles renders

Grain in a Cycles render means too few samples for the lighting in the scene. Turn on Denoise in Render Properties, raise the sample count, and keep Adaptive Sampling on so Cycles spends time where noise remains. For bright white dots, called fireflies, lower Clamp Indirect in Light Paths, and avoid tiny, very bright light sources and strongly glossy surfaces lit indirectly.

Mesh that cannot exist as a real solid

Non-manifold geometry is mesh that could not exist as a real solid object, such as edges shared by three or more faces, loose vertices and edges, faces inside the model or zero-area faces. It causes boolean operations, remeshing, subdivision, 3D printing and baking to fail or produce artifacts. You usually fix it by merging by distance, deleting loose parts and removing interior faces. In Blender, Select All by Trait > Non Manifold highlights the problem areas.

Per-pixel surface detail

A normal map is a texture that stores per-pixel surface direction (the normal vector) of a high-resolution mesh, baked onto a low-resolution mesh. Each pixel encodes an XYZ direction in RGB channels, letting the shader light a flat polygon as if it had millions of bumps and grooves. Normal maps are the single most common technique for adding detail without polygons, used universally in real-time game art since the mid-2000s.

Why Unreal textures look blocky or wrong

If a normal map or packed texture looks wrong in Unreal Engine, check its Compression Settings. Normal maps should use Normalmap, which Unreal usually picks from the file name, and packed data maps such as ORM should use Masks (no sRGB) or have sRGB switched off. A normal map left on Default compression gives blocky, incorrect lighting, and sRGB left on for a data map shifts every value.

Flat, noisy or inverted bumps in Unity

If a normal map looks flat, noisy or wrong in Unity, select the texture and set Texture Type to Normal map; Unity then shows a Fix Now button when a normal texture is assigned without it. Unity expects OpenGL-style normal maps, where green points up, so a map exported for Unreal needs its green channel flipped. Turning off sRGB is handled automatically for normal maps.

Visible in the viewport but missing from the render

If an object is visible in the 3D viewport but missing from the render, its render visibility is probably off. Enable the camera icon (Disable in Renders) column in the Outliner filter and make sure it is on for the object, and check that its collection is not excluded. The monitor icon only controls the viewport, so an object can be shown there and still be hidden in the final image.

Geometry cut off when you get close

Objects disappear when the camera gets close because they are inside the camera's near clip plane. Open the Camera component, expand Clipping Planes and lower Near, whose default is 0.3, to a small value such as 0.05 to 0.1. Do not go to extremes, because a very small near plane compared with the far plane reduces depth precision and makes distant surfaces flicker.

Skip rendering hidden geometry

Occlusion culling skips rendering meshes that are hidden behind other geometry from the camera's perspective. The engine maintains a visibility map at runtime (UE5 uses hierarchical Z-buffer occlusion); meshes determined to be fully behind opaque geometry are skipped entirely. Crucial for indoor/corridor games where most of a scene is technically loaded but not visible at any moment.

Occlusion / Roughness / Metalness packed into one map

An ORM texture packs three grayscale PBR maps — ambient Occlusion, Roughness, and Metalness — into the R, G, and B channels of a single image. This cuts texture samples and memory by two-thirds compared to using three separate maps. ORM is the de facto standard for Unreal Engine PBR exports; Unity URP/HDRP uses a similar packing called MaskMap (with different channel order).

Studios that produce art for other game companies

Outsourcing studios, also called co-development or external art studios, produce assets, characters, environments, animation and effects for other game companies under contract. They work to the client's style guide, technical limits and schedule, and deliver finished, engine-ready content, which lets game developers scale their teams for a project. For artists they are a common entry point, with a wide variety of projects, a fast pace and strong pipelines, and a good place to learn production skills.

Changing size, color and opacity across a particle life

Over-life curves control how a particle's properties change from the moment it spawns to the moment it dies. Typical curves drive size, color, opacity, speed and rotation, such as a spark that starts bright and small, grows quickly and then fades out, or smoke that expands and becomes transparent. These curves, shown as graphs or gradients in the editor, are the main tool for giving an effect its feel, and are called Color over Lifetime in Unity and Color From Curve in Niagara.

Redrawing same pixels

Overdraw happens when the GPU shades the same pixel multiple times in one frame — once per overlapping transparent or alpha-tested surface in front of it. Particles, foliage, hair cards, and stacked decals are the main culprits. A scene with heavy overdraw can be CPU-cheap but GPU-fragment-bound: framerate tanks not because of triangles, but because each pixel is being painted 10 times over.

Painting on top of a 3D render or sketch

A paintover is a painting made on top of an existing image, such as a 3D blockout render, a screenshot from the engine or a student's work, to change or improve the design. Concept artists paint over rough 3D scenes to add detail, lighting and mood quickly while keeping correct perspective. Art directors and mentors paint over screenshots and models to show corrections and ideas directly, which is why paintover feedback is common in art schools and game studios.

Fake-depth via per-pixel ray march

Parallax occlusion mapping is a shader technique that simulates surface depth on flat polygons by per-pixel ray-marching through a height map. It creates the illusion of real displacement (bricks pop out, cobblestones cast self-shadows) at a fraction of the cost of true displacement — but only works convincingly within a limited viewing angle range and breaks at the silhouette where there's no real geometry to offset.

An effect eats the frame time

Particle effects are usually expensive because of overdraw: many large, translucent sprites stacked on top of each other, each shaded across a big part of the screen. Use fewer and smaller particles, trim the sprite shape tightly so transparent pixels are not shaded, use simpler materials, and consider Masked or dithered opacity where it looks acceptable. Check the shader complexity and overdraw view modes to find the worst effect.

Spawns and animates many small elements

A particle system creates and animates large numbers of small elements, called particles, to make effects such as fire, smoke, sparks, rain, magic and explosions. An emitter spawns particles at a rate or in bursts, and each particle gets a lifetime, velocity, size, color and rotation that can change over time and respond to forces such as gravity and wind. Each particle is drawn as a sprite, a mesh or a ribbon. Unreal Engine uses Niagara, and Unity has the Particle System and the VFX Graph.

Effects vanish at the edge of the screen

Particles disappear when the camera looks away or turns because the engine culls the effect using its bounds, and the bounds do not cover where the particles really are. In Niagara, set Fixed Bounds in the system or emitter properties to a box that covers the whole effect. In Unity, set the Particle System's Culling Mode to Always Simulate or give it a larger custom bounds, so the effect keeps running and drawing correctly.

The effect plays but nothing appears

When particles do not appear, check the basics in this order: the system is active and playing, the spawn rate and lifetime are above zero, the emitter has a renderer, and the renderer has a working material. In Niagara, the Sprite or Mesh renderer needs a material and the emitter needs a spawn module. In Unity, the Particle System Renderer needs a material, and a pink one means the shader does not match the render pipeline.

Effects pop in front or behind each other

Particles render in the wrong order because translucent objects are sorted by distance, and overlapping effects or large sprites can sort incorrectly. Set the sort mode on the emitter to sort by distance to the camera, and use priority controls to force an order: Translucency Sort Priority on the component in Unreal Engine, and Sorting Fudge or the renderer's Order in Layer in Unity. Put the effect that should be behind at a lower priority.

Folder blending that works per channel

Passthrough is a blending mode for folders in Substance Painter, and it is the default. In Passthrough, the layers inside a folder blend directly with the layers below the folder, channel by channel, as if they were in the main stack. This lets a folder mask and group layers without changing how its contents interact with the rest of the material. Choosing Normal instead flattens the folder into one layer first.

Physically accurate light with random sampling

Path tracing is a form of ray tracing that simulates light by following random paths from the camera through many bounces, and averaging many samples per pixel. It handles reflections, refraction, soft shadows, global illumination and caustics in one consistent method, and is the base of offline renderers such as Cycles and Arnold. Images start noisy and become cleaner as the samples increase, which is why denoising is so important.

Physically Based Rendering

PBR (Physically Based Rendering) is a shading and material workflow that simulates how light interacts with surfaces according to real-world physics. Instead of authoring colours per lighting condition, an artist defines a material via separate texture channels — typically base colour, roughness, metalness, normal, and ambient occlusion — and the engine handles consistent lighting across any scene. PBR is the universal standard for modern game engines (Unreal Engine 5, Unity HDRP, Godot 4) because the same material looks correct under any lighting rig.

Rule-based placement of content in Unreal

PCG, the Procedural Content Generation Framework, is a node-graph toolset in Unreal Engine for generating and placing content from rules. A PCG graph reads surfaces, splines, volumes or landscapes and scatters meshes such as trees, rocks, props and debris according to density, slope, noise and exclusion rules. It lets environment artists fill large areas consistently and re-run the result when the layout changes.

One-, two- and three-point perspective

Perspective drawing is the method of showing 3D space on a flat surface, so that objects look smaller and converge as they go away from the viewer. It uses a horizon line at eye level and vanishing points where parallel lines meet. One-point perspective has a single vanishing point and suits straight-on views of corridors and roads, two-point shows corners of buildings, and three-point adds a vertical vanishing point for high or low views. Artists also use it to build environments and sets.

Buildings and rooms look warped or off

Perspective looks wrong when the lines of the scene do not agree on a horizon line and shared vanishing points. Set the horizon line first, at the viewer's eye level, then draw all lines that run parallel in space toward the same vanishing point, one for each direction. Use a perspective grid or a 3D blockout as a guide, and check for a wide lens that stretches the edges, which makes forms look warped.

Building a concept by combining and painting over photos

Photobashing is a concept art technique where parts of photographs and textures are combined into a rough image, and then painted over to unify the result and turn it into an original design. It is fast, produces rich detail and realistic textures, and is widely used for environments, vehicles and architecture. Artists cut, scale and arrange the photos on layers, adjust color and lighting to match, and paint to blend the pieces and add the elements that photos cannot give.

3D models built from photographs

Photogrammetry builds a 3D model from many overlapping photographs of a real object or place. Software finds matching points between the images, calculates the camera positions and reconstructs a dense mesh with texture. It is how many realistic rocks, trees and surfaces in scan libraries such as Quixel Megascans are made. The raw result is a heavy, noisy mesh that needs cleanup and retopology before it is game-ready.

Lux, lumens, candela and nits

Physical light units are real-world measures used to set light intensity in engines. Lumens measure the total light a source emits, candela the intensity in a direction, lux the light arriving on a surface, and nits the brightness of a surface or display. Using them with a camera exposure makes lighting behave like real photography, so a lamp, the sun and the sky can all be balanced in the same system. Unreal Engine mainly uses candela, lumens and EV values.

Magenta objects after switching render pipeline

Materials turn pink in Unity when their shader does not work with the active render pipeline, most often after moving a project to URP or HDRP. Convert the materials with Window > Rendering > Render Pipeline Converter, or switch each material to a shader from the new pipeline, such as Universal Render Pipeline/Lit. Also confirm that a pipeline asset is assigned in Project Settings > Graphics.

The origin a mesh transforms around

The pivot point is the origin a mesh rotates, scales, and translates around when placed in an engine. For props it usually sits at the base contact point (a chair on the floor, a wall flush with the grid); for doors it sits along the hinge edge so rotation reads correctly. Pivot mistakes are one of the most common reasons modular kits "do not snap right" in the engine — fix at export, not at runtime.

Designer node that runs a custom function per pixel

The Pixel Processor is a Substance Designer node that runs a custom function graph on every pixel of an image. Inside it, a function graph can read the pixel's value and its neighbours and calculate a new value, which makes it possible to create custom filters and effects that no ordinary node offers, such as special blurs, edge detection and distortions. It is one of the most flexible nodes in Designer, but also one of the most expensive.

Vertex where edge-count breaks

A pole is a vertex where the number of incident edges differs from the regular grid count of 4. An E-pole (or 5-pole) has 5 edges; an N-pole has 3. Poles are necessary anywhere edge-flow needs to bend, branch, or terminate — but they cause shading artefacts under subdivision and can pinch under skinning. Placing poles is craft: hide them in flat areas, never in highly-curved or deforming geometry.

Triangle budget for a mesh

Polycount is the number of triangles in a mesh, the primary measure of geometric complexity in real-time rendering. Engines render triangles, not polygons, so quads count as two triangles. Modern AAA hero characters run 30k–100k triangles; environment props 500–8k; mobile characters under 10k; background scatter often under 200.

Colored face groups used for selection and control

Polygroups are colored groups of polygons in ZBrush that organize a mesh. They can be used to hide or show parts, select and mask areas, guide ZRemesher so it keeps the borders of a group as edge loops, and separate parts into SubTools. Pressing Ctrl+W with part of the mesh visible creates a polygroup from it, and the Polygroups settings in the Tool palette build them automatically from other data.

Per-vertex colour in ZBrush

Polypaint is ZBrush's technique of painting colour directly onto a sculpt's vertices rather than onto a UV-mapped texture. Each vertex stores an RGB value — so the polycount sets the effective texture resolution. Polypaint is fast for blocking colour passes during sculpting and for generating an albedo basis that's baked to a UV-mapped texture at the retopology stage.

The process shots that prove how a piece was made

A portfolio breakdown is the set of images or videos that shows how a piece of art was made, in addition to the final render. For a 3D asset it usually includes the final view, a wireframe or topology view, the UV layout, the texture maps, a clay or untextured render, and a view in the game engine. A breakdown proves that you did the work, that it is technically sound, and that you understand the production process, which is what studios want to see.

Why a game art portfolio gets ignored

A game art portfolio usually fails to get interviews because it has too many average pieces, no clear specialization, or work that does not match the studios it targets. Show three to five excellent pieces for one role, such as environment artist or character artist, include breakdowns that show your process from wireframe and UVs to textures and in-engine results, match the quality and style of the studio's shipped art, and put your best piece and your contact details where they are seen first.

Baked map of where each point sits on the model

A position map is a mesh map that stores where each point of the model sits in space, usually as a gradient from the bottom to the top of the object. In Substance Painter it is baked with the other mesh maps and used by generators and smart masks to apply effects according to height, for example dirt that is heavier near the ground and lighter higher up, or rust that gathers at the bottom of a metal part.

Reusable Unity object saved as an asset

A prefab is a saved GameObject, with its components, children and settings, that you can place many times in scenes. Edit the prefab and every instance updates, while an instance can still override individual values. Prefab Variants inherit from another prefab and change only some parts, and prefabs can be nested inside each other. For artists, a prefab is the finished, game-ready version of a model with its materials, collider and LODs set up.

Working from big shapes to small details

Primary, secondary and tertiary forms describe the levels of detail in a sculpt. Primary forms are the large masses and overall proportions, such as the head, torso and limbs. Secondary forms are the medium shapes within them, such as muscle groups, the jaw, folds of cloth and armor plates. Tertiary forms are the fine detail, such as pores, wrinkles, scratches and stitching. Working in this order gives a sculpt a clear structure and prevents getting lost in detail.

Blender's all-purpose PBR shader

The Principled BSDF is Blender's main physically based shader, combining base color, metallic, roughness, IOR, transmission, emission, alpha and coating into one node. It follows the metal/roughness PBR workflow, so textures from Substance Painter or engine pipelines plug in directly: base color, metallic, roughness and a normal map through a Normal Map node. It works in both Eevee and Cycles and is exported to glTF.

Greybox and blockout modeling inside Unity

ProBuilder is a Unity package for modeling meshes directly in the editor. Level and environment artists use it to build greybox spaces quickly, with simple shapes, extrusion, beveling and cutting that can be tested in the game right away. The result is a normal mesh that can be exported to a 3D tool for final modeling or replaced by finished assets. It is meant for blockouts and prototyping, not for final art.

Motion generated by rules and physics instead of keyframes

Procedural animation is motion created at runtime by rules, math and physics instead of hand-authored keyframes. Common examples are look-at systems that turn a head toward a target, inverse kinematics for feet and hands, spring and jiggle bones for hair, tails and cloth, and fully procedural movement for creatures such as spiders and robots that adapt to terrain. It reacts to the game world, which keyed animation cannot do, and is often layered on top of authored animation.

Measure before you optimize

Profiling is measuring where a game spends its time and memory, so you optimize what actually costs the most instead of guessing. Profilers show how long each system, function and draw call takes in every frame. Common tools are Unreal Insights and the stat commands in Unreal Engine, the Profiler, Memory Profiler and Frame Debugger in Unity, and external GPU tools such as RenderDoc, PIX and NVIDIA Nsight.

Transfer sculpted detail onto new topology

Project All is a ZBrush command, found in the SubTool palette under Project, that transfers sculpted detail from one SubTool to another that has a similar shape. It is the standard step after retopology: ZRemesher builds a clean mesh, you subdivide it and project the detail from a copy of the original sculpt onto it, so the new topology carries the old detail. The Dist setting controls how far ZBrush searches for the surface.

How a texture is mapped onto the model

Projection modes in Substance Painter decide how a texture or material is mapped onto the model. UV projection follows the UV layout, Tri-planar projects from three directions and blends them, which hides seams and stretching on organic shapes, and Planar, Spherical and Cylindrical projections project the texture from a single shape. Each fill layer and each stamp can use its own mode, set in the layer's properties.

Soft selection that moves nearby geometry

Proportional editing is a Blender mode in which moving, rotating or scaling a selection also affects nearby geometry, with the effect fading with distance. Press O to toggle it, and scroll the mouse wheel while transforming to change the radius. The falloff, such as Smooth, Sphere or Linear, sets how the influence drops. It is how you pull a soft hill from a flat plane, adjust organic shapes and refine forms without selecting every vertex.

Four-sided polygon

A quad is a polygon with exactly four vertices, the preferred building block for clean 3D topology. Quads subdivide predictably, deform cleanly under skinning, and let edge loops flow naturally around a form. Although game engines render triangles, the source mesh is built in quads and only triangulated at export.

Maya's retopology tool

Quad Draw is Maya's retopology tool, part of the Modeling Toolkit. You make a high-poly mesh live, so it acts as a surface to draw on, and then place vertices on it and create quads by clicking, with the new mesh snapping to the live surface. It gives full control over the edge flow of a clean, low-poly mesh built over a sculpt or scan, and has tools to relax, extrude and weld the new topology.

Physics-driven body for falls and knockdowns

A ragdoll is a character whose bones are driven by physics instead of animation, so the body falls, collapses and reacts to forces in a natural way. Each bone gets a simple collision shape and joint limits that connect it to the next, and the engine simulates them. In Unreal Engine this setup is the Physics Asset, and Unity has Ragdoll Wizard and joints. Ragdolls are used for deaths, knockdowns and hit reactions, and can blend with animation for partial effects.

How real-time engines draw triangles

Rasterization is the method that real-time engines use to draw 3D scenes. Each triangle is projected onto the screen, the pixels it covers are found, and a shader colors each one. It is extremely fast and runs well on GPUs, which is why games use it, but it does not naturally simulate light, so shadows, reflections and global illumination are done with extra techniques such as shadow maps and probes. Ray tracing is the main alternative.

Simulating light by tracing rays

Ray tracing renders images by following rays of light through a scene, to find what they hit and how light bounces between surfaces. It produces accurate reflections, refraction, soft shadows and global illumination that rasterization can only approximate. Recent graphics cards have hardware to speed it up, and games use it for selected effects, often in a hybrid with rasterization, while offline renderers use it for the whole image.

Pre-captured cubemap for local reflections

A reflection probe captures a cubemap snapshot of the environment at a specific point in a level, used to drive reflections on nearby surfaces. Before ray-traced or screen-space reflections, probes were the only way to give real-time materials accurate reflections of their surroundings — and even now they remain the cheap fallback for off-screen reflections. UE5 Lumen still uses probe data for distant indirect reflections.

Separate layers of a render for compositing

Render passes, also called AOVs, are separate images saved from a single render, each containing one part of the result: diffuse, specular, reflection, ambient occlusion, depth, normals, object ID and more. Saved together, usually in a multilayer EXR file, they let you adjust and combine the parts in compositing without rendering again, for example to strengthen reflections, relight an object or add depth of field afterward.

How a frame is drawn

A render pipeline is the sequence of steps an engine takes to turn scene data (meshes, materials, lights) into a final frame on screen. Modern engines ship with different pipelines tuned for different trade-offs: Unity has URP, HDRP, and Built-in; Unreal has Forward and Deferred. The pipeline choice constrains which features (post-processing, lighting models, shading complexity) are available and how cheaply they render — switching pipelines mid-project is usually painful, so it is decided at project start.

Rebuilding a clean mesh over a sculpt

Retopology is the process of building a new, clean, low-polygon mesh on top of a dense high-poly sculpt. The result is a model with consistent quad-based topology suitable for animation, UV unwrapping, and game-engine import. Retopology is the bridge between sculpting (where polycount is irrelevant) and production (where every triangle counts).

Strips that follow a moving point

Ribbons and trails are strips of geometry that follow a moving point, used for sword swipes, projectile tails, magic streaks, speed lines and wind. A ribbon connects the positions of a particle or an object over time into a camera-facing strip with a texture, and fades out along its length. Niagara has a Ribbon renderer, and Unity has the Trail Renderer and the Trails module of the Particle System. They look much smoother than a series of separate sprites.

Building a deformation skeleton

Rigging is the process of building the skeleton and control system that animators use to pose and animate a character. A rig consists of bones, controllers (NURBS curves shaped for ease of selection), constraints (IK/FK chains, parent constraints), and often a custom UI. Production rigs are surprisingly complex — a typical AAA character rig has 200–500 bones and 50–100 controllers.

Blender's built-in rig generator add-on

Rigify is a Blender add-on that generates a complete control rig from a simple template called a Meta-Rig. You fit the Meta-Rig to your character, press Generate, and Rigify builds a rig with IK and FK, spine and finger controls and a facial setup. It ships with Blender but is switched off by default, and must be enabled in Preferences > Add-ons. It saves hours compared with building a rig by hand.

Movement driven by the animation, not the controller

Root motion drives a character’s world-space position and rotation from the root bone’s baked translation in an animation clip, rather than from a separate movement controller. It is the gold standard for melee combat, climbing, and mocap-driven locomotion where the animation needs to land exactly where it should. The trade-off is responsiveness: tightly-tuned shooter movement usually drives the controller directly and discards root motion.

Surface microfacet detail

A roughness map is a grayscale texture controlling how rough or smooth each pixel of a surface appears to light. Black (0) is mirror-smooth (sharp reflections), white (1) is matte (diffuse, blurred reflections). It is arguably the most important PBR channel for selling material identity — wood, metal, wet vs dry surfaces, finish quality.

TGA and PNG with transparency

To save transparency from Photoshop for a game engine, keep the alpha in an alpha channel in the Channels panel or as a transparent layer, then export as TGA with 32 bits per pixel or as PNG with transparency. Both keep the alpha, which engines read as opacity or as a mask. If the edges show dark halos, extend the color beyond the alpha edge before saving, since engines blend the color behind the transparent pixels.

Parametric Substance material file

An SBSAR is a published Substance file, a compiled version of a Substance Designer graph that keeps its exposed parameters. It generates texture maps on demand, so you can change values such as color, wear, scale and pattern without opening the graph. SBSARs are used in Substance Painter, in Substance Designer and in engines and tools with Substance support, and Adobe's Substance 3D Assets library is delivered in this format.

Props and buildings feel too big or too small

Scale looks wrong when assets are built without a common reference, so doors, furniture and props do not match the size of the player character. Build to real-world units, with a standard such as one Unreal unit equal to one centimeter and one Unity unit equal to one meter, import a player-sized reference mannequin into every scene, and check key dimensions such as door height around 2 meters, steps around 15 to 18 centimeters and a chair seat about 45 centimeters.

Auto exposure changes the whole look

A scene looks too dark or too bright when auto exposure keeps changing the camera's brightness to match what it sees. To lock it in Unreal Engine, add a Post Process Volume, set it to Infinite Extent, and in Exposure set Min EV100 and Max EV100 to the same value, or use Manual metering and adjust Exposure Compensation. In Unity, add an Exposure override to a Volume and set it to Fixed. Then adjust the lighting to look right.

Soft, noisy forms without clear planes

A sculpt looks lumpy or mushy when detail is added before the large forms and planes are clear. Go back to low subdivision, block the primary forms, then define the planes, the flat facets where one form turns into the next, and sharpen the edges between them before moving to smaller detail. Check the silhouette from several angles, avoid over-smoothing, and work at the resolution the form needs, not the highest one.

Make an image tile without visible seams

To make a texture seamless in Photoshop, use Filter > Other > Offset with half the image size and Wrap Around. The edges now meet in the middle of the image, where you can fix the visible seams with the Clone Stamp or Healing Brush. Offset again to check that no seams remain, and use View > Pattern Preview to see the image tiling.

Engine tools for cinematics and scripted scenes

Sequencer in Unreal Engine and Timeline in Unity are the engines' tools for building cinematics, cutscenes and scripted moments. They are non-linear editors with tracks for cameras, characters, animation, audio, lights, effects and any property, arranged along a time axis, so artists can choreograph a scene directly in the game's real-time lighting and assets. Cameras are cut and animated with the help of Cinemachine in Unity and Cine Camera Actors in Unreal Engine.

Placing props to make a space feel lived in

Set dressing is the process of placing props, debris, clutter and details in an environment to make it feel real, lived in and a part of a story. After the architecture and the main layout are built, artists add objects such as furniture, boxes, plants, cables and signs, taking care of how they would naturally be placed and used. Good set dressing tells the story of the space, guides the player's eye and adds believable variety, without hiding the gameplay path.

Link one attribute to another in a rig

Set Driven Key is a Maya tool that links one attribute, the driver, to another, the driven, using a curve. When the driver changes, the driven attribute follows according to the keyed relationship. It is used throughout rigging: a finger curl control bends all three finger joints, an elbow angle triggers a corrective blend shape, and a slider moves a facial expression. It is found in the Animate menu.

Move the pivot point of an object

To change an object's origin, which is its pivot point, in Blender, select it in Object Mode and use Object > Set Origin. Origin to Geometry centers it on the mesh, Origin to 3D Cursor puts it where the cursor is, and Geometry to Origin moves the mesh instead. To put it at a custom spot, place the 3D cursor there first and then choose Origin to 3D Cursor.

Dark patches after Shade Smooth and missing Auto Smooth

Dark patches or odd gradients after Shade Smooth appear because smooth shading averages normals across edges that should stay sharp. In Blender 4.1 and later, Auto Smooth was replaced by the Smooth by Angle modifier: choose Object > Shade Auto Smooth, set an angle such as 30 to 60 degrees, and sharp edges stay crisp. Older versions have an Auto Smooth checkbox in Object Data properties.

Hitches the first time an effect or material appears

Shader compilation stutter is a freeze or hitch the first time a material, effect or mesh appears, because the engine compiles its shader or pipeline state while the game runs. The fix is to compile earlier: precache or warm up shaders during loading, reduce the number of shader variants and unique materials, and make sure the engine's pipeline state caching is enabled. Once a shader has been compiled and cached, the hitch should not return.

Viewport view of per-pixel material cost

Shader Complexity is an Unreal Engine view mode that colors each pixel by the cost of the material shading it, running from green for cheap through red to white for very expensive. It helps artists find materials that are too heavy and stacked translucent surfaces that cost more because several layers are shaded per pixel. You open it from the viewport's View Mode menu, under Optimization Viewmodes.

Visual shader authoring

A shader graph is a visual node-based interface for authoring shaders without writing HLSL or GLSL code. Each node represents an operation — sample a texture, multiply colours, calculate a Fresnel falloff — and connections form the shader's logic. Unreal Engine's Material Editor, Unity's Shader Graph, and Godot's VisualShader all share this pattern, making custom shading accessible to artists who don't code.

Compiled versions of one shader

A shader variant is one compiled version of a shader for a particular combination of keywords, such as fog on or off, shadows on or off, or normal map on or off. A single shader with many keywords can produce thousands of variants, which slows builds, increases build size and can cause hitches when a variant first compiles at runtime. Unity strips variants it can prove are unused, and you can reduce the rest yourself.

Striped shadows or shadows detached from objects

Shadow acne is a pattern of stripes or speckles on lit surfaces, and peter panning is a shadow that floats away from its object. Both come from the shadow bias. In Unity, adjust Depth Bias and Normal Bias on the light, or in the URP pipeline asset under Shadows: raise the bias a little to remove acne, and lower it if shadows detach.

Blender morph targets for facial expressions and correctives

Shape keys are Blender's version of blend shapes or morph targets: stored alternative positions of a mesh's vertices that can be blended with a slider from 0 to 1. A Basis key holds the original shape, and each further key, such as a smile, a blink or a muscle bulge, changes it. They are used for facial animation, corrective shapes next to joints and any shape change that bones cannot make. They export to engines as morph targets.

How basic shapes communicate personality

Shape language is the use of basic shapes to communicate meaning and personality in a design. Circles read as soft, friendly and safe, squares and rectangles as stable, strong and reliable, and triangles as sharp, dynamic or dangerous. Concept artists build characters, creatures, props and environments from a dominant shape with supporting ones, so a design can be understood at a glance. It is a core tool of stylized art, where clear shapes carry the design.

The readable outline of a shape

A silhouette is the outline of an object or character when filled with a single flat color. A strong silhouette is recognizable and unique even without detail, color or lighting, which matters in games where characters and props are seen small, at a distance and in motion. Stylized artists design the silhouette first and add detail afterwards, and a silhouette test is a standard check during concept and blockout.

Skinned mesh driven by a skeleton

A Skeletal Mesh is a mesh whose vertices are skinned to a skeleton, so bones can deform it. In Unreal Engine it is the asset type for characters, creatures and anything animated through bones, and it takes the SK_ prefix. It is bound to a Skeleton asset (SKEL_) that several meshes and animations can share, and it can carry morph targets, LODs, sockets and a Physics Asset for ragdoll and collision.

Hierarchical bone structure for animation

A skeleton is the hierarchical tree of bones that drives mesh deformation through skinning. Each bone has a parent (so moving the shoulder moves the elbow that moves the wrist), a local transform, and a list of vertices it influences. AAA character skeletons typically have 80-200 bones — main body, fingers, jaw, eyes, plus utility bones for tweak controls and twist correction.

Paint to correct skewed bake detail

A skew map is a map painted in Marmoset Toolbag that bends the direction of the baking rays in specific areas, fixing skewed or stretched detail on the baked normal map. It is used where the cage is not enough, for example on curved surfaces, where a high-poly detail is swept to one side or where a thin part leaves stretched lines. Skew painting is a Toolbag feature and one of its most loved for fixing bakes.

Subsurface scattering and specular for skin

Skin shading is the set of techniques used to make skin look alive in a renderer. Light enters the skin, scatters below the surface and comes out nearby, which softens shadows and gives the red glow of thin areas such as ears and nostrils, and this is called subsurface scattering. A skin shader also has a soft, double-lobed specular for the oily layer, varied roughness, and detail maps for pores. Unreal Engine offers the Subsurface Profile shading model, and Unity's HDRP uses diffusion profiles.

Binding a mesh to a skeleton

Skinning is the process of binding a mesh to a rig so that moving the skeleton deforms the mesh. Each vertex receives weights — fractional influences from one or more bones — controlling how it follows their motion. Quality skinning is invisible: a character bends, twists, and stretches naturally. Bad skinning produces collapsing joints, candy-wrapper twists, and shoulder pops.

Physically based sky and sunlight

A sky atmosphere is a physically based model of the sky that calculates how sunlight scatters through the air, giving realistic blue skies, red sunsets and haze toward the horizon. In Unreal Engine the Sky Atmosphere component works with a Directional Light as the sun and a Sky Light that lights the scene from the sky. The sky changes with the sun's direction, so a time of day can be set by rotating the sun. Unity HDRP offers a Physically Based Sky.

Mask presets driven by baked mesh maps

A smart mask is a saved mask setup in Substance Painter that builds a layer mask from a model's baked mesh maps, such as curvature, ambient occlusion and position. Applied to a layer, it produces effects like edge wear, dirt in crevices, dust on top surfaces or leaks, and the result adapts to each model's shape. A smart mask works on one layer's mask, whereas a smart material is a whole layer stack.

Procedural multi-layer material

A smart material in Substance Painter is a pre-built layer stack with mask generators that automatically adapts to the geometry of any mesh — dust settles in cavities, paint chips on edges, oxidation grows on metal. Drag a smart material onto a model and you get a believable PBR result in seconds because the masks read curvature, AO, and worldspace data baked from the model.

Wear and dirt missing after dropping on another asset

A smart material looks different on a new model because it reads that model's own baked mesh maps. If the new model has not been baked, the edge wear, dirt and dust that depend on curvature and ambient occlusion are missing or flat. Bake the mesh maps for the new Texture Set first, then adjust the generator and filter settings to suit the size and shape of the new model.

Maya's skinning command

Smooth Bind is the Maya command, found in the Skin menu, that attaches a mesh to a skeleton so its vertices follow the joints. It creates a skin cluster with weights that decide how strongly each joint moves each vertex, and the weights are refined with the Paint Skin Weights tool. Options such as Max Influences limit how many joints can affect a vertex, which matters for game export, where four is a common limit.

Per-face shading split

Smoothing groups (called "hard edges" in Maya/Blender) control which faces of a mesh share averaged vertex normals — making them shade smoothly — versus which faces produce a sharp lighting break. They are the single most important per-vertex attribute beyond position and UV: identical geometry with different smoothing settings will look like two completely different surfaces under lighting. Always set hard edges along UV seams to avoid baking errors.

Named attachment point on a mesh or bone

A socket is a named attachment point on a mesh or a bone, used to attach other objects such as weapons, hats, torches or effects. A socket on a Skeletal Mesh follows the bone it is attached to, so a sword stays in the hand through the whole animation. You can set an offset and rotation per socket, and give the same name on different characters so one item attaches to all of them.

Adds thickness to a surface

The Solidify modifier gives a surface thickness by extruding it along its normals and closing the edges. It turns planes and open shells into solid objects, such as walls, cloth, armor plates, leaves and paper. Thickness sets how thick it is, Offset sets the direction relative to the original surface, and Even Thickness keeps the width consistent on curved parts. A negative thickness makes it grow inward.

Software for creating game-ready trees and plants

SpeedTree is specialized software for creating trees, plants and other vegetation for games and film. It builds trees procedurally from generators for the trunk, branches, leaves and roots, with controls for shape and variation, and it outputs game-ready meshes with LODs, billboards, textures and wind animation. It has been used in many games and integrates with engines such as Unreal Engine and Unity, which makes it a standard for realistic vegetation.

Colour-space encoding for textures

sRGB is the gamma-corrected colour space monitors display in; linear is the colour space in which lighting math is correct. Albedo and other colour-data textures store values in sRGB; normal, roughness, metalness, masks, and data textures must be flagged as linear because they store numeric values, not colour. Tagging a normal map as sRGB silently corrupts every bump on every surface — one of the most common beginner texturing bugs.

Cheaper draw calls in URP and HDRP

The SRP Batcher is a rendering feature of Unity's Scriptable Render Pipelines (URP and HDRP) that cuts the CPU cost of draw calls. It keeps material data in GPU memory and draws objects that use the same shader variant one after another without resetting state for each material. It does not reduce the number of draw calls, but it makes each one cheaper, so scenes with many materials render faster.

Screen-space ambient occlusion

SSAO approximates ambient occlusion (the soft contact darkening in crevices and corners) by sampling the depth buffer at runtime, rather than baking it into textures. Variants like HBAO and GTAO improve quality. SSAO grounds objects and adds perceived depth almost for free — every modern engine ships some flavor of it. It cannot replace baked AO on hero assets, but it covers everything dynamic that baking misses.

Screen-space reflections

SSR (Screen-Space Reflections) computes glossy reflections by ray-marching the depth buffer in screen space. It is fast and handles dynamic geometry without preprocessing, but it can only reflect what is already on screen — anything outside the camera or behind another object falls back to reflection probes or cubemaps. SSR is the standard for wet floors, puddles, and polished surfaces in modern titles.

Combine non-moving meshes to cut draw calls

Static batching is a Unity optimization that combines the meshes of objects that never move into larger batches at build time, so the GPU draws them in fewer draw calls. You enable it by marking objects Batching Static. It uses more memory because the combined geometry is stored, and it only works for objects that share a material. Dynamic batching does a similar thing at runtime for very small meshes and is rarely useful today.

Non-deforming geometry asset in Unreal Engine

A Static Mesh is Unreal Engine's asset type for geometry that does not deform: props, architecture, rocks, modular kit pieces and most foliage. It stores vertices, UVs, material slots, collision and LODs, and it renders more cheaply than a Skeletal Mesh because nothing is skinned. With no bones, it can only move, rotate and scale as a whole. Epic's recommended naming gives it the SM_ prefix.

Smeared or elongated texture detail

A texture looks stretched when the UVs on that part of the model are larger or smaller than the surface they cover, or when the mesh is scaled non-uniformly after UV mapping. The fix is to give the UVs an even texel density, check them against a checker pattern and remove non-uniform scale. For rocks, cliffs and terrain, world-aligned or triplanar texturing avoids stretching without perfect UVs.

PBR with cartoon art direction

Stylized PBR is the modern compromise between fully hand-painted texturing (WoW-style) and full photoreal PBR. It uses real PBR channels (roughness, metalness, normal) but treats them stylistically — exaggerated edge wear, simplified colour palettes, brush-stroke-like detail in normal maps. The result reads as stylized but reacts to dynamic lighting like a realistic game. Fortnite, Genshin Impact, Valorant, and Riot Forge titles all use this approach.

Exaggerated body and face ratios in stylized characters

Stylized proportions are deliberate exaggerations of the human body and face, such as large heads and eyes, small bodies, big hands and feet, or broad shoulders and thin legs, used to give characters a distinct personality and read clearly at game camera distances. Different styles follow different ratios: a heroic character can be eight or more heads tall, a typical stylized one four or five, and a chibi two or three. The key is to stay consistent across the whole cast.

Choosing a direction for your portfolio

Stylized and realistic are the two broad directions in game art, and studios hire for both. Stylized art relies on shape, color, simplified forms and hand-painted or simple textures, and is common in mobile, MMO, online and indie games. Realistic art uses physically based materials, scans and detailed anatomy, and is common in AAA and cinematic projects. Skills transfer between them, since both depend on strong fundamentals in form, value, color and composition.

Smooth mesh from a low-poly cage

Subdivision surface (SubD) is a modeling technique where a low-polygon "cage" mesh is mathematically smoothed by subdividing each face into four — repeatedly — to produce a high-resolution result. Each subdivision level quadruples polygon count: a 1000-tri cage becomes 16,000 tris at level 2, 256,000 at level 4. SubD is the foundation of hard-surface modeling because edge control comes from the cage, not from manually placed loops.

Smooths a low-poly mesh by adding geometry

The Subdivision Surface modifier smooths a mesh by splitting each face into smaller faces and rounding the shape, using the Catmull-Clark method. Low-poly meshes become smooth and organic, which is why it is the base of most character and product modeling. It has separate Levels Viewport and Render settings, so you can work with a light mesh and render with a smooth one. Ctrl+1 to Ctrl+5 add the modifier at that level.

The graph takes too long to update

A slow Substance Designer graph is usually computing at a resolution that is too high for the number of nodes. Lower the graph's output size to 512 or 256 while you build and raise it for the final export, and avoid very heavy nodes such as large blurs, many Tile Samplers and Pixel Processors at high resolution. Close the 3D view when you do not need it, and keep other GPU programs closed.

Visible seams when the material repeats

A Substance Designer graph stops tiling when a node cuts or fills the edges instead of wrapping them. Check each node that moves or transforms the image: on Transformation 2D, set the Tiling Mode to tile in both directions, and use nodes that tile correctly. Blur HQ and other edge-aware nodes are safe, but a crop, warp or noise with the wrong settings can break the seam. Find the node where the seam first appears by previewing the graph step by step.

Procedural material authoring in Substance Designer

A Substance graph is the node-based authoring format of Substance Designer — a fully procedural pipeline that produces parametric materials usable in any engine. Unlike Substance Painter (which paints on a specific mesh), Designer outputs reusable tileable materials with exposed parameters (color, roughness range, damage amount). The output .sbsar file can be plugged into Unreal or Unity at runtime, letting tech artists ship "one material, many variations."

Which preset, size and format to use

Use the engine's export preset in Substance Painter's Export Textures window: Unreal Engine 4 (Packed) for Unreal, and the Unity Universal Render Pipeline or HD Render Pipeline Metallic Standard preset for Unity. The preset decides which maps go into which files and which normal map format is used. Choose PNG or TGA at 8 bits for most assets, a size that matches the object on screen, and dilation padding so UV edges do not show seams.

Slow viewport and brush strokes while painting

Substance Painter lags when the texture resolution, viewport effects or layer stack are too heavy for the graphics card. Lower the Texture Set resolution to 1K or 2K while you paint and raise it at export, turn off heavy Display Settings such as ambient occlusion, subsurface scattering and bloom, and reduce the viewport resolution. Close other programs that use the GPU, and make sure Painter runs on your dedicated graphics card.

Light entering and bouncing inside a material

Subsurface scattering (SSS) simulates how light enters a translucent material — skin, wax, marble, leaves, milk — bounces around inside, and re-emerges at a slightly different point. It is what makes a hand backlit by sunlight glow reddish at the fingertips, or marble appear to have depth instead of just being a coloured surface. Real-time SSS is expensive but essential for believable skin shading in characters.

Separate mesh inside a ZBrush project

A SubTool is one separate mesh inside a ZBrush tool, listed in the SubTool palette. A character, for example, can be a body, a head, eyes, armor pieces and clothes, each its own SubTool with its own polygon count and subdivision levels. You can show or hide, duplicate, mirror, merge and split SubTools, and sculpt on only the selected one, which keeps the project organized and the polygon load manageable.

Neutral poses for modeling and rigging

A T-pose has the arms stretched straight out to the sides, and an A-pose has them lowered about 45 degrees, forming an A shape. Both are neutral poses used to model, rig and skin characters, because they keep the limbs apart and make it easy to weight and mirror. The T-pose is the traditional choice and is required by some tools, such as Mixamo and some retargeting setups, while the A-pose is closer to a natural stance and reduces shoulder deformation problems.

Temporal anti-aliasing

TAA (Temporal Anti-Aliasing) jitters the camera each frame and blends the result with the previous frame using motion vectors, accumulating sub-pixel detail over time. It handles both edge and shader aliasing cheaply, which is why it is the default AA in modern AAA titles. The trade-off is ghosting on fast motion and slight blurring of static images — usually mitigated with sharpening passes.

Smearing trails and soft images from temporal anti-aliasing

TAA ghosting and blur come from temporal anti-aliasing blending the current frame with earlier ones, which smears moving or animated things that do not report their motion correctly. Make sure materials with vertex animation, such as foliage wind, output correct motion vectors, avoid very thin, high-contrast details, and raise the render resolution or use an upscaler such as TSR, DLSS or FSR. Switching to another anti-aliasing method is the quick test.

Local coordinate system for normal maps

Tangent space is a per-vertex local coordinate system used to interpret normal maps relative to the surface they're applied to. The texture's R channel maps to the surface tangent, G to bitangent, B to the actual surface normal. Tangent-space normals are the universal format for game engines because they survive UV mirroring, deformation, and animation — unlike object-space normals which break under any transform.

Tangent, bitangent, normal — the basis for normal maps

The TBN matrix is the per-vertex basis (tangent, bitangent, normal) that transforms a tangent-space normal map sample into world space. If the tangents your baker uses do not match the tangents the engine uses, normal maps render with subtle shading errors at the seams — the classic "looks fine in Painter, wrong in Unreal" problem. The fix is to bake with the same tangent basis your target engine reads, or use a synchronized baker.

Bridge between art and engineering

A technical artist is a specialist who connects artists and programmers, solving problems with shaders, tools, rigs and performance so that artwork works well in the engine. They write shaders and material systems, build Python or Blueprint tools, set up asset pipelines and optimize scenes. Technical art suits people who like both art and problem solving, and the role is in demand because few artists have the technical depth.

Grayscale image that defines terrain elevation

A terrain heightmap is a grayscale image in which each pixel's brightness stores the height of the terrain at that point, usually in 16 bits so that smooth slopes do not show steps. Game engines turn it into a landscape mesh, and tools such as Gaea, World Machine and Houdini heightfields generate and erode heightmaps with realistic mountains and valleys. Unreal Engine landscapes use specific resolutions, such as 1009 by 1009, 2017 by 2017 and 4033 by 4033 pixels.

Subdivide geometry on the GPU

Tessellation is the GPU stage that subdivides incoming triangles into denser geometry, usually driven by a displacement map and a camera-distance falloff. It lets a low-poly silhouette gain real depth at close range without paying for the polys far away. Tessellation has largely been displaced in production by Unreal’s Nanite (virtualized geometry) and by high-poly meshes streamed via LOD, but it still appears in terrain and water shaders.

Texture-to-surface ratio

Texel density is the number of texture pixels (texels) per unit of 3D surface area, usually measured in pixels per centimetre (px/cm). It defines how sharp or blurry a texture appears on a model relative to other objects in the scene. Consistent texel density across props is what makes a game scene feel cohesive — a wall at 10.24 px/cm next to a prop at 2.56 px/cm will read as a quality mismatch even with great art.

Multiple assets, one texture

A texture atlas is a single texture that contains the UV space of many separate objects packed together. Atlasing reduces draw calls (one material, many meshes) and is fundamental to optimising scenes with hundreds of small props — UI elements, modular debris, foliage cards, character accessories.

Which image format to use for game textures

TGA, PNG and EXR are the main image formats for game textures. TGA is simple and uncompressed or lightly compressed with alpha, long common in game pipelines. PNG is compressed without losing quality, stores alpha and is smaller on disk, with no quality difference. EXR holds 16 or 32 bit floating-point data, used for height maps and HDR images. JPEG is lossy and should not be used for source textures, since it adds artifacts.

How Unity processes an imported texture

Texture import settings are the options in Unity's texture inspector that control how an image is processed for the game. The key ones are Texture Type, such as Default, Normal map or Sprite, sRGB (Color Texture), Generate Mip Maps, Aniso Level, Filter Mode, Max Size and the compression format for each platform. They decide how much memory a texture uses and how sharp it looks, so wrong values are a common cause of blurry, dark or wrong-looking surfaces.

How much memory textures use

A texture memory budget is the amount of video memory a game can spend on textures, and each texture's cost depends on its size and format. A 4096 by 4096 texture uses about 64 MB uncompressed, about 16 MB with BC7 or BC3 compression and about 8 MB with BC1, and mipmaps add roughly a third more. Texture memory is often the largest part of an asset's cost, so resolution and compression decisions matter more than most polygon savings.

Color extended beyond UV island edges

Texture padding, also called dilation or bleed, extends an island's color a few pixels past its UV border so texture filtering and mipmaps do not pick up the empty background. Without padding you get dark or wrongly colored lines along UV edges and seams, especially at a distance. More padding is needed on higher-resolution textures and for objects seen from far away, because mipmaps shrink the texture and the padding with it.

One material's worth of textures in Painter

A texture set in Substance Painter is a group of textures for one material on a model, matching one material or material ID in the mesh you imported. Each set has its own resolution, mesh map bakes, layer stack and exported maps. A model with three materials becomes three texture sets, and settings such as resolution and baking are chosen per set.

Sparkling or crawling surfaces on far objects

Textures shimmer at a distance when very fine, high-contrast detail is sampled by too few pixels and the result changes from frame to frame. Make sure mipmaps are generated, set a higher anisotropic filtering level, use temporal anti-aliasing or an upscaler, and reduce high-frequency detail in the textures. Strong normal maps and sharp roughness details are the usual cause of sparkling highlights on distant surfaces.

Load only the mip you need

Texture streaming keeps high-resolution mips of a texture on disk and only loads the level of detail the camera currently needs into VRAM. It is what lets open-world games fit on a console: instead of holding every 4K texture resident, the engine streams smaller mips for distant or off-screen surfaces and promotes them when the camera gets close. The visible artifact is a brief blur when you turn a corner — usually a sign of bandwidth pressure or mis-tagged priorities.

Why the same maps shade differently

Textures rarely look identical in Unreal Engine and Substance Painter because lighting, tonemapping and material setup differ, but large differences usually come from four settings: the export preset, the sRGB flag, the normal map format and the packed map's channel order. Export with the Unreal Engine preset, turn sRGB off for the packed ORM texture, use a DirectX normal map and make sure the material reads the right channels.

Model arrives in the engine without its materials

Textures go missing after an FBX export because FBX does not carry Blender's node-based materials, only simple material slots and file references. Set Path Mode to Copy and click Embed Textures in the exporter, or simply re-create the materials in Unreal or Unity from the texture files. glTF/GLB handles the Principled BSDF much better and carries the textures with the model. Procedural textures must be baked to images first.

Foundations of believable motion

The twelve principles of animation are guidelines from Disney animators that make motion believable and appealing: squash and stretch, anticipation, staging, straight ahead and pose to pose, follow through and overlapping action, slow in and slow out, arcs, secondary action, timing, exaggeration, solid drawing and appeal. They apply to 2D, 3D and game animation, and are the base for evaluating almost any piece of character motion, from a walk to an attack.

How thick the object is at every point

A thickness map is a baked texture that records how thick an object is at each point, measured through its volume. It is used for subsurface scattering and translucency effects, where thin parts such as ears, leaves and candle wax let more light through, and for masks in Substance Painter that react to thin or thick areas. It is baked from the mesh, so it works best on a clean, closed model.

Key, fill and rim light setup

Three-point lighting is a classic setup of three lights that makes a subject read clearly. The key light is the strongest and sets the main direction and shadows, usually placed to one side and above the camera. The fill light is softer and on the opposite side, lifting the shadows so they are not too dark. The rim or back light sits behind the subject and traces its edges, separating it from the background.

Small, fast sketches for exploring ideas

A thumbnail sketch is a small, fast drawing, often only a couple of inches across, used to explore ideas before committing to a final piece. Concept artists draw many thumbnails of a composition, character or environment, in simple shapes and a few values, to test the layout, silhouette and mood quickly. Because they are small and rough, they are cheap to discard, and they show whether an idea reads before any detail is added.

Designer node that scatters patterns

The Tile Sampler is a Substance Designer node that scatters a pattern across an image with controls for position, size, rotation, randomness and color. It can arrange patterns in a grid, randomize their positions, and use several different patterns at once through its inputs. It is one of the most used nodes in Substance Designer, and is the basis of stones, pebbles, leaves, tiles, scratches and many other textures.

Repeats without visible seams

A tileable texture is an image whose opposite edges match, so it can repeat across a surface in a grid with no visible seam. Tileable textures cover large areas such as floors, walls, ground and fabric with one small image, which saves memory and texture space. The challenge is repetition: an obvious pattern, bright spot or unique mark shows up like a stamp as the texture tiles.

HDR → display-range remapping

Tonemapping is the final stage of the render pipeline that compresses the engine's internal high-dynamic-range (HDR) lighting calculations into the 0-1 colour range a display can actually show. Without tonemapping, bright lights would clip to pure white and dark areas to pure black. Different tonemappers (ACES, Reinhard, Filmic, AgX) produce different cinematic looks — choosing one is as much an art-direction call as a technical one.

Marmoset Toolbag's GPU ray-traced renderer

Toolbag's ray tracing is a GPU renderer in Marmoset Toolbag 4 that traces light rays for physically accurate reflections, shadows and global illumination. It gives results closer to an offline renderer than the real-time viewport, and works with the same materials and lighting as the rasterized mode. It needs a graphics card that supports ray tracing, and is used for portfolio renders, turntables and material previews of game assets.

How polygons flow across a mesh

Topology is the arrangement and flow of polygons on a 3D mesh. Good topology consists primarily of quads, with edge loops following the natural curvature of the form — for characters, this means loops around eyes, mouths, joints, and major muscle masses. Bad topology with triangles or n-gons in deforming areas causes pinching, twisting, and shading artefacts.

What the numbers in a polycount mean

Polygons, triangles and vertices are three different ways to count a mesh. Artists often count polygons, usually quads, while the GPU draws only triangles, and each quad becomes two. Engines report triangle counts, and the real cost also depends on vertices. A vertex is duplicated wherever there is a UV seam, a hard edge or a material split, so a mesh usually has more vertices in the engine than in the modeling tool.

Quads → triangles for the GPU

Triangulation is the process of converting a quad-based mesh into all triangles, since GPUs render only triangles natively. Most DCC tools triangulate automatically at export, but the chosen diagonal direction (which way each quad splits) affects shading — particularly on bent or twisted geometry where the wrong diagonal creates pinching. Manual triangulation gives the artist control, especially around character joints where automatic splits often deform incorrectly.

Reusable horizontal strips of detail

A trim sheet is a special atlas containing horizontal strips of repeating material detail — moldings, panels, fabric edges, screws — that can be wrapped along arbitrary 3D geometry by aligning UVs to specific rows of the sheet. One trim sheet often textures an entire building exterior or vehicle, dramatically reducing unique texture work for modular environment art.

UV-free projection from three axes

Triplanar mapping samples a texture three times — once from each world axis — and blends the results based on the surface normal. It bypasses UVs entirely, which makes it perfect for procedural terrain, large rock formations, and any geometry too complex (or too modular) to unwrap cleanly. The cost is three texture samples per layer instead of one, so it is reserved for surfaces where uniform texel density matters more than that cost.

Rotating presentation of an asset

A turntable render is a video or animation of a 3D asset rotating a full turn on a neutral base, used to present a model in portfolios and on sites such as ArtStation. It shows the form from all sides, the quality of the texturing and the materials under controlled lighting. Typical turntables show the textured model and often the clay or wireframe versions, in a few seconds of looping video.

Show a surface from both sides

To make a mesh visible from both sides in Unreal Engine, open its material, click the main material node and tick Two Sided in the Details panel. By default Unreal draws only the front of each face, so a plane, a leaf card or a single-sided wall disappears when you look at its back. Two Sided makes the engine render the back faces too, using the same material.

Show a surface from both sides in URP and HDRP

To make a surface visible from both sides in Unity URP, open the material and set Render Face to Both in Surface Options. By default Unity culls back faces, so a plane, leaf card or single-sided wall vanishes when you look at its back. In a Shader Graph material, set Render Face to Both in the Graph Settings of the Graph Inspector; in HDRP use Double-Sided in the material's Surface Options.

Multi-tile UV layout

UDIM is a multi-tile UV layout standard where each "tile" is a separate texture file numbered 1001, 1002, 1003 and so on. Instead of cramming an entire character's UVs into one 4K texture, UDIM lets the artist split the head onto 1001 (its own 4K), the torso onto 1002, hands onto 1003 — increasing effective resolution without pushing one texture beyond practical sizes. Used heavily in film and high-end game character pipelines.

Slow viewport while working in the editor

A slow Unreal Engine editor viewport is usually fixed by lowering the quality the editor renders at. Open Settings > Engine Scalability Settings and choose a lower level, reduce the viewport's screen percentage, and turn off Realtime in the viewport when you are not testing lighting or animation. Switching Lumen and Virtual Shadow Maps down in the project or using a simpler view mode also helps a lot on mid-range graphics cards.

Unity’s Universal Render Pipeline

URP (Universal Render Pipeline) is Unity’s scalable, forward-renderer-based pipeline designed to run from mobile to mid-spec PC and console. It trades some high-end features (volumetrics, screen-space reflections, complex lighting models) for predictable performance and a wide platform reach. URP is the default choice for stylized 3D games, VR titles, and anything targeting weaker hardware.

Unity's default PBR shader for URP

The URP Lit shader is the standard PBR shader of Unity's Universal Render Pipeline. It reads base color, metallic, smoothness, normal, occlusion and emission maps, and supports transparency, alpha clipping and detail maps. URP also includes cheaper shaders for other needs: Simple Lit for non-PBR lighting, Baked Lit for static lighting only and Unlit for flat color. Lit is the right choice for most realistic and stylized objects.

Scene description format for pipelines

USD, Universal Scene Description, is an open-source scene description format developed at Pixar and now known as OpenUSD. It describes whole scenes rather than single models, with layers and references that let many artists work on the same shot or level without overwriting each other's work. USD is standard in film and animation and is spreading into game and real-time pipelines through tools such as Houdini, Maya and Blender and engine integrations such as Unreal's USD support.

Unwrapping 3D meshes to 2D

UV mapping is the process of flattening a 3D mesh into a 2D layout so that a texture can be applied to it. The "U" and "V" axes refer to coordinates on the texture plane (since X, Y, Z are taken by 3D space). Every vertex of a 3D model receives a UV coordinate that tells the renderer which pixel of the texture maps to that point on the surface.

Scrolling a texture over time

UV panning moves a texture's coordinates over time, so the texture appears to scroll across the surface. It is one of the simplest and most used VFX techniques, giving motion to water, lava, energy beams, conveyor belts, clouds, waterfalls and force fields. In Unreal Engine, the Panner node does it, and in Unity Shader Graph, a Tiling and Offset node driven by Time. Combining several layers at different speeds creates depth and complexity.

Where a UV island is cut

A UV seam is the edge where a UV island is cut so a 3D surface can lay flat, and visible texture seams appear when the textures on each side of that edge do not match. The usual causes are too little texture padding, different texel density on neighbouring islands, and a mismatch between smoothing and UV splits. Hide seams along hard edges or out of sight, keep texel density equal, and use enough padding.

The UV Editor is empty

The Blender UV Editor only shows the UVs of faces that are selected in Edit Mode. Press Tab to enter Edit Mode, press A to select everything, and the UV islands appear. If you want the editor to show UVs regardless of the selection, enable UV Sync Selection in the editor header. Make sure the object actually has a UV map in Object Data properties.

Planning lights and darks before color

Value structure is the arrangement of lights and darks in an image, independent of color. A strong value structure uses a few large value masses, typically three to five, to make the image read clearly, and the eye goes first to the strongest contrast. Concept artists work out values in grayscale before adding color, because color can only support a design whose values already work, and because games are often viewed small, where values carry the readability.

The two main GPU programs in every material

A shader is a small program that runs on the GPU. The vertex shader runs once for every vertex of a mesh and decides where it appears on the screen, so it handles transformations, skinning and effects like wind. The pixel shader, or fragment shader, runs for every pixel the mesh covers and decides its final color, using textures, lighting and material settings. Compute shaders run general calculations outside the drawing process.

Simulation baked into textures

A vertex animation texture, or VAT, stores the movement of a mesh's vertices over time in textures, which a vertex shader reads to play the animation. It lets complex simulations, such as destruction, cloth, fluids, soft bodies and morphs, run in real time on the GPU without a skeleton. Houdini provides tools that bake a simulation into position and normal textures and a matching mesh, and engines such as Unreal Engine and Unity play them with a material.

Per-vertex paintable mask channel

Vertex color is per-vertex RGBA data painted directly onto a mesh and used as a mask channel in shaders — typically to blend between two materials (R = sand, G = grass, B = stone) on terrain or modular kit pieces. It costs nothing in memory beyond the mesh itself and lets level artists hand-blend texture variation without authoring new textures. The classic use case is terrain painting in UE5.

Named sets of vertices with weights

A vertex group is a named set of vertices in Blender, where each vertex has a weight from 0 to 1. Vertex groups are used for many things: bone influence in an Armature, limiting a modifier or shape key to part of a mesh, controlling hair, masking, and driving materials. When you parent a mesh to an armature with Automatic Weights, Blender creates one vertex group per bone and fills it with weights.

Painting blend masks directly on mesh vertices

Vertex painting stores color values on a mesh's vertices and uses them in the material as blend masks. It lets artists paint where a second material, such as moss, dirt, damage or wet, appears on a model, without extra texture memory or unique UVs, and every instance of an asset can have its own pattern. It is used for blending materials on modular walls and rocks, and for driving effects such as wind on foliage. Unreal Engine has Mesh Paint mode, and Blender and Maya can paint vertex colors.

Houdini's fast expression language

VEX is the scripting language of Houdini, used to read and change geometry attributes quickly and in parallel. Most often it is written in an Attribute Wrangle node, where short snippets of code control point positions, colors, normals and any custom attribute across thousands or millions of points at once. It is similar to the C language, runs multi-threaded and is the fastest way to write custom logic in Houdini.

Unity's GPU node-based particle system

The Visual Effect Graph, or VFX Graph, is Unity's node-based tool for building particle effects that simulate on the GPU. It can handle millions of particles, and its graph lets artists spawn, shape and render particles with a clear flow of contexts such as Spawn, Initialize, Update and Output. It works with URP and HDRP and needs a platform with compute shader support. The older Particle System, also called Shuriken, simulates on the CPU.

The rhythm that makes an effect feel right

VFX timing is the rhythm of an effect, usually split into anticipation, impact and dissipation. Anticipation is the short buildup that tells the player something is about to happen, impact is the sharp, bright peak that sells the hit or burst, and dissipation is the fade as the energy dies away. A strong effect has a very fast, clear impact and a clean exit. Timing, more than detail, decides whether an effect feels powerful and readable in a game.

High-resolution shadows in Unreal Engine 5

Virtual Shadow Maps (VSM) are Unreal Engine 5's shadow technique, designed to work with Nanite and Lumen. Each light gets a very high-resolution virtual shadow map, but only the pages visible on screen are rendered and cached, which gives sharp, consistent shadows without hand-tuning cascade settings. They give film-like contact shadows on detailed geometry, at a cost that rises with scene complexity.

Stream only the visible tiles of a texture

Virtual texturing splits a very large texture into small tiles and keeps only the tiles that are visible in memory, instead of loading whole mip chains. Unreal Engine has two systems: Streaming Virtual Texturing (SVT), where cooked texel data is loaded from disk, and Runtime Virtual Texturing (RVT), where the GPU generates texel data at runtime. SVT suits large artist-made textures and UDIM sets; RVT suits procedural or layered material output such as Landscape blending.

Unity post-processing and lighting overrides

A Volume is a Unity component that applies post-processing and rendering settings, such as Bloom, Color Adjustments, Tonemapping, Vignette and Depth of Field, to a camera. A Global Volume affects the whole scene, and a local Volume with a collider blends in when the camera enters it. The settings live in a Volume Profile asset, and volumes with a higher priority override lower ones. URP and HDRP both use this system.

Light scattered through a participating medium

Volumetric lighting renders the visible interaction of light with air, fog, smoke, or dust — the "god rays" streaming through cathedral windows or fog headlights cutting through night air. Modern engines compute this via ray-marched volumetric integration through a 3D fog texture or analytical density function. Cinematic UE5 scenes lean heavily on volumetric fog to add atmosphere and depth cues.

Rebuilds a sculpt with even polygons

Voxel Remesh rebuilds a sculpted mesh into evenly sized quad-based polygons, which gives uniform detail and removes stretched or overlapping geometry. In Blender's Sculpt Mode you set a Voxel Size and press Remesh or Ctrl+R, and a smaller voxel size gives more polygons and more detail. It is a quick way to start a sculpt from a rough base and to repair a mesh after heavy stretching.

Why VR needs higher frame rates and simpler art

A VR performance budget is tighter than a flat-screen game because the scene is drawn twice, once for each eye, at a high, stable frame rate, such as 72 to 120 frames per second depending on the headset, which leaves around 8 to 14 milliseconds per frame. Dropped frames cause discomfort, so VR projects keep geometry and materials light, bake lighting, favor MSAA and avoid heavy post-processing. Standalone headsets, based on mobile chips, have much stricter limits than PC VR.

The looping base of character locomotion

A walk cycle is a looping animation of a character walking, built from a few key poses: contact, where the front heel touches the ground, down, where the weight sinks, passing, where the legs cross, and up, where the body rises, repeated for each leg. A run cycle follows the same idea with a moment where both feet are off the ground. Cycles must loop seamlessly, and in games they form the base of locomotion that blends with idle, turn and stop animations.

Scene looks too bright, flat or too dark

Colors look washed out or too dark in Unity when the project color space and the texture settings do not agree. Set Edit > Project Settings > Player > Other Settings > Color Space to Linear, keep sRGB on for color textures such as base color, and switch it off for data textures such as normal, roughness, metallic and masks. Mixed settings shift every value in the material.

Painting how bones move vertices

Weight painting is the process of painting how strongly each bone influences each vertex of a skinned mesh, with values from 0 to 1. Where a vertex is fully influenced by one bone it moves with it, and where two bones overlap it blends between them, which is what makes elbows, shoulders and knees bend smoothly. The weights for a vertex add up to 1, and game engines limit how many bones can influence one vertex, commonly four.

Smooth shading that keeps crisp edges

Weighted normals is a shading technique that weights each vertex normal by the area or angle of the faces around it, so large flat faces stay smooth while small bevels keep crisp edges. It removes the shading errors that smooth normals cause on hard-surface models and lets you use fewer supporting edges. It is a standard step for game-ready hard-surface props, and in Blender it is done with the Weighted Normal modifier.

Edge-only mesh view

A wireframe is the edge-only representation of a 3D mesh, showing every polygon edge against a transparent or solid background. Wireframe renders are standard portfolio practice — they prove that a model has clean, professional topology underneath the textured surface. A pretty render with secretly messy topology fails immediately when a hiring manager asks for the wireframe view.

Unreal Engine 5 large-world streaming

World Partition is Unreal Engine 5's system for building large worlds in a single level. It divides the map into a grid of cells and streams them in and out by distance from the player, so you do not have to split the map into sublevels by hand. It also saves each actor as its own file, which lets several people work on the same area at once, and it replaces the older World Composition workflow.

Move vertices from the material

World Position Offset (WPO) is an Unreal Engine material output that moves each vertex of a mesh in world space at render time. It drives foliage wind, waving flags, grass bending, simple vertex animation and effects such as raised snow or pulsing surfaces, all without a skeleton. Because the offset is computed in the vertex shader, it changes how the mesh looks but not its collision or its stored bounds.

Normals baked in world coordinates

A world space normal map stores the direction each surface faces in world coordinates, instead of relative to the surface like a tangent-space normal map. It is baked as a mesh map in Substance Painter and is used for masks rather than final textures: it tells generators which surfaces face up, down or to the side. That is what makes effects like dust settling on top surfaces, moss on one side or snow possible.

Shimmering caused by coplanar surfaces

Z-fighting is the flickering pattern that appears when two surfaces sit at almost the same depth and the depth buffer cannot decide which one is closer. The fix is artistic, not technical: separate the surfaces by a small offset, use decals on a polygon offset, or push detail into the base material. In stylized art it can wreck a clean line; in environments it shows up most often on stacked floor tiles or coplanar trim.

Cannot add or lose subdivision levels

ZBrush cannot add subdivision levels while DynaMesh is switched on, so turn DynaMesh off before pressing Divide in the Geometry palette. Subdivision levels also disappear when the topology is rebuilt: DynaMesh and ZRemesher replace the mesh and remove the old levels. To get levels back, run ZRemesher on the mesh, then press Divide to build new levels, and use Project All to bring the detail from a copy.

Inverted or odd shading on a ZBrush normal map

A ZBrush normal map looks inverted when its green channel does not match the target engine. In Tool > Normal Map, use Flip G to reverse the green channel, and Flip R or Switch RG if other channels are wrong, then create the map again and test it in the engine. Unreal Engine expects DirectX-style normals and Unity expects OpenGL-style, so choose the setting that matches. Also turn on Tangent so the map works on animated models.

Strokes do nothing on the model

If strokes do nothing in ZBrush, you are probably not in Edit Mode or the tool is still a primitive. Select a tool, drag it on the canvas to draw it, then press T or click Edit to enter Edit Mode, and sculpt on it. Primitives such as a sphere need Make PolyMesh3D before they can be sculpted. Also check that Draw mode is on, and that Zadd is selected instead of Zsub.

Color is painted but the model stays grey

Polypaint does not show in ZBrush when painting is not turned on or the model is not set to display it. Turn on Rgb in the Draw palette, or Mrgb, before you paint, and make sure Colorize is switched on in Tool > Polypaint so the model displays its colors. If the color still looks wrong, the material may be overriding it, so try a simple material such as Flat Color or the default one.

Turn painted vertex color into a texture map

To turn polypaint into a texture map in ZBrush, the model needs clean UVs, made with UV Master or in your 3D tool. Then go to Tool > Texture Map, create a new texture at the size you want, and use Col>Txtr in the Polypaint palette to convert the polypaint to a texture. Export it with Texture > Export. Without clean UVs, the texture will have seams and overlaps.

Strokes only appear on one side

To turn symmetry on in ZBrush, press X or open the Transform palette and click Activate Symmetry, then choose the X, Y or Z axis. If it still does not mirror strokes, the model is probably not centered on its axis or has been moved or rotated after it was made. Turn on Local Symmetry in the Transform palette so symmetry follows the model, or reset its position, and check that you are sculpting a mesh that is actually symmetrical.

Polygon modeling brush in ZBrush

ZModeler is a ZBrush brush for polygon modeling. Hovering over points, edges and polygons shows a menu of actions, such as Extrude, Inset, Bevel, Bridge, Delete and Insert Edge Loop, so you can build and edit clean topology directly inside ZBrush instead of switching to another program. It works with polygroups as targets and with Dynamic Subdivision, and it is widely used for hard-surface and base mesh modeling.

ZBrush auto-retopology

ZRemesher is ZBrush's automatic retopology tool. It analyses a dense sculpt and produces a quad-based mesh with configurable polygon target and edge-flow guidance. ZRemesher 2024 produces production-quality topology for most organic forms when paired with manual polypaint guide curves to direct flow.