Utility Material Expressions

Utility Material Expressions are nodes that can affect Materials in a number of different ways than one might be used to. For example the GIReplace node will replace an object's indirect bounce color with a given value you input, while the Linear Interpolate node will help blend between two textures based on an Alpha input. On the following page you will find detailed descriptions for all of the Utility expressions are available in the Material Editor.

AntialiasedTextureMask

The AntialiasedTextureMask expression allows you to create a Material using a soft (anti-aliased) transition mask. The mask can be used to blend between two complex Material properties or to fade out an alpha blended Material (works well with SoftMasked). Specify a texture with the mask specified in one channel (red, green, blue, or alpha), set the used channel in the expression and specify the comparison value. Assuming the channel stores a grayscale value in the range 0 = black to 1 = white the comparison function defines if the resulting mask should be 0 or 1. This expression is a parameter, allowing the Texture property to be overridden by child MaterialInstances.

Pseudo code:

Result = 1
    if TextureLookup < Threshold then Result = 0

The actual implementation is quite a bit more complicated as it tries to return values between 0 and 1 depending on the actual pixel coverage to avoid aliasing.

Example (this tiny 128x128 texture, uncompressed for best quality):

Was used as a normal texture (left top) and used with the described material expression (bottom right):

The technique works best in magnification and with blurred input content. Compression hurts the quality a lot so try to use uncompressed low resolution textures.

BlackBody

The BlackBody expression simulates the effects of black body radiation within your Material. The user inputs a temperature (in Kelvin) and the resulting color and intensity can be used to drive Base Color and Emissive values to get a physically accurate result.

BumpOffset

BumpOffset is the Unreal Engine 4 term for what is commonly known as 'Parallax Mapping'. The Bump Offset expression allows a material to give the illusion of depth without the need for additional geometry. BumpOffset materials use a grayscale heightmap to give depth information. The brighter the value in the heightmap, the more 'popped out' the material will be; these areas will parallax (shift) as a camera moves across the surface. Darker areas in the heightmap are 'further away' and will shift the least.

ConstantBiasScale

The ConstantBiasScale expression takes an input value, adds a bias value to it, and then multiplies it by a scaling factor outputting the result. So for example, to convert input data from [-1,1] to [0,1] you would use a bias of 1.0 and a scale of 0.5.

DDX

The DDX expression exposes DDX derivative calculation, a GPU hardware feature used in pixel shader calculation.

DDY

The DDY expression exposes DDY derivative calculation, a GPU hardware feature used in pixel shader calculation.

DepthFade

The DepthFade expression is used to hide unsightly seams that take place when translucent objects intersect with opaque ones.

Without Depth Fade

With Depth Fade

The Material network for this example is pictured below.

DepthOfFieldFunction

The Depth of Field Function expression is designed to give artists control over what happens to a Material when it is being blurred by Depth of Field. It outputs a value between 0-1 such that 0 represents "in focus" and 1 represents "completely blurred." This is useful for interpolating between sharp and blurry versions of a texture, for instance. The Depth input allows for the existing results from the scene's Depth of Field calculations to be overridden by other calculations.

Blended Colors

Blending regular and blurred textures

Desaturation

The Desaturation expression desaturates its input, or converts the colors of its input into shades of gray, based a certain percentage.

Distance

The Distance expression computes the (Euclidian) distance between two points/colors/positions/vectors and outputs the resulting value. This works on one, two, three and four component vectors, but both inputs to the expression must have the same number of channels.

Note how the color changes as the camera distance increases.

Pseudo code:

Result = length (A - B)

Low level HLSL code:

float Result = sqrt (dot (A-B, A-B))

DistanceFieldGradient

The DistanceFieldGradient Material Expression node, when normalized, outputs the X,Y,Z direction an object would move with in the distance field. This makes the Distance Field Gradient Material Expression node well-suited for Materials that need to simulate the flow of liquids.

Here is an example of how to use the DistanceFieldGradient Material Expression in your Materials. In this example below make sure to note that the DistanceFieldGradient was first normalized and then input into a Mask Channel node. The reason for this is because without normalizing the DistanceFieldGradient first you can not get directional data. The Mask Channel Parameter was added to allow for easier RGB channel switching with in the Material Instance.

Here is an example of the DistanceFieldGradient in action. The image below shows what data the DistanceFieldGradient will use when the various RGB are enabled.

DistanceToNearestSurface

The Distance To Nearest Surface Material Expression node allows Materials to sample any point in the levels Global Distance Field. This Material Expression works by outputting the signed distance in world space units from the distance field to the nearest occluders in the scene.

Here is an example of the Distance To Nearest Surface Material Expression in action.

In this example the Distance To Nearest Surface was fed into the Opacity input on a Material and that Material was applied to a Static Mesh plane that was placed just above the levels floor. What the Distance To Nearest Surface is doing is telling the Material to only color areas red were the Static Meshes plane will start to intersect other Static Meshes placed in the scene.

FeatureLevelSwitch

The Feature Level Switch node allows you to make simplified materials for lower powered devices.

Example Usage: You might have a material with 10 textures overlapping and complex math, but just a single static texture for mobile (feature level ES2).

Fresnel

The Fresnel expression calculates a falloff based on the dot product of the surface normal and the direction to the camera. When the surface normal points directly at the camera, a value of 0 is output. When the surface normal is perpendicular to the camera, a value of 1 is output. The result is clamped to [0,1] so you do not have any negative color in the center.

GIReplace

GIReplace allows artists to specify a different, usually simpler, expression chain when the material is being used for GI.

Example Usage: Lightmass static GI and LPV dynamic GI use it.

LightmassReplace

The LightmassReplace expression simply passes through the Realtime input when compiling the material for normal rendering purposes, and passes through the Lightmass input when exporting the material to Lightmass for global illumination. This is useful to work around material expressions that the exported version cannot handle correctly, for example WorldPosition.

LinearInterpolate

The LinearInterpolate expression blends between two input value(s) based on a third input value used as a mask. This can be thought of as a mask to define transitions between two textures, like a layer mask in Photoshop. The intensity of the mask Alpha determines the ratio of color to take from the two input values. If Alpha is 0.0, the first input is used. If Alpha is 1.0, the second input is used. If Alpha is between 0.0 and 1.0, the output is a blend between the two inputs. Keep in mind that the blend happens per channel. So, if Alpha is an RGB color, Alpha's red channel value defines the blend between A and B's red channels independently of Alpha's green channel, which defines the blend between A and B's green channels.

Programmers: LinearInterpolate does a per-channel lerp between A and B based on the parametric value Alpha.

Noise

The Noise expression creates a procedural noise field, giving you control over how it is generated.

Previous Frame Switch

The Previous Frame Switch Material Expression assists with the implementation of complex vertex animations in Materials by providing a way to generate correct motion vectors which work correctly with Temporal AA and Motion Blur.

Materials that are only a function of time already work without modification, however, they cannot account for other variables, such as Material Parameters, that can affect the animation at runtime. The Previous Frame Switch Material Expression provides a means to solve these problems manually by tracking how these parameters change. For example, in Blueprints they could manually provide expressions for motion vector generation that is caused by changes in World Position Offset between frames.

Here is an example using Previous Frame Switch Material Expression in a Material.

In this example, the Previous Frame Switch is using a constant value to control the directional blur through a Multiply node.

In this example, you can see how this is being used in Epic's own games, like Fortnite, to control the motion blur with a Vertex Animation that assembles on screen. The animation on the right is using Previous Frame Switch to add some motion blur, while the animation on the left is not.

Viewport Show Flag

There is a show flag in the Editor viewport under Show > Visualize > Previous Frame's Reprojection that you can use with the Previous Frame Switch to diagnose and correct discrepancies in the directional vectors of the current and previous frame.

When enabled, this visualizer compares the current frame color with the previous, and returns the difference between the two frames. When the difference is zero, the Material appears gray in the viewport (pictured left). When the directional vectors do not match, the Material displays a colored overlay (pictured right).

QualitySwitch

The QualitySwitch expression allows for the use of different expression networks based on the engine is switched between quality levels, such as using lower quality on lower-end devices.

RotateAboutAxis

The RotateAboutAxis expression rotates a three-channel vector input given the rotation axis, a point on the axis, and the angle to rotate. This node outputs the Delta to the rotated position, not the fully rotated position itself. This makes it a useful and easy way to input the result into the World Position Offset input for simple rotations.

In the above example, the preview plane would appear to spin on its vertical axis.

SphereMask

The SphereMask expression outputs a mask value based on a distance calculation. If one input is the position of a point and the other input is the center of a sphere with some radius, the mask value is 0 outside and 1 inside with some transition area. This works on one, two, three, and four component vectors

The node outputs a value of 1 until the camera passes beyond a certain distance, after which it outputs 0.

Thin Translucent

The Thin Translucent Material Output expression accurately represents physically based transparent materials in a single pass. This enables you to create true tinted or colored transparent materials that accurately respond to lighting and shading.

When creating a tinted glass material, a white specular highlight and tinted background are needed. These are rendered in a single pass with a physically based shader that accounts for light bounces from the air into the glass and the glass into the air.

Standard Translucent Shading Model

Thin Translucent Shading Model

Vector Noise

The Vector Noise Material expression adds several more 3D or 4D vector noise results to use in your Materials. Due to the run-time expense of these functions, it is recommended that once a look is developed with them, all or part of the computation be baked into a Texture using the Render Targets feature.

These Material graph Expressions allow procedural looks to be developed in the engine on final assets, providing an alternative to creating procedurally generated Textures with an external tool. Inside the Vector Noise Material Expression, you will find the following Vector Noise types.

Image	Item	Description
	Cellnoise	Returns a random color for each cell in a 3D grid (i.e. from the mathematical floor operation applied to the node input). The results are always consistent for a given position, so can provide a reliable way to add randomness to a Material. This Vector Noise function is extremely cheap to compute, so it is not necessary to bake it into a Texture for performance.
	Perlin 3D Noise	Returns a random color for each cell in a 3D grid (i.e. from the mathematical floor operation applied to the node input). The results are always consistent for a given position, so can provide a reliable way to add randomness to a Material. This Vector Noise function is extremely cheap to compute, so it is not necessary to bake it into a Texture for performance.
	Perlin Gradient	Computes the analytical 3D gradient of a scalar Perlin Simplex Noise. The output is four channels, where the first three (RGB) are the gradient, and the fourth (A) is the scalar noise. This noise type is useful for bumps on a surface or for flow maps.
	Perlin Curl	Computes the analytical 3D curl of a vector Perlin Simplex Noise (aka Curl Noise). The output is a 3D signed curl vector and is useful for fluid or particle flow.
	Voronoi	Computes the same Voronoi noise as the scalar Noise material node. The scalar Voronoi noise scatters seed points in 3D space and returns the distance to the closest one. The Vector Noise version returns the location of the closest seed point in RGB, and the distance to it in A. Especially coupled with Cellnoise, this can allow some randomized behavior per Voronoi cell.

Below is a simple stone bed Material using the distance component of the Voronoi Vector Noise to modulate some surface bumps and blend moss into the cracks. The seed position together with Vector Noise > Cellnoise is used to change the color and bump height per rock.

The derivative-based operations Perlin Curl and Perlin Gradient can be added together in octaves, just as regular Perlin noise can. For derivatives of more complex expressions, it is necessary to compute the gradient of the result of the expression. To help with this, place the expression to compute into a Material Function and use it with the following helper nodes.

Below you will find descriptions of the various noise functions you will find in the Vector Noise Material Expression.

• Cell Noise Material Example:

  

• Perlin Gradient Material Example:

  

• Voronoi Material Example: