Quick Answer
To export an AI 3D asset for Unity, export to FBX or glTF/GLB, then fix the predictable import problems before you trust the asset: set the correct scale factor (Unity expects 1 unit = 1 meter), ground the pivot at the object's base, point the mesh forward on +Z, extract and remap materials to a URP or HDRP shader, and pack textures into ORM/mask maps. Then drop the asset into a real scene with your target lighting and camera, add a collider if it needs one, and build LODs if it's a hero prop. The export is not the finish line. The Unity import is the test, and most generated assets fail it the first time on scale, materials, or polycount.
What You Need Before You Export
Do not start the handoff until you have these in hand. Skipping them is the single biggest cause of reimport churn.
A clean, inspected mesh. Watertight where it should be, no inverted normals, no stray floating geometry.
A known target use. Static environment prop, interactable, character, or skinned mesh. The use decides the rules.
Your render pipeline. Built-in, URP, or HDRP. The pipeline determines which shader your materials must map to, and a material authored for the wrong one shows up magenta in Unity.
A texture set with named maps. Albedo (base color), normal, and a metallic/roughness or ORM map at minimum. Loose, unnamed textures get lost on import.
A real reference scale. "It looked big in the preview" is not a measurement. Know that the crate is 1.2 m or the sword is 0.9 m so you can verify scale on arrival.
If any of these are missing, fix them upstream. Importing a broken asset just relocates the problem into your Unity project, where it costs more to find.
Step 1: Pick the Right Export Format
Unity ingests several formats, but two carry almost all professional work. Choose based on what the asset has to carry.
Format | Best for in Unity | Carries | Watch out for |
|---|---|---|---|
FBX | Skinned characters, rigs, animation, studio pipelines | Mesh, skeleton, animation clips, material slots, multiple LOD meshes | Embedded vs. linked textures; FBX scale baked at export |
glTF / GLB | Static props, PBR-heavy assets, web-adjacent pipelines | Mesh, PBR materials, packed textures (GLB) | Needs a glTF importer package; animation support varies |
OBJ | Quick static drops, prototyping | Mesh + UVs only | No animation, no real material data, no scale unit |
For anything with a skeleton or animation, use FBX. For a static prop with clean PBR materials, GLB is compact and self-contained. OBJ is fine for a throwaway prototype where you only need the silhouette. If your team already standardizes on FBX or GLB, follow that standard over any general advice here. For a deeper format breakdown, see the guides linked at the end.
Step 2: Fix Scale, Pivot, and Orientation Before Import
These three are responsible for the most "why is my crate the size of a building" tickets. Set them before Unity ever sees the file.
Scale. Unity's world unit is one meter. AI generators and many DCC tools export in centimeters or arbitrary units, so an asset can arrive 100x too large or vanishingly small. In the FBX Import Settings, set Convert Units on and verify the Scale Factor (FBX from centimeter sources usually wants 0.01). Confirm against your known reference measurement, not by eye.
Pivot / origin. Place the origin where Unity will rotate and snap the object. For a floor prop, ground the pivot at the base center so it sits flat at y = 0. For a wall-mounted piece, put it at the mount point. A pivot floating in the geometric center makes placement and rotation miserable.
Orientation. Unity is left-handed, Y-up, and treats +Z as forward. Many tools are right-handed or Z-up, so a model can arrive lying on its back or facing away. Bake the correct rotation at export, or apply a corrective rotation on a parent before you make the prefab, so the asset's forward matches Unity's.
Step 3: Extract and Remap Materials
A generated material almost never maps cleanly onto a Unity render pipeline shader on first import. Handle it deliberately.
In the model's Import Settings under the Materials tab, choose Extract Materials so Unity creates editable material assets instead of read-only embedded ones.
Reassign each material to the correct pipeline shader: URP/Lit for URP, HDRP/Lit for HDRP, or Standard for Built-in. A material that stays on a foreign shader renders as flat magenta.
Confirm the material slot count matches what you expect. Five slots on a single rock means five draw calls. Merge materials upstream where the asset can share one atlas.
Step 4: Wire Up Textures and Compression
Materials are nothing without correctly assigned maps, and Unity has its own packing conventions.
Assign Base Color (Albedo), Normal Map, and a Metallic/Smoothness map to each material. Mark the normal map's texture type as Normal map in its import settings or lighting will look wrong.
Unity's URP/HDRP Lit shader uses smoothness, not roughness. If your generator output roughness, you may need to invert it or pack it into the alpha channel of the metallic map. Many studios standardize on an ORM (occlusion, roughness, metallic) packed texture; map its channels to Unity's mask map slot in HDRP.
Set texture Max Size to the real budget. A 4K texture on a background pebble wastes memory; 512 or 1024 is plenty. Confirm compression is on (typically to a BCn format) so the asset doesn't bloat your build.
If a texture reads as too dark or too bright, check the sRGB (Color Texture) flag — color maps want it on, data maps like normal and ORM want it off.
Step 5: Optimize Polycount, Add Colliders, and Build LODs
This is where a generated asset becomes a Unity asset rather than a viewer trinket.
Polycount. AI meshes are frequently dense and triangulated with no topology logic. For a prop seen at distance, decimate hard. A background barrel does not need 80,000 triangles. Retopology upstream produces cleaner results than Unity's automatic mesh simplification.
Colliders. Visual mesh is not collision. Add a primitive collider (box, capsule, sphere) wherever you can — they are far cheaper than a Mesh Collider, which should be reserved for shapes that genuinely need it and set to convex when used on a Rigidbody.
LODs. For hero or repeated assets, set up an LOD Group with two or three reduction levels so distant copies render cheaply. See the LOD guide linked below for how many levels and what triangle drop-off to target.
Prefab. Once scale, materials, colliders, and LODs are correct, save the configured object as a prefab. The prefab — not the raw imported model — is what the rest of the team should instance.
Unity Handoff Settings Checklist
Run this before any asset enters a Unity project. Mark each row pass or fail; one fail sends the asset back upstream.
Check | Target / setting | Pass when |
|---|---|---|
Format | FBX (rig/anim) or GLB (static PBR) | Matches the asset's needs and team standard |
Scale factor | 1 unit = 1 m; convert units on | Matches a known real-world measurement |
Pivot / origin | At base or mount point | Object snaps and rotates predictably |
Orientation | +Z forward, Y up | Faces correct direction in scene |
Material slots | Minimized; shared atlas where possible | No surprise extra draw calls |
Shader | URP/HDRP/Standard Lit | No magenta materials |
Normal map | Texture type = Normal map | Lighting reads correctly |
Smoothness vs. roughness | Converted to Unity convention | Surface looks right under light |
Texture max size | 512–2048 by importance | No 4K maps on background props |
sRGB flags | On for color, off for data maps | Albedo and normals both correct |
Polycount | Budgeted to view distance | No needless density |
Collider | Primitive where possible | Cheap, correct collision |
LODs | LOD Group for hero/repeated | Distant copies render cheap |
Naming + prefab | Clear name, saved prefab | Team instances the prefab, not raw model |
Common Mistakes and How to Fix Them
Importing too early. A model that looks fine in a browser preview arrives in Unity with wrong scale, broken materials, oversized textures, and no collision plan. Fix: run the checklist above before the file touches the project.
Magenta materials everywhere. This means the material is on a shader the active render pipeline doesn't understand. Fix: extract materials and reassign them to the matching Lit shader (URP/HDRP/Standard).
Asset is 100x too big or too small. A unit mismatch between the source tool and Unity's meters. Fix: turn on Convert Units and set the correct Scale Factor, then verify against a real measurement, not by eye.
Object faces the wrong way or lies on its side. A handedness or up-axis mismatch. Fix: bake the corrective rotation at export or on a parent transform before making the prefab.
Build size balloons. Usually 4K textures on minor props and uncompressed maps. Fix: cap texture Max Size by importance and confirm BCn compression is on.
Mesh collider tanks physics performance. A high-poly Mesh Collider on a moving object is expensive. Fix: use primitive colliders, or a low-poly convex collider, and reserve full Mesh Colliders for static geometry that truly needs them.
How to Verify the Result in Unity
Verification happens in context, not in the Inspector.
Drop it into a real scene with your target lighting, post-processing, and camera. A material that looks great in a neutral viewer can fall apart under your scene's lighting.
Check scale next to a reference object — a character controller capsule or a known-size prop. The new asset should read correctly beside it.
Walk the camera around it at gameplay distance. Does the silhouette read? Do you see backface holes, inverted normals, or seams?
Enter Play mode and stress it. Instance it the number of times it'll actually appear. Watch the Frame Debugger and Profiler for draw-call and triangle spikes.
Test collision and interaction if the asset is interactable. The player should not walk through it or get stuck on invisible geometry.
If it passes all five, it's a Unity asset. If not, it's still a candidate, and the fix belongs upstream, not buried in scene overrides.
Prototype vs. Production: Don't Use the Same Bar
For a prototype, a rough generated prop can go straight in. The goal is speed, and gray-box-quality assets are fine. For production, the bar is much higher: clean topology, optimized polycount, correct PBR materials, LODs, colliders, naming standards, and an art-direction review. Decide the asset's status before it reaches the Unity project, because that status sets how strict the import review should be. A prototype can be rough; a production candidate needs a genuinely clean handoff.
Keeping the Work Visible Before Export
AI-generated assets multiply fast, and a Unity project fills with files no one can tell apart — which are tests, which are approved, which still need cleanup. This is where doing the AI 3D work inside a workflow workspace pays off before the handoff. In Customuse, the generation, retopology, texturing, and export steps live as visible nodes in one canvas, so the state of an asset — source reference, format, texture budget, polycount note, cleanup flags — travels with it instead of getting lost. Customuse uses model providers like Meshy, Tripo, and Hunyuan as nodes inside that larger graph, which means the asset that reaches Unity has already been shaped, reviewed, and exported as the strongest version, not dumped raw from a one-shot generator. Unity is still where the asset is implemented and validated. The workspace is where it gets prepared.
Related Guides
FAQ
Can AI 3D assets be used in Unity?
Yes. Export to FBX or GLB, then verify scale, pivot, orientation, materials, textures, and polycount before you trust the asset in a scene. Generated assets are not Unity-ready by default — they pass once you fix the import settings and confirm behavior in a real scene with your target lighting and camera.
What is the best format to export AI 3D assets for Unity?
Use FBX for anything with a rig or animation, since it carries the skeleton, clips, and material slots. Use glTF/GLB for static PBR props because it packs mesh and textures into one compact, self-contained file. Use OBJ only for quick prototypes — it carries no animation, scale unit, or real material data. Above all, follow your team's existing pipeline standard.
Why are my imported materials showing up pink or magenta in Unity?
Magenta means the material is assigned to a shader the active render pipeline does not understand — for example, a Built-in Standard material in a URP project. Fix it by extracting the materials in the model's Import Settings and reassigning each one to the matching Lit shader (URP/Lit, HDRP/Lit, or Standard), then reconnecting the albedo, normal, and metallic maps.
Why is my AI 3D model the wrong size in Unity?
Unity treats one unit as one meter, while many AI generators export in centimeters or arbitrary units, so a model can land 100x too large or too small. Turn on Convert Units in the FBX Import Settings and set the correct Scale Factor (often 0.01 for centimeter sources), then confirm against a known real-world measurement rather than judging by eye.
Do AI-generated assets need optimization before going into Unity?
Usually yes. Generated meshes are often dense and triangulated with no topology logic, materials may use too many slots, and textures are frequently oversized. For production, plan on retopology, polycount reduction to fit view distance, material/texture cleanup, primitive colliders, and an LOD Group for hero or repeated assets before the handoff is complete.
