Implement raytracing extension(s); resolves #3560 for GLSL & SPIR-V targets (#3675)

The following PR implements raytracing extensions (GLSL_EXT_ray_tracing, GLSL_EXT_ray_query, GLSL_NV_shader_invocation_reorder & GLSL_NV_ray_tracing_motion_blur); for GLSL & SPIR-V targets. Fully implements all functions, built-in variables, & syntax; resolves #3560 for GLSL & SPIR-V Targets.

notes of worth:

* __rayPayloadFromLocation, __rayAttributeFromLocation, and __rayCallableFromLocation, were added as SPIR-V Intrinsics to refer to location's of raytracing objects in SPIR-V for when using GLSL syntax.

1 files changed, 924 insertions, 124 deletions

diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang
index f220a68a5..8df7861ea 100644
--- a/source/slang/hlsl.meta.slang
+++ b/source/slang/hlsl.meta.slang
@@ -9520,6 +9520,7 @@ struct BuiltInTriangleIntersectionAttributes
 // `CallShader()` for GLSL-based targets.
 //
 __target_intrinsic(_GL_EXT_ray_tracing, "executeCallableEXT")
+[require(glsl, raytracing)]
 void __executeCallable(uint shaderIndex, int payloadLocation);
 
 // Next is the custom intrinsic that will compute the payload location
@@ -9535,6 +9536,9 @@ int __callablePayloadLocation(__ref Payload payload);
 // GLSL equivalent.
 //
 __generic<Payload>
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
+[require(hlsl, raytracing)]
 void CallShader(uint shaderIndex, inout Payload payload)
 {
     __target_switch
@@ -9555,7 +9559,8 @@ void CallShader(uint shaderIndex, inout Payload payload)
             static Payload p;
 
             p = payload;
-            spirv_asm {
+            spirv_asm 
+            {
                 OpExecuteCallableKHR $shaderIndex &p
             };
             payload = p;
@@ -9565,7 +9570,9 @@ void CallShader(uint shaderIndex, inout Payload payload)
 
 // 10.3.2
 
+
 __target_intrinsic(_GL_EXT_ray_tracing, "traceRayEXT")
+[require(glsl, raytracing)]
 void __traceRay(
     RaytracingAccelerationStructure AccelerationStructure,
     uint                            RayFlags,
@@ -9590,6 +9597,9 @@ __generic<Payload>
 __intrinsic_op($(kIROp_GetVulkanRayTracingPayloadLocation))
 int __rayPayloadLocation(__ref Payload payload);
 
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
+[require(hlsl, raytracing)]
 __generic<payload_t>
 void TraceRay(
     RaytracingAccelerationStructure AccelerationStructure,
@@ -9635,7 +9645,8 @@ void TraceRay(
         let direction = Ray.Direction;
         let tmin = Ray.TMin;
         let tmax = Ray.TMax;
-        spirv_asm {
+        spirv_asm 
+        {
             OpTraceRayKHR 
                 /**/ $AccelerationStructure
                 /**/ $RayFlags
@@ -9660,10 +9671,9 @@ void TraceRay(
 //
 // https://github.com/KhronosGroup/GLSL/blob/master/extensions/nv/GLSL_NV_ray_tracing_motion_blur.txt
 
-__target_intrinsic(glsl, "traceRayMotionNV")
-__glsl_version(460)
 __glsl_extension(GL_NV_ray_tracing_motion_blur)
-__glsl_extension(GL_EXT_ray_tracing)
+__target_intrinsic(glsl, "traceRayMotionNV")
+[require(glsl, raytracing_motionblur)]
 void __traceMotionRay(
     RaytracingAccelerationStructure AccelerationStructure,
     uint                            RayFlags,
@@ -9678,6 +9688,9 @@ void __traceMotionRay(
     float                           CurrentTime,
     int                             PayloadLocation);
 
+[require(glsl, raytracing_motionblur)]
+[require(spirv, raytracing_motionblur)]
+[require(hlsl, raytracing_motionblur)]
 __generic<payload_t>
 void TraceMotionRay(
     RaytracingAccelerationStructure AccelerationStructure,
@@ -9725,7 +9738,8 @@ void TraceMotionRay(
         let tmax = Ray.TMax;
 
         p = Payload;
-        spirv_asm {
+        spirv_asm 
+        {
             OpCapability RayTracingMotionBlurNV;
             OpExtension "SPV_NV_ray_tracing_motion_blur";
 
@@ -9750,15 +9764,19 @@ void TraceMotionRay(
 
 // 10.3.3
 __target_intrinsic(hlsl)
+[require(hlsl, raytracing)]
 bool ReportHit<A>(float tHit, uint hitKind, A attributes);
 
+[require(spirv, raytracing)]
+[require(glsl, raytracing)]
 bool __reportIntersection(float tHit, uint hitKind)
 {
     __target_switch
     {
     case _GL_EXT_ray_tracing: __intrinsic_asm "reportIntersectionEXT";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$bool = OpReportIntersectionKHR $tHit $hitKind;
         };
     }
@@ -9777,6 +9795,9 @@ bool ReportHit(float tHit, uint hitKind, A attributes)
 }
 
 // 10.3.4
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 void IgnoreHit()
 {
     __target_switch
@@ -9784,11 +9805,18 @@ void IgnoreHit()
     case hlsl: __intrinsic_asm "IgnoreHit";
     case _GL_EXT_ray_tracing: __intrinsic_asm "ignoreIntersectionEXT;";
     case cuda: __intrinsic_asm "optixIgnoreIntersection";
-    case spirv: spirv_asm { OpIgnoreIntersectionKHR; %_ = OpLabel };
+    case spirv: 
+        spirv_asm 
+        { 
+            OpIgnoreIntersectionKHR; %_ = OpLabel 
+        };
     }
 }
 
 // 10.3.5
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 void AcceptHitAndEndSearch()
 {
     __target_switch
@@ -9796,7 +9824,11 @@ void AcceptHitAndEndSearch()
     case hlsl: __intrinsic_asm "AcceptHitAndEndSearch";
     case _GL_EXT_ray_tracing: __intrinsic_asm "terminateRayEXT;";
     case cuda: __intrinsic_asm "optixTerminateRay";
-    case spirv: spirv_asm { OpTerminateRayKHR; %_ = OpLabel };
+    case spirv: 
+        spirv_asm 
+        { 
+            OpTerminateRayKHR; %_ = OpLabel 
+        };
     }
 }
 
@@ -9808,20 +9840,27 @@ void AcceptHitAndEndSearch()
 // 10.4.1 - Ray Dispatch System Values
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 uint3 DispatchRaysIndex()
 {
     __target_switch
     {
-    case hlsl:  __intrinsic_asm "DispatchRaysIndex";
+    case hlsl: __intrinsic_asm "DispatchRaysIndex";
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_LaunchIDEXT)";
     case cuda: __intrinsic_asm "optixGetLaunchIndex";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$uint3 = OpLoad builtin(LaunchIdKHR:uint3);
         };
     }
 }
 
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 uint3 DispatchRaysDimensions()
 {
     __target_switch
@@ -9830,7 +9869,8 @@ uint3 DispatchRaysDimensions()
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_LaunchSizeEXT)";
     case cuda: __intrinsic_asm "optixGetLaunchDimensions";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$uint3 = OpLoad builtin(LaunchSizeKHR:uint3);
         };
     }
@@ -9839,6 +9879,9 @@ uint3 DispatchRaysDimensions()
 // 10.4.2 - Ray System Values
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 float3 WorldRayOrigin()
 {
     __target_switch
@@ -9847,13 +9890,17 @@ float3 WorldRayOrigin()
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_WorldRayOriginEXT)";
     case cuda: __intrinsic_asm "optixGetWorldRayOrigin";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$float3 = OpLoad builtin(WorldRayOriginKHR:float3);
         };
     }
 }
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 float3 WorldRayDirection()
 {
     __target_switch
@@ -9862,13 +9909,17 @@ float3 WorldRayDirection()
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_WorldRayDirectionEXT)";
     case cuda: __intrinsic_asm "optixGetWorldRayDirection";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$float3 = OpLoad builtin(WorldRayDirectionKHR:float3);
         };
     }
 }
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 float RayTMin()
 {
     __target_switch
@@ -9877,7 +9928,8 @@ float RayTMin()
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_RayTminEXT)";
     case cuda: __intrinsic_asm "optixGetRayTmin";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$float = OpLoad builtin(RayTminKHR:float);
         };
     }
@@ -9894,6 +9946,9 @@ float RayTMin()
 // to the appropriate Vulkan stages.
 //
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 float RayTCurrent()
 {
     __target_switch
@@ -9902,12 +9957,16 @@ float RayTCurrent()
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_RayTmaxEXT)";
     case cuda: __intrinsic_asm "optixGetRayTmax";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$float = OpLoad builtin(RayTmaxKHR:float);
         };
     }
 }
 
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 uint RayFlags()
 {
     __target_switch
@@ -9916,7 +9975,8 @@ uint RayFlags()
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_IncomingRayFlagsEXT)";
     case cuda: __intrinsic_asm "optixGetRayFlags";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$uint = OpLoad builtin(IncomingRayFlagsKHR:uint);
         };
     }
@@ -9925,6 +9985,9 @@ uint RayFlags()
 // 10.4.3 - Primitive/Object Space System Values
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 uint InstanceIndex()
 {
     __target_switch
@@ -9933,13 +9996,17 @@ uint InstanceIndex()
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_InstanceID)";
     case cuda: __intrinsic_asm "optixGetInstanceIndex";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$uint = OpLoad builtin(InstanceId:uint);
         };
     }
 }
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 uint InstanceID()
 {
     __target_switch
@@ -9948,28 +10015,36 @@ uint InstanceID()
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_InstanceCustomIndexEXT)";
     case cuda: __intrinsic_asm "optixGetInstanceId";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$uint = OpLoad builtin(InstanceCustomIndexKHR:uint);
         };
     }
 }
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 uint PrimitiveIndex()
 {
     __target_switch
     {
     case hlsl:  __intrinsic_asm "PrimitiveIndex";
-    case _GL_EXT_ray_tracing:  __intrinsic_asm "(gl_PrimitiveID)";
+    case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_PrimitiveID)";
     case cuda: __intrinsic_asm "optixGetPrimitiveIndex";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$uint = OpLoad builtin(PrimitiveId:uint);
         };
     }
 }
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 float3 ObjectRayOrigin()
 {
     __target_switch
@@ -9978,13 +10053,17 @@ float3 ObjectRayOrigin()
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_ObjectRayOriginEXT)";
     case cuda: __intrinsic_asm "optixGetObjectRayOrigin";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$float3 = OpLoad builtin(ObjectRayOriginKHR:float3);
         };
     }
 }
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 float3 ObjectRayDirection()
 {
     __target_switch
@@ -9993,7 +10072,8 @@ float3 ObjectRayDirection()
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_ObjectRayDirectionEXT)";
     case cuda: __intrinsic_asm "optixGetObjectRayDirection";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$float3 = OpLoad builtin(ObjectRayDirectionKHR:float3);
         };
     }
@@ -10002,6 +10082,9 @@ float3 ObjectRayDirection()
 // TODO: optix has an optixGetObjectToWorldTransformMatrix function that returns 12
 // floats by reference.
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 float3x4 ObjectToWorld3x4()
 {
     __target_switch
@@ -10009,7 +10092,8 @@ float3x4 ObjectToWorld3x4()
     case hlsl:  __intrinsic_asm "ObjectToWorld3x4";
     case _GL_EXT_ray_tracing: __intrinsic_asm "transpose(gl_ObjectToWorldEXT)";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             %mat:$$float4x3 = OpLoad builtin(ObjectToWorldKHR:float4x3);
             result:$$float3x4 = OpTranspose %mat;
         };
@@ -10017,6 +10101,9 @@ float3x4 ObjectToWorld3x4()
 }
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 float3x4 WorldToObject3x4()
 {
     __target_switch
@@ -10024,7 +10111,8 @@ float3x4 WorldToObject3x4()
     case hlsl:  __intrinsic_asm "WorldToObject3x4";
     case _GL_EXT_ray_tracing: __intrinsic_asm "transpose(gl_WorldToObjectEXT)";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             %mat:$$float4x3 = OpLoad builtin(WorldToObjectKHR:float4x3);
             result:$$float3x4 = OpTranspose %mat;
         };
@@ -10032,6 +10120,9 @@ float3x4 WorldToObject3x4()
 }
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 float4x3 ObjectToWorld4x3()
 {
     __target_switch
@@ -10039,13 +10130,17 @@ float4x3 ObjectToWorld4x3()
     case hlsl:  __intrinsic_asm "ObjectToWorld4x3";
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_ObjectToWorldEXT)";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$float4x3 = OpLoad builtin(ObjectToWorldKHR:float4x3);
         };
     }
 }
 
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 float4x3 WorldToObject4x3()
 {
     __target_switch
@@ -10053,7 +10148,8 @@ float4x3 WorldToObject4x3()
     case hlsl:  __intrinsic_asm "WorldToObject4x3";
     case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_WorldToObjectEXT)";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$float4x3 = OpLoad builtin(WorldToObjectKHR:float4x3);
         };
     }
@@ -10063,10 +10159,12 @@ float4x3 WorldToObject4x3()
 // The name of the following functions may change when DXR supports
 // a feature similar to the `GL_NV_ray_tracing_motion_blur` extension
 
-__glsl_version(460)
 __glsl_extension(GL_NV_ray_tracing_motion_blur)
 __glsl_extension(GL_EXT_ray_tracing)
 [NonUniformReturn]
+[require(hlsl, raytracing_motionblur)]
+[require(glsl, raytracing_motionblur)]
+[require(spirv, raytracing_motionblur)]
 float RayCurrentTime()
 {
     __target_switch
@@ -10074,7 +10172,8 @@ float RayCurrentTime()
     case hlsl:  __intrinsic_asm "RayCurrentTime";
     case glsl:  __intrinsic_asm "(gl_CurrentRayTimeNV)";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$float = OpLoad builtin(CurrentRayTimeNV:float);
         };
     }
@@ -10094,15 +10193,19 @@ float RayCurrentTime()
 
 // 10.4.4 - Hit Specific System values
 [NonUniformReturn]
+[require(hlsl, raytracing)]
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
 uint HitKind()
 {
     __target_switch
     {
     case hlsl:  __intrinsic_asm "HitKind";
-    case _GL_EXT_ray_tracing:  __intrinsic_asm "(gl_HitKindEXT)";
+    case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_HitKindEXT)";
     case cuda:  __intrinsic_asm "optixGetHitKind";
     case spirv:
-        return spirv_asm {
+        return spirv_asm 
+        {
             result:$$uint = OpLoad builtin(HitKindKHR:uint);
         };
     }
@@ -10291,6 +10394,9 @@ extension __TextureImpl<T,__Shape2D, 1, 0, 0, $(kStdlibResourceAccessFeedback),
 
 // Get the index of the geometry that was hit in an intersection, any-hit, or closest-hit shader
 __glsl_extension(GL_EXT_ray_tracing)
+[require(glsl, raytracing)]
+[require(spirv, raytracing)]
+[require(hlsl, raytracing)]
 [NonUniformReturn]
 uint GeometryIndex()
 {
@@ -10308,7 +10414,8 @@ uint GeometryIndex()
 // https://github.com/KhronosGroup/GLSL/blob/master/extensions/ext/GLSL_EXT_ray_tracing_position_fetch.txt
 __glsl_extension(GL_EXT_ray_tracing)
 __glsl_extension(GL_EXT_ray_tracing_position_fetch)
-__glsl_version(460)
+[require(glsl, raytracing_pos)]
+[require(spirv, raytracing_pos)]
 [ForceInline]
 float3 HitTriangleVertexPosition(uint index)
 {
@@ -10392,8 +10499,9 @@ static const CANDIDATE_TYPE CANDIDATE_PROCEDURAL_PRIMITIVE = 1;
 // In Slang, a parameter like `q` above should be declared `inout`.
 // HLSL does not care about whether `q` is declared `inout` or not.
 //
+//cannot use a cap for struct with unequal target support
+//since it will propegate rules to children
 __glsl_extension(GL_EXT_ray_query)
-__glsl_version(460)
 [__NonCopyableType]
 __intrinsic_type($(kIROp_RayQueryType))
 struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
@@ -10403,10 +10511,11 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
     __intrinsic_op($(kIROp_AllocateOpaqueHandle))
     __init();
 
-    
+
     __target_intrinsic(glsl, "rayQueryInitializeEXT($0, $1, $2, $3, $4, $5, $6, $7)")
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
     [mutating]
     void __rayQueryInitializeEXT(
         RaytracingAccelerationStructure accelerationStructure,
@@ -10439,6 +10548,9 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
     // `RayQuery` to get the effective ray flags, which
     // must obey any API-imposed restrictions.
     //
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__unsafeForceInlineEarly]
     [mutating]
     void TraceRayInline(
@@ -10478,7 +10590,9 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
     // that was found.
     //
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [mutating]
     bool Proceed()
     {
@@ -10500,7 +10614,9 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
     // `Proceed()` calls will return `false`.
     //
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [mutating]
     void Abort()
     {
@@ -10514,7 +10630,9 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
 
     // Commit the current non-opaque triangle hit.
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [mutating]
     void CommitNonOpaqueTriangleHit()
@@ -10529,7 +10647,9 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
 
     // Commit the current procedural primitive hit, with hit time `t`.
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [mutating]
     void CommitProceduralPrimitiveHit(float t)
@@ -10552,7 +10672,9 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
     // user code.
     //
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     CANDIDATE_TYPE CandidateType()
@@ -10571,7 +10693,9 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
 
     // Get the status of the committed (closest) hit, if any.
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     COMMITTED_STATUS CommittedStatus()
@@ -10590,7 +10714,9 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
     }
 
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     bool CandidateProceduralPrimitiveNonOpaque()
@@ -10598,7 +10724,7 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
         __target_switch
         {
         case hlsl: __intrinsic_asm ".CandidateProceduralPrimitiveNonOpaque";
-        case glsl: __intrinsic_asm "(!rayQueryGetIntersectionCandidateAABBOpaqueEXT($0, false))";
+        case glsl: __intrinsic_asm "(!rayQueryGetIntersectionCandidateAABBOpaqueEXT($0))";
         case spirv:
             uint iCandidateOrCommitted = 0;
             return spirv_asm
@@ -10610,7 +10736,9 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
     }
 
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     float CandidateTriangleRayT()
@@ -10628,7 +10756,9 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
         }
     }
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     float CommittedRayT()
@@ -10646,6 +10776,404 @@ struct RayQuery <let rayFlagsGeneric : RAY_FLAG = RAY_FLAG_NONE>
         }
     }
 
+///missing hlsl equivlent; only implemented for glsl & spirv
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    int CandidateRayInstanceCustomIndex()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionInstanceCustomIndexEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$int = OpRayQueryGetIntersectionInstanceCustomIndexKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    int CommittedRayInstanceCustomIndex()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionInstanceCustomIndexEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                result:$$int = OpRayQueryGetIntersectionInstanceCustomIndexKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    int CandidateRayInstanceId()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionInstanceIdEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$int = OpRayQueryGetIntersectionInstanceIdKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    int CommittedRayInstanceId()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionInstanceIdEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                result:$$int = OpRayQueryGetIntersectionInstanceIdKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    uint CandidateRayInstanceShaderBindingTableRecordOffset()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$uint = OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    uint CommittedRayInstanceShaderBindingTableRecordOffset()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                result:$$uint = OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    int CandidateRayGeometryIndex()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionGeometryIndexEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$int = OpRayQueryGetIntersectionGeometryIndexKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    int CommittedRayGeometryIndex()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionGeometryIndexEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                result:$$int = OpRayQueryGetIntersectionGeometryIndexKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    int CandidateRayPrimitiveIndex()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionPrimitiveIndexEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$int = OpRayQueryGetIntersectionPrimitiveIndexKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    int CommittedRayPrimitiveIndex()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionPrimitiveIndexEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                result:$$int = OpRayQueryGetIntersectionPrimitiveIndexKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    float2 CandidateRayBarycentrics()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionBarycentricsEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$float2 = OpRayQueryGetIntersectionBarycentricsKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    float2 CommittedRayBarycentrics()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionBarycentricsEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                result:$$float2 = OpRayQueryGetIntersectionBarycentricsKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    bool CandidateRayFrontFace()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionFrontFaceEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$bool = OpRayQueryGetIntersectionFrontFaceKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    bool CommittedRayFrontFace()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionFrontFaceEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                result:$$bool = OpRayQueryGetIntersectionFrontFaceKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    float3 CandidateRayObjectRayDirection()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionObjectRayDirectionEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$float3 = OpRayQueryGetIntersectionObjectRayDirectionKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    float3 CommittedRayObjectRayDirection()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionObjectRayDirectionEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                result:$$float3 = OpRayQueryGetIntersectionObjectRayDirectionKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    float3 CandidateRayObjectRayOrigin()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionObjectRayOriginEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$float3 = OpRayQueryGetIntersectionObjectRayOriginKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    float3 CommittedRayObjectRayOrigin()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionObjectRayOriginEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                result:$$float3 = OpRayQueryGetIntersectionObjectRayOriginKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    float4x3 CandidateRayObjectToWorld()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionObjectToWorldEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$float4x3 = OpRayQueryGetIntersectionObjectToWorldKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    float4x3 CommittedRayObjectToWorld()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionObjectToWorldEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                result:$$float4x3 = OpRayQueryGetIntersectionObjectToWorldKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    float4x3 CandidateRayWorldToObject()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionWorldToObjectEXT($0, false)";
+        case spirv:
+            uint iCandidateOrCommitted = 0;
+            return spirv_asm
+            {
+                result:$$float4x3 = OpRayQueryGetIntersectionWorldToObjectKHR &this $iCandidateOrCommitted;
+            };
+        }
+    }
+
+    __glsl_extension(GL_EXT_ray_query)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [__NoSideEffect]
+    float4x3 CommittedRayWorldToObject()
+    {
+        __target_switch
+        {
+        case glsl: __intrinsic_asm "rayQueryGetIntersectionWorldToObjectEXT($0, true)";
+        case spirv:
+            uint iCandidateOrCommitted = 1;
+            return spirv_asm
+            {
+                OpRayQueryGetIntersectionWorldToObjectKHR $$float4x3 result &this $iCandidateOrCommitted;
+            };
+        }
+    }
+///~
+
 ${{{{
     const char* kCandidateCommitted[] = {"Candidate", "Committed"};
 
@@ -10658,7 +11186,7 @@ ${{{{
 
     __glsl_extension(GL_EXT_ray_query)
     __glsl_extension(GL_EXT_ray_tracing_position_fetch)
-    __glsl_version(460)
+    [require(glsl, rayquery_pos)]
     [__NoSideEffect]
     void __glslGetIntersectionTriangleVertexPositions$(ccName)(out float3 arr[3])
     {
@@ -10666,8 +11194,8 @@ ${{{{
     };
 
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_extension(GL_EXT_ray_tracing_position_fetch)
-    __glsl_version(460)
+    [require(glsl, rayquery_pos)]
+    [require(spirv, rayquery_pos)]
     [__NoSideEffect]
     float3[3] $(ccName)GetIntersectionTriangleVertexPositions()
     {
@@ -10700,7 +11228,9 @@ ${{{{
     }}}}
 
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     float3x4 $(ccName)$(matName)3x4()
@@ -10711,7 +11241,8 @@ ${{{{
         case hlsl: __intrinsic_asm ".$(ccName)$(matName)3x4";
         case spirv:
             uint iCandidateOrCommitted = $(candidateOrCommitted);
-            return spirv_asm {
+            return spirv_asm 
+            {
                 %m:$$float4x3 = OpRayQueryGetIntersection$(matName)KHR &this $iCandidateOrCommitted;
                 result:$$float3x4 = OpTranspose %m;
             };
@@ -10719,7 +11250,9 @@ ${{{{
     }
 
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__readNone]
     [NonUniformReturn]
     float4x3 $(ccName)$(matName)4x3()
@@ -10730,7 +11263,8 @@ ${{{{
         case hlsl: __intrinsic_asm ".$(ccName)$(matName)4x3";
         case spirv:
             uint iCandidateOrCommitted = $(candidateOrCommitted);
-            return spirv_asm {
+            return spirv_asm 
+            {
                 result:$$float4x3 = OpRayQueryGetIntersection$(matName)KHR &this $iCandidateOrCommitted;
             };
         }
@@ -10761,7 +11295,9 @@ ${{{{
 }}}}
 
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     $(method.type) $(ccName)$(method.hlslName)()
@@ -10772,7 +11308,8 @@ ${{{{
         case glsl: __intrinsic_asm "rayQueryGetIntersection$(method.glslName)EXT($0, $(ccTF))";
         case spirv:
             uint iCandidateOrCommitted = $(candidateOrCommitted);
-            return spirv_asm {
+            return spirv_asm 
+            {
                 result:$$$(method.type) = OpRayQueryGetIntersection$(method.glslName)KHR &this $iCandidateOrCommitted;
             };
         }
@@ -10785,7 +11322,9 @@ ${{{{
     // Access properties of the ray being traced.
 
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     uint RayFlags()
@@ -10795,14 +11334,17 @@ ${{{{
         case hlsl: __intrinsic_asm ".RayFlags";
         case glsl: __intrinsic_asm "rayQueryGetRayFlagsEXT";
         case spirv:
-            return spirv_asm {
+            return spirv_asm 
+            {
                 result:$$uint = OpRayQueryGetRayFlagsKHR &this;
             };
         }
     }
 
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     float3 WorldRayOrigin()
@@ -10812,14 +11354,17 @@ ${{{{
         case hlsl: __intrinsic_asm ".WorldRayOrigin";
         case glsl: __intrinsic_asm "rayQueryGetWorldRayOriginEXT";
         case spirv:
-            return spirv_asm {
+            return spirv_asm 
+            {
                 result:$$float3 = OpRayQueryGetWorldRayOriginKHR &this;
             };
         }
     }
 
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     float3 WorldRayDirection()
@@ -10829,14 +11374,17 @@ ${{{{
         case hlsl: __intrinsic_asm ".WorldRayDirection";
         case glsl: __intrinsic_asm "rayQueryGetWorldRayDirectionEXT";
         case spirv:
-            return spirv_asm {
+            return spirv_asm 
+            {
                 result:$$float3 = OpRayQueryGetWorldRayDirectionKHR &this;
             };
         }
     }
 
     __glsl_extension(GL_EXT_ray_query)
-    __glsl_version(460)
+    [require(glsl, rayquery)]
+    [require(spirv, rayquery)]
+    [require(hlsl, rayquery)]
     [__NoSideEffect]
     [NonUniformReturn]
     float RayTMin()
@@ -10846,7 +11394,8 @@ ${{{{
         case hlsl: __intrinsic_asm ".RayTMin";
         case glsl: __intrinsic_asm "rayQueryGetRayTMinEXT";
         case spirv:
-            return spirv_asm {
+            return spirv_asm 
+            {
                 result:$$float = OpRayQueryGetRayTMinKHR &this;
             };
         }
@@ -10921,7 +11470,6 @@ int __hitObjectAttributesLocation(__ref Attributes attributes);
     /// Immutable data type representing a ray hit or a miss. Can be used to invoke hit or miss shading,
     /// or as a key in ReorderThread. Created by one of several methods described below. HitObject
     /// and its related functions are available in raytracing shader types only.
-[__requiresNVAPI]
 __glsl_extension(GL_NV_shader_invocation_reorder)
 __glsl_extension(GL_EXT_ray_tracing)
 [__NonCopyableType]
@@ -10933,6 +11481,9 @@ struct HitObject
 
         /// Executes ray traversal (including anyhit and intersection shaders) like TraceRay, but returns the
         /// resulting hit information as a HitObject and does not trigger closesthit or miss shaders.
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
     static HitObject TraceRay<payload_t>(
         RaytracingAccelerationStructure AccelerationStructure,
@@ -10998,7 +11549,9 @@ struct HitObject
                 let direction = Ray.Direction;
                 let tmin = Ray.TMin;
                 let tmax = Ray.TMax;
-                spirv_asm {
+                spirv_asm 
+                {
+                    OpExtension "SPV_NV_shader_invocation_reorder";
                     OpCapability ShaderInvocationReorderNV;
                     OpHitObjectTraceRayNV
                         /**/ &__return_val
@@ -11024,6 +11577,9 @@ struct HitObject
         /// Executes motion ray traversal (including anyhit and intersection shaders) like TraceRay, but returns the
         /// resulting hit information as a HitObject and does not trigger closesthit or miss shaders.
     [ForceInline]
+    [require(glsl, ser_motion)]
+    [require(spirv, ser_motion)]
+    [require(hlsl, ser_motion)]
     static HitObject TraceMotionRay<payload_t>( 
         RaytracingAccelerationStructure AccelerationStructure, 
         uint RayFlags, 
@@ -11077,9 +11633,12 @@ struct HitObject
                 let direction = Ray.Direction;
                 let tmin = Ray.TMin;
                 let tmax = Ray.TMax;
-                spirv_asm {
-                    OpCapability RayTracingMotionBlurNV;
+                spirv_asm 
+                {
+                    OpExtension "SPV_NV_shader_invocation_reorder";
+                    OpCapability ShaderInvocationReorderNV;
                     OpExtension "SPV_NV_ray_tracing_motion_blur";
+                    OpCapability RayTracingMotionBlurNV;
                     OpHitObjectTraceRayMotionNV
                         /**/ &__return_val
                         /**/ $AccelerationStructure
@@ -11109,6 +11668,9 @@ struct HitObject
         /// TraceRay. The computed index must reference a valid hit group record in the shader table. The
         /// Attributes parameter must either be an attribute struct, such as
         /// BuiltInTriangleIntersectionAttributes, or another HitObject to copy the attributes from.
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
     static HitObject MakeHit<attr_t>(
         RaytracingAccelerationStructure AccelerationStructure,
@@ -11168,7 +11730,10 @@ struct HitObject
                 let direction = Ray.Direction;
                 let tmin = Ray.TMin;
                 let tmax = Ray.TMax;
-                spirv_asm {
+                spirv_asm 
+                {
+                    OpExtension "SPV_NV_shader_invocation_reorder";
+                    OpCapability ShaderInvocationReorderNV;
                     OpHitObjectRecordHitNV
                         /**/ &__return_val
                         /**/ $AccelerationStructure
@@ -11190,6 +11755,9 @@ struct HitObject
 
         /// See MakeHit but handles Motion 
         /// Currently only supported on VK
+    [require(glsl, ser_motion)]
+    [require(spirv, ser_motion)]
+    [require(hlsl, ser_motion)]
     [ForceInline]
     static HitObject MakeMotionHit<attr_t>( 
         RaytracingAccelerationStructure AccelerationStructure, 
@@ -11238,9 +11806,12 @@ struct HitObject
             let direction = Ray.Direction;
             let tmin = Ray.TMin;
             let tmax = Ray.TMax;
-            spirv_asm {
-                OpCapability RayTracingMotionBlurNV;
+            spirv_asm 
+            {
                 OpExtension "SPV_NV_ray_tracing_motion_blur";
+                OpCapability RayTracingMotionBlurNV;
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 OpHitObjectRecordHitMotionNV
                     /**/ &__return_val
                     /**/ $AccelerationStructure
@@ -11268,6 +11839,9 @@ struct HitObject
         /// reference a valid hit group record in the shader table. The Attributes parameter must either be an
         /// attribute struct, such as BuiltInTriangleIntersectionAttributes, or another HitObject to copy the
         /// attributes from.
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
     static HitObject MakeHit<attr_t>(
         uint HitGroupRecordIndex,
@@ -11301,10 +11875,10 @@ struct HitObject
 
             __glslMakeHitWithIndex(
                 __return_val,
-                AccelerationStructure, 
+                AccelerationStructure,
                 InstanceIndex,              ///? Same as instanceid ?
-                GeometryIndex, 
                 PrimitiveIndex,
+                GeometryIndex,
                 HitKind,                    /// Assuming HitKinds are compatible
                 HitGroupRecordIndex,        /// sbtRecordIndex
                 Ray.Origin,
@@ -11322,7 +11896,10 @@ struct HitObject
             let direction = Ray.Direction;
             let tmin = Ray.TMin;
             let tmax = Ray.TMax;
-            spirv_asm {
+            spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 OpHitObjectRecordHitWithIndexNV
                     /**/ &__return_val
                     /**/ $AccelerationStructure
@@ -11342,7 +11919,8 @@ struct HitObject
     }
         /// See MakeHit but handles Motion 
         /// Currently only supported on VK
-
+    [require(glsl, ser_motion)]
+    [require(spirv, ser_motion)]
     [ForceInline]
     static HitObject MakeMotionHit<attr_t>( 
         uint HitGroupRecordIndex, 
@@ -11364,10 +11942,10 @@ struct HitObject
 
             __glslMakeMotionHitWithIndex(
                 __return_val,
-                AccelerationStructure, 
+                AccelerationStructure,
                 InstanceIndex,              ///? Same as instanceid ?
-                GeometryIndex, 
-                PrimitiveIndex,
+                PrimitiveIndex, 
+                GeometryIndex,
                 HitKind,                    /// Assuming HitKinds are compatible
                 HitGroupRecordIndex,        /// sbtRecordIndex
                 Ray.Origin,
@@ -11386,9 +11964,10 @@ struct HitObject
             let direction = Ray.Direction;
             let tmin = Ray.TMin;
             let tmax = Ray.TMax;
-            spirv_asm {
-                OpCapability RayTracingMotionBlurNV;
+            spirv_asm 
+            {
                 OpExtension "SPV_NV_ray_tracing_motion_blur";
+                OpCapability RayTracingMotionBlurNV;
                 OpHitObjectRecordHitWithIndexMotionNV
                     /**/ &__return_val
                     /**/ $AccelerationStructure
@@ -11412,6 +11991,9 @@ struct HitObject
         /// tracing a ray. The provided shader table index must reference a valid miss record in the shader
         /// table.
     [__requiresNVAPI]
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
     static HitObject MakeMiss( 
         uint MissShaderIndex, 
@@ -11428,7 +12010,10 @@ struct HitObject
                 let direction = Ray.Direction;
                 let tmin = Ray.TMin;
                 let tmax = Ray.TMax;
-                spirv_asm {
+                spirv_asm 
+                {
+                    OpExtension "SPV_NV_shader_invocation_reorder";
+                    OpCapability ShaderInvocationReorderNV;
                     OpHitObjectRecordMissNV
                         /**/ &__return_val
                         /**/ $MissShaderIndex
@@ -11443,8 +12028,10 @@ struct HitObject
 
         /// See MakeMiss but handles Motion 
         /// Currently only supported on VK
+    [require(glsl, ser_motion)]
+    [require(spirv, ser_motion)]
+    [require(hlsl, ser_motion)]
     [ForceInline]
-    __specialized_for_target(glsl)
     static HitObject MakeMotionMiss( 
         uint MissShaderIndex, 
         RayDesc Ray,
@@ -11461,9 +12048,12 @@ struct HitObject
                 let direction = Ray.Direction;
                 let tmin = Ray.TMin;
                 let tmax = Ray.TMax;
-                spirv_asm {
-                    OpCapability RayTracingMotionBlurNV;
+                spirv_asm 
+                {
                     OpExtension "SPV_NV_ray_tracing_motion_blur";
+                    OpCapability RayTracingMotionBlurNV;
+                    OpExtension "SPV_NV_shader_invocation_reorder";
+                    OpCapability ShaderInvocationReorderNV;
                     OpHitObjectRecordMissMotionNV
                         /**/ &__return_val
                         /**/ $MissShaderIndex
@@ -11483,6 +12073,9 @@ struct HitObject
         /// scenarios where future control flow for some threads is known to process neither a hit nor a
         /// miss.
     [__requiresNVAPI]
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
     static HitObject MakeNop()
     {
@@ -11493,7 +12086,10 @@ struct HitObject
         case glsl:
             __glslMakeNop(__return_val);
         case spirv:
-            spirv_asm {
+            spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 OpHitObjectRecordEmptyNV
                     /**/ &__return_val;
             };
@@ -11503,6 +12099,9 @@ struct HitObject
         /// Invokes closesthit or miss shading for the specified hit object. In case of a NOP HitObject, no
         /// shader is invoked.
     [__requiresNVAPI]
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
     static void Invoke<payload_t>(
         RaytracingAccelerationStructure AccelerationStructure,
@@ -11533,7 +12132,10 @@ struct HitObject
                 // Save the payload
                 p = Payload;
 
-                spirv_asm {
+                spirv_asm 
+                {     
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;   
                     OpHitObjectExecuteShaderNV
                         /**/ &HitOrMiss
                         /**/ &p;
@@ -11547,15 +12149,21 @@ struct HitObject
 
         /// Returns true if the HitObject encodes a miss, otherwise returns false.
     [__requiresNVAPI]
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
-    __glsl_extension(GL_EXT_ray_tracing)
     bool IsMiss()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".IsMiss";
         case glsl: __intrinsic_asm "hitObjectIsMissNV($0)";
-        case spirv: return spirv_asm {
+        case spirv:
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$bool = OpHitObjectIsMissNV &this;
             };
         }
@@ -11563,15 +12171,21 @@ struct HitObject
 
         /// Returns true if the HitObject encodes a hit, otherwise returns false.
     [__requiresNVAPI]
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
-    __glsl_extension(GL_EXT_ray_tracing)
     bool IsHit()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".IsHit";
         case glsl: __intrinsic_asm "hitObjectIsHitNV($0)";
-        case spirv: return spirv_asm {
+        case spirv: 
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$bool = OpHitObjectIsHitNV &this;
             };
         }
@@ -11579,15 +12193,21 @@ struct HitObject
 
         /// Returns true if the HitObject encodes a nop, otherwise returns false.
     [__requiresNVAPI]
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
-    __glsl_extension(GL_EXT_ray_tracing)
     bool IsNop()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".IsNop";
         case glsl: __intrinsic_asm "hitObjectIsEmptyNV($0)";
-        case spirv: return spirv_asm {
+        case spirv: 
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$bool = OpHitObjectIsEmptyNV &this;
             };
         }
@@ -11595,8 +12215,10 @@ struct HitObject
 
         /// Queries ray properties from HitObject. Valid if the hit object represents a hit or a miss.
     [__requiresNVAPI]
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
-    __target_intrinsic(hlsl)
     RayDesc GetRayDesc()
     {
         __target_switch
@@ -11609,7 +12231,10 @@ struct HitObject
                 return ray;
             }
         case spirv:
-            return spirv_asm {
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 %origin:$$float3 = OpHitObjectGetWorldRayOriginNV &this;
                 %tmin:$$float = OpHitObjectGetRayTMinNV &this;
                 %direction:$$float3 = OpHitObjectGetWorldRayDirectionNV &this;
@@ -11621,15 +12246,22 @@ struct HitObject
 
         /// Queries shader table index from HitObject. Valid if the hit object represents a hit or a miss.
     [__requiresNVAPI]
-    [ForceInline]
     __glsl_extension(GL_EXT_ray_tracing)
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
+    [ForceInline]
     uint GetShaderTableIndex()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".GetShaderTableIndex";
         case glsl: __intrinsic_asm "hitObjectGetShaderBindingTableRecordIndexNV($0)";
-        case spirv: return spirv_asm {
+        case spirv: 
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$uint = OpHitObjectGetShaderBindingTableRecordIndexNV &this;
             };
         }
@@ -11637,15 +12269,22 @@ struct HitObject
 
         /// Returns the instance index of a hit. Valid if the hit object represents a hit.
     [__requiresNVAPI]
-    [ForceInline]
     __glsl_extension(GL_EXT_ray_tracing)
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
+    [ForceInline]
     uint GetInstanceIndex()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".GetInstanceIndex";
         case glsl: __intrinsic_asm "hitObjectGetInstanceIdNV($0)";
-        case spirv: return spirv_asm {
+        case spirv: 
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$uint = OpHitObjectGetInstanceIdNV &this;
             };
         }
@@ -11653,15 +12292,22 @@ struct HitObject
 
         /// Returns the instance ID of a hit. Valid if the hit object represents a hit.
     [__requiresNVAPI]
-    [ForceInline]
     __glsl_extension(GL_EXT_ray_tracing)
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
+    [ForceInline]
     uint GetInstanceID()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".GetInstanceID";
         case glsl: __intrinsic_asm "hitObjectGetInstanceCustomIndexNV($0)";
-        case spirv: return spirv_asm {
+        case spirv:
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$uint = OpHitObjectGetInstanceCustomIndexNV &this;
             };
         }
@@ -11669,15 +12315,22 @@ struct HitObject
 
         /// Returns the geometry index of a hit. Valid if the hit object represents a hit.
     [__requiresNVAPI]
-    [ForceInline]
     __glsl_extension(GL_EXT_ray_tracing)
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
+    [ForceInline]
     uint GetGeometryIndex()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".GetGeometryIndex";
         case glsl: __intrinsic_asm "hitObjectGetGeometryIndexNV($0)";
-        case spirv: return spirv_asm {
+        case spirv: 
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$uint = OpHitObjectGetGeometryIndexNV &this;
             };
         }
@@ -11685,15 +12338,22 @@ struct HitObject
 
         /// Returns the primitive index of a hit. Valid if the hit object represents a hit.
     [__requiresNVAPI]
-    [ForceInline]
     __glsl_extension(GL_EXT_ray_tracing)
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
+    [ForceInline]
     uint GetPrimitiveIndex()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".GetPrimitiveIndex";
         case glsl: __intrinsic_asm "hitObjectGetPrimitiveIndexNV($0)";
-        case spirv: return spirv_asm {
+        case spirv: 
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$uint = OpHitObjectGetPrimitiveIndexNV &this;
             };
         }
@@ -11701,51 +12361,147 @@ struct HitObject
 
         /// Returns the hit kind. Valid if the hit object represents a hit.
     [__requiresNVAPI]
-    [ForceInline]
     __glsl_extension(GL_EXT_ray_tracing)
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
+    [ForceInline]
     uint GetHitKind()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".GetHitKind";
         case glsl: __intrinsic_asm "hitObjectGetHitKindNV($0)";
-        case spirv: return spirv_asm {
+        case spirv: 
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$uint = OpHitObjectGetHitKindNV &this;
             };
         }
     }
 
     [__requiresNVAPI]
-    [ForceInline]
     __glsl_extension(GL_EXT_ray_tracing)
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
+    [ForceInline]
     float4x3 GetWorldToObject()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".GetWorldToObject";
         case glsl: __intrinsic_asm "hitObjectGetWorldToObjectNV($0)";
-        case spirv: return spirv_asm {
+        case spirv: 
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$float4x3 = OpHitObjectGetWorldToObjectNV &this;
             };
         }
     }
 
     [__requiresNVAPI]
-    [ForceInline]
     __glsl_extension(GL_EXT_ray_tracing)
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
+    [ForceInline]
     float4x3 GetObjectToWorld()
     {
         __target_switch
         {
         case hlsl: __intrinsic_asm ".GetObjectToWorld";
         case glsl: __intrinsic_asm "hitObjectGetObjectToWorldNV($0)";
-        case spirv: return spirv_asm {
+        case spirv: 
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
                 result:$$float4x3 = OpHitObjectGetObjectToWorldNV &this;
             };
         }
     }
 
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [ForceInline]
+    float GetCurrentTime() {
+        __target_switch
+        {
+        case glsl:
+            __intrinsic_asm "hitObjectGetCurrentTimeNV($0)";
+        case spirv:
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
+                result:$$float = OpHitObjectGetCurrentTimeNV &this
+            };
+        }
+    }
+
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [ForceInline]
+    float3 GetObjectRayOrigin() {
+        __target_switch
+        {
+        case glsl:
+            __intrinsic_asm "hitObjectGetObjectRayOriginNV($0)";
+        case spirv:
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
+                result:$$float3 = OpHitObjectGetObjectRayOriginNV &this
+            };
+        }
+    }
+
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [ForceInline]
+    float3 GetObjectRayDirection() {
+        __target_switch
+        {
+        case glsl:
+            __intrinsic_asm "hitObjectGetObjectRayDirectionNV($0)";
+        case spirv:
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
+                result:$$float3 = OpHitObjectGetObjectRayDirectionNV &this
+            };
+        }
+    }
+
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [ForceInline]
+    uint2 GetShaderRecordBufferHandle() {
+        __target_switch
+        {
+        case glsl:
+            __intrinsic_asm "hitObjectGetShaderRecordBufferHandleNV($0)";
+        case spirv:
+            return spirv_asm 
+            {
+                OpExtension "SPV_NV_shader_invocation_reorder";
+                OpCapability ShaderInvocationReorderNV;
+                result:$$uint2 = OpHitObjectGetShaderRecordBufferHandleNV &this
+            };
+        }
+    }
+
     /// Returns the attributes of a hit. Valid if the hit object represents a hit or a miss.
+    [require(glsl, ser)]
+    [require(spirv, ser)]
+    [require(hlsl, ser)]
     [ForceInline]
     attr_t GetAttributes<attr_t>()
     {
@@ -11771,7 +12527,10 @@ struct HitObject
         case spirv:
             {
                 Ptr<attr_t> attr = __allocHitObjectAttributes<attr_t>();
-                spirv_asm {
+                spirv_asm 
+                {
+                    OpExtension "SPV_NV_shader_invocation_reorder";
+                    OpCapability ShaderInvocationReorderNV;
                     OpHitObjectGetAttributesNV &this $attr;
                 };
                 return *attr;
@@ -11782,6 +12541,7 @@ struct HitObject
         /// represents a hit or a miss. RootConstantOffsetInBytes must be a multiple of 4.
     __target_intrinsic(hlsl)
     [__requiresNVAPI]
+    [require(hlsl, ser)]
     uint LoadLocalRootTableConstant(uint RootConstantOffsetInBytes);
 
     /// 
@@ -11790,10 +12550,12 @@ struct HitObject
 
     __target_intrinsic(hlsl, "NvGetAttributesFromHitObject($0, $1)")
     [__requiresNVAPI]
+    [require(hlsl, ser)]
     void __hlslGetAttributesFromHitObject<T>(out T t);
 
     __target_intrinsic(hlsl, "NvMakeHitWithRecordIndex")
     [__requiresNVAPI]
+    [require(hlsl, ser)]
     static void __hlslMakeHitWithRecordIndex<attr_t>(
         uint HitGroupRecordIndex, 
         RaytracingAccelerationStructure AccelerationStructure, 
@@ -11807,6 +12569,7 @@ struct HitObject
 
     __target_intrinsic(hlsl, "NvMakeHit")
     [__requiresNVAPI]
+    [require(hlsl, ser)]
     static void __hlslMakeHit<attr_t>(RaytracingAccelerationStructure AccelerationStructure, 
         uint InstanceIndex, 
         uint GeometryIndex, 
@@ -11820,6 +12583,7 @@ struct HitObject
 
     __target_intrinsic(hlsl, "NvTraceRayHitObject")
     [__requiresNVAPI]
+    [require(hlsl, ser)]
     static void __hlslTraceRay<payload_t>( 
         RaytracingAccelerationStructure AccelerationStructure, 
         uint RayFlags, 
@@ -11837,7 +12601,7 @@ struct HitObject
 
     __glsl_extension(GL_NV_shader_invocation_reorder)
     __glsl_extension(GL_EXT_ray_tracing)
-    __glsl_version(460)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectRecordMissNV")
     static void __glslMakeMiss(
         out HitObject hitObj,
@@ -11850,8 +12614,8 @@ struct HitObject
     // "void hitObjectRecordMissNV(hitObjectNV, uint, vec3, float, vec3, float);"
     __glsl_extension(GL_NV_shader_invocation_reorder)
     __glsl_extension(GL_EXT_ray_tracing)
-    __glsl_extension(GL_NV_ray_tracing_motion_blur)
-    __glsl_version(460)
+    __glsl_extension(GL_NV_ray_tracing_motion_blur)    
+    [require(glsl, ser_motion)]
     __target_intrinsic(glsl, "hitObjectRecordMissMotionNV")
     static void __glslMakeMotionMiss(
         out HitObject hitObj,
@@ -11862,35 +12626,46 @@ struct HitObject
         float TMax, 
         float CurrentTime);
 
-    __glsl_extension(GL_NV_shader_invocation_reorder)
     __glsl_extension(GL_EXT_ray_tracing)
+    __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectRecordEmptyNV")
     static void __glslMakeNop(out HitObject hitObj);
 
+    __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectGetObjectRayDirectionNV($0)")
     float3 __glslGetRayDirection();
-
+    
+    __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectGetWorldRayDirectionNV($0)")
     float3 __glslGetRayWorldDirection();
 
+    __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectGetWorldRayOriginNV($0)")
     float3 __glslGetRayWorldOrigin();
 
+    __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectGetRayTMaxNV($0)")
     float __glslGetTMax();
 
+    __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectGetRayTMinNV($0)")
     float __glslGetTMin();
 
     // "void hitObjectRecordHitWithIndexNV(hitObjectNV, accelerationStructureEXT,int,int,int,uint,uint,vec3,float,vec3,float,int);"
-    __glsl_extension(GL_NV_shader_invocation_reorder)
     __glsl_extension(GL_EXT_ray_tracing)
-    __glsl_version(460)
+    __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectRecordHitWithIndexNV")
     static void __glslMakeHitWithIndex(
         out HitObject hitObj,
@@ -11907,9 +12682,10 @@ struct HitObject
         int attributeLocation);
 
     //  "void hitObjectRecordHitWithIndexMotionNV(hitObjectNV, accelerationStructureEXT,int,int,int,uint,uint,vec3,float,vec3,float,float,int);"
-    __glsl_extension(GL_NV_shader_invocation_reorder)
     __glsl_extension(GL_EXT_ray_tracing)
+    __glsl_extension(GL_NV_shader_invocation_reorder)
     __glsl_extension(GL_NV_ray_tracing_motion_blur)
+    [require(glsl, ser_motion)]
     __target_intrinsic(glsl, "hitObjectRecordHitWithIndexMotionNV")
     static void __glslMakeMotionHitWithIndex(
         out HitObject hitObj,
@@ -11929,6 +12705,7 @@ struct HitObject
     // "void hitObjectRecordHitNV(hitObjectNV,accelerationStructureEXT,int,int,int,uint,uint,uint,vec3,float,vec3,float,int);"
     __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectRecordHitNV")
     static void __glslMakeHit(
         out HitObject hitObj,
@@ -11949,6 +12726,7 @@ struct HitObject
     __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
     __glsl_extension(GL_NV_ray_tracing_motion_blur)
+    [require(glsl, ser_motion)]
     __target_intrinsic(glsl, "hitObjectRecordHitMotionNV")
     static void __glslMakeMotionHit(
         out HitObject hitObj,
@@ -11969,11 +12747,13 @@ struct HitObject
     
     __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectGetAttributesNV($0, $1)")
     void __glslGetAttributes(int attributeLocation);
 
     __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectTraceRayNV")
     static void __glslTraceRay(
         out HitObject hitObject,
@@ -11992,6 +12772,7 @@ struct HitObject
     __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
     __glsl_extension(GL_NV_ray_tracing_motion_blur)
+    [require(glsl, ser_motion)]
     __target_intrinsic(glsl, "hitObjectTraceRayMotionNV")
     static void __glslTraceMotionRay(
         out HitObject hitObject,
@@ -12010,6 +12791,7 @@ struct HitObject
 
     __glsl_extension(GL_EXT_ray_tracing)
     __glsl_extension(GL_NV_shader_invocation_reorder)
+    [require(glsl, ser)]
     __target_intrinsic(glsl, "hitObjectExecuteShaderNV")
     static void __glslInvoke(
         HitObject hitObj,
@@ -12024,8 +12806,11 @@ struct HitObject
     /// Where possible, reordering will also attempt to retain locality in the thread’s launch indices
     /// (DispatchRaysIndex in DXR).
 [__requiresNVAPI]
-__glsl_extension(GL_NV_shader_invocation_reorder)
 __glsl_extension(GL_EXT_ray_tracing)
+__glsl_extension(GL_NV_shader_invocation_reorder)
+[require(glsl, ser)]
+[require(spirv, ser)]
+[require(hlsl, ser)]
 void ReorderThread( uint CoherenceHint, uint NumCoherenceHintBitsFromLSB )
 {
     __target_switch
@@ -12033,9 +12818,10 @@ void ReorderThread( uint CoherenceHint, uint NumCoherenceHintBitsFromLSB )
     case hlsl: __intrinsic_asm "NvReorderThread";
     case glsl: __intrinsic_asm "reorderThreadNV";
     case spirv:
-        spirv_asm {
-            OpCapability ShaderInvocationReorderNV;
+        spirv_asm 
+        {
             OpExtension "SPV_NV_shader_invocation_reorder";
+            OpCapability ShaderInvocationReorderNV;
             OpReorderThreadWithHintNV $CoherenceHint $NumCoherenceHintBitsFromLSB;
         };
     }
@@ -12056,9 +12842,13 @@ void ReorderThread( uint CoherenceHint, uint NumCoherenceHintBitsFromLSB )
     /// same shader ID. (Miss shaders and NOP HitObjects are grouped separately). Within each of these
     /// groups, it will attempt to order threads by the value of their coherence hints. And within ranges
     /// of equal coherence hints, it will attempt to maximize locality in 3D space of the ray hit (if any).
+
 [__requiresNVAPI]
-__glsl_extension(GL_NV_shader_invocation_reorder)
 __glsl_extension(GL_EXT_ray_tracing)
+__glsl_extension(GL_NV_shader_invocation_reorder)
+[require(glsl, ser)]
+[require(spirv, ser)]
+[require(hlsl, ser)]
 void ReorderThread( HitObject HitOrMiss, uint CoherenceHint, uint NumCoherenceHintBitsFromLSB )
 {
     __target_switch
@@ -12066,7 +12856,10 @@ void ReorderThread( HitObject HitOrMiss, uint CoherenceHint, uint NumCoherenceHi
     case hlsl: __intrinsic_asm "NvReorderThread";
     case glsl: __intrinsic_asm "reorderThreadNV";
     case spirv:
-        spirv_asm {
+        spirv_asm 
+        {
+            OpExtension "SPV_NV_shader_invocation_reorder";
+            OpCapability ShaderInvocationReorderNV;
             OpReorderThreadWithHitObjectNV &HitOrMiss $CoherenceHint $NumCoherenceHintBitsFromLSB;
         };
     }
@@ -12077,8 +12870,13 @@ void ReorderThread( HitObject HitOrMiss, uint CoherenceHint, uint NumCoherenceHi
     /// void ReorderThread( HitObject HitOrMiss, uint CoherenceHint, uint NumCoherenceHintBitsFromLSB );
     /// ```
     /// With CoherenceHint and NumCoherenceHintBitsFromLSB as 0, meaning they are ignored.
+
 [__requiresNVAPI]
+__glsl_extension(GL_EXT_ray_tracing)
 __glsl_extension(GL_NV_shader_invocation_reorder)
+[require(glsl, ser)]
+[require(spirv, ser)]
+[require(hlsl, ser)]
 void ReorderThread( HitObject HitOrMiss )
 {
     __target_switch
@@ -12086,13 +12884,15 @@ void ReorderThread( HitObject HitOrMiss )
     case hlsl: __intrinsic_asm "NvReorderThread";
     case glsl: __intrinsic_asm "reorderThreadNV";
     case spirv:
-        spirv_asm {
+        spirv_asm 
+        {
+            OpExtension "SPV_NV_shader_invocation_reorder";
+            OpCapability ShaderInvocationReorderNV;
             OpReorderThreadWithHitObjectNV &HitOrMiss;
         };
     }
 }
 
-
 ///
 /// DebugBreak support 
 ///