Bringing MeshForge models into Unity, Unreal and Godot

A generated model is only useful once it behaves like any other asset in your project: the right size, the right materials, sensible collision and good performance. Each engine has its own preferred format and a few import settings that make the difference. This guide covers Unity, Unreal Engine and Godot, then a checklist that applies to all three.

Before you export: a pre-flight checklist

• Check the polycount. If the model is dense, run Retopology first (500–100,000 faces) so detail is baked into the normal map.
• Choose PBR texturing so you get base colour, roughness, metalness and normal maps that engines understand.
• Rig in MeshForge if the model is a character, and add the clips you need before export.
• Pick the format for your engine (below). GLB and FBX both keep rigs and animations.
• Name things. Rename the file and animation clips so they are easy to find later.

Unity

Unity's manual describes FBX as its primary supported model format. For glTF, Unity provides the glTFast package, which imports .glb and .gltf files in the editor and can also load them at runtime, across the Universal, High Definition and Built-In render pipelines.

Import FBX: drag the file into the Project window. In the model's Import Settings:

• Model tab: check Scale Factor and Convert Units so the model is the right size; enable Generate Lightmap UVs for static props that will receive baked lighting.
• Rig tab: set Animation Type to Humanoid for humanoid characters (to use Unity's retargeting) or Generic for other skeletons.
• Animation tab: check the clips were found, set loop options for walk and idle cycles.
• Materials tab: extract materials if you want to edit them, and assign your pipeline's lit shader.

Import GLB: install glTFast from the Package Manager, then drag the .glb into the project. Materials are created for your render pipeline automatically.

Unity's guidance on characters is worth following: use a single skinned mesh per character where you can, and keep the number of materials low.

Unreal Engine

Unreal's FBX content pipeline imports static meshes, skeletal meshes, animation and morph targets from one format, and can create materials and textures on import.

Import FBX: drag the file into the Content Browser. In the import dialog:

• For props, import as a Static Mesh. Enable Combine Meshes if the file contains several parts that belong together.
• For rigged characters, import as a Skeletal Mesh and let Unreal create the skeleton; animation clips import alongside it.
• Import normals and tangents from the file so the normal map matches the way it was baked.
• Check the import scale; Unreal works in centimetres.

Nanite: for dense static meshes in projects that use it, Unreal's Nanite virtualized geometry can render very high polygon counts efficiently. It does not help download size or editing, and it does not apply to every mesh type, so retopology is still useful for many assets.

Godot

Godot's documentation lists glTF 2.0 as the recommended 3D format, and notes that binary .glb is the smaller option with textures embedded. Godot 4.3 and later also import FBX natively using ufbx.

Import GLB: copy the file into your project folder. Godot imports it as a scene with meshes, materials, skeleton and animations. Double-click it to open the Advanced Import Settings, where you can:

• generate collision shapes per mesh,
• set animations to loop,
• extract materials to separate resources for editing,
• adjust the root scale.

To place the model, instance the imported scene in your level. For a character, add a CharacterBody3D parent and use the AnimationPlayer inside the imported scene to play clips.

Engine comparison at a glance

	Unity	Unreal Engine	Godot
Preferred format	FBX (glTF via glTFast)	FBX	glTF / GLB (FBX supported)
Rig & animation	Humanoid or Generic rig types	Skeletal Mesh + Skeleton asset	AnimationPlayer in the imported scene
Scale to check	Scale Factor / Convert Units	Import uniform scale (cm)	Root scale in import settings
Collision	Add colliders on the prefab	Auto or custom collision on import	Generate per mesh in import settings

Common problems

Symptom	Likely cause	Fix
Model is tiny or huge	Unit mismatch	Adjust import scale once, then reuse the settings
Normal map looks inverted	Green channel convention	Flip green in texture import settings
Materials look flat grey	Textures not linked or shader not supported	Re-link textures or use the engine's lit shader
Character bends badly at joints	Weights or low joint resolution	Retopologise with more faces, fix weights in Blender
Frame rate drops with many copies	Too many triangles or materials	Retopologise, use LODs, share materials

Materials: getting the look right

A GLB from MeshForge with PBR texturing carries a metallic-roughness material: base colour, roughness, metalness and a normal map. Each engine maps that onto its own standard lit material:

• Unity: glTFast creates materials for your render pipeline on import. For FBX, assign the textures to your pipeline's lit shader — base colour to the albedo slot, the normal map to the normal slot (marked as a normal map in its texture import settings).
• Unreal Engine: FBX import can create a material instance; check that the normal map is imported as a normal map and that roughness and metalness are read from the right texture channels.
• Godot: glTF materials import as StandardMaterial3D resources with the maps already connected.

If a model looks noticeably different in your engine than in the MeshForge viewer, check colour space first: base colour textures are sRGB, while roughness, metalness and normal maps are linear data.

Collision and physics

Rendered meshes are rarely good collision shapes. For props, use simple primitives (boxes, capsules, spheres) or a convex hull, and keep the detailed mesh for rendering only. For characters, engines provide capsule-based controllers that ignore the mesh shape entirely.

Sources & further reading

• Unity Manual: importing model files and FBX importer Model tab.
• Unity glTFast — glTF import and runtime loading in Unity.
• Unity Manual: Modeling characters for optimal performance.
• Unreal Engine: FBX content pipeline and Nanite.
• Godot: available 3D formats.
• Khronos glTF 2.0 specification.