What is Channel Packing and Why Do Game Engines Use It?
Channel packing stores multiple greyscale maps in the R, G, B, and A channels of a single texture — reducing texture memory usage and GPU sampling costs. It's a fundamental technique in every professional game art pipeline, and understanding it makes you a more effective technical artist.
What is Channel Packing?
Channel packing is the practice of combining multiple greyscale texture maps into the individual color channels (R, G, B, A) of a single RGBA texture file. Because each channel of an image is completely independent, you can store four separate greyscale maps in one file with no information loss between them.
For example: instead of three separate texture files for Roughness, Metallic, and Ambient Occlusion, you combine all three into one texture — Roughness in the Green channel, Metallic in the Blue, AO in the Red. The engine reads all three values from a single texture sample rather than three separate ones.
Ambient occlusion data. White = open to light, dark = occluded.
Surface roughness. White = fully rough/matte, black = mirror smooth.
Metal vs non-metal. White = pure metal, black = non-metal.
Available for opacity, height, or other data depending on the material.
Why Game Engines Use It
Channel packing isn't just a convention — it produces measurable performance improvements at runtime. Here's what actually changes when you pack vs when you don't.
Fewer texture samples
Every texture the GPU reads requires a texture sample — a fixed cost in GPU cycles. Three separate textures cost three samples. One packed texture costs one sample. Across a scene with hundreds of materials, this difference compounds significantly into real frame-time savings.
Reduced VRAM usage
Each texture loaded into GPU memory has overhead — headers, mip chain, compression blocks. Three textures carry that overhead three times. One packed texture carries it once. The actual data savings can be significant when multiplied across every material in a project.
Better texture cache performance
The GPU's texture cache works best when related data sits in the same memory location. Roughness, Metallic, and AO are always used together by the same shader. Keeping them in the same packed texture means they load into cache together — cache hits are more likely, reducing latency.
Simpler asset management
Three maps become one file. Fewer files to track in version control, fewer to import into the engine, fewer to verify during QA. Any time a texture is missing or mismatched, it's easier to spot with one packed file than three separate ones.
Engine Conventions — Which Channel Goes Where
Each engine uses a slightly different channel assignment convention. Getting this wrong is one of the most common import mistakes — the material imports without errors but the shading looks wrong because the engine is reading Roughness where it expects AO, or vice versa.
| Engine | Packed Map Name | R Channel | G Channel | B Channel | A Channel |
|---|---|---|---|---|---|
| Unreal Engine 5 | ORM | Occlusion (AO) | Roughness | Metallic | — |
| Unity HDRP | Mask Map | Metallic | Occlusion (AO) | Detail Mask | Smoothness |
| Unity URP / Built-in | Specular / Metallic | R | G | B | Smoothness |
| Godot 4 | ORM | Occlusion (AO) | Roughness | Metallic | — |
Unreal and Godot share the same ORM convention, which makes cross-engine workflows between them straightforward. Unity HDRP uses a completely different layout — and critically, stores Smoothness in the alpha channel rather than Roughness anywhere. This is the most common source of confusion between Unreal and Unity pipelines.
The Smoothness Trap — Roughness vs Smoothness
This catches almost every artist moving between Unreal and Unity for the first time. The two engines use inverse roughness conventions.
Unreal / Godot — Roughness
White = rough/matte surface. Black = smooth/shiny surface. A value of 1.0 is a completely diffuse, chalk-like surface. A value of 0.0 is a perfect mirror.
Unity HDRP — Smoothness
White = smooth/shiny surface. Black = rough/matte surface. The exact inverse. A value of 1.0 is a perfect mirror. A value of 0.0 is completely matte. Also called Glossiness in older workflows.
If you export a Roughness map from Trumble for Unreal and plug it directly into Unity HDRP's Smoothness slot, every material in your project will have inverted surface quality — polished metals will look rough, worn concrete will look shiny. The fix is simple: invert the Roughness channel (subtract from 1, or use an Invert node in the material graph) before connecting it to Unity's Smoothness input.
Packing Channels Manually
If you ever need to pack channels by hand — in Photoshop, GIMP, or another image editor — the process is the same regardless of software: copy each greyscale source map into the correct channel of a new RGBA document.
Open your greyscale maps as separate files
Open your AO, Roughness, and Metallic maps as individual greyscale images. Verify each one looks correct before packing — errors in the source are invisible once packed.
Create a new RGBA document
New document at the same resolution as your source maps — 2048×2048, 4096×4096, etc. Set mode to RGB with an alpha channel. Fill all channels with black as a starting point.
Copy each map into the correct channel
In Photoshop: open the Channels panel, click the Red channel, paste your AO map. Click Green, paste Roughness. Click Blue, paste Metallic. Return to the composite RGB view to verify it looks like noise (which is correct — it's three unrelated greyscale images combined).
Export as PNG
Export as a 24-bit (RGB) or 32-bit (RGBA) PNG. Name it clearly — T_AssetName_ORM.png for Unreal/Godot, T_AssetName_Mask.png for Unity. Never export a packed texture as JPEG — lossy compression corrupts the greyscale data in each channel.
Channel Packing in Trumble
Trumble handles channel packing automatically as part of every export. Paint your Roughness, Metallic, and AO as independent channels in the texture painter — they remain separate throughout your workflow so you can edit each one freely. At export time, select your target engine and Trumble packs them into the correct convention automatically.
Exports ORM — AO in Red, Roughness in Green, Metallic in Blue. Named T_AssetName_ORM. Ready to connect directly to the engine's material slots.
Exports Mask Map — Metallic in Red, AO in Green, Detail Mask in Blue, Smoothness (inverted Roughness) in Alpha. Convention differences handled automatically.
Need a non-standard channel layout? Trumble's custom export mode lets you assign any painted channel to any output channel in the packed texture.