Some ray tracing changes

plots.py

@@ -1,6 +1,12 @@
 import pandas as pd
 import matplotlib.pyplot as plt
 
+#areas = pd.read_csv('build/s.csv')
+#
+#plot = areas.hist(column='area', bins=100)
+#plt.yscale('log')
+#plt.show()
+
 df = pd.read_csv('build/stats.csv')
 noculldf = pd.read_csv('build/statsNOCULL.csv')
 
@@ -60,3 +66,16 @@ nocullax.legend()
 
 nocullfig.savefig('allnocull.png')
 
+combfig, combax = plt.subplots()
+
+combax.plot(scaled_reltime, scaled_FrameTime, label='Culling Frametime')
+combax.plot(nocullscaled_reltime, nocullscaled_FrameTime, label='No Culling Frametime')
+
+combax.set_xlabel('Application Time (ms)')
+combax.set_ylabel('Render Times (ms)')
+
+combax.legend()
+
+combfig.savefig('combined.png')
+
+

res/shaders/BasePass.slang

@@ -1,7 +1,6 @@
 import Common;
 import LightEnv;
 import MaterialParameter;
-import MATERIAL_FILE_NAME;
 
 struct LightCullingData
 {
@@ -26,7 +25,7 @@ float4 fragmentMain(in FragmentParameter params) : SV_Target
     {
         result += pLightEnv.directionalLights[i].illuminate(lightingParams, brdf);
     }
-    for(uint i = 0; i < pLightEnv.numPointLights; ++i)
+    for(uint i = 0; i < lightCount; ++i)
     {
         uint lightIndex = pLightCullingData.lightIndexList[startOffset + i];
         result += pLightEnv.pointLights[lightIndex].illuminate(lightingParams, brdf);

res/shaders/lib/MaterialParameter.slang

@@ -49,6 +49,23 @@ struct FragmentParameter
 		return result;
 	}
 #endif
+    static FragmentParameter interpolate(FragmentParameter f0, FragmentParameter f1, FragmentParameter f2, float3 barycentricCoords)
+    {
+        FragmentParameter result;
+        result.position_CS = f0.position_CS * barycentricCoords.x + f1.position_CS * barycentricCoords.y + f2.position_CS * barycentricCoords.z;
+#ifndef POS_ONLY
+	    result.normal_WS = f0.normal_WS * barycentricCoords.x + f1.normal_WS * barycentricCoords.y + f2.normal_WS * barycentricCoords.z;
+	    result.tangent_WS = f0.tangent_WS * barycentricCoords.x + f1.tangent_WS * barycentricCoords.y + f2.tangent_WS * barycentricCoords.z;
+	    result.biTangent_WS = f0.biTangent_WS * barycentricCoords.x + f1.biTangent_WS * barycentricCoords.y + f2.biTangent_WS * barycentricCoords.z;
+	    result.position_WS = f0.position_WS * barycentricCoords.x + f1.position_WS * barycentricCoords.y + f2.position_WS * barycentricCoords.z;
+	    result.vertexColor = f0.vertexColor * barycentricCoords.x + f1.vertexColor * barycentricCoords.y + f2.vertexColor * barycentricCoords.z;
+		for(uint i = 0; i < MAX_TEXCOORDS; ++i)
+        {
+            result.texCoords[i] = f0.texCoords[i] * barycentricCoords.x + f1.texCoords[i] * barycentricCoords.y + f2.texCoords[i] * barycentricCoords.z;
+        }
+#endif
+        return result;
+    }
 };
 
 // data passed to visibility render

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;

src/AssetViewer/main.cpp

@@ -5,58 +5,165 @@
 #include "Asset/MaterialInstanceAsset.h"
 #include "Asset/MeshAsset.h"
 #include "Asset/TextureAsset.h"
+#include <assimp/Exporter.hpp>
+#include <assimp/Importer.hpp>
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
 #include <fstream>
 #include <iostream>
 
-
 using namespace Seele;
 
 AssetRegistry* _instance = new AssetRegistry();
 
 int main(int, char**) {
-    // if(argc < 2)
-    //{
-    //     return -1;
-    // }
-    std::filesystem::path path = std::filesystem::path("C:\\Users\\Dynamitos\\TrackClear\\Assets\\Dirt.asset");
-    std::ifstream stream = std::ifstream(path, std::ios::binary);
+    Assimp::Importer importer;
+    const aiScene* scene =
+        importer.ReadFile("C:\\Users\\Dynamitos\\MeshShadingDemo\\import\\models\\after-the-rain-vr-sound\\source\\WhitechapelSrc.fbx",
+                          (uint32)(aiProcess_FlipUVs | aiProcess_Triangulate | aiProcess_ImproveCacheLocality));
 
-    ArchiveBuffer buffer;
-    buffer.readFromStream(stream);
+    auto interpolate = [](Vector p0, Vector p1, Vector p2) { return (p0 + p1 + p2) / 3.0f; };
+    
+    //std::fstream stats("s.csv");
+    //stats << "area" << std::endl;
+    for (uint32 m = 0; m < scene->mNumMeshes; ++m) {
+        aiMesh* mesh = scene->mMeshes[m];
+        Array<Vector> positions(mesh->mNumVertices);
+        Array<Vector> normals(mesh->mNumVertices);
+        Array<Vector> tangents(mesh->mNumVertices);
+        Array<Vector> biTangents(mesh->mNumVertices);
+        Array<Vector> texCoords(mesh->mNumVertices);
+        Array<Vector> texCoords1(mesh->mNumVertices);
+        if (mesh->HasTextureCoords(2))
+            abort();
+        for (int32 i = 0; i < mesh->mNumVertices; ++i) {
+            positions[i] = Vector(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z);
 
-    // Read asset type
-    uint64 identifier;
-    Serialization::load(buffer, identifier);
+            if (mesh->mTextureCoords[0] != nullptr)
+                texCoords[i] = Vector(mesh->mTextureCoords[0][i].x, mesh->mTextureCoords[0][i].y, 0);
 
-    // Read name
-    std::string name;
-    Serialization::load(buffer, name);
+            if (mesh->mTextureCoords[1] != nullptr)
+                texCoords1[i] = Vector(mesh->mTextureCoords[1][i].x, mesh->mTextureCoords[1][i].y, 0);
 
-    // Read folder
-    std::string folderPath;
-    Serialization::load(buffer, folderPath);
+            if (mesh->mNormals != nullptr)
+                normals[i] = Vector(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z);
 
-    PAsset asset;
-    switch (identifier) {
-    case TextureAsset::IDENTIFIER:
-        asset = new TextureAsset(folderPath, name);
-        break;
-    case MeshAsset::IDENTIFIER:
-        asset = new MeshAsset(folderPath, name);
-        break;
-    case MaterialAsset::IDENTIFIER:
-        asset = new MaterialAsset(folderPath, name);
-        break;
-    case MaterialInstanceAsset::IDENTIFIER:
-        asset = new MaterialInstanceAsset(folderPath, name);
-        // TODO
-        break;
-    case FontAsset::IDENTIFIER:
-        asset = new FontAsset(folderPath, name);
-        break;
-    default:
-        throw new std::logic_error("Unknown Identifier");
+            if (mesh->mTangents != nullptr)
+                tangents[i] = Vector(mesh->mTangents[i].x, mesh->mTangents[i].y, mesh->mTangents[i].z);
+
+            if (mesh->mBitangents != nullptr)
+                biTangents[i] = Vector(mesh->mBitangents[i].x, mesh->mBitangents[i].y, mesh->mBitangents[i].z);
+        }
+
+        struct Tri {
+            uint32 p[3];
+        };
+        auto calcArea = [&positions](Tri t) {
+            Vector p1 = positions[t.p[0]];
+            Vector p2 = positions[t.p[1]];
+            Vector p3 = positions[t.p[2]];
+            return 0.5 * glm::length(glm::cross(p2 - p1, p3 - p1));
+        };
+        Array<Tri> tris(mesh->mNumFaces);
+        for (int32 faceIndex = 0; faceIndex < mesh->mNumFaces; ++faceIndex) {
+            tris[faceIndex].p[0] = mesh->mFaces[faceIndex].mIndices[0];
+            tris[faceIndex].p[1] = mesh->mFaces[faceIndex].mIndices[1];
+            tris[faceIndex].p[2] = mesh->mFaces[faceIndex].mIndices[2];
+        }
+        auto tesselate = [&](uint32 i) {
+            uint32 p0 = tris[i].p[0];
+            uint32 p1 = tris[i].p[1];
+            uint32 p2 = tris[i].p[2];
+            uint32 p3 = positions.size();
+            positions.add(interpolate(positions[p0], positions[p1], positions[p2]));
+
+            if (mesh->mTextureCoords[0] != nullptr)
+                texCoords.add(interpolate(texCoords[p0], texCoords[p1], texCoords[p2]));
+
+            if (mesh->mTextureCoords[1] != nullptr)
+                texCoords1.add(interpolate(texCoords1[p0], texCoords1[p1], texCoords1[p2]));
+
+            if (mesh->mNormals != nullptr)
+                normals.add(interpolate(normals[p0], normals[p1], normals[p2]));
+
+            if (mesh->mTangents != nullptr)
+                tangents.add(interpolate(tangents[p0], tangents[p1], tangents[p2]));
+
+            if (mesh->mBitangents != nullptr)
+                biTangents.add(interpolate(biTangents[p0], biTangents[p1], biTangents[p2]));
+
+            tris[i].p[2] = p3;
+
+            tris.add(Tri{p1, p2, p3});
+
+            tris.add(Tri{p2, p0, p3});
+        };
+        
+        //for (uint32 i = 0; i < tris.size(); ++i) {
+        //    stats << calcArea(tris[i]) << std::endl;
+        //}
+        bool tess = false;
+        while (!tess) {
+            tess = true;
+            for (uint32 i = 0; i < tris.size(); ++i) {
+                if (calcArea(tris[i]) > 100.f) {
+                    tesselate(i);
+                    tess = false;
+                }
+            }
+        }
+
+        aiVector3D* newPos = new aiVector3D[positions.size()];
+        std::memcpy(newPos, positions.data(), positions.size() * sizeof(Vector));
+
+        if (mesh->mTextureCoords[0] != nullptr) {
+            aiVector3D* newTex = new aiVector3D[texCoords.size()];
+            std::memcpy(newTex, texCoords.data(), texCoords.size() * sizeof(Vector));
+            mesh->mTextureCoords[0] = newTex;
+        }
+
+        if (mesh->mTextureCoords[1] != nullptr) {
+            aiVector3D* newTex = new aiVector3D[texCoords1.size()];
+            std::memcpy(newTex, texCoords1.data(), texCoords1.size() * sizeof(Vector));
+            mesh->mTextureCoords[1] = newTex;
+        }
+        if (mesh->mNormals != nullptr) {
+            aiVector3D* newNor = new aiVector3D[normals.size()];
+            std::memcpy(newNor, normals.data(), normals.size() * sizeof(Vector));
+            mesh->mNormals = newNor;
+        }
+        if (mesh->mTangents != nullptr) {
+            aiVector3D* newTan = new aiVector3D[tangents.size()];
+            std::memcpy(newTan, tangents.data(), tangents.size() * sizeof(Vector));
+            mesh->mTangents = newTan;
+        }
+        if (mesh->mBitangents != nullptr) {
+            aiVector3D* newBit = new aiVector3D[biTangents.size()];
+            std::memcpy(newBit, biTangents.data(), biTangents.size() * sizeof(Vector));
+            mesh->mBitangents = newBit;
+        }
+
+        uint32 numFaces = tris.size();
+        aiFace* newFaces = new aiFace[numFaces];
+        for (uint32 i = 0; i < numFaces; ++i) {
+            newFaces[i].mNumIndices = 3;
+            newFaces[i].mIndices = new uint32[3];
+            newFaces[i].mIndices[0] = tris[i].p[0];
+            newFaces[i].mIndices[1] = tris[i].p[1];
+            newFaces[i].mIndices[2] = tris[i].p[2];
+        }
+
+        mesh->mNumVertices = positions.size();
+        mesh->mVertices = newPos;
+        mesh->mFaces = newFaces;
+        mesh->mNumFaces = tris.size();
+    }
+
+    Assimp::Exporter exporter;
+    exporter.Export(scene, "fbx",
+                    "C:\\Users\\Dynamitos\\MeshShadingDemo\\import\\models\\after-the-rain-vr-sound\\source\\Whitechapel.fbx");
+    for (uint32 i = 0; i < exporter.GetExportFormatCount(); ++i) {
+        auto desc = exporter.GetExportFormatDescription(i);
+        std::cout << desc->description << " " << desc->fileExtension << " " << desc->id << " " << std::endl;
     }
-    asset->load(buffer);
-    std::cin.get();
 }

src/Benchmark/PlayView.cpp

@@ -1,7 +1,7 @@
 #include "PlayView.h"
 #include "Window/Window.h"
-#include <fstream>
 #include <fmt/format.h>
+#include <fstream>
 
 using namespace Seele;
 
@@ -38,11 +38,17 @@ PlayView::PlayView(Gfx::PGraphics graphics, PWindow window, const ViewportCreate
             if (start == 0) {
                 start = timestamps[0].time;
             }
-            stats << timestamps[0].time - start << "," << cachedResults << depthResults << baseResults << lightCullResults
-                  << visiblityResults << timestamps[1].time - timestamps[0].time << "," << timestamps[2].time - timestamps[1].time << ","
-                  << timestamps[3].time - timestamps[2].time << "," << timestamps[4].time - timestamps[3].time << ","
-                  << timestamps[5].time - timestamps[4].time << "," << timestamps[6].time - timestamps[5].time << ","
-                  << timestamps[6].time - timestamps[0].time << std::endl;
+            uint64 t0 = timestamps[0].time;
+            uint64 t1 = timestamps[1].time;
+            uint64 t2 = timestamps[2].time;
+            uint64 t3 = timestamps[3].time;
+            uint64 t4 = timestamps[4].time;
+            uint64 t5 = timestamps[5].time;
+            uint64 t6 = timestamps[6].time;
+            if (t1 < t0 || t2 < t1 || t3 < t2 || t4 < t3 || t5 < t4 || t6 < t5)
+                continue;
+            stats << t0 - start << "," << cachedResults << depthResults << baseResults << lightCullResults << visiblityResults << t1 - t0
+                  << "," << t2 - t1 << "," << t3 - t2 << "," << t4 - t3 << "," << t5 - t4 << "," << t6 - t5 << "," << t6 - t0 << std::endl;
             stats.flush();
         }
     });

src/Benchmark/main.cpp

@@ -23,7 +23,7 @@ int main(int argc, char** argv) {
         useDepthCulling = false;
     }
 
-    std::filesystem::path binaryPath = "MeshShadingDemo.dll";
+    std::filesystem::path binaryPath = "C:/Users/Dynamitos/MeshShadingDemo/bin/MeshShadingDemo.dll";
     graphics = new Vulkan::Graphics();
     GraphicsInitializer initializer;
     graphics->init(initializer);
@@ -31,7 +31,7 @@ int main(int argc, char** argv) {
     vd->init(graphics);
 
     OWindowManager windowManager = new WindowManager();
-    AssetRegistry::init("Assets", graphics);
+    AssetRegistry::init("C:/Users/Dynamitos/MeshShadingDemo/Assets", graphics);
     vd->commitMeshes();
     WindowCreateInfo mainWindowInfo = {
         .width = 1920,

src/Editor/Asset/MeshLoader.cpp

@@ -416,7 +416,7 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
         uint64 offset = vertexData->getMeshOffset(id);
         collider.boundingbox.adjust(Vector(mesh->mAABB.mMin.x, mesh->mAABB.mMin.y, mesh->mAABB.mMin.z));
         collider.boundingbox.adjust(Vector(mesh->mAABB.mMax.x, mesh->mAABB.mMax.y, mesh->mAABB.mMax.z));
-        work.add([=, &globalMeshes]() {
+        work.add([=, this, &globalMeshes]() {
             // assume static mesh for now
             Array<Vector4> positions(mesh->mNumVertices);
             StaticArray<Array<Vector2>, MAX_TEXCOORDS> texCoords;
@@ -462,7 +462,7 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
             vertexData->loadColors(offset, colors);
 
             Array<uint32> indices(mesh->mNumFaces * 3);
-            for (int32 faceIndex = 0; faceIndex < mesh->mNumFaces; ++faceIndex) {
+            for (uint32 faceIndex = 0; faceIndex < mesh->mNumFaces; ++faceIndex) {
                 indices[faceIndex * 3 + 0] = mesh->mFaces[faceIndex].mIndices[0];
                 indices[faceIndex * 3 + 1] = mesh->mFaces[faceIndex].mIndices[1];
                 indices[faceIndex * 3 + 2] = mesh->mFaces[faceIndex].mIndices[2];
@@ -481,7 +481,10 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
             globalMeshes[meshIndex]->meshlets = std::move(meshlets);
             globalMeshes[meshIndex]->indices = std::move(indices);
             globalMeshes[meshIndex]->vertexCount = mesh->mNumVertices;
+            globalMeshes[meshIndex]->blas = graphics->createBottomLevelAccelerationStructure(Gfx::BottomLevelASCreateInfo{
+                .mesh = globalMeshes[meshIndex],
             });
+        });
     }
     getThreadPool().runAndWait(std::move(work));
 }

src/Editor/Asset/TextureLoader.cpp

@@ -125,12 +125,12 @@ void TextureLoader::import(TextureImportArgs args, PTextureAsset textureAsset) {
         .structSize = sizeof(ktxBasisParams),
         .uastc = true,
         .threadCount = std::thread::hardware_concurrency() - 2,
-        .uastcFlags = KTX_PACK_UASTC_LEVEL_SLOWER,
+        .uastcFlags = KTX_PACK_UASTC_LEVEL_FASTER,
         .uastcRDO = true,
     };
     KTX_ASSERT(ktxTexture2_CompressBasisEx(kTexture, &basisParams));
-
-    KTX_ASSERT(ktxTexture2_DeflateZstd(kTexture, 20));
+    
+    KTX_ASSERT(ktxTexture2_DeflateZstd(kTexture, 10));
 
     char writer[100];
     snprintf(writer, sizeof(writer), "%s version %s", "SeeleEngine", "0.0.1");
@@ -140,7 +140,7 @@ void TextureLoader::import(TextureImportArgs args, PTextureAsset textureAsset) {
     size_t texSize;
     KTX_ASSERT(ktxTexture_WriteToMemory(ktxTexture(kTexture), &texData, &texSize));
 
-    ktxTexture_WriteToNamedFile(ktxTexture(kTexture), args.filePath.filename().replace_extension(".ktx").generic_string().c_str());
+    //ktxTexture_WriteToNamedFile(ktxTexture(kTexture), args.filePath.filename().replace_extension(".ktx").generic_string().c_str());
 
     Array<uint8> serialized(texSize);
     std::memcpy(serialized.data(), texData, texSize);

src/Engine/Graphics/MeshData.h

@@ -5,7 +5,9 @@ struct MeshData {
     AABB bounding;
     uint32 numMeshlets = 0;
     uint32 meshletOffset = 0;
+    // offset into the global index buffer
     uint32 firstIndex = 0;
+    // number of indices in the global index buffer
     uint32 numIndices = 0;
 };
 struct InstanceData {

src/Engine/Graphics/VertexData.h

@@ -22,6 +22,7 @@ struct MeshId {
 class VertexData {
   public:
     struct DrawCallOffsets {
+        // offset into the instanceData and meshData arrays
         uint32 instanceOffset = 0;
         uint32 textureOffset = 0;
         uint32 samplerOffset = 0;
@@ -91,11 +92,16 @@ class VertexData {
     VertexData();
     struct MeshletDescription {
         AABB bounding;
+        // number of relevant entries in the vertexIndices array
         uint32 vertexCount;
+        // number of relevant entries in the primitiveIndices array
         uint32 primitiveCount;
+        // starting offset into the vertexIndices array
         uint32 vertexOffset;
+        // starting offset into the primitiveIndices array
         uint32 primitiveOffset;
         Vector color;
+        // gets added to vertex indices so that they reference the global mesh bool
         uint32 indicesOffset = 0;
     };
     std::mutex materialDataLock;

src/Engine/Graphics/Vulkan/Graphics.cpp

@@ -675,7 +675,6 @@ void Graphics::createDevice(GraphicsInitializer initializer) {
 
     VK_CHECK(vkCreateDevice(physicalDevice, &deviceInfo, nullptr, &handle));
     // std::cout << "Vulkan handle: " << handle << std::endl;
-
     graphicsQueue = 0;
     computeQueue = 0;
     transferQueue = 0;

src/Engine/Graphics/Vulkan/RayTracing.cpp

@@ -12,7 +12,8 @@
 
 using namespace Seele::Vulkan;
 
-BottomLevelAS::BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateInfo& createInfo) : graphics(graphics) {
+BottomLevelAS::BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateInfo& createInfo)
+    : graphics(graphics), material(createInfo.mesh->referencedMaterial->getHandle()) {
     VertexData* vertexData = createInfo.mesh->vertexData;
     MeshData meshData = vertexData->getMeshData(createInfo.mesh->id);
     Gfx::PShaderBuffer positionBuffer = vertexData->getPositionBuffer();
@@ -37,6 +38,8 @@ BottomLevelAS::BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateI
     };
     OBufferAllocation transformBuffer =
         new BufferAllocation(graphics, "TransformBuffer", transformBufferInfo, transformAllocInfo, Gfx::QueueType::GRAPHICS);
+    transformBuffer->updateContents(0, sizeof(VkTransformMatrixKHR), &matrix);
+
     VkDeviceOrHostAddressConstKHR vertexDataAddress = {
         .deviceAddress =
             positionBuffer.cast<ShaderBuffer>()->getDeviceAddress() + vertexData->getMeshOffset(createInfo.mesh->id) * sizeof(Vector4),
@@ -51,18 +54,21 @@ BottomLevelAS::BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateI
         .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR,
         .pNext = nullptr,
         .geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
-        .geometry = {.triangles =
-                         {
-                             .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
-                             .pNext = nullptr,
-                             .vertexFormat = VK_FORMAT_R32G32B32_SFLOAT,
-                             .vertexData = vertexDataAddress,
-                             .vertexStride = sizeof(Vector),
-                             .maxVertex = static_cast<uint32_t>(createInfo.mesh->vertexCount),
-                             .indexType = VK_INDEX_TYPE_UINT32,
-                             .indexData = indexDataAddress,
-                             .transformData = transformDataAddress,
-                         }},
+        .geometry =
+            {
+                .triangles =
+                    {
+                        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
+                        .pNext = nullptr,
+                        .vertexFormat = VK_FORMAT_R32G32B32_SFLOAT,
+                        .vertexData = vertexDataAddress,
+                        .vertexStride = sizeof(Vector),
+                        .maxVertex = static_cast<uint32_t>(createInfo.mesh->vertexCount),
+                        .indexType = VK_INDEX_TYPE_UINT32,
+                        .indexData = indexDataAddress,
+                        .transformData = transformDataAddress,
+                    },
+            },
         .flags = VK_GEOMETRY_OPAQUE_BIT_KHR,
     };
     VkAccelerationStructureBuildGeometryInfoKHR structureBuildGeometry = {

src/Engine/Graphics/Vulkan/RayTracing.h

@@ -16,7 +16,7 @@ class BottomLevelAS : public Gfx::BottomLevelAS {
     PGraphics graphics;
     VkAccelerationStructureKHR handle;
     OBufferAllocation buffer;
-
+    PMaterialInstance material;
 };
 DEFINE_REF(BottomLevelAS)
 class TopLevelAS : public Gfx::TopLevelAS {