v1.3 release

.gitignore

@@ -4,12 +4,22 @@
 log.txt
 build/*
 dxc
+d3d
 samples/test-harness/data/gltf/*
 !samples/test-harness/data/gltf/cornell
+samples/test-harness/data/gltf/cornell/*.cache
 !samples/test-harness/data/gltf/furnace
+samples/test-harness/data/gltf/furnace/*.cache
 !samples/test-harness/data/gltf/multi-cornell
+samples/test-harness/data/gltf/multi-cornell/*.cache
 !samples/test-harness/data/gltf/sponza
+samples/test-harness/data/gltf/sponza/*.cache
+samples/test-harness/data/gltf/sponza/*.jpg
+samples/test-harness/data/gltf/sponza/*.png
+samples/test-harness/data/gltf/sponza/*.gltf
+samples/test-harness/data/gltf/sponza/*.bin
+samples/test-harness/data/gltf/sponza/Sponza.cache
 !samples/test-harness/data/gltf/tunnel
+samples/test-harness/data/gltf/tunnel/*.cache
 !samples/test-harness/data/gltf/two-rooms
-
-samples/test-harness/data/gltf/sponza/Sponza.cache
+samples/test-harness/data/gltf/two-rooms/*.cache

ChangeLog.md

@@ -1,5 +1,59 @@
 # RTXGI SDK Change Log
 
+## 1.3.0
+
+### SDK
+- **Dynamic Library**
+  - Adds support for building and using the SDK as a dynamic library (`*.dll`, `*.so`)
+  - Removes the use of std in SDK headers
+- **DDGIVolume Probe Counts** 
+  - Changes all GPU-side texture resources to ```Texture2DArrays``` (D3D12 and Vulkan)
+  - Increases the *theoretical* maximum number of probes per volume to ~33.5 million (128x2048x128)
+  - Increases the *practical* maximum probes per volume increases to 2,097,152 probes (with the default texel format settings)
+    - This is a 2x increase over the previous maximum of 1024x32x32 (1,048,576 probes) and is limited by API restrictions: a single D3D12/Vulkan resource cannot be larger than 4GB
+    - More importantly, this change enables a more flexible and (at times) less wasteful memory layout since monolithic 2D texture atlases are no longer used for ```DDGIVolume``` probe resources
+- **Bindless Resources**
+  - Adds support for [Shader Model 6.6 Dynamic Resources](https://microsoft.github.io/DirectX-Specs/d3d/HLSL_SM_6_6_DynamicResources.html) (aka Descriptor Heap bindless) in D3D12
+  - Reworks how bindless resource indices are specified for both Resource Array and Descriptor Heap style bindless implementations (D3D12 and Vulkan)
+- **Probe Border Updates, Probe Blending, and GPU Utilization**
+  - Moves probe border update work into the probe blending passes
+    - *This removes the need for separate border update compute passes*, simplifying SDK use while also providing a small performance benefit
+  - Adjusts probe blending thread group sizes to increase GPU utilization and enable **probe ray counts in factors of 64** to be stored in shared memory (no more ```unusual``` ray counts like 144, 288, etc).
+- **Vulkan Push Constants**
+  - Updates the Vulkan push constants implementation to be more flexible and customizable so you can tailor them to your application's setup
+- **Other Improvements and Fixes**
+  - Represents probe counts with 10 bits (instead of 8) in ```DDGIVolumeDescGPUPacked```
+  - Adds ```GetRayDispatchDimensions()``` to make probe ray tracing dispatches easier to setup
+  - Adds ```GetGPUMemoryUsedInBytes()``` to make ```DDGIVolume``` memory tracking easier
+  - Adds ```ValidatePackedData()``` to ensure correct functionality of the ```PackDDGIVolumeDescGPU()``` and ```UnpackDDGIVolumeDescGPU()``` functions, executes in Debug configurations as part of ```UploadDDGIVolumeConstants()```.
+  - Moves shader define validation code to separate files to make the main SDK shader code more friendly and readable
+  - Adds fix for ```EulerAnglesToRotationMatrixYXZ()``` not producing correct ```DDGIVolume``` rotations across all coordinate systems
+  - Adds ```ConvertEulerAngles()``` convenience function to convert euler angles to alternate coordinate systems
+
+### Test Harness
+
+- **Improvements**
+  - Adds support for RTXGI SDK ```v1.3.0``` features
+  - Reorganizes the (D3D12) global root signature / (Vulkan) pipeline layout to bindlessly index texture array resources
+  - Eliminates the visualization-specific descriptor heap - all descriptors are now part of the global descriptor heap
+  - Uses the D3D12 Agility SDK v1.606.3 to access Shader Model 6.6+ features
+  - Reworks shader compilation code to use latest DXC interfaces, explicitly links DXC
+  - Adds support for storing ```DDGIVolume``` texture array data to disk (for debug / regression)
+  - Sets the `COORDINATE_SYSTEM` define through CMake, based on the SDK's `RTXGI_COORDINATE_SYSTEM` define. The Test Harness and RTXGI SDK can no longer have mismatching coordinate systems.
+  - Scene graph node transforms are now converted to the selected coordinate system
+  - Test Harness converts all config file positions, directions, and rotations to the selected coordinate system
+    - All scene config files updated to specify right hand, y-up positions, directions, and rotations.
+  - Scene Cache
+    - Coordinate system of the scene geometry is now stored in the cache file
+    - Cache files with mismatching coordinate system are rejected and the cache file is rebuilt
+    - Cache files are built for binary (.glb) GLTF files too now
+- **Bug Fixes**
+  - Adds several fixes for issues with Vulkan timestamps
+  - Adds fix to properly compute bounding boxes, taking mesh instance transforms into account for the chosen coordinate system
+  - Adds fix so probe visualization spheres are not inside out in left handed coordinate systems
+
+
+
 ## 1.2.13
 
 ### SDK

README.md

@@ -1,12 +1,14 @@
 # RTX Global Illumination
 
-Version 1.2
+Version 1.3
 
 [Change Log](ChangeLog.md)
 
 ## Introduction
 
-**RTX G**lobal **I**llumination (RTXGI) is a collection of algorithms that leverage GPU ray tracing to provide scalable solutions for rendering real-time Global Illumination (GI). The goal of RTXGI is to provide optimized implementations of global lighting algorithms that are flexible enough to be useful in both real-time and pre-computed lighting scenarios. Focusing on scalability allows RTXGI to be an effective tool across a wide range of platforms with varying computational capabilities. Algorithm implementations provided here require graphics APIs and platforms with support for GPU ray tracing (e.g. Microsoft DirectX Raytracing or Vulkan Ray Tracing). That said, it is possible to use RTXGI's Dynamic Diffuse Global Illumination algorithm on development machines with GPU ray tracing support and then load pre-computed data at run-time on platforms without GPU ray tracing support.
+**RTX G**lobal **I**llumination (RTXGI) is a collection of algorithms that leverage GPU ray tracing to provide scalable solutions for rendering real-time Global Illumination (GI). The goal of RTXGI is to provide optimized implementations of global lighting algorithms that are flexible enough to be useful in both real-time and pre-computed lighting scenarios. Focusing on scalability allows RTXGI to be an effective tool across a wide range of platforms with varying computational capabilities.
+
+Algorithm implementations provided here require graphics APIs and platforms with support for GPU ray tracing (e.g. Microsoft DirectX Raytracing or Vulkan Ray Tracing). That said, it is possible to use RTXGI's Dynamic Diffuse Global Illumination algorithm on development machines with GPU ray tracing support, store the lighting data, and then load the (static) lighting data at run-time on platforms without GPU ray tracing support.
 
 For more information on RTXGI, see the [NVIDIA Developer Page](https://developer.nvidia.com/rtxgi).
 
@@ -18,21 +20,23 @@ This repository contains the RTXGI SDK, a sample application, the RTXGI Unreal E
 
 Although we aim for RTXGI to eventually provide a collection of global illumination algorithms, the current SDK provides one algorithm based on *Dynamic Diffuse Global Illumination (DDGI)*, [first described in this academic publication from NVIDIA Research](https://jcgt.org/published/0008/02/01/) along with collaborators at McGill University and the University of Montreal. Since DDGI is based on irradiance probes (the pre-computed variety are already commonly used in games), it is an ideal entry point for developers to bring the benefits of real-time ray tracing to their tools, technology, and applications without substantial performance penalties. Furthermore, the implementation here includes performance improvements and optimization techniques not available elsewhere.
 
-* [rtxgi-sdk](rtxgi-sdk) contains the SDK source code and shaders meant to be included in an application's build
-
-    * [rtxgi-sdk/include](rtxgi-sdk/include) contains the include files for host code and (some) shaders
+* [rtxgi-sdk](rtxgi-sdk) contains the SDK source code
 
-    * [rtxgi-sdk/src](rtxgi-sdk/src) contains the host source code and some useful utilities
+    * [rtxgi-sdk/include](rtxgi-sdk/include) contains the include files used by host code and some shaders
 
-    * [rtxgi-sdk/shaders](rtxgi-sdk/shaders) contains the HLSL shader code to be compiled with the [DirectX Shader Compiler (DXC)](https://github.com/microsoft/DirectXShaderCompiler)
+    * [rtxgi-sdk/src](rtxgi-sdk/src) contains the host source code and useful utilities
 
-* [samples](samples) contains sample applications that demonstrate the SDK's algorithms
+    * [rtxgi-sdk/shaders](rtxgi-sdk/shaders) contains the HLSL shader code to be compiled with the provided [DirectX Shader Compiler (DXC)](https://github.com/microsoft/DirectXShaderCompiler)
 
-* [ue4-plugin](ue4-plugin) contains the RTXGI Unreal Engine 4 plugin source code and documentation
+* [samples](samples) contains the Test Harness sample application that demonstrates and exercises the SDK's functionality
 
 * [thirdparty](thirdparty) contains third-party software used by the sample application(s)
 
-* **dxc** contains an appropriate recent version of the DirectX Shader Compiler for your platform (delivered by packman)
+* **d3d** contains a compatible recent version of the DirectX 12 Agility SDK to use when running on Windows (delivered by Packman)
+
+* **dxc** contains a compatible recent version of the DirectX Shader Compiler for your platform (delivered by Packman)
+
+* [ue4-plugin](ue4-plugin) contains the RTXGI Unreal Engine 4 plugin source code and documentation
 
 * [docs](docs) contains helpful guides and documentation
 
@@ -42,6 +46,7 @@ The RTXGI SDK and sample application(s) require the following hardware and softw
 
 ### Hardware
 * Any DXR capable GPU. NVIDIA DXR enabled GPUs are:
+    * RTX 4090, 4080
     * RTX 3090 Ti, 3090, 3080 Ti, 3080, 3070 Ti, 3070, 3060 Ti, 3060, 3050
     * Titan RTX
     * RTX 2080 Ti, 2080 SUPER, 2080, 2070 SUPER, 2070, 2060 SUPER, 2060
@@ -54,14 +59,14 @@ The RTXGI SDK and sample application(s) require the following hardware and softw
 * Windows 10 SDK version 10.0.17763 or higher
 * [Vulkan SDK 1.2.170]((https://vulkan.lunarg.com/sdk/home)) or higher
 * [CMake 3.10](https://cmake.org/download) or higher
-* [Visual Studio 2017 or 2019](https://visualstudio.microsoft.com/downloads/) or [Visual Studio Code](https://code.visualstudio.com/download)
-* Latest GPU drivers. NVIDIA drivers are [available here](http://www.nvidia.com/drivers)
+* [Visual Studio 2017, 2019, 2022](https://visualstudio.microsoft.com/downloads/) or [Visual Studio Code](https://code.visualstudio.com/download)
+* Latest GPU drivers. NVIDIA drivers are [available here.](http://www.nvidia.com/drivers)
 
 ### Software (Linux)
 * [Vulkan SDK 1.2.170]((https://vulkan.lunarg.com/sdk/home)) or higher
 * [CMake 3.10](https://cmake.org/download) or higher
 * [Visual Studio Code](https://code.visualstudio.com/download)
-* Latest GPU drivers. NVIDIA drivers are [available here](http://www.nvidia.com/drivers)
+* Latest GPU drivers. NVIDIA drivers are [available here.](http://www.nvidia.com/drivers)
 
 ## Getting Started