Unreal Engine 5 Documentation has been moved to the Epic Developer Community

Bump mapping is an old trick of graphics programmers (1978 James Blinn) that creates the illusion of bump surfaces through an adjusted shading computation without adding more geometry. Instead of using the surface normal, a new normal is used for shading. The new normal can be adjusted by a 1d function (e.g. Perlin noise, grayscale texture). This trick is much faster than doing real displacement mapping with minor short comings (e.g. silhouettes, occlusion, shadows).

In real-time rendering, we usually use a variant of bump mapping called normal mapping (bluish textures). Normal maps store a color in each pixel of the texture which is actually a 3d vector with the length of 1.

There are two ways to generate a normal map:

• Create a normal map from a grayscale image - Precompute the difference of each pixel to its vertical and horizontal neighbors. Convert the two resulting numbers (derivative) to a unit normal and store as color.

• Bake the normal down from a high poly 3d model - Associate each pixel of a texture with a 3d surface location on the high poly object and store its normal encoded as color.

In order to make the resulting texture reusable at any rotations, the normal vectors stored must be in tangent space , which consists of 3 vectors generally referred to as: normal, tangent and binormal. It defines how the surface is oriented. So by converting all normal into the tangent space, we can reuse them as they are now defined relative to the

1. Tangent space mapping depends on the UV mapping of the object because the x and y direction in the texture defines two vectors of the tangent space (tangent and binormal) in world space. It is difficult and takes time to produce good UV mapping without seeing tangent space artifacts.

What if we want to use a 3d grayscale function like Perlin noise? The function does not require any UV mapping and could improve the nearby detail rendering of bump surfaces. Implementing bump mapping without requiring tangent space makes this possible.

ddx and ddy

In order to implement bump mapping without tangent space, we added two new material expressions to the material editor: ddx and ddy . Each of these expressions returns an approximation of the derivative of its input. The graphics hardware calculates this approximate derivative by shading two pixels and subtracting the results ( ddx = right - left , ddy = bottom - top ).

These functions can only be used in the pixel shader and are generally only useful in Material Functions for implementing larger effects.

Bump Mapping Material Functions

Several Material Functions are provided to implement bump mapping in your materials without relying on tangent-space normal maps.

ComputeFilterWidth

This function makes use of ddx and ddy to compute how quickly a value is changing over the screen. This allows to fade out a procedural shader in the distance where it would start getting noisy. The fading results in less shimmering which is even more noticeable in motion and extremely important for bump mapping as specularity on bumpy surfaces can produce extreme aliasing artifacts.

The following example images show how a procedural bump map function can be faded out in the distance.

PerturbNormalLQ

The PerturbNormalLQ function converts a grayscale bump map input into a world-space normal. However, because it uses ddx and ddy , which have the aforementioned 2x2 block artifacts, the output world-space normal is of low quality.

PerturbNormalHQ

The PerturbNormalHQ function provides higher quality by calculating a more precise derivative than ddx and ddy provide. It does this by computing the scalar function multiple times using three sample positions.

PreparePerturbNormalHQ

The PreparePerturbNormalHQ function computes the three sample positions needed by the PerturbNormalHQ function to compute the world-space normal.

Single function instead of 3 functions

You can create a material function that encapsulate your bump mapping function and evaluate it 3 times in your other function. This hides the complexity to a certain degree.

Using Textures

Textures can be used with the bump mapping Material Functions for better performance; however, artifacts may be introduced due to the way in which the graphics card handles filtering textures. A normally filtered color is interpolated with a linear interpolation, the derivative of that is a constant. That means using a grayscale texture provides you with normals that are not smoothly interpolating of the surface.

Notes

The described method is based on the work from Morten S. Mikkelsen (see references).

Performance

Procedural shaders can cost quite some performance and are hard to implement without aliasing (compared to texture mapping). We currently provide Perlin noise and although this material expression can be optimized, it will always be a heavy operation. Using the levels feature for n levels requires most of the computations being done n times. Evaluating the function 3 times for bump mapping hurts even more. Be aware that the cost scales with pixel count. You can make use of all those features but we suggest them only for prototyping or in controlled situations.

Issues

• Flipped/Mirrored UV are not handled correctly yet.

Future Work

This method can be used to replace the explicit stored tangent space. To go in that direction, we need to get more experience. The current implementation not only enables artists to use this for bump mapping, but it also provides a way to do research.

References

• Bump Mapping Unparametrized Surfaces on the GPU (Morten S. Mikkelsen)

  Bump Mapping Unparametrized Surfaces on the GPU

• Derivative Maps (Mikkelsen and 3D Graphics blog)

  mmikkelsen3d.blogspot.com/2011/07/derivative-maps.html