ReSTIR PT

Author: SomeNvidiaGuy

.gitmodules

@@ -4,15 +4,15 @@
 [submodule "NRD"]
 	path = External/NRD
 	url = https://github.com/NVIDIA-RTX/NRD.git
-[submodule "DLSS"]
-	path = External/DLSS
-	url = https://github.com/NVIDIA/DLSS.git
 [submodule "rtxdi-runtime"]
 	path = Libraries/Rtxdi
-	url = https://github.com/NVIDIA-RTX/RTXDI-Library.git
+	url = https://github.com/NVIDIA-RTX/RTXDI-Library
 [submodule "thirdparty/cxxopts"]
 	path = External/cxxopts
 	url = https://github.com/jarro2783/cxxopts.git
 [submodule "Assets/Media"]
 	path = Assets/Media
-	url = https://github.com/NVIDIA-RTX/RTXDI-Assets.git
+	url = https://github.com/NVIDIA-RTX/RTXDI-Assets
+[submodule "External/NVAPI"]
+	path = External/NVAPI
+	url = https://github.com/NVIDIA/nvapi.git

Assets/Media

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.10)
 
 project(RTXDI)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS ON)
 
@@ -37,6 +37,12 @@ option(DONUT_WITH_DX11 "" OFF)
 option(DONUT_WITH_VULKAN "" ON)
 option(DONUT_WITH_LZ4 "" OFF)
 option(DONUT_WITH_MINIZ "" OFF)
+option(DONUT_WITH_DLSS "" ON)
+
+# Setup NVAPI support
+option(NVRHI_WITH_NVAPI "Include NVAPI support (requires NVAPI SDK)" ON)
+set(NVAPI_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/External/NVAPI/" CACHE STRING "Path to NVAPI include headers/shaders" )
+set(NVAPI_LIBRARY "${CMAKE_CURRENT_SOURCE_DIR}/External/NVAPI/amd64/nvapi64.lib" CACHE STRING "Path to NVAPI .lib file")
 
 # Helper to download and unzip a package from a URL
 # Uses a zero-length file to identify the version of the package
@@ -60,20 +66,20 @@ endfunction()
 
 # Download DXC
 if (WIN32)
-	CheckAndDownloadPackage("DXC" "v1.7.2212.1" ${CMAKE_CURRENT_SOURCE_DIR}/External/dxc https://github.com/microsoft/DirectXShaderCompiler/releases/download/v1.7.2212.1/dxc_2023_03_01.zip)
-	set(REDIST_DXC "${CMAKE_CURRENT_SOURCE_DIR}/External/dxc/bin/x64/dxc.exe")
+	CheckAndDownloadPackage("DXC" "v1.8.2505.1" ${CMAKE_CURRENT_SOURCE_DIR}/External/dxc https://github.com/microsoft/DirectXShaderCompiler/releases/download/v1.8.2505.1/dxc_2025_07_14.zip)
+	set(SHADERMAKE_DXC_PATH "${CMAKE_CURRENT_SOURCE_DIR}/External/dxc/bin/x64/dxc.exe")
 else()
-	CheckAndDownloadPackage("DXC" "v1.7.2212.1" ${CMAKE_CURRENT_SOURCE_DIR}/External/dxc https://github.com/microsoft/DirectXShaderCompiler/releases/download/v1.7.2212.1/linux_dxc_2023_03_01.x86_64.tar.gz)
+	CheckAndDownloadPackage("DXC" "v1.8.2505.1" ${CMAKE_CURRENT_SOURCE_DIR}/External/dxc https://github.com/microsoft/DirectXShaderCompiler/releases/download/v1.8.2505.1/linux_dxc_2025_07_14.x86_64.tar.gz)
 	# Add execute permissions
 	file(CHMOD ${CMAKE_CURRENT_SOURCE_DIR}/External/dxc/bin/dxc PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE)
-	set(REDIST_DXC "${CMAKE_CURRENT_SOURCE_DIR}/External/dxc/bin/dxc")
+	set(SHADERMAKE_DXC_PATH "${CMAKE_CURRENT_SOURCE_DIR}/External/dxc/bin/dxc")
 endif()
-if (EXISTS "${REDIST_DXC}")
+if (EXISTS "${SHADERMAKE_DXC_PATH}")
 	if (WIN32 AND NOT DXC_PATH)
-		set(DXC_PATH "${REDIST_DXC}" CACHE STRING "Path to DirectX Shader Compiler for DXIL output")
+		set(DXC_PATH "${SHADERMAKE_DXC_PATH}" CACHE STRING "Path to DirectX Shader Compiler for DXIL output")
 	endif()
 	if (NOT DXC_SPIRV_PATH)
-		set(DXC_SPIRV_PATH "${REDIST_DXC}" CACHE STRING "Path to DirectX Shader Compiler for SPIR-V output")
+		set(DXC_SPIRV_PATH "${SHADERMAKE_DXC_PATH}" CACHE STRING "Path to DirectX Shader Compiler for SPIR-V output")
 	endif()
 endif()
 # Have ShaderMake use included DXC
@@ -96,12 +102,12 @@ add_subdirectory(External/donut)
 set(DONUT_PATH "${CMAKE_CURRENT_LIST_DIR}/External/donut")
 
 include(External/NRD.cmake)
-include(External/DLSS.cmake)
 
 if (EXISTS "${CMAKE_CURRENT_LIST_DIR}/Libraries/Rtxdi/CMakeLists.txt")
 
     add_subdirectory(Libraries/Rtxdi)
     set(RTXDI_RUNTIME_INCLUDE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Libraries/Rtxdi/Include")
+    set_target_properties(Rtxdi PROPERTIES FOLDER "RTXDI SDK")
 
 endif()
 
@@ -118,7 +124,11 @@ add_subdirectory(Samples/FullSample/Shaders)
 add_subdirectory(Samples/FullSample/Source)
 add_subdirectory(Samples/MinimalSample/Shaders)
 add_subdirectory(Samples/MinimalSample/Source)
+add_subdirectory(Support/Tests/FullSampleStructAlignmentTests)
 add_subdirectory(Support/Tests/RtxdiRuntimeShaderTests)
+add_subdirectory(Support/Tests/RtxdiRuntimeStructAlignmentTests)
+
+set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT FullSample)
 
 if (MSVC)
 	set_property(DIRECTORY PROPERTY VS_STARTUP_PROJECT FullSample)

CMakeLists.txt

@@ -1,5 +1,30 @@
 # RTXDI SDK Change Log
 
+## 3.0.0
+
+**Release highlights:**
+
+- Added ReSTIR PT resampling functions to the runtime and their integration in the Full Sample application.
+- Added shader debug print for D3D12.
+- Added path tracer visualization tool.
+- Added Primary Surface Replacement (PSR) support for NRD integrations.
+- Added visualization tools for DI, GI, and PT reservoirs.
+
+**Breaking changes:**
+
+- The RTXDI_PathTracerContext interface uses a primitive #define-based interface for maximum compatibility and requires an additional preprocessor macro.
+
+**Fixed issues:**
+
+- Removed ghosting issues that appeared on recent drivers.
+
+**Misc improvements:**
+
+- Updated Donut
+- Updated NRD
+- DLSS integration replaced by Donut's DLSS integration
+- Added NVAPI for D3D12
+
 ## 2.3.0
 
 **Release highlights:**

ChangeLog.md

@@ -0,0 +1,29 @@
+# Debug Utilities
+
+The RTXDI SDK contains several tools for debugging and visualizing data.
+
+## Shader Debug Print
+
+Shader debug printing is supported in D3D12 for a single pixel, which is selected by mouse click. Enabling it requires setting `SHADER_DEBUG_PRINT_ENABLED` to 1, as well as binding several buffers to the shader and running the proper initialization code, which can be seen in the `RAB_Buffers.hlsli` and `GenerateInitialSamples.hlsl` files. Once enabled, the `DebugPrint_` function can send formatted strings, which support primitive types such as scalars and vectors, back to the host side. When run from the MSVS debugger, this output shows up in the Output panel. When run standalone, it can be seen by running [Debug View](https://learn.microsoft.com/en-us/sysinternals/downloads/debugview). The `RuntimeShaderDebugPrintUtilities.hlsli` file contains helper functions for printing the `RTXDI_PTReservoir` and `RTXDI_PTPathTraceInvocationType` types.
+
+`DebugPrint_` works like printf, but uses braced numbers instead of percentage signs to send out variables. For example, `DebugPrint_("Hello pixel: {0}", pixelPos);` and `DebugPrint_("Diffuse is {0} and specular is {1}", diffuse, specular);` will work as expected.
+
+**Note:** `DebugPrint_` degrades shader performance proportional to its usage - the more and longer the strings, the slower the shader gets. Performance should be fine for debugging, but don't forget to turn it off to measure performance.
+
+**Note:** There are rare cases when `DebugPrint_` may cause general shader corruption for unknown reasons, typically from overuse. Try disabling `DebugPrint_` if you find the sample has gone haywire.
+
+## Path Visualization
+
+The path visualization tool tracks the bounces of the path tracer and records each hit, normal vector, and NEE sample, if one is taken. All five path tracing invocations are supported - initial sampling, temporal shift, temporal inverse shift, spatial shift, and spatial inverse shift. Two additional passes of temporal retrace and spatial retrace re-run the path tracer from the temporal or spatial neighbor's primary surface to the maximum bounce depth. Paths can be individually enabled and colored.
+
+Performance note: Enabling path visualization causes a minor hit to performance and is compiled out by default. To enable it, set the `PT_PATH_VIZ_ENABLED` define to 1 and recompile. The two temporal and spatial retrace options are additionally toggled by the `RTXDI_DEBUG` define, which lives in the runtime rather than in the sample, and it must also be set to 1 to enable them.
+
+**Note:** Sometimes the path visualization tool ends up adding an extra vertex (and often normal and NEE ray) at the camera position as a result of encountering stale data. This shows up as a line jumping across the screen. Just try clicking again to get a different path.
+
+## Intermediate Buffer Visualization
+
+The Intermediate Buffer Visualization menu in the GUI allows users to visualize buffer data in several ways
+
+- Intermediate Texture Display blits the selected buffer directly to the screen. The list includes GBuffer layers and their PSR counterparts, as well as lighting components such as direct and indirect illumination.
+- Reservoir Subfield Display sends the chosen field of the selected reservoir type to the screen, transforming some values to help in visualization.
+- NRD Validation blits the NRD validation texture to the screen, with the option of overlaying it on top of the regularly rendered output.

Doc/DebugUtilities.md

@@ -1,10 +1,11 @@
-# Three Algorithms in One SDK
+# Four Algorithms in One SDK
 
 The RTXDI SDK originally contained a single algorithm, ReSTIR DI. Over time, however, the SDK has been expanded to include the ReGIR and ReSTIR GI algorithms. These three algorithms are grouped together because they all deal with importance sampling for path tracing. While something like "RTX IS" might therefore be a clearer name today, RTXDI is kept for historical continuity, and the DI now stands for Dynamic Illumination. Here is a summary of the three algorithms:
 
 - ReSTIR DI, short for **Re**servoir **S**patio**T**emporal **I**mportance **R**esampling for **D**irect **I**llumination, is a screen space light sampling technique used for illuminating primary surfaces during path tracing. It cheaply selects several lights from an initial distribution, such as a uniform or power-based one, then selects one light of that group based on a more expensive distribution, such as one including geometry, BRDF, and visibility terms, and uses that one for illumination. These samples are then resampled over time and across neighboring pixels to increase effective sample count.
 - ReGIR, short for Reservoir-based Grid Importance Sampling, is a world space light sampling technique that can be used for illuminating primary or subsequent surfaces. It samples lights from an initial distribution, such as a uniform or power-based one, for each grid cell. Other algorithms, such as ReSTIR DI and ReSTIR GI, can sample lights from this grid if the surface they are illuminating falls in a grid cell.
 - ReSTIR GI, short for **Re**servoir **S**patio**T**emporal **I**mportance **R**esampling for **G**lobal **I**llumination, is a screen space light sampling technique used for illuminating secondary surfaces during path tracing. ReSTIR GI requires an initial light sampling technique be implemented by the path tracer for the secondary surface. In the `full-sample` project, this method is the initial sampling pass from ReSTIR DI, although any technique may be used. This secondary surface sample is then resampled across other pixels in space and time.
+- ReSTIR PT, short for **Re**servoir **S**patio**T**emporal **I**mportance **R**esampling for **P**ath **T**racing, is a screen space path resampling technique used for illuminating secondary surfaces. ReSTIR PT requires an integration of the RTXDI_PathTracingContext into a path tracer that calculates indirect lighting starting from the primary hit.
 
 The algorithms in the SDK are implemented largely independent from one another, and the C++-side of each is centered around an accordingly named context class (`ReSTIRDIContext`, `ReGIRContext`, and `ReSTIRGIContext`). However, ReSTIR DI has a close integration of ReGIR for initial sampling. Likewise, the `full-sample` project uses ReSTIR DI's light sampling functions to illuminate secondary surfaces during multi-bounce path tracing.