How to Prep an AI-Generated 3D Model for Unity (GLB/OBJ, Scale, Materials)

For a clean Unity import, take GLB in through a free glTF package (glTFast is the one to reach for) so textures arrive embedded, or export OBJ if you'd rather skip the package entirely — Unity imports OBJ natively. Then fix the two things that bite everyone: scale (Unity treats 1 unit as 1 metre, and OBJ carries no unit info) and materials (Unity auto-links textures only if they sit in a folder named Textures next to the mesh). This guide walks through both, plus a real-time poly budget — and is honest that an AI-generated mesh is a static prop, not a rigged character.

GLB vs OBJ: GLB for embedded textures, OBJ for a zero-package import

GLB is a single binary file that packs the mesh, the materials, and the textures together. Nothing to lose, nothing to relink — you bring one file in and the model arrives with its maps attached. That alone removes the most common cause of a "pink/grey model in Unity" support thread. GLB is also glTF 2.0, which carries proper PBR material definitions (base colour, metallic-roughness, normal, occlusion), so a model exported with PBR textures lands in Unity already looking close to its source. The catch: Unity won't read GLB without a package (covered in the next section).

OBJ is older and splits into pieces: the .obj geometry, a .mtl material file, and loose texture images that the .mtl references by relative path. If any path is wrong or a file goes missing, materials silently fall off. OBJ also stores no scale unit, and its normals and units are less reliable than glTF's, so you do a little more cleanup by hand. Its one real advantage is that Unity imports OBJ natively — no package needed — which is handy if you don't want glTFast in the project.

HIBR 3D exports both: GLB and OBJ for games/AR, plus STL for printing. Take the GLB into Unity for embedded textures, or grab the OBJ for the no-package path. If you generate on the Ultra 4K tier, the PBR texture set comes through in the GLB, which is what makes the material "game-ready" rather than a flat colour.

Import GLB with glTFast (or use UnityGLTF)

Unity does not import GLB natively — install a package first. The modern, Unity-maintained one is glTFast. Open Window > Package Manager, click the + (Add package by name), and enter com.unity.cloud.gltfast. It works across the Built-In, URP, and HDRP render pipelines, so it fits whatever your project already uses. (UnityGLTF is a solid alternative importer if you prefer it — either gets a .glb into the project; or skip both and import the OBJ, which Unity reads on its own.)

With glTFast installed, drag the .glb into your Assets folder. Unity imports it as a model asset with its materials and textures generated automatically, and you can drop the resulting prefab straight into a scene. glTFast also handles the coordinate-system conversion for you: glTF is Y-up and right-handed while Unity is Y-up and left-handed, so the importer flips the handedness on the way in. If a model still faces away from the camera after import, that's just the asset's own authored orientation, not a Unity or glTFast bug — rotate the prefab 180 degrees on Y and move on.

One render-pipeline gotcha: if the model imports but appears solid magenta, your project's render pipeline doesn't match the generated material's shader. Switch the material to your pipeline's lit shader (URP/Lit or HDRP/Lit) and the maps reconnect.

Fix the scale: Unity is 1 unit = 1 metre

Unity's physics, lighting, and navigation all assume 1 world unit equals 1 metre. An AI-generated mesh is normalised to an arbitrary bounding size, so on import a "coffee mug" can land two units tall (two metres) or a fraction of a unit — almost never its real-world size. Fix it before you build anything around it, because parenting, colliders, and lightmaps all inherit the wrong scale otherwise.

For GLB via glTFast, select the imported asset and set the Scale value in the import settings, or just set the Transform scale on the prefab instance until a known dimension reads correctly in the Scene view (drop in a 1x1x1 Unity cube as a 1-metre ruler and eyeball against it). For OBJ — which stores no unit at all — open the model's Import Settings and use Scale Factor; Unity's default OBJ Scale Factor is often 1, so if your object is wildly large or small, set the factor to bring its real dimension to metres (e.g. a 25 cm helmet should measure 0.25 units tall). Apply, then verify against the cube. Doing this once at import beats scaling every instance later.

Make materials hook up automatically (the Textures folder)

Unity's model importer has a specific search order for textures: it first looks for a subfolder named exactly Textures sitting next to the mesh file (or in any parent folder up the tree), and only if that fails does it run an exhaustive project-wide search. So the reliable pattern is: put the mesh in a folder, and put its texture images in a Textures subfolder right beside it. Then Unity finds each map and wires it into the generated material without you dragging anything.

This matters most for OBJ, where textures are external files the .mtl points to. Keep the exported images together, drop them in /Textures next to the .obj, and re-import. For GLB the textures are embedded so this is usually moot — but if you'd rather edit them, select the asset and use Extract Textures (and Extract Materials) to pull them out as real project files you can swap or compress.

If a material still reads as flat colour, check three things: the texture is actually in the project, the normal map is flagged as a Normal map in its import settings (otherwise lighting looks wrong), and the shader matches your render pipeline. HIBR 3D's Ultra 4K PBR output gives you the full metallic-roughness set, so once the maps are connected the surface responds correctly to scene lighting instead of looking painted-on.

Budget your polygons for real-time

AI generators optimise for visual fidelity, not frame rate, so a single generated asset can ship with hundreds of thousands of triangles — fine for a hero render, wasteful for a game where dozens of objects share a frame. Set a budget by role. Rough working targets for modern PC/console: a small background prop 1k–5k triangles, a mid-ground interactive prop 5k–20k, and a true hero object up to ~50k+. For mobile and standalone VR, cut those by roughly half and watch total scene draw, not just one mesh.

If a generated mesh overshoots, decimate it. Blender's Decimate modifier (Collapse) or Unity's own mesh-simplification tooling will drop triangle count substantially with little visible loss on an organic prop — bring the high-poly in, target a triangle count, and bake. Check the real number in Unity's Stats overlay (Game view > Stats) or the Profiler rather than trusting the source figure.

Also watch texture resolution: a 4K PBR set looks great up close but eats memory fast across many props. Set a per-platform Max Size on the texture import (1K or 2K is plenty for most props) and enable mipmaps so distant objects sample cheaper versions.

Know the limit: these are static meshes (props, not characters)

Be clear-eyed about what an AI-generated mesh is: a static, single-pose model with no skeleton, no skin weights, and no animation. HIBR 3D outputs static meshes only — it does not rig or animate. That's not a flaw, it's a scope: it makes these assets ideal for props and set dressing — crates, rocks, furniture, terrain features, weapons-as-pickups, environment clutter — anything that sits in the world and doesn't need to deform.

If you need the asset to move or articulate, rig it separately downstream. Import the mesh into Blender (or Maya), build an armature, paint weights, author the animation, and export an FBX with the rig for Unity's Animator. The AI step gives you the geometry fast; the rigging step stays a normal DCC workflow. Plan for this split up front: use generated assets where static is the right answer, and reserve hand-rigged or store-bought characters for anything that needs to walk, talk, or open.

For everything in the static-prop lane, the path is genuinely fast: generate, export GLB with PBR, bring it into Unity via glTFast (or import the OBJ for a no-package start), fix scale once, confirm the Textures folder, set a poly/texture budget — and it's in your scene. Every model carries a full commercial license, so the props can ship in a game you sell.

FAQ

More guides