RTX Path Tracing v1.8.1

What's new in 1.8.0 and 1.8.1

• Performance optimizations (25-30%+ perf gain over 1.7.x with comparable or better quality)
• New performance/quality presets in "Display and performance" allow for better scaling from low end to high end GPUs
• New modes in bistro-programmer-art scene for stress testing animation and dynamic lighting scenarios (see 1, 2, 3, 4)
• Fixes for a number of DLSS-RR denoising stability issues in reflected/refracted surfaces
• DirectX SER and Opacity Micromaps are now available when Agility SDK 1.619 is enabled (on by default in 1.8.1, requires DXR 1.2 driver support; to disable, remove Agility SDK 1.619 from CMake settings)

See Releases for more detail and downloads.

Overview

RTX Path Tracing is a code sample that strives to embody years of ray tracing and neural graphics research and experience. It is intended as a starting point for a clean path tracer integration, as a reference for various integrated SDKs, and/or for learning and experimentation.

It is a pure path tracer that does not rely on rasterization. In its main configuration, all light transport is evaluated within a single ray tracing pass, leveraging light-sampling caches for real-time performance. It further employs path-space layer decomposition and guide-buffer generation to support real-time denoising (DLSS-RR) and other techniques.

The base path tracing implementation derives from NVIDIA’s Falcor Research Path Tracer, ported to approachable C++/HLSL Donut framework.

GTC presentation How to Build a Real-time Path Tracer provides a high level introduction to most of the features, although it is pretty much out of date by now.

Features

• DirectX 12 and Vulkan back-ends
• Reference and real-time modes
• Simple BSDF model that is easy(ish) to extend
• Simple asset pipeline based on glTF 2.0 (support for a subset of glTF extensions including animation)
• Volumes and nested dielectrics with priority
• Support for analytic lights (directional, spot, point), emissive triangles and environment map lighting
• NEE lighting with feedback-based, temporaly adaptive guided importance sampling (NEE-AT)
• Path tracing features such as: Low-discrepancy sample generator based on Practical Hash-based Owen Scrambling, use of RayCones for texture MIP selection, RR early ray termination, firefly filter and similar
• Basic post-processing features such as: TAA, tone mapping, bloom and similar
• Reference mode 'photo-mode screenshot' with simple OptiX denoiser integration
• Shader Execution Reordering for significant increase in execution performance
• RTXDI integration for ReSTIR DI (light importance sampling) and and ReSTIR GI (indirect lighting)
• OMM integration for fast ray traced alpha testing
• NRD ReLAX and ReBLUR denoiser integration with up to 3-layer path space decomposition
• RTXTF integration for Stochastic Texture Filtering
• Streamline integration for DLSS (DLSS RR, DLSS SR, DLSS AA, DLSS FG & MFG)

Requirements

• Windows 10 20H1 (version 2004-10.0.19041) or newer
• DXR Capable GPU (DirectX Raytracing 1.1 API, or higher; if DXR 1.2 not available please disable Agility SDK 1.619 in CMake settings)
• GeForce Game Ready Driver 595.71 or newer
• DirectX 12 or Vulkan API
• CMake v4.02+
• Visual Studio 2022 (v143 build tools) or later with Windows 10 SDK version 10.0.20348.0 or 10.0.26100.0 or later

Known Issues

• By default, Agility SDK 1.619 is enabled and requires DXR 1.2 (Shader Model 6.9). Our current setup can only switch to older shader models at build configuration time, so if your GPU does not support DXR 1.2 with Shader Model 6.9, set RTXPT_D3D_AGILITY_SDK_PATH, RTXPT_D3D_AGILITY_SDK_VERSION and RTXPT_D3D_AGILITY_SDK_VERSION_NAME CMake variables to empty before cleaning the /bin folder, re-configuring/re-generating and rebuilding the project.
• Enabling Vulkan support requires a couple of manual steps, see below
• SER and OMM support on Vulkan is currently work in progress
• Running Vulkan on AMD GPUs may trigger a TDR during TLAS building in scenes with null TLAS instances
• Enabling debug layer on Vulkan will show a number of warnings and errors - fixes are work in progress
• We recommend using NVIDIA Nsight Graphics graphics for frame capture and analysis. If using other GPU performance tuning and debugging tools such as PIX on Windows, it is advisable to disable NVRHI_WITH_NVAPI and DONUT_WITH_STREAMLINE variables in CMake to avoid compatibility issues. Please note: disabling these settings results in lower performance and missing features
• There is a known issue resulting in LIVE_DEVICE DirectX warnings reported at shutdown when Streamline is enabled in Debug builds
• There is a known issue resulting in black or incorrect transparencies/reflection on some AMD systems with latest drivers; this is most likely a driver error and has been reported

Folder Structure

Build

At the moment, only Windows builds are fully supported. We are going to add Linux support in the future.

1. Clone the repository with all submodules recursively:

git clone --recursive https://github.com/NVIDIA-RTX/RTXPT.git

1. Use CMake to configure the build and generate the project files.

cd RTXPT cmake CMakeLists.txt -B ./build

Use -G "some tested VS version" if specific Visual Studio or other environment version required. Make sure the x64 platform is used.

1. Build the solution generated by CMake in the ./build/ folder.

In example, if using Visual Studio, open the generated solution build/RTXPathTracing.sln and build it.

1. Select and run the Rtxpt project. Binaries get built to the bin folder. Assets/media are loaded from Assets folder.

If making a binary build, the Assets and Support folders can be placed into bin next to executable and packed up together (i.e. the sample app will search for both Assets/ and ../Assets/).

Building Vulkan

Due to interaction with various included libraries, Vulkan support is not enabled by default and needs a couple of additional tweaks on the user side; please find the recommended steps below: * Install Vulkan SDK (we tested with VulkanSDK-1.3.290.0) and clear CMake cache (if applicable) to make sure the correct dxc.exe path from Vulkan SDK is set for SPIRV compilation * Set DONUT_WITH_VULKAN and NVRHI_WITH_VULKAN CMake variables to ON. DXC_SPIRV_PATH should already have automatically picked up the location of the DXC compiler in the Vulkan SDK during config; if not, please set it manually * To run with Vulkan use --vk command line parameter

## DirectX 12 Agility SDK RTX PT optionally integrates DirectX 12 Agility SDK. If RTXPT_DOWNLOAD_AND_ENABLE_AGILITY_SDK CMake variable is set to TRUE, the version 717-preview will be automatically downloaded via CMake script and required build variables will be set. If different version is required, please set correct RTXPT_D3D_AGILITY_SDK_PATH and RTXPT_D3D_AGILITY_SDK_VERSION.

Version 717-preview enables native DirectX support for Shader Execution Reordering and Opacity Micromaps. For testing this on Nvidia hardware, a preview driver is required and can be downloaded from https://developer.nvidia.com/downloads/shadermodel6-9-preview-driver

## User Interface

Once the application is running, most of the SDK features can be accessed via the UI window on the left hand side and drop-down controls in the top-center.

Camera can be moved using W/S/A/D keys and rotated by dragging with the left mouse cursor.

Command Line

• --scene loads a specific .scene.json file; example: --scene programmer-art.scene.json
• --width and --height to set the window size; example: --width 3840 --height 2160
• --fullscreen to start in full screen mode; example: --width 3840 --height 2160 --fullscreen
• --debug to enable the graphics API debug layer or runtime, and additional validation layers.
• --vk to enable Vulkan (see building-vulkan)

Developer Documentation

We are working on more detailed SDK developer documentation - watch this space!

Contact

RTX Path Tracing is under active development. Please report any issues directly through GitHub issue tracker, and for any information, suggestions or general requests please feel free to contact us at pathtracing-sdk-support@nvidia.com!

Thanks

Many thanks to the developers of the following open-source libraries or projects that make this project possible: * dear imgui (https://github.com/ocornut/imgui) * DirectX Shader Compiler (https://github.com/microsoft/DirectXShaderCompiler) * cgltf, Single-file glTF 2.0 loader (https://github.com/jkuhlmann/cgltf) * Krzysztof Narkowicz's Real-time BC6H compression on GPU (https://github.com/knarkowicz/GPURealTimeBC6H) * okdshin's https://github.com/okdshin/PicoSHA2 * ...and any we might have forgotten (please let us know) :)

Citation

If you use RTX Path Tracing in a research project leading to a publication, please cite the project. The BibTex entry is

@online{RTXPT,
   title   = {{{NVIDIA}}\textregistered{} {RTX Path Tracing}},
   author  = {{NVIDIA}},
   year    = 2023,
   url     = {https://github.com/NVIDIA-RTX/RTXPT},
   urldate = {2024-01-26},
}

License

See LICENSE.txt

This project includes NVAPI software. All uses of NVAPI software are governed by the license terms specified here: https://github.com/NVIDIA/nvapi/blob/main/License.txt.