RTXGI SDK

RTXGI SDK implements two state-of-the-art radiance caching techniques designed to replace traditional probe-based irradiance caching with a world-space radiance cache. This allows for real-time indirect illumination by sampling cached radiance when scene geometry is hit during path tracing. These techniques can be combined with a regular path tracing pipeline for primary rays, reducing costs by using cache lookups for indirect bounce evaluation.

Supported techniques:

• Neural Radiance Cache (NRC): An experimental AI-based approach that requires NVIDIA Tensor Cores.
• Spatially Hashed Radiance Cache (SHaRC): A technique supported on a wider range of hardware (any DXR GPU) without vendor-specific requirements, though it has certain limitations.

The repository is organized into the following directories:

The NRC library supports two memory management modes, controlled by globalSettings.enableGPUMemoryAllocation:

1. Internal Management (SDK-managed):

• Set globalSettings.enableGPUMemoryAllocation = true during initialization.
• The SDK manages all buffers.
• Use GetBuffers() to obtain handles/views to these buffers for use in path tracing or custom resolve passes.

2. Application-managed:

• Set globalSettings.enableGPUMemoryAllocation = false during initialization.
• The application is responsible for creating and managing buffers.
• During the Configure step, use GetBuffersAllocationInfo(const ContextSettings& contextSettings, BuffersAllocationInfo& outBuffersAllocationInfo) to determine the required element size, stride, and allowed view types.
• Pass these buffers to the Configure method.

Integrating NRC requires interacting with both the CPU and the GPU (shaders):

CPU-side API (NrcD3d12.h or NrcVk.h):

• Handles initialization and (re)configuration of the NRC context.
• Manages resource memory (app-managed vs. internally managed).
• Invokes neural network operations: creating query data and training the network.
• Invokes the Resolve pass (an internal compute pass) to resolve radiance at queried points.

Shader-side API (Nrc.hlsli, NrcHelpers.hlsli, NrcStructures.h):

• Used within the application's pathtracer to declare and write training and query data to NRC resources.

To ensure the application's path tracer is correctly writing to NRC buffers, use Nsight Graphics Frame Capture.

• Structured Memory Configuration: Use this feature in Nsight to inspect the contents of NRC buffers regardless of their packing. This is useful for verifying the data within buffers like NrcRadianceParameters.
• Limitation: Neural network calls are currently not available for inspection within Nsight Graphics Frame Debugging.

If using the Vulkan API, you must specify required extensions and features during device creation. Use the provided helper functions to retrieve the necessary strings:

uint32_t GetVulkanDeviceExtensions(char const* const*& outStringArray);
uint32_t GetVulkanInstanceExtensions(char const* const*& outStringArray);
uint32_t GetVulkanDeviceFeatures(char const* const*& outStringArray);

The following features must be available and enabled:

• VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME
• VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME
• VK_EXT_scalar_block_layout

// Example of retrieving required extensions/features
uint32_t deviceExtCount;
const char** deviceExts;
GetVulkanDeviceExtensions(deviceExts);
// Use deviceExts during vkCreateDevice...

To get up and running with the RTXGI SDK pathtracer sample (which demonstrates NRC and SHaRC integration in a unidirectional Monte Carlo path tracer), follow these steps:

1. Clone the repository: Clone the project recursively to your preferred location.
2. Configure with CMake: Use CMake GUI or the CLI to configure and generate the solution. Set the source directory to the repository root and the build directory to a new directory within the repository root.
3. Run the sample: Open the generated rtxgi2_samples.sln in the build directory and run the pathtracer project.

Note: To run the NVRHI Vulkan rendering backend version, use the -vk debug command line argument.

git clone --progress --recursive --branch main -v "https://github.com/NVIDIAGameWorks/RTXGI.git" "local-repo-path"

To ensure correct execution and resource cleanup, follow this lifecycle:

1. End of Frame: Once the command list is submitted, call EndFrame(ID3D12CommandQueue* cmdQueue). The command queue must be the same one used for all previous NRC command lists.
2. Shutdown: When the application closes:
   • Destroy all created contexts using Destroy(Context& context).
   • Call Shutdown() to shut down the NRC library.

// End of frame
EndFrame(cmdQueue);

// Application shutdown
Destroy(myContext);
Shutdown();