How to Export Textures for Unity, Unreal, and Godot
Getting your textures out of a tool like Trumble and into your game engine correctly is the final step in the PBR workflow — and it's where a lot of artists get tripped up. Each engine has its own expected formats, channel conventions, and import settings. This guide covers exactly what each engine needs so your materials look right the first time.
File Formats — What to Export As
Before looking at engine-specific requirements, it helps to understand the texture file formats you'll be working with. Different maps have different needs when it comes to color space and compression compatibility.
| Format | Best for | Notes |
|---|---|---|
| PNG | All maps — the safe universal choice | Lossless, supports alpha channel, widely supported everywhere. Larger file size than JPG but no quality loss. |
| JPG / JPEG | Albedo / color maps only | Lossy compression — never use for normal maps, roughness, or metallic. The compression artifacts will cause visible shading errors. |
| TGA | All maps — preferred by some pipelines | Lossless, supports alpha, fast to read. Older format but still widely used especially in Unreal pipelines. |
| EXR | HDR maps, emissive, displacement | 16 or 32-bit float precision. Overkill for standard PBR maps but essential for HDR emissive or height data. |
| WebP | Web-based games, browser engines | Smaller file size than PNG with near-lossless quality. Good for WebGL projects targeting fast load times. |
Channel Packing — Saving Texture Memory
Channel packing is the technique of storing multiple grayscale maps in the R, G, B, and A channels of a single RGBA texture. Since roughness, metallic, and AO are all single-channel grayscale data, you can combine three maps into one texture — reducing texture samples from three to one and saving significant GPU memory and bandwidth.
Without channel packing
Three separate texture samples: one for Roughness, one for Metallic, one for AO. Three texture lookups per pixel in the shader. More GPU memory used.
With channel packing (ORM)
One texture, three channels: R = Occlusion, G = Roughness, B = Metallic. One texture lookup per pixel. Roughly 3× the memory efficiency.
The most common channel packing convention is called ORM — Occlusion in Red, Roughness in Green, Metallic in Blue. This is what Unreal Engine expects by default. Unity uses a slightly different packing called MADS for its Mask Map. Knowing which convention your engine uses prevents you from plugging channels in incorrectly.
Exporting for Unity
Unity's Universal Render Pipeline (URP) and High Definition Render Pipeline (HDRP) both use PBR materials. The standard Lit shader in both pipelines accepts the following maps:
T_AssetName_D or _BaseColorT_AssetName_NT_AssetName_MT_AssetName_MetallicSmoothT_AssetName_AOT_AssetName_EUnity HDRP Mask Map Channel Layout
¹ Smoothness = inverted roughness (1 − Roughness). Invert your roughness map before packing into the Alpha channel.
Exporting for Unreal Engine
Unreal Engine uses a well-established PBR convention that most texturing tools — including Trumble — target by default. Unreal's standard material inputs are straightforward, and its ORM packing convention is widely supported.
T_AssetName_D or _BCT_AssetName_NT_AssetName_ORMT_AssetName_EUnreal ORM Channel Layout
_D (diffuse/base color), _N (normal), _ORM (packed mask). Using these suffixes means Unreal will automatically assign textures to the correct material slots when you drag a mesh into the editor.Exporting for Godot
Godot 4's StandardMaterial3D uses a clean Metal/Roughness PBR workflow and accepts separate maps for each channel — no channel packing required, though packing is supported via the ORM texture option. Godot is one of the most straightforward engines to set up PBR materials in.
Exporting from Trumble
Trumble's export system is built around these engine conventions. Rather than exporting raw channels and figuring out packing yourself, Trumble's export presets handle the channel layout, format, color space, and naming for your chosen target engine automatically.
| Export Preset | Maps Generated | Format |
|---|---|---|
| Unity URP | Base Color (sRGB), Normal (linear), Metallic+Smoothness (R+A), AO (linear) | PNG |
| Unity HDRP | Base Color (sRGB), Normal (linear), Mask Map MADS (R=Metal, G=AO, B=Detail, A=Smooth) | PNG |
| Unreal Engine | Base Color (sRGB), Normal (linear), ORM packed (R=AO, G=Rough, B=Metal) | PNG / TGA |
| Godot 4 | Albedo (sRGB), Normal (linear), Roughness (linear), Metallic (linear), AO (linear) | PNG |
| Roblox | Color Map, Normal Map, Roughness Map, Metalness Map | PNG |
| Raw PBR | All channels exported separately — no packing. For custom pipelines. | PNG |
Select your target engine in the Export panel, choose your output resolution, and Trumble generates the complete set of correctly formatted, correctly named texture maps ready to drop straight into your project. No manual channel packing, no color space headaches, no renaming files.
Naming conventions
Each preset applies the correct suffix conventions for that engine — _N for normals, _ORM for packed masks in Unreal, _BaseColor for Unity — so auto-import systems work as expected.
Color space handled automatically
Trumble tags sRGB maps correctly and exports linear maps without gamma encoding. You don't have to remember which maps are which — the presets handle it.