RavEngine
Loading...
Searching...
No Matches
NvFlowRayMarchUtils.h
1// Redistribution and use in source and binary forms, with or without
2// modification, are permitted provided that the following conditions
3// are met:
4// * Redistributions of source code must retain the above copyright
5// notice, this list of conditions and the following disclaimer.
6// * Redistributions in binary form must reproduce the above copyright
7// notice, this list of conditions and the following disclaimer in the
8// documentation and/or other materials provided with the distribution.
9// * Neither the name of NVIDIA CORPORATION nor the names of its
10// contributors may be used to endorse or promote products derived
11// from this software without specific prior written permission.
12//
13// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
14// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
17// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24//
25// Copyright (c) 2014-2022 NVIDIA Corporation. All rights reserved.
26
27#ifndef NV_FLOW_RAY_MARCH_UTILS_H
28#define NV_FLOW_RAY_MARCH_UTILS_H
29
30#if defined(__cplusplus)
31
32#include "NvFlowExt.h"
33#include "NvFlowRayMarchParams.h"
34#include "NvFlowMath.h"
35
36NV_FLOW_INLINE void NvFlowRayMarchLayerShaderParams_populate(
37 NvFlowRayMarchLayerShaderParams* dst,
38 NvFlowUint velocityLevelIdx,
39 NvFlowUint densityLevelIdx,
40 NvFlowUint layerParamIdx,
41 const NvFlowSparseParams* sparseParams,
42 const NvFlowRayMarchParams* rayMarchParams
43)
44{
45 const NvFlowSparseLevelParams* levelParamsVelocity = &sparseParams->levels[velocityLevelIdx];
46 const NvFlowSparseLevelParams* levelParamsDensity = &sparseParams->levels[densityLevelIdx];
47 const NvFlowSparseLayerParams* layerParams = &sparseParams->layers[layerParamIdx];
48
49 NvFlowFloat3 blockSizeWorld = layerParams->blockSizeWorld;
50 NvFlowFloat3 blockSizeWorldInv = layerParams->blockSizeWorldInv;
51 float minBlockSizeWorld = fminf(blockSizeWorld.x, fminf(blockSizeWorld.y, blockSizeWorld.z));
52 float maxBlockSizeWorld = fmaxf(blockSizeWorld.x, fmaxf(blockSizeWorld.y, blockSizeWorld.z));
53
54 NvFlowFloat3 cellSize = NvFlowFloat3{
55 blockSizeWorld.x / float(levelParamsDensity->blockDimLessOne.x + 1u),
56 blockSizeWorld.y / float(levelParamsDensity->blockDimLessOne.y + 1u),
57 blockSizeWorld.z / float(levelParamsDensity->blockDimLessOne.z + 1u)
58 };
59 NvFlowFloat3 cellSizeInv = { 1.f / cellSize.x, 1.f / cellSize.y, 1.f / cellSize.z };
60 float cellSizeMin = fminf(fminf(cellSize.x, cellSize.y), cellSize.z);
61
62 NvFlowFloat3 velocityCellSizeInv = NvFlowFloat3{
63 float(levelParamsVelocity->blockDimLessOne.x + 1u) / blockSizeWorld.x,
64 float(levelParamsVelocity->blockDimLessOne.y + 1u) / blockSizeWorld.y,
65 float(levelParamsVelocity->blockDimLessOne.z + 1u) / blockSizeWorld.z
66 };
67
68 float stepSize = rayMarchParams->stepSizeScale * cellSizeMin;
69 float stepSizeInv = 1.f / stepSize;
70
71 // normalize alphaScale based on stepSize
72 float alphaScale = 1.f - expf(-rayMarchParams->attenuation * stepSize);
73 float layerColormapV = (float(layerParamIdx) + 0.5f) / float(sparseParams->layerCount);
74
75 dst->blockSizeWorld = blockSizeWorld;
76 dst->minBlockSizeWorld = minBlockSizeWorld;
77 dst->blockSizeWorldInv = blockSizeWorldInv;
78 dst->maxBlockSizeWorld = maxBlockSizeWorld;
79 dst->cellSize = cellSize;
80 dst->stepSize = stepSize;
81 dst->cellSizeInv = cellSizeInv;
82 dst->stepSizeInv = stepSizeInv;
83 dst->locationMin = layerParams->locationMin;
84 dst->locationMax = layerParams->locationMax;
85 dst->worldMin.x = (layerParams->locationMin.x - 0.5f) * layerParams->blockSizeWorld.x;
86 dst->worldMin.y = (layerParams->locationMin.y - 0.5f) * layerParams->blockSizeWorld.y;
87 dst->worldMin.z = (layerParams->locationMin.z - 0.5f) * layerParams->blockSizeWorld.z;
88 dst->enableBlockWireframe = rayMarchParams->enableBlockWireframe;
89 dst->worldMax.x = (layerParams->locationMax.x + 0.5f) * layerParams->blockSizeWorld.x;
90 dst->worldMax.y = (layerParams->locationMax.y + 0.5f) * layerParams->blockSizeWorld.y;
91 dst->worldMax.z = (layerParams->locationMax.z + 0.5f) * layerParams->blockSizeWorld.z;
92 dst->enableRawMode = rayMarchParams->enableRawMode;
93
94 dst->velocityCellSizeInv = velocityCellSizeInv;
95 dst->deltaTime = layerParams->deltaTime;
96
97 dst->layer = layerParams->layer;
98 dst->layerColormapV = layerColormapV;
99 dst->alphaScale = alphaScale;
100 dst->colorScale = rayMarchParams->colorScale;
101
102 dst->shadowFactor = rayMarchParams->shadowFactor;
103 dst->pad1 = 0.f;
104 dst->pad2 = 0.f;
105 dst->pad3 = 0.f;
106
107 dst->cloud.densityMultiplier = rayMarchParams->cloud.densityMultiplier;
108 dst->cloud.enableCloudMode = rayMarchParams->cloud.enableCloudMode;
109 dst->cloud.pad1 = 0.f;
110 dst->cloud.pad2 = 0.f;
111 dst->cloud.ambientColor = rayMarchParams->cloud.ambientColor;
112 dst->cloud.ambientMultiplier = rayMarchParams->cloud.ambientMultiplier;
113 dst->cloud.volumeBaseColor = rayMarchParams->cloud.volumeBaseColor;
114 dst->cloud.volumeColorMultiplier = rayMarchParams->cloud.volumeColorMultiplier;
115 dst->cloud.sunDirection = rayMarchParams->cloud.sunDirection;
116 dst->cloud.shadowStepMultiplier = rayMarchParams->cloud.shadowStepMultiplier;
117 dst->cloud.attenuationMultiplier = rayMarchParams->cloud.attenuationMultiplier;
118 dst->cloud.numShadowSteps = rayMarchParams->cloud.numShadowSteps;
119}
120
121NV_FLOW_INLINE void NvFlowRayMarchIsosurfaceLayerShaderParams_populate(
122 NvFlowRayMarchIsosurfaceLayerShaderParams* dst,
123 NvFlowUint densityLevelIdx,
124 NvFlowUint layerParamIdx,
125 const NvFlowSparseParams* sparseParams,
126 const NvFlowRayMarchIsosurfaceParams* rayMarchParams
127)
128{
129 const NvFlowSparseLevelParams* levelParams = &sparseParams->levels[densityLevelIdx];
130 const NvFlowSparseLayerParams* layerParams = &sparseParams->layers[layerParamIdx];
131
132 NvFlowFloat3 blockSizeWorld = layerParams->blockSizeWorld;
133 NvFlowFloat3 blockSizeWorldInv = layerParams->blockSizeWorldInv;
134 float minBlockSizeWorld = fminf(blockSizeWorld.x, fminf(blockSizeWorld.y, blockSizeWorld.z));
135 float maxBlockSizeWorld = fmaxf(blockSizeWorld.x, fmaxf(blockSizeWorld.y, blockSizeWorld.z));
136
137 NvFlowFloat3 cellSize = NvFlowFloat3{
138 blockSizeWorld.x / float(levelParams->blockDimLessOne.x + 1u),
139 blockSizeWorld.y / float(levelParams->blockDimLessOne.y + 1u),
140 blockSizeWorld.z / float(levelParams->blockDimLessOne.z + 1u)
141 };
142 NvFlowFloat3 cellSizeInv = { 1.f / cellSize.x, 1.f / cellSize.y, 1.f / cellSize.z };
143 float cellSizeMin = fminf(fminf(cellSize.x, cellSize.y), cellSize.z);
144
145 float stepSize = rayMarchParams->stepSizeScale * cellSizeMin;
146 float stepSizeInv = 1.f / stepSize;
147
148 dst->blockSizeWorld = blockSizeWorld;
149 dst->minBlockSizeWorld = minBlockSizeWorld;
150 dst->blockSizeWorldInv = blockSizeWorldInv;
151 dst->maxBlockSizeWorld = maxBlockSizeWorld;
152 dst->cellSize = cellSize;
153 dst->stepSize = stepSize;
154 dst->cellSizeInv = cellSizeInv;
155 dst->stepSizeInv = stepSizeInv;
156 dst->locationMin = layerParams->locationMin;
157 dst->locationMax = layerParams->locationMax;
158 dst->worldMin.x = (layerParams->locationMin.x - 0.5f) * layerParams->blockSizeWorld.x;
159 dst->worldMin.y = (layerParams->locationMin.y - 0.5f) * layerParams->blockSizeWorld.y;
160 dst->worldMin.z = (layerParams->locationMin.z - 0.5f) * layerParams->blockSizeWorld.z;
161 dst->enableBlockWireframe = rayMarchParams->enableBlockWireframe;
162 dst->worldMax.x = (layerParams->locationMax.x + 0.5f) * layerParams->blockSizeWorld.x;
163 dst->worldMax.y = (layerParams->locationMax.y + 0.5f) * layerParams->blockSizeWorld.y;
164 dst->worldMax.z = (layerParams->locationMax.z + 0.5f) * layerParams->blockSizeWorld.z;
165 dst->visualizeNormals = rayMarchParams->visualizeNormals;
166
167 dst->layer = layerParams->layer;
168 dst->densityThreshold = rayMarchParams->densityThreshold;
169 dst->refractionMode = rayMarchParams->refractionMode;
170 dst->pad2 = 0u;
171
172 dst->fluidColor = rayMarchParams->fluidColor;
173 dst->fluidIoR = rayMarchParams->fluidIoR;
174 dst->fluidSpecularReflectance = rayMarchParams->fluidSpecularReflectance;
175 dst->fluidAbsorptionCoefficient = rayMarchParams->fluidAbsorptionCoefficient;
176 dst->fluidDiffuseReflectance = rayMarchParams->fluidDiffuseReflectance;
177 dst->pad3 = 0.f;
178 dst->fluidRadiance = rayMarchParams->fluidRadiance;
179 dst->pad4 = 0.f;
180}
181
182NV_FLOW_INLINE void NvFlowRayMarchShaderParams_populate(
183 NvFlowRayMarchShaderParams* dst,
184 NvFlowUint velocityLevelIdx,
185 NvFlowUint densityLevelIdx,
186 const NvFlowSparseParams* sparseParams,
187 const NvFlowFloat4x4* view,
188 const NvFlowFloat4x4* projection,
189 const NvFlowFloat4x4* projectionJittered,
190 NvFlowUint textureWidth,
191 NvFlowUint textureHeight,
192 NvFlowUint sceneDepthWidth,
193 NvFlowUint sceneDepthHeight,
194 float compositeColorScale
195)
196{
197 using namespace NvFlowMath;
198
199 NvFlowFloat4x4 projectionInv = matrixInverse(*projection);
200 NvFlowFloat4x4 projectionJitteredInv = matrixInverse(*projectionJittered);
201 NvFlowFloat4x4 viewInv = matrixInverse(*view);
202
203 FrustumRays frustumRays = {};
204 computeFrustumRays(&frustumRays, viewInv, projectionInv);
205
206 const NvFlowSparseLevelParams* levelParamsVelocity = &sparseParams->levels[velocityLevelIdx];
207 const NvFlowSparseLevelParams* levelParamsDensity = &sparseParams->levels[densityLevelIdx];
208
209 dst->levelParamsVelocity = *levelParamsVelocity;
210 dst->levelParamsDensity = *levelParamsDensity;
211
212 dst->projection = NvFlowMath::matrixTranspose(*projection);
213 dst->view = NvFlowMath::matrixTranspose(*view);
214 dst->projectionJitteredInv = NvFlowMath::matrixTranspose(projectionJitteredInv);
215 dst->viewInv = NvFlowMath::matrixTranspose(viewInv);
216
217 dst->rayDir00 = frustumRays.rayDir00;
218 dst->rayDir10 = frustumRays.rayDir10;
219 dst->rayDir01 = frustumRays.rayDir01;
220 dst->rayDir11 = frustumRays.rayDir11;
221
222 dst->rayOrigin00 = frustumRays.rayOrigin00;
223 dst->rayOrigin10 = frustumRays.rayOrigin10;
224 dst->rayOrigin01 = frustumRays.rayOrigin01;
225 dst->rayOrigin11 = frustumRays.rayOrigin11;
226
227 dst->width = float(textureWidth);
228 dst->height = float(textureHeight);
229 dst->widthInv = 1.f / float(textureWidth);
230 dst->heightInv = 1.f / float(textureHeight);
231
232 dst->depthWidth = float(sceneDepthWidth);
233 dst->depthHeight = float(sceneDepthHeight);
234 dst->depthWidthInv = 1.f / float(sceneDepthWidth);
235 dst->depthHeightInv = 1.f / float(sceneDepthHeight);
236
237 dst->numLayers = sparseParams->layerCount;
238 dst->maxWorldDistance = INFINITY;
239 dst->isReverseZ = frustumRays.isReverseZ;
240 dst->compositeColorScale = compositeColorScale;
241}
242
243NV_FLOW_INLINE void NvFlowSelfShadowLayerShaderParams_populate(
244 NvFlowSelfShadowLayerShaderParams* dst,
245 NvFlowUint coarseLevelIdx,
246 NvFlowUint fineLevelIdx,
247 NvFlowUint layerParamIdx,
248 const NvFlowSparseParams* sparseParams,
249 const NvFlowShadowParams* shadowParams
250)
251{
252 bool isCoarse = coarseLevelIdx != fineLevelIdx;
253
254 const NvFlowSparseLevelParams* coarseDensityLevelParams = &sparseParams->levels[coarseLevelIdx];
255 const NvFlowSparseLayerParams* layerParams = &sparseParams->layers[layerParamIdx];
256
257 int layer = layerParams->layer;
258 NvFlowFloat3 blockSizeWorld = layerParams->blockSizeWorld;
259 NvFlowFloat3 blockSizeWorldInv = layerParams->blockSizeWorldInv;
260 float minBlockSizeWorld = fminf(blockSizeWorld.x, fminf(blockSizeWorld.y, blockSizeWorld.z));
261 float maxBlockSizeWorld = fmaxf(blockSizeWorld.x, fmaxf(blockSizeWorld.y, blockSizeWorld.z));
262
263 NvFlowFloat3 cellSize = NvFlowFloat3{
264 blockSizeWorld.x / float(coarseDensityLevelParams->blockDimLessOne.x + 1u),
265 blockSizeWorld.y / float(coarseDensityLevelParams->blockDimLessOne.y + 1u),
266 blockSizeWorld.z / float(coarseDensityLevelParams->blockDimLessOne.z + 1u)
267 };
268 NvFlowFloat3 cellSizeInv = { 1.f / cellSize.x, 1.f / cellSize.y, 1.f / cellSize.z };
269 float cellSizeMin = fminf(fminf(cellSize.x, cellSize.y), cellSize.z);
270
271 float stepSize = shadowParams->stepSizeScale * cellSizeMin;
272 float stepSizeInv = 1.f / stepSize;
273 float stepOffset = shadowParams->stepOffsetScale * cellSizeMin;
274
275 // normalize alphaScale based on stepSize
276 float alphaScale = 1.f - expf(-shadowParams->attenuation * stepSize);
277 float layerColormapV = (float(layerParamIdx) + 0.5f) / float(sparseParams->layerCount);
278
279 dst->base.blockSizeWorld = blockSizeWorld;
280 dst->base.minBlockSizeWorld = minBlockSizeWorld;
281 dst->base.blockSizeWorldInv = blockSizeWorldInv;
282 dst->base.maxBlockSizeWorld = maxBlockSizeWorld;
283 dst->base.cellSize = cellSize;
284 dst->base.stepSize = stepSize;
285 dst->base.cellSizeInv = cellSizeInv;
286 dst->base.stepSizeInv = stepSizeInv;
287 dst->base.locationMin = layerParams->locationMin;
288 dst->base.locationMax = layerParams->locationMax;
289 dst->base.worldMin.x = (layerParams->locationMin.x - 0.5f) * layerParams->blockSizeWorld.x;
290 dst->base.worldMin.y = (layerParams->locationMin.y - 0.5f) * layerParams->blockSizeWorld.y;
291 dst->base.worldMin.z = (layerParams->locationMin.z - 0.5f) * layerParams->blockSizeWorld.z;
292 dst->base.enableBlockWireframe = NV_FLOW_FALSE;
293 dst->base.worldMax.x = (layerParams->locationMax.x + 0.5f) * layerParams->blockSizeWorld.x;
294 dst->base.worldMax.y = (layerParams->locationMax.y + 0.5f) * layerParams->blockSizeWorld.y;
295 dst->base.worldMax.z = (layerParams->locationMax.z + 0.5f) * layerParams->blockSizeWorld.z;
296 dst->base.enableRawMode = NV_FLOW_FALSE;
297
298 dst->base.velocityCellSizeInv = cellSizeInv;
299 dst->base.deltaTime = layerParams->deltaTime;
300
301 dst->base.layer = layer;
302 dst->base.layerColormapV = layerColormapV;
303 dst->base.alphaScale = alphaScale;
304 dst->base.colorScale = 1.f;
305
306 dst->base.shadowFactor = 0.f;
307 dst->base.pad1 = 0.f;
308 dst->base.pad2 = 0.f;
309 dst->base.pad3 = 0.f;
310
311 // Set cloud mode to default
312 dst->base.cloud.densityMultiplier = 0.5f;
313 dst->base.cloud.enableCloudMode = NV_FLOW_FALSE;
314 dst->base.cloud.pad1 = 0.f;
315 dst->base.cloud.pad2 = 0.f;
316 dst->base.cloud.ambientColor.x = 0.4f;
317 dst->base.cloud.ambientColor.y = 0.55f;
318 dst->base.cloud.ambientColor.z = 0.9f;
319 dst->base.cloud.ambientMultiplier = 1.f;
320 dst->base.cloud.volumeBaseColor.x = 1.1f;
321 dst->base.cloud.volumeBaseColor.y = 1.f;
322 dst->base.cloud.volumeBaseColor.z = 0.9f;
323 dst->base.cloud.volumeColorMultiplier = 1.f;
324 dst->base.cloud.sunDirection.x = 1.f;
325 dst->base.cloud.sunDirection.y = 1.f;
326 dst->base.cloud.sunDirection.z = 1.f;
327 dst->base.cloud.shadowStepMultiplier = 1.f;
328 dst->base.cloud.attenuationMultiplier.x = 1.f;
329 dst->base.cloud.attenuationMultiplier.y = 1.f;
330 dst->base.cloud.attenuationMultiplier.z = 1.f;
331 dst->base.cloud.numShadowSteps = 10u;
332
333 dst->minIntensity = shadowParams->minIntensity;
334 dst->numSteps = isCoarse ? (shadowParams->numSteps / 2u) : shadowParams->numSteps;
335 dst->isPointLight = shadowParams->isPointLight;
336 dst->stepOffset = stepOffset;
337
338 dst->lightDirection = shadowParams->lightDirection;
339 dst->enabled = shadowParams->enabled;
340 dst->lightPosition = shadowParams->lightPosition;
341 dst->pad3 = 0.f;
342}
343
344NV_FLOW_INLINE void NvFlowSelfShadowShaderParams_populate(
345 NvFlowSelfShadowShaderParams* dst,
346 NvFlowUint coarseLevelIdx,
347 NvFlowUint fineLevelIdx,
348 const NvFlowSparseParams* sparseParams,
349 NvFlowUint blockIdxOffset
350)
351{
352 dst->blockIdxOffset = blockIdxOffset;
353 dst->pad1 = 0u;
354 dst->pad2 = 0u;
355 dst->pad3 = 0u;
356 dst->coarseDensityTable = sparseParams->levels[coarseLevelIdx];
357 dst->densityTable = sparseParams->levels[fineLevelIdx];
358}
359
360#endif
361
362#endif
NvFlowMath::FrustumRays
Definition NvFlowMath.h:732
NvFlowRayMarchIsosurfaceLayerShaderParams
Definition NvFlowRayMarchParams.h:89
NvFlowRayMarchIsosurfaceParams
Definition NvFlowExt.h:2103
NvFlowRayMarchLayerShaderParams
Definition NvFlowRayMarchParams.h:53
NvFlowRayMarchParams
Definition NvFlowExt.h:2069
NvFlowRayMarchShaderParams
Definition NvFlowRayMarchParams.h:124
NvFlowSelfShadowLayerShaderParams
Definition NvFlowRayMarchParams.h:163
NvFlowSelfShadowShaderParams
Definition NvFlowRayMarchParams.h:179
NvFlowShadowParams
********************************* Shadow ***************************************
Definition NvFlowExt.h:1889
NvFlowSparseLayerParams
Definition NvFlowShaderTypes.h:155
NvFlowSparseLevelParams
Definition NvFlowShaderTypes.h:117
NvFlowSparseParams
Definition NvFlow.h:190