Sync with "simplex"

Author: dzhdanNV

3-Run NRD sample.bat 3-Run.bat3-Run NRD sample.bat renamed to 3-Run.bat

@@ -110,6 +110,7 @@ echo 1 - Bistro (interior)
 echo 2 - Bistro (exterior)
 echo 3 - Shader balls
 echo 4 - Kitchen
+echo 5 - Claire
 :CHOOSE_SCENE
     set /P M=Choose scene [1-4]:
     if %M%==1 (
@@ -128,6 +129,10 @@ echo 4 - Kitchen
         set SCENE=Kitchen\Kitchen.gltf
         goto RUN
     )
+    if %M%==5 (
+        set SCENE=Claire\Claire.gltf
+        goto RUN
+    )
     goto CHOOSE_SCENE
 
 :RUN

External/NRD

@@ -25,7 +25,6 @@ NRI_FORMAT("unknown") NRI_RESOURCE( RWTexture2D<float4>, gOut_ComposedSpec_ViewZ
 void main( int2 pixelPos : SV_DispatchThreadId )
 {
     float2 pixelUv = float2( pixelPos + 0.5 ) * gInvRectSize;
-    float2 sampleUv = pixelUv + gJitter;
 
     // Do not generate NANs for unused threads
     if( pixelUv.x > 1.0 || pixelUv.y > 1.0 )
@@ -72,7 +71,7 @@ void main( int2 pixelPos : SV_DispatchThreadId )
     float4 baseColorMetalness = gIn_BaseColor_Metalness[ pixelPos ];
     BRDF::ConvertBaseColorMetalnessToAlbedoRf0( baseColorMetalness.xyz, baseColorMetalness.w, albedo, Rf0 );
 
-    float3 Xv = Geometry::ReconstructViewPosition( sampleUv, gCameraFrustum, viewZ, gOrthoMode );
+    float3 Xv = Geometry::ReconstructViewPosition( pixelUv, gCameraFrustum, viewZ, gOrthoMode );
     float3 V = gOrthoMode == 0 ? normalize( Geometry::RotateVector( gViewToWorld, 0 - Xv ) ) : gViewDirection.xyz;
 
     // Sample NRD outputs
@@ -97,11 +96,8 @@ void main( int2 pixelPos : SV_DispatchThreadId )
 
         if( gResolve && pixelUv.x >= gSeparator )
         {
-            // ( Optional ) replace "roughness" with "roughnessAA"
-            roughness = NRD_SG_ExtractRoughnessAA( specSg );
-
             // Regain macro-details
-            diff.xyz = NRD_SG_ResolveDiffuse( diffSg, N ); // or NRD_SH_ResolveDiffuse( diffSg, N )
+            diff.xyz = NRD_SG_ResolveDiffuse( diffSg, N, V, roughness ); // or NRD_SH_ResolveDiffuse( diffSg, N )
             spec.xyz = NRD_SG_ResolveSpecular( specSg, N, V, roughness );
 
             // Regain micro-details & jittering // TODO: preload N and Z into SMEM
@@ -115,7 +111,7 @@ void main( int2 pixelPos : SV_DispatchThreadId )
             float Zn = gIn_ViewZ[ pixelPos + int2(  0,  1 ) ];
             float Zs = gIn_ViewZ[ pixelPos + int2(  0, -1 ) ];
 
-            float2 scale = NRD_SG_ReJitter( diffSg, specSg, Rf0, V, roughness, viewZ, Ze, Zw, Zn, Zs, N, Ne, Nw, Nn, Ns );
+            float2 scale = NRD_SG_ReJitter( diffSg, specSg, V, roughness, viewZ, Ze, Zw, Zn, Zs, N, Ne, Nw, Nn, Ns );
 
             diff.xyz *= scale.x;
             spec.xyz *= scale.y;

External/NRIFramework

@@ -0,0 +1,100 @@
+// © 2024 NVIDIA Corporation
+
+#include "Include/Shared.hlsli"
+
+struct PushConstants
+{
+    int step;
+};
+
+NRI_ROOT_CONSTANTS( PushConstants, g_PushConstants, 1, SET_ROOT );
+
+// Inputs
+NRI_RESOURCE( Texture2D<float4>, gIn_Gradient, t, 0, SET_OTHER );
+
+// Outputs
+NRI_FORMAT("unknown") NRI_RESOURCE( RWTexture2D<float4>, gOut_Gradient, u, 0, SET_OTHER );
+
+float2 GetGeometryWeightParams( float3 Nv, float3 Xv )
+{
+    const float planeDistSensitivity = 0.02;
+
+    float frustumSize = gRectSize.x * gUnproject * lerp( abs( Xv.z ), 1.0, abs( gOrthoMode ) );
+    float norm = planeDistSensitivity * frustumSize;
+    float a = 1.0 / norm;
+    float b = dot( Nv, Xv ) * a;
+
+    return float2( a, -b );
+}
+
+#define ComputeNonExponentialWeight( x, px, py ) \
+    Math::SmoothStep( 1.0, 0.0, abs( ( x ) * px + py ) )
+
+[numthreads( 16, 16, 1 )]
+void main( uint2 pixelPos : SV_DispatchThreadId )
+{
+    float2 pixelUv = ( pixelPos + 0.5 ) * gInvSharcRenderSize;
+
+    float4 data0 = gIn_Gradient[ pixelPos ];
+    float z0 = data0.w / FP16_VIEWZ_SCALE;
+    bool isLastPass = g_PushConstants.step == 5;
+
+    if( abs( z0 ) > INF )
+    {
+        gOut_Gradient[ pixelPos ] = float4( isLastPass, data0.yzw );
+        return;
+    }
+
+    float3 Xv0 = Geometry::ReconstructViewPosition( pixelUv, gCameraFrustum, z0, gOrthoMode );
+    float3 Nv0 = Packing::DecodeUnitVector( data0.yz );
+    float2 geometryWeightParams = GetGeometryWeightParams( Nv0, Xv0 );
+    float gradient = data0.x;
+    float sum = 1.0;
+
+    [unroll]
+    for( int i = -2; i <= 2; i++ )
+    {
+        [unroll]
+        for( int j = -2; j <= 2; j++ )
+        {
+            if( i == 0 && j == 0 )
+                continue;
+
+            int2 pos = pixelPos + int2( i, j ) * g_PushConstants.step;
+            float2 uv = ( pos + 0.5 ) * gInvSharcRenderSize;
+
+            float4 data = gIn_Gradient.SampleLevel( gNearestClamp, uv, 0 );
+
+            // Gaussian weight
+            float d = length( int2( i, j ) ) / 2.0;
+            float w = exp( -2.0 * d * d );
+
+            // Plane distance weight
+            float z = data.w / FP16_VIEWZ_SCALE;
+            float3 Xv = Geometry::ReconstructViewPosition( uv, gCameraFrustum, z, gOrthoMode );
+            float NoX = dot( Nv0, Xv );
+            w *= ComputeNonExponentialWeight( NoX, geometryWeightParams.x, geometryWeightParams.y );
+
+            // Normal weight
+            float3 Nv = Packing::DecodeUnitVector( data.yz );
+            float NoN = saturate( dot( Nv0, Nv ) );
+            w *= NoN * NoN;
+
+            // Accumulate
+            gradient += data.x * w;
+            sum += w;
+        }
+    }
+
+    gradient /= sum;
+
+    if( isLastPass )
+    {
+        // Last pass converts "gradient" to "history confidence"
+        gradient = Color::HdrToLinear_Uncharted( gradient * gExposure ).x; // or normalize to the blurred final image or SHARC cache
+        gradient *= 1.0 - ( Sequence::Bayer4x4( pixelPos, gFrameIndex ) - 0.5 ) * 1.0; // optional dithering
+        gradient = 1.0 - Color::ToSrgb( saturate( gradient ) ).x;
+    }
+
+    gOut_Gradient[ pixelPos ] = float4( gradient, data0.yzw );
+}

Shaders/Composition.cs.hlsl

@@ -50,7 +50,7 @@ void main( uint2 pixelPos : SV_DispatchThreadId )
         float NoV = abs( dot( N, V ) );
         float3 Fenv = gIndirectSpecular * BRDF::EnvironmentTerm_Rtg( Rf0, NoV, roughness );
 
-        float scaleHitDistance = gDenoiserType == DENOISER_RELAX ? 1.0 : _REBLUR_GetHitDistanceNormalization( viewZ, gHitDistParams, roughness );
+        float scaleHitDistance = gDenoiserType == DENOISER_RELAX ? 1.0 : _REBLUR_GetHitDistanceNormalization( viewZ, gHitDistSettings, roughness );
         float specHitDistance = gIn_Spec[ pixelPos ].w * scaleHitDistance;
 
         bool isSky = abs( viewZ ) == INF;

Shaders/ConfidenceBlur.cs.hlsl

@@ -18,7 +18,7 @@ void main( uint2 pixelPos : SV_DispatchThreadId )
         return;
 
     // Noisy input
-    float3 input = gIn_PreAA.SampleLevel( gNearestSampler, pixelUv * gRectSize * gInvRenderSize, 0 ).xyz;
+    float3 input = gIn_PreAA.SampleLevel( gNearestClamp, pixelUv * gRectSize * gInvRenderSize, 0 ).xyz;
 
     input = ApplyTonemap( input );
     if( gIsSrgb )
@@ -47,7 +47,7 @@ void main( uint2 pixelPos : SV_DispatchThreadId )
     // Validation layer
     if( gValidation )
     {
-        float4 validation = gIn_Validation.SampleLevel( gNearestSampler, pixelUv, 0 );
+        float4 validation = gIn_Validation.SampleLevel( gNearestClamp, pixelUv, 0 );
         result = lerp( result, validation.xyz, validation.w );
     }
 

Shaders/DlssBefore.cs.hlsl

@@ -448,11 +448,13 @@ MaterialProps GetMaterialProps( GeometryProps geometryProps )
     float3 N = gUseNormalMap ? Geometry::TransformLocalNormal( packedNormal, geometryProps.T, geometryProps.N ) : geometryProps.N;
     float3 T = geometryProps.T.xyz;
 
+    float3 Nlocal = Geometry::UnpackLocalNormal( packedNormal );
+    Nlocal.xy *= float( gUseNormalMap );
+
     // Estimate curvature
     float viewZ = Geometry::AffineTransform( gWorldToView, geometryProps.X ).z;
     float pixelSize = gUnproject * lerp( abs( viewZ ), 1.0, abs( gOrthoMode ) );
-    float localCurvature = length( Geometry::UnpackLocalNormal( packedNormal ).xy ) * float( gUseNormalMap );
-    localCurvature /= pixelSize;
+    float localCurvature = length( Nlocal.xy ) / pixelSize;
 
     // Emission
     coords = GetSamplingCoords( baseTexture + 3, geometryProps.uv, geometryProps.mip, MIP_VISIBILITY );
@@ -464,10 +466,12 @@ MaterialProps GetMaterialProps( GeometryProps geometryProps )
     if( geometryProps.Has( FLAG_FORCED_EMISSION ) )
     {
         Lemi = geometryProps.GetForcedEmissionColor( );
+        Lemi *= gEmissionIntensityCubes;
+
         baseColor = 0.0;
     }
-
-    Lemi *= gEmissionIntensity;
+    else
+        Lemi *= gEmissionIntensityLights;
 
     // Material overrides
     [flatten]
@@ -511,6 +515,9 @@ MaterialProps GetMaterialProps( GeometryProps geometryProps )
     metalness = lerp( metalness, 0.0, emissionLevel );
     roughness = lerp( roughness, 1.0, emissionLevel );
 
+    // TODO: roughness AA
+
+    // Output
     props.Lemi = Lemi;
     props.N = N;
     props.T = T;
@@ -519,6 +526,10 @@ MaterialProps GetMaterialProps( GeometryProps geometryProps )
     props.metalness = metalness;
     props.curvature = geometryProps.curvature + localCurvature;
 
+#if USE_WHITE_FURNACE
+    props.baseColor = 1.0;
+#endif
+
     return props;
 }
 
@@ -527,7 +538,7 @@ MaterialProps GetMaterialProps( GeometryProps geometryProps )
 #define SHADOW      0x02
 #define SSS         0x04
 
-float3 GetLighting( GeometryProps geometryProps, MaterialProps materialProps, uint flags, out float3 Xshadow )
+float3 GetLighting( GeometryProps geometryProps, MaterialProps materialProps, compiletime uint flags, out float3 Xshadow )
 {
     float3 lighting = 0.0;
 
@@ -730,6 +741,7 @@ float3 GenerateRayAndUpdateThroughput( inout GeometryProps geometryProps, inout
             emissiveHitNum++;
 
         // Save either the first ray or the last ray hitting an emissive
+        // TODO: the selection should be probabilistic and based on the intensity percentage across all hit candidates, currently emission intensity is uniform, so all candidates are equally "good"
         if( isEmissiveHit || sampleIndex == 0 )
             rayLocal = candidateRayLocal;
 
@@ -900,7 +912,7 @@ float ReprojectIrradiance( bool isPrevFrame, bool isRefraction, Texture2D<float3
     float2 uv = Geometry::GetScreenUv( isPrevFrame ? gWorldToClipPrev : gWorldToClip, geometryProps.X, true ) - gJitter;
 
     float2 rescale = ( isPrevFrame ? gRectSizePrev : gRectSize ) * gInvRenderSize;
-    float4 data = texSpecViewZ.SampleLevel( gNearestSampler, uv * rescale, 0 );
+    float4 data = texSpecViewZ.SampleLevel( gNearestClamp, uv * rescale, 0 );
     float prevViewZ = abs( data.w ) / FP16_VIEWZ_SCALE;
 
     // Initial state
@@ -950,7 +962,7 @@ float ReprojectIrradiance( bool isPrevFrame, bool isRefraction, Texture2D<float3
         weight *= gPrevFrameConfidence; // see C++ code for details
 
     // Read data
-    Ldiff = texDiff.SampleLevel( gNearestSampler, uv * rescale, 0 );
+    Ldiff = texDiff.SampleLevel( gNearestClamp, uv * rescale, 0 );
     Lspec = data.xyz;
 
     // Avoid NANs

Shaders/Final.cs.hlsl

@@ -21,6 +21,7 @@
 #define USE_SHARC_DITHERING                 1
 #define USE_TRANSLUCENCY                    1 // translucent foliage
 #define USE_MOVING_EMISSION_FIX             1 // fixes a dark tail, left by an animated emissive object
+#define USE_IS_FOR_ALL_BOUNCES              1 // slower, but better lighting for 2nd+ bounces
 
 // Default = 0
 #define USE_SANITIZATION                    0 // NRD sample is NAN/INF free
@@ -36,6 +37,8 @@
 #define USE_SHARC_DEBUG                     0 // 1 - show cache, 2 - show grid (NRD sample recompile required)
 #define USE_TAA_DEBUG                       0 // 1 - show weight
 #define USE_BIAS_FIX                        0 // fixes negligible hair and specular bias
+#define USE_AO_FOR_LAST_BOUNCE              0 // apply a simple AO estimation to SHARC data for the last bounce
+#define USE_WHITE_FURNACE                   0 // energy conservation test
 #define USE_CAMERA_ATTACHED_REFLECTION_TEST 0 // test special treatment for reflections of objects attached to the camera
 #define USE_RUSSIAN_ROULETTE                0 // bad practice for real-time denoising
 
@@ -125,14 +128,15 @@
 #define SHARC_MATERIAL_DEMODULATION         1
 #define SHARC_USE_FP16                      0
 #define SHARC_RADIANCE_SCALE                100.0 // matches max emission intensity range ( must be > SUN_INTENSITY )
+#define SHARC_RESAMPLING_DEPTH_MIN          1
 
 // Blue noise
 #define BLUE_NOISE_SPATIAL_DIM              128 // see StaticTexture::ScramblingRanking
 #define BLUE_NOISE_TEMPORAL_DIM             4 // good values: 4-8 for shadows, 8-16 for occlusion, 8-32 for lighting
 
 // Other
 #define FP16_MAX                            65504.0
-#define INF                                 1e5
+#define INF                                 1e5 // IMPORTANT: INF * FP16_VIEWZ_SCALE < FP16_MAX!
 #define LINEAR_BLOCK_SIZE                   256
 #define FP16_VIEWZ_SCALE                    0.125 // TODO: tuned for meters, needs to be scaled down for cm and mm
 #define MAX_MIP_LEVEL                       11.0
@@ -238,10 +242,11 @@ NRI_RESOURCE( cbuffer, GlobalConstants, b, 0, SET_ROOT )
     float4x4 gViewToWorld;
     float4x4 gViewToClip;
     float4x4 gWorldToView;
-    float4x4 gWorldToViewPrev;
     float4x4 gWorldToClip;
+    float4x4 gWorldToViewPrev;
     float4x4 gWorldToClipPrev;
-    float4 gHitDistParams;
+    float4x4 gViewToWorldPrev;
+    float4 gHitDistSettings;
     float4 gCameraFrustum;
     float4 gSunBasisX;
     float4 gSunBasisY;
@@ -260,7 +265,9 @@ NRI_RESOURCE( cbuffer, GlobalConstants, b, 0, SET_ROOT )
     float2 gRectSizePrev;
     float2 gInvSharcRenderSize;
     float2 gJitter;
-    float gEmissionIntensity;
+    float2 gJitterPrev;
+    float gEmissionIntensityLights;
+    float gEmissionIntensityCubes;
     float gNearZ;
     float gSeparator;
     float gRoughnessOverride;
@@ -332,9 +339,8 @@ NRI_RESOURCE( cbuffer, MorphMeshUpdatePrimitivesConstants, b, 0, SET_ROOT )
 NRI_RESOURCE( SamplerState, gLinearMipmapLinearSampler, s, 0, SET_ROOT );
 NRI_RESOURCE( SamplerState, gLinearMipmapNearestSampler, s, 1, SET_ROOT );
 NRI_RESOURCE( SamplerState, gNearestMipmapNearestSampler, s, 2, SET_ROOT );
-
-#define gLinearSampler gLinearMipmapLinearSampler
-#define gNearestSampler gNearestMipmapNearestSampler
+NRI_RESOURCE( SamplerState, gLinearClamp, s, 3, SET_ROOT );
+NRI_RESOURCE( SamplerState, gNearestClamp, s, 4, SET_ROOT );
 
 //=============================================================================================
 // MISC
@@ -498,7 +504,11 @@ float3 GetSunIntensity( float3 v )
 
     sunColor *= Math::SmoothStep( -0.01, 0.05, gSunDirection.z );
 
+#if USE_WHITE_FURNACE
+    return 0.0;
+#else
     return Color::FromGamma( sunColor ) * SUN_INTENSITY;
+#endif
 }
 
 float3 GetSkyIntensity( float3 v )
@@ -515,7 +525,11 @@ float3 GetSkyIntensity( float3 v )
     float ground = 0.5 + 0.5 * Math::SmoothStep( -1.0, 0.0, v.z );
     skyColor *= ground;
 
+#if USE_WHITE_FURNACE
+    return 1.0;
+#else
     return Color::FromGamma( skyColor ) * SKY_INTENSITY + GetSunIntensity( v );
+#endif
 }
 
 #endif

Shaders/Include/RaytracingShared.hlsli

@@ -1,11 +1,12 @@
-DlssBefore.cs.hlsl -T cs
-DlssAfter.cs.hlsl -T cs
-Composition.cs.hlsl -T cs
 MorphMeshUpdatePrimitives.cs.hlsl -T cs
 MorphMeshUpdateVertices.cs.hlsl -T cs
-SharcResolve.cs.hlsl -T cs
 SharcUpdate.cs.hlsl -T cs
-Taa.cs.hlsl -T cs
+SharcResolve.cs.hlsl -T cs
+ConfidenceBlur.cs.hlsl -T cs
 TraceOpaque.cs.hlsl -T cs
+Composition.cs.hlsl -T cs
 TraceTransparent.cs.hlsl -T cs
+Taa.cs.hlsl -T cs
+DlssBefore.cs.hlsl -T cs
+DlssAfter.cs.hlsl -T cs
 Final.cs.hlsl -T cs