diff options
| -rw-r--r-- | tests/cuda/optix-get-attributes-mixed.slang | 50 | ||||
| -rw-r--r-- | tests/cuda/optix-intrinsics-comprehensive.slang | 248 |
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; + } +} |