3D modelling, texturing and UV mapping

In short

3D modelling builds the geometry of an object as vertices, edges and faces (or as mathematical curved surfaces); UV mapping flattens that 3D surface into a 2D layout so images can be painted on it; texturing supplies the colour and surface-property maps that make the model read as metal, skin or cloth. The three are one pipeline stage — a model with bad topology cannot be unwrapped cleanly, and a bad unwrap wastes texture resolution and shows seams. This is the core practical and viva content of 3D papers in B.Sc Animation / B.Des programmes (Maya, Blender, 3ds Max, ZBrush, Substance Painter labs) and the first thing tested in portfolio and technical rounds at Technicolor India, DNEG India, MPC, Framestore, Rockstar India, Ubisoft Pune, Zynga, SuperGaming, Green Gold, Technicolor Games and Lakshya Digital. Game and real-time work adds hard budgets — triangle counts, texel density, UV channels — which is where most interview questions land.

Explained

Geometry: what a 3D model actually is

• Vertex — a point in 3D space (x, y, z). Edge — a line joining two vertices. Face (polygon) — a closed loop of edges; mesh — the whole collection.
• Tri (3 sides), quad (4), n-gon (5+). Hardware renders only triangles; a quad is split into two tris at display/export time. Quads are kept in modelling because they subdivide and deform predictably.
• Normal — a vector perpendicular to a face or interpolated at a vertex; it decides which way a surface faces and how light hits it. Flipped normals render black, invisible or inside-out.
• Winding order — the direction (clockwise / counter-clockwise) in which a face's vertices are listed; it defines the normal and so back-face culling.
• Vertex normals and smoothing/hard edges: one averaged normal per vertex gives a smooth look; split normals at an edge give a hard crease. "Smoothing groups" (3ds Max) and "soften/harden edge" (Maya) control this.
• Manifold geometry — every edge is shared by at most two faces and the surface is continuous. Non-manifold cases: an edge with three faces, two faces joined at a single vertex, internal faces. These break booleans, subdivision, UV unwrapping, baking and 3D printing.
• Watertight / closed mesh — no boundary (open) edges; required for 3D printing and for most simulations.
• Pivot / origin, local vs world space, transforms — translate, rotate, scale; freeze transformations resets the object's transform to identity without moving it. Scale must be uniform and non-negative; negative scale inverts normals.
• Coordinate conventions differ: Maya and Blender are Y-up / Z-up respectively (Blender is Z-up, Maya and Unity Y-up, Unreal Z-up, left-handed), and unit scale differs — always set scene units (1 unit = 1 cm or 1 m) before modelling, and verify on export.

Modelling methods and classification

• Polygon (mesh) modelling — direct manipulation of verts/edges/faces. Dominant in games and most of VFX.
  • Box modelling: start from a primitive, extrude and refine to the shape — good for characters and organic props.
  • Edge / poly-by-poly modelling: build the surface strip by strip, usually over a reference or scan — good for exact topology on faces and vehicles.
  • Hard-surface modelling: mechanical forms with crisp bevels, support loops and panel lines.
• Spline / curve-based — NURBS (Non-Uniform Rational B-Splines): surfaces defined by control points, weights and knot vectors; mathematically exact and resolution-independent, tessellated only at render. Standard in CAD/product design (Alias, Rhino, Maya NURBS); weak at branching organic topology.
• Subdivision surfaces (SubD) — a low-poly "cage" refined by an algorithm (Catmull–Clark for quads, Doo–Sabin, OpenSubdiv). Combines editable low-poly control with smooth limit surface; creases and support loops control tightness. The film standard.
• Digital sculpting — voxel or dynamic-topology clay (ZBrush Dynamesh/Sculptris, Blender Dyntopo, Mudbox). Millions of polygons, no usable topology; needs retopology afterwards.
• Procedural / parametric — node graphs generating geometry (Houdini SOPs, Blender Geometry Nodes, Substance); non-destructive and re-usable for cities, foliage, damage.
• CSG / Boolean — union, difference, intersection of solids; fast blockout, messy topology that must be cleaned.
• Scan-based — photogrammetry (RealityCapture, Metashape) and LiDAR produce dense triangle soup plus a colour map; used heavily for Indian heritage and set scans.
• Other representations: voxels (volume grids), point clouds, implicit surfaces/SDFs, and more recently Gaussian splats and neural radiance fields for capture-based scenes — these are not polygon meshes and need conversion before conventional texturing.
• Modelling types by purpose: blockout/proxy → hero (close-up, highest detail) → mid/background (A, B, C assets) → LODs (LOD0…LODn, progressively decimated for distance).

Topology: the rule that governs everything downstream

• Topology is how the faces are arranged, independent of shape. Good topology = mostly quads, even quad density, loops following the form and the direction of deformation.
• Edge loop — a continuous ring of edges around a form; edge ring — the parallel edges across it. Loops are placed concentrically around eyes, mouth and joints so deformation folds correctly.
• Pole / extraordinary vertex — a vertex where other than four edges meet. 3-pole (triangle pole) and 5-pole are acceptable if hidden in flat or non-deforming areas; 6+ poles pinch under subdivision. Keep poles off creases, silhouettes and deforming joints.
• Triangles and n-gons: avoid in deforming or subdivided areas; acceptable in static hard-surface interiors. N-gons can tessellate unpredictably across software.
• Topology errors: overlapping/duplicate vertices, coincident faces, zero-area faces, inverted normals, stray loose verts and edges, self-intersection, interior faces. Use mesh-cleanup tools (Maya Mesh > Cleanup, Blender Merge by Distance, 3D-Print toolbox) before UVs.
• Retopology — rebuilding a clean animatable quad mesh over a sculpt or scan: manual (ZBrush ZRemesher guides, Maya Quad Draw, RetopoFlow, TopoGun) or automatic (ZRemesher, Instant Meshes, QuadRemesher). Auto-retopo is fine for props, rarely acceptable for faces.
• Decimation vs remeshing: decimation collapses triangles to a target count keeping silhouette (good for background/scan assets); remeshing creates a new uniform mesh (good for sculpt base and for UV-able LODs).
• Polygon budgets are stated in triangles, not quads, and vary with platform and target year — mobile hero characters commonly in the low thousands to tens of thousands of tris, PC/console heroes far higher. Treat any specific number as studio- and project-specific.

UV mapping and unwrapping

• UV space — a 2D parameter space, axes U (horizontal) and V (vertical), normalised 0–1; the 0–1 square is one UDIM tile / texture space. Each vertex carries a UV coordinate linking the 3D surface to the 2D image.
• Why it is needed: a texture is a flat raster; the mesh must be cut and flattened so each triangle maps to a region of that raster.
• Projection mapping types (quick, non-destructive starting points): planar, cylindrical, spherical, box/cubic, camera/perspective projection, and automatic/best-plane projection. Planar projection stretches badly on any face not parallel to the plane.
• Unwrapping — cutting the mesh along seams and relaxing/flattening the shells. Core algorithms: LSCM / ABF (angle-based flattening) — conformal, preserves angles and minimises distortion locally (Blender's "Unwrap"); Conformal and Minimum Stretch in Maya; UVAtlas/Unwrella-style automatic cutters; Houdini and RizomUV offer optimiser-based packing and unfolding.
• UV shell / island / patch — a connected piece of flattened geometry. Seam — the cut edge; a visible break in the texture and in tangent-space normals.
• Seam placement rules: hide seams where the eye does not travel — under arms, inside legs, along the hairline, in concave corners, along material or panel boundaries, on the back and underside; follow existing hard edges; keep symmetrical for mirrored texturing.
• Distortion — stretching (texture squashed over too much surface) and compression. Checked with a checker map (squares must stay square and equal-sized) or a UV-distortion/stretch heat map.
• Layout and packing: shells straightened (axis-aligned where possible for crisp, compressible textures), scaled to a uniform texel density, rotated to multiples of 90° where practical, and packed with padding/gutter between shells and edge bleed/margin at the border.
• Padding guideline: enough pixels so that mip-mapping does not pull neighbouring shells into each other. Common practice is a few pixels at the working resolution — typically 2 px at 512, 4 px at 1K, 8 px at 2K, 16 px at 4K (i.e. roughly scaling with resolution); exact values are studio standards, not a fixed rule.
• Overlapping UVs are deliberate for symmetry and tiling (two arms share one shell → half the texture cost) but must not overlap in the channel used for lightmaps or for baking ambient occlusion/ID maps.
• Multiple UV sets / channels: UV0 for the albedo and material maps, UV1 for a non-overlapping lightmap (Unreal/Unity baked lighting), further sets for detail/decal/tiling layers or vertex-blend masks.
• UDIM — tiles numbered 1001 + u + 10v, so tile (0,0) = 1001, (1,0) = 1002, (0,1) = 1011. Lets a film-quality asset carry many 4K textures without one giant map; supported by Maya, Blender, Substance Painter, Mari, Arnold, RenderMan. Games mostly avoid UDIMs and use atlases or trim sheets instead.
• Mirrored / stacked UVs, tiling UVs (deliberately outside 0–1), trim sheets (one strip of reusable material bands used across a whole environment) and texture atlases (many objects in one map) are the standard game space-saving techniques.

Texturing and PBR maps

• Texture map — an image (or procedural) sampled through UVs to drive a material input. Texel — one pixel of that map as it lands on the surface.
• PBR (physically based rendering) describes a surface with energy-conserving, measurable properties. Two workflows:
  • Metallic–Roughness: Base Colour (albedo), Metallic (0 or 1 for real materials), Roughness, Normal, Ambient Occlusion, Height. Used by Unreal, Unity, Substance, glTF.
  • Specular–Glossiness: Diffuse, Specular (RGB colour), Glossiness, Normal. Older; still used in some pipelines.
• Map types and what each does:
  • Albedo / Base Colour — pure colour, no baked lighting or shadow; should contain no AO and no highlights.
  • Normal map — RGB encodes a perturbed surface normal; fakes small detail without geometry. Tangent space (purple-blue, follows the surface, works on deforming meshes) vs object/world space (static). Green-channel handedness differs: OpenGL (Y+ — Blender, Godot, glTF) vs DirectX (Y− — Unreal, 3ds Max) — the single most common "my bevels look inverted" bug; flip the green channel to convert.
  • Bump / height (displacement) — greyscale. Bump only shades, height/displacement actually moves geometry at render (needs tessellation); vector displacement can move in any direction (overhangs).
  • Roughness / glossiness — microsurface scatter; roughness 0 = mirror, 1 = fully diffuse. The main storyteller of wear and material difference.
  • Metallic — binary mask of conductors; in the metallic workflow a metal's base colour *is* its specular reflectance (bright — around 0.95 for silver) and it has no diffuse term; it is in the specular–glossiness workflow that metals carry a near-black diffuse map.
  • Ambient occlusion — baked contact shadowing, multiplied into ambient light, not into base colour in a correct PBR setup.
  • Opacity / alpha (cutout vs blend), emissive, subsurface scattering mask (skin, wax, marble), anisotropy and tangent direction (brushed metal, hair), clear coat (car paint), thickness, curvature, cavity, position and ID / material mask maps.
• Texture resolution — powers of two (512, 1K = 1024, 2K, 4K, 8K) for mip-mapping and GPU efficiency. Mipmaps are pre-filtered smaller copies that stop shimmering at distance (about 33% extra memory).
• Texture formats and compression: PNG/TGA/TIFF for authoring, EXR (16/32-bit float, HDR) for film and for displacement, BC/DXT (BC1/BC3/BC5/BC7) on PC and console, ASTC / ETC2 on mobile, Basis Universal / KTX2 for web and glTF. Normal maps use BC5 (two-channel) and must not be stored in a lossy sRGB-encoded format.
• Colour space: albedo/base colour and emissive are sRGB; roughness, metallic, AO, height, normal are linear / non-colour data. Tagging a roughness map as sRGB is a standard beginner error. Film pipelines work in ACES (ACEScg working space, Input/Output transforms).
• Texturing methods: hand-painted (2D in Photoshop/Krita over the UV layout, or 3D in Substance Painter / Mari / 3D-Coat / Blender Texture Paint), procedural (Substance Designer node graphs, Blender shader nodes — resolution-independent, tweakable), photo-sourced / scanned (Quixel Megascans, Poliigon), and projection painting from photographs.
• Smart materials and masks — generators driven by baked curvature, AO and thickness maps place edge wear, dirt in cavities and dust on upward faces automatically; this is why baking comes before texturing.
• Tileable / seamless textures — must match at opposite borders (offset-and-heal, or author procedurally); combine with a detail/macro variation map to break obvious repetition.

Baking: high-poly to low-poly

1. Model high-poly (SubD or sculpt) and a low-poly game mesh that follows the same silhouette.
2. UV the low-poly: no overlaps, correct padding, uniform texel density, hard edges split in UVs where the normal map needs it.
3. Name-match or explode the parts (part_high / part_low, or separate them in space) so rays hit the right surface.
4. Set a cage / ray distance — too small misses detail, too large catches neighbouring parts.
5. Bake normal, AO, curvature, thickness, position, world-space normal and ID maps by casting rays from the low-poly along its interpolated normals to the high-poly.
6. Fix artefacts: gradients/skewing from averaged normals (add support loops, harden edges, use a cage, or bake with matched smoothing), seam shading breaks (split UVs where you have hard edges — "hard edge = UV seam"), ray-miss black spots (increase distance), and waviness from mismatched silhouettes.
7. Triangulate before baking and before export so the engine's triangulation matches the baker's; use the same tangent basis (MikkTSpace is the common standard) in baker and engine.
8. Also baked in production: lightmaps (UV1), vertex colour / vertex AO, and for film Ptex (per-face texturing with no UVs at all — used where unwrapping a dense asset is impractical).

Pipeline, formats and professional practice

• Order of work: reference and scale → blockout → high-poly → retopology/low-poly → UV → bake → texture → material setup → LODs → export → engine/shot check.
• Interchange formats: FBX (industry workhorse: mesh, UVs, normals, skin, animation), OBJ (mesh + UVs only, no animation), glTF / GLB (open, PBR-native, web and AR), USD / USDZ (scene description and layering — now the backbone of film pipelines and AR), Alembic (baked cached geometry), STL/3MF (printing), MaterialX (portable shading graphs).
• Naming and organisation: consistent asset naming (SM_, T_, M_ style prefixes), material IDs, no transforms baked into skinned meshes, scene scale in real-world units, non-zero pivots documented.
• Deliverables checked in QC: triangle count, UV overlap and texel density report, map set and resolutions, naming, scale, pivot, normals, no history/construction nodes left, LOD chain, file size.
• Legal and commercial context in India: 3D models and textures are artistic/computer works under the Copyright Act, 1957 (as amended); a studio employee's work is normally the employer's, while a freelancer should settle ownership in the contract — assignment of copyright must be in writing. Marketplace and scan-library assets (Megascans, TurboSquid, CGTrader, Sketchfab) carry licences that restrict resale and sometimes model-training use — read them. Service exports of VFX/animation work are zero-rated under GST with the usual LUT/refund route; domestic animation services are taxed at the applicable services rate (slabs since 22 September 2025 are 5%, 18% and 40%) — confirm the current rate for the specific service before quoting. Studio work is covered by the four Labour Codes in force from 21 November 2025.
• Indian industry bodies and references: AVGC (Animation, VFX, Gaming, Comics) sector promotion under the Ministry of Information and Broadcasting, the National AVGC-XR Mission and state AVGC policies (Karnataka, Maharashtra, Telangana, Kerala, Madhya Pradesh); NSQF/MESC (Media & Entertainment Skills Council) qualification packs define role-wise competency for "3D Modeller", "Texturing Artist" and "Rigging Artist" — syllabi in B.Sc/B.Des programmes often map to these.

Key points

• Mesh — vertices + edges + faces; hardware draws triangles, artists model in quads for predictable subdivision and deformation.
• Topology — face arrangement, not shape; even quads and loops following deformation are the whole quality test.
• Edge loop / edge ring — concentric loops around eyes, mouth and joints make deformation fold correctly.
• Pole — a vertex with other than 4 edges; 3- and 5-poles hidden in flat areas are fine, 6+ pinch.
• Non-manifold — an edge shared by 3+ faces or faces meeting at one vertex; breaks booleans, SubD, UV and baking.
• NURBS vs SubD vs sculpt — exact maths for CAD; editable smooth cage for film; millions of free-form polys needing retopology.
• Catmull–Clark — the standard quad subdivision scheme; creases and support loops control tightness.
• UV mapping — assigning 2D (U,V) coordinates in the 0–1 space to every vertex so a flat image lands on a 3D surface.
• Seam — a UV cut; place it where it is hidden, and always where you have a hard edge.
• Texel density — pixels per unit of surface (px/cm); keep it uniform across an asset and consistent across a project.
• Padding / gutter — empty pixels between UV shells so mipmaps do not bleed; roughly scales with map resolution.
• UDIM — tile = 1001 + u + 10v; many 4K maps per asset for film. Games prefer atlases and trim sheets.
• UV1 — a second, strictly non-overlapping UV channel for baked lightmaps in Unreal/Unity.
• PBR metallic-roughness — Base Colour, Metallic, Roughness, Normal, AO, Height; albedo carries no lighting.
• Normal map space — tangent (deforming meshes) vs object/world (static); OpenGL vs DirectX differ in the green channel.
• Colour space — base colour and emissive are sRGB; roughness, metallic, AO, height and normal are linear/non-colour.
• Baking — casting rays from low-poly to high-poly to capture normal, AO, curvature, thickness and ID maps; triangulate first.
• LOD — progressively decimated versions swapped by screen size to control triangle and draw-call cost.

Formulas and examples

Example 1 — Euler check on a cube and a torus

• Cube: V = 8, E = 12, F = 6 → 8 − 12 + 6 = 2 → genus 0, a closed surface with no holes. Correct.
• Triangulated cube: F = 12, E = 18, V = 8 → 8 − 18 + 12 = 2. Still 2 — triangulating does not change topology.
• A quad torus (grid 16 × 8 = 128 quads): V = 128, E = 256, F = 128 → 128 − 256 + 128 = 0 = 2 − 2g → g = 1, one hole. Correct for a torus.

Example 2 — Subdivision cost A SubD cage has 2,400 quads.

• Level 1: 2,400 × 4 = 9,600 quads. Level 2: 38,400. Level 3: 153,600 quads = 307,200 triangles.
• Each level multiplies face count by 4, so memory and sculpt cost roughly ×4 per level — this is why hero film assets are subdivided only at render and why ZBrush subdivision levels are stepped down before export.

Example 3 — Texel density and map size A game character is 180 cm tall. The project standard is 10.24 px/cm (= 1024 px per metre).

• Pixels needed along the height = 180 × 10.24 = 1,843 px. The nearest power of two above is 2048 → a 2K map gives 2048/180 = 11.38 px/cm, slightly above standard; a 1K map gives 1024/180 = 5.69 px/cm, half the standard.
• Choice: 2K for the body. If the UV layout uses only 70% of the tile, the effective density falls by √0.70 = 0.837 → 11.38 × 0.837 ≈ 9.5 px/cm — just under standard, so improve packing or move to a second 2K tile.
• A 10 cm-wide prop at the same density needs 10 × 10.24 = 102 px → a 128 map is enough; using 2K on it wastes 256 × the memory.

Example 4 — Texture memory budget A character ships with Base Colour, Normal, and a packed ORM (AO/Roughness/Metallic) map, all 2K.

• Uncompressed 8-bit RGBA, one 2048² map = 2048 × 2048 × 4 = 16,777,216 bytes = 16 MB. Three maps = 48 MB; with mipmaps ≈ 48 × 1.333 = 64 MB. Far too much for mobile.
• Compressed: Base Colour BC7 ≈ 1 byte/texel = 4 MB; Normal BC5 ≈ 1 byte/texel = 4 MB; ORM BC7 = 4 MB → 12 MB, with mipmaps ≈ 16 MB.
• Dropping to 1K halves each dimension, so memory falls to one quarter: ≈ 4 MB with mipmaps. Packing three greyscale maps into one RGB texture (ORM) is why the set is 3 maps and not 5.

Example 5 — UDIM and packing A film hero prop needs an effective 8K of detail but the renderer is set to 4K tiles.

• 8K² of area = 4 × (4K²), so 4 UDIM tiles: 1001, 1002, 1011, 1012 (u,v = (0,0), (1,0), (0,1), (1,1)).
• Check: 1001 + 1 + 0 = 1002 ✓; 1001 + 0 + 10 = 1011 ✓; 1001 + 1 + 10 = 1012 ✓.
• Padding at 4K at the 16 px guideline = 16/4096 = 0.39% of the tile per edge; across many small shells this is the main reason utilisation rarely exceeds about 80–85%.

Where it is used

• VFX and animated features: hero asset modelling, UDIM texturing and look-dev at DNEG India, MPC, Technicolor, Framestore Mumbai/Bengaluru, Redefine, Phantom FX and Green Gold — roles: Modeller, Texture/Look-dev Artist, Asset TD.
• Games: character and environment art for Rockstar India (Bengaluru), Ubisoft Pune/Mumbai, Zynga, Lakshya Digital (Keywords), SuperGaming, Nodding Heads, Nazara studios — trim sheets, atlases, LODs, lightmap UVs and strict tri/texture budgets.
• Product design, automotive and manufacturing: NURBS Class-A surfacing and CAD-to-visual conversion at Tata Motors, Mahindra, Maruti design studios and Bajaj; design-viz and configurators.
• Architecture, real estate and infrastructure visualisation: interior and exterior stills, walkthroughs and Unreal/Twinmotion experiences for Indian developers; BIM-to-visual conversion.
• AR/VR, ed-tech and e-commerce: glTF/USDZ product viewers and try-on for Indian e-commerce, museum and heritage digitisation (ASI monument scans), medical and industrial training simulators; 3D printing and prototyping need watertight, correctly scaled meshes.
• Advertising, broadcast and events: product CGI for TVCs, channel branding and AR graphics for Indian broadcast; MESC/NSQF-aligned studio hiring and apprenticeships.

Interview questions

• Q: Why model in quads when the GPU only draws triangles? A: Quads subdivide predictably with Catmull–Clark, deform cleanly, keep edge loops and rings selectable, and triangulate reliably at export — the triangulation is a last step, not a modelling constraint.
• Q: What is non-manifold geometry and why does it matter? A: Geometry where an edge is shared by more than two faces, or faces touch only at a vertex. It has no consistent surface or normal, so booleans, subdivision, UV unwrapping, baking and 3D printing all fail or produce artefacts.
• Q: How do you decide where to put a UV seam? A: Where it is hidden from the camera and from the eye — concave corners, undersides, inside limbs, hairlines, material and panel boundaries — on existing hard edges, symmetrical for mirrored texturing, and always wherever the mesh has a hard (split-normal) edge.
• Q: What is texel density and how do you set it? A: Texture pixels per unit of real-world surface (px/cm). You pick a project standard, scale every UV shell to it so detail reads evenly, and choose map resolution from the asset's real size — a 180 cm character at 1024 px/m needs a 2K map.
• Q: Why must lightmap UVs be in a separate channel? A: Baked lighting is unique per surface, so no two faces may share lightmap texels; UV0 deliberately overlaps for mirrored and tiling detail, so a non-overlapping UV1 is generated for the lightmap.
• Q: My baked normal map makes bevels look inverted in the engine. What happened? A: Almost certainly a green-channel handedness mismatch — the map was baked in OpenGL (Y+) convention and the engine expects DirectX (Y−), or vice versa. Invert the green channel or change the bake setting; also confirm both use the same tangent basis.
• Q: Why do dark gradients or skewing appear on a baked low-poly surface? A: Rays are cast along averaged (smoothed) vertex normals, so on long flat faces they miss or skew against the high-poly. Fix with support loops, hard edges plus matching UV splits, a tuned cage, or matched smoothing between baker and mesh.
• Q: What is the difference between bump, normal and displacement? A: Bump is a greyscale shading trick, normal maps perturb the surface normal in RGB with directional detail, and displacement actually moves geometry (needing tessellation) so it changes the silhouette and casts real shadows.
• Q: Should ambient occlusion be multiplied into the base colour map? A: No — in a correct PBR setup the albedo carries no lighting; AO is supplied separately and applied only to indirect/ambient light, otherwise shadows double up under direct light.
• Q: When would you use UDIMs, and when not? A: UDIMs for film/VFX hero assets that need many high-resolution tiles with per-tile detail; not in most real-time games, where a single atlas, trim sheets or tiling materials keep draw calls, memory and streaming predictable.
• Q: What is retopology and when is auto-retopo acceptable? A: Rebuilding a clean quad mesh over a sculpt or scan. Automatic remeshers are fine for static props and background assets; faces and deforming characters need manual loop placement around eyes, mouth and joints.
• Q: How do you cut a character's texture memory by three-quarters without changing the model? A: Halve each map's resolution (2K → 1K reduces memory to a quarter), pack AO, roughness and metallic into one RGB map, reuse mirrored UVs for symmetrical parts, and use BC5 for normals and BC7/BC1 for colour.
• Q: Why triangulate before baking and exporting? A: Different applications split quads along different diagonals; if the baker's triangulation differs from the engine's, shading and normal-map detail shift. Triangulating once fixes the split everywhere.

Common mistakes

• Sculpting or modelling at the wrong scene scale and in the wrong up-axis, then discovering it at export — set units and axis conventions before starting.
• Leaving triangles, n-gons and 6+ poles in deforming areas (face, shoulders, knees), where they pinch under subdivision and animation.
• Unwrapping with non-uniform shell scale, so one part of the asset is sharp and another blurry; and ignoring the checker test for stretching.
• Insufficient padding, or overlapping shells in the channel used for lightmaps/AO baking — giving bleeding seams and black patches.
• Baking lighting, shadow or AO into the base colour map, or tagging roughness/normal maps as sRGB instead of linear.
• Forgetting that a hard edge must be a UV seam (and vice versa in practice), which is the usual cause of visible shading breaks across a bake.
• Using a hero-sized map on a small prop (a 2K map on a 10 cm object) and blowing the texture budget, instead of sizing maps by real-world dimensions.

Related topics

Rigging and character animation · Lighting, rendering and shaders · Digital sculpting and retopology workflows · Real-time engines: Unreal and Unity asset pipelines · Compositing and look development · Computer graphics fundamentals: transformations, rasterisation and projection