Made by AI, Directed by David Stein

Search
Digital Artists

Getting Started With Substance 3D Designer

A procedural material is a small program that outputs textures. Here is the mental model, the six nodes that do most of the work, and the habits that stop a graph becoming unreadable.

6 min read

Substance 3D Designer defeats more artists than any other tool in the texturing pipeline, and not because it is harder than ZBrush. It defeats people because it looks like an art tool and behaves like a programming environment.

You do not paint in Designer. You build a graph that, when evaluated, produces a set of texture maps. Change one number at the top and everything downstream re-renders. That is enormously powerful and completely unlike every other application on your dock.

The one idea that makes it click

Everything in a Designer graph is a grayscale height field until you decide otherwise.

Internalise that and the tool opens up. You are not designing a brick wall’s appearance; you are designing a grayscale image where white is high and black is low. Once the height is right, colour, roughness, metalness and normals are all derived from it — mostly by feeding that same grayscale into different nodes.

Beginners do the opposite. They start with colour, because colour is what a material looks like, and then spend an hour trying to make a basecolour map behave like geometry. It cannot. Build the height first, in black and white, and judge it in black and white. If the material does not read as a convincing surface in grayscale, no amount of colour will save it.

Six nodes carry most of the work

Designer ships hundreds of nodes. You can build a great deal with these:

Tile Generator. Lays out a repeating pattern of a shape across the canvas, with per-tile randomisation of scale, rotation, offset and brightness. This is bricks, tiles, planks, scales, cobbles. Most structured materials start here.

Shape. A single primitive — disc, square, gradient, paraboloid. Fed into Tile Generator as its pattern input, or used alone as a mask.

Blend. Combines two inputs with an opacity and a blending mode, optionally through a mask. This is the workhorse; a mature graph is mostly Blends. Learning Max, Min, Add and Subtract in height terms — Max makes the union of two surfaces, Min the intersection — is worth more than learning twenty exotic nodes.

Warp / Directional Warp. Pushes one image around using another as the displacement. This is how a mechanically perfect pattern stops looking mechanically perfect. One subtle Directional Warp driven by a noise is the difference between CG and plausible.

Blur / Slope Blur. Slope Blur smears an input along the slopes of a second input, and it is how you get erosion, wear, melted edges and flow. If a material looks too crisp, this is usually the fix.

Curve / Levels. Remaps the grayscale range. You will use these constantly, because the difference between a good height field and a bad one is very often just contrast in the right places.

A first graph, end to end

Build a simple tiled stone material:

  1. Tile Generator, pattern set to a rounded square, 6×6. Add a small amount of random rotation and random offset. You now have grid-aligned blocks.
  2. Blur it very slightly, then run it through Levels to push the block faces toward white and the gaps toward black. This is your base height.
  3. Make a Perlin Noise or Clouds node and Blend it over the height at low opacity in Add mode. Each block now has surface variation.
  4. Slope Blur the result using a second, finer noise as the slope input, at low intensity. Edges soften unevenly. This is the step that does the most for the least effort.
  5. Feed the final height into a Normal node. That is your normal map.
  6. For roughness, take the same height, run it through a Curve to invert and compress it, and blend in some noise. Recesses hold dirt and read rougher; high points get polished and read smoother. Deriving roughness from height is why height-first works.
  7. For basecolour, use a Gradient Map driven by the height. Now colour varies with elevation automatically, and when you change the height, the colour follows.

That is a complete PBR material from one grayscale field.

Habits that keep a graph usable

Expose parameters as you go, not at the end. Right-click any value and expose it to the graph’s input parameters. A graph with eight well-named exposed parameters is a material you can reuse; the same graph with none is a one-off you will rebuild.

Name your nodes and use frames. Designer lets you drop a labelled frame around a cluster. In three weeks you will not remember why there are two Warps in the middle. Frames labelled “base pattern”, “surface detail”, “wear” will tell you.

Work at 512 and output at 2048. Set the graph’s working resolution low while you build — it is dramatically more responsive — and raise it only for the final output. Also check your material at 2048 before you ship it, because some noises change character with resolution.

Preview on a real mesh, not the flat 2D view. The 3D view with a proper HDRI will tell you in two seconds that your normal map is too strong, which the 2D view will never tell you.

Decide your output set first. Know whether you are delivering basecolour/roughness/metalness/normal/height/AO for Unreal, Unity, Blender or a renderer with its own conventions, and set the output nodes accordingly. Designer will happily let you build a beautiful material that is wired to the wrong channel names.

Where people get stuck

Everything looks like plastic. Your roughness map is probably flat. Roughness variation, more than anything else, is what makes a surface read as a real material.

The tiling is obvious. You need warp and large-scale variation. A low-frequency noise blended over the whole height at low opacity breaks the grid without touching the detail.

The normal map is wrong-looking. Check whether your target expects OpenGL or DirectX normals, and flip the green channel accordingly. This is the single most common one-click bug in the pipeline.

The graph is unbearably slow. Drop the working resolution, and check for a node computing at 4096 in the middle of the chain. Resolution propagates, and one absolute-resolution node can poison everything downstream.

Where to go next

Rebuild an existing material from Designer’s own library by looking only at its output and never at its graph, then compare. That exercise teaches more than any tutorial, because it forces you to reason backwards from a surface to the operations that could have produced it — which is the actual skill.

Sources

Related Reading