diff --git a/CMakeLists.txt b/CMakeLists.txt index df22608..d7e86d2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -129,8 +129,8 @@ add_subdirectory(src/) if(WIN32) add_custom_target(dll_copy ALL COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ - COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}/slang.dll $ - COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}/slang-glslang.dll $ + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}bin/slang.dll $ + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SLANG_ROOT}bin/slang-glslang.dll $ COMMAND_EXPAND_LISTS DEPENDS Editor) elseif(APPLE) diff --git a/cmake/SuperBuild.cmake b/cmake/SuperBuild.cmake index 7e7b09e..0ddad00 100644 --- a/cmake/SuperBuild.cmake +++ b/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_target_properties(slang-glslang PROPERTIES IMPORTED_LOCATION ${SLANG_ROOT}slang-glslang.dll) - set_target_properties(slang-glslang PROPERTIES IMPORTED_IMPLIB ${SLANG_ROOT}slang.lib) - set_target_properties(slang PROPERTIES IMPORTED_LOCATION ${SLANG_ROOT}slang.dll) - set_target_properties(slang PROPERTIES IMPORTED_IMPLIB ${SLANG_ROOT}slang.lib) + set(SLANG_ROOT ${EXTERNAL_ROOT}/slang/build/Release/) + set_target_properties(slang-glslang PROPERTIES IMPORTED_LOCATION ${SLANG_ROOT}bin/slang-glslang.dll) + set_target_properties(slang-glslang PROPERTIES IMPORTED_IMPLIB ${SLANG_ROOT}lib/slang.lib) + set_target_properties(slang PROPERTIES IMPORTED_LOCATION ${SLANG_ROOT}bin/slang.dll) + 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}slang.dll + ${SLANG_ROOT}bin/slang-glslang.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/) diff --git a/external/slang b/external/slang new file mode 160000 index 0000000..1a0bbb5 --- /dev/null +++ b/external/slang @@ -0,0 +1 @@ +Subproject commit 1a0bbb53c116e6e5f89ed577803341e6aa1bce82 diff --git a/res/shaders/raytracing/ClosestHit.slang b/res/shaders/raytracing/ClosestHit.slang index 5fdf226..c4950a1 100644 --- a/res/shaders/raytracing/ClosestHit.slang +++ b/res/shaders/raytracing/ClosestHit.slang @@ -1,5 +1,4 @@ import Common; -import VertexData; import MaterialParameter; import LightEnv; import Scene; diff --git a/res/shaders/raytracing/RayGen.slang b/res/shaders/raytracing/RayGen.slang index 2b75b51..b0f4445 100644 --- a/res/shaders/raytracing/RayGen.slang +++ b/res/shaders/raytracing/RayGen.slang @@ -4,28 +4,22 @@ import RayTracingData; [shader("raygeneration")] void raygen() { - const float2 pixelCenter = float2(DispatchRaysIndex().xy) + float2(0.5); - const float2 inUV = pixelCenter / float2(DispatchRaysDimensions().xy); - float2 d = inUV * 2.0 - 1.0; + uint3 LaunchID = DispatchRaysIndex(); + uint3 LaunchSize = DispatchRaysDimensions(); - 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; - float tmax = 10000.0; - - uint max_rays = 24; + RayDesc rayDesc; + rayDesc.Origin = mul(pViewParams.inverseViewMatrix, float4(0, 0, 0, 1)).xyz; + rayDesc.Direction = mul(pViewParams.inverseViewMatrix, float4(normalize(target.xyz), 0)).xyz; + 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; - 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); + pRayTracingParams.image[int2(LaunchID.xy)] = float4(payload.color, 0.0); } diff --git a/src/Editor/Asset/MeshLoader.cpp b/src/Editor/Asset/MeshLoader.cpp index c560ddb..0b98c3d 100644 --- a/src/Editor/Asset/MeshLoader.cpp +++ b/src/Editor/Asset/MeshLoader.cpp @@ -486,6 +486,7 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Arrayblas = graphics->createBottomLevelAccelerationStructure(Gfx::BottomLevelASCreateInfo{ .mesh = globalMeshes[meshIndex], }); + vertexData->registerBottomLevelAccelerationStructure(globalMeshes[meshIndex]->blas); }); } getThreadPool().runAndWait(std::move(work)); diff --git a/src/Engine/Graphics/RenderPass/BasePass.cpp b/src/Engine/Graphics/RenderPass/BasePass.cpp index dcb9deb..ad24b0d 100644 --- a/src/Engine/Graphics/RenderPass/BasePass.cpp +++ b/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); diff --git a/src/Engine/Graphics/RenderPass/RayTracingPass.cpp b/src/Engine/Graphics/RenderPass/RayTracingPass.cpp index 85c41e5..9783fa5 100644 --- a/src/Engine/Graphics/RenderPass/RayTracingPass.cpp +++ b/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() {} diff --git a/src/Engine/Graphics/RenderPass/RayTracingPass.h b/src/Engine/Graphics/RenderPass/RayTracingPass.h index e2f64a2..8b8ecab 100644 --- a/src/Engine/Graphics/RenderPass/RayTracingPass.h +++ b/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 \ No newline at end of file diff --git a/src/Engine/Graphics/StaticMeshVertexData.cpp b/src/Engine/Graphics/StaticMeshVertexData.cpp index 6684917..69d6a0b 100644 --- a/src/Engine/Graphics/StaticMeshVertexData.cpp +++ b/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); diff --git a/src/Engine/Graphics/VertexData.cpp b/src/Engine/Graphics/VertexData.cpp index 1d35779..bfb718a 100644 --- a/src/Engine/Graphics/VertexData.cpp +++ b/src/Engine/Graphics/VertexData.cpp @@ -293,6 +293,8 @@ void VertexData::commitMeshes() { .dynamic = false, .name = "PrimitiveIndicesBuffer", }); + updateBuffers(); + dirty = false; graphics->buildBottomLevelAccelerationStructures(std::move(dataToBuild)); } diff --git a/src/Engine/Graphics/Vulkan/Buffer.cpp b/src/Engine/Graphics/Vulkan/Buffer.cpp index a249fe0..3db672c 100644 --- a/src/Engine/Graphics/Vulkan/Buffer.cpp +++ b/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, - &dstBarrier, 0, nullptr); + vkCmdPipelineBarrier(command->getHandle(), VK_PIPELINE_STAGE_TRANSFER_BIT, + 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() {} diff --git a/src/Engine/Graphics/Vulkan/Buffer.h b/src/Engine/Graphics/Vulkan/Buffer.h index 363fca0..6e2feab 100644 --- a/src/Engine/Graphics/Vulkan/Buffer.h +++ b/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(); diff --git a/src/Engine/Graphics/Vulkan/Enums.h b/src/Engine/Graphics/Vulkan/Enums.h index 0a627c3..9f82595 100644 --- a/src/Engine/Graphics/Vulkan/Enums.h +++ b/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(); \ } \ } diff --git a/src/Engine/Graphics/Vulkan/Graphics.cpp b/src/Engine/Graphics/Vulkan/Graphics.cpp index c54e9b2..58909f6 100644 --- a/src/Engine/Graphics/Vulkan/Graphics.cpp +++ b/src/Engine/Graphics/Vulkan/Graphics.cpp @@ -380,9 +380,19 @@ Gfx::OTopLevelAS Graphics::createTopLevelAccelerationStructure(const Gfx::TopLev } void Graphics::buildBottomLevelAccelerationStructures(Array 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,10 +417,10 @@ void Graphics::buildBottomLevelAccelerationStructures(Array 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, - VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR); + 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); + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR); Array geometries(data.size()); Array buildGeometries(data.size()); @@ -421,7 +431,7 @@ void Graphics::buildBottomLevelAccelerationStructures(Array for (uint32 i = 0; i < data.size(); ++i) { auto blas = data[i].cast(); VkDeviceOrHostAddressConstKHR vertexDataAddress = { - .deviceAddress = positionBuffer.cast()->getDeviceAddress() + blas->getVertexOffset(), + .deviceAddress = verticesBuffer.cast()->getDeviceAddress() + blas->getVertexOffset(), }; VkDeviceOrHostAddressConstKHR indexDataAddress = { .deviceAddress = indexBuffer.cast()->getDeviceAddress() + blas->getIndexOffset(), @@ -520,7 +530,6 @@ void Graphics::buildBottomLevelAccelerationStructures(Array 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, diff --git a/src/Engine/Graphics/Vulkan/PipelineCache.cpp b/src/Engine/Graphics/Vulkan/PipelineCache.cpp index b728bcb..56ab0de 100644 --- a/src/Engine/Graphics/Vulkan/PipelineCache.cpp +++ b/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(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(shaderGroups.size()), .pGroups = shaderGroups.data(), - .maxPipelineRayRecursionDepth = 24, + .maxPipelineRayRecursionDepth = 1, .layout = createInfo.pipelineLayout.cast()->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(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 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(raygen_shader_binding_table->map()); + memcpy(data, shader_handle_storage.data(), handle_size); + data = static_cast(miss_shader_binding_table->map()); + memcpy(data, shader_handle_storage.data() + handle_size_aligned, handle_size); + data = static_cast(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 = align(handleSize, handleAlignment); + const uint32_t handleSizeAligned = + align(graphics->getRayTracingProperties().shaderGroupHandleSize, graphics->getRayTracingProperties().shaderGroupHandleAlignment); + const uint32_t handleAlignment = graphics->getRayTracingProperties().shaderGroupHandleAlignment; const uint32_t groupCount = static_cast(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 sbt(sbtSize); - vkGetRayTracingShaderGroupHandlesKHR(graphics->getDevice(), pipelineHandle, 0, shaderGroups.size(), sbtSize, sbt.data()); - uint32 rayGenSize = align(handleSize + createInfo.rayGenGroup.parameters.size(), handleAlignment); - Array 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(maxParamSize, hitgroup.parameters.size()); - } - uint64 hitStride = align(handleSize + maxParamSize, handleAlignment); - Array 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(maxParamSize, missGroup.parameters.size()); - } - uint64 missStride = align(handleSize + maxParamSize, handleAlignment); - Array 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; + /* maxParamSize = 0; for (auto& callableGroup : createInfo.callableGroups) { maxParamSize = std::max(maxParamSize, callableGroup.parameters.size()); } uint64 callableStride = align(handleSize + maxParamSize, handleAlignment); - Array callableSbt(callableStride * createInfo.callableGroups.size()); + + OBufferAllocation callableBuffer = new BufferAllocation(graphics, "CallableSBT", + VkBufferCreateInfo{ + .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, + .pNext = nullptr, + .flags = 0, + .size = callableStride * createInfo.callableGroups.size(), + .usage = sbtBufferUsage, + }, + VmaAllocationCreateInfo{ + .usage = sbtMemoryUsage, + }, + Gfx::QueueType::GRAPHICS); + uint8* callableData = static_cast(callableBuffer->map()); 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(), + 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(rayGenBuffer->map()); + std::memcpy(rayGenData, sbt.data() + sbtOffset, handleSize); + rayGenBuffer->unmap(); + sbtOffset += handleSizeAligned; - OBufferAllocation callableBuffer = - new BufferAllocation(graphics, "CallableSBT", - VkBufferCreateInfo{ - .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, - .pNext = nullptr, - .flags = 0, - .size = callableSbt.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); - callableBuffer->updateContents(0, callableSbt.size(), callableSbt.data()); - callableBuffer->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); + uint8* hitData = static_cast(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(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, - std::move(missBuffer), missStride, std::move(callableBuffer), callableStride, createInfo.pipelineLayout); + new RayTracingPipeline(graphics, pipelineHandle, std::move(rayGenBuffer), handleSizeAligned, std::move(hitBuffer), + handleSizeAligned, std::move(missBuffer), handleSizeAligned, nullptr, 0, createInfo.pipelineLayout); PRayTracingPipeline handle = pipeline; rayTracingPipelines[hash] = std::move(pipeline); return handle; diff --git a/src/Engine/Graphics/Vulkan/RayTracing.cpp b/src/Engine/Graphics/Vulkan/RayTracing.cpp index a301a3a..99c5bf2 100644 --- a/src/Engine/Graphics/Vulkan/RayTracing.cpp +++ b/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; diff --git a/src/Engine/Graphics/Vulkan/RayTracing.h b/src/Engine/Graphics/Vulkan/RayTracing.h index b7a1d10..3e6ff9e 100644 --- a/src/Engine/Graphics/Vulkan/RayTracing.h +++ b/src/Engine/Graphics/Vulkan/RayTracing.h @@ -83,9 +83,9 @@ class RayTracingPipeline : public Gfx::RayTracingPipeline { } VkStridedDeviceAddressRegionKHR getCallableRegion() { return VkStridedDeviceAddressRegionKHR{ - .deviceAddress = callable->deviceAddress, - .stride = callableStride, - .size = callable->size, + .deviceAddress = 0,//callable->deviceAddress, + .stride = 0,//callableStride, + .size = 0,//callable->size, }; } VkPipelineLayout getLayout() const { return layout.cast()->getHandle(); } diff --git a/src/Engine/Graphics/Vulkan/Resources.cpp b/src/Engine/Graphics/Vulkan/Resources.cpp index e9a56cd..51526f8 100644 --- a/src/Engine/Graphics/Vulkan/Resources.cpp +++ b/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)); } diff --git a/src/Engine/Scene/LightEnvironment.cpp b/src/Engine/Scene/LightEnvironment.cpp index 2076a54..11a6491 100644 --- a/src/Engine/Scene/LightEnvironment.cpp +++ b/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(), }); - - lightEnvBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_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); + pointLights->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); set->updateBuffer(0, lightEnvBuffer); set->updateBuffer(1, directionalLights); set->updateBuffer(2, pointLights); diff --git a/src/Engine/ThreadPool.h b/src/Engine/ThreadPool.h index 778f478..15e4e2e 100644 --- a/src/Engine/ThreadPool.h +++ b/src/Engine/ThreadPool.h @@ -10,7 +10,7 @@ class ThreadPool { ThreadPool(uint32 numWorkers = std::thread::hardware_concurrency() - 2); ~ThreadPool(); void runAndWait(List> functions); - + void runAsync(std::function func); private: struct Task { uint64 numRemaining = 0;