Getting your textures out of Substance Painter correctly is half the battle. The wrong export preset wastes hours of debugging missing channels, broken roughness maps, and inverted normals — on every single asset. This guide locks down the exact settings for Unity URP, Unity HDRP, Unreal Engine 5, and Godot 4, including custom channel-packing presets you can reuse across your entire pipeline.
Understanding Texture Sets and Export Templates
Before touching the export dialog, understand what Substance Painter is actually exporting. A Texture Set maps to one UV tile and one material slot in your target engine. If your asset has multiple material IDs (e.g., a character with a skin set, a cloth set, and armor), each gets its own texture set — and its own batch of output maps.
Substance Painter ships with built-in export templates (called Output Templates) that define:
- Which channels to bake into which map files
- The file format (PNG, EXR, TGA)
- The bit depth (8-bit, 16-bit, 32-bit float)
- How channels are packed (R, G, B, A slots)
You access these under File → Export Textures → Config tab. The drop-down at the top lists every available preset. Crucially, the built-in presets — "Unreal Engine 4 (Packed)", "Unity 5 (Standard Metallic)", etc. — are often out of date or mismatched for current engine versions. Always inspect the channel mapping before using them blindly.
The golden rule: know which maps your engine expects, then configure exports to match exactly. Every engine uses BaseColor/Albedo and a Normal map, but the packed ORM (Occlusion-Roughness-Metallic) or MRA format differs by pipeline.
Exporting for Unity URP and HDRP
Unity's Universal Render Pipeline (URP) and High Definition Render Pipeline (HDRP) use different packed texture conventions, which is a common source of confusion.
Unity URP Export Settings
URP's Lit shader expects:
- BaseMap: BaseColor (RGB) + Alpha (A) — PNG, 8-bit
- MetallicGlossMap: Metallic (R), Smoothness (A) — no G/B needed
- BumpMap: Normal map DirectX format (flip G channel in SP)
- OcclusionMap: AO in R channel only
In Substance Painter's Export dialog, duplicate the "Unity 5 (Standard Metallic)" preset and rename it "Unity URP". Edit the output maps:
```
BaseColor_Opacity: $mesh_$textureSet_BaseColor
R: BaseColor.r G: BaseColor.g B: BaseColor.b A: Opacity
Metallic_Smoothness: $mesh_$textureSet_MetallicSmooth
R: Metallic G: 0 B: 0 A: Roughness (inverted → Smoothness)
Normal: $mesh_$textureSet_Normal
Format: Normal OpenGL → flip to DirectX in SP
```
Key setting: Unity uses Smoothness, not Roughness. In the channel packing for the Alpha slot, set source to `user0` or use the Roughness channel with Invert checked.
Unity HDRP Export Settings
HDRP's Lit shader uses a Mask Map in the format: R=Metallic, G=AO, B=Detail Mask, A=Smoothness. This is HDRP-specific and not compatible with URP or any other engine.
```
MaskMap: $mesh_$textureSet_MaskMap
R: Metallic G: AmbientOcclusion B: 0 (or Detail) A: Roughness (inverted)
```
Export resolution: for hero assets, 4096×4096 PNG. For environment props, 2048 is sufficient.
Exporting for Unreal Engine 5
Unreal Engine 5 uses a packed ORM map: Occlusion (R), Roughness (G), Metallic (B). This is baked into a single texture to save texture samples in the material graph.
UE5 also expects DirectX normal maps (G channel NOT flipped). Substance Painter defaults to OpenGL normals, so you must either:
- Set Normal Map Format to DirectX in Substance Painter's project settings, or
- Flip G in the export config under the Normal map output
Recommended UE5 export config:
```
BaseColor: $mesh_$textureSet_BaseColor (RGB, 8-bit PNG)
ORM: $mesh_$textureSet_OcclusionRoughnessMetallic
R: AmbientOcclusion G: Roughness B: Metallic A: 255
Normal: $mesh_$textureSet_Normal (DirectX, 8-bit PNG)
Emissive: $mesh_$textureSet_Emissive (RGB, 8-bit PNG — only if used)
```
For high-fidelity hero assets, use 16-bit PNG for the Normal map to avoid banding artefacts in grazing-angle lighting. UE5's default material function `M_Asset_Base` already has ORM wired up correctly if you drop it from the BitSoul marketplace — no manual node wiring needed.
Exporting for Godot 4
Godot 4's StandardMaterial3D and ORMMaterial3D each accept textures differently:
StandardMaterial3D (most common):
- Albedo: BaseColor (RGBA)
- Metallic: single-channel (R), not packed
- Roughness: single-channel (R), not packed
- Normal: OpenGL format (Substance Painter's default — no flip needed)
- AO: single-channel (R)
ORMMaterial3D (performance-optimized):
- Uses a packed ORM in the same R=AO, G=Roughness, B=Metallic format as UE5
For most Godot 4 workflows, export individual unpacked maps unless you're specifically using ORMMaterial3D. Godot's importer handles channel separation poorly if you feed it a packed ORM into StandardMaterial3D.
```
# Godot 4 StandardMaterial3D export config
Albedo: $mesh_$textureSet_Albedo R:BaseColor.r G:BaseColor.g B:BaseColor.b A:Opacity
Metallic: $mesh_$textureSet_Metallic R:Metallic (single channel, 8-bit)
Roughness: $mesh_$textureSet_Roughness R:Roughness (single channel, 8-bit)
Normal: $mesh_$textureSet_Normal OpenGL format
AO: $mesh_$textureSet_AO R:AmbientOcclusion
```
Godot 4 imports PNG at 8-bit by default. For normal maps, ensure you flag the import as Normal Map in the Godot import panel to get correct sRGB → linear conversion.
Channel Packing and Custom Export Presets
Custom export presets are Substance Painter's most underused feature for studio pipelines. Once you've configured the correct channel assignments for each engine, save them as named presets so every artist on the team exports identically.
| Engine | Normal Format | Roughness | Packed Map | Bit Depth |
|---|---|---|---|---|
| Unity URP | DirectX | Smoothness (inverted) | MetallicSmooth (RA) | 8-bit PNG |
| Unity HDRP | DirectX | Smoothness (inverted) | MaskMap (RGBA) | 8-bit PNG |
| Unreal Engine 5 | DirectX | Roughness | ORM (RGB) | 8-bit / 16-bit Normal |
| Godot 4 (Standard) | OpenGL | Roughness | None (unpacked) | 8-bit PNG |
| Godot 4 (ORM) | OpenGL | Roughness | ORM (RGB) | 8-bit PNG |
To create a reusable preset: in the Export Textures dialog, configure all output maps, then click the floppy disk icon next to the preset dropdown and choose "Save Current Settings As New Template". Store these `.spexp` preset files in version control alongside your project.
For teams using multiple engines, name presets unambiguously: `BitSoul_URP_v1`, `BitSoul_UE5_v1`, `BitSoul_Godot4_Standard_v1`. Version-stamp them — Substance Painter's export format can shift between major versions.
If you're sourcing game-ready assets that already ship with correctly exported texture sets, the BitSoul marketplace includes assets with engine-specific texture variants included — no manual re-export required.
Closing Thoughts
Substance Painter's export system is powerful but unforgiving — one mismatched channel packing wastes an hour of shader debugging. The workflow is the same regardless of engine: know your target's expected format, configure a named preset once, verify it on a test asset, then lock it down for the team.
For UE5, ORM + DirectX normal. For Unity HDRP, MaskMap + DirectX normal. For Godot 4 Standard, unpacked channels + OpenGL normal. Memorise that table and you'll never have a broken texture import again.
Need pre-textured, engine-ready 3D assets to test your pipeline against? Browse the full library at BitSoul Marketplace — every asset ships with verified texture exports for Unity, Unreal, and Godot.