Add Optix Intrinsics Coverage (#8159) (#8310)

Add 29 intrinsics to the list by new test

2 files changed, 298 insertions, 0 deletions

diff --git a/tests/cuda/optix-get-attributes-mixed.slang b/tests/cuda/optix-get-attributes-mixed.slang
new file mode 100644
index 000000000..9892f4138
--- /dev/null
+++ b/tests/cuda/optix-get-attributes-mixed.slang
@@ -0,0 +1,50 @@
+//TEST:SIMPLE(filecheck=CHECK): -target cuda -entry closestHitShader -stage closesthit
+//TEST:SIMPLE(filecheck=CHECK_PTX): -target ptx -entry closestHitShader -stage closesthit
+
+//CHECK: optixGetAttribute_0()
+//CHECK: __int_as_float(optixGetAttribute_1())
+//CHECK: optixGetAttribute_2()
+//CHECK: __int_as_float(optixGetAttribute_3())
+//CHECK: optixGetAttribute_4()
+//CHECK: __int_as_float(optixGetAttribute_5())
+//CHECK: optixGetAttribute_6()
+//CHECK: __int_as_float(optixGetAttribute_7())
+//CHECK_PTX: _optix_get_attribute_0
+//CHECK_PTX: _optix_get_attribute_1
+//CHECK_PTX: _optix_get_attribute_2
+//CHECK_PTX: _optix_get_attribute_3
+//CHECK_PTX: _optix_get_attribute_4
+//CHECK_PTX: _optix_get_attribute_5
+//CHECK_PTX: _optix_get_attribute_6
+//CHECK_PTX: _optix_get_attribute_7
+
+struct CustomIntersectionAttributes
+{
+    uint attr0;   // Will use index 0 - integer
+    float attr1;  // Will use index 1 - float
+    uint attr2;   // Will use index 2 - integer
+    float attr3;  // Will use index 3 - float
+    int attr4;    // Will use index 4 - integer
+    float attr5;  // Will use index 5 - float
+    uint attr6;   // Will use index 6 - integer
+    float attr7;  // Will use index 7 - float
+};
+
+struct RayPayload
+{
+    uint uintValues[4];
+    float floatValues[4];
+};
+
+[shader("closesthit")]
+void closestHitShader(inout RayPayload payload, in CustomIntersectionAttributes attr)
+{
+    payload.uintValues[0] = attr.attr0;   // optixGetAttribute_0()
+    payload.floatValues[0] = attr.attr1;  // __int_as_float(optixGetAttribute_1())
+    payload.uintValues[1] = attr.attr2;   // optixGetAttribute_2()
+    payload.floatValues[1] = attr.attr3;  // __int_as_float(optixGetAttribute_3())
+    payload.uintValues[2] = uint(attr.attr4);  // optixGetAttribute_4()
+    payload.floatValues[2] = attr.attr5;  // __int_as_float(optixGetAttribute_5())
+    payload.uintValues[3] = attr.attr6;   // optixGetAttribute_6()
+    payload.floatValues[3] = attr.attr7;  // __int_as_float(optixGetAttribute_7())
+}
diff --git a/tests/cuda/optix-intrinsics-comprehensive.slang b/tests/cuda/optix-intrinsics-comprehensive.slang
new file mode 100644
index 000000000..26cafd1a5
--- /dev/null
+++ b/tests/cuda/optix-intrinsics-comprehensive.slang
@@ -0,0 +1,248 @@
+//TEST:SIMPLE(filecheck=CHECK): -target cuda
+//TEST:SIMPLE(filecheck=CHECK_PTX): -target ptx
+
+//TEST_INPUT: set scene = AccelerationStructure
+uniform RaytracingAccelerationStructure scene;
+
+// Ray query and geometry intrinsics - order independent
+//CHECK-DAG: optixGetHitKind()
+//CHECK-DAG: optixGetInstanceIndex()
+//CHECK-DAG: optixGetInstanceId()
+//CHECK-DAG: optixGetObjectRayDirection()
+//CHECK-DAG: optixGetObjectRayOrigin()
+//CHECK-DAG: optixGetPrimitiveIndex()
+//CHECK-DAG: optixGetRayFlags()
+//CHECK-DAG: optixGetRayTmin()
+//CHECK-DAG: optixGetWorldRayDirection()
+//CHECK-DAG: optixGetWorldRayOrigin()
+
+// HitObject intrinsics - uses generic templated call, not individual _N functions
+//CHECK-DAG: optixHitObjectGetAttribute<CustomAttributes_0>
+//CHECK-DAG: slangOptixHitObjectIsMiss
+
+// Control flow intrinsics
+//CHECK-DAG: optixTerminateRay
+//CHECK-DAG: optixTraverse
+//CHECK-DAG: optixMakeHitObject
+//CHECK-DAG: optixIgnoreIntersection
+
+// Traditional SBT data access
+//CHECK-DAG: optixGetSbtDataPointer
+
+// PTX intrinsics validation - using actual PTX names (order independent)
+//CHECK_PTX-DAG: _optix_get_hit_kind
+//CHECK_PTX-DAG: _optix_read_instance_idx
+//CHECK_PTX-DAG: _optix_read_instance_id  
+//CHECK_PTX-DAG: _optix_get_object_ray_direction_x
+//CHECK_PTX-DAG: _optix_get_object_ray_origin_x
+//CHECK_PTX-DAG: _optix_read_primitive_idx
+//CHECK_PTX-DAG: _optix_get_ray_flags
+//CHECK_PTX-DAG: _optix_get_ray_tmin
+//CHECK_PTX-DAG: _optix_get_world_ray_direction_x
+//CHECK_PTX-DAG: _optix_get_world_ray_origin_x
+//CHECK_PTX-DAG: _optix_terminate_ray
+//CHECK_PTX-DAG: _optix_ignore_intersection
+//CHECK_PTX-DAG: _optix_hitobject_get_traverse_data
+//CHECK_PTX-DAG: _optix_hitobject_make_with_traverse_data
+//CHECK_PTX-DAG: _optix_get_sbt_data_ptr_64
+
+struct CustomAttributes
+{
+    float attr0;
+    uint attr1;
+    float attr2;
+    uint attr3;
+    float attr4;
+    uint attr5;
+    float attr6;
+    uint attr7;
+};
+
+struct IntrinsicData
+{
+    // Ray geometry data
+    uint hitKind;
+    uint instanceIndex;
+    uint instanceID;
+    uint primitiveIndex;
+    float3 objectRayDirection;
+    float3 objectRayOrigin;
+    float3 worldRayDirection;
+    float3 worldRayOrigin;
+    float rayTmin;
+    uint rayFlags;
+    
+    // HitObject attributes
+    float hitObjAttr0;
+    uint hitObjAttr1;
+    float hitObjAttr2;
+    uint hitObjAttr3;
+    float hitObjAttr4;
+    uint hitObjAttr5;
+    float hitObjAttr6;
+    uint hitObjAttr7;
+    
+    // HitObject state
+    bool isMiss;
+};
+
+struct RayPayload
+{
+    IntrinsicData data;
+    bool shouldTerminate;
+};
+
+// Traditional SBT data structure
+struct TraditionalSbtData
+{
+    float multiplier;
+    uint flags;
+    float3 color;
+};
+
+// Add a separate payload for anyhit shader testing
+struct AnyHitPayload
+{
+    bool terminateRequested;
+    uint hitCount;
+};
+
+[shader("closesthit")]
+void closestHitShader(
+    uniform TraditionalSbtData sbtData,  // This triggers traditional optixGetSbtDataPointer
+    inout RayPayload payload, 
+    in CustomAttributes attr)
+{
+    // Test basic ray query intrinsics using correct HLSL names
+    payload.data.hitKind = HitKind();
+    payload.data.instanceIndex = InstanceIndex();
+    payload.data.instanceID = InstanceID();
+    payload.data.primitiveIndex = PrimitiveIndex();
+    payload.data.objectRayDirection = ObjectRayDirection();
+    payload.data.objectRayOrigin = ObjectRayOrigin();
+    payload.data.worldRayDirection = WorldRayDirection();
+    payload.data.worldRayOrigin = WorldRayOrigin();
+    payload.data.rayTmin = RayTMin();
+    payload.data.rayFlags = RayFlags();
+    
+    // Test HitObject operations (using a NOP HitObject for simplicity)
+    HitObject hitObj = HitObject::MakeNop();
+    
+    // Test HitObject attribute access with the correct API
+    CustomAttributes hitObjAttrs = hitObj.GetAttributes<CustomAttributes>();
+    payload.data.hitObjAttr0 = hitObjAttrs.attr0;
+    payload.data.hitObjAttr1 = hitObjAttrs.attr1;
+    payload.data.hitObjAttr2 = hitObjAttrs.attr2;
+    payload.data.hitObjAttr3 = hitObjAttrs.attr3;
+    payload.data.hitObjAttr4 = hitObjAttrs.attr4;
+    payload.data.hitObjAttr5 = hitObjAttrs.attr5;
+    payload.data.hitObjAttr6 = hitObjAttrs.attr6;
+    payload.data.hitObjAttr7 = hitObjAttrs.attr7;
+    
+    // Test HitObject state queries
+    payload.data.isMiss = hitObj.IsMiss();
+    
+    // Test traditional SBT data access - this should generate optixGetSbtDataPointer
+    payload.data.rayTmin *= sbtData.multiplier;
+    if (sbtData.flags > 0)
+    {
+        payload.data.rayTmin += sbtData.color.x + sbtData.color.y + sbtData.color.z;
+    }
+    
+    // Mark test as completed
+    payload.shouldTerminate = true;
+}
+
+[shader("anyhit")]
+void anyHitShader(inout AnyHitPayload payload, in CustomAttributes attr)
+{
+    // Test anyhit-specific intrinsics
+    uint hitKind = HitKind();
+    uint instanceID = InstanceID();
+    float rayT = RayTCurrent();
+    
+    // Count hits for testing
+    payload.hitCount++;
+    
+    // Test termination based on some criteria
+    if (payload.terminateRequested || payload.hitCount > 3)
+    {
+        // Test optixTerminateRay - only available in anyhit shaders
+        AcceptHitAndEndSearch();  // This maps to optixTerminateRay for CUDA
+    }
+    else
+    {
+        // Test ignoring hit to continue traversal
+        IgnoreHit();
+    }
+}
+
+[shader("miss")]
+void missShader(inout RayPayload payload)
+{
+    // Initialize with miss data
+    payload.data.hitKind = 0;
+    payload.data.instanceIndex = ~0u;
+}
+
+[shader("raygeneration")]
+void rayGenShader()
+{
+    uint2 index = DispatchRaysIndex().xy;
+    
+    RayPayload payload;
+    payload.shouldTerminate = (index.x % 2) == 0;
+    
+    RayDesc ray;
+    ray.Origin = float3(index.x, index.y, 0);
+    ray.Direction = float3(0, 0, 1);
+    ray.TMin = 0.001f;
+    ray.TMax = 1000.0f;
+    
+    // Test optixTrace through HitObject TraceRay
+    HitObject hit = HitObject::TraceRay(
+        scene,
+        RAY_FLAG_NONE,
+        0xFF,
+        0,
+        1, 
+        0,
+        ray,
+        payload.data
+    );
+    
+    // Test optixMakeHitObject and optixHitObjectGetTraverseData
+    // Create a custom hit object with specific parameters
+    CustomAttributes testAttrs;
+    testAttrs.attr0 = 1.0f;
+    testAttrs.attr1 = 42;
+    
+    uint hitGroupRecordIndex = 0;
+    uint instanceIndex = index.x;
+    uint geometryIndex = 0;
+    uint primitiveIndex = index.y;
+    uint hitKind = 0;
+    
+    // Test optixMakeHitObject through HitObject::MakeHit
+    HitObject customHit = HitObject::MakeHit(
+        hitGroupRecordIndex,
+        scene,
+        instanceIndex,
+        geometryIndex,
+        primitiveIndex,
+        hitKind,
+        ray,
+        testAttrs
+    );
+    
+    // Test optixHitObjectGetTraverseData - this should be called internally
+    // by the HitObject operations and generate the optix call
+    bool isValidHit = customHit.IsHit();
+    if (isValidHit)
+    {
+        // Access traverse data indirectly through HitObject queries
+        CustomAttributes retrievedAttrs = customHit.GetAttributes<CustomAttributes>();
+        payload.data.hitObjAttr0 = retrievedAttrs.attr0;
+        payload.data.hitObjAttr1 = retrievedAttrs.attr1;
+    }
+}