The game asset pipeline

The game asset pipeline is the ordered set of stages that turns an idea into an object that works in a game engine. Most stages exist to keep the detail of a high-quality model while making it cheap enough to draw in real time (see real-time vs. offline rendering).

No two studios run exactly the same pipeline, and the order often changes. The stages below appear, in some form, in almost every 3D game production.

#The stages

#1. Concept and reference

Decide what the asset is, what it is for and how it should look. For an environment piece that means the setting, the material, its condition, and how close the player will get. Collect reference before you model anything.

#2. Blockout

A blockout is a rough, untextured version built from simple shapes. It checks size, proportion and gameplay before any detail work. In level design, the blockout is often the level itself: Naughty Dog's Emilia Schatz describes her main responsibility as "level design and layout", building rough blockout geometry and then working with environment artists "to make sure the design intention of the level is maintained throughout production" (80 Level: Defining Environment Language for Video Games). For a single prop, the blockout is a few boxes at the right scale, placed in the engine next to a player-sized reference.

#3. High poly

The high-poly model carries all the shape detail: rounded edges, panel lines, sculpted cracks, wood grain. Polygon count barely matters here because it will not go into the game. Artists build it with subdivision surface modeling, digital sculpting, or a mix. See the high-to-low workflow.

#4. Low poly

The low-poly model is the in-game mesh. It follows the silhouette of the high poly with as few triangles as the budget allows. Unity's manual states the principle: "The fewer the polygons you use in your meshes, the faster your application runs" (Unity 6.6 Manual: Creating models for optimal performance). Building the low poly over the high poly is called retopology.

#5. UVs

UV mapping flattens the low-poly surface into 2D so a texture can wrap onto it. You decide where the seams go, keep texel density consistent, and leave padding between islands.

#6. Bake

Baking transfers detail from the high poly to textures on the low poly, most importantly a normal map and ambient occlusion. Normal maps "only simulate fluctuations in the surface direction" (Magnopus: Unreal Engine 5 and Nanite virtualized…), but at game distances that is usually convincing. Baking has many settings that can go wrong; one studio blog lists "adjusting cages, exploding parts, smoothing groups, UVs, and different coordinate spaces" among its pain points (Magnopus: Unreal Engine 5 and Nanite virtualized…). See bake cage, tangent space and MikkTSpace and fixing baking artefacts.

#7. Texture

Texturing creates the surface maps for physically based rendering: base colour, roughness, metallic and the baked normal. The baked maps drive smart masks for edge wear and dirt. Environment assets often mix unique textures with shared tileable materials and trim sheets. See ways to texture an environment.

#8. Export

Export the low poly from your modeling tool, usually as FBX; see 3D file formats. Unity's manual advises that you check the exported file's size and re-import it into your modeling software to confirm it looks right, and not to embed textures in the FBX file (Unity 6.6 Manual: Preparing your model files for export). Most export problems are about units, scale and axes and the pivot point.

#9. Engine setup

Import the mesh and textures, create the material, assign it, and place the asset in a level. In Unity, if your normal map was baked from a high-poly model, the manual recommends setting the importer's Smoothing Angle to 180° (Unity 6.6 Manual: Importing model files). In Unreal, a master material with instances lets each new asset reuse the same shader, so it only needs its own textures plugged in.

#10. LOD and collision

LODs are simpler versions of the mesh that the engine swaps in at a distance. Collision is a separate, very simple shape that physics and the player collide with. In Unreal, a static prop's custom collision can come from meshes in the same FBX whose names start with UBX_, UCP_, USP_ or UCX_ (box, capsule, sphere and convex) followed by the render mesh's name (Cinevva: Blender to Unreal Engine Export Checklist…).

#11. Review

Look at the asset in the engine, in the lighting it will actually have, at the distance players will see it. Check it against the concept, the budget and its neighbours. Then go back to whichever stage needs fixing. The review loop is where most of the quality comes from.

#Common variations

The classic path above is called the high-to-low workflow. Several variations change or skip stages.

#Mid-poly

In a the mid-poly workflow, the in-game mesh carries its own bevelled edges, so the separate high poly and most of the bake disappear. Detail comes from geometry plus weighted (custom) normals, tiling materials and decals. Magnopus notes that mid-poly assets with texture-only detail are a complication for Nanite, and suggests generating high-resolution meshes from them, for example by "exporting a tessellated version of their mesh with the heightmap data" (Magnopus: Unreal Engine 5 and Nanite virtualized…).

#Nanite and dense meshes

With Unreal's Nanite, Epic says you can "directly import film-quality source arts, such as ZBrush sculpts and photogrammetry scans", that LODs are handled automatically, and that you can "use high-poly detailing rather than baking detail into normal map textures" (Unreal Engine 5.8 Documentation: Nanite Virtualized Geometry in Unreal Engine). Stages 4, 6 and 10 become smaller but remain. Nanite only supports opaque and masked materials, so translucent surfaces still need normal meshes (Unreal Engine 5.8 Documentation: Nanite Virtualized Geometry in Unreal Engine), and Epic still recommends an additional normal map when you use Nanite tessellation (Unreal Engine 5.8 Documentation: Working with Nanite-Enabled Content).

#Photogrammetry

Photogrammetry replaces the early stages with photographs of a real object, reconstructed into a dense mesh and texture. The scan is then cleaned, decimated or retopologised, and baked down, or imported directly into a Nanite workflow (Unreal Engine 5.8 Documentation: Nanite Virtualized Geometry in Unreal Engine). Ready-made scan libraries such as Megascans skip capture entirely, though their licensing changed when they moved to Fab (CG Channel: Epic Games has made Megascans free to all…). See photogrammetry and scanning tools.

#Stylised and hand-painted

In a hand-painted style, the texture stage carries most of the look: form, light and wear are painted into the base colour. The high poly and bake may be skipped, or reduced to helper maps that guide the painting.

#Common mistakes

• Detailing before the blockout is approved. A beautifully sculpted crate that turns out to be the wrong size is wasted time.
• Baking with mismatched settings. If the baker and the engine disagree about tangent space and MikkTSpace or smoothing, the normal map shows seams. See fixing baking artefacts.
• Forgetting collision and LODs. They are part of the asset, not an afterthought.
• Moving the pivot in the engine instead of the source file. Unreal's Edit Pivot tool bakes the change into the static mesh asset and every instance in the scene (Unreal Engine 5.8 Documentation: Edit Pivot Tool in Unreal Engine), so the source file and the engine asset no longer match. Fix it in the source and re-export.
• Not writing down export settings. Blender-to-Unreal guides disagree on details such as the Apply Scalings mode (Substack: Blender to UE5: the complete export pipeline; Cinevva: Blender to Unreal Engine Export Checklist…), so whichever you choose, write it on a one-page export checklist and share it with the team.

#In different tools

exercise: your first game-ready prop turns this into a full, structured exercise.

#Further reading and watching