The Material Editor & Master Materials

Double-click a Material asset in Unreal and the Material Editor opens: a large node graph on the left, a preview viewport and a details panel on the right. Everything flows toward a single node on the far right - the Main Material node, which has an input pin for each PBR channel you met in 3.1: Base Color, Metallic, Roughness, Normal, plus Specular, Ambient Occlusion, Opacity and a few more. Your whole job in this editor is to feed those pins.

The simplest material plugs a Texture Sample node into Base Color, a Constant value into Roughness, another into Metallic, and a normal-map Texture Sample into Normal. That is a complete PBR material in four nodes. From there the graph can grow as complex as you like: multiply the base color by a tint, add a TexCoord node to control tiling, blend two textures with a mask, use a Fresnel node for edge effects. The preview sphere updates live as you wire, so you are never guessing.

Two practical notes. First, materials must compile - after edits Unreal builds the shader, which takes a moment; heavy graphs on many materials make this painful, which is one more reason for the instance workflow below. Second, keep an eye on instruction count (shown in the stats): every node costs GPU time on every pixel that material covers, so a bloated graph is a performance cost you carry into VR (Module 8). Elegant materials are usually cheap ones.

A material built only from fixed Constants and hard-wired textures is a dead end - to change anything you must reopen the graph and recompile. The fix is parameters. Instead of a plain Constant feeding Roughness, you use a Scalar Parameter named 'Roughness'; instead of a fixed color, a Vector Parameter named 'Tint'; instead of a hard-wired texture, a Texture Parameter named 'BaseColorMap'. A parameter is just a node with a name and a default that you have chosen to expose to the outside.

The moment a value is a parameter, it can be changed without opening the graph - and, crucially, without recompiling the shader. That is what unlocks the Master/Instance workflow. A well-designed Master Material exposes the handful of parameters an artist actually needs: the texture maps, a roughness value or a min/max range, a tint, a tiling amount, maybe a switch to turn a detail on or off. You are, in effect, designing a small control panel for a family of materials.

Think of it like a good Revit family or a parametric block: the geometry (here, the node graph) is authored once, and the instances vary only through the parameters you chose to expose. Deciding which parameters to expose is the actual craft of a Master Material - too few and it is rigid, too many and it is a mess. For most archviz a master with base color, roughness, normal, tiling and tint parameters covers the vast majority of opaque surfaces.

Here is the pattern that separates a professional Unreal project from a beginner one. You build one Master Material with well-chosen parameters. Then, for every actual surface in your scene, you right-click it and Create Material Instance. A Material Instance does not have its own graph - it inherits the master's entirely and only overrides the parameters you tick. Your oak floor, walnut worktop and teak door can all be instances of a single 'Wood' master, each just pointing at different textures and roughness.

The benefits are large and stack up. Speed of iteration: changing an instance parameter is instant - no shader recompile - so you can tune a whole room live, even while looking at it. Consistency: every wood in the project shares one lighting response, so they read as a coherent family instead of ten slightly-different guesses. Maintenance: improve the master - add a better normal blend, fix an edge case - and every instance inherits the fix at once. Performance: instances of one master share a compiled shader, so the GPU and the compiler both do far less work than a hundred unique materials would demand.

The practical rule most studios settle on: build a small set of masters (an opaque master, a glass master, a metal master, an emissive master), and make almost everything else an instance. You rarely author a truly unique material; you far more often instance an existing master and point it at new textures. Adopt this from day one and your projects stay fast and tidy as they grow; ignore it and a large scene becomes a swamp of one-off materials that recompile forever and never quite match.

Most of what a Master Material does is sample textures, so a few habits pay off. A Texture Sample node reads a texture map and outputs its color plus separate channels (R, G, B, A). A common optimisation is channel packing: because roughness, metallic and ambient occlusion are each just grayscale, artists often pack them into the R, G and B channels of a single texture (an 'ORM' map - occlusion, roughness, metallic) so one texture fetch feeds three inputs. Fewer texture samples means less memory bandwidth and a faster material - it matters more than beginners expect, especially in VR where you render everything twice.

Tiling is controlled by a TextureCoordinate (TexCoord) node feeding the sample's UVs; multiply it up to repeat a texture more often, expose that multiplier as a parameter and you can tune brick or floorboard density per instance (real-world scale is lesson 3.3's whole subject). Watch texture resolution: a 4K map for a distant skirting board is wasted memory; Unreal streams textures, but authoring sensible resolutions keeps your project light.

A final quality note: for variation across a large surface - so a whole floor does not visibly repeat - you can blend in a large-scale noise or a second detail texture, or break the tiling with a subtle macro map. This is the difference between a floor that reads as a real material and one that shows an obvious grid. Build these tricks into the master as optional, parameter-driven features and every instance gets them for free.

Make it concrete. You want oak flooring, a walnut worktop and a teak door. The beginner builds three materials. You build one.

Create a material, call it M_Wood_Master. Add a Texture Parameter 'BaseColorMap' into Base Color; a Texture Parameter 'NormalMap' into Normal; a Texture Parameter 'RoughnessMap' into Roughness (or a Scalar 'Roughness' if you prefer a flat value); a Vector Parameter 'Tint' multiplied onto the base color; and a Scalar 'Tiling' feeding a TexCoord into all the samples. Set sensible defaults, then compile once.

Now right-click MWoodMaster three times to create MI_Oak_Floor, MI_Walnut_Worktop and MI_Teak_Door. In each instance, tick and set only what differs: point BaseColorMap and NormalMap at the right oak/walnut/teak textures, nudge Tint, set Tiling so the grain reads at the right scale for a floor versus a worktop, adjust Roughness so the sealed floor is glossier than the oiled door. None of this recompiles anything - it is instant, and you can do it while walking the room.

The result: three convincingly different wood surfaces, one shared lighting response, one graph to maintain. Later you decide all your woods need a subtle sheen variation - you add it to the master once, and all three inherit it. That is the whole argument for Master Materials in a single example, and it is exactly how production archviz scenes are actually built.