forked from NVIDIAGameWorks/RTXGI-DDGI
-
Notifications
You must be signed in to change notification settings - Fork 0
/
ProbeClassificationCS.hlsl
257 lines (199 loc) · 11.1 KB
/
ProbeClassificationCS.hlsl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
/*
* Copyright (c) 2019-2023, NVIDIA CORPORATION. All rights reserved.
*
* NVIDIA CORPORATION and its licensors retain all intellectual property
* and proprietary rights in and to this software, related documentation
* and any modifications thereto. Any use, reproduction, disclosure or
* distribution of this software and related documentation without an express
* license agreement from NVIDIA CORPORATION is strictly prohibited.
*/
// For example usage, see DDGI_[D3D12|VK].cpp::CompileDDGIVolumeShaders() function.
// -------- CONFIG FILE ---------------------------------------------------------------------------
#if RTXGI_DDGI_USE_SHADER_CONFIG_FILE
#include <DDGIShaderConfig.h>
#endif
// -------- DEFINE VALIDATION ---------------------------------------------------------------------
#include "include/validation/ProbeClassificationDefines.hlsl"
// -------- REGISTER DECLARATIONS -----------------------------------------------------------------
#if RTXGI_DDGI_SHADER_REFLECTION || defined(__spirv__)
// Don't declare registers when using reflection or cross-compiling to SPIRV
#define VOLUME_CONSTS_REG_DECL
#if RTXGI_DDGI_BINDLESS_RESOURCES
#define VOLUME_RESOURCES_REG_DECL
#define RWTEX2DARRAY_REG_DECL
#else
#define RAY_DATA_REG_DECL
#define PROBE_DATA_REG_DECL
#endif
#else
// Declare registers and spaces when using D3D *without* reflection
#define VOLUME_CONSTS_REG_DECL : register(VOLUME_CONSTS_REGISTER, VOLUME_CONSTS_SPACE)
#if RTXGI_DDGI_BINDLESS_RESOURCES
#if RTXGI_BINDLESS_TYPE == RTXGI_BINDLESS_TYPE_RESOURCE_ARRAYS
#define VOLUME_RESOURCES_REG_DECL : register(VOLUME_RESOURCES_REGISTER, VOLUME_RESOURCES_SPACE)
#define RWTEX2DARRAY_REG_DECL : register(RWTEX2DARRAY_REGISTER, RWTEX2DARRAY_SPACE)
#endif
#else
#define RAY_DATA_REG_DECL : register(RAY_DATA_REGISTER, RAY_DATA_SPACE)
#define PROBE_DATA_REG_DECL : register(PROBE_DATA_REGISTER, PROBE_DATA_SPACE)
#endif
#endif // RTXGI_DDGI_SHADER_REFLECTION || SPIRV
// -------- ROOT / PUSH CONSTANT DECLARATIONS -----------------------------------------------------
#include "include/ProbeCommon.hlsl"
#include "include/DDGIRootConstants.hlsl"
// -------- RESOURCE DECLARATIONS -----------------------------------------------------------------
#if RTXGI_DDGI_BINDLESS_RESOURCES
#if RTXGI_BINDLESS_TYPE == RTXGI_BINDLESS_TYPE_RESOURCE_ARRAYS
// DDGIVolume constants structured buffer
RTXGI_VK_BINDING(VOLUME_CONSTS_REGISTER, VOLUME_CONSTS_SPACE)
StructuredBuffer<DDGIVolumeDescGPUPacked> DDGIVolumes VOLUME_CONSTS_REG_DECL;
// DDGIVolume resource indices structured buffer
RTXGI_VK_BINDING(VOLUME_RESOURCES_REGISTER, VOLUME_RESOURCES_SPACE)
StructuredBuffer<DDGIVolumeResourceIndices> DDGIVolumeBindless VOLUME_RESOURCES_REG_DECL;
// DDGIVolume ray data, probe irradiance, probe distance, and probe data
RTXGI_VK_BINDING(RWTEX2DARRAY_REGISTER, RWTEX2DARRAY_SPACE)
RWTexture2DArray<float4> RWTex2DArray[] RWTEX2DARRAY_REG_DECL;
#endif
#else
// DDGIVolume constants structured buffer
RTXGI_VK_BINDING(VOLUME_CONSTS_REGISTER, VOLUME_CONSTS_SPACE)
StructuredBuffer<DDGIVolumeDescGPUPacked> DDGIVolumes VOLUME_CONSTS_REG_DECL;
// DDGIVolume ray data (radiance and hit distances)
RTXGI_VK_BINDING(RAY_DATA_REGISTER, RAY_DATA_SPACE)
RWTexture2DArray<float4> RayData RAY_DATA_REG_DECL;
// Probe data (world-space offsets and classification states)
RTXGI_VK_BINDING(PROBE_DATA_REGISTER, PROBE_DATA_SPACE)
RWTexture2DArray<float4> ProbeData PROBE_DATA_REG_DECL;
#endif // RTXGI_DDGI_BINDLESS_RESOURCES
[numthreads(32, 1, 1)]
void DDGIProbeClassificationCS(uint3 DispatchThreadID : SV_DispatchThreadID)
{
// Get the volume's index
uint volumeIndex = GetDDGIVolumeIndex();
// Compute the probe index for this thread
uint probeIndex = DispatchThreadID.x;
#if RTXGI_DDGI_BINDLESS_RESOURCES
#if RTXGI_BINDLESS_TYPE == RTXGI_BINDLESS_TYPE_DESCRIPTOR_HEAP
// Get the DDGIVolume constants structured buffer from the descriptor heap (SM6.6+ only)
StructuredBuffer<DDGIVolumeDescGPUPacked> DDGIVolumes = ResourceDescriptorHeap[GetDDGIVolumeConstantsIndex()];
#endif
#endif
// Get the volume's constants
DDGIVolumeDescGPU volume = UnpackDDGIVolumeDescGPU(DDGIVolumes[volumeIndex]);
// Early out: if this thread maps past the number of probes in the volume
int numProbes = (volume.probeCounts.x * volume.probeCounts.y * volume.probeCounts.z);
if (probeIndex >= numProbes) return;
#if RTXGI_DDGI_BINDLESS_RESOURCES
#if RTXGI_BINDLESS_TYPE == RTXGI_BINDLESS_TYPE_DESCRIPTOR_HEAP
// Get the volume's resource indices from the descriptor heap (SM6.6+ only)
StructuredBuffer<DDGIVolumeResourceIndices> DDGIVolumeBindless = ResourceDescriptorHeap[GetDDGIVolumeResourceIndicesIndex()];
DDGIVolumeResourceIndices resourceIndices = DDGIVolumeBindless[volumeIndex];
// Get the volume's ray data and probe data UAVs from the descriptor heap (SM6.6+ only)
RWTexture2DArray<float4> RayData = ResourceDescriptorHeap[resourceIndices.rayDataUAVIndex];
RWTexture2DArray<float4> ProbeData = ResourceDescriptorHeap[resourceIndices.probeDataUAVIndex];
#elif RTXGI_BINDLESS_TYPE == RTXGI_BINDLESS_TYPE_RESOURCE_ARRAYS
// Get the volume's resource indices
DDGIVolumeResourceIndices resourceIndices = DDGIVolumeBindless[volumeIndex];
// Get the volume's ray data and probe data UAVs
RWTexture2DArray<float4> RayData = RWTex2DArray[resourceIndices.rayDataUAVIndex];
RWTexture2DArray<float4> ProbeData = RWTex2DArray[resourceIndices.probeDataUAVIndex];
#endif
#endif
// Get the number of ray samples to inspect
int numRays = min(volume.probeNumRays, RTXGI_DDGI_NUM_FIXED_RAYS);
int rayIndex;
int backfaceCount = 0;
float hitDistances[RTXGI_DDGI_NUM_FIXED_RAYS];
// Load the hit distances and count the number of backface hits
for (rayIndex = 0; rayIndex < RTXGI_DDGI_NUM_FIXED_RAYS; rayIndex++)
{
// Get the coordinates for the probe ray in the RayData texture array
int3 rayDataTexCoords = DDGIGetRayDataTexelCoords(rayIndex, probeIndex, volume);
// Load the hit distance for the ray
hitDistances[rayIndex] = DDGILoadProbeRayDistance(RayData, rayDataTexCoords, volume);
// Increment the count if a backface is hit
backfaceCount += (hitDistances[rayIndex] < 0.f);
}
// Get the probe's texel coordinates in the Probe Data texture array
uint3 outputCoords = DDGIGetProbeTexelCoords(probeIndex, volume);
// Early out: number of backface hits has been exceeded. The probe is probably inside geometry.
if(((float)backfaceCount / (float)RTXGI_DDGI_NUM_FIXED_RAYS) > volume.probeFixedRayBackfaceThreshold)
{
ProbeData[outputCoords].w = RTXGI_DDGI_PROBE_STATE_INACTIVE;
return;
}
// Get the world space position of the probe
int3 probeCoords = DDGIGetProbeCoords(probeIndex, volume);
float3 probeWorldPosition = DDGIGetProbeWorldPosition(probeCoords, volume, ProbeData);
// Determine if there is nearby geometry in the probe's voxel.
// Iterate over the probe rays and compare ray hit distances with
// the distance(s) to the probe's voxel planes.
for (rayIndex = 0; rayIndex < RTXGI_DDGI_NUM_FIXED_RAYS; rayIndex++)
{
// Skip backface hits
if(hitDistances[rayIndex] < 0) continue;
// Get the direction of the "fixed" ray
float3 direction = DDGIGetProbeRayDirection(rayIndex, volume);
// Get the plane normals
float3 xNormal = float3(direction.x / max(abs(direction.x), 0.000001f), 0.f, 0.f);
float3 yNormal = float3(0.f, direction.y / max(abs(direction.y), 0.000001f), 0.f);
float3 zNormal = float3(0.f, 0.f, direction.z / max(abs(direction.z), 0.000001f));
// Get the relevant planes to intersect
float3 p0x = probeWorldPosition + (volume.probeSpacing.x * xNormal);
float3 p0y = probeWorldPosition + (volume.probeSpacing.y * yNormal);
float3 p0z = probeWorldPosition + (volume.probeSpacing.z * zNormal);
// Get the ray's intersection distance with each plane
float3 distances =
{
dot((p0x - probeWorldPosition), xNormal) / max(dot(direction, xNormal), 0.000001f),
dot((p0y - probeWorldPosition), yNormal) / max(dot(direction, yNormal), 0.000001f),
dot((p0z - probeWorldPosition), zNormal) / max(dot(direction, zNormal), 0.000001f)
};
// If the ray is parallel to the plane, it will never intersect
// Set the distance to a very large number for those planes
if (distances.x == 0.f) distances.x = 1e27f;
if (distances.y == 0.f) distances.y = 1e27f;
if (distances.z == 0.f) distances.z = 1e27f;
// Get the distance to the closest plane intersection
float maxDistance = min(distances.x, min(distances.y, distances.z));
// If the hit distance is less than the closest plane intersection, the probe should be active
if(hitDistances[rayIndex] <= maxDistance)
{
ProbeData[outputCoords].w = RTXGI_DDGI_PROBE_STATE_ACTIVE;
return;
}
}
ProbeData[outputCoords].w = RTXGI_DDGI_PROBE_STATE_INACTIVE;
}
[numthreads(32, 1, 1)]
void DDGIProbeClassificationResetCS(uint3 DispatchThreadID : SV_DispatchThreadID)
{
// Get the volume's index
uint volumeIndex = GetDDGIVolumeIndex();
#if RTXGI_DDGI_BINDLESS_RESOURCES
#if RTXGI_BINDLESS_TYPE == RTXGI_BINDLESS_TYPE_DESCRIPTOR_HEAP
// Get the DDGIVolume constants structured buffer from the descriptor heap (SM6.6+ only)
StructuredBuffer<DDGIVolumeDescGPUPacked> DDGIVolumes = ResourceDescriptorHeap[GetDDGIVolumeConstantsIndex()];
#endif
#endif
// Get the volume's constants
DDGIVolumeDescGPU volume = UnpackDDGIVolumeDescGPU(DDGIVolumes[volumeIndex]);
#if RTXGI_DDGI_BINDLESS_RESOURCES
#if RTXGI_BINDLESS_TYPE == RTXGI_BINDLESS_TYPE_DESCRIPTOR_HEAP
// Get the volume's resource indices from the descriptor heap (SM6.6+ only)
StructuredBuffer<DDGIVolumeResourceIndices> DDGIVolumeBindless = ResourceDescriptorHeap[GetDDGIVolumeResourceIndicesIndex()];
DDGIVolumeResourceIndices resourceIndices = DDGIVolumeBindless[volumeIndex];
// Get the volume's probe data texture array UAV
RWTexture2DArray<float4> ProbeData = ResourceDescriptorHeap[resourceIndices.probeDataUAVIndex];
#elif RTXGI_BINDLESS_TYPE == RTXGI_BINDLESS_TYPE_RESOURCE_ARRAYS
// Get the volume's resource indices
DDGIVolumeResourceIndices resourceIndices = DDGIVolumeBindless[volumeIndex];
// Get the volume's probe data texture array UAV
RWTexture2DArray<float4> ProbeData = RWTex2DArray[resourceIndices.probeDataUAVIndex];
#endif
#endif
// Get the probe's texel coordinates in the Probe Data texture
uint3 outputCoords = DDGIGetProbeTexelCoords(DispatchThreadID.x, volume);
// Set all probes to active
ProbeData[outputCoords].w = RTXGI_DDGI_PROBE_STATE_ACTIVE;
}