Lumen Technical Details

An overview of technical capabilities and specifications of the Lumen Global Illumination and Reflections system.

Windows
MacOS
Linux

Lumen uses multiple ray tracing methods to solve Global Illumination and Reflections. Screen traces are done first, followed by a more reliable method.

Lumen uses Software Ray Tracing through Signed Distance Fields by default, but can achieve higher quality on supporting video cards when Hardware Ray Tracing is enabled.

Lumen's Global Illumination and Reflections primary shipping target is to support large, open worlds running at 60 frames per second (fps) on next-generation consoles. The engine's High scalability level contains settings for Lumen targeting 60 fps.

Lumen's secondary focus is on clean indoor lighting at 30 fps on next-generation consoles. The engine's Epic scalability level produces around 8 milliseconds (ms) on next-generation consoles for global illumination and reflections at 1080p internal resolution, relying on Temporal Super Resolution to output at quality approaching native 4k.

Surface Cache

Lumen generates an automatic parameterization of the nearby scene's surfaces called the Surface Cache. It is used to quickly look up lighting at ray hit points in the scene. Lumen captures the material properties for each mesh from multiple angles. These capture positions (called Cards) are generated offline for each mesh. These can be visualized with r.Lumen.Visualize.CardPlacement 1.

Nanite accelerates the mesh captures used to keep the Surface Cache in sync with the triangle scene. High-poly meshes in particular, need to be using Nanite to have efficient captures.

After the Surface Cache is populated with material properties, Lumen calculates direct and indirect lighting for these surface positions. These updates are amortized over multiple frames, providing efficient support for many dynamic lights and multi-bounce global illumination.

Unreal Engine provides visualization modes for Surface Cache and Cards representation. See the Lumen Visualization Options section of this page for more details.

Only meshes with simple interiors can be supported — walls, floors, and ceilings should be in separate meshes. Importing large, single meshes are not expected to work with Lumen.

Screen Tracing

Lumen features trace rays against the screen first (called Screen Tracing or Screen Space Tracing), before using a more reliable method if no hit is found, or the ray passes behind a surface. Screen tracing supports any geometry type and is useful for covering up mismatches between the Lumen Scene and triangle scene.

The disadvantage in using screen traces is that they greatly limit controls for art direction, which would only apply to indirect lighting, like lighting properties for Indirect Lighting Scale or Emissive Boost.

In the scene below, Software Ray Tracing uses screen traces first before falling back to other, more costly tracing options. If screen traces are disabled for global illumination and reflections, you see only the Lumen Scene. Screen traces help resolve the mismatch that can happen between the triangle scene and Lumen Scene.

You can disable screen traces for comparison by using the console to set r.Lumen.ScreenProbeGather.ScreenTraces 0 and `r.Lumen.Reflections.ScreenTraces 0**.

Screen Traces Enabled | (Default)

Screen Traces Disabled

Lumen Ray Tracing

Lumen has two methods of ray tracing in Unreal Engine 5: Software Ray Tracing which operates on the widest range of hardware and platforms and Hardware Ray Tracing which requires supported video cards and systems to operate.

Software Ray Tracing

Lumen uses Software Ray Tracing against Signed Distance Fields by default. This tracing representation is supported on any hardware supporting Shader Model 5 (SM5), and only requires Generate Mesh Distance Fields to be enabled in the project settings.

The renderer merges Mesh Distance Fields into a Global Distance Field to accelerate tracing. By default, Lumen traces against each mesh's Distance Fields for the first two meters for accuracy, and the merged Global Distance Field for the rest of each ray. Projects with extreme overlapping instances can control the method Lumen uses with Software Ray Tracing Mode in the project settings.

Lumen's Software Ray Tracing provides two tracing options:

  • Detail Tracing is the default tracing method. It traces against the individual mesh's Distance Field for the highest quality, using the first two meters for accuracy and the Global Distance Field for the rest of each ray.

  • Global Tracing traces against the Global Distance Field for the fastest traces.

Mesh Distance Fields are streamed in and out based on distance as the camera moves through the world. They are packed into a single atlas to allow ray tracing, which has stats that can be output to the log using r.DistanceFields.LogAtlasStats 1.

The quality of Lumen's Software Ray Tracing can sometimes depend on the quality of the mesh's Distance Field representation. The two visualization options for Mesh Distance Fields and Global Distance Field are found in the viewport's Show > Visualize menu.

Mesh Distance Fields | Visualization

Global Distance Field | Visualization

For some meshes, thin surfaces may not have good Distance Field respresentation and could cause issues with light leaking. the Mesh Distance Field visualization can help you spot these types of issues.

mdfresolution-chandelier.png

(Left to Right) Triangle Mesh, Distance Field Resolution Scales 1.0 (Default), 1.5, 2.0

There are two ways to improve Distance FIeld representation. Projects can increase them by using the project settings Distance Field Voxel Density, which affects the entire project. And preferably, adjust the Distance Field Resolution Scale setting in the Static Mesh Editor for only the meshes that are causing problems with Software Ray Tracing. Increasing Distance Field resolution or density will increase the disk size of the project.

Project Settings: Distance Field Voxel Density

Static Mesh Editor: Distance Field Resolution Scale

Click image for full size.

Click image for full size.

Limitations of Software Ray Tracing

Software Ray Tracing has some limitations relating to how you should work with it in your projects, and what types of geometry and materials it currently supports.

This is not an exhaustive list of known issues or limitations, but is largely representative of what you should expect while working with Lumen Software Ray Tracing in Unreal Engine 5 Early Access.

Geometry Limitations
  • Only Static Meshes, Instanced Static Meshes, and Hierarchical Instanced Static Meshes are represented in the Lumen Scene.

  • Landscape geometry is not currently represented in the Lumen Scene and therefore does not bounce lighting. This will be supported in a future release of the engine.

Material Limitations
  • World Position Offset (WPO) is not supported.

  • Transparent materials are ignored by Distance Fields and treat Masked materials as opaque. This can cause significant over-shadowing on foliage, which has large areas of leaves masked out.

  • Distance Fields are built off of the properties of the material assigned to the Static Mesh Asset, rather than the override component. Overriding with a material that has a different Blend Mode or Two-Sided property will cause a mismatch between the triangle representation and the Distance Field.

Workflow Limitations
  • Software Ray Tracing requires levels to be made out of modular pieces. Walls, floors, and ceilings should be separate meshes. Large meshes, like mountains, will have poor representations and may cause self-occlusion artifacts.

  • Walls should be no thinner than 10 centimeters (cm) to avoid light leaking.

  • Mesh Distance Field resolution is assigned based on the imported scale of the Static Mesh. A mesh that is imported very small and then scaled up on the component will not have sufficient Distance Field resolution. If you use significant scaling on placed instances in a level, use Distance Field Resolution Scale to compensate.

  • Distance Fields cannot represent extremely thin features, or one-sided meshes seen from behind. Avoid artifacts by ensuring the viewer doesn't see triangle back faces of one-sided meshes.

Hardware Ray Tracing

Hardware Ray Tracing supports a larger range of geometry types than Software Ray Tracing, in particular it supports tracing against skinned meshes. Hardware Ray Tracing also scales up better to higher qualities — it intersects against the actual triangles and has the option to evaluate lighting at the ray hit instead of the lower quality Surface Cache. However, Hardware Ray Tracing has significant scene setup cost and currently cannot scale to scenes with more than 100,000 instances. Dynamically deforming meshes, like skinned meshes, also incur a large cost to update the Ray Tracing acceleration structures each frame, proportional to the number of skinned triangles.

For static meshes using Nanite, Hardware Ray Tracing can only operate on the Proxy Mesh generated from Nanite's Proxy Triangle Percent in the Static Mesh Editor settings. These Proxy Meshes can be visualized with the console command r.Nanite 0 or using the hotkey CTRL + N.

Screen Traces are used to cover the mismatch between the full triangle mesh rendered by Nanite and the Proxy Mesh being ray traced by Lumen. However, in some cases, the mismatch is too large to be hidden. In these cases, raising the Proxy Triangle Percent can reduce incorrect self-intersection artifacts.

Full-detail Triangle Mesh

Nanite's Generated Proxy Mesh

Lumen will use Hardware Ray Tracing when:

  • The project has Support Hardware Ray Tracing enabled, and when Lumen's project setting Use Hardware Ray Tracing when available is enabled. These are set in the Project Settings under the Rendering category. Changing these settings requires that the engine be restarted.

  • The project is running on a supported operating system, RHI, and video card. Currently, only the following platforms support performant Hardware Ray Tracing:

  • Windows 10 with DirectX 12

    • PlayStation 5

    • Xbox Series S / X

    • Video cards must be NVIDIA RTX-2000 series and higher, or AMD RX 6000 series and higher.

Large Worlds

Lumen Scene operates on the world near the cameras rather than the whole, enabling large worlds and streaming. Lumen relies on Nanite's Level of Detail (LOD) and Multi-View rasterization for fast scene captures to maintain the Surface Cache, with all operations throttled to prevent hitches from occurring. Lumen does not require Nanite to operate, but Lumen's scene capturing becomes very slow in scenes with lots of high poly meshes that have not enabled Nanite. This can be especially true in scenes if the assets do not have good LODs set up.

Fast camera movement will cause Lumen Scene updating to fall behind where the camera is looking, causing indirect lighting to pop in as it catches up.

Lumen Surface Cache covers the 200 meters from the camera position. Past this, only screen traces are active for global illumination.

Lumen has an experimental Distant Scene representation to provide traces past the Surface Cache. This was used in the Unreal Engine 5 technical demo "Lumen in the Land of Nanite" to achieve indirect lighting in the canyon. It covers the range of 200 meters to 1 kilometer from the camera (see image below). It works by rendering a low resolution Reflective Shadowmap from the sun using Nanite, and traces against this heightfield during the Final Gather to pick up one bounce of the sun's indirect lighting. This Distant Scene representation is promising but requires significant development to be shippable in projects.

ue5techdemolargeworldscene.png

The Unreal Engine 5 technical demo "Lumen in the Land of Nanite" demonstrates large-world global illumination and reflection.

Other Limitations of Lumen

  • Lumen Global Illumination cannot be used with Static lighting in lightmaps. Lumen Reflections should be extended to work with global illumination in lightmaps in the future, which will provide a way to further scale up render quality.

  • Foliage is not well supported in this Early Access build because of the heavy reliance on downsampled rendering and temporal filters.

  • Lumen's Final Gather can add significant noise around moving objects and is still under active development.

  • Translucent materials are not yet supported for Lumen Reflections.

  • Translucent materials will not have high-quality dynamic global illumination.

Performance

Lumen defaults for the Epic scalability level are set for a 30 fps budget (8ms Global Illumination and Reflections) at 1080p on next-generation consoles. Lumen relies heavily on Unreal Engine 4's Temporal Upsampling with the new UE5 Temporal Super Resolution algorithm for 4k output. Under the High engine scalability level, Lumen uses defaults targeting 60 fps. Lumen is disabled under Low and Medium scalability levels.

Materials with roughness below 0.4 cost the most for Lumen to solve lighting for, as extra rays have to be traced to provide Lumen Reflections.

Lumen Platform Support

  • Lumen does not support current-generation consoles, such as PlayStation 4 and Xbox One.

    • Projects that rely on dynamic lighting can use a combination of Distance Field Ambient Occlusion and Screen Space Global Illumination on current-generation consoles and legacy PC hardware.

    • Lumen is developed for next-generation consoles (PlayStation 5 and Xbox Series S / X) and high-end PCs. Lumen has two ray tracing modes each with different requirements:

  • Software Ray Tracing:

    • Video cards using DirectX 11 with support for Shader Model 5.

    Currently requires an NVIDIA GeForce GTX-1070 or greater card for performance in Early Access. Lumen has many options for scaling down but requires further development recommended for use.

  • Hardware Ray Tracing:

    • Windows 10 with DirectX 12 support.

    • Video cards must be NVIDIA RTX-2000 series and higher, or AMD RX-6000 series and higher.

  • Lumen does not support mobile platforms and there are no plans to develop a dynamic global illumination system for the mobile renderer. Games using dynamic lighting need to use unshadowed Sky Light on mobile.

Lumen Visualization Options

Lumen provides several ways of visualizing data in the Unreal Editor that can be helpful in inspecting and troubleshooting how Lumen is lighting the scene.

The primary visualization options are found in the Level Viewport under the Show > Visualize menu.

Click image for full size.

Property

Description

Viewport Visualization Modes

Lumen Scene

Visualize the scene with Lumen's Surface Cache.

Lumen Global Illumination

Visualize the scene with only Lumen's Global Illumination and Reflections features.

Software/Hardware Ray Tracing

Mesh Distance Fields

Visualize the individual mesh's Signed Distance Field representations that make up the scene.

Global Distance Fields

Visualize individual Mesh Distance Fields that have been merged based on the rendered scene view into a larger, lower-detail Distance Field representation.

There are also some console commands you can use to visualize other data being used for Lumen:

  • Lumen's Card Placement looks at how capture positions (called Cards) are used in the scene. These Cards are generated offline for each mesh, and are used to capture the material properties of each mesh from multiple angles. Use r.Lumen.Visualize.CardPlacement 1 to enable this.

  • Hardware Ray Tracing uses the Nanite Proxy Mesh, which is generated from the Proxy Triangle Percent property of a Static Mesh Asset. The proxy mesh is used to cover mismatches between screen traces and the Nanite ray-traced scene in Lumen Reflections. Use r.Nanite 0 to disable Nanite rendering and see the proxy mesh used by Lumen.

Troubleshooting Topics

When troubleshooting any Lumen-related issues in your scene, a good place to start is with the Lumen Scene visualization listed under the viewport's Show > Visualization menu.

This view should match the main scene view in ways that have noticeable impact on indirect lighting. For example, in Lumen Scene, the metal doors on the building and the bus are more likely to reflect some of their color into the scene in a noticeable way.

TestScene_LumenEnabled.png

TestScene_LumenSceneCardsRepresentation.png

Problem-Causing Meshes

In cases where you have problem-causing meshes contributing to indirect lighting, they can be removed using the Level instance's Details panel.

For Software Ray Tracing, unchecking the box for Affect Distance Field Lighting removes them.

For Hardware Ray Tracing, unchecking the box for Affect Dynamic Indirect Lighting removes them.

Mismatch Between Shadow Maps and Ray-Traced Shadows

Lumen reuses the Renderer's shadowmaps for shadowing the Lumen Scene. However, these are only available for on-screen positions. For off-screen surfaces, Lumen uses ray tracing for shadowing. When there is significant mismatch between these two techniques, Lumen Global Illumination becomes highly view-dependent, similarly to the screen space techniques like Screen Space Global Illumination.

The issue can often be solved by figuring out what is causing the mismatch to happen. Use the console to enter r.Lumen.DirectLighting.ForceOffscreenShadowing 1 while looking at the Lumen Scene visualization mode to see the raytraced shadows.