Adding Fallback Layer support for Intersection Shaders

Libraries/D3D12RaytracingFallback/developerguide.md

@@ -177,8 +177,8 @@ The use of an AnyHit requires that the traversal code must stop it's current tra
 * #### No Local Root Signature Support for Root Descriptors
 Root descriptors are not currently supported. This is expected to be supported in the future, but it should be noted that these will require the use of `WRAPPED_GPU_POINTER`'s rather then being able to consume a `GPU_VIRTUAL_ADDRESS` directly
 
-* #### No Callable or Intersection shaders
-Both Callable and Intersection shaders are not yet supported. 
+* #### No Callable shaders
+Callable shaders are not yet supported. 
 
 * #### No Cross libs dependencies
 All raytracing shaders are expected to be contained within a single DXIL library.

Libraries/D3D12RaytracingFallback/src/BVHValidator.cpp

@@ -81,7 +81,7 @@ namespace FallbackLayer
 
             BVHOffsets offsets = *(BVHOffsets*)pOutputCpuData;
             AABBNode *pNodeArray = (AABBNode*)((BYTE *)pOutputCpuData + offsets.offsetToBoxes);
-            Triangle *pTriangleArray = (Triangle*)((BYTE *)pOutputCpuData + offsets.offsetToVertices);
+            Primitive *pPrimitiveArray = (Primitive*)((BYTE *)pOutputCpuData + offsets.offsetToVertices);
 
             UINT currentQueue = 0;
             std::deque<AABBNode*> nodeQueue;
@@ -142,7 +142,7 @@ namespace FallbackLayer
 
                     for (UINT triangleId = firstTriangleId; triangleId < firstTriangleId + numTriangles; triangleId++)
                     {
-                        Triangle *pTriangle = &pTriangleArray[triangleId];
+                        Primitive *pTriangle = &pPrimitiveArray[triangleId];
                         for (int j = (int)pExpectedLeafNodes.size() - 1; j >= 0; j--)
                         {
                             if (pExpectedLeafNodes[j]->IsLeafEqual((void *)pTriangle, parentAABB))
@@ -255,7 +255,8 @@ namespace FallbackLayer
 
     bool BvhValidator::TriangleLeafNode::IsLeafEqual(void *pLeafData, const AABB &leafAABB)
     {
-        Triangle *pTriangle = (Triangle *)pLeafData;
+        Primitive *pPrimitive = (Primitive *)pLeafData;
+        Triangle *pTriangle = &pPrimitive->triangle;
         return IsTriangleEqual(*this, pTriangle);
     }
 

Libraries/D3D12RaytracingFallback/src/BottomLevelComputeAABBs.hlsl

@@ -12,18 +12,33 @@
 #include "ConstructAABBBindings.h"
 #include "RayTracingHelper.hlsli"
 
-BoundingBox ComputeLeafAABB(uint triangleIndex, uint offsetToVertices, out uint2 flags)
+BoundingBox ComputeLeafAABB(uint primitiveIndex, uint offsetToPrimitives, out uint2 flags)
 {
-    uint offsetToReadTriangles = offsetToVertices + triangleIndex * SizeOfTriangle;
-    float3 v[NumberOfVerticesPerTriangle];
+    uint offsetToReadPrimitive = offsetToPrimitives + primitiveIndex * SizeOfPrimitive;
+    uint primitiveType = outputBVH.Load(offsetToReadPrimitive);
+    offsetToReadPrimitive += SizeOfUINT32;
 
-    [unroll]
-    for (uint i = 0; i < NumberOfVerticesPerTriangle; i++)
+    if (primitiveType == TRIANGLE_TYPE)
     {
-        v[i] = asfloat(outputBVH.Load3(offsetToReadTriangles + i * SizeOfVertex));
-    }
+        float3 v[NumberOfVerticesPerTriangle];
+        [unroll]
+        for (uint i = 0; i < NumberOfVerticesPerTriangle; i++)
+        {
+            v[i] = asfloat(outputBVH.Load3(offsetToReadPrimitive + i * SizeOfVertex));
+        }
 
-    return GetBoxDataFromTriangle(v[0], v[1], v[2], triangleIndex, flags);
+        return GetBoxDataFromTriangle(v[0], v[1], v[2], primitiveIndex, flags);
+    }
+    else // if(primitiveType == PROCEDURAL_PRIMITIVE_TYPE)
+    {
+        flags.x = primitiveIndex | IsLeafFlag | IsProceduralGeometryFlag;
+        flags.y = 1;
+
+        AABB aabb;
+        aabb.min = asfloat(outputBVH.Load3(offsetToReadPrimitive));
+        aabb.max = asfloat(outputBVH.Load3(offsetToReadPrimitive + 12));
+        return AABBtoBoundingBox(aabb);
+    }
 }
 
 #define BOTTOM_LEVEL 1

Libraries/D3D12RaytracingFallback/src/BottomLevelLoadTriangles.hlsli

@@ -9,7 +9,7 @@
 //
 //*********************************************************
 #define HLSL
-#include "LoadTrianglesBindings.h"
+#include "LoadPrimitivesBindings.h"
 #include "RayTracingHelper.hlsli"
 
 uint3 GetUint32Index3(ByteAddressBuffer IndexBuffer, uint IndexBufferOffset, uint index)
@@ -89,22 +89,22 @@ float3 TransformVertex(float3 v, float3x4 transform)
 void main( uint3 DTid : SV_DispatchThreadID )
 { 
     uint localTriangleIndex = DTid.x;
-    if (localTriangleIndex >= Constants.NumTrianglesBound)
+    if (localTriangleIndex >= Constants.NumPrimitivesBound)
     {
         return;
     }
 
-    uint NumberOfInternalNodes = Constants.TotalTriangleCount - 1;
-    uint NumberOfAABBs = NumberOfInternalNodes + Constants.TotalTriangleCount;
+    uint NumberOfInternalNodes = Constants.TotalPrimitiveCount - 1;
+    uint NumberOfAABBs = NumberOfInternalNodes + Constants.TotalPrimitiveCount;
 
     uint3 indicies = GetIndex(localTriangleIndex);
 
-    uint globalTriangleIndex = localTriangleIndex + Constants.TriangleOffset;
+    uint globalTriangleIndex = localTriangleIndex + Constants.PrimitiveOffset;
 
     Triangle tri;
-    tri.v0 = GetVertex(vertexBuffer, indicies[0], Constants.VertexBufferStride);
-    tri.v1 = GetVertex(vertexBuffer, indicies[1], Constants.VertexBufferStride);
-    tri.v2 = GetVertex(vertexBuffer, indicies[2], Constants.VertexBufferStride);
+    tri.v0 = GetVertex(elementBuffer, indicies[0], Constants.ElementBufferStride);
+    tri.v1 = GetVertex(elementBuffer, indicies[1], Constants.ElementBufferStride);
+    tri.v2 = GetVertex(elementBuffer, indicies[2], Constants.ElementBufferStride);
 
     if (Constants.HasValidTransform)
     {
@@ -120,9 +120,9 @@ void main( uint3 DTid : SV_DispatchThreadID )
         tri.v2 = TransformVertex(tri.v2, transform);
     }
 
-    triangeBuffer[globalTriangleIndex] = tri;
+    PrimitiveBuffer[globalTriangleIndex] = CreateTrianglePrimitive(tri);
 
-    TriangleMetaData metaData;
+    PrimitiveMetaData metaData;
     metaData.GeometryContributionToHitGroupIndex = Constants.GeometryContributionToHitGroupIndex;
     metaData.PrimitiveIndex = localTriangleIndex;
     MetadataBuffer[globalTriangleIndex] = metaData;

Libraries/D3D12RaytracingFallback/src/BottomLevelPrepareForComputeAABBs.hlsl

@@ -12,11 +12,6 @@
 #include "ConstructAABBBindings.h"
 #include "RayTracingHelper.hlsli"
 
-uint GetVertexAddress(int startAddress, uint triangleIndex, uint vertexIndex)
-{
-    return startAddress + triangleIndex * SizeOfTriangle + SizeOfVertex * vertexIndex;
-}
-
 [numthreads(THREAD_GROUP_1D_WIDTH, 1, 1)]
 void main(uint3 DTid : SV_DispatchThreadID)
 {
@@ -44,15 +39,15 @@ void main(uint3 DTid : SV_DispatchThreadID)
     }
 
     uint offsetToBoxes = SizeOfBVHOffsets;
-    uint offsetToTriangles = GetOffsetToTriangles(Constants.NumberOfElements);
-    uint offsetToTriangleMetadata = offsetToTriangles + GetOffsetFromTrianglesToTriangleMetadata(Constants.NumberOfElements);
-    uint totalSize = offsetToTriangleMetadata + Constants.NumberOfElements * SizeOfTriangleMetaData;
+    uint offsetToPrimitives = GetOffsetToPrimitives(Constants.NumberOfElements);
+    uint offsetToPrimitiveMetaData = offsetToPrimitives + GetOffsetFromPrimitivesToPrimitiveMetaData(Constants.NumberOfElements);
+    uint totalSize = offsetToPrimitiveMetaData + Constants.NumberOfElements * SizeOfPrimitiveMetaData;
 
     if (DTid.x == 0)
     {
         outputBVH.Store(OffsetToBoxesOffset, offsetToBoxes);
-        outputBVH.Store(OffsetToVerticesOffset, offsetToTriangles);
-        outputBVH.Store(OffsetToTriangleMetadataOffset, offsetToTriangleMetadata);
+        outputBVH.Store(OffsetToPrimitivesOffset, offsetToPrimitives);
+        outputBVH.Store(OffsetToPrimitiveMetaDataOffset, offsetToPrimitiveMetaData);
         outputBVH.Store(OffsetToTotalSize, totalSize);
     }
 }

Libraries/D3D12RaytracingFallback/src/CalculateMortonCodesForTriangles.hlsl

@@ -12,10 +12,19 @@
 #include "CalculateMortonCodesBindings.h"
 #include "RayTracingHelper.hlsli"
 
-RWStructuredBuffer<Triangle> InputBuffer : UAV_REGISTER(MortonCodeCalculatorInputBufferRegister);
+RWStructuredBuffer<Primitive> InputBuffer : UAV_REGISTER(MortonCodeCalculatorInputBufferRegister);
 
 float3 GetCentroid(uint elementIndex)
 {
-    Triangle tri = InputBuffer[elementIndex];
-    return (tri.v0 + tri.v1 + tri.v2) / 3.0;
+    Primitive primitive = InputBuffer[elementIndex];
+    if(primitive.PrimitiveType == TRIANGLE_TYPE)
+    {
+        Triangle tri = GetTriangle(primitive);
+        return (tri.v0 + tri.v1 + tri.v2) / 3.0;
+    }
+    else //if(primitive.PrimitiveType == PROCEDURAL_PRIMITIVE_TYPE)
+    {
+        AABB aabb = GetProceduralPrimitiveAABB(primitive);
+        return (aabb.min + aabb.max) / 2.0;
+    }
 }

Libraries/D3D12RaytracingFallback/src/CalculateSceneAABBFromTriangles.hlsl

@@ -12,19 +12,35 @@
 #include "CalculateSceneAABBBindings.h"
 #include "RayTracingHelper.hlsli"
 
-RWStructuredBuffer<Triangle> InputBuffer : UAV_REGISTER(SceneAABBCalculatorInputBufferRegister);
+RWStructuredBuffer<Primitive> InputBuffer : UAV_REGISTER(SceneAABBCalculatorInputBufferRegister);
 AABB CalculateSceneAABB(uint baseElementIndex)
 {
-    uint trianglesToRead = min(Constants.NumberOfElements - baseElementIndex, ElementsSummedPerThread);
+    uint primitivesToRead = min(Constants.NumberOfElements - baseElementIndex, ElementsSummedPerThread);
 
     AABB sceneAABB;
     sceneAABB.min = float3(FLT_MAX, FLT_MAX, FLT_MAX);
     sceneAABB.max = float3(-FLT_MAX, -FLT_MAX, -FLT_MAX);
-    for (uint i = 0; i < trianglesToRead; i++)
+    for (uint i = 0; i < primitivesToRead; i++)
     {
-        Triangle tri = InputBuffer[baseElementIndex + i];
-        sceneAABB.min = min(min(min(tri.v0, sceneAABB.min), tri.v1), tri.v2);
-        sceneAABB.max = max(max(max(tri.v0, sceneAABB.max), tri.v1), tri.v2);
+        Primitive primitive = InputBuffer[baseElementIndex + i];
+        switch (primitive.PrimitiveType)
+        {
+            case TRIANGLE_TYPE:
+            {
+                Triangle tri = GetTriangle(primitive);
+                sceneAABB.min = min(min(min(tri.v0, sceneAABB.min), tri.v1), tri.v2);
+                sceneAABB.max = max(max(max(tri.v0, sceneAABB.max), tri.v1), tri.v2);
+                break;
+            }
+            case PROCEDURAL_PRIMITIVE_TYPE:
+            {
+                AABB aabb = GetProceduralPrimitiveAABB(primitive);
+                sceneAABB.min = min(sceneAABB.min, aabb.min);
+                sceneAABB.max = max(sceneAABB.max, aabb.max);
+                break;
+            }
+        }
+
     }
     return sceneAABB;
 }

Libraries/D3D12RaytracingFallback/src/ComputeAABBs.hlsli

@@ -43,7 +43,7 @@ void main(uint3 DTid : SV_DispatchThreadID)
     uint nodeIndex = scratchMemory.Load(threadScratchAddress);
     if (nodeIndex == InvalidNodeIndex) { return; }
 
-    int offsetToVertices = outputBVH.Load(OffsetToVerticesOffset);
+    int offsetToPrimitives = outputBVH.Load(OffsetToPrimitivesOffset);
 
     uint dummyFlag;
     uint nodeAddress = GetBoxAddress(offsetToBoxes, nodeIndex);
@@ -59,7 +59,7 @@ void main(uint3 DTid : SV_DispatchThreadID)
         if (isLeaf)
         {
             uint leafIndex = nodeIndex - NumberOfInternalNodes;
-            boxData = ComputeLeafAABB(leafIndex, offsetToVertices, outputFlag);
+            boxData = ComputeLeafAABB(leafIndex, offsetToPrimitives, outputFlag);
         }
         else
         {