Setting Up PBR Materials for Game Engines

You've assembled a PBR material in Substance Painter, but it looks different in the engine? That's a familiar scenario. In 80% of cases, the issue is a mismatch in color spaces: Albedo imported as sRGB, but the engine expects Linear. Or a Normal Map without green channel inversion for DirectX. We've worked on projects where incorrect packing of a Mask Map in HDRP required manual rework of 50 materials. Our methodology eliminates such errors. We analyze source textures, select proper import settings, create a Master Material with parameters—and the material looks identical to Substance Painter. Contact us to get a consultation on your materials.

The problem is almost always one of three: incorrect color space, wrong channel packing, or a mismatch in Tone Mapping settings between the DCC tool and the engine. We solve it in 2–4 days for a set of 20 materials.

Why do PBR materials look different in the engine?

Each engine interprets PBR data differently. Unity uses different material formats depending on the pipeline; Unreal Engine 5 requires a packed ORM texture. If these nuances are not accounted for, Albedo shifts, Smoothness inverts, normals flip. The result is a material that "doesn't work."

How to set up channel packing for HDRP and URP?

In Unity, the difference between HDRP and URP is not just in rendering quality. They have completely different material formats.

Universal Render Pipeline (URP) uses a Lit Shader with straightforward packing: Albedo, Normal, Metallic (R) + Smoothness (A), AO (G), Emission. In URP, Smoothness is inverted Roughness. If you export Roughness from Substance Painter and plug it into the Smoothness channel without inversion, the material will be glossy where it should be matte.

High Definition Render Pipeline (HDRP) has a Mask Map packed as Metallic (R), AO (G), Detail Mask (B), Smoothness (A). This non-standard packing is not automatically generated by Substance Painter's default templates. You need to either use the HDRP template when creating the project in Substance Painter or manually compose the Mask Map. Incorrect channel packing is one of the most common bugs when migrating assets from another engine.

Color Space is another critical point. In Unity, Albedo is imported as sRGB, Normal Map as Linear (uncheck sRGB in Import Settings), Roughness, Metallic, AO as Linear. Ignoring these settings is the source of half the problems.

How to properly pack an ORM texture for Unreal Engine?

In Unreal's Material Graph, textures are connected to the corresponding inputs of the Principled BSDF analogue. But there are a few nuances.

Packed ORM texture. In Unreal Engine, the standard is packing AO (R), Roughness (G), Metallic (B) into one texture with the Linear Color flag. This reduces the number of texture samples in the shader from three to one, improving performance by 20% in scenes with many materials. The correct Export Preset for Unreal in Substance Painter is Unreal Engine 4 (Packed).

Normal Map coordinates. Unreal uses DirectX normal map space: the green channel (Y) is inverted relative to OpenGL. When importing normals, either use the DirectX flag when exporting from Substance, or enable the Flip Green Channel option in Unreal's Import Settings.

Texture Compression. Unreal compresses textures into BC7 (DirectX) or ETC2 (mobile). Albedo: Default (BC7), Normal Map: Normal Map (BC5), Metallic/Roughness/AO: Masks (BC4/BC7 without sRGB).

Material Instances are a must. Instead of duplicating the Material Graph for each variant, create one Master Material with parameters and then create Instances. This reduces the number of unique shaders by 3–4 times, speeds up loading by 30%, and allows parameter changes without recompilation. Such shader optimization reduces draw calls and improves FPS. For example, we optimized a project from 200 materials down to 15 Master Materials + 200 Instances, cutting load time by 40%.

How we set up PBR materials: step-by-step process

1. Audit source textures: check bit depth, color space, presence of all maps.
2. Select the target engine and render pipeline, determine the packing format.
3. Configure export from Substance Painter with the correct preset or write a custom JSON config.
4. Import into the engine with proper Import Settings (sRGB/Linear).
5. Assemble a Master Material with parameters, create Instances.
6. Verify the material on a test scene: Albedo (30–240 sRGB), Normal Map (no artifacts), Smoothness (0–1), AO (no double shadowing), Metallic (binary).

Comparison of render pipelines by PBR parameters

What's included in PBR material setup

• Analysis of source textures and their suitability for the target engine.
• Export Preset configuration and texture conversion (channels, color space).
• Creation of Master Material with parameters (Base Color, Normal, ORM/Mask, Emission).
• Assembly of Material Instances for each asset.
• Verification on a test scene with side lighting and HDRI.
• Documentation of settings and transfer to the project's git repository.

Timelines are clarified after project analysis. Order PBR material setup—we guarantee compatibility with your engine. Contact us for a free work scope assessment.

Physically Based Rendering is the foundation of modern game materials. More on Wikipedia.

Texturing and Materials

An artist sends an asset to the engine — and it looks like a plastic toy. We've seen this dozens of times: correct geometry, good UV unwrapping, but the material doesn't "play". In 90% of cases, the reason is a misunderstanding of PBR channels. Over 10+ years working on mobile and PC projects, we've developed a pipeline that guarantees predictable results in any lighting. Texturing for modern games involves physically based materials, procedural systems, and a strict FPS budget. Our experience includes over 50 completed game projects — from indie to AAA. Contact us — let's discuss which texturing pipeline best suits your project with PBR materials for games.

Why are PBR materials the standard for modern games?

PBR (Physically Based Rendering) is not an artistic style but a set of rules that make materials behave physically predictably under any lighting. In Unity (URP/HDRP) and Unreal, this is the default standard. Using PBR reduces rework time by 30%: a material baked correctly does not require re-tuning when the environment changes. In contrast to legacy approaches, PBR provides consistency across the team — artists and engineers speak the same channel language.

What is included in the PBR pipeline: Metal/Roughness vs Specular/Glossiness

Two main workflows:

• Metal/Roughness (used in Unity URP, Unreal): Base Color — diffuse color without lighting information. Metallic — binary map: 0 (dielectric) or 1 (metal). Roughness — 0 mirror surface, 1 matte. Normal Map — relief simulation. AO (Ambient Occlusion) — darkening in crevices.
• Specular/Glossiness — older workflow, used less often, mainly in legacy projects or when converting from Photoshop.

Boundary values for dielectrics: base color not darker than #383838 and not lighter than #E0E0E0 — otherwise the material starts to "glow" or "sink" into darkness under HDR lighting. For metals, base color = reflection color (gold — warm, chrome — neutral).

— from Unreal Engine documentation: "PBR is the only way to get predictable reflections on all platforms."

How does Substance Designer speed up the creation of tiling materials?

If Substance Painter is manual painting on finished geometry, Substance Designer is programming a material. The node graph outputs a set of texture maps that are generated algorithmically. Designer is 5 times faster than manual texturing when reused: one graph with parameters — stone size, gap, mossiness, wetness — gives hundreds of variations. Instead of painting a 2K texture by hand, the artist builds a graph that can:

• Be parameterized — one "stone wall" graph with sliders: stone size, gap, mossiness, wetness.
• Be scaled without quality loss — rendering at any resolution (2K → 4K for cinematic).

Building blocks of the Designer graph:

• Shape nodes — geometric primitives (rectangle, circle, polygon). Basis for tiling patterns.
• Noise nodes (Perlin, Gaussian, Cells, Voronoi) — organic irregularities.
• Tile Generator / Splatter — key nodes for creating patterns with control over offset, rotation, scale.
• Warp nodes — deformation by normal map or gradient (drips, shifts, cracks).
• Blend — layer blending with masking (final compositing).
• Normal Map nodes — synthesis of normals from height data.

Typical graph for "industrial metal" material:

[Shape: rectangular panel]
    ↓
[Tile Generator: grid of panels with small offset]
    ↓
[Warp: micro-dents from Gaussian noise]
    ↓
[Blend: add curvature mask → rust on edges]
    ↓
[Blend: drips by Directional Warp]
    ↓
[Export: BaseColor / Metallic / Roughness / Normal / AO]

Such a graph is reused across different projects without rework when resolution changes. One graph saves up to 40% of time on repetitive textures.

How to avoid performance loss when working with textures?

The main mistake is overestimated texture resolution and wrong compression format. Comparison table by platform:

Never export PNG to production without compression — it's a direct memory waste. BC7 for RGBA gives good quality at 8 bpp. ASTC for mobile is adjustable by quality/size ratio. Additional tool comparison table:

Work process: from reference to integration

1. Analysis of references and reference geometry — determine PBR channels, style, platform constraints.
2. UV unwrapping and baking — bake AO, Normal, Curvature, Thickness considering texel density.
3. Texturing — Painter for hero, Designer for tiles, hand-painted if needed.
4. Export and optimization — compress to target format, atlas, LOD textures, test on target platform.
5. Support during integration — set up materials in engine, debug lighting issues.

What is included in our work and quality guarantees?

• Deliverables: PBR texture sets (Base Color, Metallic, Roughness, Normal, AO) for Metal/Roughness workflow, parametric Substance Designer graph (if required), full documentation for material setup in Unity/Unreal, support during integration with testing on target platform.
• Guarantee: every material is tested in the engine under three different lighting conditions. Our experience — 10+ years, 50+ projects, including projects with AR Foundation and XR Interaction Toolkit.
• Timeframe: 3 to 14 days depending on complexity (one tiling material in Designer — 3–5 days, hero asset with UDIM — up to 14 days). Cost is calculated individually.

Order texturing of your asset — we guarantee predictable results without rework. Get a consultation on the right pipeline today.