|
|
@@ -8,15 +8,35 @@
|
|
|
#include <AnKi/Shaders/Common.hlsl>
|
|
|
#include <AnKi/Shaders/Include/MiscRendererTypes.h>
|
|
|
|
|
|
-F32 computeClipmapFade(Clipmap clipmap, Vec3 cameraPos, Vec3 lookDir, Vec3 worldPos)
|
|
|
+/// Flags to fine tune the probe selection in sampleClipmapCommon
|
|
|
+enum SampleClipmapFlag : U32
|
|
|
{
|
|
|
- const Vec3 offset = normalize(lookDir) * kIndirectDiffuseClipmapForwardBias * (clipmap.m_index + 1);
|
|
|
- const Vec3 biasedCameraPos = cameraPos + offset;
|
|
|
+ kSampleClipmapFlagAccurateClipmapSelection = 1 << 0,
|
|
|
+ kSampleClipmapFlagBiasSamplePointTowardsCamera = 1 << 1,
|
|
|
+ kSampleClipmapFlagBiasSamplePointSurfaceNormal = 1 << 2,
|
|
|
+ kSampleClipmapFlagInvalidProbeRejection = 1 << 3,
|
|
|
+ kSampleClipmapFlagChebyshevOcclusion = 1 << 4,
|
|
|
+ kSampleClipmapFlagBackfacingProbeRejection = 1 << 5,
|
|
|
+ kSampleClipmapFlagUsePreviousFrame = 1 << 6,
|
|
|
+
|
|
|
+ kSampleClipmapFlagFullQuality = (1 << 5) - 1,
|
|
|
+ kSampleClipmapFlagNone = 0
|
|
|
+};
|
|
|
|
|
|
- const Vec3 probeSize = clipmap.m_size / clipmap.m_probeCounts;
|
|
|
- const Vec3 halfSize = clipmap.m_size * 0.5;
|
|
|
- const Vec3 aabbMin = biasedCameraPos - halfSize + probeSize;
|
|
|
- const Vec3 aabbMax = biasedCameraPos + halfSize - probeSize;
|
|
|
+F32 computeClipmapFade(IndirectDiffuseClipmapConstants consts, U32 clipmapIdx, Vec3 cameraPos, Vec3 worldPos, SampleClipmapFlag flags)
|
|
|
+{
|
|
|
+ Vec3 aabbMin;
|
|
|
+ Vec3 aabbMax;
|
|
|
+ if(flags & kSampleClipmapFlagUsePreviousFrame)
|
|
|
+ {
|
|
|
+ aabbMin = consts.m_previousFrameAabbMins[clipmapIdx].xyz;
|
|
|
+ aabbMax = consts.m_previousFrameAabbMins[clipmapIdx].xyz + consts.m_sizes[clipmapIdx].xyz;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ aabbMin = consts.m_aabbMins[clipmapIdx].xyz;
|
|
|
+ aabbMax = consts.m_aabbMins[clipmapIdx].xyz + consts.m_sizes[clipmapIdx].xyz;
|
|
|
+ }
|
|
|
|
|
|
const Vec3 distances = select(worldPos > cameraPos, aabbMax - cameraPos, cameraPos - aabbMin);
|
|
|
|
|
|
@@ -30,16 +50,29 @@ F32 computeClipmapFade(Clipmap clipmap, Vec3 cameraPos, Vec3 lookDir, Vec3 world
|
|
|
return fade;
|
|
|
}
|
|
|
|
|
|
-Bool insideClipmap(Clipmap clipmap, Vec3 worldPos)
|
|
|
+Bool insideClipmap(IndirectDiffuseClipmapConstants consts, U32 clipmapIdx, Vec3 worldPos, SampleClipmapFlag flags)
|
|
|
{
|
|
|
- return (all(worldPos < clipmap.m_aabbMin + clipmap.m_size) && all(worldPos > clipmap.m_aabbMin));
|
|
|
+ Vec3 aabbMin;
|
|
|
+ Vec3 aabbMax;
|
|
|
+ if(flags & kSampleClipmapFlagUsePreviousFrame)
|
|
|
+ {
|
|
|
+ aabbMin = consts.m_previousFrameAabbMins[clipmapIdx].xyz;
|
|
|
+ aabbMax = consts.m_previousFrameAabbMins[clipmapIdx].xyz + consts.m_sizes[clipmapIdx].xyz;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ aabbMin = consts.m_aabbMins[clipmapIdx].xyz;
|
|
|
+ aabbMax = consts.m_aabbMins[clipmapIdx].xyz + consts.m_sizes[clipmapIdx].xyz;
|
|
|
+ }
|
|
|
+
|
|
|
+ return (all(worldPos < aabbMax) && all(worldPos > aabbMin));
|
|
|
}
|
|
|
|
|
|
-U16 findClipmapOnPosition(Clipmap clipmaps[kIndirectDiffuseClipmapCount], Vec3 cameraPos, Vec3 lookDir, Vec3 worldPos, F32 randFactor)
|
|
|
+U16 findClipmapOnPosition(IndirectDiffuseClipmapConstants consts, Vec3 cameraPos, Vec3 worldPos, F32 randFactor, SampleClipmapFlag flags)
|
|
|
{
|
|
|
for(U32 i = 0; i < kIndirectDiffuseClipmapCount; ++i)
|
|
|
{
|
|
|
- const F32 fade = computeClipmapFade(clipmaps[i], cameraPos, lookDir, worldPos);
|
|
|
+ const F32 fade = computeClipmapFade(consts, i, cameraPos, worldPos, flags);
|
|
|
if(fade > randFactor)
|
|
|
{
|
|
|
return i;
|
|
|
@@ -49,11 +82,11 @@ U16 findClipmapOnPosition(Clipmap clipmaps[kIndirectDiffuseClipmapCount], Vec3 c
|
|
|
return kIndirectDiffuseClipmapCount;
|
|
|
}
|
|
|
|
|
|
-U16 findClipmapOnPositionCheap(Clipmap clipmaps[kIndirectDiffuseClipmapCount], Vec3 worldPos)
|
|
|
+U16 findClipmapOnPositionCheap(IndirectDiffuseClipmapConstants consts, Vec3 worldPos, SampleClipmapFlag flags)
|
|
|
{
|
|
|
for(U32 i = 0; i < kIndirectDiffuseClipmapCount; ++i)
|
|
|
{
|
|
|
- if(insideClipmap(clipmaps[i], worldPos))
|
|
|
+ if(insideClipmap(consts, i, worldPos, flags))
|
|
|
{
|
|
|
return i;
|
|
|
}
|
|
|
@@ -62,38 +95,60 @@ U16 findClipmapOnPositionCheap(Clipmap clipmaps[kIndirectDiffuseClipmapCount], V
|
|
|
return kIndirectDiffuseClipmapCount;
|
|
|
}
|
|
|
|
|
|
-struct SampleClipmapsConfig
|
|
|
-{
|
|
|
- Bool m_fastClipmapSelection;
|
|
|
- Bool m_biasSamplePoint;
|
|
|
- Bool m_doInvalidProbeRejection;
|
|
|
- Bool m_doChebyshevOcclusion;
|
|
|
- Bool m_primaryVolumesHaveOctMap;
|
|
|
- Bool m_normalRejection;
|
|
|
-};
|
|
|
-
|
|
|
struct SampleClipmapsArgs
|
|
|
{
|
|
|
+ SampleClipmapFlag m_flags;
|
|
|
+ U32 m_primaryVolume; // 0: Irradiance, 1: radiance, 2: avgIrradiance
|
|
|
+
|
|
|
F32 m_clipmapSelectionRandFactor;
|
|
|
Vec3 m_samplePoint;
|
|
|
Vec3 m_normal;
|
|
|
Vec3 m_cameraPos;
|
|
|
- Vec3 m_lookDir; // Only used when SampleClipmapsConfig::m_fastClipmapSelection is false
|
|
|
};
|
|
|
|
|
|
+Vec3 computeBiasedSamplePoint(Vec3 samplePoint, Vec3 normal, Vec3 cameraPos, SampleClipmapFlag flags, F32 bias)
|
|
|
+{
|
|
|
+ constexpr SampleClipmapFlag bothBiases = kSampleClipmapFlagBiasSamplePointTowardsCamera | kSampleClipmapFlagBiasSamplePointSurfaceNormal;
|
|
|
+
|
|
|
+ if(flags & bothBiases)
|
|
|
+ {
|
|
|
+ Vec3 biasDir = 0.0;
|
|
|
+ if(flags & kSampleClipmapFlagBiasSamplePointTowardsCamera)
|
|
|
+ {
|
|
|
+ biasDir = normalize(cameraPos - samplePoint);
|
|
|
+ }
|
|
|
+
|
|
|
+ if(flags & kSampleClipmapFlagBiasSamplePointSurfaceNormal)
|
|
|
+ {
|
|
|
+ biasDir += normal;
|
|
|
+ }
|
|
|
+
|
|
|
+ if((flags & bothBiases) == bothBiases)
|
|
|
+ {
|
|
|
+ // Normalize if both biases have been applied
|
|
|
+ biasDir = normalize(biasDir);
|
|
|
+ }
|
|
|
+
|
|
|
+ return samplePoint + biasDir * bias;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ return samplePoint;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
/// Find out the clipmap for a given sample point and sample the probes in the volumes.
|
|
|
-Vec3 sampleClipmapIrradianceCommon(SampleClipmapsConfig cfg, SampleClipmapsArgs args, Texture3D<Vec4> primaryVolumes[kIndirectDiffuseClipmapCount],
|
|
|
- Texture3D<Vec4> distanceMomentsVolumes[kIndirectDiffuseClipmapCount],
|
|
|
- Texture3D<Vec4> probeValidityVolumes[kIndirectDiffuseClipmapCount], SamplerState linearAnyRepeatSampler,
|
|
|
- Clipmap clipmaps[kIndirectDiffuseClipmapCount])
|
|
|
+Vec3 sampleClipmapCommon(SampleClipmapsArgs args, SamplerState linearAnyRepeatSampler, IndirectDiffuseClipmapConstants consts)
|
|
|
{
|
|
|
+ const SampleClipmapFlag flags = args.m_flags;
|
|
|
+
|
|
|
#if 1
|
|
|
- const U16 clipmapIdx = (cfg.m_fastClipmapSelection) ? findClipmapOnPositionCheap(clipmaps, args.m_samplePoint)
|
|
|
- : findClipmapOnPosition(clipmaps, args.m_cameraPos, args.m_lookDir, args.m_samplePoint,
|
|
|
- args.m_clipmapSelectionRandFactor);
|
|
|
+ const U16 clipmapIdx = (flags & kSampleClipmapFlagAccurateClipmapSelection)
|
|
|
+ ? findClipmapOnPosition(consts, args.m_cameraPos, args.m_samplePoint, args.m_clipmapSelectionRandFactor, flags)
|
|
|
+ : findClipmapOnPositionCheap(consts, args.m_samplePoint, flags);
|
|
|
#else
|
|
|
U16 clipmapIdx = 0;
|
|
|
- if(!insideClipmap(clipmaps[clipmapIdx], args.m_samplePoint))
|
|
|
+ if(!insideClipmap(consts, clipmapIdx, args.m_samplePoint))
|
|
|
{
|
|
|
clipmapIdx = 10;
|
|
|
}
|
|
|
@@ -123,36 +178,24 @@ Vec3 sampleClipmapIrradianceCommon(SampleClipmapsConfig cfg, SampleClipmapsArgs
|
|
|
return 0.0;
|
|
|
}
|
|
|
|
|
|
- const Clipmap clipmap = clipmaps[clipmapIdx];
|
|
|
- const Vec3 probeSize = clipmap.m_size / clipmap.m_probeCounts;
|
|
|
- const Vec3 fakeVolumeSize = clipmap.m_probeCounts; // Volume size without the octahedron
|
|
|
+ const Vec3 clipmapSize = consts.m_sizes[clipmapIdx].xyz;
|
|
|
+ const Vec3 probeCountsf = consts.m_probeCounts;
|
|
|
+ const IndirectDiffuseClipmapTextures textures = consts.m_textures[clipmapIdx];
|
|
|
|
|
|
- const Vec3 biasDir = normalize(args.m_cameraPos - args.m_samplePoint);
|
|
|
- const Vec3 biasedWorldPos = (cfg.m_biasSamplePoint) ? args.m_samplePoint + biasDir * probeSize * 0.2 : args.m_samplePoint;
|
|
|
+ const Vec3 probeSize = clipmapSize / probeCountsf;
|
|
|
+ const Vec3 fakeVolumeSize = probeCountsf; // Volume size without the octahedron
|
|
|
|
|
|
- F32 octahedronSize = 0.0;
|
|
|
- Vec3 realVolumeSize = 0.0;
|
|
|
- {
|
|
|
- primaryVolumes[0].GetDimensions(realVolumeSize.x, realVolumeSize.y, realVolumeSize.z);
|
|
|
+ const Vec3 biasedWorldPos = computeBiasedSamplePoint(args.m_samplePoint, args.m_normal, args.m_cameraPos, flags, min3(probeSize) * 0.2);
|
|
|
|
|
|
- if(cfg.m_primaryVolumesHaveOctMap)
|
|
|
- {
|
|
|
- octahedronSize = realVolumeSize.x / clipmap.m_probeCounts.x;
|
|
|
- octahedronSize -= 2.0; // The border
|
|
|
- }
|
|
|
- };
|
|
|
+ const Bool primaryVolumesHaveOctMap = args.m_primaryVolume != 2;
|
|
|
+ const F32 octahedronSize =
|
|
|
+ (primaryVolumesHaveOctMap) ? ((args.m_primaryVolume == 0) ? textures.m_irradianceOctMapSize : textures.m_radianceOctMapSize) : 1.0;
|
|
|
+ const Vec3 realVolumeSize = probeCountsf.xzy * Vec3(octahedronSize + 2.0, octahedronSize + 2.0, 1.0);
|
|
|
|
|
|
- F32 distMomentsOctSize = 0.0;
|
|
|
- Vec3 distMomentsRealVolumeSize = 0.0;
|
|
|
- if(cfg.m_doChebyshevOcclusion)
|
|
|
- {
|
|
|
- distanceMomentsVolumes[0].GetDimensions(distMomentsRealVolumeSize.x, distMomentsRealVolumeSize.y, distMomentsRealVolumeSize.z);
|
|
|
-
|
|
|
- distMomentsOctSize = distMomentsRealVolumeSize.x / clipmap.m_probeCounts.x;
|
|
|
- distMomentsOctSize -= 2.0; // The border
|
|
|
- }
|
|
|
+ const F32 distMomentsOctSize = textures.m_distanceMomentsOctMapSize;
|
|
|
+ const Vec3 distMomentsRealVolumeSize = probeCountsf.xzy * Vec3(distMomentsOctSize + 2.0, distMomentsOctSize + 2.0, 1.0);
|
|
|
|
|
|
- const Vec3 samplePointUvw = frac(biasedWorldPos / clipmap.m_size);
|
|
|
+ const Vec3 samplePointUvw = frac(biasedWorldPos / clipmapSize);
|
|
|
const Vec3 icoord = floor(samplePointUvw * fakeVolumeSize - 0.5);
|
|
|
const Vec3 fcoord = frac(samplePointUvw * fakeVolumeSize - 0.5);
|
|
|
|
|
|
@@ -169,23 +212,20 @@ Vec3 sampleClipmapIrradianceCommon(SampleClipmapsConfig cfg, SampleClipmapsArgs
|
|
|
coords = select(coords >= 0.0, coords, fakeVolumeSize + coords);
|
|
|
coords = select(coords < fakeVolumeSize, coords, coords - fakeVolumeSize);
|
|
|
|
|
|
- if(cfg.m_doInvalidProbeRejection)
|
|
|
+ if(flags & kSampleClipmapFlagInvalidProbeRejection)
|
|
|
{
|
|
|
- const Bool valid = TEX(probeValidityVolumes[NonUniformResourceIndex(clipmapIdx)], coords.xzy).x > 0.8;
|
|
|
+ const Bool valid = TEX(getBindlessTextureNonUniformIndex3DVec4(textures.m_probeValidityTexture), coords.xzy).x > 0.8;
|
|
|
if(!valid)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- // Reject probes outside the current clipmap. The accurate version doesn't need that because it fades between clipmaps.
|
|
|
+ // Reject probes outside the current clipmap
|
|
|
const Vec3 probePosition = firstProbePosition + xyz * probeSize;
|
|
|
- if(cfg.m_fastClipmapSelection)
|
|
|
+ if(!insideClipmap(consts, clipmapIdx, probePosition, flags))
|
|
|
{
|
|
|
- if(!insideClipmap(clipmap, probePosition))
|
|
|
- {
|
|
|
- continue;
|
|
|
- }
|
|
|
+ continue;
|
|
|
}
|
|
|
|
|
|
// Filtering weight
|
|
|
@@ -193,7 +233,7 @@ Vec3 sampleClipmapIrradianceCommon(SampleClipmapsConfig cfg, SampleClipmapsArgs
|
|
|
F32 w = w3.x * w3.y * w3.z;
|
|
|
|
|
|
// Normal weight
|
|
|
- if(cfg.m_normalRejection)
|
|
|
+ if(flags & kSampleClipmapFlagBackfacingProbeRejection)
|
|
|
{
|
|
|
const Vec3 dir = normalize(probePosition - args.m_samplePoint);
|
|
|
const F32 wNormal = (dot(dir, args.m_normal) + 1.0) * 0.5;
|
|
|
@@ -201,7 +241,7 @@ Vec3 sampleClipmapIrradianceCommon(SampleClipmapsConfig cfg, SampleClipmapsArgs
|
|
|
}
|
|
|
|
|
|
// Chebyshev occlusion
|
|
|
- if(cfg.m_doChebyshevOcclusion)
|
|
|
+ if(flags & kSampleClipmapFlagChebyshevOcclusion)
|
|
|
{
|
|
|
Vec3 uvw = coords.xzy;
|
|
|
uvw.xy *= distMomentsOctSize + 2.0;
|
|
|
@@ -209,7 +249,8 @@ Vec3 sampleClipmapIrradianceCommon(SampleClipmapsConfig cfg, SampleClipmapsArgs
|
|
|
uvw.xy += octahedronEncode(normalize(biasedWorldPos - probePosition)) * distMomentsOctSize;
|
|
|
uvw.z += 0.5;
|
|
|
uvw /= distMomentsRealVolumeSize;
|
|
|
- const Vec2 distMoments = distanceMomentsVolumes[NonUniformResourceIndex(clipmapIdx)].SampleLevel(linearAnyRepeatSampler, uvw, 0.0);
|
|
|
+ const Vec2 distMoments =
|
|
|
+ getBindlessTextureNonUniformIndex3DVec4(textures.m_distanceMomentsTexture).SampleLevel(linearAnyRepeatSampler, uvw, 0.0);
|
|
|
|
|
|
const F32 variance = abs(distMoments.x * distMoments.x - distMoments.y);
|
|
|
|
|
|
@@ -229,9 +270,22 @@ Vec3 sampleClipmapIrradianceCommon(SampleClipmapsConfig cfg, SampleClipmapsArgs
|
|
|
w *= chebyshevWeight;
|
|
|
}
|
|
|
|
|
|
- // Compute the actual coords
|
|
|
+ // Compute the actual coords and sample
|
|
|
+ U32 bindlessIndex;
|
|
|
+ switch(args.m_primaryVolume)
|
|
|
+ {
|
|
|
+ case 0:
|
|
|
+ bindlessIndex = textures.m_irradianceTexture;
|
|
|
+ break;
|
|
|
+ case 1:
|
|
|
+ bindlessIndex = textures.m_radianceTexture;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ bindlessIndex = textures.m_averageIrradianceTexture;
|
|
|
+ }
|
|
|
+
|
|
|
Vec3 v;
|
|
|
- if(cfg.m_primaryVolumesHaveOctMap)
|
|
|
+ if(primaryVolumesHaveOctMap)
|
|
|
{
|
|
|
Vec3 uvw = coords.xzy;
|
|
|
uvw.xy *= octahedronSize + 2.0;
|
|
|
@@ -240,11 +294,11 @@ Vec3 sampleClipmapIrradianceCommon(SampleClipmapsConfig cfg, SampleClipmapsArgs
|
|
|
uvw.z += 0.5;
|
|
|
uvw /= realVolumeSize;
|
|
|
|
|
|
- v = primaryVolumes[NonUniformResourceIndex(clipmapIdx)].SampleLevel(linearAnyRepeatSampler, uvw, 0.0);
|
|
|
+ v = getBindlessTextureNonUniformIndex3DVec4(bindlessIndex).SampleLevel(linearAnyRepeatSampler, uvw, 0.0);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
- v = TEX(primaryVolumes[NonUniformResourceIndex(clipmapIdx)], coords.xzy);
|
|
|
+ v = TEX(getBindlessTextureNonUniformIndex3DVec4(bindlessIndex), coords.xzy);
|
|
|
}
|
|
|
|
|
|
value += v * w;
|
|
|
@@ -263,94 +317,64 @@ Vec3 sampleClipmapIrradianceCommon(SampleClipmapsConfig cfg, SampleClipmapsArgs
|
|
|
return value;
|
|
|
}
|
|
|
|
|
|
-Vec3 sampleClipmapIrradianceAccurate(Vec3 samplePoint, Vec3 normal, Vec3 cameraPos, Vec3 lookDir, Clipmap clipmaps[kIndirectDiffuseClipmapCount],
|
|
|
- Texture3D<Vec4> primaryVolumes[kIndirectDiffuseClipmapCount],
|
|
|
- Texture3D<Vec4> distanceMomentsVolumes[kIndirectDiffuseClipmapCount],
|
|
|
- Texture3D<Vec4> probeValidityVolumes[kIndirectDiffuseClipmapCount], SamplerState linearAnyRepeatSampler,
|
|
|
- F32 randFactor, Bool biasSamplePoint = true)
|
|
|
+Vec3 sampleClipmapIrradiance(Vec3 samplePoint, Vec3 normal, Vec3 cameraPos, IndirectDiffuseClipmapConstants consts,
|
|
|
+ SamplerState linearAnyRepeatSampler, SampleClipmapFlag flags = kSampleClipmapFlagFullQuality, F32 randFactor = 0.5)
|
|
|
{
|
|
|
- SampleClipmapsConfig cfg;
|
|
|
- cfg.m_biasSamplePoint = biasSamplePoint;
|
|
|
- cfg.m_doChebyshevOcclusion = true;
|
|
|
- cfg.m_doInvalidProbeRejection = true;
|
|
|
- cfg.m_fastClipmapSelection = false;
|
|
|
- cfg.m_primaryVolumesHaveOctMap = true;
|
|
|
- cfg.m_normalRejection = true;
|
|
|
-
|
|
|
SampleClipmapsArgs args;
|
|
|
+ args.m_primaryVolume = 0;
|
|
|
+ args.m_flags = flags;
|
|
|
args.m_cameraPos = cameraPos;
|
|
|
args.m_clipmapSelectionRandFactor = randFactor;
|
|
|
- args.m_lookDir = lookDir;
|
|
|
args.m_normal = normal;
|
|
|
args.m_samplePoint = samplePoint;
|
|
|
|
|
|
- return sampleClipmapIrradianceCommon(cfg, args, primaryVolumes, distanceMomentsVolumes, probeValidityVolumes, linearAnyRepeatSampler, clipmaps);
|
|
|
+ return sampleClipmapCommon(args, linearAnyRepeatSampler, consts);
|
|
|
}
|
|
|
|
|
|
-Vec3 sampleClipmapIrradianceCheap(Vec3 samplePoint, Vec3 normal, Clipmap clipmaps[kIndirectDiffuseClipmapCount],
|
|
|
- Texture3D<Vec4> primaryVolumes[kIndirectDiffuseClipmapCount], SamplerState linearAnyRepeatSampler,
|
|
|
- Bool biasSamplePoint = true)
|
|
|
+Vec3 sampleClipmapAvgIrradianceCheap(Vec3 samplePoint, Vec3 cameraPos, IndirectDiffuseClipmapConstants consts, F32 randFactor,
|
|
|
+ SamplerState linearAnyRepeatSampler, SampleClipmapFlag flags)
|
|
|
{
|
|
|
- SampleClipmapsConfig cfg;
|
|
|
- cfg.m_biasSamplePoint = biasSamplePoint;
|
|
|
- cfg.m_doChebyshevOcclusion = false;
|
|
|
- cfg.m_doInvalidProbeRejection = false;
|
|
|
- cfg.m_fastClipmapSelection = true;
|
|
|
- cfg.m_primaryVolumesHaveOctMap = true;
|
|
|
- cfg.m_normalRejection = true;
|
|
|
+ const U16 clipmapIdx = (flags & kSampleClipmapFlagAccurateClipmapSelection)
|
|
|
+ ? findClipmapOnPosition(consts, cameraPos, samplePoint, randFactor, flags)
|
|
|
+ : findClipmapOnPositionCheap(consts, samplePoint, flags);
|
|
|
|
|
|
- SampleClipmapsArgs args;
|
|
|
- args.m_cameraPos = 0.0;
|
|
|
- args.m_clipmapSelectionRandFactor = 0.0;
|
|
|
- args.m_lookDir = 0.0;
|
|
|
- args.m_normal = normal;
|
|
|
- args.m_samplePoint = samplePoint;
|
|
|
+ if(clipmapIdx >= kIndirectDiffuseClipmapCount)
|
|
|
+ {
|
|
|
+ return 0.0;
|
|
|
+ }
|
|
|
|
|
|
- return sampleClipmapIrradianceCommon(cfg, args, primaryVolumes, primaryVolumes, primaryVolumes, linearAnyRepeatSampler, clipmaps);
|
|
|
-}
|
|
|
+ const Vec3 clipmapSize = consts.m_sizes[clipmapIdx].xyz;
|
|
|
+ const Vec3 probeCountsf = consts.m_probeCounts;
|
|
|
|
|
|
-Vec3 sampleClipmapAvgIrradianceAccurate(Vec3 samplePoint, Vec3 normal, Vec3 cameraPos, Vec3 lookDir, Clipmap clipmaps[kIndirectDiffuseClipmapCount],
|
|
|
- Texture3D<Vec4> primaryVolumes[kIndirectDiffuseClipmapCount],
|
|
|
- Texture3D<Vec4> distanceMomentsVolumes[kIndirectDiffuseClipmapCount],
|
|
|
- Texture3D<Vec4> probeValidityVolumes[kIndirectDiffuseClipmapCount], SamplerState linearAnyRepeatSampler,
|
|
|
- F32 randFactor, Bool biasSamplePoint = true, Bool normalRejection = true)
|
|
|
-{
|
|
|
- SampleClipmapsConfig cfg;
|
|
|
- cfg.m_biasSamplePoint = biasSamplePoint;
|
|
|
- cfg.m_doChebyshevOcclusion = true;
|
|
|
- cfg.m_doInvalidProbeRejection = true;
|
|
|
- cfg.m_fastClipmapSelection = false;
|
|
|
- cfg.m_primaryVolumesHaveOctMap = false;
|
|
|
- cfg.m_normalRejection = normalRejection;
|
|
|
+ const Vec3 probeSize = clipmapSize / probeCountsf;
|
|
|
+ const Vec3 biasedWorldPos = computeBiasedSamplePoint(samplePoint, 0.0, cameraPos, flags, min3(probeSize) * 0.2);
|
|
|
|
|
|
- SampleClipmapsArgs args;
|
|
|
- args.m_cameraPos = cameraPos;
|
|
|
- args.m_clipmapSelectionRandFactor = randFactor;
|
|
|
- args.m_lookDir = lookDir;
|
|
|
- args.m_normal = normal;
|
|
|
- args.m_samplePoint = samplePoint;
|
|
|
+ const Vec3 samplePointUvw = (biasedWorldPos / clipmapSize).xzy;
|
|
|
|
|
|
- return sampleClipmapIrradianceCommon(cfg, args, primaryVolumes, distanceMomentsVolumes, probeValidityVolumes, linearAnyRepeatSampler, clipmaps);
|
|
|
+ return getBindlessTextureNonUniformIndex3DVec4(consts.m_textures[clipmapIdx].m_averageIrradianceTexture)
|
|
|
+ .SampleLevel(linearAnyRepeatSampler, samplePointUvw, 0.0)
|
|
|
+ .xyz;
|
|
|
}
|
|
|
|
|
|
-Vec3 sampleClipmapAvgIrradianceCheap(Vec3 samplePoint, Vec3 cameraPos, Vec3 lookDir, Clipmap clipmaps[kIndirectDiffuseClipmapCount],
|
|
|
- Texture3D<Vec4> primaryVolumes[kIndirectDiffuseClipmapCount], F32 randFactor,
|
|
|
- SamplerState linearAnyRepeatSampler, Bool biasSamplePoint = true)
|
|
|
+Vec3 sampleClipmapAvgIrradiance(Vec3 samplePoint, Vec3 normal, Vec3 cameraPos, IndirectDiffuseClipmapConstants consts,
|
|
|
+ SamplerState linearAnyRepeatSampler, SampleClipmapFlag flags = kSampleClipmapFlagFullQuality, F32 randFactor = 0.5)
|
|
|
{
|
|
|
- const U16 clipmapIdx = findClipmapOnPosition(clipmaps, cameraPos, lookDir, samplePoint, randFactor);
|
|
|
-
|
|
|
- if(clipmapIdx >= kIndirectDiffuseClipmapCount)
|
|
|
+ const SampleClipmapFlag requireManualTrilinearFiltering =
|
|
|
+ kSampleClipmapFlagInvalidProbeRejection | kSampleClipmapFlagBackfacingProbeRejection | kSampleClipmapFlagChebyshevOcclusion;
|
|
|
+ if(flags & requireManualTrilinearFiltering)
|
|
|
{
|
|
|
- return 0.0;
|
|
|
+ SampleClipmapsArgs args;
|
|
|
+ args.m_primaryVolume = 2;
|
|
|
+ args.m_flags = flags;
|
|
|
+ args.m_cameraPos = cameraPos;
|
|
|
+ args.m_clipmapSelectionRandFactor = randFactor;
|
|
|
+ args.m_normal = normal;
|
|
|
+ args.m_samplePoint = samplePoint;
|
|
|
+
|
|
|
+ return sampleClipmapCommon(args, linearAnyRepeatSampler, consts);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ return sampleClipmapAvgIrradianceCheap(samplePoint, cameraPos, consts, randFactor, linearAnyRepeatSampler, flags);
|
|
|
}
|
|
|
-
|
|
|
- const Clipmap clipmap = clipmaps[clipmapIdx];
|
|
|
- const Vec3 probeSize = clipmap.m_size / clipmap.m_probeCounts;
|
|
|
-
|
|
|
- const Vec3 biasDir = normalize(cameraPos - samplePoint);
|
|
|
- const Vec3 biasedWorldPos = (biasSamplePoint) ? samplePoint + biasDir * probeSize * 0.2 : samplePoint;
|
|
|
-
|
|
|
- const Vec3 samplePointUvw = (biasedWorldPos / clipmap.m_size).xzy;
|
|
|
-
|
|
|
- return primaryVolumes[NonUniformResourceIndex(clipmapIdx)].SampleLevel(linearAnyRepeatSampler, samplePointUvw, 0.0).xyz;
|
|
|
}
|
Panagiotis Christopoulos Charitos