Some ray tracing changes

res/shaders/raytracing/ClosestHit.slang

@@ -0,0 +1,56 @@
+import Common;
+import RayTracingData;
+import VertexData;
+import MaterialParameter;
+import Scene;
+import LightEnv;
+
+// simplification: all BLAS only have 1 geometry
+
+[shader("closesthit")]
+void main(inout payload Payload hitValue, in BuiltInTriangleIntersectionAttributes attr)
+{
+    const float3 barycentricCoords = float3(1.0f - attr.barycentrics.x - attr.barycentrics.y, attr.barycentrics.x, attr.barycentrics.y);
+
+    InstanceData inst = pScene.instances[InstanceID()];
+    MeshData m = pScene.meshData[InstanceID()];
+
+    // offset into the index buffer
+    uint indexOffset = m.firstIndex;
+    // added to indices to reference correct part of global mesh pool
+    uint vertexOffset = pScene.meshletInfos[m.meshletOffset].indicesOffset;
+
+    uint vertexIndex0 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 0];
+    uint vertexIndex1 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 1];
+    uint vertexIndex2 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 2];
+
+    VertexAttributes attr0 = pVertexData.getAttributes(vertexIndex0);
+    VertexAttributes attr1 = pVertexData.getAttributes(vertexIndex1);
+    VertexAttributes attr2 = pVertexData.getAttributes(vertexIndex2);
+
+    FragmentParameter f0 = attr0.getParameter(inst.transformMatrix);
+    FragmentParameter f1 = attr1.getParameter(inst.transformMatrix);
+    FragmentParameter f2 = attr2.getParameter(inst.transformMatrix);
+
+    FragmentParameter params = FragmentParameter.interpolate(f0, f1, f2, barycentricCoords);
+
+    LightingParameter lightingParams = params.getLightingParameter();
+    MaterialParameter materialParams = params.getMaterialParameter();
+	let brdf = Material.prepare(materialParams);
+    
+    float3 result = float3(0, 0, 0);
+    for(int i = 0; i < pLightEnv.numDirectionalLights; ++i)
+    {
+        result += pLightEnv.directionalLights[i].illuminate(lightingParams, brdf);
+    }
+    for(uint i = 0; i < pLightEnv.numPointLights; ++i)
+    {
+        result += pLightEnv.pointLights[i].illuminate(lightingParams, brdf);
+    }
+    result += brdf.evaluateAmbient();
+    // gamma correction
+    result = result / (result + float3(1.0));
+    result = pow(result, float3(1.0/2.2));
+
+    hitValue.color = result;
+}

res/shaders/raytracing/RayGen.slang

@@ -0,0 +1,36 @@
+import Common;
+import RayTracingData;
+
+[shader("raygeneration")]
+void main()
+{
+	const float2 pixelCenter = float2(DispatchRaysIndex().xy) + float2(0.5);
+	const float2 inUV = pixelCenter / float2(DispatchRaysDimensions().xy);
+	float2 d = inUV * 2.0 - 1.0;
+
+	float4 origin = mul(pViewParams.inverseViewMatrix, float4(0, 0, 0, 1));
+	float4 target = mul(pViewParams.inverseProjection, float4(d.x, d.y, 1, 1));
+	float4 direction = mul(pViewParams.inverseViewMatrix, float4(normalize(target.xyz), 0));
+
+	float tmin = 0.0001;
+	float tmax = 10000.0;
+
+	uint max_rays = 24;
+
+    uint object_type = 100;
+    float4 color = float4(0, 0, 0, 0);
+    uint current_mode = 0;
+    float expectedDistance = -1;
+    Payload payload;
+
+    RayDesc desc = {
+        origin.xyz,
+        tmin,
+        direction.xyz,
+        tmax,
+    };
+
+    TraceRay(pRayTracingParams.scene, RAY_FLAG_FORCE_OPAQUE, 0xff, 0, 0, 0, desc, payload);
+
+    pRayTracingParams.image[DispatchRaysIndex().xy] = payload.color;
+}

res/shaders/raytracing/RayTracingData.slang

@@ -0,0 +1,13 @@
+
+struct Payload
+{
+	float3 color;
+};
+
+struct RayTracingParams
+{
+	RaytracingAccelerationStructure scene;
+	RWTexture2D<float3> image;
+    StructuredBuffer<uint> indexBuffer;
+};
+ParameterBlock<RayTracingParams> pRayTracingParams;