do shadows without any closest hit shaders, one miss shader instead

Author: devsh

71_RayTracingPipeline/app_resources/common.hlsl

@@ -170,7 +170,10 @@ struct RayLight
 
 struct [raypayload] OcclusionPayload
 {
-    float32_t attenuation : read(caller) : write(caller, anyhit);
+    // TODO: will this break DXC? Tbh should come from push constant or some autoexposure feedback
+    // NBL_CONSTEXPR_STATIC_INLINE float32_t MinAttenuation = 1.f/1024.f;
+
+    float32_t attenuation : read(caller,anyhit,miss) : write(caller,anyhit,miss);
 };
 
 struct MaterialId
@@ -210,7 +213,7 @@ struct [raypayload] PrimaryPayload
     using generator_t = nbl::hlsl::random::Pcg;
 
     float32_t3  worldNormal : read(caller) : write(closesthit);
-    float32_t   rayDistance : read(caller) : write(closesthit, miss);
+    float32_t   rayDistance : read(caller) : write(closesthit,miss);
     generator_t pcg         : read(anyhit) : write(caller,anyhit);
     MaterialId  materialId  : read(caller) : write(closesthit);
 

71_RayTracingPipeline/app_resources/raytrace.rgen.hlsl

@@ -97,13 +97,15 @@ void main()
             rayDesc.TMin = 0.01;
             rayDesc.TMax = cLight.outLightDistance;
 
-            uint32_t shadowRayFlags = RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH;
             OcclusionPayload occlusionPayload;
-            occlusionPayload.attenuation = 1;
+            // negative means its a hit, the miss shader will flip it back around to positive
+            occlusionPayload.attenuation = -1.f;
+            // abuse of miss shader to mean "not hit shader" solves us having to call closest hit shaders
+            uint32_t shadowRayFlags = RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH | RAY_FLAG_SKIP_CLOSEST_HIT_SHADER;
             TraceRay(topLevelAS, shadowRayFlags, 0xFF, ERT_OCCLUSION, 0, EMT_OCCLUSION, rayDesc, occlusionPayload);
 
             attenuation = occlusionPayload.attenuation;
-            if (occlusionPayload.attenuation > 0.0001)
+            if (occlusionPayload.attenuation > 1.f/1024.f)
             {
                 const float32_t3 diffuse = computeDiffuse(material, cLight.outLightDir, worldNormal);
                 const float32_t3 specular = computeSpecular(material, camDirection, cLight.outLightDir, worldNormal);

71_RayTracingPipeline/app_resources/raytrace_shadow.rahit.hlsl

@@ -1,4 +1,5 @@
 #include "common.hlsl"
+#include "nbl/builtin/hlsl/spirv_intrinsics/raytracing.hlsl"
 
 [[vk::push_constant]] SPushConstants pc;
 
@@ -9,9 +10,11 @@ void main(inout OcclusionPayload payload, in BuiltInTriangleIntersectionAttribut
     const STriangleGeomInfo geom = vk::RawBufferLoad < STriangleGeomInfo > (pc.triangleGeomInfoBuffer + instID * sizeof(STriangleGeomInfo));
     const Material material = nbl::hlsl::_static_cast<Material>(geom.material);
 
-    payload.attenuation = (1.f-material.alpha) * payload.attenuation;
-    // arbitrary constant
-//    if (payload.attenuation < 1.f/1024.f)
-//        TerminateRay();
+    const float attenuation = (1.f-material.alpha) * payload.attenuation;
+    // DXC cogegens weird things in the presence of termination instructions
+    payload.attenuation = attenuation;
+    // arbitrary constant, whatever you want the smallest attenuation to be. Remember until miss, the attenuatio is negative
+    if (attenuation > -1.f/1024.f)
+        AcceptHitAndEndSearch();
     IgnoreHit();
 }

71_RayTracingPipeline/app_resources/raytrace_shadow.rmiss.hlsl

@@ -0,0 +1,8 @@
+#include "common.hlsl"
+
+[shader("miss")]
+void main(inout OcclusionPayload payload)
+{
+    // make positive
+    payload.attenuation = -payload.attenuation;
+}

71_RayTracingPipeline/app_resources/raytrace_shadow_triangle.rchit.hlsl

@@ -163,7 +163,7 @@ class RaytracingPipelineApp final : public examples::SimpleWindowedApplication,
     const auto anyHitShaderColorPayload = loadCompileAndCreateShader("app_resources/raytrace.rahit.hlsl");
     const auto anyHitShaderShadowPayload = loadCompileAndCreateShader("app_resources/raytrace_shadow.rahit.hlsl");
     const auto missShader = loadCompileAndCreateShader("app_resources/raytrace.rmiss.hlsl");
-    const auto shadowClosestHitShader = loadCompileAndCreateShader("app_resources/raytrace_shadow_triangle.rchit.hlsl");
+    const auto missShadowShader = loadCompileAndCreateShader("app_resources/raytrace_shadow.rmiss.hlsl");
     const auto directionalLightCallShader = loadCompileAndCreateShader("app_resources/light_directional.rcall.hlsl");
     const auto pointLightCallShader = loadCompileAndCreateShader("app_resources/light_point.rcall.hlsl");
     const auto spotLightCallShader = loadCompileAndCreateShader("app_resources/light_spot.rcall.hlsl");
@@ -323,7 +323,7 @@ class RaytracingPipelineApp final : public examples::SimpleWindowedApplication,
       {
         RTDS_RAYGEN,
         RTDS_MISS,
-        RTDS_CLOSEST_HIT_SHADOW,
+        RTDS_MISS_SHADOW,
         RTDS_CLOSEST_HIT,
         RTDS_SPHERE_CLOSEST_HIT,
         RTDS_ANYHIT_PRIMARY,
@@ -338,7 +338,7 @@ class RaytracingPipelineApp final : public examples::SimpleWindowedApplication,
       IGPUShader::SSpecInfo shaders[RTDS_COUNT];
       shaders[RTDS_RAYGEN] = {.shader = raygenShader.get()};
       shaders[RTDS_MISS] = {.shader = missShader.get()};
-      shaders[RTDS_CLOSEST_HIT_SHADOW] = { .shader = shadowClosestHitShader.get() };
+      shaders[RTDS_MISS_SHADOW] = { .shader = missShadowShader.get() };
       shaders[RTDS_CLOSEST_HIT] = {.shader = closestHitShader.get()};
       shaders[RTDS_SPHERE_CLOSEST_HIT] = {.shader = proceduralClosestHitShader.get()};
       shaders[RTDS_ANYHIT_PRIMARY] = {.shader = anyHitShaderColorPayload.get()};
@@ -351,17 +351,17 @@ class RaytracingPipelineApp final : public examples::SimpleWindowedApplication,
       params.layout = pipelineLayout.get();
       params.shaders = std::span(shaders);
       using RayTracingFlags = IGPURayTracingPipeline::SCreationParams::FLAGS;
-      params.flags = core::bitflag(RayTracingFlags::NO_NULL_INTERSECTION_SHADERS) | 
-        RayTracingFlags::NO_NULL_ANY_HIT_SHADERS |
-        RayTracingFlags::NO_NULL_CLOSEST_HIT_SHADERS;
+      params.flags = core::bitflag(RayTracingFlags::NO_NULL_MISS_SHADERS) |
+        RayTracingFlags::NO_NULL_INTERSECTION_SHADERS | 
+        RayTracingFlags::NO_NULL_ANY_HIT_SHADERS;
 
       auto& shaderGroups = params.shaderGroups;
 
       shaderGroups.raygen = { .index = RTDS_RAYGEN };
 
       IRayTracingPipelineBase::SGeneralShaderGroup missGroups[EMT_COUNT];
       missGroups[EMT_PRIMARY] = { .index = RTDS_MISS };
-      missGroups[EMT_OCCLUSION] = { .index = IGPURayTracingPipeline::SGeneralShaderGroup::Unused };
+      missGroups[EMT_OCCLUSION] = { .index = RTDS_MISS_SHADOW };
       shaderGroups.misses = missGroups;
 
       auto getHitGroupIndex = [](E_GEOM_TYPE geomType, E_RAY_TYPE rayType)
@@ -374,7 +374,7 @@ class RaytracingPipelineApp final : public examples::SimpleWindowedApplication,
         .anyHit = RTDS_ANYHIT_PRIMARY,
       };
       hitGroups[getHitGroupIndex(EGT_TRIANGLES, ERT_OCCLUSION)] = {
-        .closestHit = RTDS_CLOSEST_HIT_SHADOW,
+        .closestHit = IGPURayTracingPipeline::SGeneralShaderGroup::Unused,
         .anyHit = RTDS_ANYHIT_SHADOW,
       };
       hitGroups[getHitGroupIndex(EGT_PROCEDURAL, ERT_PRIMARY)] = {
@@ -383,7 +383,7 @@ class RaytracingPipelineApp final : public examples::SimpleWindowedApplication,
         .intersection = RTDS_INTERSECTION,
       };
       hitGroups[getHitGroupIndex(EGT_PROCEDURAL, ERT_OCCLUSION)] = {
-        .closestHit = RTDS_CLOSEST_HIT_SHADOW,
+        .closestHit = IGPURayTracingPipeline::SGeneralShaderGroup::Unused,
         .anyHit = RTDS_ANYHIT_SHADOW,
         .intersection = RTDS_INTERSECTION,
       };