Quick Answer
Export the AI asset as FBX, scale it 100x into centimeters, rotate it to Z-up, pack your PBR maps into Unreal's ORM convention, then import and prove it in a real level. The one number that breaks most imports: Unreal's unit is 1 cm, but nearly every AI generator exports in meters with Y-up, so an untouched mesh lands 100x too small and lying on its side. Fix units and axis at export, not on every placed copy. Treat the asset as prototype-ready until it survives Unreal's lighting, collision, and Nanite-or-LOD decision in-engine.
The Two Things Unreal Cares About That Your Generator Ignores
Most "Unreal export" advice is generic 3D hygiene. The two failures that are specifically Unreal's are worth naming up front, because everything else in this guide is downstream of them.
Unit and axis convention. Unreal is centimeters and Z-up. The dominant AI export — GLB/glTF straight out of Meshy, Tripo, or Hunyuan — is meters and Y-up. That single mismatch produces the two most-reported import bugs: a character that arrives 2 units tall instead of 200, and a prop that imports flat on its back. Neither is a bug in the asset; both are convention collisions you resolve once at export.
Material and shading model. Unreal does not read a generator's "material" so much as a set of texture maps wired into its own shading model. It expects base color in sRGB, a tangent-space normal map, and roughness/metallic/AO packed into a single ORM texture (AO in Red, Roughness in Green, Metallic in Blue). An AI tool that hands you four loose, sRGB-flagged PNGs is not wrong — it just hasn't done Unreal's packing for you.
Decide the asset's job before you export, because the quality bar moves with it:
Prototype prop or greybox stand-in — speed beats topology. A raw AI mesh is usually fine.
Hero or close-up asset — clean topology, deliberate UVs, inspected PBR maps, and likely a retopology pass.
Set dressing — sane density (or Nanite) and a working collision proxy matter more than perfect geometry.
Cinematic or product-viz asset — material accuracy and surfaces that hold up under movie-quality lighting.
Have the mesh, the texture maps, and a note of the source units and up-axis in hand before you click download. AI tools rarely state units, so confirm them in a neutral viewer first.
Inspect the Mesh, Then Decide on Retopology
AI meshes can look finished in a render and still hide structure that Unreal will not repair. Before export, look for melted or fused geometry where parts blur together, non-manifold edges and stray holes that break shading and collision, wildly uneven density (a decorative bolt carrying more triangles than the body), detail that only reads from the hero angle, and inverted normals that show up as black or see-through faces in Unreal.
The decision this drives is retopology, and Unreal makes it interesting because of Nanite. For a static hero or dense set-dressing mesh, Nanite can swallow raw AI density without hand-authored LODs, so messy-but-watertight topology is often acceptable. For anything skeletal (animated), small, or translucent — none of which Nanite handles — rough topology is a real cost and a retopology pass before export pays off. For the broader judgment of what a generator gives you versus what a pipeline needs, see AI 3D model generation after the first mesh.
Fix Scale, Axis, and Pivot at Export
This is the cm/Z-up problem from the top, handled concretely so it never reaches your level:
Units. One Unreal unit is 1 cm, so a 2-meter character is 200 units. Export FBX with a 100x scale, or use Blender's Apply Transform, so the asset arrives at real-world size.
Up-axis. Unreal is Z-up; GLB and most AI exports are Y-up. Bake the corrective rotation before export rather than fixing it on every placed instance.
Pivot. Put the origin where the asset gets grabbed and snapped — base center for props, feet for characters. A pivot floating in space makes level layout miserable.
Apply transforms. Bake scale and rotation into the mesh so Unreal receives a clean 1,1,1 transform.
Choose the Format: FBX First, and Why
For Unreal the practical order is FBX first, with GLB and OBJ as situational fallbacks.
Format | Unreal support | Carries materials | Carries rig/animation | Best use for AI assets |
|---|---|---|---|---|
FBX | Native, most robust import path | Yes (material slots + textures) | Yes (skeleton, skin, anim) | Default for nearly all Unreal imports |
GLB / glTF | Supported via Interchange importer | Yes (packed PBR) | Yes | Web-first assets or when FBX is unavailable; watch the Y-up flip |
OBJ | Supported, geometry only | Material reference only | No | Static single-mesh props with no animation |
USD | Strong for scenes/layouts | Yes | Yes | Studio scene assembly, not single-asset handoff |
FBX is the safest default because Unreal's importer is built around it and it carries skeletons, multiple material slots, and LOD groups in one file. Newer Unreal versions route GLB through the Interchange framework, which is improving but still flips Y-up to Z-up on you if you let it. If you are weighing the two common AI export options, the tradeoffs in GLB vs FBX for AI 3D assets map directly onto this choice.
Pack Materials the Way Unreal Expects
Unreal wants a specific PBR set, and AI tools rarely name or pack maps to match:
Base Color — free of baked lighting or shadow; Unreal lights the surface.
Normal — confirm it is a tangent-space normal map, not a height or bump map, or details invert.
ORM — pack Roughness, Metallic, and Ambient Occlusion into one texture (AO/R, Roughness/G, Metallic/B) before import to keep material setup clean.
Color space — base color is sRGB; normal, ORM, and other data maps are linear, so uncheck sRGB on them after import.
Plan the material slot count up front. AI meshes often arrive as one giant material when the asset really wants two or three (body, glass, trim). Splitting at the source beats reassigning inside Unreal. The principles of clean PBR setup are in what PBR materials are.
Import Settings That Actually Move the Needle
When the FBX comes in, the import dialog decides how cleanly it lands. The settings worth getting right:
Import Uniform Scale — 100 if the asset was authored in meters.
Convert Scene Unit / Force Front XAxis — corrects axis if the source was Y-up and you did not bake the rotation.
Generate Lightmap UVs — enable for static meshes using baked lighting; AI assets rarely ship a clean second UV channel.
Combine Meshes — decide whether multi-part imports merge into one static mesh or stay separate.
Nanite — enable for high-poly static hero and set-dressing meshes so Unreal handles density without manual LODs; skip it for skeletal meshes and tiny props where it adds overhead.
Then build collision, because this is the step Unreal will not do for you: it does not auto-generate collision for complex AI meshes. Add a simple convex or box proxy for gameplay assets so they do not fall through the world. Per-poly collision is expensive and rarely needed.
Verify in a Real Level
Skip the empty grid. Drop the asset into a representative level next to a known reference — a character capsule, a standard 1-meter doorway — and run one combined pass instead of three overlapping checklists:
What to check | Pass condition | Where it failed if it doesn't |
|---|---|---|
Scale | Reads correct beside the capsule/door reference | Import Uniform Scale or export 100x |
Orientation + pivot | Upright, clean 1,1,1 transform, pivot where expected | Up-axis bake at export |
Materials | All slots resolve; textures connected; color space right | ORM packing / sRGB flags |
Lighting | Holds up under the level's real baked and dynamic light | Normal map space, lightmap UVs |
Collision | Behaves for gameplay; nothing falls through or snags | Collision proxy in-editor |
Frame cost | Triangles, draw calls, texture memory acceptable for the role | Nanite vs LOD decision, texture size |
Naming | Follows convention (SM_, SK_, M_, T_) and is in source control | Project naming pass |
If every row passes, the asset is genuinely usable. If a row fails, the right-hand column tells you which earlier step to revisit rather than patching it in-scene. Formalizing this into a team sign-off is what the production-ready AI 3D asset checklist is for.
The Mistakes That Actually Recur
A few failures are common enough to call out, none of which the table above already covers:
Trusting that import reveals everything. It reveals a lot, but by the time it surfaces, you may have cleanup debt across many placed instances. Inspect before handoff, not after.
Reaching for Nanite on the wrong asset. It is a static-mesh feature. Enabling it on a skeletal mesh or a tiny prop adds cost without benefit; those want traditional LODs or a hand-made low-poly version.
Treating a raw generation as production-ready. Most AI assets are prototype-ready until proven otherwise.
Prototype-ready means the asset communicates intent well enough to greybox a level or pitch a look. Production-ready means it survives real constraints: optimization, material standards, collision, the Nanite-or-LOD call, naming, review, and source control. The gap between the two is exactly what the in-level pass above measures.
Why the Prep Belongs Before Unreal
Unreal is the runtime and production environment. It is a poor place to be born and debugged in, because every fix you make there — rescaling, reorienting, repacking materials, building collision — gets baked into a level project that then accumulates half-finished experiments no one can tell apart.
In Customuse, that preparation happens earlier, on a visible node graph. Generation through providers such as Meshy, Tripo, or Hunyuan is one node; the steps Unreal cares about most — the 100x scale, the Z-up bake, the ORM pack, the mesh split, the retopology-or-Nanite call — sit downstream as explicit, reusable nodes rather than ad-hoc fixes. AI agents can assemble those steps in the canvas, a team can review the same candidate in real-time multiplayer instead of trading FBX files, and Cinema Studio lets you frame the asset under deliberate lighting before it ever crosses the engine boundary. The result is that the file reaching your Unreal project is the prepared version, already carrying its job, its status, and its export settings — so the level project stays a place for building worlds, not sorting through dumps. For the wider picture, see the AI 3D workspace.
FAQ
Can AI-generated 3D models be used in Unreal Engine?
Yes. They import like any other model, but they need inspection first — mesh quality, scale, orientation, materials, texture maps, collision, and frame cost. The asset that imports cleanly is the one prepared before export, not the one that happened to download without an error.
What format should I export for Unreal Engine?
FBX, in almost every case: Unreal's importer is built around it and it carries material slots, skeletons, animation, and LOD groups in one file. GLB/glTF works through the Interchange importer but watch the Y-up to Z-up flip. OBJ suits static single-mesh props with no animation. See GLB vs FBX for AI 3D assets for the full tradeoff.
Why does my AI 3D asset import at the wrong size in Unreal?
Unreal measures in centimeters (1 unit = 1 cm) while most AI generators export in meters. A meter-authored model needs a 100x scale to land correctly — set Import Uniform Scale to 100, or apply the scale at export. Fix it at the source, not by rescaling every placed instance.
Should I use Nanite for AI-generated meshes?
For dense static meshes — hero props and detailed set dressing — Nanite renders the geometry without hand-authored LODs, which suits high-poly AI output. Skip it for skeletal (animated) meshes and very small props, where traditional LODs or a low-poly version fit better. Either way, confirm frame cost in a real level.
Do I need to add collision to AI assets in Unreal?
Yes, for anything gameplay touches. Unreal does not auto-generate collision for complex imported meshes, so add a simple convex or box proxy in the editor. Reserve per-poly collision for shapes that genuinely need it, since it is far more expensive.
