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.

6 files changed, 651 insertions, 0 deletions

diff --git a/tests/glsl-intrinsic/raytracing/glsl-rayAnyhit.slang b/tests/glsl-intrinsic/raytracing/glsl-rayAnyhit.slang
new file mode 100644
index 000000000..0ad09d64d
--- /dev/null
+++ b/tests/glsl-intrinsic/raytracing/glsl-rayAnyhit.slang
@@ -0,0 +1,29 @@
+//TEST:SIMPLE(filecheck=CHECK_GLSL): -allow-glsl -stage anyhit -entry main -target glsl
+//TEST:SIMPLE(filecheck=CHECK_SPV): -allow-glsl -emit-spirv-directly -stage anyhit -entry main -target spirv-assembly
+
+layout(binding = 0) uniform accelerationStructureEXT as;
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+buffer MyBlockName
+{
+    uint data[];
+} outputBuffer;
+
+bool testVars() {
+    return true
+// CHECK_GLSL-DAG: gl_HitTEXT
+// CHECK_SPV-DAG: RayTmaxNV
+        && gl_HitTEXT != 99.0f
+// CHECK_GLSL-DAG: gl_HitKindEXT
+// CHECK_SPV-DAG: HitKindNV
+        && gl_HitKindEXT != 0xFFFFFFFF
+        ;    
+}
+
+void main()
+{
+    outputBuffer.data[0] = true
+        && testVars()
+        ;
+    //BUF: 1
+}
diff --git a/tests/glsl-intrinsic/raytracing/glsl-rayCompute.slang b/tests/glsl-intrinsic/raytracing/glsl-rayCompute.slang
new file mode 100644
index 000000000..7d4950271
--- /dev/null
+++ b/tests/glsl-intrinsic/raytracing/glsl-rayCompute.slang
@@ -0,0 +1,106 @@
+//TEST:SIMPLE(filecheck=CHECK_GLSL): -allow-glsl -stage compute -entry computeMain -target glsl
+//TEST:SIMPLE(filecheck=CHECK_SPV): -allow-glsl -emit-spirv-directly -stage compute -entry computeMain -target spirv-assembly
+
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=BUF): -allow-glsl -vk -compute -output-using-type -render-feature ray-query -entry computeMain 
+//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=BUF): -allow-glsl -vk -compute -output-using-type -render-feature ray-query -emit-spirv-directly -entry computeMain 
+
+// note: the referenced input data is in render-test-main kVertexData; 1 triangle at {(0,0,0.5),(0,1,0.5),(1,0,0.5)}
+//TEST_INPUT: set scene = AccelerationStructure
+layout(binding = 0) uniform accelerationStructureEXT scene;
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+buffer MyBlockName
+{
+    uint data[];
+} outputBuffer;
+
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
+bool equals(matrix<T, N, M> lhs, matrix<T, N, M> rhs)
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < M; j++)
+        {
+            if (
+                lhs[i][j] 
+                !=
+                rhs[i][j]
+                )
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool testAbortRayTrace() {
+    rayQueryEXT q;
+    rayQueryInitializeEXT(q, scene, gl_RayFlagsNoneEXT, 0xff, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f);
+    rayQueryTerminateEXT(q);
+
+    return true
+        && rayQueryGetIntersectionTypeEXT(q, true) == gl_RayQueryCommittedIntersectionNoneEXT
+        ;
+}
+
+bool testProceedRayTrace() {
+    rayQueryEXT q;
+    rayQueryInitializeEXT(q, scene, gl_RayFlagsNoneEXT, 0xff, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f);
+    rayQueryProceedEXT(q);
+
+    return true
+        && rayQueryGetIntersectionTypeEXT(q, true) == gl_RayQueryCommittedIntersectionTriangleEXT
+        && rayQueryGetIntersectionTEXT(q, true) == 0.5
+        ;
+}
+
+bool testProceedRayAuxInfo() {
+    rayQueryEXT q;
+    rayQueryInitializeEXT(q, scene, gl_RayFlagsNoneEXT, 0xff, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f);
+    rayQueryProceedEXT(q);
+
+    return true
+        && rayQueryGetRayTMinEXT(q) == 0.01f
+        && rayQueryGetRayFlagsEXT(q) == gl_RayFlagsNoneEXT
+        && rayQueryGetWorldRayOriginEXT(q) == vec3(0.1, 0.1, 0.0)
+        && rayQueryGetWorldRayDirectionEXT(q) == vec3(0, 0, 1)
+        && rayQueryGetIntersectionInstanceCustomIndexEXT(q, true) == 0
+        && rayQueryGetIntersectionInstanceIdEXT(q, true) == 0
+        && rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT(q, true) == 0
+        && rayQueryGetIntersectionGeometryIndexEXT(q, true) == 0
+        && rayQueryGetIntersectionPrimitiveIndexEXT(q, true) == 0
+        && rayQueryGetIntersectionBarycentricsEXT(q, true) == vec2(0.1)
+        && rayQueryGetIntersectionFrontFaceEXT(q, true) == true
+        && rayQueryGetIntersectionCandidateAABBOpaqueEXT(q) == true
+        && rayQueryGetIntersectionObjectRayDirectionEXT(q, true) == vec3(0, 0, 1)
+        && rayQueryGetIntersectionObjectRayOriginEXT(q, true) == vec3(0.1, 0.1, 0.0)
+        && !equals(rayQueryGetIntersectionObjectToWorldEXT(q, true), mat4x3(0)) // some compile error to sort later
+        && !equals(rayQueryGetIntersectionWorldToObjectEXT(q, true), mat4x3(0))
+        ;
+}
+bool testRayTraceGenerate() {
+    rayQueryEXT q;
+    rayQueryInitializeEXT(q, scene, gl_RayFlagsNoneEXT, 0xff, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f);
+    rayQueryGenerateIntersectionEXT(q, 0.5);
+    rayQueryConfirmIntersectionEXT(q);
+
+    return true
+        && rayQueryGetIntersectionTypeEXT(q, true) == gl_RayQueryCommittedIntersectionTriangleEXT
+        ;
+}
+
+// CHECK_GLSL-DAG: main
+// CHECK_SPV-DAG: OpEntryPoint
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void computeMain()
+{
+    outputBuffer.data[0] = true
+        && testAbortRayTrace()
+        //&& testProceedRayTrace()
+        //&& testProceedRayAuxInfo()
+        //&& testRayTraceGenerate()
+        ;
+    // BUF: 1
+}
+
diff --git a/tests/glsl-intrinsic/raytracing/glsl-rayGen.slang b/tests/glsl-intrinsic/raytracing/glsl-rayGen.slang
new file mode 100644
index 000000000..ba4663f12
--- /dev/null
+++ b/tests/glsl-intrinsic/raytracing/glsl-rayGen.slang
@@ -0,0 +1,333 @@
+//TEST:SIMPLE(filecheck=CHECK_GLSL): -allow-glsl -stage raygeneration -entry main -target glsl
+//TEST:SIMPLE(filecheck=CHECK_SPV): -allow-glsl -emit-spirv-directly -stage raygeneration -entry main -target spirv-assembly
+
+layout(binding = 0) uniform accelerationStructureEXT as;
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+buffer MyBlockName
+{
+    uint data[];
+} outputBuffer;
+
+// CHECK_GLSL-DAG: rayPayloadEXT
+// CHECK_SPV-DAG: RayPayloadNV
+layout(location = 2) rayPayloadEXT vec4 payload;
+// CHECK_GLSL-DAG: hitObjectAttributeNV
+// CHECK_SPV-DAG: HitObjectAttributeNV
+layout(location = 2) hitObjectAttributeNV vec4 attrMain;
+// CHECK_GLSL-DAG: callableDataEXT
+// CHECK_SPV-DAG: CallableDataNV
+layout(location = 0) callableDataEXT vec4 outcall;
+
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
+bool equals(matrix<T, N, M> lhs, matrix<T, N, M> rhs)
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < M; j++)
+        {
+            if (
+                lhs[i][j] 
+                !=
+                rhs[i][j]
+                )
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool testHitObjectTraceRay() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectTraceRayNV
+// CHECK_SPV-DAG: OpHitObjectTraceRayNV
+    hitObjectTraceRayNV(hit, as, gl_RayFlagsNoneEXT, 0xff, 0, 0, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 2);
+    return true
+// CHECK_GLSL-DAG: hitObjectIsHitNV
+// CHECK_SPV-DAG: OpHitObjectIsHitNV
+        && hitObjectIsHitNV(hit) == true
+        ;
+}
+
+bool testHitObjectTraceRayWithAuxInfo() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectTraceRayNV
+// CHECK_SPV-DAG: OpHitObjectTraceRayNV
+    hitObjectTraceRayNV(hit, as, gl_RayFlagsNoneEXT, 0xff, 0, 0, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 2);
+// CHECK_GLSL-DAG: hitObjectGetAttributesNV
+// CHECK_SPV-DAG: OpHitObjectGetAttributesNV
+    hitObjectGetAttributesNV(hit, 2);
+    vec4 testCopy = attrMain;
+
+// CHECK_GLSL-DAG: reorderThreadNV
+// CHECK_SPV-DAG: OpReorderThreadWithHintNV
+    reorderThreadNV(0, 3);
+// CHECK_GLSL-DAG: reorderThreadNV
+// CHECK_SPV-DAG: OpReorderThreadWithHitObjectNV
+    reorderThreadNV(hit);
+// CHECK_GLSL-DAG: reorderThreadNV
+// CHECK_SPV-DAG: OpReorderThreadWithHitObjectNV
+    reorderThreadNV(hit, 0, 3);
+
+    return true
+// CHECK_GLSL-DAG: hitObjectGetShaderBindingTableRecordIndexNV
+// CHECK_SPV-DAG: OpHitObjectGetShaderBindingTableRecordIndexNV
+        && hitObjectGetShaderBindingTableRecordIndexNV(hit) == 0
+// CHECK_GLSL-DAG: hitObjectGetShaderRecordBufferHandleNV
+// CHECK_SPV-DAG: OpHitObjectGetShaderRecordBufferHandleNV
+        && hitObjectGetShaderRecordBufferHandleNV(hit) != uvec2(0) // valid Handles are never 0, but not predictable either
+        && testCopy == vec4(1)
+// CHECK_GLSL-DAG: hitObjectIsHitNV
+// CHECK_SPV-DAG: OpHitObjectIsHitNV
+        && hitObjectIsHitNV(hit) == true
+// CHECK_GLSL-DAG: hitObjectGetRayTMinNV
+// CHECK_SPV-DAG: OpHitObjectGetRayTMinNV
+        && hitObjectGetRayTMinNV(hit) == 0.01f
+// CHECK_GLSL-DAG: hitObjectGetRayTMaxNV
+// CHECK_SPV-DAG: OpHitObjectGetRayTMaxNV
+        && hitObjectGetRayTMaxNV(hit) == 1e4f
+// CHECK_GLSL-DAG: hitObjectGetObjectRayOriginNV
+// CHECK_SPV-DAG: OpHitObjectGetObjectRayOriginNV
+        && hitObjectGetObjectRayOriginNV(hit) == vec3(0.1, 0.1, 0.0) 
+// CHECK_GLSL-DAG: hitObjectGetObjectRayDirectionNV
+// CHECK_SPV-DAG: OpHitObjectGetObjectRayDirectionNV
+        && hitObjectGetObjectRayDirectionNV(hit) == vec3(0, 0, 1)
+// CHECK_GLSL-DAG: hitObjectGetWorldRayOriginNV
+// CHECK_SPV-DAG: OpHitObjectGetWorldRayOriginNV
+        && hitObjectGetWorldRayOriginNV(hit) == vec3(0.1, 0.1, 0.0) 
+// CHECK_GLSL-DAG: hitObjectGetWorldRayDirectionNV
+// CHECK_SPV-DAG: OpHitObjectGetWorldRayDirectionNV
+        && hitObjectGetWorldRayDirectionNV(hit) == vec3(0, 0, 1)
+// CHECK_GLSL-DAG: hitObjectGetObjectToWorldNV
+// CHECK_SPV-DAG: OpHitObjectGetObjectToWorldNV
+        && !equals(hitObjectGetObjectToWorldNV(hit), mat4x3(0))
+// CHECK_GLSL-DAG: hitObjectGetWorldToObjectNV
+// CHECK_SPV-DAG: OpHitObjectGetWorldToObjectNV
+        && !equals(hitObjectGetWorldToObjectNV(hit), mat4x3(0))
+// CHECK_GLSL-DAG: hitObjectGetInstanceCustomIndexNV
+// CHECK_SPV-DAG: OpHitObjectGetInstanceCustomIndexNV
+        && hitObjectGetInstanceCustomIndexNV(hit) == 0
+// CHECK_GLSL-DAG: hitObjectGetInstanceIdNV
+// CHECK_SPV-DAG: OpHitObjectGetInstanceIdNV
+        && hitObjectGetInstanceIdNV(hit) == 0
+// CHECK_GLSL-DAG: hitObjectGetGeometryIndexNV
+// CHECK_SPV-DAG: OpHitObjectGetGeometryIndexNV
+        && hitObjectGetGeometryIndexNV(hit) == 0
+// CHECK_GLSL-DAG: hitObjectGetPrimitiveIndexNV
+// CHECK_SPV-DAG: OpHitObjectGetPrimitiveIndexNV
+        && hitObjectGetPrimitiveIndexNV(hit) == 0
+// CHECK_GLSL-DAG: hitObjectGetHitKindNV
+// CHECK_SPV-DAG: OpHitObjectGetHitKindNV
+        && hitObjectGetHitKindNV(hit) == gl_HitKindFrontFacingTriangleEXT
+        ;
+}
+
+bool testHitObjectTraceRayLaunchSubShaders() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectTraceRayNV
+// CHECK_SPV-DAG: OpHitObjectTraceRayNV
+    hitObjectTraceRayNV(hit, as, gl_RayFlagsNoneEXT, 0xff, 0, 0, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 2);
+// CHECK_GLSL-DAG: hitObjectExecuteShaderNV
+// CHECK_SPV-DAG: OpHitObjectExecuteShaderNV
+    hitObjectExecuteShaderNV(hit, 2);
+    return true
+// CHECK_GLSL-DAG: hitObjectIsHitNV
+// CHECK_SPV-DAG: OpHitObjectIsHitNV
+        && hitObjectIsHitNV(hit) == true
+        ;
+}
+
+bool testHitObjectTraceRayMotion() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectTraceRayMotionNV
+// CHECK_SPV-DAG: OpHitObjectTraceRayMotionNV
+    hitObjectTraceRayMotionNV(hit, as, gl_RayFlagsNoneEXT, 0xff, 0, 0, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 0.0f, 2);
+    return true
+// CHECK_GLSL-DAG: hitObjectIsHitNV
+// CHECK_SPV-DAG: OpHitObjectIsHitNV
+        && hitObjectIsHitNV(hit) == true
+// CHECK_GLSL-DAG: hitObjectGetCurrentTimeNV
+// CHECK_SPV-DAG: OpHitObjectGetCurrentTimeNV
+        && hitObjectGetCurrentTimeNV(hit) == 0.0f
+        ;
+}
+
+bool testTraceRayFunctions() {
+// CHECK_GLSL-DAG: traceRayEXT
+// CHECK_SPV-DAG: OpTraceRayKHR
+    traceRayEXT(as, 0, 0, 0, 0, 0, vec3(0), 0, vec3(0), 0, 2);
+    return true
+        ;
+}
+
+bool testTraceRayCalls() {
+    return true
+        && testHitObjectTraceRay()
+        && testHitObjectTraceRayWithAuxInfo()
+        && testHitObjectTraceRayLaunchSubShaders()
+        && testHitObjectTraceRayMotion()
+        && testTraceRayFunctions()
+        ;
+}
+
+bool testHitObjectRecord() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectRecordHitNV
+// CHECK_SPV-DAG: OpHitObjectRecordHitNV
+    hitObjectRecordHitNV(hit, as, 0, 0, 0, gl_HitKindFrontFacingTriangleEXT, 0, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 2);
+    return true
+// CHECK_GLSL-DAG: hitObjectIsHitNV
+// CHECK_SPV-DAG: OpHitObjectIsHitNV
+        && hitObjectIsHitNV(hit) == true
+        ;
+}
+
+bool testHitObjectRecordIndex() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectRecordHitWithIndexNV
+// CHECK_SPV-DAG: OpHitObjectRecordHitWithIndexNV
+    hitObjectRecordHitWithIndexNV(hit, as, 0, 0, 0, gl_HitKindFrontFacingTriangleEXT, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 2);
+    return true
+// CHECK_GLSL-DAG: hitObjectIsHitNV
+// CHECK_SPV-DAG: OpHitObjectIsHitNV
+        && hitObjectIsHitNV(hit) == true
+        ;
+}
+
+bool testHitObjectRecordMotion() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectRecordHitMotionNV
+// CHECK_SPV-DAG: OpHitObjectRecordHitMotionNV
+    hitObjectRecordHitMotionNV(hit, as, 0, 0, 0, gl_HitKindFrontFacingTriangleEXT, 0, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 0.0f, 2);
+    return true
+// CHECK_GLSL-DAG: hitObjectIsHitNV
+// CHECK_SPV-DAG: OpHitObjectIsHitNV
+        && hitObjectIsHitNV(hit) == true
+        ;
+}
+
+bool testHitObjectRecordIndexMotion() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectRecordHitWithIndexMotionNV
+// CHECK_SPV-DAG: OpHitObjectRecordHitWithIndexMotionNV
+    hitObjectRecordHitWithIndexMotionNV(hit, as, 0, 0, 0, gl_HitKindFrontFacingTriangleEXT, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 0.0f, 2);
+    return true
+// CHECK_GLSL-DAG: hitObjectIsHitNV
+// CHECK_SPV-DAG: OpHitObjectIsHitNV
+        && hitObjectIsHitNV(hit) == true
+        ;
+}
+
+bool testRecordHitCalls() {
+    return true
+    && testHitObjectRecord()
+    && testHitObjectRecordIndex()
+    && testHitObjectRecordMotion()
+    && testHitObjectRecordIndexMotion()
+    ;
+}
+
+bool testHitObjectRecordMiss() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectRecordMissNV
+// CHECK_SPV-DAG: OpHitObjectRecordMissNV
+    hitObjectRecordMissNV(hit, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f);
+    return true
+// CHECK_GLSL-DAG: hitObjectIsMissNV
+// CHECK_SPV-DAG: OpHitObjectIsMissNV
+        && hitObjectIsMissNV(hit) == true
+        ;
+}
+
+bool testHitObjectRecordMissMotion() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectRecordMissMotionNV
+// CHECK_SPV-DAG: OpHitObjectRecordMissMotionNV
+    hitObjectRecordMissMotionNV(hit, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 0.0f);
+    return true
+// CHECK_GLSL-DAG: hitObjectIsMissNV
+// CHECK_SPV-DAG: OpHitObjectIsMissNV
+        && hitObjectIsMissNV(hit) == true
+        ;
+}
+
+bool testRecordMissCalls() {
+    return true
+    && testHitObjectRecordMiss()
+    && testHitObjectRecordMissMotion()
+    ;
+}
+
+bool testHitObjectRecordEmpty() {
+    hitObjectNV hit;
+// CHECK_GLSL-DAG: hitObjectRecordEmptyNV
+// CHECK_SPV-DAG: OpHitObjectRecordEmptyNV
+    hitObjectRecordEmptyNV(hit);
+    return true
+// CHECK_GLSL-DAG: hitObjectIsEmptyNV
+// CHECK_SPV-DAG: OpHitObjectIsEmptyNV
+        && hitObjectIsEmptyNV(hit) == true
+        ;
+}
+
+bool testRecordEmptyCalls() {
+    return true
+    && testHitObjectRecordEmpty()
+    ;
+}
+
+bool testTraceRayMotion() {
+// CHECK_GLSL-DAG: traceRayMotionNV
+// CHECK_SPV-DAG: OpTraceRayMotionNV
+    traceRayMotionNV(as, gl_RayFlagsNoneEXT, 0xff, 0, 0, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 0.0f, 2);
+    attrMain = vec4(1); //ensure traceRayMotionNV does not get optimized out 
+    return true &&
+        attrMain == vec4(1)
+        ;       
+}
+
+bool testPayloadReadWrite() {
+    payload = vec4(2);
+    vec4 read = payload;
+    return true
+        && read != vec4(0)
+        ;
+}
+
+bool testAttributeReadWrite() {
+    attrMain = vec4(2);
+    vec4 read = attrMain;
+    return true
+        && read != vec4(0)
+        ;
+}
+
+bool testCallableReadWrite() {
+    outcall = vec4(2);
+    vec4 read = outcall;
+    return true
+        && read != vec4(0)
+        ;
+}
+
+bool testReadWriteOfObjects(){
+    return true
+        && testPayloadReadWrite()
+        && testAttributeReadWrite()
+        && testCallableReadWrite();
+        ;       
+}
+
+void main()
+{
+    outputBuffer.data[0] = true
+        && testTraceRayCalls()
+        && testRecordHitCalls()
+        && testRecordMissCalls()
+        && testRecordEmptyCalls()
+        && testTraceRayMotion()
+        && testReadWriteOfObjects();    
+    //BUF: 1
+}
diff --git a/tests/glsl-intrinsic/raytracing/glsl-rayGenSimple.slang b/tests/glsl-intrinsic/raytracing/glsl-rayGenSimple.slang
new file mode 100644
index 000000000..444384f52
--- /dev/null
+++ b/tests/glsl-intrinsic/raytracing/glsl-rayGenSimple.slang
@@ -0,0 +1,34 @@
+//TEST:SIMPLE(filecheck=CHECK_GLSL): -allow-glsl -stage raygeneration -entry main -target glsl
+//TEST:SIMPLE(filecheck=CHECK_SPV): -allow-glsl -emit-spirv-directly -stage raygeneration -entry main -target spirv-assembly
+
+// CHECK_GLSL-DAG: hitObjectAttributeNV
+// CHECK_SPV-DAG: HitObjectAttributeNV
+
+layout(binding = 0) uniform accelerationStructureEXT as;
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+buffer MyBlockName
+{
+    uint data[];
+} outputBuffer;
+
+layout(location = 2) hitObjectAttributeNV vec4 attrMain;
+
+bool testHitObjectRecord() {
+    hitObjectNV hit;
+    // CHECK_GLSL: hitObjectRecordHitNV
+    // CHECK_SPV: OpHitObjectRecordHitNV
+    hitObjectRecordHitNV(hit, as, 0, 0, 0, gl_HitKindFrontFacingTriangleEXT, 0, 0, vec3(0.1, 0.1, 0.0), 0.01f, vec3(0, 0, 1), 1e4f, 2);
+    return true
+           // CHECK_GLSL: hitObjectIsHitNV
+           // CHECK_SPV: OpHitObjectIsHitNV
+           && hitObjectIsHitNV(hit) == true
+        ;
+}
+
+void main()
+{
+    outputBuffer.data[0] = true
+        && testHitObjectRecord();
+    //BUF: 1
+}
diff --git a/tests/glsl-intrinsic/raytracing/glsl-rayIntersection.slang b/tests/glsl-intrinsic/raytracing/glsl-rayIntersection.slang
new file mode 100644
index 000000000..92549e2d7
--- /dev/null
+++ b/tests/glsl-intrinsic/raytracing/glsl-rayIntersection.slang
@@ -0,0 +1,87 @@
+//TEST:SIMPLE(filecheck=CHECK_GLSL): -stage intersection -entry main -target glsl -allow-glsl 
+//TEST:SIMPLE(filecheck=CHECK_SPV): -stage intersection -entry main -target spirv-assembly -emit-spirv-directly -allow-glsl 
+
+layout(binding = 0) uniform accelerationStructureEXT as;
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+buffer MyBlockName
+{ 
+    uint data[];
+} outputBuffer;
+
+//CHECK_GLSL-DAG: hitAttributeEXT
+//CHECK_SPV-DAG: HitAttributeNV
+hitAttributeEXT vec4 hitAttr;
+
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
+bool equals(matrix<T, N, M> lhs, matrix<T, N, M> rhs)
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < M; j++)
+        {
+            if (
+                lhs[i][j] 
+                !=
+                rhs[i][j]
+                )
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool testVars() {
+    hitAttr = vec4(1);
+    
+    return true
+// CHECK_GLSL-DAG: gl_PrimitiveID
+// CHECK_SPV-DAG: PrimitiveId
+        && gl_PrimitiveID != 10000
+// CHECK_GLSL-DAG: gl_InstanceID
+// CHECK_SPV-DAG: InstanceId
+        && gl_InstanceID != 10000
+// CHECK_GLSL-DAG: gl_InstanceCustomIndexEXT
+// CHECK_SPV-DAG: InstanceCustomIndexNV
+        && gl_InstanceCustomIndexEXT != 10000
+// CHECK_GLSL-DAG: gl_GeometryIndexEXT
+// CHECK_SPV-DAG: RayGeometryIndexKHR
+        && gl_GeometryIndexEXT != 10000
+// CHECK_GLSL-DAG: gl_ObjectRayOriginEXT
+// CHECK_SPV-DAG: ObjectRayOriginNV
+        && gl_ObjectRayOriginEXT != vec3(99)
+// CHECK_GLSL-DAG: gl_ObjectRayDirectionEXT
+// CHECK_SPV-DAG: ObjectRayDirectionNV
+        && gl_ObjectRayDirectionEXT != vec3(99)
+// CHECK_GLSL-DAG: gl_ObjectToWorldEXT
+//COM: CHECK_SPV-DAG: ObjectToWorldNV
+        && !equals(gl_ObjectToWorldEXT, mat4x3(0.0f))
+// CHECK_GLSL-DAG: gl_ObjectToWorld3x4EXT
+//COM: CHECK_SPV-DAG: ObjectToWorldNV
+        && !equals(gl_ObjectToWorld3x4EXT, mat3x4(0.0f))
+// CHECK_GLSL-DAG: gl_WorldToObjectEXT
+// CHECK_SPV-DAG-N: WorldToObjectNV 
+        && !equals(gl_WorldToObjectEXT, mat4x3(0.0f))
+// CHECK_GLSL-DAG: gl_WorldToObject3x4EXT
+// spirv checked with CHECK_SPV-DAG-N
+        && !equals(gl_WorldToObject3x4EXT, mat3x4(0.0f))
+        ;
+}
+
+bool testFunctions() {
+    return true
+// CHECK_GLSL-DAG: reportIntersectionEXT
+// CHECK_SPV-DAG: OpReportIntersectionKHR
+        && reportIntersectionEXT(99, 0);
+}
+
+void main()
+{
+    outputBuffer.data[0] = true
+        && testVars()
+        && testFunctions();
+        ;
+    //BUF: 1
+}
diff --git a/tests/glsl-intrinsic/raytracing/glsl-rayMiss.slang b/tests/glsl-intrinsic/raytracing/glsl-rayMiss.slang
new file mode 100644
index 000000000..714b214e1
--- /dev/null
+++ b/tests/glsl-intrinsic/raytracing/glsl-rayMiss.slang
@@ -0,0 +1,62 @@
+//TEST:SIMPLE(filecheck=CHECK_GLSL): -allow-glsl -stage miss -entry main -target glsl
+//TEST:SIMPLE(filecheck=CHECK_SPV): -allow-glsl -emit-spirv-directly -stage miss -entry main -target spirv-assembly
+
+layout(binding = 0) uniform accelerationStructureEXT as;
+
+//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
+buffer MyBlockName
+{
+    uint data[];
+} outputBuffer;
+
+// CHECK_GLSL-DAG: rayPayloadInEXT
+// CHECK_SPV-DAG: IncomingRayPayloadNV
+layout(location = 2) rayPayloadInEXT vec4 payload;
+// CHECK_GLSL-DAG: hitObjectAttributeNV
+// CHECK_SPV-DAG: HitObjectAttributeNV
+layout(location = 2) hitObjectAttributeNV vec4 attrMain;
+
+bool testVars() {
+    payload = vec4(1);
+    attrMain = vec4(1);
+    return true
+// CHECK_GLSL-DAG: gl_LaunchIDNV
+// CHECK_SPV-DAG-N: LaunchIdNV
+        && gl_LaunchIDNV != uint3(99)
+// CHECK_GLSL-DAG: gl_LaunchIDEXT
+// spirv checked with CHECK_SPV-DAG-N
+        && gl_LaunchIDEXT != uint3(99)
+// CHECK_GLSL-DAG: gl_LaunchSizeNV
+// CHECK_SPV-DAG-N: LaunchSizeNV
+        && gl_LaunchSizeNV != uint3(99)
+// CHECK_GLSL-DAG: gl_LaunchSizeEXT
+// spirv checked with CHECK_SPV-DAG-N
+        && gl_LaunchSizeEXT != uint3(99)
+// CHECK_GLSL-DAG: gl_WorldRayOriginEXT
+// CHECK_SPV-DAG: WorldRayOriginNV
+        && gl_WorldRayOriginEXT != vec3(99)
+// CHECK_GLSL-DAG: gl_WorldRayDirectionEXT
+// CHECK_SPV-DAG: WorldRayDirectionNV
+        && gl_WorldRayDirectionEXT != vec3(99)
+// CHECK_GLSL-DAG: gl_RayTminEXT
+// CHECK_SPV-DAG: RayTminNV
+        && gl_RayTminEXT != 99.0f
+// CHECK_GLSL-DAG: gl_RayTmaxEXT
+// CHECK_SPV-DAG: RayTmaxNV
+        && gl_RayTmaxEXT != 99.0f
+// CHECK_GLSL-DAG: gl_IncomingRayFlagsEXT
+// CHECK_SPV-DAG: IncomingRayFlagsNV
+        && gl_IncomingRayFlagsEXT != 0xFFFFFFFF
+// CHECK_GLSL-DAG: gl_CurrentRayTimeNV
+// CHECK_SPV-DAG: CurrentRayTimeNV
+        && gl_CurrentRayTimeNV != 0.0f
+        ;
+}
+
+void main()
+{
+    outputBuffer.data[0] = true
+        && testVars()
+        ;
+    //BUF: 1
+}