Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

More ray tracing changes

Browse Source
This commit is contained in:
Dynamitos
2024-07-12 13:33:52 +02:00
parent a9089bd997
commit 8387ad6ffe
33 changed files with 527 additions and 292 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Graphics/Vulkan/Buffer.cpp
+7 -3
View File
@@ -237,8 +237,7 @@ void Buffer::createBuffer(uint64 size, uint32 destIndex) {
.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE,
};
buffers[destIndex] = new BufferAllocation(graphics, name, info, allocInfo, initialOwner);
if (createCleared)
{
if (createCleared) {
PCommand command = graphics->getQueueCommands(initialOwner)->getCommands();
vkCmdFillBuffer(command->getHandle(), buffers[destIndex]->buffer, 0, VK_WHOLE_SIZE, clearValue);
pipelineBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
@@ -351,6 +350,11 @@ ShaderBuffer::ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo& cre
ShaderBuffer::~ShaderBuffer() {}
void ShaderBuffer::readContents(Array<uint8>& data) {
data.resize(getSize());
getAlloc()->readContents(0, data.size(), data.data());
}
void ShaderBuffer::updateContents(const ShaderBufferCreateInfo& createInfo) {
if (createInfo.sourceData.data == nullptr) {
return;
@@ -407,7 +411,7 @@ IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo& create
: Gfx::IndexBuffer(graphics->getFamilyMapping(), createInfo),
Vulkan::Buffer(graphics, createInfo.sourceData.size,
VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR |
VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
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);
}
src/Engine/Graphics/Vulkan/Buffer.h
+1
View File
@@ -109,6 +109,7 @@ class ShaderBuffer : public Gfx::ShaderBuffer, public Buffer {
public:
ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo& sourceData);
virtual ~ShaderBuffer();
virtual void readContents(Array<uint8>& data) override;
virtual void updateContents(const ShaderBufferCreateInfo& createInfo) override;
virtual void rotateBuffer(uint64 size, bool preserveContents = false) override;
src/Engine/Graphics/Vulkan/Command.cpp
+7 -5
View File
@@ -74,7 +74,6 @@ void Command::endRenderPass() {
}
void Command::executeCommands(Array<Gfx::ORenderCommand> commands) {
assert(state == State::RenderPass);
if (commands.size() == 0) {
// std::cout << "No commands provided" << std::endl;
return;
@@ -253,8 +252,9 @@ void RenderCommand::bindDescriptor(Gfx::PDescriptorSet descriptorSet, Array<uint
VkDescriptorSet setHandle = descriptor->getHandle();
Gfx::PPipelineLayout layout = pipeline != nullptr ? pipeline->getPipelineLayout() : rtPipeline->getPipelineLayout();
vkCmdBindDescriptorSets(handle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->getLayout(), layout->findParameter(descriptorSet->getName()),
1, &setHandle, dynamicOffsets.size(), dynamicOffsets.data());
vkCmdBindDescriptorSets(handle, pipeline != nullptr ? VK_PIPELINE_BIND_POINT_GRAPHICS : VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,
pipeline->getLayout(), layout->findParameter(descriptorSet->getName()), 1, &setHandle, dynamicOffsets.size(),
dynamicOffsets.data());
}
void RenderCommand::bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorSets, Array<uint32> dynamicOffsets) {
@@ -279,7 +279,8 @@ void RenderCommand::bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorS
}
sets[layout->findParameter(descriptorSet->getName())] = descriptorSet->getHandle();
}
vkCmdBindDescriptorSets(handle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->getLayout(), 0, (uint32)descriptorSets.size(), sets,
vkCmdBindDescriptorSets(handle, pipeline != nullptr ? VK_PIPELINE_BIND_POINT_GRAPHICS : VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,
pipeline != nullptr ? pipeline->getLayout() : rtPipeline->getLayout(), 0, (uint32)descriptorSets.size(), sets,
dynamicOffsets.size(), dynamicOffsets.data());
delete[] sets;
}
@@ -334,7 +335,8 @@ void RenderCommand::traceRays(uint32 width, uint32 height, uint32 depth) {
VkStridedDeviceAddressRegionKHR rayGenRef = rtPipeline->getRayGenRegion();
VkStridedDeviceAddressRegionKHR hitRef = rtPipeline->getHitRegion();
VkStridedDeviceAddressRegionKHR missRef = rtPipeline->getMissRegion();
vkCmdTraceRaysKHR(handle, &rayGenRef, &missRef, &hitRef, nullptr, width, height, depth);
VkStridedDeviceAddressRegionKHR callableRef = rtPipeline->getCallableRegion();
vkCmdTraceRaysKHR(handle, &rayGenRef, &missRef, &hitRef, &callableRef, width, height, depth);
}
ComputeCommand::ComputeCommand(PGraphics graphics, VkCommandPool cmdPool) : graphics(graphics), owner(cmdPool) {
src/Engine/Graphics/Vulkan/Descriptor.cpp
+1 -2
View File
@@ -453,12 +453,11 @@ void DescriptorSet::updateSamplerArray(uint32_t binding, Array<Gfx::PSampler> sa
void DescriptorSet::updateAccelerationStructure(uint32 binding, Gfx::PTopLevelAS as) {
auto tlas = as.cast<TopLevelAS>();
auto handle = tlas->getHandle();
accelerationInfos.add(VkWriteDescriptorSetAccelerationStructureKHR{
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
.pNext = nullptr,
.accelerationStructureCount = 1,
.pAccelerationStructures = &handle,
.pAccelerationStructures = &tlas->handle,
});
writeDescriptors.add(VkWriteDescriptorSet{
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
src/Engine/Graphics/Vulkan/Graphics.cpp
+162 -6
View File
@@ -8,6 +8,8 @@
#include "Graphics/Enums.h"
#include "Graphics/Graphics.h"
#include "Graphics/Initializer.h"
#include "Graphics/StaticMeshVertexData.h"
#include "Graphics/slang-compile.h"
#include "PipelineCache.h"
#include "Query.h"
#include "RayTracing.h"
@@ -15,7 +17,6 @@
#include "Shader.h"
#include "Window.h"
#include <GLFW/glfw3.h>
#include "Graphics/slang-compile.h"
#include <cstring>
#include <vulkan/vulkan_core.h>
@@ -91,7 +92,6 @@ void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddre
width, height, depth);
}
Graphics::Graphics() : instance(VK_NULL_HANDLE), handle(VK_NULL_HANDLE), physicalDevice(VK_NULL_HANDLE), callback(VK_NULL_HANDLE) {}
Graphics::~Graphics() {
@@ -189,7 +189,9 @@ Gfx::ORenderCommand Graphics::createRenderCommand(const std::string& name) { ret
Gfx::OComputeCommand Graphics::createComputeCommand(const std::string& name) { return getComputeCommands()->createComputeCommand(name); }
void Graphics::beginShaderCompilation(const ShaderCompilationInfo& createInfo) { beginCompilation(createInfo, SLANG_SPIRV, createInfo.rootSignature); }
void Graphics::beginShaderCompilation(const ShaderCompilationInfo& createInfo) {
beginCompilation(createInfo, SLANG_SPIRV, createInfo.rootSignature);
}
Gfx::OVertexShader Graphics::createVertexShader(const ShaderCreateInfo& createInfo) {
OVertexShader shader = new VertexShader(this);
@@ -319,6 +321,13 @@ void Graphics::resolveTexture(Gfx::PTexture source, Gfx::PTexture destination) {
void Graphics::copyTexture(Gfx::PTexture source, Gfx::PTexture destination) {
PTextureBase src = source.cast<TextureBase>();
PTextureBase dst = destination.cast<TextureBase>();
Gfx::SeImageLayout srcLayout = src->getLayout();
Gfx::SeImageLayout dstLayout = dst->getLayout();
src->changeLayout(Gfx::SE_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, Gfx::SE_ACCESS_MEMORY_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
Gfx::SE_ACCESS_TRANSFER_READ_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT);
dst->changeLayout(Gfx::SE_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, Gfx::SE_ACCESS_MEMORY_WRITE_BIT | Gfx::SE_ACCESS_MEMORY_READ_BIT,
Gfx::SE_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT);
VkImageBlit blit = {
.srcSubresource =
{
@@ -349,6 +358,12 @@ void Graphics::copyTexture(Gfx::PTexture source, Gfx::PTexture destination) {
vkCmdBlitImage(command->getHandle(), src->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst->getImage(),
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit,
src->getAspect() & VK_IMAGE_ASPECT_DEPTH_BIT ? VK_FILTER_NEAREST : VK_FILTER_LINEAR);
src->changeLayout(srcLayout, Gfx::SE_ACCESS_TRANSFER_READ_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
Gfx::SE_ACCESS_MEMORY_READ_BIT | Gfx::SE_ACCESS_MEMORY_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
dst->changeLayout(dstLayout, Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
Gfx::SE_ACCESS_MEMORY_READ_BIT | Gfx::SE_ACCESS_MEMORY_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
}
Gfx::OBottomLevelAS Graphics::createBottomLevelAccelerationStructure(const Gfx::BottomLevelASCreateInfo& createInfo) {
@@ -359,6 +374,148 @@ Gfx::OTopLevelAS Graphics::createTopLevelAccelerationStructure(const Gfx::TopLev
return new TopLevelAS(this, createInfo);
}
void Graphics::buildBottomLevelAccelerationStructures(Array<Gfx::PBottomLevelAS> data) {
Gfx::PShaderBuffer positionBuffer = StaticMeshVertexData::getInstance()->getPositionBuffer();
Gfx::PIndexBuffer indexBuffer = StaticMeshVertexData::getInstance()->getIndexBuffer();
VkBufferCreateInfo transformBufferInfo = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = sizeof(VkTransformMatrixKHR) * data.size(),
.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT |
VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
};
VmaAllocationCreateInfo transformAllocInfo = {
.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
.usage = VMA_MEMORY_USAGE_AUTO,
};
Array<VkTransformMatrixKHR> matrices;
for (const auto gfxBlas : data) {
const auto blas = gfxBlas.cast<BottomLevelAS>();
matrices.add(blas->getTransform());
}
OBufferAllocation transformBuffer =
new BufferAllocation(this, "TransformBuffer", transformBufferInfo, transformAllocInfo, Gfx::QueueType::GRAPHICS);
transformBuffer->updateContents(0, sizeof(VkTransformMatrixKHR) * matrices.size(), matrices.data());
Array<VkAccelerationStructureGeometryKHR> geometries(data.size());
Array<VkAccelerationStructureBuildGeometryInfoKHR> buildGeometries(data.size());
Array<VkAccelerationStructureBuildSizesInfoKHR> buildSizes(data.size());
Array<OBufferAllocation> scratchBuffers(data.size());
Array<VkAccelerationStructureBuildRangeInfoKHR> buildRanges(data.size());
Array<VkAccelerationStructureBuildRangeInfoKHR*> buildRangePointers(data.size());
for (uint32 i = 0; i < data.size(); ++i) {
auto blas = data[i].cast<BottomLevelAS>();
VkDeviceOrHostAddressConstKHR vertexDataAddress = {
.deviceAddress = positionBuffer.cast<ShaderBuffer>()->getDeviceAddress() + blas->getVertexOffset(),
};
VkDeviceOrHostAddressConstKHR indexDataAddress = {
.deviceAddress = indexBuffer.cast<IndexBuffer>()->getDeviceAddress() + blas->getIndexOffset(),
};
VkDeviceOrHostAddressConstKHR transformDataAddress = {
.deviceAddress = transformBuffer->deviceAddress + i * sizeof(VkTransformMatrixKHR),
};
geometries[i] = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR,
.pNext = nullptr,
.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
.geometry =
{
.triangles =
{
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
.pNext = nullptr,
.vertexFormat = VK_FORMAT_R32G32B32_SFLOAT,
.vertexData = vertexDataAddress,
.vertexStride = sizeof(Vector4),
.maxVertex = static_cast<uint32_t>(blas->getVertexCount()),
.indexType = VK_INDEX_TYPE_UINT32,
.indexData = indexDataAddress,
.transformData = transformDataAddress,
},
},
.flags = VK_GEOMETRY_OPAQUE_BIT_KHR,
};
buildGeometries[i] = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
.pNext = nullptr,
.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
.flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
.geometryCount = 1,
.pGeometries = &geometries[i],
};
buildSizes[i] = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR,
.pNext = nullptr,
};
const uint32 primitiveCount = blas->getPrimitiveCount();
vkGetAccelerationStructureBuildSizesKHR(handle, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &buildGeometries[i],
&primitiveCount, &buildSizes[i]);
VkBufferCreateInfo bufferInfo = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = buildSizes[i].accelerationStructureSize,
.usage = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
};
VmaAllocationCreateInfo bufferAllocInfo = {
.usage = VMA_MEMORY_USAGE_AUTO,
};
blas->buffer = new BufferAllocation(this, "BLAS", bufferInfo, bufferAllocInfo, Gfx::QueueType::GRAPHICS);
VkAccelerationStructureCreateInfoKHR blasInfo = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
.pNext = nullptr,
.createFlags = 0,
.buffer = blas->buffer->buffer,
.offset = 0,
.size = buildSizes[i].accelerationStructureSize,
.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
};
VK_CHECK(vkCreateAccelerationStructureKHR(handle, &blasInfo, nullptr, &blas->handle));
VkBufferCreateInfo scratchInfo = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = buildSizes[i].buildScratchSize,
.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
};
VmaAllocationCreateInfo scratchAllocInfo = {
.usage = VMA_MEMORY_USAGE_AUTO,
};
scratchBuffers[i] = new BufferAllocation(this, "ScratchBuffer", scratchInfo, scratchAllocInfo, Gfx::QueueType::GRAPHICS,
accelerationProperties.minAccelerationStructureScratchOffsetAlignment);
buildGeometries[i].dstAccelerationStructure = blas->handle;
buildGeometries[i].scratchData.deviceAddress = scratchBuffers[i]->deviceAddress;
buildRanges[i] = VkAccelerationStructureBuildRangeInfoKHR{
.primitiveCount = primitiveCount,
.primitiveOffset = 0,
.firstVertex = 0,
.transformOffset = 0,
};
buildRangePointers[i] = &buildRanges[i];
}
PCommand cmd = graphicsCommands->getCommands();
vkCmdBuildAccelerationStructuresKHR(cmd->getHandle(), buildGeometries.size(), buildGeometries.data(), buildRangePointers.data());
transformBuffer->bind();
cmd->bindResource(PBufferAllocation(transformBuffer));
destructionManager->queueResourceForDestruction(std::move(transformBuffer));
for (auto& scratchAlloc : scratchBuffers) {
scratchAlloc->bind();
cmd->bindResource(PBufferAllocation(scratchAlloc));
destructionManager->queueResourceForDestruction(std::move(scratchAlloc));
}
}
Gfx::ORayGenShader Graphics::createRayGenShader(const ShaderCreateInfo& createInfo) {
ORayGenShader shader = new RayGenShader(this);
shader->create(createInfo);
@@ -499,7 +656,7 @@ void Graphics::setupDebugCallback() {
.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
.pNext = nullptr,
.flags = 0,
.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT,
.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
.pfnUserCallback = &debugCallback,
@@ -583,10 +740,8 @@ void Graphics::pickPhysicalDevice() {
.pNext = &features12,
.features =
{
.geometryShader = true,
.fillModeNonSolid = true,
.wideLines = true,
.occlusionQueryPrecise = true,
.pipelineStatisticsQuery = true,
.fragmentStoresAndAtomics = true,
.shaderInt64 = true,
@@ -727,4 +882,5 @@ void Graphics::createDevice(GraphicsInitializer initializer) {
createRayTracingPipelines = (PFN_vkCreateRayTracingPipelinesKHR)vkGetDeviceProcAddr(handle, "vkCreateRayTracingPipelinesKHR");
getRayTracingShaderGroupHandles =
(PFN_vkGetRayTracingShaderGroupHandlesKHR)vkGetDeviceProcAddr(handle, "vkGetRayTracingShaderGroupHandlesKHR");
cmdTraceRays = (PFN_vkCmdTraceRaysKHR)vkGetDeviceProcAddr(handle, "vkCmdTraceRaysKHR");
}
src/Engine/Graphics/Vulkan/Graphics.h
+1
View File
@@ -81,6 +81,7 @@ class Graphics : public Gfx::Graphics {
// Ray Tracing
virtual Gfx::OBottomLevelAS createBottomLevelAccelerationStructure(const Gfx::BottomLevelASCreateInfo& createInfo) override;
virtual Gfx::OTopLevelAS createTopLevelAccelerationStructure(const Gfx::TopLevelASCreateInfo& createInfo) override;
virtual void buildBottomLevelAccelerationStructures(Array<Gfx::PBottomLevelAS> data) override;
virtual Gfx::ORayGenShader createRayGenShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::OAnyHitShader createAnyHitShader(const ShaderCreateInfo& createInfo) override;
src/Engine/Graphics/Vulkan/PipelineCache.cpp
+78 -26
View File
@@ -470,14 +470,14 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
Array<VkPipelineShaderStageCreateInfo> shaderStages;
Array<VkRayTracingShaderGroupCreateInfoKHR> shaderGroups;
{
auto rayGen = createInfo.rayGenShader.cast<RayGenShader>();
auto rayGen = createInfo.rayGenGroup.shader.cast<RayGenShader>();
shaderStages.add(VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.stage = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
.module = rayGen->getModuleHandle(),
.pName = rayGen->getEntryPointName(),
.pName = "main",
});
shaderGroups.add(VkRayTracingShaderGroupCreateInfoKHR{
.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
@@ -490,7 +490,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
});
}
{
for (auto hitgroup : createInfo.hitgroups) {
for (auto hitgroup : createInfo.hitGroups) {
auto hit = hitgroup.closestHitShader.cast<ClosestHitShader>();
shaderStages.add(VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
@@ -498,8 +498,9 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
.flags = 0,
.stage = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
.module = hit->getModuleHandle(),
.pName = hit->getEntryPointName(),
.pName = "main",
});
uint32 hitIndex = static_cast<uint32>(shaderStages.size() - 1);
uint32 anyHitIndex = VK_SHADER_UNUSED_KHR;
uint32 intersectionIndex = VK_SHADER_UNUSED_KHR;
if (hitgroup.anyHitShader != nullptr) {
@@ -509,8 +510,8 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
.pNext = nullptr,
.flags = 0,
.stage = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
.module = hit->getModuleHandle(),
.pName = hit->getEntryPointName(),
.module = anyHit->getModuleHandle(),
.pName = "main",
});
}
if (hitgroup.intersectionShader != nullptr) {
@@ -529,15 +530,15 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
.pNext = nullptr,
.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
.generalShader = VK_SHADER_UNUSED_KHR,
.closestHitShader = static_cast<uint32>(shaderStages.size() - 1),
.closestHitShader = hitIndex,
.anyHitShader = anyHitIndex,
.intersectionShader = intersectionIndex,
});
}
}
{
for (auto gfxMiss : createInfo.missShaders) {
auto miss = gfxMiss.cast<MissShader>();
for (auto gfxMiss : createInfo.missGroups) {
auto miss = gfxMiss.shader.cast<MissShader>();
shaderStages.add(VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = nullptr,
@@ -558,15 +559,15 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
}
}
{
for (auto gfxCallable : createInfo.callableShaders) {
auto miss = gfxCallable.cast<CallableShader>();
for (auto gfxCallable : createInfo.callableGroups) {
auto call = gfxCallable.shader.cast<CallableShader>();
shaderStages.add(VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.stage = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
.module = miss->getModuleHandle(),
.pName = miss->getEntryPointName(),
.module = call->getModuleHandle(),
.pName = call->getEntryPointName(),
});
shaderGroups.add(VkRayTracingShaderGroupCreateInfoKHR{
.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
@@ -604,26 +605,51 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
vkGetRayTracingShaderGroupHandlesKHR(graphics->getDevice(), pipelineHandle, 0, shaderGroups.size(), sbtSize, sbt.data());
uint32 rayGenSize = align<uint32>(handleSize + createInfo.rayGenGroup.parameters.size(), handleAlignment);
Array<uint8> rayGenSbt(handleSizeAligned);
std::memcpy(rayGenSbt.data(), sbt.data(), handleSize);
std::memcpy(rayGenSbt.data() + handleSize, createInfo.rayGenGroup.parameters.data(), createInfo.rayGenGroup.parameters.size());
uint64 sbtOffset = handleSizeAligned;
uint32 maxParamSize = 0;
for (auto& hitgroup : createInfo.hitgroups) {
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) {
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());
std::memcpy(hitSbt.data() + i * hitStride + handleSize, createInfo.hitGroups[i].parameters.data(),
createInfo.hitGroups[i].parameters.size());
sbtOffset += handleSizeAligned;
}
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;
}
Array<uint8> missSbt(handleSizeAligned);
std::memcpy(missSbt.data(), sbt.data() + sbtOffset, handleSize);
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 rayGenBuffer =
new BufferAllocation(graphics, "RayGenSBT",
@@ -633,13 +659,15 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
.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_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);
OBufferAllocation hitBuffer =
new BufferAllocation(graphics, "HitSBT",
@@ -649,13 +677,15 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
.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_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);
OBufferAllocation missBuffer =
new BufferAllocation(graphics, "MissSBT",
@@ -665,17 +695,39 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
.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_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);
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);
ORayTracingPipeline pipeline =
new RayTracingPipeline(graphics, pipelineHandle, std::move(rayGenBuffer), handleSizeAligned, std::move(hitBuffer), hitStride,
std::move(missBuffer), handleSizeAligned, createInfo.pipelineLayout);
new RayTracingPipeline(graphics, pipelineHandle, std::move(rayGenBuffer), rayGenSize, std::move(hitBuffer), hitStride,
std::move(missBuffer), missStride, std::move(callableBuffer), callableStride, createInfo.pipelineLayout);
PRayTracingPipeline handle = pipeline;
rayTracingPipelines[hash] = std::move(pipeline);
return handle;
src/Engine/Graphics/Vulkan/RayTracing.cpp
+49 -155
View File
@@ -14,146 +14,25 @@ using namespace Seele::Vulkan;
BottomLevelAS::BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateInfo& createInfo)
: graphics(graphics), material(createInfo.mesh->referencedMaterial->getHandle()) {
matrix = {
// createInfo.mesh->transform[0][0], createInfo.mesh->transform[0][1], createInfo.mesh->transform[0][2],
// createInfo.mesh->transform[0][3], createInfo.mesh->transform[1][0], createInfo.mesh->transform[1][1],
// createInfo.mesh->transform[1][2], createInfo.mesh->transform[1][3], createInfo.mesh->transform[2][0],
// createInfo.mesh->transform[2][1], createInfo.mesh->transform[2][2], createInfo.mesh->transform[2][3],
1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
};
VertexData* vertexData = createInfo.mesh->vertexData;
MeshData meshData = vertexData->getMeshData(createInfo.mesh->id);
Gfx::PShaderBuffer positionBuffer = vertexData->getPositionBuffer();
Gfx::PIndexBuffer indexBuffer = vertexData->getIndexBuffer();
VkTransformMatrixKHR matrix = {
createInfo.mesh->transform[0][0], createInfo.mesh->transform[1][0], createInfo.mesh->transform[2][0],
createInfo.mesh->transform[3][0], createInfo.mesh->transform[0][1], createInfo.mesh->transform[1][1],
createInfo.mesh->transform[2][1], createInfo.mesh->transform[3][1], createInfo.mesh->transform[0][2],
createInfo.mesh->transform[1][2], createInfo.mesh->transform[2][2], createInfo.mesh->transform[3][2],
};
VkBufferCreateInfo transformBufferInfo = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = sizeof(VkTransformMatrixKHR),
.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT |
VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
};
VmaAllocationCreateInfo transformAllocInfo = {
.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
.usage = VMA_MEMORY_USAGE_AUTO,
};
OBufferAllocation transformBuffer =
new BufferAllocation(graphics, "TransformBuffer", transformBufferInfo, transformAllocInfo, Gfx::QueueType::GRAPHICS);
transformBuffer->updateContents(0, sizeof(VkTransformMatrixKHR), &matrix);
vertexOffset = vertexData->getMeshOffset(createInfo.mesh->id) * sizeof(Vector4);
indexOffset = meshData.firstIndex * sizeof(uint32);
primitiveCount = meshData.numIndices / 3;
VkDeviceOrHostAddressConstKHR vertexDataAddress = {
.deviceAddress =
positionBuffer.cast<ShaderBuffer>()->getDeviceAddress() + vertexData->getMeshOffset(createInfo.mesh->id) * sizeof(Vector4),
};
VkDeviceOrHostAddressConstKHR indexDataAddress = {
.deviceAddress = indexBuffer.cast<IndexBuffer>()->getDeviceAddress() + meshData.firstIndex * sizeof(uint32),
};
VkDeviceOrHostAddressConstKHR transformDataAddress = {
.deviceAddress = transformBuffer->deviceAddress,
};
VkAccelerationStructureGeometryKHR geometry = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR,
.pNext = nullptr,
.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
.geometry =
{
.triangles =
{
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
.pNext = nullptr,
.vertexFormat = VK_FORMAT_R32G32B32_SFLOAT,
.vertexData = vertexDataAddress,
.vertexStride = sizeof(Vector),
.maxVertex = static_cast<uint32_t>(createInfo.mesh->vertexCount),
.indexType = VK_INDEX_TYPE_UINT32,
.indexData = indexDataAddress,
.transformData = transformDataAddress,
},
},
.flags = VK_GEOMETRY_OPAQUE_BIT_KHR,
};
VkAccelerationStructureBuildGeometryInfoKHR structureBuildGeometry = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
.pNext = nullptr,
.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
.flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
.geometryCount = 1,
.pGeometries = &geometry,
};
const uint32 primitiveCount = meshData.numIndices / 3;
VkAccelerationStructureBuildSizesInfoKHR buildSizesInfo = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR,
.pNext = nullptr,
};
vkGetAccelerationStructureBuildSizesKHR(graphics->getDevice(), VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &structureBuildGeometry,
&primitiveCount, &buildSizesInfo);
VkBufferCreateInfo bufferInfo = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = buildSizesInfo.accelerationStructureSize,
.usage = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
};
VmaAllocationCreateInfo bufferAllocInfo = {
.usage = VMA_MEMORY_USAGE_AUTO,
};
buffer = new BufferAllocation(graphics, "BLAS", bufferInfo, bufferAllocInfo, Gfx::QueueType::GRAPHICS);
VkAccelerationStructureCreateInfoKHR blasInfo = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
.pNext = nullptr,
.createFlags = 0,
.buffer = buffer->buffer,
.offset = 0,
.size = buildSizesInfo.accelerationStructureSize,
.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
};
VK_CHECK(vkCreateAccelerationStructureKHR(graphics->getDevice(), &blasInfo, nullptr, &handle));
VkBufferCreateInfo scratchInfo = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = buildSizesInfo.buildScratchSize,
.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
};
VmaAllocationCreateInfo scratchAllocInfo = {
.usage = VMA_MEMORY_USAGE_AUTO,
};
OBufferAllocation scratchAlloc =
new BufferAllocation(graphics, "ScratchBuffer", scratchInfo, scratchAllocInfo, Gfx::QueueType::GRAPHICS,
graphics->getAccelerationProperties().minAccelerationStructureScratchOffsetAlignment);
structureBuildGeometry.dstAccelerationStructure = handle;
structureBuildGeometry.scratchData.deviceAddress = scratchAlloc->deviceAddress;
VkAccelerationStructureBuildRangeInfoKHR buildRangeInfo = {
.primitiveCount = primitiveCount,
.primitiveOffset = 0,
.firstVertex = 0,
.transformOffset = 0,
};
Array<VkAccelerationStructureBuildRangeInfoKHR*> ranges = {&buildRangeInfo};
PCommand cmd = graphics->getGraphicsCommands()->getCommands();
vkCmdBuildAccelerationStructuresKHR(cmd->getHandle(), 1, &structureBuildGeometry, ranges.data());
scratchAlloc->bind();
buffer->bind();
transformBuffer->bind();
cmd->bindResource(PBufferAllocation(transformBuffer));
cmd->bindResource(PBufferAllocation(buffer));
cmd->bindResource(PBufferAllocation(scratchAlloc));
graphics->getDestructionManager()->queueResourceForDestruction(std::move(transformBuffer));
graphics->getDestructionManager()->queueResourceForDestruction(std::move(scratchAlloc));
// todo: compact
}
BottomLevelAS::~BottomLevelAS() { graphics->getDestructionManager()->queueResourceForDestruction(std::move(buffer)); }
TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& createInfo) {
TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& createInfo) : graphics(graphics) {
Array<VkAccelerationStructureInstanceKHR> instances(createInfo.instances.size());
for (uint32 i = 0; i < instances.size(); ++i) {
auto blas = createInfo.bottomLevelStructures[i].cast<BottomLevelAS>();
@@ -174,28 +53,28 @@ TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& crea
createInfo.instances[i].transformMatrix[2][2],
createInfo.instances[i].transformMatrix[3][2],
},
.instanceCustomIndex = i,
.instanceCustomIndex = 0,
.mask = 0xff,
.instanceShaderBindingTableRecordOffset = i,
.instanceShaderBindingTableRecordOffset = 0,
.flags = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR,
.accelerationStructureReference = blas->getDeviceAddress(),
};
}
instanceAllocation = new BufferAllocation(
graphics, "ASInstances",
VkBufferCreateInfo{
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = sizeof(VkAccelerationStructureInstanceKHR) * instances.size(),
.usage = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
},
VmaAllocationCreateInfo{
.usage = VMA_MEMORY_USAGE_AUTO,
},
Gfx::QueueType::GRAPHICS);
instanceAllocation = new BufferAllocation(graphics, "ASInstances",
VkBufferCreateInfo{
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = sizeof(VkAccelerationStructureInstanceKHR) * instances.size(),
.usage = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR |
VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
},
VmaAllocationCreateInfo{
.usage = VMA_MEMORY_USAGE_AUTO,
},
Gfx::QueueType::GRAPHICS);
instanceAllocation->updateContents(0, sizeof(VkAccelerationStructureInstanceKHR) * instances.size(), instances.data());
VkDeviceOrHostAddressConstKHR instanceDeviceAddress = {
.deviceAddress = instanceAllocation->deviceAddress,
};
@@ -203,7 +82,7 @@ TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& crea
VkAccelerationStructureGeometryKHR geometry = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR,
.pNext = nullptr,
.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
.geometryType = VK_GEOMETRY_TYPE_INSTANCES_KHR,
.geometry = {.instances =
{
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
@@ -216,7 +95,7 @@ TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& crea
VkAccelerationStructureBuildGeometryInfoKHR structureBuildGeometry = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
.pNext = nullptr,
.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
.type = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR,
.flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
.geometryCount = 1,
.pGeometries = &geometry,
@@ -294,18 +173,33 @@ TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& crea
auto cmd = graphics->getGraphicsCommands()->getCommands();
vkCmdBuildAccelerationStructuresKHR(cmd->getHandle(), 1, &buildGeometry, buildRangeInfos);
scratchBuffer->bind();
cmd->bindResource(PBufferAllocation(scratchBuffer));
graphics->getDestructionManager()->queueResourceForDestruction(std::move(scratchBuffer));
buffer->bind();
cmd->bindResource(PBufferAllocation(buffer));
instanceAllocation->bind();
cmd->bindResource(PBufferAllocation(instanceAllocation));
}
TopLevelAS::~TopLevelAS() {}
TopLevelAS::~TopLevelAS() {
graphics->getDestructionManager()->queueResourceForDestruction(std::move(buffer));
graphics->getDestructionManager()->queueResourceForDestruction(std::move(instanceAllocation));
}
RayTracingPipeline::RayTracingPipeline(PGraphics graphics, VkPipeline handle, OBufferAllocation rayGen, uint64 rayGenStride,
OBufferAllocation hit, uint64 hitStride, OBufferAllocation miss, uint64 missStride,
Gfx::PPipelineLayout layout)
OBufferAllocation callable, uint64 callableStride, Gfx::PPipelineLayout layout)
: Gfx::RayTracingPipeline(layout), graphics(graphics), pipeline(handle), rayGen(std::move(rayGen)), rayGenStride(rayGenStride),
hit(std::move(hit)), hitStride(hitStride), miss(std::move(miss)), missStride(missStride) {}
hit(std::move(hit)), hitStride(hitStride), miss(std::move(miss)), missStride(missStride), callable(std::move(callable)),
callableStride(callableStride) {}
RayTracingPipeline::~RayTracingPipeline() {}
RayTracingPipeline::~RayTracingPipeline() {
graphics->getDestructionManager()->queueResourceForDestruction(std::move(rayGen));
graphics->getDestructionManager()->queueResourceForDestruction(std::move(hit));
graphics->getDestructionManager()->queueResourceForDestruction(std::move(miss));
graphics->getDestructionManager()->queueResourceForDestruction(std::move(callable));
}
void RayTracingPipeline::bind(VkCommandBuffer handle) { vkCmdBindPipeline(handle, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, pipeline); }
src/Engine/Graphics/Vulkan/RayTracing.h
+26 -2
View File
@@ -1,5 +1,6 @@
#pragma once
#include "Buffer.h"
#include "Descriptor.h"
#include "Graphics.h"
#include "Graphics/Initializer.h"
#include "Graphics/RayTracing.h"
@@ -12,12 +13,23 @@ class BottomLevelAS : public Gfx::BottomLevelAS {
BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateInfo& createInfo);
~BottomLevelAS();
uint64 getDeviceAddress() const { return buffer->deviceAddress; }
constexpr VkTransformMatrixKHR getTransform() const { return matrix; }
constexpr uint64 getIndexOffset() const { return indexOffset; }
constexpr uint64 getVertexOffset() const { return vertexOffset; }
constexpr uint64 getVertexCount() const { return vertexCount; }
constexpr uint32 getPrimitiveCount() const { return primitiveCount; }
private:
PGraphics graphics;
VkAccelerationStructureKHR handle;
OBufferAllocation buffer;
PMaterialInstance material;
VkTransformMatrixKHR matrix;
uint64 indexOffset;
uint64 vertexOffset;
uint64 vertexCount;
uint32 primitiveCount;
friend class Graphics;
};
DEFINE_REF(BottomLevelAS)
class TopLevelAS : public Gfx::TopLevelAS {
@@ -31,13 +43,14 @@ class TopLevelAS : public Gfx::TopLevelAS {
VkAccelerationStructureKHR handle;
OBufferAllocation instanceAllocation;
OBufferAllocation buffer;
friend class DescriptorSet;
};
DEFINE_REF(TopLevelAS)
class RayTracingPipeline : public Gfx::RayTracingPipeline {
public:
RayTracingPipeline(PGraphics graphics, VkPipeline handle, OBufferAllocation rayGen, uint64 rayGenStride, OBufferAllocation hit,
uint64 hitStride, OBufferAllocation miss, uint64 missStride, Gfx::PPipelineLayout layout);
uint64 hitStride, OBufferAllocation miss, uint64 missStride, OBufferAllocation callable, uint64 callableStride,
Gfx::PPipelineLayout layout);
virtual ~RayTracingPipeline();
void bind(VkCommandBuffer handle);
VkStridedDeviceAddressRegionKHR getRayGenRegion() {
@@ -61,6 +74,15 @@ class RayTracingPipeline : public Gfx::RayTracingPipeline {
.size = miss->size,
};
}
VkStridedDeviceAddressRegionKHR getCallableRegion() {
return VkStridedDeviceAddressRegionKHR{
.deviceAddress = callable->deviceAddress,
.stride = callableStride,
.size = callable->size,
};
}
VkPipelineLayout getLayout() const { return layout.cast<PipelineLayout>()->getHandle(); }
private:
PGraphics graphics;
VkPipeline pipeline;
@@ -70,6 +92,8 @@ class RayTracingPipeline : public Gfx::RayTracingPipeline {
uint64 hitStride;
OBufferAllocation miss;
uint64 missStride;
OBufferAllocation callable;
uint64 callableStride;
};
DEFINE_REF(RayTracingPipeline)
} // namespace Vulkan
src/Engine/Graphics/Vulkan/Shader.cpp
+2 -1
View File
@@ -21,7 +21,8 @@ Shader::~Shader() {
uint32 Seele::Vulkan::Shader::getShaderHash() const { return hash; }
void Shader::create(const ShaderCreateInfo& createInfo) {
Slang::ComPtr<slang::IBlob> kernelBlob = generateShader(createInfo);
auto [kernelBlob, entryName] = generateShader(createInfo);
entryPointName = entryName;
VkShaderModuleCreateInfo moduleInfo = {
.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
.pNext = nullptr,
src/Engine/Graphics/Vulkan/Shader.h
+2 -1
View File
@@ -18,7 +18,7 @@ class Shader {
constexpr VkShaderModule getModuleHandle() const { return module; }
constexpr const char* getEntryPointName() const {
// SLang renames all entry points to main, so we dont need that
return "main"; // entryPointName.c_str();
return "main";// entryPointName.c_str();
}
constexpr VkShaderStageFlags getStage() const { return stage; }
uint32 getShaderHash() const;
@@ -27,6 +27,7 @@ class Shader {
PGraphics graphics;
VkShaderModule module;
VkShaderStageFlags stage;
std::string entryPointName;
uint32 hash;
};
DEFINE_REF(Shader)