Merge branch 'pkristof/roughnessDebugView' into 'main'

Cleanly separated primary and secondary demodulation paths. Adjusted debug views

See merge request lightspeedrtx/dxvk-remix-nv!2125

Author: pkristof

src/dxvk/rtx_render/rtx_debug_view.cpp

@@ -114,9 +114,9 @@ namespace dxvk {
                                                     "Parameterize via:\n"
                                                     "Debug Knob [0]: num texels per checker box [Default: 64]\n"
                                                     "Debug Knob [1]: checkers overlay strength [Default: 0.5]"},
-        {DEBUG_VIEW_BASE_REFLECTIVITY, "Base Reflectivity"},
         {DEBUG_VIEW_ROUGHNESS, "Isotropic Roughness"},
-        {DEBUG_VIEW_PERCEPTUAL_ROUGHNESS, "Perceptual Roughness"},
+        {DEBUG_VIEW_INDIRECT_FIRST_HIT_PERCEPTUAL_ROUGHNESS, "Indirect First Hit Perceptual Roughness"},
+        {DEBUG_VIEW_PRIMARY_PERCEPTUAL_ROUGHNESS, "Primary Perceptual Roughness"},
         {DEBUG_VIEW_ANISOTROPY, "Anisotropy"},
         {DEBUG_VIEW_ANISOTROPIC_ROUGHNESS, "Anisotropic Roughness"},
         {DEBUG_VIEW_OPACITY, "Opacity"},
@@ -234,6 +234,12 @@ namespace dxvk {
 
         {DEBUG_VIEW_PRIMARY_SPECULAR_ALBEDO,               "Primary Specular Albedo"},
         {DEBUG_VIEW_SECONDARY_SPECULAR_ALBEDO,               "Secondary Specular Albedo"},
+        {DEBUG_VIEW_SECONDARY_ALBEDO,                      "Secondary Diffuse Albedo"},
+        {DEBUG_VIEW_PRIMARY_BASE_REFLECTIVITY_RAW,         "Primary Base Reflectivity (Raw)"},
+        {DEBUG_VIEW_PRIMARY_BASE_REFLECTIVITY_ADJUSTED,    "Primary Base Reflectivity (Adjusted)"},
+        {DEBUG_VIEW_SECONDARY_BASE_REFLECTIVITY_RAW,       "Secondary Base Reflectivity (Raw)"},
+        {DEBUG_VIEW_SECONDARY_BASE_REFLECTIVITY_ADJUSTED,  "Secondary Base Reflectivity (Adjusted)"},
+        {DEBUG_VIEW_SECONDARY_PERCEPTUAL_ROUGHNESS, "Secondary Perceptual Roughness" },
 
         {DEBUG_VIEW_NOISY_PRIMARY_DIRECT_DIFFUSE_RADIANCE,               "Primary Direct Diffuse: Noisy Color"},
         {DEBUG_VIEW_NOISY_PRIMARY_DIRECT_DIFFUSE_HIT_T,                  "Primary Direct Diffuse: Noisy HitT"},
@@ -436,7 +442,7 @@ namespace dxvk {
   #define LIST_EXPLICIT_COMPOSITE_DEBUG_VIEWS(X) \
     X(CompositeDebugView::FinalRenderWithMaterialProperties, "Final Render + Material Properties", 3, \
       DEBUG_VIEW_POST_TONEMAP_OUTPUT, DEBUG_VIEW_ALBEDO, DEBUG_VIEW_SHADING_NORMAL, \
-      DEBUG_VIEW_PERCEPTUAL_ROUGHNESS, DEBUG_VIEW_EMISSIVE_RADIANCE, DEBUG_VIEW_HEIGHT_MAP) \
+      DEBUG_VIEW_PRIMARY_PERCEPTUAL_ROUGHNESS, DEBUG_VIEW_EMISSIVE_RADIANCE, DEBUG_VIEW_HEIGHT_MAP) \
     X(CompositeDebugView::OpaqueMaterialTextureResolutionCheckers, "Opaque Material Texture Resolution Checkers", 2, \
       DEBUG_VIEW_OPAQUE_RAW_ALBEDO_RESOLUTION_CHECKERS, DEBUG_VIEW_OPAQUE_NORMAL_RESOLUTION_CHECKERS, \
       DEBUG_VIEW_OPAQUE_ROUGHNESS_RESOLUTION_CHECKERS)

src/dxvk/shaders/rtx/algorithm/geometry_resolver.slangh

@@ -416,7 +416,7 @@ void geometryResolverOutputSurface<
     AlphaBlendGBuffer[pixelCoordinate] = alphaBlendSurface.pack(cb.alphaBlendSurfacePackMult);
   }
 
-  geometryResolverOutputSurfaceDebugView(pixelCoordinate, virtualMotion);
+  geometryResolverOutputSurfaceDebugView<PRIMARY_SURFACE>(pixelCoordinate, virtualMotion, polymorphicSurfaceMaterialInteraction);
 }
 
 void geometryResolverOutputSurfaceDynamic(
@@ -525,9 +525,11 @@ void accumulateParticleBuffer(ivec2 pixelCoordinate, vec3 radiance)
 
 #if GBUFFER_FEATURE_DEBUG_VIEW
 
-void geometryResolverOutputSurfaceDebugView(
+void geometryResolverOutputSurfaceDebugView<
+  let PRIMARY_SURFACE : bool>(
   uvec2 pixelCoordinate,
-  vec3 virtualMotion)
+  vec3 virtualMotion,
+  PolymorphicSurfaceMaterialInteraction polymorphicSurfaceMaterialInteraction)
  {
   switch(cb.debugView)
   {
@@ -537,17 +539,51 @@ void geometryResolverOutputSurfaceDebugView(
   case DEBUG_VIEW_VIRTUAL_MOTION_VECTOR:
     storeInDebugView(pixelCoordinate, virtualMotion);
     break;
-   case DEBUG_VIEW_NAN:
+  case DEBUG_VIEW_SECONDARY_PERCEPTUAL_ROUGHNESS:
+    if (!PRIMARY_SURFACE)
+    {
+      storeInDebugView(pixelCoordinate, SecondaryPerceptualRoughness[pixelCoordinate]);
+    }
+    break;
+  case DEBUG_VIEW_SECONDARY_ALBEDO:
+    if (!PRIMARY_SURFACE)
+    {
+      storeInDebugView(pixelCoordinate, SecondaryAlbedo[pixelCoordinate].xyz);
+    }
+    break;
+  case DEBUG_VIEW_SECONDARY_BASE_REFLECTIVITY_RAW:
+    if (!PRIMARY_SURFACE)
+    {
+      storeInDebugView(pixelCoordinate, SecondaryBaseReflectivity[pixelCoordinate].xyz);
+    }
+    break;
+  case DEBUG_VIEW_NAN:
    {
      bool isValid = true;
-      
+
      // DEBUG_VIEW_VIRTUAL_MOTION_VECTOR
      isValid &= isValidValue(virtualMotion);
 
+     // DEBUG_VIEW_SECONDARY_PERCEPTUAL_ROUGHNESS / DEBUG_VIEW_SECONDARY_ALBEDO
+     if (!PRIMARY_SURFACE)
+     {
+       isValid &= isValidValue(SecondaryPerceptualRoughness[pixelCoordinate]);
+       isValid &= isValidValue(SecondaryAlbedo[pixelCoordinate].xyz);
+       // DEBUG_VIEW_SECONDARY_BASE_REFLECTIVITY_RAW
+       isValid &= isValidValue(SecondaryBaseReflectivity[pixelCoordinate].xyz);
+     }
+
      accumulateInDebugViewAnd(pixelCoordinate, isValid);
      break;
    }
   }
+
+  // Primary-material debug views are factored into a separate helper because the unordered-decals
+  // pass re-invokes it after blending updates the GBuffer; calling it here covers the initial write.
+  if (PRIMARY_SURFACE)
+  {
+    geometryResolverOutputPrimaryMaterialDebugView(pixelCoordinate, polymorphicSurfaceMaterialInteraction);
+  }
 }
 
 void geometryResolverVertexOutputDebugView(
@@ -756,21 +792,6 @@ void geometryResolverVertexOutputDebugView(
 
     storeInDebugView(pixelCoordinate, albedo);
 
-    break;
-  case DEBUG_VIEW_BASE_REFLECTIVITY:
-    vec3 baseReflectivity = vec3(0.0f);
-
-    if (materialType == surfaceMaterialTypeOpaque)
-    {
-      baseReflectivity = opaqueSurfaceMaterialInteractionCreate(polymorphicSurfaceMaterialInteraction).baseReflectivity;
-    }
-    else if (materialType == surfaceMaterialTypeTranslucent)
-    {
-      baseReflectivity = translucentSurfaceMaterialInteractionCreate(polymorphicSurfaceMaterialInteraction).baseReflectivity;
-    }
-    
-    storeInDebugView(pixelCoordinate, baseReflectivity);
-
     break;
   case DEBUG_VIEW_ROUGHNESS:
     float isotropicRoughness = 0.0f;
@@ -1075,18 +1096,6 @@ void geometryResolverVertexOutputDebugView(
       }
       isValid &= isValidValue(albedo);
 
-      // DEBUG_VIEW_BASE_REFLECTIVITY
-      vec3 baseReflectivity = vec3(0.0f);
-      if (materialType == surfaceMaterialTypeOpaque)
-      {
-        baseReflectivity = opaqueSurfaceMaterialInteractionCreate(polymorphicSurfaceMaterialInteraction).baseReflectivity;
-      }
-      else if (materialType == surfaceMaterialTypeTranslucent)
-      {
-        baseReflectivity = translucentSurfaceMaterialInteractionCreate(polymorphicSurfaceMaterialInteraction).baseReflectivity;
-      }
-      isValid &= isValidValue(baseReflectivity);
-
       // DEBUG_VIEW_ROUGHNESS
       float isotropicRoughness = 0.0f;
       if (materialType == surfaceMaterialTypeOpaque)
@@ -1334,7 +1343,12 @@ void geometryResolverOutputDebugView(uvec2 pixelCoordinate)
   }
 }
 
-void geometryResolverOutputFinalPrimaryMaterialDebugView(
+// Writes primary-surface debug views derived from the GBuffer-resident material data.
+// May be called more than once per pixel: once after the initial primary material write in the
+// geometry resolve pass, and again after unordered-decal blending updates the same GBuffer
+// resources. All cases here must therefore be safe to re-run (snapshot writes that overwrite the
+// previous value, or accumulators whose operation is idempotent/order-independent).
+void geometryResolverOutputPrimaryMaterialDebugView(
   uvec2 pixelCoordinate,
   PolymorphicSurfaceMaterialInteraction polymorphicSurfaceMaterialInteraction)
 {
@@ -1344,6 +1358,12 @@ void geometryResolverOutputFinalPrimaryMaterialDebugView(
   {
   default:
     break;
+  case DEBUG_VIEW_PRIMARY_PERCEPTUAL_ROUGHNESS:
+    storeInDebugView(pixelCoordinate, PrimaryPerceptualRoughness[pixelCoordinate]);
+    break;
+  case DEBUG_VIEW_PRIMARY_BASE_REFLECTIVITY_RAW:
+    storeInDebugView(pixelCoordinate, PrimaryBaseReflectivity[pixelCoordinate].xyz);
+    break;
   case DEBUG_VIEW_SHADING_NORMAL:
   {
     vec3 shadingNormal = vec3(0.0f);
@@ -1381,22 +1401,6 @@ void geometryResolverOutputFinalPrimaryMaterialDebugView(
     storeInDebugView(pixelCoordinate, albedo);
     break;
   }
-  case DEBUG_VIEW_BASE_REFLECTIVITY:
-  {
-    vec3 baseReflectivity = vec3(0.0f);
-
-    if (materialType == surfaceMaterialTypeOpaque)
-    {
-      baseReflectivity = opaqueSurfaceMaterialInteractionCreate(polymorphicSurfaceMaterialInteraction).baseReflectivity;
-    }
-    else if (materialType == surfaceMaterialTypeTranslucent)
-    {
-      baseReflectivity = vec3(translucentSurfaceMaterialInteractionCreate(polymorphicSurfaceMaterialInteraction).baseReflectivity);
-    }
-
-    storeInDebugView(pixelCoordinate, baseReflectivity);
-    break;
-  }
   case DEBUG_VIEW_ROUGHNESS:
   {
     float isotropicRoughness = 0.0f;
@@ -1511,9 +1515,11 @@ void geometryResolverOutputFinalPrimaryMaterialDebugView(
 
 #else
 
-void geometryResolverOutputSurfaceDebugView(
+void geometryResolverOutputSurfaceDebugView<
+  let PRIMARY_SURFACE : bool>(
   uvec2 pixelCoordinate,
-  vec3 virtualMotion)
+  vec3 virtualMotion,
+  PolymorphicSurfaceMaterialInteraction polymorphicSurfaceMaterialInteraction)
 {
 }
 
@@ -1996,7 +2002,7 @@ void geometryResolverVertex(
 
   // Update NRC when a final GBuffer hit occurs.
   // Note: any path termination handling is delayed to indirect pass
-  if (!(geometryResolverState.performPSRR || geometryResolverState.performPSTR))
+  if (!geometryResolverState.performedAnyPSR())
   {
     // Note: radiance and throughput gets reset by NRC for training paths
     updateNrcOnGBufferHitTrainingAndQueryPaths(geometryResolverState.pixelCoordinate,
@@ -2038,7 +2044,7 @@ void geometryResolverVertex(
 #else
     true &&
 #endif
-    (geometryResolverState.performPSRR || geometryResolverState.performPSTR);
+    geometryResolverState.performedAnyPSR();
 
   if (writeFirstHitForPSRPrepare)
   {
@@ -2106,7 +2112,7 @@ void geometryResolverVertex(
     }
   }
 #if GBUFFER_FEATURE_INLINE_PSR_SAMPLING
-  else if (geometryResolverState.performPSRR || geometryResolverState.performPSTR)
+  else if (geometryResolverState.performedAnyPSR())
   {
     // Set the geometry flag bits that must be the same for both PSR passes, see unpackPSRData(...)
 
@@ -2202,7 +2208,7 @@ void geometryResolverVertex(
       geometryResolverState.isViewModelSurface);
   }
 
-  if (GBUFFER_FEATURE_INLINE_PSR_SAMPLING && !push.usePSRPrepare && (geometryResolverState.performPSRR || geometryResolverState.performPSTR))
+  if (GBUFFER_FEATURE_INLINE_PSR_SAMPLING && !push.usePSRPrepare && geometryResolverState.performedAnyPSR())
   {
     PrimaryAttenuation[geometryResolverState.pixelCoordinate] = colorToR11G11B10(geometryResolverState.attenuation);
   }
@@ -2953,7 +2959,7 @@ void geometryResolver(ivec2 pixelCoordinate) {
   bool primarySelectedIntegrationSurface;
   bool secondarySurfaceMask;
 
-  if (geometryResolverState.performPSRR && geometryResolverState.performPSTR)
+  if (geometryResolverState.hasSecondarySurface())
   {
     // Note: Transmission preferred as the primary surface when both PSRR and PSTR are done at the same time.
     primarySelectedIntegrationSurface = !geometryResolverState.reflectionSelectedIntegrationSurface;
@@ -3269,7 +3275,7 @@ void geometryResolverApplyUnorderedDecalsPass(ivec2 pixelCoordinate) {
   }
 
 #if GBUFFER_FEATURE_DEBUG_VIEW
-  geometryResolverOutputFinalPrimaryMaterialDebugView(
+  geometryResolverOutputPrimaryMaterialDebugView(
     pixelCoordinate,
     blendedPolymorphicSurfaceMaterialInteraction);
 #endif
@@ -3406,7 +3412,10 @@ void geometryPSRPreparePass(ivec2 pixelCoordinate) {
   SharedRadianceB[pixelCoordinate] = radiance.b;
   SharedIntegrationSurfacePdf[pixelCoordinate] = selectedIntegrationSurfacePdf;
 
-  if (performPSRR && performPSTR)
+  geometryFlags.performPSRR = performPSRR;
+  geometryFlags.performPSTR = performPSTR;
+
+  if (geometryFlags.hasSecondarySurface())
   {
     geometryFlags.primarySelectedIntegrationSurface = !reflectionSelectedIntegrationSurface;
     geometryFlags.secondarySurfaceMask = true;
@@ -3417,10 +3426,7 @@ void geometryPSRPreparePass(ivec2 pixelCoordinate) {
     geometryFlags.secondarySurfaceMask = false;
   }
 
-  geometryFlags.performPSRR = performPSRR;
-  geometryFlags.performPSTR = performPSTR;
-
-  if (!(performPSRR || performPSTR))
+  if (!geometryFlags.performedAnyPSR())
   {
     geometryResolverOutputMiss<false, false>(pixelCoordinate);
     geometryFlagsWriteToGBuffer(geometryFlags, pixelCoordinate, SharedFlags);

src/dxvk/shaders/rtx/algorithm/geometry_resolver_state.slangh

@@ -188,6 +188,18 @@ struct GeometryResolverState : IBasePayloadState
     return false;
   }
 #endif // defined(RAY_PIPELINE)
+
+  // True if any PSR (reflection or transmission) is being performed for this pixel.
+  bool performedAnyPSR()
+  {
+    return performPSTR || performPSRR;
+  }
+
+  // True only when BOTH PSRR and PSTR fire — one becomes the primary surface, the other becomes a distinct secondary surface.
+  bool hasSecondarySurface()
+  {
+    return performPSTR && performPSRR;
+  }
 }
 
 struct GeometryPSRResolverState : IBasePayloadState
@@ -363,7 +375,7 @@ struct GeometryPSRResolverState : IBasePayloadState
   }
 
 #ifdef RAY_PIPELINE
-  bool shouldReorder(out uint coherenceHints, out uint numCoherenceHints) 
+  bool shouldReorder(out uint coherenceHints, out uint numCoherenceHints)
   {
     coherenceHints = 0;
     numCoherenceHints = 0;

src/dxvk/shaders/rtx/algorithm/integrator_direct.slangh

@@ -517,7 +517,7 @@ void integratorDirectPathOutputDebugView(
     }
     break;
   }
-  case DEBUG_VIEW_PERCEPTUAL_ROUGHNESS:
+  case DEBUG_VIEW_INDIRECT_FIRST_HIT_PERCEPTUAL_ROUGHNESS:
     storeInDebugView(pixelCoordinate, aliasedData1.IndirectFirstHitPerceptualRoughness[pixelCoordinate]);
     break;
   case DEBUG_VIEW_INTEGRATE_INDIRECT_FIRST_RAY_THROUGHPUT:
@@ -543,7 +543,7 @@ void integratorDirectPathOutputDebugView(
       isValid &= isValidValue(SecondaryCombinedSpecularLobeRadianceHitDistance[pixelCoordinate]);
     }
 
-    // DEBUG_VIEW_PERCEPTUAL_ROUGHNESS
+    // DEBUG_VIEW_INDIRECT_FIRST_HIT_PERCEPTUAL_ROUGHNESS
     isValid &= isValidValue(aliasedData1.IndirectFirstHitPerceptualRoughness[pixelCoordinate]);
 
     // DEBUG_VIEW_INTEGRATE_INDIRECT_FIRST_RAY_THROUGHPUT

src/dxvk/shaders/rtx/pass/composite/composite.comp.slang

@@ -561,8 +561,7 @@ void main(uint2 threadIndex : SV_DispatchThreadID, uint2 localIndex : SV_GroupTh
   // Note: Relying on the same sentinel value outputted to the linear view Z which NRD relies on, so this is safe (and lets us not have to read
   // in the cone radius texture which typically contains the flag we use to determine this).
   const bool primaryMiss = primaryLinearViewZ == cb.primaryDirectMissLinearViewZ
-                           && !geometryFlags.performPSTR
-                           && !geometryFlags.performPSRR;  // must not be PSR
+                           && !geometryFlags.performedAnyPSR();  // must not be PSR
 
   vec4 particleLayerOutput;
   vec4 finalOutput = compositeResult(pixelCoordinate, geometryFlags, primaryLinearViewZ, primaryMiss, particleLayerOutput);