Master Materials
UE5 · Material Editor · Material Instances · MPC
A single Master Material that exposes every common surface control as a parameter, so new textures and variants are applied via Material Instances rather than authoring a fresh shader per mesh. Selected parameters tie into a Material Parameter Collection, letting game-loop events drive material state globally at runtime.
Overview
M_MasterMaterial is the single material every prop, wall, and set-dressing asset in the level is built from. Rather than authoring a new material graph for every surface, artists create a Material Instance of M_MasterMaterial and drive a shared set of exposed parameters — swap in a texture set, dial in a UV offset, decide whether the surface should read as rusted metal or bare stone. This tutorial walks through how the graph itself is built, feature by feature, so you understand what each parameter is actually doing under the hood. At the top level, the whole graph is gated by one Static Switch Parameter, Use Textures?. When it's True, the material samples an entire set of textures (BaseColor, ORM, Normal, Roughness, Specular, Emissive, Displacement) and runs them through every effect described below. When it's False, the material skips texturing entirely and builds its surface from flat Vector Parameter and Scalar Parameter colors instead — useful for quick greybox blockouts or stylized flat-shaded props. Both paths converge on their own Make Material Attributes node, and the Use Textures? switch picks between the two before feeding the result into the main material output node's Material Attributes pin.
The UV Pipeline
Every texture sample in the material — BaseColor, Normal, ORM, Roughness, Specular, Emissive, Displacement — reads its UVs from a single shared source rather than wiring Texture Coordinate [0] into each one individually. This keeps every channel in registration and means one set of controls (scale, offset, an optional radial bend, and rotation) affects the whole material consistently. The pipeline runs, in order: scale and offset the UVs, optionally replace them entirely with a radial (polar) mapping, then rotate the result, and hand it off through a Named Reroute Declaration called UV Out that every texture sample downstream reads from via a matching Named Reroute Usage. Important: UV A and UV B are reused in two different roles depending on the Radial UV? switch. With Radial UV off, they're the U/V tiling multipliers described in step 2. With Radial UV on, the exact same two parameters instead define the center point of the radial bend. Changing them will do something different depending on which mode is active — this is intentional parameter reuse to avoid exposing redundant controls, but it's worth remembering when building a Material Instance.
- A Texture Coordinate node (Coordinate Index 0) supplies the mesh's raw UVs.
- Two Scalar Parameters, UV A and UV B, control tiling scale. A Component Mask pulls the R channel and another pulls the G channel off the Texture Coordinate, and two Multiply nodes scale U by UV A and V by UV B independently.
- Two more Scalar Parameters, Offset Horizontal and Offset Vertical, are added on top (one Add per axis) to pan the tiled UVs, and an Append node recombines the scaled-and-offset U and V back into a single UV vector — this is the "standard" (non-radial) UV output.
- In parallel, a Static Switch Parameter named Radial UV? decides which UV set actually reaches the rest of the material: the standard scaled/offset UVs from step 3, or the output of the Radial UV pipeline described in the next section.
- The winning UV set is fed into a CustomRotator material function call, along with a fixed rotation center (a Constant3Vector at 0.5, 0.5, 0.5 — the middle of UV space) and a rotation amount. The rotation amount comes from a Rotation Scalar Parameter divided by 100 (a Divide node), so the parameter reads as roughly "percent of a full turn" rather than raw radians.
- The rotated result is written to a Named Reroute Declaration named UV Out. Every texture sample elsewhere in the graph pulls its UVs from a Named Reroute Usage pointed at this same declaration.
Radial UV
This is the feature that lets a texture bend around a chosen point instead of tiling in straight rows and columns — useful for things like sunburst decals, clock faces, drain grates, or anything that should read as radiating outward from a center. It converts the mesh's UVs into polar coordinates (an angle and a distance from the center) and uses those as the new U and V. Because the texture's U axis now represents "degrees around the center," any texture used with Radial UV enabled needs to tile seamlessly left-to-right, and its sampler's U address mode should be set to Wrap so the wrap-around point doesn't show a seam.
- A second Texture Coordinate node (Coordinate Index 0) supplies the raw UVs for this pipeline.
- The UV A and UV B Scalar Parameters (the same two described above) are combined with an Append node into a single UV-space point — this is the center the texture bends around.
- A Subtract node computes Texture Coordinate minus that center point, giving UV coordinates relative to the center.
- A Length node measures the distance from the center — this becomes the radius.
- Two Component Mask nodes split the centered coordinate into its R and G channels, which feed the Y and X inputs of an ArcTangent2Fast node to get the angle around the center.
- The radius is scaled by a Radial Scale Scalar Parameter (Multiply) and shifted by a Radial Offset Scalar Parameter (Add) — together these control how far the texture stretches along the radius and where the texture's V axis starts at the center point.
- The angle from ArcTangent2Fast is divided down to a 0–1 range, multiplied by an Angle Repeat Scalar Parameter (how many times the texture wraps around a full circle), and offset by the same Radial Offset parameter, then passed through a Frac node to wrap it cleanly back into 0–1.
- A final Append node combines the wrapped angle (U) and the scaled/offset radius (V) into the radial UV, which feeds the Radial UV? switch described in the UV Pipeline section above.
Core PBR Texture Channels
When Use Textures? is on, each physical property of the surface — color, metal/non-metal, roughness, reflectivity, normal detail, ambient occlusion, and emission — is built from a texture sample plus a small set of override controls, all reading UVs from the shared UV Out reroute. Several channels also fall back to reading from a single packed ORM (AO/Roughness/Metallic) texture when a dedicated texture isn't used, so the material doesn't force every surface to author four separate grayscale maps. Base Color: A Texture Object Parameter named Texture holds the base color map. A Texture Sample node reads it using the shared UV Out UVs. The sampled color is multiplied by an Albedo Control Vector Parameter, letting an instance tint the base texture without needing a second texture. The result is written to a BaseColor Out Named Reroute Declaration — further downstream it has Frost added on top, is blended against Moss's base color, optionally has Vertex Painting layers blended in, and finally has Grid and Rust added on top. ORM (packed pass-through): The ORM Texture Object Parameter is sampled once and declared directly as ORM Out with no further processing — it exists purely to feed the Metallic, Roughness, and AO fallback branches below.
- —Metallic — A Component Mask pulls the blue channel of ORM Out (the metallic channel, by the standard ORM packing convention). A Static Switch Parameter, Texture Metallic?, chooses between that ORM.B value (True) and a flat Metallic Scalar Parameter (False). The result is declared as Metallic Out.
- —Roughness — A separate Roughness Texture Object Parameter is available for cases where roughness isn't packed into ORM. A Component Mask on the green channel of ORM Out provides the packed fallback. A Static Switch Parameter, Texture Roughness?, picks between them. A Roughness Level Scalar Parameter is added as a bias and the result is clamped with Saturate before being declared as Roughness Out.
- —Specular — A dedicated Specular Texture Object Parameter is sampled and multiplied by a SpecularLevel Scalar Parameter. A Static Switch Parameter, Texture Specular?, chooses between that textured result (True) and a flat saturated SpecularLevel value (False). The result is declared as Specular Out.
- —Normal — A dedicated Normal Texture Object Parameter is sampled and run through a FlattenNormal material function call, blending the normal map toward a flat surface based on a Flatten Normal Scalar Parameter. A Static Switch Parameter, Texture Normal? (defaults to True), chooses between the flattened normal (True) and a flat fallback Constant (False). The result is declared as Normal Out, later combined with the Macro Normal detail layer.
- —Ambient Occlusion — A dedicated AO Texture Object Parameter and Texture Sample, plus a Component Mask on the red channel of ORM Out as the packed fallback. A Static Switch Parameter, Texture AO?, picks between them, declared as AO Out.
- —Emissive — A dedicated Emissive Texture Object Parameter is sampled and multiplied by an Emissive Albedo Vector Parameter tint. That result is raised to an Emissive Power, multiplied by Emissive Sharpness, and has Emissive Level added on top. A Static Switch Parameter, Texture Emissive?, chooses between that computed value (True) and a black Constant3Vector (False). A global pulsing flicker driven by a Flicker Collection Parameter scales a Time-based Sine wave — as the global Flicker value rises, the emissive starts flickering and oscillates faster. The switched emissive value is multiplied by that flicker Lerp and declared as Emissive Out.
Macro Normal Detail
Large flat surfaces tend to look dead under close-up lighting even with a good base normal map, because the normal detail repeats at the same scale as the base texture. Macro Normal adds a second, independently-scaled normal map layered on top to break that up.
- A MacroNormal Texture Object Parameter holds the detail normal map.
- A MacroTile Scalar Parameter (default 1024) feeds an MF_MacroUV material function call, which generates a UV set tiled at that scale — independent of the object's own UV set or the main UV pipeline, so the detail doesn't stretch or shift when you adjust the main UV A/UV B/offset controls.
- A Texture Sample reads the MacroNormal texture using those tiled UVs.
- A MacroNormal_Strength Scalar Parameter feeds a MakeFloat3 call as both the X and Y inputs (with Z fixed at 1.0 via a Constant), producing a vector that scales down the X/Y tilt of the detail normal without touching its Z.
- The texture sample is multiplied by that strength vector and declared as MacroNormalOut.
- Downstream, MacroNormalOut is combined with the base Normal Out using a BlendAngleCorrectedNormals material function call — the standard Unreal technique for layering two normal maps without the result looking flattened or over-sharpened.
Displacement
Displacement drives Unreal's Nanite tessellation/displacement pin, letting the material push geometry detail outward based on a texture. The material supports both a dedicated displacement texture and a procedural fallback derived from the normal map, and layers moss growth on top of whichever one is active.
- A Displacement Texture Object Parameter is sampled (Texture Sample).
- Displacement Power, Displacement Sharpness, and Displacement Level Scalar Parameters are routed through Named Reroute Declarations so they can be reused elsewhere in the graph, then combined: the texture sample is raised to Displacement Power, multiplied by Displacement Sharpness, and has Displacement Level added on top.
- That result is passed through an SCurve material function call, shaped by a Displacement Curve Scalar Parameter, and declared as Displacement Out.
- Separately, a Derived Displacement block builds a fallback displacement value directly from the Normal map: it masks the normal's R and G channels, mirrors and combines them (Multiply by -1, Add), raises each side to a fixed Power of 0.7, sums and Saturates them, then raises the result to a configurable power and runs it through its own SCurve call before declaring it as Derived Displacement Out.
- A Derived Displacement? Static Switch Parameter picks between Derived Displacement Out (True) and a flat 0.5 Constant (False). A Texture Displacement? Static Switch Parameter then picks between the textured Displacement Out (True) and whatever the Derived Displacement switch produced (False).
- The Moss Displacement contribution is added on top of that result before it reaches the Displacement pin on Make Material Attributes.
Vertex Painting
Vertex Painting lets an artist blend up to three additional tiling textures onto the surface using the mesh's painted vertex colors — for example, painting dirt or moisture into crevices by hand in the mesh editor rather than relying purely on procedural masks. Note: the per-layer Lerp alphas in step 3 currently pull from the AO Out and Displacement Out reroutes rather than a per-channel mask of the Vertex Color node, and all three final blends in step 4 read from the same unmasked Vertex Color output rather than its individual R, G, and B channels. If you were expecting classic "paint red where the red channel is painted" behavior, it's worth comparing this against your intended design before relying on it.
- Three independent VertexRed, VertexGreen, and VertexBlue Texture Object Parameters hold the Red-, Green-, and Blue-channel textures.
- Each has its own Texture Coordinate and its own tiling Scalar Parameter (Vertex Paint Red UV, Vertex Paint Green UV, Vertex Paint Blue UV), multiplied together before feeding a Texture Sample — so each of the three layers can tile at a different scale.
- The Blue layer is declared directly as Vertex Blue Out with no additional blending. The Red and Green layers are each run through a Lerp against black before being declared as Vertex Red Out and Vertex Green Out.
- Further downstream, a Vertex Color node reads the mesh's painted vertex colors, and three chained Lerp nodes blend Vertex Red Out, Vertex Green Out, and Vertex Blue Out successively onto the base material result, all driven by that same Vertex Color output.
- A Vertex Painting? Static Switch Parameter chooses between this vertex-painted result and the un-painted base chain, so the whole feature can be switched off per instance.
Emissive Sweep
Emissive Sweep is a "build" or "activation" style wipe effect — a bright band that sweeps across the surface — commonly used for teleporters, terminals powering on, or holographic reveals.
- A fixed-scale UV set is generated through an MF_MacroUV call (using a Constant value of 4096 for its scale), independent of the main UV pipeline.
- That UV feeds an MF_EmissiveSweep material function call, along with SweepSpeed, SweepWidth, SweepHeight, SweepIntensity, and SweepFeather Scalar Parameters, and SweepHorizontal? / SweepEnable Static Bool Parameters to control the sweep's direction and an on/off toggle.
- The result is declared as an EmissiveSweep Named Reroute Declaration.
- Downstream, the combined emissive total (base Emissive plus Heat plus Static) is multiplied by EmissiveSweep before reaching the final EmissiveColor pin — meaning the sweep band modulates all emissive sources at once, not just the base emissive texture.
Grid Overlay
A simple debug/stylistic overlay that draws a scale grid across the surface, useful for blockout materials or a technical/UI-panel look.
- An Add Grid? Static Switch Parameter gates the whole feature.
- When enabled, an MF_Grid material function call takes a Grid Color Vector Parameter, a Grid Scale Scalar Parameter, and a Grid Edge Fade? Static Bool Parameter.
- Its result is added directly on top of the material's running Base Color total (after Vertex Painting has already been blended in) rather than replacing or lerping over it — so the grid reads as an additive bright overlay rather than a painted-on decal.
Weathering Effects (Material Parameter Collection)
Frost, Heat, Static, and Moss are four environmental effects that all read their intensity from a shared Material Parameter Collection, rather than from per-material parameters. A single global value — set once on the Collection, or driven at runtime from gameplay code — can push the same effect across every instance of this master material in the level simultaneously, without touching individual Material Instances. Five Collection Parameters read Flicker, Frost, Heat, Static, and Moss values from the Parameter Collection. Each is scaled and range-limited with a Multiply and a Clamp node (Frost clamped 0–10, Heat clamped 0–5, Static and Moss clamped 0–1) before being re-exposed through Named Reroute Declarations that the individual effect blocks below read from.
Frost
- A Component Mask pulls the green channel of BaseColor Out, raises it to a fixed Power of 6, and scales it up (Multiply by 10) to build a mask that concentrates frost onto whichever areas the base color's green channel reads brightest.
- That masked value feeds a further Power / Multiply / Add chain driven by MPC Frost (read three separate times, scaled by different amounts) and Saturated, producing a blend mask that sharpens and expands as the global Frost value increases.
- A frost texture is sampled through an MF_MacroUV call (fixed scale of 512) and Lerped onto black using that mask as alpha.
- A second Lerp blends the un-frosted surface against that frosted result, with MPC Frost (saturated) as the outer blend alpha — so frost only appears once the global Frost value rises above zero, and increases in coverage from there.
- The result is declared as Frost Out, which gets added directly on top of BaseColor Out before any other Base Color effects.
Heat
- The global MPC Heat value is read several times through separate Multiply nodes at different scales, each driving a different part of the effect: how sharply Ambient Occlusion shapes the result, how strong the glow color mixes in, and how visible the whole effect is overall.
- AO Out is raised to a Power whose exponent is shaped by MPC Heat, then inverted (One Minus) — so the areas the AO map marks as occluded contribute to the glow differently than exposed areas.
- Two heat-mask textures are sampled through separate MF_MacroUV calls (scales of 128 and 512). The first Lerps between two warm Constant3Vector tints — a red and an orange — to build a heat-glow color gradient; the second combines with MPC Heat to modulate overall glow intensity.
- The AO-derived value, the color gradient, and the intensity modulation are combined through a chain of Multiply and Lerp nodes, using MPC Heat as the blend alpha at two different points.
- The result is declared as Heat Out. An Effected By Heat? Static Switch Parameter (default True) later decides whether this material instance responds to the global Heat value at all before it's summed into the final emissive total.
Static
- Two Panner nodes scroll a shared texture in different directions and speeds (driven by Sine waves offset from Time), and a third Panner scrolls it a third way; the results are multiplied and saturated together to build a shifting interference-like mask.
- That mask is Lerped onto a fixed teal/green Constant3Vector tint (0.038, 1.0, 0.881 — a classic "electrical" color), then blended again using MPC Static (squared, so the effect ramps in gently at low values and sharply at high ones) as the alpha.
- The result is declared as Static Out, which is squared and scaled (Power, Multiply) before being summed into the final emissive total alongside Heat Out and the base Emissive Out.
Moss
- World Position and a rotated, large-scale UV set (tiled at 1024 via MF_MacroUV) drive a vertical growth mask: a fixed Texture Sample is inverted (One Minus) and blended against MPC Moss to decide how far up a surface moss should climb, then shaped with a Power curve.
- Three separate moss source textures — a base color/albedo map, a normal map, and a packed AO/Roughness/Metallic map — are each sampled through a Texture_Bombing material function call rather than a plain Texture Sample, which randomly offsets and rotates repeating tiles so the moss doesn't show an obvious grid pattern across large surfaces.
- The moss base color is tinted with a Constant3Vector (a mossy green) via Multiply.
- The growth mask from step 1 drives three Lerp nodes that blend the un-mossed surface toward the moss BaseColor, Normal, and packed AO/Roughness/Metallic map respectively.
- The packed moss map is split with three Component Mask nodes (R for AO, G for Roughness, B for Metallic) and the five results are declared as Moss BaseColorOut, Moss Normal Out, Moss AO Out, Moss Roughness Out, and Moss Metallic Out.
- Further downstream, each of these is Lerped against the corresponding base channel with MPC Moss as the alpha — so a single global dial gradually turns the entire surface, across every PBR channel at once, into moss as the value increases.
Moss Displacement
- The R and G channels of Moss BaseColorOut are masked out, added together, and averaged (Divide by 2) as a rough stand-in "height" value derived from the moss color texture (used since there's no dedicated moss height map).
- That average is added on top of the base Displacement Out value, raised to a MossDisplacementPower Scalar Parameter, multiplied by a MossDisplacementSharpness Scalar Parameter, and reshaped through an SCurve call driven by a MossDisplacementCurve Scalar Parameter.
- The result is Saturated and declared as Moss Displacement Out, which is added onto the main Displacement chain.
Rust
Rust is a procedural damage/staining layer that doesn't require a dedicated rust texture per material — it's generated from a single tiling mask texture and two fixed color tints, then added on top of Base Color.
- A Rust Scale Scalar Parameter is Rounded and used as the exponent of a Power node (base 2), so the exposed control steps through power-of-two tiling scales; that value feeds an MF_MacroUV call.
- A rust mask texture is sampled using those UVs, raised to a Rust Power Scalar Parameter, and multiplied by a Rust Sharpness Scalar Parameter to control how tightly the rust pattern is thresholded.
- That value is Saturated to drive the overall rust mask strength, and a second derived value (Subtract 0.7, Multiply by 0.5, Saturate) drives a Lerp between two rust color tints — a darker brown and a redder Constant3Vector — so heavier rust reads as a different color than light surface staining.
- The tinted result is declared as Rust Out.
- An Add Rust? Static Switch Parameter (present in both the Texture Based and Flat Color Based paths) adds Rust Out on top of the running Base Color total when enabled, after Grid has already been layered in.
The Flat Color Based Material Path
When Use Textures? is False, the material skips all texture sampling and builds its surface entirely from flat parameters — useful for greybox geometry or intentionally flat-shaded stylized props. It still shares several systems with the textured path: Heat, Static, and Rust all still apply, and normal detail is still built from Macro Normal blended against a flat base.
- BaseColor, Metallic, Specular, and Roughness Vector/Scalar Parameters feed directly into this path's Make Material Attributes node with no texture sampling involved.
- Emissive Color (Vector Parameter) and Emissive Intensity (Scalar Parameter) are multiplied together, then have the Effected By Heat?-gated Heat contribution and a Static contribution added on top, matching the textured path's emissive assembly.
- A BlendAngleCorrectedNormals call blends the Macro Normal detail layer against a flat base normal (rather than a sampled Normal texture), then the result is Normalized.
- Ambient Occlusion here is built from an Add of 0.5 plus a Frost contribution, Saturated, rather than from an AO texture.
- Add Rust? adds Rust Out on top of the flat Base Color exactly as it does in the textured path.
- The resulting Make Material Attributes node is the False input of the Use Textures? switch at the top of the graph.
Tying It All Together
At the root of the graph, a single Static Switch Parameter, Use Textures?, chooses between the Texture Based Material's Make Material Attributes output and the Flat Color Based Material's Make Material Attributes output. That result feeds directly into the Material Attributes pin on the material's root output node, which is what ultimately determines everything you see when the material is applied to a mesh: Base Color, Metallic, Specular, Roughness, Emissive Color, Normal, Ambient Occlusion, and Displacement, each assembled from the feature blocks described above. Because nearly every feature in this material is exposed as a parameter rather than hardcoded, artists build variety by creating Material Instances of M_MasterMaterial and adjusting these controls per asset — while systemic effects like Frost, Heat, Static, and Moss can additionally be pushed across every instance at once through the shared Material Parameter Collection, letting gameplay or level-design systems dial in environmental storytelling without touching individual materials at all.
// Key Features
- Single authored Master Material — every textured surface in the project is a Material Instance of it
- UV scaling and rotation exposed as per-instance parameters
- Albedo controls for per-instance colour and tint variation
- Displacement parameters for surface relief on supported meshes
- VFX feature hooks layered into the master graph and toggled per instance
- Material Parameter Collection bindings — game-loop events update every instance via shared MPC parameters, no per-actor work required
// Downloads
// Project Info
- Engine
- UE 5.8
- Status
- In Progress
- Category
- Unreal Engine