Merge remote-tracking branch 'remotes/origin/ray_tracing_spirv_intrinsics'

Author: devsh

71_RayTracingPipeline/app_resources/raytrace.rahit.hlsl

@@ -1,14 +1,19 @@
 #include "common.hlsl"
 
+#include "nbl/builtin/hlsl/spirv_intrinsics/raytracing.hlsl"
+
+using namespace nbl::hlsl;
+
 [[vk::push_constant]] SPushConstants pc;
 
 [shader("anyhit")]
 void main(inout PrimaryPayload payload, in BuiltInTriangleIntersectionAttributes attribs)
 {
-    const int instID = InstanceID();
+    const int instID = spirv::InstanceCustomIndexKHR;
     const STriangleGeomInfo geom = vk::RawBufferLoad < STriangleGeomInfo > (pc.triangleGeomInfoBuffer + instID * sizeof(STriangleGeomInfo));
 
     const uint32_t bitpattern = payload.pcg();
+    // Cannot use spirv::ignoreIntersectionKHR and spirv::terminateRayKHR due to https://github.com/microsoft/DirectXShaderCompiler/issues/7279
     if (geom.material.alphaTest(bitpattern))
         IgnoreHit();
 }

71_RayTracingPipeline/app_resources/raytrace.rchit.hlsl

@@ -1,7 +1,11 @@
 #include "common.hlsl"
 
+#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
+#include "nbl/builtin/hlsl/spirv_intrinsics/raytracing.hlsl"
 #include "nbl/builtin/hlsl/bda/__ptr.hlsl"
 
+using namespace nbl::hlsl;
+
 [[vk::push_constant]] SPushConstants pc;
 
 float3 calculateNormals(int primID, STriangleGeomInfo geom, float2 bary)
@@ -74,16 +78,16 @@ float3 calculateNormals(int primID, STriangleGeomInfo geom, float2 bary)
 [shader("closesthit")]
 void main(inout PrimaryPayload payload, in BuiltInTriangleIntersectionAttributes attribs)
 {
-    const int primID = PrimitiveIndex();
-    const int instanceCustomIndex = InstanceIndex();
-    const int geometryIndex = GeometryIndex();
+    const int primID = spirv::PrimitiveId;
+    const int instanceCustomIndex = spirv::InstanceCustomIndexKHR;
+    const int geometryIndex = spirv::RayGeometryIndexKHR;
     const STriangleGeomInfo geom = vk::RawBufferLoad < STriangleGeomInfo > (pc.triangleGeomInfoBuffer + (instanceCustomIndex + geometryIndex) * sizeof(STriangleGeomInfo));
     const float32_t3 vertexNormal = calculateNormals(primID, geom, attribs.barycentrics);
-    const float32_t3 worldNormal = normalize(mul(vertexNormal, WorldToObject3x4()).xyz);
+    const float32_t3 worldNormal = normalize(mul(vertexNormal, transpose(spirv::WorldToObjectKHR)).xyz);
 
     payload.materialId = MaterialId::createTriangle(instanceCustomIndex);
 
     payload.worldNormal = worldNormal;
-    payload.rayDistance = RayTCurrent();
+    payload.rayDistance = spirv::RayTmaxKHR;
 
 }

71_RayTracingPipeline/app_resources/raytrace.rgen.hlsl

@@ -9,6 +9,8 @@
 static const int32_t s_sampleCount = 10;
 static const float32_t3 s_clearColor = float32_t3(0.3, 0.3, 0.8);
 
+using namespace nbl::hlsl;
+
 [[vk::push_constant]] SPushConstants pc;
 
 [[vk::binding(0, 0)]] RaytracingAccelerationStructure topLevelAS;
@@ -23,8 +25,8 @@ float32_t nextRandomUnorm(inout nbl::hlsl::Xoroshiro64StarStar rnd)
 [shader("raygeneration")]
 void main()
 {
-    const uint32_t3 launchID = DispatchRaysIndex();
-    const uint32_t3 launchSize = DispatchRaysDimensions();
+    const uint32_t3 launchID = spirv::LaunchIdKHR;
+    const uint32_t3 launchSize = spirv::LaunchSizeKHR;
     const uint32_t2 coords = launchID.xy;
 
     const uint32_t seed1 = nbl::hlsl::random::Pcg::create(pc.frameCounter)();
@@ -53,9 +55,11 @@ void main()
         rayDesc.TMin = 0.01;
         rayDesc.TMax = 10000.0;
 
+        [[vk::ext_storage_class(spv::StorageClassRayPayloadKHR)]]
         PrimaryPayload payload;
         payload.pcg = PrimaryPayload::generator_t::create(rnd());
-        TraceRay(topLevelAS, RAY_FLAG_NONE, 0xff, ERT_PRIMARY, 0, EMT_PRIMARY, rayDesc, payload);
+        spirv::traceRayKHR(topLevelAS, spv::RayFlagsMaskNone, 0xff, ERT_PRIMARY, 0, EMT_PRIMARY, rayDesc.Origin, rayDesc.TMin, rayDesc.Direction, rayDesc.TMax, payload);
+        // TraceRay(topLevelAS, RAY_FLAG_NONE, 0xff, ERT_PRIMARY, 0, EMT_PRIMARY, rayDesc, payload);
 
         const float32_t rayDistance = payload.rayDistance;
         if (rayDistance < 0)
@@ -67,9 +71,10 @@ void main()
         const float32_t3 worldPosition = pc.camPos + (camDirection * rayDistance);
 
         // make sure to call with least live state
+        [[vk::ext_storage_class(spv::StorageClassCallableDataKHR)]]
         RayLight cLight;
         cLight.inHitPosition = worldPosition;
-        CallShader(pc.light.type, cLight);
+        spirv::executeCallable(pc.light.type, cLight);
 
         const float32_t3 worldNormal = payload.worldNormal;
 
@@ -97,12 +102,16 @@ void main()
             rayDesc.TMin = 0.01;
             rayDesc.TMax = cLight.outLightDistance;
 
+            [[vk::ext_storage_class(spv::StorageClassRayPayloadKHR)]]
             OcclusionPayload occlusionPayload;
             // 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);
+            uint32_t shadowRayFlags = spv::RayFlagsTerminateOnFirstHitKHRMask | spv::RayFlagsSkipClosestHitShaderKHRMask;
+            spirv::traceRayKHR(topLevelAS, shadowRayFlags, 0xFF, ERT_OCCLUSION, 0, EMT_OCCLUSION, rayDesc.Origin, rayDesc.TMin, rayDesc.Direction, rayDesc.TMax, occlusionPayload);
+
+            // 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 > 1.f/1024.f)

71_RayTracingPipeline/app_resources/raytrace.rint.hlsl

@@ -1,5 +1,10 @@
 #include "common.hlsl"
 
+#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
+#include "nbl/builtin/hlsl/spirv_intrinsics/raytracing.hlsl"
+
+using namespace nbl::hlsl;
+
 [[vk::push_constant]] SPushConstants pc;
 
 struct Ray
@@ -26,22 +31,23 @@ float32_t hitSphere(SProceduralGeomInfo s, Ray r)
 void main()
 {
     Ray ray;
-    ray.origin = WorldRayOrigin();
-    ray.direction = WorldRayDirection();
+    ray.origin = spirv::WorldRayOriginKHR;
+    ray.direction = spirv::WorldRayDirectionKHR;
 
-    const int primID = PrimitiveIndex();
+    const int primID = spirv::PrimitiveId;
 
     // Sphere data
     SProceduralGeomInfo sphere = vk::RawBufferLoad<SProceduralGeomInfo>(pc.proceduralGeomInfoBuffer + primID * sizeof(SProceduralGeomInfo));
 
     const float32_t tHit = hitSphere(sphere, ray);
 
+    [[vk::ext_storage_class(spv::StorageClassHitAttributeKHR)]]
     ProceduralHitAttribute hitAttrib;
 
     // Report hit point
     if (tHit > 0)
     {
         hitAttrib.center = sphere.center;
-        ReportHit(tHit, 0, hitAttrib);
+        spirv::reportIntersectionKHR(tHit, 0);
     }
 }

71_RayTracingPipeline/app_resources/raytrace_procedural.rchit.hlsl

@@ -1,16 +1,20 @@
 #include "common.hlsl"
 
+#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
+#include "nbl/builtin/hlsl/spirv_intrinsics/raytracing.hlsl"
+using namespace nbl::hlsl;
+
 [[vk::push_constant]] SPushConstants pc;
 
 [shader("closesthit")]
 void main(inout PrimaryPayload payload, in ProceduralHitAttribute attrib)
 {
-    const float32_t3 worldPosition = WorldRayOrigin() + WorldRayDirection() * RayTCurrent();
+    const float32_t3 worldPosition = spirv::WorldRayOriginKHR + spirv::WorldRayDirectionKHR * spirv::RayTmaxKHR;
     const float32_t3 worldNormal = normalize(worldPosition - attrib.center);
 
-    payload.materialId = MaterialId::createProcedural(PrimitiveIndex()); // we use negative value to indicate that this is procedural
+    payload.materialId = MaterialId::createProcedural(spirv::PrimitiveId); // we use negative value to indicate that this is procedural
 
     payload.worldNormal = worldNormal;
-    payload.rayDistance = RayTCurrent();
+    payload.rayDistance = spirv::RayTmaxKHR;
 
 }

71_RayTracingPipeline/app_resources/raytrace_shadow.rahit.hlsl

@@ -1,18 +1,24 @@
 #include "common.hlsl"
 #include "nbl/builtin/hlsl/spirv_intrinsics/raytracing.hlsl"
+#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
+
+using namespace nbl::hlsl;
 
 [[vk::push_constant]] SPushConstants pc;
 
 [shader("anyhit")]
 void main(inout OcclusionPayload payload, in BuiltInTriangleIntersectionAttributes attribs)
 {
-    const int instID = InstanceID();
+    const int instID = spirv::InstanceCustomIndexKHR;
     const STriangleGeomInfo geom = vk::RawBufferLoad < STriangleGeomInfo > (pc.triangleGeomInfoBuffer + instID * sizeof(STriangleGeomInfo));
     const Material material = nbl::hlsl::_static_cast<Material>(geom.material);
 
     const float attenuation = (1.f-material.alpha) * payload.attenuation;
     // DXC cogegens weird things in the presence of termination instructions
     payload.attenuation = attenuation;
+
+
+    // Cannot use spirv::ignoreIntersectionKHR and spirv::terminateRayKHR due to https://github.com/microsoft/DirectXShaderCompiler/issues/7279
     // arbitrary constant, whatever you want the smallest attenuation to be. Remember until miss, the attenuatio is negative
     if (attenuation > -1.f/1024.f)
         AcceptHitAndEndSearch();