Texture Sets

A material is never one picture. Bark from a texture site arrives as a color map, a normal map, a roughness map, a height map, and more, and they only work as long as they line up pixel for pixel. In ArcBrush those maps travel together as one texture set on one green wire, so whatever you do to the material happens to every map at once.

A downloaded 4K bark material, brought down to 1K for a game. One Resize scales all five maps to the same size together, and Export Texture writes them with Unreal's names and channel packing.

Getting a set in

From a downloaded material. Point a Texture Folder at the folder, or drop the folder on the canvas and choose Texture Folder when asked. It matches each file to its role by its name (oak_bark_normal.png, oak_bark_rough.png, and so on) and the set takes the asset’s name, oak_bark.

From maps you made yourself. Wire them into the matching inputs of a Texture node. Any role you leave empty is simply absent.

From a plain picture. Wire an ordinary image where a set is expected, such as Export Texture or 3D Render, and it is read as a set with only a Base Color, its alpha becoming the set’s Opacity.

What a set holds

A set has up to eight maps, one per role, plus the asset’s name and its normal map’s convention (OpenGL or DirectX):

Role	Kind of map
Base Color	Full-color image
Normal	Full-color image holding packed directions
Roughness	Single value per pixel
Metallic	Single value per pixel
Ambient Occlusion	Single value per pixel
Height	Single value per pixel, which can go below zero or above one in a 32-bit document
Opacity	Single value per pixel: where the asset exists
Emissive	Full-color image

A role the asset does not have stays absent; nothing fills it with a neutral value behind your back. A single-value map saved as an RGB file needs no conversion: the red channel is read.

Opacity is the set’s one cutout. Every node that places, trims, or layers a set, the Preview, 3D Render, and Export Texture all read where the asset is from this one map, so they can never disagree. On the Texture node, Opacity From picks where it comes from:

Texture 1 · leaf

Opacity From

Base Color Alpha

Opacity Input uses a map wired into the Opacity pin, Base Color Alpha uses the color map’s transparency, and None (Opaque) makes the set solid. A map’s own alpha is never read as Opacity unless you pick it here, so a color map with a stray alpha channel does not punch holes in your material.

To see every map at once, select a node carrying the set and click All in the Preview; each map also has a tab of its own. See Preview Panel: Texture Sets.

Moving and reshaping a whole set

Wire a set into a node that places or bends pictures, such as Transform, Hex Tile, Resize, Crop, Trim, or Mesh Warp, and the whole material moves as one: every map takes the same placement in one pass, so nothing can slip out of register.

Hex Tile breaks up the visible repeat of a tiling material. Every map is cut into the same cells, and the normal map is turned to match each cell, so the stones still read as stones in 3D Render.

Three things behave differently with a set connected, so the result always stays a usable material:

The normal map is re-aimed, not just moved. Rotate or warp the set and the normal’s directions follow, so light still falls the right way across the relief.
A fill color only reaches color maps. Transform’s Background color or Pad’s Fill Color paints Base Color and Emissive; every other map gets its neutral value, so a red background never becomes a red roughness.
Lanczos becomes Bilinear on a set with a Normal or Height map, because Lanczos’s ringing would invent bumps that nobody painted.

How each node treats a set, map by map, is in Each node, map by map at the end of this page.

Changing one map

Levels, Curves, HSB, Color Balance, Gradient Map, Exposure, Brightness/Contrast, Invert, Clamp, and Black and White edit one named map of a set. Wire the set in and a Map row appears at the top of the node’s first section: pick Roughness on a Levels and only the Roughness changes, while every other map, the Opacity, and the name pass through exactly as they were. The node body names the map, and the Preview jumps to that map’s tab with a dot marking it as edited.

Only the maps the set carries are offered, in role order, and the first one the node can edit is the default (Base Color for these nodes). A line under the row says what the map holds, such as Roughness, linear 0 to 1, one channel.
A color node never edits the Normal, which is a direction rather than a tone, and HSB offers color maps only; those entries are grayed with the reason (for the Normal, Normal is a direction, not a tone. Use Normal Map with Map set to Normal, then Strength.). The Opacity is the set’s cutout and is never offered: Mask Apply edits it.
Levels’ Auto Levels and its Input Black and White eyedroppers read the chosen map too: they pick from that map of the set the Preview shows, never another map.
A set without the chosen map passes through unchanged with a note, never a different map. Over a library one choice applies to every set.
Color Range, Luma Key, and Magic Wand select from one map, the Normal included, and cut the whole set by that selection: the output is the set with its Opacity multiplied by the selection and every map kept, and the mask output carries the selection. Pick a color on the Base Color and the whole material is cut out. The Color eyedroppers of Color Range and Luma Key pick from the chosen map.
Normal Map reads the Height and writes the Normal into the set, or rescales the set’s own Normal (its intensity, with the Height following), and Normal to Height reads the Normal and writes the Height, both without the set coming apart.
Blur, Sharpen, and Denoise filter every map of a set with the same settings, keeping the Normal a unit direction; the Opacity is filtered only when the node’s alpha option says so.

Any other node still refuses a set at the wire:

Texture sets are not supported here. Use Export Texture to write one, or Split Texture to edit one channel.

What is left is the nodes that read one picture at a time, such as Posterize and the other stylize nodes, Composite and Layer (for sets, use Merge or Texture Layer), and the other keyers. To run one of those on a single map, take the map out, change it, and put it back. Here the bark’s Roughness is posterized, and everything else is left alone:

Split Texture takes the set apart into one output per role.
Run the node on the map you need: here a Posterize on Roughness.
Wire the original set into the Texture pin of a Texture node, and the edited map into its Roughness pin.

The Texture node then works as an override: the role you wired in replaces that map, and the other maps, the name, the normal convention, and the Opacity pass through exactly as they were. A Levels or Curves pass on one map needs none of this: pick the map on its Map row.

Drawing into one map

Noise, Pattern, Gradient, and Shape draw straight over a picture wired into their optional Background input, with no Composite node, and over a set they draw into one map. Wire a set in and a Map row heads the Output section: pick Base Color, Roughness, Metallic, Ambient Occlusion, Height, or Emissive and the generator draws into that map only. Every other map and the Opacity pass through untouched, and the node body names the edited map. The Normal and the Opacity are listed but grayed, with the reason. To draw into several maps, use one node per map with the same seed.

Text draws into one map the same way: Base Color for a painted label, or Height for lettering embossed into the surface (white text raises it, black sinks it). Like Shape, it adds its own coverage and leaves the set’s Opacity untouched.

Grunge in the roughness:

Wire a Texture node (or any texture set) into a Noise node’s Background.
Set Map to Roughness.
Leave Output Mode on Composite, then pick a Blend (Overlay is the default; Multiply darkens, Linear Dodge (Add) lightens) and drag Opacity to taste.
For grunge only in the crevices, wire a mask, such as a Curvature node’s Concavity or Ambient Occlusion result, into Mask.

The result is the same set with only its Roughness changed. Noise, Pattern, and Gradient start at Overlay and half opacity and never paint where the set is transparent; Shape starts at Normal and full opacity. A set wired into Size Reference instead still only sets the size.

Layering one material over another

Texture Layer stacks whole sets the way Layer stacks pictures, but where two materials overlap, their height decides which one shows, for every map at once. Wire moss as the top row and cobblestones as the bottom row: the moss fills the low gaps, and the stones, being higher, stay on top.

Each row also has its own placement, opacity, and Height Offset to push a material up or sink it in.

For one material simply over another, Merge takes sets too: Over is exactly a two-row Texture Layer, and the other coverage operators (Under, In, Out, Atop, and the rest) work on whole materials. To lay a masked material over another, cut its Opacity with Mask Apply (Cut Out replaces the Opacity, Intersect multiplies it, and Mask Fit sizes the mask), then Merge Over. Merge is order based; a deep stack, or one where height decides, belongs on Texture Layer. Scatter works the same way: scatter pebble sets over a ground set and each pebble’s height decides how it meets the ground.

Filling in missing maps

A downloaded asset is often missing a map. Three nodes work out one from what the set already has:

Ambient Occlusion works out soft contact shadows from the Height and hands back the set with its Ambient Occlusion filled in. Wire it straight in line.
Normal to Height turns a normal map into a height map, so a normal-only asset can layer by height and feed Ambient Occlusion. Wire the set straight in: it reads the set’s Normal in the set’s own convention and writes the Height into the set.
Curvature reads edges and cavities from the Normal or Height, a mask for edge wear and grime rather than a map of the set.

A whole library at once

Point Texture Folder at a folder holding many assets and it outputs a library: one set per asset, as a batch. The graph you built for one material now runs on each of them, and Export Texture writes every asset under its own name.

Export Texture 1

Destination

Unity Built-in / URP

Folder

export/{name}

Writes

export/cobblestone/...

export/moss/...

export/oak_bark/...

... one folder per asset, 12 in all

Separate makes a library by cutting a sheet of variants apart, and Collect makes one from sets you pick by hand. Arrange joins a library back into one set. More in Batch Processing.

Checking and shipping

See it on a mesh. 3D Render takes the whole set on one Texture input and fills each material slot from the matching map. There are no per-map pins: edit a map in place on a node’s Map row, or swap it with the override above.

Read what it carries. Wire a set or a library into Inspect to see each map with its channels and bit depth, the Normal convention, whether it has an Opacity, and its place on a trim sheet when it came from one. The set passes through unchanged, and the statistics read the map the Preview shows.

Write it for your engine. Export Texture writes one file per map, named, packed, and converted the way the destination you pick expects: Unreal’s T_ names and packed ORM map, Unity’s packed mask map, glTF’s one file for occlusion, roughness, and metallic, and so on. Each destination has a guide with the exact files and the steps to take in that tool: see the Texturing Guides. To choose the file names yourself, see Naming with Tokens.

Each node, map by map

The rules below are for looking up what a particular node does to each map of a set.

Placing a set

Node and mode	What happens to the set	What happens to the Normal
Transform: move, rotate, scale, skew, mirror	Every map takes the same placement	Turned with the pixels. A uniform scale of any size keeps its strength; a stretch, a squash, or a skew tilts the two axes by their ratio
Rotate 90	Every map takes the same quarter turn	Turned with the quarter turn
Mirror: Horizontal, Vertical, Both	Every map is flipped the same way	Flipped with the pixels
Mirror: Radial	Every map is folded into the same wedges	Reflected or rotated by the wedge it landed in
Crop	One rectangle taken from every map	Unchanged
Pad	Every map placed at the same spot in the larger canvas	Unchanged
Offset	Every map shifted by the same amount, wrapping or not	Unchanged
Resize	Every map resampled to the same size	Unchanged by a uniform resize of any size; an aspect change tilts it by the ratio between the two axes
Tile: plain grid	The same grid of copies in every map	Unchanged
Tile: Mirror X, Mirror Y	The same mirrored cells in every map	Reflected per mirrored cell
Hex Tile	Every map sampled with the same cells, rotations, and weights	Turned with each cell’s rotation and renormalized; Scale Jitter never changes its strength. Normal Map mode engages for the Normal automatically
Trim	One rectangle measured from the set’s Opacity, applied to every map	Unchanged

Tile’s Alpha input is an Opacity control over a set. A mask wired there is tiled by the same grid and replaces the set’s Opacity (never a data map).
Trim measures the set’s Opacity, never one map’s pixels, which is why its detection modes are named Transparent Pixels, Top-Left Opacity, and Bottom-Right Opacity over a set.
Transform’s Background input takes a picture, not a set, and over a set it is a canvas. Every map comes back at the background’s size with the set placed on it, and no background pixel is drawn into a map. Output Mode offers Composite grayed with the reason; to lay one surface over another, use Texture Layer, or Merge Over.
Neither the Composite nor the Lanczos switch is written into your node: unwire the set and your choice is back.

On the graph, a node moving a set shows the set’s first map as its thumbnail with a badge such as “x8” counting the maps; hover it to see which roles they are.

Warping a set

Node	What happens to the set	What happens to the Normal
Displace	Every map is pushed and pulled by the same displacement map	Re-aimed at each pixel to match the push there
Polar Remap	Every map is wrapped, unwrapped, or repeated Droste-style together, and Edge Mode fills every map and the Opacity identically	Re-aimed at each pixel to match the remap. The exact center is carried through unchanged
Lens Distortion	Every map takes the same lens correction or distortion	Re-aimed at each pixel to match the lens curve
Corner Pin	Every map is warped onto the same four corners	Re-aimed at each pixel to match the perspective
Mesh Warp	Every map follows the same control-grid deformation	Re-aimed at each pixel to match the mesh
Puppet Warp	Every map follows the same pin deformation	Re-aimed to match the mesh, one direction per triangle
Path Warp	Every map is bent along the same path; Rigid Pieces cuts the pieces once, from the Opacity	Turned to follow the bend

Displace’s displacement map stays a single image. It decides where each map’s pixels come from and is never part of the set.
Corner Pin, Mesh Warp, and Path Warp treat a background the way Transform does: a picture, never a set, used as a canvas.
Mesh Warp’s soft edge fades the Opacity, never a value, so Roughness or Height keep their true values right up to the edge.
Puppet Warp’s mesh is traced from the set’s Opacity, not from any one map’s alpha.

While you drag a handle or scrub a slider, the Preview warps the map on screen, and the whole set is built when you let go.

Libraries

Scatter outputs a set when any stamp or the background is a set; a Surface group decides how overlapping instances meet by height, and Blend Mode acts on Base Color and Emissive only. See Scattering texture sets.
Split and Collect carry a library through whole, frame for frame. A set keeps its own asset name through Collect, above any node rename.
Split Texture outputs a batch on each role output. A frame missing a role stays absent in that position, so a library of twelve stays twelve on every output.
Texture Layer rows fan out over a library, one composition per frame, and a row fed a single set is shared across every frame.
Export Texture writes every asset under its own name, one asset in memory at a time.
Mask Apply, Merge, Trim, and Texture’s override pin take a library; Texture pairs library frames with batched role maps by position.

What takes a set

Texture, Split Texture, Texture Layer, Collect, Split, Arrange, Reroute, Separate, Scatter, Merge, Mask Apply, Seamless Blend, Blur, Sharpen, Denoise, Inspect, the Background of Noise, Pattern, Gradient, Shape, and Text (see Drawing into one map), the one-map nodes and mask readers under Changing one map, the placing and warping nodes above, the Texture inputs of Export Texture, 3D Render, Ambient Occlusion, and Curvature, the Source of Trim Sheet (which cuts every map into its trims), and Export Data, which lists a set or each of its maps as rows. A set or a library can also be the Size Ref of any node that has one, such as Crop, Pad, Resize, or a generator, which then takes the set’s size (and its place on a trim sheet). Every other node refuses a set at the wire, including Export Image and Export Batch. Reroute passes a set through unchanged, so a set can cross a busy graph without being taken apart.

Good to know

A texture set is not saved as its own value. Like a batch, it exists while the graph is evaluated; what is saved is the graph that builds it.
The Texture category of the Add Node menu and the Library holds the texture nodes, between Filter and Composite; Texture Folder sits under Inputs and Export Texture under Export.
When Opacity Input or Base Color Alpha is picked on a Texture override, the Opacity is recomputed only from an input freshly connected on that node; an incoming set’s Opacity, such as a Texture Layer’s composed one, is otherwise kept.
Search the Library for “pbr”, “material”, “texture set”, “channels”, “roles”, or “library”.