Rt works now, no idea why

CMakeLists.txt

@@ -129,8 +129,8 @@ add_subdirectory(src/)
 if(WIN32)
     add_custom_target(dll_copy ALL
         COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_RUNTIME_DLLS:Engine> $<TARGET_FILE_DIR:Editor>
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}/slang.dll $<TARGET_FILE_DIR:Editor>
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}bin/slang.dll $<TARGET_FILE_DIR:Editor>
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}/slang-glslang.dll $<TARGET_FILE_DIR:Editor>
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}bin/slang-glslang.dll $<TARGET_FILE_DIR:Editor>
         COMMAND_EXPAND_LISTS
         DEPENDS Editor)
 elseif(APPLE)

cmake/SuperBuild.cmake

@@ -5,18 +5,18 @@ include (ExternalProject)
 add_library(slang SHARED IMPORTED)
 if(WIN32)
     add_library(slang-glslang SHARED IMPORTED)
-    set(SLANG_ROOT ${EXTERNAL_ROOT}/slang/bin/windows-x64/release/)
+    set(SLANG_ROOT ${EXTERNAL_ROOT}/slang/build/Release/)
-    set_target_properties(slang-glslang PROPERTIES IMPORTED_LOCATION ${SLANG_ROOT}slang-glslang.dll)
+    set_target_properties(slang-glslang PROPERTIES IMPORTED_LOCATION ${SLANG_ROOT}bin/slang-glslang.dll)
-    set_target_properties(slang-glslang PROPERTIES IMPORTED_IMPLIB ${SLANG_ROOT}slang.lib)
+    set_target_properties(slang-glslang PROPERTIES IMPORTED_IMPLIB ${SLANG_ROOT}lib/slang.lib)
-    set_target_properties(slang PROPERTIES IMPORTED_LOCATION ${SLANG_ROOT}slang.dll)
+    set_target_properties(slang PROPERTIES IMPORTED_LOCATION ${SLANG_ROOT}bin/slang.dll)
-    set_target_properties(slang PROPERTIES IMPORTED_IMPLIB ${SLANG_ROOT}slang.lib)
+    set_target_properties(slang PROPERTIES IMPORTED_IMPLIB ${SLANG_ROOT}lib/slang.lib)
     target_link_libraries(slang INTERFACE slang-glslang)
     install(FILES 
-        ${SLANG_ROOT}slang-glslang.dll
+        ${SLANG_ROOT}bin/slang-glslang.dll
-        ${SLANG_ROOT}slang.dll
+        ${SLANG_ROOT}bin/slang.dll
     DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
     install(FILES 
-        ${SLANG_ROOT}slang.lib
+        ${SLANG_ROOT}lib/slang.lib
     DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
 elseif(APPLE)
     set(BINARY_ROOT ${SLANG_ROOT}/build/Debug/)

res/shaders/raytracing/ClosestHit.slang

@@ -1,5 +1,4 @@
 import Common;
-import VertexData;
 import MaterialParameter;
 import LightEnv;
 import Scene;

res/shaders/raytracing/RayGen.slang

@@ -4,28 +4,22 @@ import RayTracingData;
 [shader("raygeneration")]
 void raygen()
 {
-	const float2 pixelCenter = float2(DispatchRaysIndex().xy) + float2(0.5);
+    uint3 LaunchID = DispatchRaysIndex();
-	const float2 inUV = pixelCenter / float2(DispatchRaysDimensions().xy);
+    uint3 LaunchSize = DispatchRaysDimensions();
-	float2 d = inUV * 2.0 - 1.0;
 
-	float4 origin = mul(pViewParams.inverseViewMatrix, float4(0, 0, 0, 1));
+    const float2 pixelCenter = float2(LaunchID.xy) + float2(0.5, 0.5);
+    const float2 inUV = pixelCenter / float2(LaunchSize.xy);
+    float2 d = float2(inUV.x, 1 - inUV.y) * 2.0 - 1.0;
     float4 target = mul(pViewParams.inverseProjection, float4(d.x, d.y, 1, 1));
-    float4 direction = mul(pViewParams.inverseViewMatrix, float4(target.xyz, 0));
 
-	float tmin = 0.0001;
+    RayDesc rayDesc;
-	float tmax = 10000.0;
+    rayDesc.Origin = mul(pViewParams.inverseViewMatrix, float4(0, 0, 0, 1)).xyz;
-
+    rayDesc.Direction = mul(pViewParams.inverseViewMatrix, float4(normalize(target.xyz), 0)).xyz;
-	uint max_rays = 24;
+    rayDesc.TMin = 0.001;
+    rayDesc.TMax = 10000.0;
 
     RayPayload payload;
+    TraceRay(pRayTracingParams.scene, RAY_FLAG_FORCE_OPAQUE, 0xff, 0, 0, 0, rayDesc, payload);
 
-    RayDesc desc;
+    pRayTracingParams.image[int2(LaunchID.xy)] = float4(payload.color, 0.0);
-    desc.Origin = origin.xyz;
-    desc.Direction = direction.xyz;
-    desc.TMin = tmin;
-    desc.TMax = tmax;
-
-    TraceRay(pRayTracingParams.scene, 0, 0xff, 0, 0, 0, desc, payload);
-
-    pRayTracingParams.image[DispatchRaysIndex().xy] = float4(payload.color, 1.0f);
 }

src/Editor/Asset/MeshLoader.cpp

@@ -486,6 +486,7 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
             globalMeshes[meshIndex]->blas = graphics->createBottomLevelAccelerationStructure(Gfx::BottomLevelASCreateInfo{
                 .mesh = globalMeshes[meshIndex],
             });
+            vertexData->registerBottomLevelAccelerationStructure(globalMeshes[meshIndex]->blas);
         });
     }
     getThreadPool().runAndWait(std::move(work));

src/Engine/Graphics/RenderPass/BasePass.cpp

@@ -120,11 +120,11 @@ void BasePass::beginFrame(const Component::Camera& cam) {
         .size = sizeof(SkyboxData),
         .data = (uint8*)&skyboxData,
     });
+    skyboxBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_UNIFORM_READ_BIT,
+                                  Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
     skyboxDataSet = skyboxDataLayout->allocateDescriptorSet();
     skyboxDataSet->updateBuffer(0, skyboxBuffer);
     skyboxDataSet->writeChanges();
-    skyboxBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_UNIFORM_READ_BIT,
-                                  Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
     textureSet = textureLayout->allocateDescriptorSet();
     textureSet->updateTexture(0, skybox.day);
     textureSet->updateTexture(1, skybox.night);

src/Engine/Graphics/RenderPass/RayTracingPass.cpp

@@ -1,4 +1,7 @@
 #include "RayTracingPass.h"
+#include "Asset/AssetRegistry.h"
+#include "Asset/MeshAsset.h"
+#include "Graphics/Mesh.h"
 #include "Graphics/RayTracing.h"
 #include "Graphics/Shader.h"
 #include "Graphics/StaticMeshVertexData.h"
@@ -74,7 +77,7 @@ void RayTracingPass::render() {
             }
         }
     }
-    Gfx::OTopLevelAS tlas = graphics->createTopLevelAccelerationStructure(Gfx::TopLevelASCreateInfo{
+    tlas = graphics->createTopLevelAccelerationStructure(Gfx::TopLevelASCreateInfo{
         .instances = instanceData,
         .bottomLevelStructures = accelerationStructures,
     });
@@ -84,14 +87,6 @@ void RayTracingPass::render() {
     desc->updateBuffer(2, StaticMeshVertexData::getInstance()->getIndexBuffer());
     desc->writeChanges();
 
-    Gfx::PRayTracingPipeline pipeline = graphics->createRayTracingPipeline(Gfx::RayTracingPipelineCreateInfo{
-        .pipelineLayout = pipelineLayout,
-        .rayGenGroup = {.shader = rayGen},
-        .hitGroups = {{.closestHitShader = closestHit}},
-        .missGroups = {{.shader = miss}},
-        .callableGroups = callableGroups,
-    });
-
     command->bindPipeline(pipeline);
     StaticMeshVertexData::getInstance()->getInstanceDataSet()->writeChanges();
     StaticMeshVertexData::getInstance()->getVertexDataSet()->writeChanges();
@@ -123,9 +118,8 @@ void RayTracingPass::publishOutputs() {
                           Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
     ShaderCompilationInfo compileInfo = {
         .name = "RT",
-        .modules = {"RayGen", "ClosestHit", "Miss", "StaticMeshVertexData"},
+        .modules = {"RayGen", "ClosestHit", "Miss"},
         .entryPoints = {{"raygen", "RayGen"}, {"closestHit", "ClosestHit"}, {"miss", "Miss"}},
-        .typeParameter = {{"IVertexData", "StaticMeshVertexData"}},
         .defines = {{"RAY_TRACING", "1"}},
         .rootSignature = pipelineLayout,
     };
@@ -134,6 +128,16 @@ void RayTracingPass::publishOutputs() {
     closestHit = graphics->createClosestHitShader({1});
     miss = graphics->createMissShader({2});
     pipelineLayout->create();
+    pipeline = graphics->createRayTracingPipeline(Gfx::RayTracingPipelineCreateInfo{
+        .pipelineLayout = pipelineLayout,
+        .rayGenGroup = {.shader = rayGen},
+        .hitGroups = {{.closestHitShader = closestHit}},
+        .missGroups = {{.shader = miss}},
+        //.callableGroups = callableGroups,
+    });
+    Component::Transform transform;
+    transform.setScale(Vector(1, 1, 1));
+    transform.setPosition(Vector(0, 0, 1));
 }
 
 void RayTracingPass::createRenderPass() {}

src/Engine/Graphics/RenderPass/RayTracingPass.h

@@ -21,5 +21,7 @@ class RayTracingPass : public RenderPass {
     Gfx::ORayGenShader rayGen;
     Gfx::OClosestHitShader closestHit;
     Gfx::OMissShader miss;
+    Gfx::PRayTracingPipeline pipeline;
+    Gfx::OTopLevelAS tlas;
 };
 } // namespace Seele

src/Engine/Graphics/StaticMeshVertexData.cpp

@@ -152,7 +152,7 @@ void StaticMeshVertexData::resizeBuffers() {
             },
         .numElements = verticesAllocated,
         .dynamic = false,
-        .vertexBuffer = 1,
+        .vertexBuffer = true,
         .name = "Positions",
     };
     positions = graphics->createShaderBuffer(createInfo);

src/Engine/Graphics/VertexData.cpp

@@ -293,6 +293,8 @@ void VertexData::commitMeshes() {
         .dynamic = false,
         .name = "PrimitiveIndicesBuffer",
     });
+    updateBuffers();
+    dirty = false;
     graphics->buildBottomLevelAccelerationStructures(std::move(dataToBuild));
 }
 

src/Engine/Graphics/Vulkan/Buffer.cpp

@@ -98,7 +98,7 @@ void BufferAllocation::updateContents(uint64 regionOffset, uint64 regionSize, vo
         .flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT,
         .usage = VMA_MEMORY_USAGE_AUTO,
     };
-    OBufferAllocation staging = new BufferAllocation(graphics, "UpdateStaging", stagingInfo, stagingAlloc, Gfx::QueueType::TRANSFER);
+    OBufferAllocation staging = new BufferAllocation(graphics, "UpdateStaging", stagingInfo, stagingAlloc, Gfx::QueueType::GRAPHICS);
 
     uint8* data;
     VK_CHECK(vmaMapMemory(graphics->getAllocator(), staging->allocation, (void**)&data));
@@ -107,7 +107,7 @@ void BufferAllocation::updateContents(uint64 regionOffset, uint64 regionSize, vo
     vmaUnmapMemory(graphics->getAllocator(), staging->allocation);
 
     Gfx::QueueType prevOwner = owner;
-    transferOwnership(Gfx::QueueType::TRANSFER);
+    // transferOwnership(Gfx::QueueType::TRANSFER);
 
     PCommand cmd = graphics->getQueueCommands(Gfx::QueueType::TRANSFER)->getCommands();
     VkBufferCopy copy = {
@@ -119,7 +119,7 @@ void BufferAllocation::updateContents(uint64 regionOffset, uint64 regionSize, vo
     cmd->bindResource(PBufferAllocation(this));
     cmd->bindResource(PBufferAllocation(staging));
 
-    transferOwnership(prevOwner);
+    // transferOwnership(prevOwner);
     graphics->getDestructionManager()->queueResourceForDestruction(std::move(staging));
 }
 
@@ -138,10 +138,10 @@ void BufferAllocation::readContents(uint64 regionOffset, uint64 regionSize, void
         .flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT,
         .usage = VMA_MEMORY_USAGE_AUTO,
     };
-    OBufferAllocation staging = new BufferAllocation(graphics, "ReadStaging", stagingInfo, stagingAlloc, Gfx::QueueType::TRANSFER);
+    OBufferAllocation staging = new BufferAllocation(graphics, "ReadStaging", stagingInfo, stagingAlloc, Gfx::QueueType::GRAPHICS);
 
     Gfx::QueueType prevOwner = owner;
-    transferOwnership(Gfx::QueueType::TRANSFER);
+    // transferOwnership(Gfx::QueueType::TRANSFER);
 
     PCommandPool pool = graphics->getQueueCommands(Gfx::QueueType::TRANSFER);
     PCommand cmd = pool->getCommands();
@@ -156,7 +156,7 @@ void BufferAllocation::readContents(uint64 regionOffset, uint64 regionSize, void
     pool->submitCommands();
     cmd->getFence()->wait(1000000);
 
-    transferOwnership(prevOwner);
+    // transferOwnership(prevOwner);
 
     uint8* data;
     VK_CHECK(vmaMapMemory(graphics->getAllocator(), staging->allocation, (void**)&data));
@@ -166,6 +166,14 @@ void BufferAllocation::readContents(uint64 regionOffset, uint64 regionSize, void
     graphics->getDestructionManager()->queueResourceForDestruction(std::move(staging));
 }
 
+void* BufferAllocation::map() {
+    void* data;
+    vmaMapMemory(graphics->getAllocator(), allocation, &data);
+    return data;
+}
+
+void BufferAllocation::unmap() { vmaUnmapMemory(graphics->getAllocator(), allocation); }
+
 Buffer::Buffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage, Gfx::QueueType queueType, bool dynamic, std::string name,
                bool createCleared, uint32 clearValue)
     : graphics(graphics), currentBuffer(0), initialOwner(queueType),
@@ -285,15 +293,15 @@ void Buffer::copyBuffer(uint64 src, uint64 dst) {
         .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
         .pNext = nullptr,
         .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
-        .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT,
+        .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
         .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .buffer = buffers[dst]->buffer,
         .offset = 0,
         .size = buffers[dst]->size,
     };
-    vkCmdPipelineBarrier(command->getHandle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 1,
+    vkCmdPipelineBarrier(command->getHandle(), VK_PIPELINE_STAGE_TRANSFER_BIT,
-                         &dstBarrier, 0, nullptr);
+                         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1, &dstBarrier, 0, nullptr);
 }
 
 void Buffer::transferOwnership(Gfx::QueueType newOwner) {
@@ -322,6 +330,7 @@ UniformBuffer::~UniformBuffer() {}
 
 void UniformBuffer::updateContents(const DataSource& sourceData) {
     if (sourceData.size > 0 && sourceData.data != nullptr) {
+        rotateBuffer(sourceData.size);
         getAlloc()->updateContents(sourceData.offset, sourceData.size, sourceData.data);
     }
 }
@@ -414,6 +423,8 @@ IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo& create
                          VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                      createInfo.sourceData.owner, false, createInfo.name) {
     getAlloc()->updateContents(createInfo.sourceData.offset, createInfo.sourceData.size, createInfo.sourceData.data);
+    getAlloc()->pipelineBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_INDEX_READ_BIT,
+                                Gfx::SE_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR | Gfx::SE_PIPELINE_STAGE_VERTEX_INPUT_BIT);
 }
 
 IndexBuffer::~IndexBuffer() {}

src/Engine/Graphics/Vulkan/Buffer.h

@@ -17,6 +17,8 @@ class BufferAllocation : public CommandBoundResource {
     void transferOwnership(Gfx::QueueType newOwner);
     void updateContents(uint64 regionOffset, uint64 regionSize, void* ptr);
     void readContents(uint64 regionOffset, uint64 regionSize, void* ptr);
+    void* map();
+    void unmap();
     VkBuffer buffer = VK_NULL_HANDLE;
     VmaAllocation allocation = VmaAllocation();
     VmaAllocationInfo info = VmaAllocationInfo();

src/Engine/Graphics/Vulkan/Enums.h

@@ -13,7 +13,6 @@
                 std::this_thread::sleep_for(std::chrono::seconds(3));                                                                      \
             }                                                                                                                              \
             std::cout << "Fatal : VkResult is " << res << " in " << __FILE__ << " at line " << __LINE__ << std::endl;                      \
-            std::cin.get();                                                                                                                \
             abort();                                                                                                                       \
         }                                                                                                                                  \
     }

src/Engine/Graphics/Vulkan/Graphics.cpp

@@ -380,9 +380,19 @@ Gfx::OTopLevelAS Graphics::createTopLevelAccelerationStructure(const Gfx::TopLev
 }
 
 void Graphics::buildBottomLevelAccelerationStructures(Array<Gfx::PBottomLevelAS> data) {
-    Gfx::PShaderBuffer positionBuffer = StaticMeshVertexData::getInstance()->getPositionBuffer();
+    Gfx::PShaderBuffer verticesBuffer = StaticMeshVertexData::getInstance()->getPositionBuffer();
     Gfx::PIndexBuffer indexBuffer = StaticMeshVertexData::getInstance()->getIndexBuffer();
     
+    // Setup vertices and indices for a single triangle
+    
+    // Create buffers for the bottom level geometry
+    // For the sake of simplicity we won't stage the vertex data to the GPU memory
+
+    // Note that the buffer usage flags for buffers consumed by the bottom level acceleration structure require special flags
+    const VkBufferUsageFlags buffer_usage_flags = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR |
+                                                  VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+
+    
     VkBufferCreateInfo transformBufferInfo = {
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
         .pNext = nullptr,
@@ -407,7 +417,7 @@ void Graphics::buildBottomLevelAccelerationStructures(Array<Gfx::PBottomLevelAS>
     transformBuffer->pipelineBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                      VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT,
                                      VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR | VK_PIPELINE_STAGE_TRANSFER_BIT);
-    positionBuffer->pipelineBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_SHADER_READ_BIT,
+    verticesBuffer->pipelineBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_SHADER_READ_BIT,
                                    VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR);
     indexBuffer->pipelineBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_SHADER_READ_BIT,
                                   VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR);
@@ -421,7 +431,7 @@ void Graphics::buildBottomLevelAccelerationStructures(Array<Gfx::PBottomLevelAS>
     for (uint32 i = 0; i < data.size(); ++i) {
         auto blas = data[i].cast<BottomLevelAS>();
         VkDeviceOrHostAddressConstKHR vertexDataAddress = {
-            .deviceAddress = positionBuffer.cast<ShaderBuffer>()->getDeviceAddress() + blas->getVertexOffset(),
+            .deviceAddress = verticesBuffer.cast<ShaderBuffer>()->getDeviceAddress() + blas->getVertexOffset(),
         };
         VkDeviceOrHostAddressConstKHR indexDataAddress = {
             .deviceAddress = indexBuffer.cast<IndexBuffer>()->getDeviceAddress() + blas->getIndexOffset(),
@@ -520,7 +530,6 @@ void Graphics::buildBottomLevelAccelerationStructures(Array<Gfx::PBottomLevelAS>
     transformBuffer->bind();
     cmd->bindResource(PBufferAllocation(transformBuffer));
     destructionManager->queueResourceForDestruction(std::move(transformBuffer));
-
     for (auto& scratchAlloc : scratchBuffers) {
         scratchAlloc->bind();
         cmd->bindResource(PBufferAllocation(scratchAlloc));
@@ -755,6 +764,7 @@ void Graphics::pickPhysicalDevice() {
         .pNext = &features11,
         .features =
             {
+                .geometryShader = true,
                 .fillModeNonSolid = true,
                 .wideLines = true,
                 .pipelineStatisticsQuery = true,

src/Engine/Graphics/Vulkan/PipelineCache.cpp

@@ -477,7 +477,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
             .flags = 0,
             .stage = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
             .module = rayGen->getModuleHandle(),
-            .pName = "main",
+            .pName = rayGen->getEntryPointName(),
         });
         shaderGroups.add(VkRayTracingShaderGroupCreateInfoKHR{
             .sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
@@ -498,7 +498,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
                 .flags = 0,
                 .stage = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
                 .module = hit->getModuleHandle(),
-                .pName = "main",
+                .pName = hit->getEntryPointName(),
             });
             uint32 hitIndex = static_cast<uint32>(shaderStages.size() - 1);
             uint32 anyHitIndex = VK_SHADER_UNUSED_KHR;
@@ -511,7 +511,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
                     .flags = 0,
                     .stage = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
                     .module = anyHit->getModuleHandle(),
-                    .pName = "main",
+                    .pName = anyHit->getEntryPointName(),
                 });
             }
             if (hitgroup.intersectionShader != nullptr) {
@@ -589,144 +589,179 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
         .pStages = shaderStages.data(),
         .groupCount = static_cast<uint32>(shaderGroups.size()),
         .pGroups = shaderGroups.data(),
-        .maxPipelineRayRecursionDepth = 24,
+        .maxPipelineRayRecursionDepth = 1,
         .layout = createInfo.pipelineLayout.cast<PipelineLayout>()->getHandle(),
     };
     VkPipeline pipelineHandle;
     VK_CHECK(vkCreateRayTracingPipelinesKHR(graphics->getDevice(), VK_NULL_HANDLE, cache, 1, &pipelineInfo, nullptr, &pipelineHandle));
+    /*
+    const uint32_t handle_size = graphics->getRayTracingProperties().shaderGroupHandleSize;
+    const uint32_t handle_size_aligned =
+        align(graphics->getRayTracingProperties().shaderGroupHandleSize, graphics->getRayTracingProperties().shaderGroupHandleAlignment);
+    const uint32_t handle_alignment = graphics->getRayTracingProperties().shaderGroupHandleAlignment;
+    const uint32_t group_count = static_cast<uint32_t>(shaderGroups.size());
+    const uint32_t sbt_size = group_count * handle_size_aligned;
+    const VkBufferUsageFlags sbt_buffer_usage_flags =
+        VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
+    const VmaMemoryUsage sbt_memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
+
+    // Raygen
+    // Create binding table buffers for each shader type
+    OBufferAllocation raygen_shader_binding_table = new BufferAllocation(graphics, "RayGen",
+                                                                         VkBufferCreateInfo{
+                                                                             .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                                                                             .pNext = nullptr,
+                                                                             .size = handle_size,
+                                                                             .usage = sbt_buffer_usage_flags,
+                                                                         },
+                                                                         VmaAllocationCreateInfo{
+                                                                             .usage = sbt_memory_usage,
+                                                                         },
+                                                                         Gfx::QueueType::GRAPHICS, 0);
+    OBufferAllocation miss_shader_binding_table = new BufferAllocation(graphics, "Miss",
+                                                                       VkBufferCreateInfo{
+                                                                           .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                                                                           .pNext = nullptr,
+                                                                           .size = handle_size,
+                                                                           .usage = sbt_buffer_usage_flags,
+                                                                       },
+                                                                       VmaAllocationCreateInfo{
+                                                                           .usage = sbt_memory_usage,
+                                                                       },
+                                                                       Gfx::QueueType::GRAPHICS, 0);
+    OBufferAllocation hit_shader_binding_table = new BufferAllocation(graphics, "Hit",
+                                                                      VkBufferCreateInfo{
+                                                                          .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                                                                          .pNext = nullptr,
+                                                                          .size = handle_size,
+                                                                          .usage = sbt_buffer_usage_flags,
+                                                                      },
+                                                                      VmaAllocationCreateInfo{
+                                                                          .usage = sbt_memory_usage,
+                                                                      },
+                                                                      Gfx::QueueType::GRAPHICS, 0);
+
+    // Copy the pipeline's shader handles into a host buffer
+    std::vector<uint8_t> shader_handle_storage(sbt_size);
+    VK_CHECK(vkGetRayTracingShaderGroupHandlesKHR(graphics->getDevice(), pipelineHandle, 0, group_count, sbt_size,
+                                                  shader_handle_storage.data()));
+
+    // Copy the shader handles from the host buffer to the binding tables
+    uint8_t* data = static_cast<uint8_t*>(raygen_shader_binding_table->map());
+    memcpy(data, shader_handle_storage.data(), handle_size);
+    data = static_cast<uint8_t*>(miss_shader_binding_table->map());
+    memcpy(data, shader_handle_storage.data() + handle_size_aligned, handle_size);
+    data = static_cast<uint8_t*>(hit_shader_binding_table->map());
+    memcpy(data, shader_handle_storage.data() + handle_size_aligned * 2, handle_size);
+    raygen_shader_binding_table->unmap();
+    miss_shader_binding_table->unmap();
+    hit_shader_binding_table->unmap();*/
 
     const uint32_t handleSize = graphics->getRayTracingProperties().shaderGroupHandleSize;
-    const uint32_t handleAlignment = graphics->getRayTracingProperties().shaderGroupBaseAlignment;
+    const uint32_t handleSizeAligned =
-    const uint32_t handleSizeAligned = align(handleSize, handleAlignment);
+        align(graphics->getRayTracingProperties().shaderGroupHandleSize, graphics->getRayTracingProperties().shaderGroupHandleAlignment);
+    const uint32_t handleAlignment = graphics->getRayTracingProperties().shaderGroupHandleAlignment;
     const uint32_t groupCount = static_cast<uint32_t>(shaderGroups.size());
-    const uint32_t sbtSize = handleSizeAligned * groupCount;
+    const uint32_t sbtSize = groupCount * handleSizeAligned;
+    const VkBufferUsageFlags sbtBufferUsage =
+        VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
+    const VmaMemoryUsage sbtMemoryUsage = VMA_MEMORY_USAGE_CPU_TO_GPU;
+
+    OBufferAllocation rayGenBuffer = new BufferAllocation(graphics, "RayGenSBT",
+                                                          VkBufferCreateInfo{
+                                                              .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                                                              .pNext = nullptr,
+                                                              .flags = 0,
+                                                              .size = handleSize,
+                                                              .usage = sbtBufferUsage,
+                                                          },
+                                                          VmaAllocationCreateInfo{
+                                                              .usage = sbtMemoryUsage,
+                                                          },
+                                                          Gfx::QueueType::GRAPHICS);
+
+    OBufferAllocation hitBuffer = new BufferAllocation(graphics, "HitSBT",
+                                                       VkBufferCreateInfo{
+                                                           .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                                                           .pNext = nullptr,
+                                                           .flags = 0,
+                                                           .size = handleSize * createInfo.hitGroups.size(),
+                                                           .usage = sbtBufferUsage,
+                                                       },
+                                                       VmaAllocationCreateInfo{
+                                                           .usage = sbtMemoryUsage,
+                                                       },
+                                                       Gfx::QueueType::GRAPHICS);
+
+    OBufferAllocation missBuffer = new BufferAllocation(graphics, "MissSBT",
+                                                        VkBufferCreateInfo{
+                                                            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                                                            .pNext = nullptr,
+                                                            .flags = 0,
+                                                            .size = handleSize * createInfo.missGroups.size(),
+                                                            .usage = sbtBufferUsage,
+                                                        },
+                                                        VmaAllocationCreateInfo{
+                                                            .usage = sbtMemoryUsage,
+                                                        },
+                                                        Gfx::QueueType::GRAPHICS);
 
     Array<uint8> sbt(sbtSize);
-
     vkGetRayTracingShaderGroupHandlesKHR(graphics->getDevice(), pipelineHandle, 0, shaderGroups.size(), sbtSize, sbt.data());
 
-    uint32 rayGenSize = align<uint32>(handleSize + createInfo.rayGenGroup.parameters.size(), handleAlignment);
+    /* maxParamSize = 0;
-    Array<uint8> rayGenSbt(handleSizeAligned);
-    std::memcpy(rayGenSbt.data(), sbt.data(), handleSize);
-    std::memcpy(rayGenSbt.data() + handleSize, createInfo.rayGenGroup.parameters.data(), createInfo.rayGenGroup.parameters.size());
-
-    OBufferAllocation rayGenBuffer =
-        new BufferAllocation(graphics, "RayGenSBT",
-                             VkBufferCreateInfo{
-                                 .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-                                 .pNext = nullptr,
-                                 .flags = 0,
-                                 .size = rayGenSbt.size(),
-                                 .usage = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
-                                          VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-                             },
-                             VmaAllocationCreateInfo{
-                                 .usage = VMA_MEMORY_USAGE_AUTO,
-                             },
-                             Gfx::QueueType::GRAPHICS);
-    rayGenBuffer->updateContents(0, rayGenSbt.size(), rayGenSbt.data());
-    rayGenBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,
-                                  Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
-
-    uint64 sbtOffset = handleSizeAligned;
-
-    uint32 maxParamSize = 0;
-    for (auto& hitgroup : createInfo.hitGroups) {
-        maxParamSize = std::max<uint32>(maxParamSize, hitgroup.parameters.size());
-    }
-    uint64 hitStride = align(handleSize + maxParamSize, handleAlignment);
-    Array<uint8> hitSbt(hitStride * createInfo.hitGroups.size());
-    for (uint64 i = 0; i < createInfo.hitGroups.size(); ++i) {
-        std::memcpy(hitSbt.data() + i * hitStride, sbt.data() + sbtOffset, handleSize);
-        std::memcpy(hitSbt.data() + i * hitStride + handleSize, createInfo.hitGroups[i].parameters.data(),
-                    createInfo.hitGroups[i].parameters.size());
-        sbtOffset += handleSizeAligned;
-    }
-
-    OBufferAllocation hitBuffer =
-        new BufferAllocation(graphics, "HitSBT",
-                             VkBufferCreateInfo{
-                                 .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-                                 .pNext = nullptr,
-                                 .flags = 0,
-                                 .size = hitSbt.size(),
-                                 .usage = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
-                                          VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-                             },
-                             VmaAllocationCreateInfo{
-                                 .usage = VMA_MEMORY_USAGE_AUTO,
-                             },
-                             Gfx::QueueType::GRAPHICS);
-    hitBuffer->updateContents(0, hitSbt.size(), hitSbt.data());
-    hitBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,
-                               Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
-
-    maxParamSize = 0;
-    for (auto& missGroup : createInfo.missGroups) {
-        maxParamSize = std::max<uint32>(maxParamSize, missGroup.parameters.size());
-    }
-    uint64 missStride = align(handleSize + maxParamSize, handleAlignment);
-    Array<uint8> missSbt(missStride * createInfo.missGroups.size());
-    for (uint64 i = 0; i < createInfo.missGroups.size(); ++i) {
-        std::memcpy(missSbt.data() + i * missStride, sbt.data() + sbtOffset, handleSize);
-        std::memcpy(missSbt.data() + i * missStride + handleSize, createInfo.missGroups[i].parameters.data(),
-                    createInfo.missGroups[i].parameters.size());
-        sbtOffset += handleSizeAligned;
-    }
-
-    OBufferAllocation missBuffer =
-        new BufferAllocation(graphics, "MissSBT",
-                             VkBufferCreateInfo{
-                                 .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-                                 .pNext = nullptr,
-                                 .flags = 0,
-                                 .size = missSbt.size(),
-                                 .usage = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
-                                          VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-                             },
-                             VmaAllocationCreateInfo{
-                                 .usage = VMA_MEMORY_USAGE_AUTO,
-                             },
-                             Gfx::QueueType::GRAPHICS);
-    missBuffer->updateContents(0, missSbt.size(), missSbt.data());
-    missBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,
-                                Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
-
-    maxParamSize = 0;
     for (auto& callableGroup : createInfo.callableGroups) {
         maxParamSize = std::max<uint32>(maxParamSize, callableGroup.parameters.size());
     }
     uint64 callableStride = align(handleSize + maxParamSize, handleAlignment);
-    Array<uint8> callableSbt(callableStride * createInfo.callableGroups.size());
-    for (uint64 i = 0; i < createInfo.callableGroups.size(); ++i) {
-        std::memcpy(callableSbt.data() + i * callableStride, sbt.data() + sbtOffset, handleSize);
-        std::memcpy(callableSbt.data() + i * callableStride + handleSize, createInfo.callableGroups[i].parameters.data(),
-                    createInfo.callableGroups[i].parameters.size());
-        sbtOffset += handleSizeAligned;
-    }
 
-    OBufferAllocation callableBuffer =
+    OBufferAllocation callableBuffer = new BufferAllocation(graphics, "CallableSBT",
-        new BufferAllocation(graphics, "CallableSBT",
                                                             VkBufferCreateInfo{
                                                                 .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
                                                                 .pNext = nullptr,
                                                                 .flags = 0,
-                                 .size = callableSbt.size(),
+                                                                .size = callableStride * createInfo.callableGroups.size(),
-                                 .usage = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
+                                                                .usage = sbtBufferUsage,
-                                          VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
                                                             },
                                                             VmaAllocationCreateInfo{
-                                 .usage = VMA_MEMORY_USAGE_AUTO,
+                                                                .usage = sbtMemoryUsage,
                                                             },
                                                             Gfx::QueueType::GRAPHICS);
-    callableBuffer->updateContents(0, callableSbt.size(), callableSbt.data());
+    uint8* callableData = static_cast<uint8*>(callableBuffer->map());
-    callableBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,
+    for (uint64 i = 0; i < createInfo.callableGroups.size(); ++i) {
-                                Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
+        std::memcpy(callableData, sbt.data() + sbtOffset, handleSize);
+        std::memcpy(callableData + handleSize, createInfo.callableGroups[i].parameters.data(),
+                    createInfo.callableGroups[i].parameters.size());
+        sbtOffset += handleSizeAligned;
+        callableData += callableStride;
+    }
+    callableBuffer->unmap();
+    */
+    uint64 sbtOffset = 0;
+    uint8* rayGenData = static_cast<uint8*>(rayGenBuffer->map());
+    std::memcpy(rayGenData, sbt.data() + sbtOffset, handleSize);
+    rayGenBuffer->unmap();
+    sbtOffset += handleSizeAligned;
 
+    uint8* hitData = static_cast<uint8*>(hitBuffer->map());
+    for (uint64 i = 0; i < createInfo.hitGroups.size(); ++i) {
+        std::memcpy(hitData, sbt.data() + sbtOffset, handleSize);
+        sbtOffset += handleSizeAligned;
+        hitData += handleSizeAligned;
+    }
+    hitBuffer->unmap();
+
+    uint8* missData = static_cast<uint8*>(missBuffer->map());
+    for (uint64 i = 0; i < createInfo.missGroups.size(); ++i) {
+        std::memcpy(missData, sbt.data() + sbtOffset, handleSize);
+        sbtOffset += handleSizeAligned;
+        missData += handleSizeAligned;
+    }
+    missBuffer->unmap();
 
     ORayTracingPipeline pipeline =
-        new RayTracingPipeline(graphics, pipelineHandle, std::move(rayGenBuffer), rayGenSize, std::move(hitBuffer), hitStride,
+        new RayTracingPipeline(graphics, pipelineHandle, std::move(rayGenBuffer), handleSizeAligned, std::move(hitBuffer),
-                               std::move(missBuffer), missStride, std::move(callableBuffer), callableStride, createInfo.pipelineLayout);
+                               handleSizeAligned, std::move(missBuffer), handleSizeAligned, nullptr, 0, createInfo.pipelineLayout);
     PRayTracingPipeline handle = pipeline;
     rayTracingPipelines[hash] = std::move(pipeline);
     return handle;

src/Engine/Graphics/Vulkan/RayTracing.cpp

@@ -24,6 +24,7 @@ BottomLevelAS::BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateI
     VertexData* vertexData = createInfo.mesh->vertexData;
     MeshData meshData = vertexData->getMeshData(createInfo.mesh->id);
     vertexOffset = vertexData->getMeshOffset(createInfo.mesh->id) * sizeof(Vector4);
+    vertexCount = vertexData->getMeshVertexCount(createInfo.mesh->id);
     indexOffset = meshData.firstIndex * sizeof(uint32);
     primitiveCount = meshData.numIndices / 3;
 

src/Engine/Graphics/Vulkan/RayTracing.h

@@ -83,9 +83,9 @@ class RayTracingPipeline : public Gfx::RayTracingPipeline {
     }
     VkStridedDeviceAddressRegionKHR getCallableRegion() {
         return VkStridedDeviceAddressRegionKHR{
-            .deviceAddress = callable->deviceAddress,
+            .deviceAddress = 0,//callable->deviceAddress,
-            .stride = callableStride,
+            .stride = 0,//callableStride,
-            .size = callable->size,
+            .size = 0,//callable->size,
         };
     }
     VkPipelineLayout getLayout() const { return layout.cast<PipelineLayout>()->getHandle(); }

src/Engine/Graphics/Vulkan/Resources.cpp

@@ -76,6 +76,8 @@ DestructionManager::DestructionManager(PGraphics graphics) : graphics(graphics)
 DestructionManager::~DestructionManager() {}
 
 void DestructionManager::queueResourceForDestruction(OCommandBoundResource resource) {
+    if (resource == nullptr)
+        return;
     if (resource->isCurrentlyBound()) {
         resources.add(std::move(resource));
     }

src/Engine/Scene/LightEnvironment.cpp

@@ -60,24 +60,14 @@ void LightEnvironment::addDirectionalLight(Component::DirectionalLight dirLight)
 void LightEnvironment::addPointLight(Component::PointLight pointLight) { points.add(pointLight); }
 
 void LightEnvironment::commit() {
-    lightEnvBuffer->pipelineBarrier(Gfx::SE_ACCESS_UNIFORM_READ_BIT | Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
-                                    Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT | Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                                        Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
-                                    Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT);
-    pointLights->pipelineBarrier(Gfx::SE_ACCESS_SHADER_READ_BIT | Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
-                                 Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT | Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                                     Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
-                                 Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT);
-    directionalLights->pipelineBarrier(Gfx::SE_ACCESS_SHADER_READ_BIT | Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
-                                       Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT | Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                                           Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
-                                       Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT);
     lightEnv.numDirectionalLights = dirs.size();
     lightEnv.numPointLights = points.size();
     lightEnvBuffer->updateContents(DataSource{
         .size = sizeof(LightEnv),
         .data = (uint8*)&lightEnv,
     });
+    lightEnvBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_UNIFORM_READ_BIT,
+                                    Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
     directionalLights->rotateBuffer(sizeof(Component::DirectionalLight) * dirs.size());
     directionalLights->updateContents({
         .sourceData =
@@ -87,6 +77,9 @@ void LightEnvironment::commit() {
             },
         .numElements = dirs.size(),
     });
+    directionalLights->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
+                                       Gfx::SE_ACCESS_UNIFORM_READ_BIT,
+                                       Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
     pointLights->rotateBuffer(sizeof(Component::PointLight) * points.size());
     pointLights->updateContents({
         .sourceData =
@@ -96,19 +89,8 @@ void LightEnvironment::commit() {
             },
         .numElements = points.size(),
     });
-
+    pointLights->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_UNIFORM_READ_BIT,
-    lightEnvBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
+                                 Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-                                    Gfx::SE_ACCESS_UNIFORM_READ_BIT | Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
-                                    Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT | Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                                        Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
-    pointLights->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
-                                 Gfx::SE_ACCESS_SHADER_READ_BIT | Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
-                                 Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT | Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                                     Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
-    directionalLights->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
-                                       Gfx::SE_ACCESS_SHADER_READ_BIT | Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
-                                       Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT | Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                                           Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
     set->updateBuffer(0, lightEnvBuffer);
     set->updateBuffer(1, directionalLights);
     set->updateBuffer(2, pointLights);

src/Engine/ThreadPool.h

@@ -10,7 +10,7 @@ class ThreadPool {
     ThreadPool(uint32 numWorkers = std::thread::hardware_concurrency() - 2);
     ~ThreadPool();
     void runAndWait(List<std::function<void()>> functions);
-
+    void runAsync(std::function<void()> func);
   private:
     struct Task {
         uint64 numRemaining = 0;