zdoom/zdray
0
0
Fork 0
mirror of https://github.com/ZDoom/ZDRay.git synced 2025-03-13 03:33:30 +00:00
Code Issues Projects Releases Packages Wiki Activity

Update builders to use the new form also used by the gzd backend

Browse source
This commit is contained in:
Magnus Norddahl 2022-06-29 20:12:36 +02:00
parent 29d38a2969
commit d88c2ef41c
6 changed files with 1855 additions and 1660 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

432
src/lightmap/gpuraytracer.cpp
View file

@ -167,9 +167,9 @@ void GPURaytracer::CreateVulkanObjects()
CreatePipeline(); CreatePipeline();
CreateDescriptorSet(); CreateDescriptorSet();
PipelineBarrier finishbuildbarrier; PipelineBarrier()
finishbuildbarrier.addMemory(VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR); .AddMemory(VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR)
finishbuildbarrier.execute(cmdbuffer.get(), VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR); .Execute(cmdbuffer.get(), VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
} }
void GPURaytracer::UploadTasks(const TraceTask* tasks, size_t size) void GPURaytracer::UploadTasks(const TraceTask* tasks, size_t size)
@ -210,9 +210,9 @@ void GPURaytracer::UploadTasks(const TraceTask* tasks, size_t size)
} }
imageTransferBuffer->Unmap(); imageTransferBuffer->Unmap();
PipelineBarrier barrier1; PipelineBarrier()
barrier1.addImage(startPositionsImage.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, VK_ACCESS_TRANSFER_WRITE_BIT); .AddImage(startPositionsImage.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, VK_ACCESS_TRANSFER_WRITE_BIT)
barrier1.execute(cmdbuffer.get(), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); .Execute(cmdbuffer.get(), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
VkBufferImageCopy region = {}; VkBufferImageCopy region = {};
region.bufferOffset = 0; region.bufferOffset = 0;
@ -223,12 +223,12 @@ void GPURaytracer::UploadTasks(const TraceTask* tasks, size_t size)
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
cmdbuffer->copyBufferToImage(imageTransferBuffer->buffer, startPositionsImage->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region); cmdbuffer->copyBufferToImage(imageTransferBuffer->buffer, startPositionsImage->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
PipelineBarrier barrier2; PipelineBarrier()
barrier2.addBuffer(uniformBuffer.get(), VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT); .AddBuffer(uniformBuffer.get(), VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT)
barrier2.addImage(startPositionsImage.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT); .AddImage(startPositionsImage.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT)
barrier2.addImage(positionsImage.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, 0, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT); .AddImage(positionsImage.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, 0, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT)
barrier2.addImage(outputImage.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, 0, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT); .AddImage(outputImage.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, 0, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT)
barrier2.execute(cmdbuffer.get(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR); .Execute(cmdbuffer.get(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
} }
void GPURaytracer::BeginTracing() void GPURaytracer::BeginTracing()
@ -256,10 +256,10 @@ void GPURaytracer::RunTrace(const Uniforms& uniforms, const VkStridedDeviceAddre
bool needbarrier = true; bool needbarrier = true;
if (uniformsIndex == 0) if (uniformsIndex == 0)
{ {
PipelineBarrier barrier; PipelineBarrier()
barrier.addBuffer(uniformBuffer.get(), VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT); .AddBuffer(uniformBuffer.get(), VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT)
barrier.addImage(positionsImage.get(), VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT); .AddImage(positionsImage.get(), VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT)
barrier.execute(cmdbuffer.get(), VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR); .Execute(cmdbuffer.get(), VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
needbarrier = false; needbarrier = false;
} }
uniformsIndex++; uniformsIndex++;
@ -272,9 +272,9 @@ void GPURaytracer::RunTrace(const Uniforms& uniforms, const VkStridedDeviceAddre
if (needbarrier) if (needbarrier)
{ {
PipelineBarrier barrier; PipelineBarrier()
barrier.addImage(positionsImage.get(), VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT); .AddImage(positionsImage.get(), VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT)
barrier.execute(cmdbuffer.get(), VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR); .Execute(cmdbuffer.get(), VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
} }
PushConstants constants = {}; PushConstants constants = {};
@ -304,9 +304,9 @@ void GPURaytracer::SubmitCommands()
{ {
auto submitFence = std::make_unique<VulkanFence>(device.get()); auto submitFence = std::make_unique<VulkanFence>(device.get());
QueueSubmit submit; QueueSubmit()
submit.addCommandBuffer(cmdbuffer.get()); .AddCommandBuffer(cmdbuffer.get())
submit.execute(device.get(), device->graphicsQueue, submitFence.get()); .Execute(device.get(), device->graphicsQueue, submitFence.get());
VkResult result = vkWaitForFences(device->device, 1, &submitFence->fence, VK_TRUE, std::numeric_limits<uint64_t>::max()); VkResult result = vkWaitForFences(device->device, 1, &submitFence->fence, VK_TRUE, std::numeric_limits<uint64_t>::max());
if (result != VK_SUCCESS) if (result != VK_SUCCESS)
@ -319,9 +319,9 @@ void GPURaytracer::SubmitCommands()
void GPURaytracer::DownloadTasks(const TraceTask* tasks, size_t size) void GPURaytracer::DownloadTasks(const TraceTask* tasks, size_t size)
{ {
PipelineBarrier barrier4; PipelineBarrier()
barrier4.addImage(outputImage.get(), VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT); .AddImage(outputImage.get(), VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT)
barrier4.execute(cmdbuffer.get(), VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_TRANSFER_BIT); .Execute(cmdbuffer.get(), VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_TRANSFER_BIT);
VkBufferImageCopy region = {}; VkBufferImageCopy region = {};
region.bufferOffset = 0; region.bufferOffset = 0;
@ -438,41 +438,42 @@ void GPURaytracer::CreateVertexAndIndexBuffers()
size_t surfaceoffset = surfaceindexoffset + surfaceindexbuffersize; size_t surfaceoffset = surfaceindexoffset + surfaceindexbuffersize;
size_t lightoffset = surfaceoffset + surfacebuffersize; size_t lightoffset = surfaceoffset + surfacebuffersize;
BufferBuilder vbuilder; vertexBuffer = BufferBuilder()
vbuilder.setUsage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); .Usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
vbuilder.setSize(vertexbuffersize); .Size(vertexbuffersize)
vertexBuffer = vbuilder.create(device.get()); .DebugName("vertexBuffer")
vertexBuffer->SetDebugName("vertexBuffer"); .Create(device.get());
BufferBuilder ibuilder; indexBuffer = BufferBuilder()
ibuilder.setUsage(VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); .Usage(VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
ibuilder.setSize(indexbuffersize); .Size(indexbuffersize)
indexBuffer = ibuilder.create(device.get()); .DebugName("indexBuffer")
indexBuffer->SetDebugName("indexBuffer"); .Create(device.get());
BufferBuilder sibuilder; surfaceIndexBuffer = BufferBuilder()
sibuilder.setUsage(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT); .Usage(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT)
sibuilder.setSize(surfaceindexbuffersize); .Size(surfaceindexbuffersize)
surfaceIndexBuffer = sibuilder.create(device.get()); .DebugName("surfaceIndexBuffer")
surfaceIndexBuffer->SetDebugName("surfaceIndexBuffer"); .Create(device.get());
BufferBuilder sbuilder; surfaceBuffer = BufferBuilder()
sbuilder.setUsage(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT); .Usage(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT)
sbuilder.setSize(surfacebuffersize); .Size(surfacebuffersize)
surfaceBuffer = sbuilder.create(device.get()); .DebugName("surfaceBuffer")
surfaceBuffer->SetDebugName("surfaceBuffer"); .Create(device.get());
BufferBuilder lbuilder; lightBuffer = BufferBuilder()
lbuilder.setUsage(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT); .Usage(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT)
lbuilder.setSize(lightbuffersize); .Size(lightbuffersize)
lightBuffer = lbuilder.create(device.get()); .DebugName("lightBuffer")
lightBuffer->SetDebugName("lightBuffer"); .Create(device.get());
transferBuffer = BufferBuilder()
.Usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY)
.Size(transferbuffersize)
.DebugName("transferBuffer")
.Create(device.get());
BufferBuilder tbuilder;
tbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY);
tbuilder.setSize(transferbuffersize);
transferBuffer = tbuilder.create(device.get());
transferBuffer->SetDebugName("transferBuffer");
uint8_t* data = (uint8_t*)transferBuffer->Map(0, transferbuffersize); uint8_t* data = (uint8_t*)transferBuffer->Map(0, transferbuffersize);
memcpy(data + vertexoffset, mesh->MeshVertices.Data(), vertexbuffersize); memcpy(data + vertexoffset, mesh->MeshVertices.Data(), vertexbuffersize);
memcpy(data + indexoffset, mesh->MeshElements.Data(), indexbuffersize); memcpy(data + indexoffset, mesh->MeshElements.Data(), indexbuffersize);
@ -531,11 +532,11 @@ void GPURaytracer::CreateBottomLevelAccelerationStructure()
VkAccelerationStructureBuildSizesInfoKHR sizeInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR }; VkAccelerationStructureBuildSizesInfoKHR sizeInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR };
vkGetAccelerationStructureBuildSizesKHR(device->device, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &buildInfo, &maxPrimitiveCount, &sizeInfo); vkGetAccelerationStructureBuildSizesKHR(device->device, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &buildInfo, &maxPrimitiveCount, &sizeInfo);
BufferBuilder blbufbuilder; blAccelStructBuffer = BufferBuilder()
blbufbuilder.setUsage(VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT); .Usage(VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT)
blbufbuilder.setSize(sizeInfo.accelerationStructureSize); .Size(sizeInfo.accelerationStructureSize)
blAccelStructBuffer = blbufbuilder.create(device.get()); .DebugName("blAccelStructBuffer")
blAccelStructBuffer->SetDebugName("blAccelStructBuffer"); .Create(device.get());
VkAccelerationStructureKHR blAccelStructHandle = {}; VkAccelerationStructureKHR blAccelStructHandle = {};
VkAccelerationStructureCreateInfoKHR createInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR }; VkAccelerationStructureCreateInfoKHR createInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR };
@ -547,11 +548,11 @@ void GPURaytracer::CreateBottomLevelAccelerationStructure()
throw std::runtime_error("vkCreateAccelerationStructureKHR failed"); throw std::runtime_error("vkCreateAccelerationStructureKHR failed");
blAccelStruct = std::make_unique<VulkanAccelerationStructure>(device.get(), blAccelStructHandle); blAccelStruct = std::make_unique<VulkanAccelerationStructure>(device.get(), blAccelStructHandle);
BufferBuilder sbuilder; blScratchBuffer = BufferBuilder()
sbuilder.setUsage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); .Usage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
sbuilder.setSize(sizeInfo.buildScratchSize); .Size(sizeInfo.buildScratchSize)
blScratchBuffer = sbuilder.create(device.get()); .DebugName("blScratchBuffer")
blScratchBuffer->SetDebugName("blScratchBuffer"); .Create(device.get());
info = { VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO }; info = { VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO };
info.buffer = blScratchBuffer->buffer; info.buffer = blScratchBuffer->buffer;
@ -579,20 +580,21 @@ void GPURaytracer::CreateTopLevelAccelerationStructure()
instance.mask = 0xff; instance.mask = 0xff;
instance.instanceShaderBindingTableRecordOffset = 0; instance.instanceShaderBindingTableRecordOffset = 0;
BufferBuilder tbuilder; tlTransferBuffer = BufferBuilder()
tbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY); .Usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY)
tbuilder.setSize(sizeof(VkAccelerationStructureInstanceKHR)); .Size(sizeof(VkAccelerationStructureInstanceKHR))
tlTransferBuffer = tbuilder.create(device.get()); .DebugName("tlTransferBuffer")
tlTransferBuffer->SetDebugName("tlTransferBuffer"); .Create(device.get());
auto data = (uint8_t*)tlTransferBuffer->Map(0, sizeof(VkAccelerationStructureInstanceKHR)); auto data = (uint8_t*)tlTransferBuffer->Map(0, sizeof(VkAccelerationStructureInstanceKHR));
memcpy(data, &instance, sizeof(VkAccelerationStructureInstanceKHR)); memcpy(data, &instance, sizeof(VkAccelerationStructureInstanceKHR));
tlTransferBuffer->Unmap(); tlTransferBuffer->Unmap();
BufferBuilder instbufbuilder; tlInstanceBuffer = BufferBuilder()
instbufbuilder.setUsage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_DST_BIT); .Usage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_DST_BIT)
instbufbuilder.setSize(sizeof(VkAccelerationStructureInstanceKHR)); .Size(sizeof(VkAccelerationStructureInstanceKHR))
tlInstanceBuffer = instbufbuilder.create(device.get()); .DebugName("tlInstanceBuffer")
tlInstanceBuffer->SetDebugName("tlInstanceBuffer"); .Create(device.get());
cmdbuffer->copyBuffer(tlTransferBuffer.get(), tlInstanceBuffer.get()); cmdbuffer->copyBuffer(tlTransferBuffer.get(), tlInstanceBuffer.get());
@ -628,11 +630,11 @@ void GPURaytracer::CreateTopLevelAccelerationStructure()
VkAccelerationStructureBuildSizesInfoKHR sizeInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR }; VkAccelerationStructureBuildSizesInfoKHR sizeInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR };
vkGetAccelerationStructureBuildSizesKHR(device->device, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &buildInfo, &maxInstanceCount, &sizeInfo); vkGetAccelerationStructureBuildSizesKHR(device->device, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &buildInfo, &maxInstanceCount, &sizeInfo);
BufferBuilder tlbufbuilder; tlAccelStructBuffer = BufferBuilder()
tlbufbuilder.setUsage(VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT); .Usage(VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT)
tlbufbuilder.setSize(sizeInfo.accelerationStructureSize); .Size(sizeInfo.accelerationStructureSize)
tlAccelStructBuffer = tlbufbuilder.create(device.get()); .DebugName("tlAccelStructBuffer")
tlAccelStructBuffer->SetDebugName("tlAccelStructBuffer"); .Create(device.get());
VkAccelerationStructureKHR tlAccelStructHandle = {}; VkAccelerationStructureKHR tlAccelStructHandle = {};
VkAccelerationStructureCreateInfoKHR createInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR }; VkAccelerationStructureCreateInfoKHR createInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR };
@ -644,11 +646,11 @@ void GPURaytracer::CreateTopLevelAccelerationStructure()
throw std::runtime_error("vkCreateAccelerationStructureKHR failed"); throw std::runtime_error("vkCreateAccelerationStructureKHR failed");
tlAccelStruct = std::make_unique<VulkanAccelerationStructure>(device.get(), tlAccelStructHandle); tlAccelStruct = std::make_unique<VulkanAccelerationStructure>(device.get(), tlAccelStructHandle);
BufferBuilder sbuilder; tlScratchBuffer = BufferBuilder()
sbuilder.setUsage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); .Usage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
sbuilder.setSize(sizeInfo.buildScratchSize); .Size(sizeInfo.buildScratchSize)
tlScratchBuffer = sbuilder.create(device.get()); .DebugName("tlScratchBuffer")
tlScratchBuffer->SetDebugName("tlScratchBuffer"); .Create(device.get());
info = { VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO }; info = { VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO };
info.buffer = tlScratchBuffer->buffer; info.buffer = tlScratchBuffer->buffer;
@ -680,11 +682,10 @@ std::unique_ptr<VulkanShader> GPURaytracer::CompileRayGenShader(const char* code
{ {
try try
{ {
ShaderBuilder builder; return ShaderBuilder()
builder.setRayGenShader(code); .RayGenShader(code)
auto shader = builder.create(device.get()); .DebugName(name)
shader->SetDebugName(name); .Create(name, device.get());
return shader;
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
@ -696,11 +697,10 @@ std::unique_ptr<VulkanShader> GPURaytracer::CompileClosestHitShader(const char*
{ {
try try
{ {
ShaderBuilder builder; return ShaderBuilder()
builder.setClosestHitShader(code); .ClosestHitShader(code)
auto shader = builder.create(device.get()); .DebugName(name)
shader->SetDebugName(name); .Create(name, device.get());
return shader;
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
@ -712,11 +712,10 @@ std::unique_ptr<VulkanShader> GPURaytracer::CompileMissShader(const char* code,
{ {
try try
{ {
ShaderBuilder builder; return ShaderBuilder()
builder.setMissShader(code); .MissShader(code)
auto shader = builder.create(device.get()); .DebugName(name)
shader->SetDebugName(name); .Create(name, device.get());
return shader;
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
@ -726,51 +725,51 @@ std::unique_ptr<VulkanShader> GPURaytracer::CompileMissShader(const char* code,
void GPURaytracer::CreatePipeline() void GPURaytracer::CreatePipeline()
{ {
DescriptorSetLayoutBuilder setbuilder; descriptorSetLayout = DescriptorSetLayoutBuilder()
setbuilder.addBinding(0, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR); .AddBinding(0, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR)
setbuilder.addBinding(1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR); .AddBinding(1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR)
setbuilder.addBinding(2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR); .AddBinding(2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR)
setbuilder.addBinding(3, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR); .AddBinding(3, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR)
setbuilder.addBinding(4, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR); .AddBinding(4, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR)
setbuilder.addBinding(5, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR); .AddBinding(5, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR)
setbuilder.addBinding(6, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR); .AddBinding(6, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR)
setbuilder.addBinding(7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR); .AddBinding(7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_RAYGEN_BIT_KHR)
descriptorSetLayout = setbuilder.create(device.get()); .DebugName("descriptorSetLayout")
descriptorSetLayout->SetDebugName("descriptorSetLayout"); .Create(device.get());
PipelineLayoutBuilder layoutbuilder; pipelineLayout = PipelineLayoutBuilder()
layoutbuilder.addSetLayout(descriptorSetLayout.get()); .AddSetLayout(descriptorSetLayout.get())
layoutbuilder.addPushConstantRange(VK_SHADER_STAGE_RAYGEN_BIT_KHR, 0, sizeof(PushConstants)); .AddPushConstantRange(VK_SHADER_STAGE_RAYGEN_BIT_KHR, 0, sizeof(PushConstants))
pipelineLayout = layoutbuilder.create(device.get()); .DebugName("pipelineLayout")
pipelineLayout->SetDebugName("pipelineLayout"); .Create(device.get());
RayTracingPipelineBuilder builder; pipeline = RayTracingPipelineBuilder()
builder.setLayout(pipelineLayout.get()); .Layout(pipelineLayout.get())
builder.setMaxPipelineRayRecursionDepth(1); .MaxPipelineRayRecursionDepth(1)
builder.addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenBounce.get()); .AddShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenBounce.get())
builder.addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenLight.get()); .AddShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenLight.get())
builder.addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenAmbient.get()); .AddShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenAmbient.get())
builder.addShader(VK_SHADER_STAGE_MISS_BIT_KHR, rmissBounce.get()); .AddShader(VK_SHADER_STAGE_MISS_BIT_KHR, rmissBounce.get())
builder.addShader(VK_SHADER_STAGE_MISS_BIT_KHR, rmissLight.get()); .AddShader(VK_SHADER_STAGE_MISS_BIT_KHR, rmissLight.get())
builder.addShader(VK_SHADER_STAGE_MISS_BIT_KHR, rmissSun.get()); .AddShader(VK_SHADER_STAGE_MISS_BIT_KHR, rmissSun.get())
builder.addShader(VK_SHADER_STAGE_MISS_BIT_KHR, rmissAmbient.get()); .AddShader(VK_SHADER_STAGE_MISS_BIT_KHR, rmissAmbient.get())
builder.addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, rchitBounce.get()); .AddShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, rchitBounce.get())
builder.addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, rchitLight.get()); .AddShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, rchitLight.get())
builder.addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, rchitSun.get()); .AddShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, rchitSun.get())
builder.addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, rchitAmbient.get()); .AddShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, rchitAmbient.get())
builder.addRayGenGroup(0); .AddRayGenGroup(0)
builder.addRayGenGroup(1); .AddRayGenGroup(1)
builder.addRayGenGroup(2); .AddRayGenGroup(2)
builder.addMissGroup(3); .AddMissGroup(3)
builder.addMissGroup(4); .AddMissGroup(4)
builder.addMissGroup(5); .AddMissGroup(5)
builder.addMissGroup(6); .AddMissGroup(6)
builder.addTrianglesHitGroup(7); .AddTrianglesHitGroup(7)
builder.addTrianglesHitGroup(8); .AddTrianglesHitGroup(8)
builder.addTrianglesHitGroup(9); .AddTrianglesHitGroup(9)
builder.addTrianglesHitGroup(10); .AddTrianglesHitGroup(10)
pipeline = builder.create(device.get()); .DebugName("pipeline")
pipeline->SetDebugName("pipeline"); .Create(device.get());
const auto& rtProperties = device->physicalDevice.rayTracingProperties; const auto& rtProperties = device->physicalDevice.rayTracingProperties;
@ -804,17 +803,18 @@ void GPURaytracer::CreatePipeline()
VkDeviceSize sbtBufferSize = rgenSize + missRegion.size + hitRegion.size; VkDeviceSize sbtBufferSize = rgenSize + missRegion.size + hitRegion.size;
BufferBuilder bufbuilder; shaderBindingTable = BufferBuilder()
bufbuilder.setUsage(VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT); .Usage(VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT)
bufbuilder.setSize(sbtBufferSize); .Size(sbtBufferSize)
shaderBindingTable = bufbuilder.create(device.get()); .DebugName("shaderBindingTable")
shaderBindingTable->SetDebugName("shaderBindingTable"); .Create(device.get());
sbtTransferBuffer = BufferBuilder()
.Usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY)
.Size(sbtBufferSize)
.DebugName("sbtTransferBuffer")
.Create(device.get());
BufferBuilder tbuilder;
tbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY);
tbuilder.setSize(sbtBufferSize);
sbtTransferBuffer = tbuilder.create(device.get());
sbtTransferBuffer->SetDebugName("sbtTransferBuffer");
uint8_t* src = (uint8_t*)pipeline->shaderGroupHandles.data(); uint8_t* src = (uint8_t*)pipeline->shaderGroupHandles.data();
uint8_t* dest = (uint8_t*)sbtTransferBuffer->Map(0, sbtBufferSize); uint8_t* dest = (uint8_t*)sbtTransferBuffer->Map(0, sbtBufferSize);
for (VkDeviceSize i = 0; i < raygenCount; i++) for (VkDeviceSize i = 0; i < raygenCount; i++)
@ -857,82 +857,82 @@ void GPURaytracer::CreateDescriptorSet()
VkDeviceSize align = device->physicalDevice.properties.limits.minUniformBufferOffsetAlignment; VkDeviceSize align = device->physicalDevice.properties.limits.minUniformBufferOffsetAlignment;
uniformStructStride = (sizeof(Uniforms) + align - 1) / align * align; uniformStructStride = (sizeof(Uniforms) + align - 1) / align * align;
BufferBuilder uniformbuilder; uniformBuffer = BufferBuilder()
uniformbuilder.setUsage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT); .Usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT)
uniformbuilder.setSize(uniformStructs * uniformStructStride); .Size(uniformStructs * uniformStructStride)
uniformBuffer = uniformbuilder.create(device.get()); .DebugName("uniformBuffer")
uniformBuffer->SetDebugName("uniformBuffer"); .Create(device.get());
BufferBuilder uniformtransferbuilder; uniformTransferBuffer = BufferBuilder()
uniformtransferbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU); .Usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU)
uniformtransferbuilder.setSize(uniformStructs * uniformStructStride); .Size(uniformStructs * uniformStructStride)
uniformTransferBuffer = uniformtransferbuilder.create(device.get()); .DebugName("uniformTransferBuffer")
uniformTransferBuffer->SetDebugName("uniformTransferBuffer"); .Create(device.get());
BufferBuilder itbuilder; imageTransferBuffer = BufferBuilder()
itbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY); .Usage(VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY)
itbuilder.setSize(2 * sizeof(vec4) * rayTraceImageSize * rayTraceImageSize); .Size(2 * sizeof(vec4) * rayTraceImageSize * rayTraceImageSize)
imageTransferBuffer = itbuilder.create(device.get()); .DebugName("imageTransferBuffer")
imageTransferBuffer->SetDebugName("imageTransferBuffer"); .Create(device.get());
ImageBuilder imgbuilder1; startPositionsImage = ImageBuilder()
imgbuilder1.setUsage(VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); .Usage(VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT)
imgbuilder1.setFormat(VK_FORMAT_R32G32B32A32_SFLOAT); .Format(VK_FORMAT_R32G32B32A32_SFLOAT)
imgbuilder1.setSize(rayTraceImageSize, rayTraceImageSize); .Size(rayTraceImageSize, rayTraceImageSize)
startPositionsImage = imgbuilder1.create(device.get()); .DebugName("startPositionsImage")
startPositionsImage->SetDebugName("startPositionsImage"); .Create(device.get());
ImageBuilder imgbuilder2; positionsImage = ImageBuilder()
imgbuilder2.setUsage(VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); .Usage(VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT)
imgbuilder2.setFormat(VK_FORMAT_R32G32B32A32_SFLOAT); .Format(VK_FORMAT_R32G32B32A32_SFLOAT)
imgbuilder2.setSize(rayTraceImageSize, rayTraceImageSize); .Size(rayTraceImageSize, rayTraceImageSize)
positionsImage = imgbuilder2.create(device.get()); .DebugName("positionsImage")
positionsImage->SetDebugName("positionsImage"); .Create(device.get());
ImageBuilder imgbuilder3; outputImage = ImageBuilder()
imgbuilder3.setUsage(VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT); .Usage(VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
imgbuilder3.setFormat(VK_FORMAT_R32G32B32A32_SFLOAT); .Format(VK_FORMAT_R32G32B32A32_SFLOAT)
imgbuilder3.setSize(rayTraceImageSize, rayTraceImageSize); .Size(rayTraceImageSize, rayTraceImageSize)
outputImage = imgbuilder3.create(device.get()); .DebugName("outputImage")
outputImage->SetDebugName("outputImage"); .Create(device.get());
ImageViewBuilder viewbuilder1; startPositionsImageView = ImageViewBuilder()
viewbuilder1.setImage(startPositionsImage.get(), VK_FORMAT_R32G32B32A32_SFLOAT); .Image(startPositionsImage.get(), VK_FORMAT_R32G32B32A32_SFLOAT)
startPositionsImageView = viewbuilder1.create(device.get()); .DebugName("startPositionsImageView")
startPositionsImageView->SetDebugName("startPositionsImageView"); .Create(device.get());
ImageViewBuilder viewbuilder2; positionsImageView = ImageViewBuilder()
viewbuilder2.setImage(positionsImage.get(), VK_FORMAT_R32G32B32A32_SFLOAT); .Image(positionsImage.get(), VK_FORMAT_R32G32B32A32_SFLOAT)
positionsImageView = viewbuilder2.create(device.get()); .DebugName("positionsImageView")
positionsImageView->SetDebugName("positionsImageView"); .Create(device.get());
ImageViewBuilder viewbuilder3; outputImageView = ImageViewBuilder()
viewbuilder3.setImage(outputImage.get(), VK_FORMAT_R32G32B32A32_SFLOAT); .Image(outputImage.get(), VK_FORMAT_R32G32B32A32_SFLOAT)
outputImageView = viewbuilder3.create(device.get()); .DebugName("outputImageView")
outputImageView->SetDebugName("outputImageView"); .Create(device.get());
DescriptorPoolBuilder poolbuilder; descriptorPool = DescriptorPoolBuilder()
poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1); .AddPoolSize(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1)
poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 3); .AddPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 3)
poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1); .AddPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1)
poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 3); .AddPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 3)
poolbuilder.setMaxSets(1); .MaxSets(1)
descriptorPool = poolbuilder.create(device.get()); .DebugName("descriptorPool")
descriptorPool->SetDebugName("descriptorPool"); .Create(device.get());
descriptorSet = descriptorPool->allocate(descriptorSetLayout.get()); descriptorSet = descriptorPool->allocate(descriptorSetLayout.get());
descriptorSet->SetDebugName("descriptorSet"); descriptorSet->SetDebugName("descriptorSet");
WriteDescriptors write; WriteDescriptors()
write.addAccelerationStructure(descriptorSet.get(), 0, tlAccelStruct.get()); .AddAccelerationStructure(descriptorSet.get(), 0, tlAccelStruct.get())
write.addStorageImage(descriptorSet.get(), 1, startPositionsImageView.get(), VK_IMAGE_LAYOUT_GENERAL); .AddStorageImage(descriptorSet.get(), 1, startPositionsImageView.get(), VK_IMAGE_LAYOUT_GENERAL)
write.addStorageImage(descriptorSet.get(), 2, positionsImageView.get(), VK_IMAGE_LAYOUT_GENERAL); .AddStorageImage(descriptorSet.get(), 2, positionsImageView.get(), VK_IMAGE_LAYOUT_GENERAL)
write.addStorageImage(descriptorSet.get(), 3, outputImageView.get(), VK_IMAGE_LAYOUT_GENERAL); .AddStorageImage(descriptorSet.get(), 3, outputImageView.get(), VK_IMAGE_LAYOUT_GENERAL)
write.addBuffer(descriptorSet.get(), 4, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, uniformBuffer.get(), 0, sizeof(Uniforms)); .AddBuffer(descriptorSet.get(), 4, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, uniformBuffer.get(), 0, sizeof(Uniforms))
write.addBuffer(descriptorSet.get(), 5, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, surfaceIndexBuffer.get()); .AddBuffer(descriptorSet.get(), 5, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, surfaceIndexBuffer.get())
write.addBuffer(descriptorSet.get(), 6, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, surfaceBuffer.get()); .AddBuffer(descriptorSet.get(), 6, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, surfaceBuffer.get())
write.addBuffer(descriptorSet.get(), 7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, lightBuffer.get()); .AddBuffer(descriptorSet.get(), 7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, lightBuffer.get())
write.updateSets(device.get()); .Execute(device.get());
} }
void GPURaytracer::PrintVulkanInfo() void GPURaytracer::PrintVulkanInfo()

1614
src/lightmap/vulkanbuilders.cpp
View file

File diff suppressed because it is too large Load diff

1458
src/lightmap/vulkanbuilders.h
View file

File diff suppressed because it is too large Load diff

4
src/lightmap/vulkandevice.cpp
View file

@ -167,7 +167,7 @@ bool VulkanDevice::supportsDeviceExtension(const char *ext) const
void VulkanDevice::createAllocator() void VulkanDevice::createAllocator()
{ {
VmaAllocatorCreateInfo allocinfo = {}; VmaAllocatorCreateInfo allocinfo = {};
allocinfo.vulkanApiVersion = VK_API_VERSION_1_2; allocinfo.vulkanApiVersion = ApiVersion;
if (supportsDeviceExtension(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME) && supportsDeviceExtension(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME)) if (supportsDeviceExtension(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME) && supportsDeviceExtension(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME))
allocinfo.flags = VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT; allocinfo.flags = VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT;
allocinfo.flags |= VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT; allocinfo.flags |= VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT;
@ -321,7 +321,7 @@ void VulkanDevice::createInstance()
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0); appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName = "ZDRay"; appInfo.pEngineName = "ZDRay";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0); appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_2; appInfo.apiVersion = ApiVersion;
VkInstanceCreateInfo createInfo = {}; VkInstanceCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;

2
src/lightmap/vulkandevice.h
View file

@ -103,6 +103,8 @@ public:
std::vector<VulkanPhysicalDevice> availableDevices; std::vector<VulkanPhysicalDevice> availableDevices;
std::vector<VulkanCompatibleDevice> supportedDevices; std::vector<VulkanCompatibleDevice> supportedDevices;
uint32_t ApiVersion = VK_API_VERSION_1_2;
RENDERDOC_API_1_4_2* renderdoc = nullptr; RENDERDOC_API_1_4_2* renderdoc = nullptr;
static void initVolk(); static void initVolk();

5
src/lightmap/vulkanobjects.h
View file

@ -81,7 +81,7 @@ private:
class VulkanImage class VulkanImage
{ {
public: public:
VulkanImage(VulkanDevice *device, VkImage image, VmaAllocation allocation, int width, int height, int mipLevels); VulkanImage(VulkanDevice *device, VkImage image, VmaAllocation allocation, int width, int height, int mipLevels, int layerCount);
~VulkanImage(); ~VulkanImage();
void SetDebugName(const char *name) { device->setDebugObjectName(name, (uint64_t)image, VK_OBJECT_TYPE_IMAGE); } void SetDebugName(const char *name) { device->setDebugObjectName(name, (uint64_t)image, VK_OBJECT_TYPE_IMAGE); }
@ -90,6 +90,7 @@ public:
int width = 0; int width = 0;
int height = 0; int height = 0;
int mipLevels = 1; int mipLevels = 1;
int layerCount = 1;
void *Map(size_t offset, size_t size); void *Map(size_t offset, size_t size);
void Unmap(); void Unmap();
@ -1018,7 +1019,7 @@ inline VulkanFramebuffer::~VulkanFramebuffer()
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
inline VulkanImage::VulkanImage(VulkanDevice *device, VkImage image, VmaAllocation allocation, int width, int height, int mipLevels) : image(image), width(width), height(height), mipLevels(mipLevels), device(device), allocation(allocation) inline VulkanImage::VulkanImage(VulkanDevice *device, VkImage image, VmaAllocation allocation, int width, int height, int mipLevels, int layerCount) : image(image), width(width), height(height), mipLevels(mipLevels), layerCount(layerCount), device(device), allocation(allocation)
{ {
} }