Core 3D concepts

The ideas every 3D tool shares, without the tool: scenes, axes and units, transforms, meshes and normals, topology and polygon budgets, UVs, draw calls, how a renderer turns triangles into pixels, and which file format keeps what. Surfaces and light are in Materials, textures & lighting, motion in Animation & rigging concepts. For the how-to, see Blender and the export sheets.

The mental model

A scene is a tree of objects. Each object has a transform (where it is, how it is turned, how big it is) and may carry mesh data (the shape), materials (how the surface reacts to light), or be a light or camera. A renderer looks through the camera and turns all of it into pixels, one frame at a time.

 Scene
  ├─ Object  (transform: position · rotation · scale)
  │    ├─ Mesh      vertices, edges, faces, normals, UVs
  │    └─ Material  base color, roughness, metallic, textures…
  ├─ Object (child)  inherits its parent's transform
  ├─ Lights          sun, point, spot, area, sky (HDRI)
  └─ Camera ──► renderer ──► pixels (one frame; 60 per second in a game)

Object and data are separate: many objects can share one mesh (Blender "linked duplicates"), which is the same idea engines call instancing.

Coordinate systems & handedness

Every tool picks an up axis and a handedness. Right-handed: point your right thumb along +X and your index finger along +Y; your middle finger is +Z. Left-handed tools flip one axis, which mirrors everything.

How exporters convert:

• Blender → glTF: the exporter's +Y Up option (on by default) maps (x, y, z) to (x, z, −y). Model facing −Y in Blender, and it arrives facing +Z: what glTF, three.js and Godot's MODEL_FRONT expect.
• Blender → FBX: the exporter has Forward / Up axis settings; Unity and Unreal convert on import. The classic symptom of a mismatch is a model lying on its back, or a root object rotated −90° on X.
• Blender → GTA V: same axes, so Sollumz (the Blender add-on for GTA files) exports without a swap; see GTA V.
• A negative scale on one axis mirrors the object, which flips handedness, face winding and normals. Apply it and recalculate normals before export.

Units & scale

Why an object's scale should read 1.0 before export:

• Modifiers (bevel width, solidify thickness, array offsets) and physics use the scaled size, so an object scaled 0.1 behaves like something ten times smaller than its numbers say.
• Non-uniform scale (e.g. 2, 1, 1) skews normals and distorts children and rotations.
• Rigs, retargeting, collision shapes and lightmap UV density all expect scale 1.
• Exporters carry object scale inconsistently; a mesh with scale baked in is the same everywhere.

Apply scale bakes the object's scale into the vertex positions and resets the scale to 1 (Blender: Object > Apply > Scale, Ctrl A). Apply rotation the same way for static props; see Blender modeling.

Real-world sizes for blocking out scenes and buildings (rules of thumb):

Transforms & hierarchies

Put the origin where the object pivots: a door at its hinge, a character or building at floor level (center of the feet), a wheel at its axle. Engines rotate around the mesh's origin, so a misplaced origin means doors that orbit and characters that float.

Euler angles vs quaternions

Edit in Euler, let the engine store quaternions. If an animated rotation flips at 180°, switch it to quaternions or run Blender's Euler discontinuity filter.

Mesh anatomy

GPU vertex count ≠ modeling vertex count. The GPU needs one vertex per unique combination of position, normal and UV, so every UV seam and hard edge splits vertices. A 1,000-vertex model can upload as 1,500.

Non-manifold geometry (holes, an edge shared by 3+ faces, interior faces, zero-area faces, duplicate vertices) breaks booleans, 3D printing, volume and collision generation, and some bakes. Fix it with Merge by Distance and by deleting interior faces; see Blender modeling.

Normals

A normal is a unit vector saying which way a surface faces. Lighting is computed from it.

That table explains the most common beginner bug: a model looks fine in Blender and has holes in the engine. Turn on Blender's Face Orientation overlay (blue = outside, red = inside) and recalculate normals outward; use double-sided materials only for truly thin things (leaves, paper, cloth).

Topology & polygon budgets

Topology is how faces are laid out across a surface, independent of its shape.

Why quads while modeling:

• Loop cuts and loop selection work, so you can add detail where it is needed.
• Subdivision smooths quads predictably; triangles and n-gons pinch.
• Deforming parts (joints, faces) bend cleanly with loops around them: give an elbow or knee ~3 loops.

Why engines triangulate: GPUs only draw triangles, so every quad becomes 2 tris and an n-gon becomes n − 2. A quad's split direction changes how it shades when it bends, so triangulate before baking a normal map so the bake and the game use the same triangles. Count budgets in triangles.

Triangle budgets (rules of thumb, not limits; test on your weakest target device):

UV mapping

UVs are 2D coordinates stored per face corner that say which pixel of a texture lands on which part of the surface. U runs horizontally, V vertically, 0 to 1 across the image. Unwrapping is flattening the mesh like a cardboard box cut open.

Lightmaps need unique, non-overlapping UVs, usually in a second UV channel (Godot can generate one on import for LightmapGI). Texel density rules of thumb: first-person games ~512–1024 px/m, third-person ~256–512 px/m, web product views: whatever keeps a 1K–2K texture sharp at the closest zoom.

The V axis points up in Blender and OpenGL but down in glTF; exporters and GLTFLoader handle the flip, so don't flip it by hand. How to unwrap: Blender materials & UVs.

Draw calls, instancing & LOD

A draw call is one command from the CPU telling the GPU "draw this mesh with this material". Each mesh × material is at least one draw call, and each costs CPU time regardless of triangle count, so 2,000 tiny objects are slower than one 200k-triangle mesh. The web is the most sensitive: aim for draw calls in the low hundreds on phones.

Transparent surfaces cost extra: they are drawn back to front, can't be merged freely, and overlapping layers shade the same pixel many times (overdraw). Prefer alpha-clip (cutout) for leaves and fences.

Rendering: rasterization vs ray tracing

Blender has both: EEVEE (rasterizer with screen-space ray tracing since 4.2; seconds per frame, close to what an engine shows) and Cycles (path tracer; the reference for realism and the engine used for baking). A Cycles render will always look richer than the same scene in three.js or Godot; bake lighting into textures to close the gap. See Lighting & rendering in Blender.

The real-time GPU pipeline, once per frame:

 CPU   scene graph ─► cull ─► sort ─► draw calls (mesh + material + uniforms)
                                          │
 GPU   vertex shader      per vertex: object → world → camera → clip space
          ▼
       primitive assembly, clipping, perspective divide → screen coordinates
          ▼
       rasterizer         triangles → fragments; interpolate UVs, normals
          ▼
       fragment shader    per pixel: material + lights → color
          ▼
       depth test, blending → framebuffer → post-processing → display

Watch for how vertex shading, rasterization and pixel shading map onto the steps above:

Frame budget: the CPU and GPU work in parallel, and the slower one sets the frame rate.

File formats

Loading glTF in code is in three.js models & animation; the Blender side is in Export to three.js and Export to Godot.

Glossary

Recipes

Before you export anything

Run this on every asset before it leaves Blender; most "broken model" reports come from skipping one line.

• Real-world size; object scale 1.0 and rotation applied on static meshes
• Origin where the object pivots or stands (feet, hinge, axle, building base)
• Front faces −Y in Blender (so it faces +Z in glTF / Godot)
• Normals point outward (Face Orientation overlay all blue); no stray double-sided surfaces
• Merge by Distance done; no interior or zero-area faces
• Every mesh unwrapped; lightmapped meshes have a unique second UV map
• Triangle count inside your budget; LODs made for anything seen at distance
• Materials are Principled BSDF + image textures only; procedurals baked
• Clear, unique object names (engines look nodes up by name)
• Hidden helpers, unused materials and cameras removed, or excluded with Limit to Selected
• Open the export in a second viewer (three.js editor, Godot, a glTF viewer) before building on it

Why does my model look faceted, inside-out or full of holes?

Match the symptom to the cause before touching topology.

Pick a poly budget

Use when starting an asset, so detail goes where the camera will see it.

1. Name the target and frame rate (phone browser at 60 fps, desktop game at 60, offline render).
2. Take the whole-scene figure from the budget table and split it: hero objects get most, background props share the rest.
3. Ask how close the camera gets: silhouette detail needs geometry; surface detail goes in the normal map.
4. Model to the budget, then triangulate and read the triangle count (Blender: Statistics overlay).
5. Build LODs for anything that is also seen far away (roughly half the triangles per step).
6. Profile on the real device; cut draw calls and texture size before cutting triangles.

Model arrives at the wrong size or rotation

Use when an export is tiny, huge, lying down or facing backwards.

Speed up a slow scene

Use when frame time is over budget; measure first (three.js renderer.info, Godot's Monitors and Visual Profiler).

1. Draw calls: merge static meshes, share materials via atlases or trim sheets, instance repeats.
2. Transparency and overdraw: switch blend to alpha-clip where possible.
3. Shadows: fewer shadow-casting lights, smaller shadow distance.
4. Textures: KTX2 or other GPU-compressed formats, ≤ 2K on mobile, mipmaps on.
5. Triangles: LODs, decimate background props.
6. Lighting: bake static lighting instead of computing it every frame.

References

• MDN: Explaining basic 3D theory (opens in a new tab): vertices, faces, the rendering pipeline, cameras, in plain words
• MDN: WebGL model view projection (opens in a new tab): object → world → view → clip space, with the math
• Blender Manual: mesh structure (opens in a new tab), normals (opens in a new tab), object origin (opens in a new tab), scene units (opens in a new tab), UVs (opens in a new tab), EEVEE (opens in a new tab), Cycles (opens in a new tab)
• Blender Manual: glTF 2.0 add-on (opens in a new tab): what the exporter keeps, +Y Up, instancing
• Khronos glTF 2.0 specification (opens in a new tab): coordinate system and units, meshes, winding, doubleSided
• three.js manual (opens in a new tab): scene graph, cameras, optimizing lots of objects
• Godot docs: Introduction to 3D (opens in a new tab), Using 3D transforms (opens in a new tab), Model export considerations (opens in a new tab), Optimizing 3D performance (opens in a new tab), Mesh LOD (opens in a new tab)
• LearnOpenGL: Coordinate systems (opens in a new tab): the spaces and matrices behind the pipeline diagram