Every 3D artist has experienced this: you spend hours modeling an asset in Blender, export it, import it into your game engine, and something is wrong. Maybe the normals are flipped. Maybe the scale is off by a factor of 100. Maybe the materials did not come through. Maybe the pivot point is in the wrong place and the asset rotates around some arbitrary point in space.

These issues are not bugs. They are pipeline problems — small oversights during the creation process that compound into frustrating import failures. The fix is a checklist. Not a creative checklist about design quality, but a technical checklist that ensures every asset meets the baseline requirements for game engine import.

This checklist reflects the state of game-ready asset creation in 2026. Some items are evergreen (clean topology will always matter), while others reflect current best practices (texture resolution standards, LOD expectations for modern hardware).

Topology

Polygon Type

• Use quads and triangles. Game engines triangulate everything at import. Quads are preferred during modeling because they subdivide cleanly and deform predictably, but triangles are acceptable for flat surfaces and areas that will not deform.
• Eliminate n-gons. Any polygon with more than 4 vertices will triangulate unpredictably. Some engines handle this gracefully; others produce visible artifacts. Remove all n-gons before export. In Blender: Select All > Select All by Trait > Faces by Sides > set to greater than 4.
• Triangulate manually if precision matters. If you need exact control over how quads split into triangles (important for normal map baking), triangulate in Blender before export using Ctrl+T.

Polygon Count

Target polycount depends on the asset's role in the game:

These are guidelines, not rules. A stylized mobile game might use a quarter of these budgets. A cinematic PC title might use ten times more. Know your target platform and budget accordingly.

Clean Geometry

• Remove doubles/merge by distance. Select all vertices, Mesh > Merge > By Distance. Use a small threshold (0.0001m) to catch overlapping vertices without collapsing intentional geometry.
• Fix normals. Select all faces, Shift+N to recalculate normals. Check for blue faces in the overlay (face orientation display) — red means the normal is flipped.
• Remove interior faces. Delete any geometry that will never be visible. Interior faces waste triangles and can cause z-fighting or lighting artifacts.
• Remove loose vertices and edges. Mesh > Clean Up > Delete Loose.

UV Mapping

Requirements

• No overlapping UVs (unless intentionally tiling or using multiple UV channels). Overlapping UVs cause lightmap and baking artifacts.
• Consistent texel density. All UV islands should have proportional sizes relative to their 3D surface area. A large wall should not have the same UV space as a small bolt. In Blender, use the Texel Density Checker addon to verify.
• Proper seam placement. Hide seams along hard edges, behind the object, or in areas that will not be closely inspected. Never place seams across large, visible, flat surfaces.
• Island padding. Leave at least 2-4 pixels of padding between UV islands at your target resolution to prevent texture bleeding. At 2048x2048, 4 pixels of padding is standard.
• Straightened UV islands where appropriate. Hard-surface assets benefit from straightened UVs along major edges for cleaner texture application.

UV Channel Setup

Most game engines support multiple UV channels:

• UV0: Primary texture mapping
• UV1: Lightmap UVs (non-overlapping, used for baked lighting)

If your engine uses baked lighting, create a second UV channel with non-overlapping, well-packed islands for the lightmap. Unreal Engine can auto-generate lightmap UVs, but manually authored ones are almost always better.

Materials

PBR Compliance

Your materials should use Blender's Principled BSDF with physically plausible values:

• Base Color: No pure black (0,0,0) or pure white (1,1,1). Real-world albedo values range from ~0.02 (darkest charcoal) to ~0.9 (fresh snow). Most materials fall between 0.05 and 0.8.
• Metallic: Binary for most materials — 0.0 for dielectrics, 1.0 for metals. Values between 0 and 1 are only physically correct for transition areas (rust on metal, painted metal edges).
• Roughness: Full range from 0.0 (mirror) to 1.0 (completely diffuse). Avoid exactly 0.0 — even polished mirrors have slight roughness. Use 0.02-0.05 for polished surfaces.
• No emission for non-emissive surfaces. Emission should be 0 unless the surface actually glows.

Texture Maps

Standard PBR texture set for game-ready assets:

• Base Color (Albedo) — RGB, no lighting information baked in
• Normal Map — DirectX convention for UE5, OpenGL for some other engines
• Roughness — Grayscale
• Metallic — Grayscale (often black and white only)
• Ambient Occlusion — Grayscale (sometimes packed into a channel with roughness and metallic)
• Height/Displacement — Grayscale (optional, for parallax or tessellation)

Texture resolution: Match to texel density. Standard sizes: 512, 1024, 2048, 4096. Most environment props use 1024 or 2048. Hero assets use 2048 or 4096. Small props can use 512.

For the baking step, One-Click PBR Bake & Export handles all of these maps in a single operation — it bakes base color, normal, roughness, metallic, AO, and height maps from your Blender materials with correct engine conventions.

Naming Conventions

Consistent naming prevents import chaos. Adopt a convention and stick to it across your project.

Object Names

SM_AssetName_Variant

Examples:

• SM_Chair_01
• SM_Wall_Brick_2m
• SM_Barrel_Damaged
• SK_Character_Player (for skeletal meshes)

Material Names

MI_MaterialName

Examples:

• MI_Wood_Oak
• MI_Metal_Steel_Worn
• MI_Fabric_Leather_Brown

Texture Names

T_AssetName_MapType

Examples:

• T_Chair_01_BaseColor
• T_Chair_01_Normal
• T_Chair_01_ORM (packed Occlusion/Roughness/Metallic)

Why This Matters

Engines use naming to auto-detect assets. UE5 recognizes "SM_" as Static Mesh, "SK_" as Skeletal Mesh, "MI_" as Material Instance. Consistent naming also makes file management tractable when your project grows to hundreds of assets.

Scale, Origin, and Orientation

Scale

• Apply scale in Blender before export. Ctrl+A > Scale. An object that was modeled at one size and then scaled in Object Mode will export with that unapplied scale, causing size mismatches in-engine.
• Use real-world units. 1 Blender unit = 1 meter for UE5 import. A door should be roughly 2m tall, a chair seat roughly 0.45m high. Set Blender's unit system to Metric.
• Verify scale after import. Place your asset next to a reference object (default cube = 1m) in-engine to confirm.

Origin Point (Pivot)

• Set the origin to the base of the object for most props. The bottom-center is standard so objects sit on the ground at position (0,0,0).
• Set the origin to the center of rotation for objects that rotate (doors, wheels, levers).
• Set the origin to the world origin (0,0,0) in Blender before export. This ensures predictable placement in-engine.

Orientation

• Blender uses Z-up. UE5 uses Z-up. Unity uses Y-up. FBX export handles conversion automatically for most cases, but verify that forward/right axes are correct in your engine.

Collision Meshes

Game engines need separate collision geometry for physics. Rendering geometry is too complex for real-time collision detection.

• Simple collision: Use basic primitives (box, sphere, capsule, convex hull) for most props. Name them with your engine's collision prefix (UCX_ for UE5 convex collision, UBX_ for box collision).
• Complex collision: For concave shapes (doorways, L-shaped walls), use multiple convex hulls. Each separate convex mesh gets its own UCX_ prefix.
• Keep collision simple. 8-32 triangles is usually sufficient for prop collision. The player will never see the collision mesh.

LODs (Level of Detail)

LODs reduce rendering cost for distant objects.

• LOD0: Full detail. This is your base mesh.
• LOD1: 50% of LOD0 triangles. Used at medium distance.
• LOD2: 25% of LOD0. Used at far distance.
• LOD3: 10% or less. Used at very far distance or as an impostor.

In Blender, generate LODs using the Decimate modifier with Collapse mode. UE5 can also auto-generate LODs on import using Nanite (for static meshes) or traditional LOD generation, but hand-authored LODs are cleaner.

Name LODs with a suffix: SM_Chair_01_LOD0, SM_Chair_01_LOD1, etc.

Wear and Damage

Adding wear and damage to pristine assets makes them feel real in a game environment. Edge scratches, surface dirt, paint chipping, rust — these details sell the illusion.

The Procedural Damage & Wear System can add these details non-destructively in Blender — edge wear, surface scratches, dirt accumulation, and material aging — before you bake your final texture maps. This is typically one of the last steps before baking, because wear effects reference the underlying materials.

Export Settings

FBX Export from Blender

The most common format for game engine import. Recommended settings:

• Forward: -Y Forward (or match your engine's expected orientation)
• Up: Z Up
• Apply Scalings: FBX All
• Apply Unit: Checked
• Apply Transform: Checked
• Mesh > Smoothing: Face (or export normals)
• Include: Only the mesh objects, armatures, and collision you need. Uncheck Camera, Lamp, etc.

glTF Export

Increasingly popular for its PBR material support and smaller file sizes:

• Format: glTF Binary (.glb) for single-file assets
• Include: Meshes, materials, textures
• Compression: Draco compression for reduced file size (if your engine supports it)

Pre-Export Final Check

Run through this quick list before every export:

1. All n-gons eliminated
2. No overlapping vertices (merge by distance)
3. Normals consistent (recalculate outside)
4. Scale applied (Ctrl+A)
5. Origin set correctly
6. UV maps complete, no overlapping (unless intentional)
7. Materials use Principled BSDF with plausible values
8. Naming conventions followed
9. Collision meshes created and named
10. LODs generated (if applicable)
11. Texture maps baked at correct resolution
12. File saved, then export

This checklist is not glamorous. It will not make your art more creative. But it will make your assets work the first time you import them, every time. And that saves more time than almost any other workflow improvement.