Game-Ready Texture with PBR Maps

Turn a photograph of any surface into a complete PBR material set — diffuse, normal, roughness — all seamlessly tileable. Then layer on a procedural damage/wear overlay driven by noise masks, so the texture ships game-ready without leaving ArcBrush. This replaces simple seamless tiling with a full material pipeline that covers most of what you’d otherwise do in Substance Designer for straightforward photo-based textures.

The target output is a folder of texture maps you can drop directly into Unreal, Unity, Godot, or any PBR-capable engine.

What You’ll Need

A surface photograph (a wood plank texture works perfectly; the ArcBrush home page shows one as an example)
Target resolution in mind (1024x1024 or 2048x2048 are standard for environment textures)
An export folder for the final map set

The Pipeline

                                                +--> Export Image (diffuse_clean.png)
                                                |
                                                +--> Normal Map --> Export Image (normal.png)
                                                |
Image In (wood photo) --> Seamless Blend -------+--> HSB (desat) --> Invert --> Levels --> Export Image (roughness.png)
                                                |
                                                |    Noise (Perlin, ridged) --> Levels --> Mask From Image --> Mask Refine ---+
                                                |                                                                     |
                                                +--> Color Balance (mask = damage) --> Emboss (mask = damage) --> Export Image (diffuse_damaged.png)

The graph branches from a single Seamless Blend output into four paths: three clean PBR maps and one damaged diffuse variant.

Step-by-Step Walkthrough

Phase 1 — Clean PBR Maps

Build the base material first. Everything in Phase 1 branches from the Seamless Blend output.

1. Image In — Load Your Surface Photo

Add an Image In node and load your wood plank photograph. Any resolution works, but higher-resolution source photos give you more detail to preserve through the seamless blending step.

Set Watch File to true if you plan to iterate on the source photo externally. Changes saved in your image editor will automatically propagate through the entire graph.

2. Seamless Blend — Make It Tileable

Add a Seamless Blend node and connect Image In to its input.

Seamless Blend feathers the edges of the image so the texture tiles without visible seams. For wood planks and other organic surfaces, use Noise Blend mode — it breaks up the blend boundary with procedural noise so the transition is harder to spot:

Mode: Noise Blend
Blend Width: 20% (start here; go wider for surfaces with large features like stone blocks, narrower for fine-grained surfaces like metal)
Noise Scale: 5 (default works well for most organic materials)
Seed: Change this if the noise pattern creates an obviously repeated artifact

For geometric surfaces with strong straight lines, Cross-Fade mode produces cleaner results.

Preview the output and mentally tile it in a 2x2 grid. If you see a visible cross in the center, increase Blend Width. If the blended region looks too soft compared to the rest, decrease it.

3. Normal Map — Generate Surface Normals

Add a Normal Map node and connect the Seamless Blend output to its input.

Normal Map derives surface normals from luminance variation in the image. For a wood plank texture, the grain and knots create natural height information that translates directly into convincing normals.

Key parameters:

Source: Luminance (default; correct for a color diffuse photo)
Strength: 3.0 (bump this up from the default 2.0; wood grain needs stronger normals to read in-engine since the luminance contrast is relatively low)
Blur: 1.0 (a touch of blur smooths out noise from camera grain without losing the wood grain detail)
Invert Y: false for OpenGL convention (Unreal, Godot). Set to true for DirectX convention if your engine expects green-channel-down normals

The preview shows a blue-purple normal map. If it looks flat, increase Strength. If it looks noisy and harsh, increase Blur.

4. Roughness Map — Derive from Luminance

This step chains three nodes to convert the diffuse photo into a roughness map. The logic: dark areas in a photo tend to be crevices (rough), and light areas tend to be raised surfaces (smoother). We desaturate, invert, then adjust contrast.

HSB — desaturate to grayscale:

Add an HSB node and connect the Seamless Blend output to its input.

Saturation: 0 (fully desaturated; this gives you a grayscale version based on the original color luminance)
Leave Hue Shift and Brightness at defaults

Invert — flip the tonal range:

Add an Invert node and connect HSB’s output to its input.

Invert R/G/B: all true (default)
Invert A: false (default)

After inversion, dark crevices in the wood become bright (high roughness) and smooth raised surfaces become dark (low roughness). This matches the PBR convention where white = rough and black = smooth.

Levels — crush the contrast:

Add a Levels node and connect Invert’s output to its input.

Input Black: 0.15 (clips the darkest values so smooth areas don’t go fully black)
Input White: 0.80 (clips the brightest values so rough areas don’t blow out)
Midtone Gamma: 1.2 (pushes the midpoint slightly toward rougher; wood is a generally rough material)

The result should be a grayscale map where wood grain crevices are bright and flat plank faces are mid-gray. Tweak Input Black and Input White until the contrast looks right for your material.

5. Export Image (x3) — Save the PBR Set

Add three Export Image nodes, one for each map:

Diffuse export:

Connect Seamless Blend’s output
File Path: wood_diffuse.png
Format: PNG

Normal export:

Connect Normal Map’s output
File Path: wood_normal.png
Format: PNG (never use lossy formats for normal maps; JPEG compression destroys the directional data)

Roughness export:

Connect Levels’ output (end of the roughness chain)
File Path: wood_roughness.png
Format: PNG

At this point you have a complete three-map PBR set. If you don’t need the damage overlay, you’re done.

Phase 2 — Damage/Wear Overlay

This phase creates a procedural damage pattern and applies it to the clean diffuse, producing a weathered variant. The damage mask drives both Color Balance (color shift in damaged areas) and Emboss (physical relief in damaged areas).

6. Noise — Generate a Damage Pattern

Add a Noise node. This node is freestanding — it doesn’t connect to the Seamless Blend output.

For organic wear and weathering on wood (think aged, weathered planks):

Type: Perlin (Voronoi can’t tile — the Seamless option only applies to Perlin, Simplex, and Clouds, so use one of those for procedural PBR damage maps)
Scale: 6 (controls feature density; lower = larger smoother regions, higher = finer detail)
Seamless: true (critical — the damage pattern must tile just like the base texture)
Octaves: 4 (multiple fractal layers add the natural roughness that sells weathering)
Roughness: 0.5 (default amplitude decay between octaves)
Remap: Ridged (turns the smooth noise into bright ridges on a dark background, the right shape for cracks and worn-down edges)
Seed: 42 (change to get a different damage layout)

The preview should show bright ridge-like lines on a dark background. If the ridges are too thick, increase Scale. If you want more chaotic, broken-up damage, switch Type to Simplex for sharper directionality, or push Octaves to 6 for finer surface noise.

Domain Warp is automatically disabled when Seamless is enabled, so warp settings won’t affect this branch — the seamless tiling guarantee takes priority.

7. Mask From Image + Mask Refine — Build the Damage Mask

Mask From Image — convert the noise to a mask:

Add a Mask From Image node and connect the Noise output to its input.

Channel: Luminance
Threshold: 80 (only the brightest crack lines pass through; raise this to make damage sparser, lower it for more coverage)
Feather: 0 (we’ll feather in Mask Refine instead for more control)
Invert: false

Mask Refine — soften and expand the damage edges:

Add a Mask Refine node and connect Mask From Image’s output to its input.

Erode: -3 (negative values dilate/expand the mask; this thickens the crack lines slightly so the damage looks more substantial)
Feather: 4 (soft falloff at damage boundaries so the color shift and relief blend naturally into the clean surface)
Morph Op: Close (fills small gaps in the crack pattern for more continuous damage lines)

Preview the mask. White areas receive the damage effect, black areas stay clean. Adjust Threshold in Mask From Image and Erode in Mask Refine until the damage coverage looks right — typically 10-25% of the surface for subtle weathering, up to 40% for heavily damaged materials.

8. Color Balance — Scorch the Damaged Areas

Add a Color Balance node. Make two connections:

Connect Seamless Blend’s output to Color Balance’s image input
Connect Mask Refine’s output to Color Balance’s mask input

The mask restricts the color shift to only the damaged areas. The clean surface stays untouched.

For a scorched/aged wood look, push the damaged areas toward warm brown tones:

Zone: Midtones (start here; midtones affect the most visible tonal range)
Midtone Cyan-Red: 25 (shift toward red/warm)
Midtone Magenta-Green: -10 (slight green shift to avoid going too pink)
Midtone Yellow-Blue: -30 (shift toward yellow/warm, away from blue)
Preserve Luminance: true (keeps the overall brightness consistent so the damage reads as discolored, not brighter or darker)

The preview should show the crack areas tinted warmer while the rest of the wood stays unchanged. Increase the shift values for more dramatic scorching, or flip the signs for a cold/frost damage look.

9. Emboss — Add Physical Relief

Add an Emboss node. Make two connections:

Connect Color Balance’s output to Emboss’s image input
Connect Mask Refine’s output (the same damage mask) to Emboss’s mask input

Emboss simulates a light source hitting raised or recessed surface features, adding a sense of physical depth to the damage areas. With the mask applied, only the damaged regions get the relief treatment.

Source: Color (use the color channel data for the emboss calculation)
Angle: 135 (top-left lighting; this matches the default light direction in most material previewers)
Size: 2.0 (width of the emboss edge; keep it small for tight cracks, go larger for broad gouges)
Strength: 0.6 (subtle is better here; too strong and the emboss overtakes the texture detail. Start low and increase if the damage doesn’t read)

The damage areas should now have a subtle carved-in or raised appearance. If the effect is too harsh, reduce Strength. If it’s invisible, increase Size and Strength together.

10. Export Image — Save the Damaged Variant

Add one more Export Image node and connect Emboss’s output to its input.

File Path: wood_diffuse_damaged.png
Format: PNG

You now have four texture files: a clean PBR set (diffuse, normal, roughness) and a damaged diffuse variant. In your game engine, you can blend between the clean and damaged diffuse at runtime based on gameplay state, or use the damaged version as the default for aged environments.

Result

A folder containing four tileable texture maps: wood_diffuse.png (clean color), wood_normal.png (surface normals), wood_roughness.png (PBR roughness), and wood_diffuse_damaged.png (weathered variant with scorched cracks and physical relief). All four maps tile seamlessly and share the same UV space, so they stack correctly in any PBR material shader.

The entire graph rebuilds in under a second when you swap the source photo. Drop in a stone wall, a metal plate, or a brick surface and re-tweak the parameters for a different material — the pipeline structure stays the same.

Variations

Use different Noise types for different damage styles: Perlin (default) for general wear and surface erosion, Simplex for sharper directional damage, Clouds for burn marks and heat damage. Voronoi with F2-F1 Return produces the cleanest crack lines, but Voronoi can’t tile seamlessly — only use it when the texture won’t be tiled, or accept a visible seam at the borders.
Combine multiple damage layers with Mask Boolean (Union operation) for layered weathering. Run two Noise nodes with different types and scales, convert each to a mask, then union them before feeding into Color Balance and Emboss. This creates more complex, natural-looking wear.
Generate the roughness map from the damaged diffuse instead of the clean one. Route the Emboss output through the HSB-Invert-Levels roughness chain so crevices and damaged areas are rougher than clean surfaces. This gives you physically accurate roughness that matches the visible damage.
Add a height/displacement map by routing the roughness output through a Levels node with different contrast settings. Many engines accept a grayscale height map for parallax occlusion mapping or tessellation, and your roughness chain is already a good starting point.
Batch multiple materials by duplicating the graph and swapping Image In sources. Each instance produces a full PBR set, so you can process an entire material library in one session.