Game Art Terms Explained

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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."

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.