Add Vulkan/SPIR-V support for TraceRayInline() (#1737)

For the most part, this translation is straightforward because the `GL_EXT_ray_query` extension is well aligned with the DXR 1.1 `RayQuery` feature. Many function map one-to-one from one extension to the other.

A few notable details:

* The equivalent of the `RayQuery<Flags>` type is non-generic in GLSL, and the GLSL path previously didn't have support for trying to look up an intrinsic type name on an IR type declaration, so that required some tweaks to the emit logic.

* All the GLSL functions are free functions instead of member functions, but our IR doesn't recognize that distinction anyway

* The main `TraceRayInline()` call is the one that took the most tweaking, just because it takes a `RayDesc` structure for D3D/HLSL but takes individual vector sand scalars for VK/GLSL. The approach here is a standard one for how we manage this stuff in the stdlib (and I wanted to avoid adding even more `$` magic for intrinsics).

* For several other calls, the HLSL API had distinct `Candidate***()` and `Committed***()` calls that return information about a candidate hit vs. the one committed into the query. In contrast, the GLSL API uses a single call that takes an additional "must be compile-time constant" `bool` parameter to select between the two behaviors. This is even the case for one call that basically returns a value of a different `enum` type depending on the state of that `bool`. The D3D API model here seems almost strictly better and I have no idea why the GLSL extension was defined this way.

* Because both the `GL_EXT_ray_query` and `GL_EXT_ray_tracing` extensions declare the `accelerationStructureEXT` type, we can no longer infer what extension is supposed to be used based only on the presene of such a type. The logic right now is a bit slippery, because in theory a program that declares an acceleration structure but never traces into it could end up getting a compilation error now. We will have to see if that corner case comes up in practice. :(

The one big detail that is looming after doing this work is that both the HLSL and GLSL exposures of ray queries are extremely "slippery" about the actual identity of queries (e.g., when is one query a copy of another, vs. just being a new variable that references the existing query). Somehow queries get their identity from the original declaration, and as such our "default constructor" approach to them seems semanticay correct, but the whole thing is kind of slippery at a foundational level and I don't know how to fix it with the API as defined. Oh well; just something to keep an eye on.

Co-authored-by: Yong He <yonghe@outlook.com>

1 files changed, 189 insertions, 8 deletions

diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang
index 77b371662..761016866 100644
--- a/source/slang/hlsl.meta.slang
+++ b/source/slang/hlsl.meta.slang
@@ -4678,6 +4678,9 @@ static const CANDIDATE_TYPE CANDIDATE_PROCEDURAL_PRIMITIVE = 1;
 // back to the user code at interesting events along the ray.
 //
 __target_intrinsic(hlsl, RayQuery)
+__target_intrinsic(glsl, rayQueryEXT)
+__glsl_extension(GL_EXT_ray_query)
+__glsl_version(460)
 struct RayQuery <let rayFlags : RAY_FLAG = RAY_FLAG_NONE>
 {
     // Initialize the query object in a "fresh" state.
@@ -4697,7 +4700,42 @@ struct RayQuery <let rayFlags : RAY_FLAG = RAY_FLAG_NONE>
     // `RayQuery` to get the effective ray flags, which
     // must obey any API-imposed restrictions.
     //
-    void TraceRayInline(RaytracingAccelerationStructure accelerationStructure, RAY_FLAG rayFlags, uint instanceInclusionMask, RayDesc ray);
+    __target_intrinsic(hlsl)
+    void TraceRayInline(
+        RaytracingAccelerationStructure accelerationStructure,
+        RAY_FLAG                        rayFlags,
+        uint                            instanceInclusionMask,
+        RayDesc                         ray);
+
+    __target_intrinsic(glsl, "rayQueryInitializeEXT($0, $1, $2, $3, $4, $5, $6, $7)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
+    void __rayQueryInitializeEXT(
+        RaytracingAccelerationStructure accelerationStructure,
+        RAY_FLAG                        rayFlags,
+        uint                            instanceInclusionMask,
+        float3                          origin,
+        float                           tMin,
+        float3                          direction,
+        float                           tMax);
+
+    [__unsafeForceInlineEarly]
+    __specialized_for_target(glsl)
+    void TraceRayInline(
+        RaytracingAccelerationStructure accelerationStructure,
+        RAY_FLAG                        rayFlags,
+        uint                            instanceInclusionMask,
+        RayDesc                         ray)
+    {
+        __rayQueryInitializeEXT(
+            accelerationStructure,
+            rayFlags,
+            instanceInclusionMask,
+            ray.Origin,
+            ray.TMin,
+            ray.Direction,
+            ray.TMax);
+    }
 
     // Resume the ray query coroutine.
     //
@@ -4713,6 +4751,9 @@ struct RayQuery <let rayFlags : RAY_FLAG = RAY_FLAG_NONE>
     // functions to appropriately handle the closest hit (it any)
     // that was found.
     //
+    __target_intrinsic(glsl, rayQueryProceedEXT)
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     bool Proceed();
 
     // Causes the ray query to terminate.
@@ -4721,6 +4762,9 @@ struct RayQuery <let rayFlags : RAY_FLAG = RAY_FLAG_NONE>
     // traversal has terminated, so that subsequent
     // `Proceed()` calls will return `false`.
     //
+    __target_intrinsic(glsl, rayQueryTerminateEXT)
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     void Abort();
 
     // Get the type of candidate hit being considered.
@@ -4732,73 +4776,210 @@ struct RayQuery <let rayFlags : RAY_FLAG = RAY_FLAG_NONE>
     // the kind of candidate hit that must be resolved by
     // user code.
     //
+    __target_intrinsic(glsl, "rayQueryGetIntersectionTypeEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     CANDIDATE_TYPE CandidateType();
 
     // Access properties of a candidate hit.
-    //
+
+    __target_intrinsic(glsl, "transpose(rayQueryGetIntersectionObjectToWorldEXT($0, false))")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float3x4 CandidateObjectToWorld3x4();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionObjectToWorldEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float4x3 CandidateObjectToWorld4x3();
+
+    __target_intrinsic(glsl, "transpose(rayQueryGetIntersectionWorldToObjectEXT($0, false))")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float3x4 CandidateWorldToObject3x4();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionWorldToObjectEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float4x3 CandidateWorldToObject4x3();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionInstanceCustomIndexEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint CandidateInstanceIndex();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionInstanceIdEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint CandidateInstanceID();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionGeometryIndexEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint CandidateGeometryIndex();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionPrimitiveIndexEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint CandidatePrimitiveIndex();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint CandidateInstanceContributionToHitGroupIndex();
 
     // Access properties of the ray being traced
     // in the object space of a candidate hit.
-    //
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionObjectRayOriginEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float3 CandidateObjectRayOrigin();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionObjectRayDirectionEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float3 CandidateObjectRayDirection();
 
     // Access properties of a candidate procedural primitive hit.
-    //
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionCandidateAABBOpaqueEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     bool CandidateProceduralPrimitiveNonOpaque();
 
-    // Access properties of a candidate no-opaque triangle hit.
-    //
+    // Access properties of a candidate non-opaque triangle hit.
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionFrontFaceEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     bool CandidateTriangleFrontFace();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionBarycentricsEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float2 CandidateTriangleBarycentrics();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionTEXT($0, false)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float CandidateTriangleRayT();
 
     // Commit the current non-opaque triangle hit.
+    __target_intrinsic(glsl, rayQueryConfirmIntersectionEXT)
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     void CommitNonOpaqueTriangleHit();
 
     // Commit the current procedural primitive hit, with hit time `t`.
+    __target_intrinsic(glsl, rayQueryGenerateIntersectionEXT)
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     void CommitProceduralPrimitiveHit(float t);
 
     // Get the status of the committed (closest) hit, if any.
+    __target_intrinsic(glsl, "rayQueryGetIntersectionTypeEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     COMMITTED_STATUS CommittedStatus();
 
     // Access properties of the committed hit.
     //
+    __target_intrinsic(glsl, "transpose(rayQueryGetIntersectionObjectToWorldEXT($0, true))")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float3x4 CommittedObjectToWorld3x4();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionObjectToWorldEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float4x3 CommittedObjectToWorld4x3();
+
+    __target_intrinsic(glsl, "transpose(rayQueryGetIntersectionWorldToObjectEXT($0, true))")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float3x4 CommittedWorldToObject3x4();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionWorldToObjectEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float4x3 CommittedWorldToObject4x3();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionTEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float CommittedRayT();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionInstanceCustomIndexEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint CommittedInstanceIndex();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionInstanceIdEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint CommittedInstanceID();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionGeometryIndexEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint CommittedGeometryIndex();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionPrimitiveIndexEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint CommittedPrimitiveIndex();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint CommittedInstanceContributionToHitGroupIndex();
 
     // Access properties of the ray being traced
     // in the object space of a committed hit.
-    //
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionObjectRayOriginEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float3 CommittedObjectRayOrigin();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionObjectRayDirectionEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float3 CommittedObjectRayDirection();
 
     // Access properties of a committed triangle hit.
-    //
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionFrontFaceEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     bool CommittedTriangleFrontFace();
+
+    __target_intrinsic(glsl, "rayQueryGetIntersectionBarycentricsEXT($0, true)")
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float2 CommittedTriangleBarycentrics();
 
     // Access properties of the ray being traced.
+
+    __target_intrinsic(glsl, rayQueryGetRayFlagsEXT)
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     uint RayFlags();
+
+    __target_intrinsic(glsl, rayQueryGetWorldRayOriginEXT)
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float3 WorldRayOrigin();
+
+    __target_intrinsic(glsl, rayQueryGetWorldRayDirectionEXT)
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float3 WorldRayDirection();
+
+    __target_intrinsic(glsl, rayQueryGetRayTMinEXT)
+    __glsl_extension(GL_EXT_ray_query)
+    __glsl_version(460)
     float RayTMin();
 }