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-10 21:07:10 +02:00
parent acf8dde8fc
commit a9089bd997
46 changed files with 801 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Graphics/Vulkan/Command.cpp
+23 -8
View File
@@ -4,6 +4,7 @@
#include "Framebuffer.h"
#include "Graphics.h"
#include "Pipeline.h"
#include "RayTracing.h"
#include "RenderPass.h"
#include "Window.h"
@@ -178,9 +179,7 @@ void RenderCommand::begin(PRenderPass renderPass, PFramebuffer framebuffer, VkQu
ready = false;
VkCommandBufferInheritanceInfo inheritanceInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
.renderPass = renderPass->getHandle(),
.subpass = 0,
.framebuffer = framebuffer->getHandle(),
.occlusionQueryEnable = 0,
.queryFlags = 0,
.pipelineStatistics = pipelineFlags,
@@ -188,9 +187,13 @@ void RenderCommand::begin(PRenderPass renderPass, PFramebuffer framebuffer, VkQu
VkCommandBufferBeginInfo beginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.pNext = nullptr,
.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
.pInheritanceInfo = &inheritanceInfo,
};
if (renderPass != nullptr || framebuffer != nullptr) {
inheritanceInfo.renderPass = renderPass->getHandle();
inheritanceInfo.framebuffer = framebuffer->getHandle();
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
}
VK_CHECK(vkBeginCommandBuffer(handle, &beginInfo));
}
@@ -229,6 +232,12 @@ void RenderCommand::bindPipeline(Gfx::PGraphicsPipeline gfxPipeline) {
pipeline->bind(handle);
}
void RenderCommand::bindPipeline(Gfx::PRayTracingPipeline gfxPipeline) {
assert(threadId == std::this_thread::get_id());
rtPipeline = gfxPipeline.cast<RayTracingPipeline>();
rtPipeline->bind(handle);
}
void RenderCommand::bindDescriptor(Gfx::PDescriptorSet descriptorSet, Array<uint32> dynamicOffsets) {
assert(threadId == std::this_thread::get_id());
auto descriptor = descriptorSet.cast<DescriptorSet>();
@@ -243,15 +252,16 @@ void RenderCommand::bindDescriptor(Gfx::PDescriptorSet descriptorSet, Array<uint
}
VkDescriptorSet setHandle = descriptor->getHandle();
vkCmdBindDescriptorSets(handle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->getLayout(),
pipeline->getPipelineLayout()->findParameter(descriptorSet->getName()), 1, &setHandle, dynamicOffsets.size(),
dynamicOffsets.data());
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());
}
void RenderCommand::bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorSets, Array<uint32> dynamicOffsets) {
assert(threadId == std::this_thread::get_id());
VkDescriptorSet* sets = new VkDescriptorSet[descriptorSets.size()];
std::memset(sets, 0, sizeof(VkDescriptorSet) * descriptorSets.size());
Gfx::PPipelineLayout layout = pipeline != nullptr ? pipeline->getPipelineLayout() : rtPipeline->getPipelineLayout();
for (uint32 i = 0; i < descriptorSets.size(); ++i) {
auto descriptorSet = descriptorSets[i].cast<DescriptorSet>();
assert(descriptorSet->writeDescriptors.size() == 0);
@@ -267,7 +277,7 @@ void RenderCommand::bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorS
}
}
}
sets[pipeline->getPipelineLayout()->findParameter(descriptorSet->getName())] = descriptorSet->getHandle();
sets[layout->findParameter(descriptorSet->getName())] = descriptorSet->getHandle();
}
vkCmdBindDescriptorSets(handle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->getLayout(), 0, (uint32)descriptorSets.size(), sets,
dynamicOffsets.size(), dynamicOffsets.data());
@@ -320,7 +330,12 @@ void RenderCommand::drawMeshIndirect(Gfx::PShaderBuffer buffer, uint64 offset, u
vkCmdDrawMeshTasksIndirectEXT(handle, buffer.cast<ShaderBuffer>()->getHandle(), offset, drawCount, stride);
}
void RenderCommand::traceRays() {}
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);
}
ComputeCommand::ComputeCommand(PGraphics graphics, VkCommandPool cmdPool) : graphics(graphics), owner(cmdPool) {
VkCommandBufferAllocateInfo allocInfo = {
src/Engine/Graphics/Vulkan/Command.h
+4 -2
View File
@@ -65,6 +65,7 @@ DEFINE_REF(Command)
DECLARE_REF(GraphicsPipeline)
DECLARE_REF(ComputePipeline)
DECLARE_REF(RayTracingPipeline)
class RenderCommand : public Gfx::RenderCommand {
public:
RenderCommand(PGraphics graphics, VkCommandPool cmdPool);
@@ -76,6 +77,7 @@ class RenderCommand : public Gfx::RenderCommand {
bool isReady();
virtual void setViewport(Gfx::PViewport viewport) override;
virtual void bindPipeline(Gfx::PGraphicsPipeline pipeline) override;
virtual void bindPipeline(Gfx::PRayTracingPipeline pipeline) override;
virtual void bindDescriptor(Gfx::PDescriptorSet descriptorSet, Array<uint32> dynamicOffsets) override;
virtual void bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorSets, Array<uint32> dynamicOffsets) override;
virtual void bindVertexBuffer(const Array<Gfx::PVertexBuffer>& buffers) override;
@@ -85,11 +87,11 @@ class RenderCommand : public Gfx::RenderCommand {
virtual void drawIndexed(uint32 indexCount, uint32 instanceCount, int32 firstIndex, uint32 vertexOffset, uint32 firstInstance) override;
virtual void drawMesh(uint32 groupX, uint32 groupY, uint32 groupZ) override;
virtual void drawMeshIndirect(Gfx::PShaderBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride) override;
virtual void traceRays();
virtual void traceRays(uint32 width, uint32 height, uint32 depth) override;
private:
PGraphicsPipeline pipeline;
PRayTracingPipeline rtPipeline;
bool ready;
Array<PCommandBoundResource> boundResources;
VkViewport currentViewport;
src/Engine/Graphics/Vulkan/Descriptor.cpp
+53 -12
View File
@@ -4,7 +4,7 @@
#include "Command.h"
#include "Graphics.h"
#include "Texture.h"
#include "RayTracing.h"
using namespace Seele;
using namespace Seele::Vulkan;
@@ -62,21 +62,17 @@ DescriptorPool::DescriptorPool(PGraphics graphics, PDescriptorLayout layout)
cachedHandles[i] = nullptr;
}
uint32 perTypeSizes[VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT]; // TODO: FIX ENUM
std::memset(perTypeSizes, 0, sizeof(perTypeSizes));
Map<Gfx::SeDescriptorType, uint32> perTypeSizes;
for (uint32 i = 0; i < layout->getBindings().size(); ++i) {
auto& binding = layout->getBindings()[i];
int typeIndex = binding.descriptorType;
perTypeSizes[typeIndex] += 512;
perTypeSizes[binding.descriptorType] += 512;
}
Array<VkDescriptorPoolSize> poolSizes;
for (uint32 i = 0; i < VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; ++i) {
if (perTypeSizes[i] > 0) {
VkDescriptorPoolSize size;
size.descriptorCount = perTypeSizes[i];
size.type = (VkDescriptorType)i;
poolSizes.add(size);
}
for (const auto [type, num] : perTypeSizes) {
VkDescriptorPoolSize size;
size.descriptorCount = num;
size.type = cast(type);
poolSizes.add(size);
}
VkDescriptorPoolCreateInfo createInfo = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
@@ -227,6 +223,32 @@ void DescriptorSet::updateBuffer(uint32_t binding, Gfx::PShaderBuffer shaderBuff
boundResources[binding][0] = vulkanBuffer->getAlloc();
}
void DescriptorSet::updateBuffer(uint32_t binding, Gfx::PIndexBuffer indexBuffer) {
PIndexBuffer vulkanBuffer = indexBuffer.cast<IndexBuffer>();
if (boundResources[binding][0] == vulkanBuffer->getAlloc()) {
return;
}
bufferInfos.add(VkDescriptorBufferInfo{
.buffer = vulkanBuffer->getHandle(),
.offset = 0,
.range = vulkanBuffer->getSize(),
});
writeDescriptors.add(VkWriteDescriptorSet{
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.pNext = nullptr,
.dstSet = setHandle,
.dstBinding = binding,
.dstArrayElement = 0,
.descriptorCount = 1,
.descriptorType = cast(layout->getBindings()[binding].descriptorType),
.pBufferInfo = &bufferInfos.back(),
});
boundResources[binding][0] = vulkanBuffer->getAlloc();
}
void DescriptorSet::updateBuffer(uint32_t binding, uint32 index, Gfx::PShaderBuffer shaderBuffer) {
PShaderBuffer vulkanBuffer = shaderBuffer.cast<ShaderBuffer>();
if (boundResources[binding][index] == vulkanBuffer->getAlloc()) {
@@ -429,6 +451,25 @@ 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,
});
writeDescriptors.add(VkWriteDescriptorSet{
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.pNext = &accelerationInfos.back(),
.dstSet = setHandle,
.dstBinding = binding,
.dstArrayElement = 0,
.descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
});
}
void DescriptorSet::writeChanges() {
if (writeDescriptors.size() > 0) {
src/Engine/Graphics/Vulkan/Descriptor.h
+11 -8
View File
@@ -48,15 +48,17 @@ class DescriptorSet : public Gfx::DescriptorSet, public CommandBoundResource {
DescriptorSet(PGraphics graphics, PDescriptorPool owner);
virtual ~DescriptorSet();
virtual void writeChanges() override;
virtual void updateBuffer(uint32_t binding, Gfx::PUniformBuffer uniformBuffer) override;
virtual void updateBuffer(uint32_t binding, Gfx::PShaderBuffer uniformBuffer) override;
virtual void updateBuffer(uint32_t binding, uint32 index, Gfx::PShaderBuffer uniformBuffer) override;
virtual void updateSampler(uint32_t binding, Gfx::PSampler samplerState) override;
virtual void updateSampler(uint32_t binding, uint32 dstArrayIndex, Gfx::PSampler samplerState) override;
virtual void updateTexture(uint32_t binding, Gfx::PTexture texture, Gfx::PSampler sampler = nullptr) override;
virtual void updateBuffer(uint32 binding, Gfx::PUniformBuffer uniformBuffer) override;
virtual void updateBuffer(uint32 binding, Gfx::PShaderBuffer uniformBuffer) override;
virtual void updateBuffer(uint32 binding, Gfx::PIndexBuffer uniformBuffer) override;
virtual void updateBuffer(uint32 binding, uint32 index, Gfx::PShaderBuffer uniformBuffer) override;
virtual void updateSampler(uint32 binding, Gfx::PSampler samplerState) override;
virtual void updateSampler(uint32 binding, uint32 dstArrayIndex, Gfx::PSampler samplerState) override;
virtual void updateTexture(uint32 binding, Gfx::PTexture texture, Gfx::PSampler sampler = nullptr) override;
virtual void updateTexture(uint32 binding, uint32 dstArrayIndex, Gfx::PTexture texture) override;
virtual void updateTextureArray(uint32_t binding, Array<Gfx::PTexture2D> texture) override;
virtual void updateSamplerArray(uint32_t binding, Array<Gfx::PSampler> samplers) override;
virtual void updateTextureArray(uint32 binding, Array<Gfx::PTexture2D> texture) override;
virtual void updateSamplerArray(uint32 binding, Array<Gfx::PSampler> samplers) override;
virtual void updateAccelerationStructure(uint32 binding, Gfx::PTopLevelAS as) override;
constexpr bool isCurrentlyInUse() const { return currentlyInUse; }
constexpr void allocate() { currentlyInUse = true; }
@@ -66,6 +68,7 @@ class DescriptorSet : public Gfx::DescriptorSet, public CommandBoundResource {
private:
List<VkDescriptorImageInfo> imageInfos;
List<VkDescriptorBufferInfo> bufferInfos;
List<VkWriteDescriptorSetAccelerationStructureKHR> accelerationInfos;
Array<VkWriteDescriptorSet> writeDescriptors;
// contains the previously bound resources at every binding
// since the layout is fixed, trying to bind a texture to a buffer
src/Engine/Graphics/Vulkan/Enums.cpp
+12 -10
View File
@@ -29,12 +29,14 @@ VkDescriptorType Seele::Vulkan::cast(const Seele::Gfx::SeDescriptorType& descrip
return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
case SE_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
return VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
#ifdef USE_EXTENSIONS
case SE_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
return VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
case SE_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
return VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK;
case SE_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
return VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
case SE_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
return VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV;
#endif
case SE_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
return VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM;
default:
break;
}
@@ -43,7 +45,6 @@ VkDescriptorType Seele::Vulkan::cast(const Seele::Gfx::SeDescriptorType& descrip
Seele::Gfx::SeDescriptorType Seele::Vulkan::cast(const VkDescriptorType& descriptorType) {
switch (descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
return SE_DESCRIPTOR_TYPE_SAMPLER;
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
@@ -66,12 +67,14 @@ Seele::Gfx::SeDescriptorType Seele::Vulkan::cast(const VkDescriptorType& descrip
return SE_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
return SE_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
#ifdef USE_EXTENSIONS
case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
return SE_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
return SE_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK;
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
return SE_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
return SE_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV;
#endif
case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
return SE_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM;
default:
throw std::logic_error("Not implemented");
}
@@ -79,7 +82,6 @@ Seele::Gfx::SeDescriptorType Seele::Vulkan::cast(const VkDescriptorType& descrip
VkShaderStageFlagBits Seele::Vulkan::cast(const Seele::Gfx::SeShaderStageFlagBits& stage) {
switch (stage) {
case SE_SHADER_STAGE_VERTEX_BIT:
return VK_SHADER_STAGE_VERTEX_BIT;
case SE_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
src/Engine/Graphics/Vulkan/Graphics.cpp
+29 -6
View File
@@ -15,6 +15,7 @@
#include "Shader.h"
#include "Window.h"
#include <GLFW/glfw3.h>
#include "Graphics/slang-compile.h"
#include <cstring>
#include <vulkan/vulkan_core.h>
@@ -35,6 +36,8 @@ PFN_vkCreateAccelerationStructureKHR createAccelerationStructure;
PFN_vkCmdBuildAccelerationStructuresKHR cmdBuildAccelerationStructures;
PFN_vkGetAccelerationStructureBuildSizesKHR getAccelerationStructureBuildSize;
PFN_vkCreateRayTracingPipelinesKHR createRayTracingPipelines;
PFN_vkGetRayTracingShaderGroupHandlesKHR getRayTracingShaderGroupHandles;
PFN_vkCmdTraceRaysKHR cmdTraceRays;
void vkCmdDrawMeshTasksEXT(VkCommandBuffer command, uint32 groupX, uint32 groupY, uint32 groupZ) {
cmdDrawMeshTasks(command, groupX, groupY, groupZ);
@@ -69,12 +72,26 @@ void vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStru
}
VkResult vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache,
uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
return createRayTracingPipelines(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
VkResult vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount,
size_t dataSize, void* pData) {
return getRayTracingShaderGroupHandles(device, pipeline, firstGroup, groupCount, dataSize, pData);
}
void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height,
uint32_t depth) {
cmdTraceRays(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable,
width, height, depth);
}
Graphics::Graphics() : instance(VK_NULL_HANDLE), handle(VK_NULL_HANDLE), physicalDevice(VK_NULL_HANDLE), callback(VK_NULL_HANDLE) {}
Graphics::~Graphics() {
@@ -142,9 +159,7 @@ void Graphics::beginRenderPass(Gfx::PRenderPass renderPass) {
getGraphicsCommands()->getCommands()->beginRenderPass(rp, framebuffer);
}
void Graphics::endRenderPass() {
getGraphicsCommands()->getCommands()->endRenderPass();
}
void Graphics::endRenderPass() { getGraphicsCommands()->getCommands()->endRenderPass(); }
void Graphics::waitDeviceIdle() { vkDeviceWaitIdle(handle); }
@@ -174,6 +189,8 @@ 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); }
Gfx::OVertexShader Graphics::createVertexShader(const ShaderCreateInfo& createInfo) {
OVertexShader shader = new VertexShader(this);
shader->create(createInfo);
@@ -208,6 +225,10 @@ Gfx::PGraphicsPipeline Graphics::createGraphicsPipeline(Gfx::MeshPipelineCreateI
return pipelineCache->createPipeline(std::move(createInfo));
}
Gfx::PRayTracingPipeline Graphics::createRayTracingPipeline(Gfx::RayTracingPipelineCreateInfo createInfo) {
return pipelineCache->createPipeline(std::move(createInfo));
}
Gfx::PComputePipeline Graphics::createComputePipeline(Gfx::ComputePipelineCreateInfo createInfo) {
return pipelineCache->createPipeline(std::move(createInfo));
}
@@ -704,4 +725,6 @@ void Graphics::createDevice(GraphicsInitializer initializer) {
getAccelerationStructureBuildSize =
(PFN_vkGetAccelerationStructureBuildSizesKHR)vkGetDeviceProcAddr(handle, "vkGetAccelerationStructureBuildSizesKHR");
createRayTracingPipelines = (PFN_vkCreateRayTracingPipelinesKHR)vkGetDeviceProcAddr(handle, "vkCreateRayTracingPipelinesKHR");
getRayTracingShaderGroupHandles =
(PFN_vkGetRayTracingShaderGroupHandlesKHR)vkGetDeviceProcAddr(handle, "vkGetRayTracingShaderGroupHandlesKHR");
}
src/Engine/Graphics/Vulkan/Graphics.h
+2
View File
@@ -54,6 +54,7 @@ class Graphics : public Gfx::Graphics {
virtual Gfx::ORenderCommand createRenderCommand(const std::string& name) override;
virtual Gfx::OComputeCommand createComputeCommand(const std::string& name) override;
virtual void beginShaderCompilation(const ShaderCompilationInfo& compileInfo) override;
virtual Gfx::OVertexShader createVertexShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::OFragmentShader createFragmentShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::OComputeShader createComputeShader(const ShaderCreateInfo& createInfo) override;
@@ -61,6 +62,7 @@ class Graphics : public Gfx::Graphics {
virtual Gfx::OMeshShader createMeshShader(const ShaderCreateInfo& createInfo) override;
virtual Gfx::PGraphicsPipeline createGraphicsPipeline(Gfx::LegacyPipelineCreateInfo createInfo) override;
virtual Gfx::PGraphicsPipeline createGraphicsPipeline(Gfx::MeshPipelineCreateInfo createInfo) override;
virtual Gfx::PRayTracingPipeline createRayTracingPipeline(Gfx::RayTracingPipelineCreateInfo createInfo) override;
virtual Gfx::PComputePipeline createComputePipeline(Gfx::ComputePipelineCreateInfo createInfo) override;
virtual Gfx::OSampler createSampler(const SamplerCreateInfo& createInfo) override;
src/Engine/Graphics/Vulkan/PipelineCache.cpp
+112 -50
View File
@@ -5,6 +5,7 @@
#include "RenderPass.h"
#include "Shader.h"
#include <fstream>
#include <vulkan/vulkan_core.h>
using namespace Seele;
using namespace Seele::Vulkan;
@@ -489,8 +490,8 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
});
}
{
for (auto gfxHit : createInfo.closestHitShaders) {
auto hit = gfxHit.cast<ClosestHitShader>();
for (auto hitgroup : createInfo.hitgroups) {
auto hit = hitgroup.closestHitShader.cast<ClosestHitShader>();
shaderStages.add(VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = nullptr,
@@ -499,59 +500,38 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
.module = hit->getModuleHandle(),
.pName = hit->getEntryPointName(),
});
uint32 anyHitIndex = VK_SHADER_UNUSED_KHR;
uint32 intersectionIndex = VK_SHADER_UNUSED_KHR;
if (hitgroup.anyHitShader != nullptr) {
auto anyHit = hitgroup.anyHitShader.cast<AnyHitShader>();
shaderStages.add(VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.stage = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
.module = hit->getModuleHandle(),
.pName = hit->getEntryPointName(),
});
}
if (hitgroup.intersectionShader != nullptr) {
auto intersect = hitgroup.intersectionShader.cast<IntersectionShader>();
shaderStages.add(VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.stage = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
.module = intersect->getModuleHandle(),
.pName = intersect->getEntryPointName(),
});
}
shaderGroups.add(VkRayTracingShaderGroupCreateInfoKHR{
.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
.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),
.anyHitShader = VK_SHADER_UNUSED_KHR,
.intersectionShader = VK_SHADER_UNUSED_KHR,
});
}
}
{
for (auto gfxHit : createInfo.anyHitShaders) {
auto hit = gfxHit.cast<AnyHitShader>();
shaderStages.add(VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.stage = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
.module = hit->getModuleHandle(),
.pName = hit->getEntryPointName(),
});
shaderGroups.add(VkRayTracingShaderGroupCreateInfoKHR{
.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
.pNext = nullptr,
.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
.generalShader = VK_SHADER_UNUSED_KHR,
.closestHitShader = VK_SHADER_UNUSED_KHR,
.anyHitShader = static_cast<uint32>(shaderStages.size() - 1),
.intersectionShader = VK_SHADER_UNUSED_KHR,
});
}
}
{
for (auto gfxIntersect : createInfo.intersectionShaders) {
auto intersect = gfxIntersect.cast<IntersectionShader>();
shaderStages.add(VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.stage = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
.module = intersect->getModuleHandle(),
.pName = intersect->getEntryPointName(),
});
shaderGroups.add(VkRayTracingShaderGroupCreateInfoKHR{
.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
.pNext = nullptr,
.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
.generalShader = VK_SHADER_UNUSED_KHR,
.closestHitShader = VK_SHADER_UNUSED_KHR,
.anyHitShader = VK_SHADER_UNUSED_KHR,
.intersectionShader = static_cast<uint32>(shaderStages.size() - 1),
.anyHitShader = anyHitIndex,
.intersectionShader = intersectionIndex,
});
}
}
@@ -613,7 +593,89 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
};
VkPipeline pipelineHandle;
VK_CHECK(vkCreateRayTracingPipelinesKHR(graphics->getDevice(), VK_NULL_HANDLE, cache, 1, &pipelineInfo, nullptr, &pipelineHandle));
ORayTracingPipeline pipeline = new RayTracingPipeline(graphics, pipelineHandle, createInfo.pipelineLayout);
const uint32_t handleSize = graphics->getRayTracingProperties().shaderGroupHandleSize;
const uint32_t handleAlignment = graphics->getRayTracingProperties().shaderGroupHandleAlignment;
const uint32_t handleSizeAligned = align(handleSize, handleAlignment);
const uint32_t groupCount = static_cast<uint32_t>(shaderGroups.size());
const uint32_t sbtSize = handleSizeAligned * groupCount;
Array<uint8> sbt(sbtSize);
vkGetRayTracingShaderGroupHandlesKHR(graphics->getDevice(), pipelineHandle, 0, shaderGroups.size(), sbtSize, sbt.data());
Array<uint8> rayGenSbt(handleSizeAligned);
std::memcpy(rayGenSbt.data(), sbt.data(), handleSize);
uint64 sbtOffset = handleSizeAligned;
uint32 maxParamSize = 0;
for (auto& hitgroup : createInfo.hitgroups) {
maxParamSize = std::max<uint32>(maxParamSize, hitgroup.parameters.size());
}
uint64 hitStride = align(handleSize + maxParamSize, handleAlignment);
Array<uint8> hitSbt(hitStride * createInfo.hitgroups.size());
for (uint64 i = 0; i < createInfo.hitgroups.size(); ++i) {
std::memcpy(hitSbt.data() + i * hitStride, sbt.data() + sbtOffset, handleSize);
std::memcpy(hitSbt.data() + i * hitStride + handleSize, createInfo.hitgroups[i].parameters.data(),
createInfo.hitgroups[i].parameters.size());
sbtOffset += handleSizeAligned;
}
Array<uint8> missSbt(handleSizeAligned);
std::memcpy(missSbt.data(), sbt.data() + sbtOffset, handleSize);
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,
},
VmaAllocationCreateInfo{
.usage = VMA_MEMORY_USAGE_AUTO,
},
Gfx::QueueType::GRAPHICS);
rayGenBuffer->updateContents(0, rayGenSbt.size(), rayGenSbt.data());
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,
},
VmaAllocationCreateInfo{
.usage = VMA_MEMORY_USAGE_AUTO,
},
Gfx::QueueType::GRAPHICS);
hitBuffer->updateContents(0, hitSbt.size(), hitSbt.data());
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,
},
VmaAllocationCreateInfo{
.usage = VMA_MEMORY_USAGE_AUTO,
},
Gfx::QueueType::GRAPHICS);
missBuffer->updateContents(0, missSbt.size(), missSbt.data());
ORayTracingPipeline pipeline =
new RayTracingPipeline(graphics, pipelineHandle, std::move(rayGenBuffer), handleSizeAligned, std::move(hitBuffer), hitStride,
std::move(missBuffer), handleSizeAligned, createInfo.pipelineLayout);
PRayTracingPipeline handle = pipeline;
rayTracingPipelines[hash] = std::move(pipeline);
return handle;
src/Engine/Graphics/Vulkan/RayTracing.cpp
+155 -4
View File
@@ -30,7 +30,7 @@ BottomLevelAS::BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateI
.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_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,
@@ -139,6 +139,9 @@ BottomLevelAS::BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateI
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));
@@ -150,11 +153,159 @@ BottomLevelAS::BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateI
BottomLevelAS::~BottomLevelAS() { graphics->getDestructionManager()->queueResourceForDestruction(std::move(buffer)); }
TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& createInfo) {}
TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& createInfo) {
Array<VkAccelerationStructureInstanceKHR> instances(createInfo.instances.size());
for (uint32 i = 0; i < instances.size(); ++i) {
auto blas = createInfo.bottomLevelStructures[i].cast<BottomLevelAS>();
instances[i] = VkAccelerationStructureInstanceKHR{
.transform =
VkTransformMatrixKHR{
createInfo.instances[i].transformMatrix[0][0],
createInfo.instances[i].transformMatrix[1][0],
createInfo.instances[i].transformMatrix[2][0],
createInfo.instances[i].transformMatrix[3][0],
createInfo.instances[i].transformMatrix[0][1],
createInfo.instances[i].transformMatrix[1][1],
createInfo.instances[i].transformMatrix[2][1],
createInfo.instances[i].transformMatrix[3][1],
createInfo.instances[i].transformMatrix[0][2],
createInfo.instances[i].transformMatrix[1][2],
createInfo.instances[i].transformMatrix[2][2],
createInfo.instances[i].transformMatrix[3][2],
},
.instanceCustomIndex = i,
.mask = 0xff,
.instanceShaderBindingTableRecordOffset = i,
.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);
VkDeviceOrHostAddressConstKHR instanceDeviceAddress = {
.deviceAddress = instanceAllocation->deviceAddress,
};
VkAccelerationStructureGeometryKHR geometry = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR,
.pNext = nullptr,
.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
.geometry = {.instances =
{
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
.pNext = nullptr,
.arrayOfPointers = VK_FALSE,
.data = instanceDeviceAddress,
}},
.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 = instances.size();
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);
buffer = new BufferAllocation(
graphics, "TLAS",
VkBufferCreateInfo{
.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{
.usage = VMA_MEMORY_USAGE_AUTO,
},
Gfx::QueueType::GRAPHICS);
VkAccelerationStructureCreateInfoKHR accelerationInfo = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
.pNext = nullptr,
.buffer = buffer->buffer,
.size = buildSizesInfo.accelerationStructureSize,
.type = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR,
};
VK_CHECK(vkCreateAccelerationStructureKHR(graphics->getDevice(), &accelerationInfo, nullptr, &handle));
OBufferAllocation scratchBuffer =
new BufferAllocation(graphics, "ScratchBuffer",
VkBufferCreateInfo{
.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{
.usage = VMA_MEMORY_USAGE_AUTO,
},
Gfx::QueueType::GRAPHICS);
VkAccelerationStructureBuildGeometryInfoKHR buildGeometry = {
.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
.pNext = nullptr,
.flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR,
.mode = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR,
.dstAccelerationStructure = handle,
.geometryCount = 1,
.pGeometries = &geometry,
.scratchData =
{
.deviceAddress = scratchBuffer->deviceAddress,
},
};
VkAccelerationStructureBuildRangeInfoKHR buildRange = {
.primitiveCount = uint32(instances.size()),
.primitiveOffset = 0,
.firstVertex = 0,
.transformOffset = 0,
};
VkAccelerationStructureBuildRangeInfoKHR* buildRangeInfos[] = {&buildRange};
auto cmd = graphics->getGraphicsCommands()->getCommands();
vkCmdBuildAccelerationStructuresKHR(cmd->getHandle(), 1, &buildGeometry, buildRangeInfos);
scratchBuffer->bind();
graphics->getDestructionManager()->queueResourceForDestruction(std::move(scratchBuffer));
}
TopLevelAS::~TopLevelAS() {}
RayTracingPipeline::RayTracingPipeline(PGraphics graphics, VkPipeline handle, Gfx::PPipelineLayout layout)
: Gfx::RayTracingPipeline(layout), graphics(graphics), pipeline(handle) {}
RayTracingPipeline::RayTracingPipeline(PGraphics graphics, VkPipeline handle, OBufferAllocation rayGen, uint64 rayGenStride,
OBufferAllocation hit, uint64 hitStride, OBufferAllocation miss, uint64 missStride,
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) {}
RayTracingPipeline::~RayTracingPipeline() {}
void RayTracingPipeline::bind(VkCommandBuffer handle) { vkCmdBindPipeline(handle, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, pipeline); }
src/Engine/Graphics/Vulkan/RayTracing.h
+36 -5
View File
@@ -1,9 +1,9 @@
#pragma once
#include "Buffer.h"
#include "Graphics.h"
#include "Graphics/Initializer.h"
#include "Graphics/RayTracing.h"
#include <vulkan/vulkan_core.h>
#include "Buffer.h"
namespace Seele {
namespace Vulkan {
@@ -11,6 +11,7 @@ class BottomLevelAS : public Gfx::BottomLevelAS {
public:
BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateInfo& createInfo);
~BottomLevelAS();
uint64 getDeviceAddress() const { return buffer->deviceAddress; }
private:
PGraphics graphics;
@@ -23,22 +24,52 @@ class TopLevelAS : public Gfx::TopLevelAS {
public:
TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& createInfo);
~TopLevelAS();
const VkAccelerationStructureKHR getHandle() const { return handle; }
private:
PGraphics graphics;
VkAccelerationStructureKHR handle;
OBufferAllocation instanceAllocation;
OBufferAllocation buffer;
};
DEFINE_REF(TopLevelAS)
class RayTracingPipeline : public Gfx::RayTracingPipeline
{
class RayTracingPipeline : public Gfx::RayTracingPipeline {
public:
RayTracingPipeline(PGraphics graphics, VkPipeline handle, Gfx::PPipelineLayout layout);
RayTracingPipeline(PGraphics graphics, VkPipeline handle, OBufferAllocation rayGen, uint64 rayGenStride, OBufferAllocation hit,
uint64 hitStride, OBufferAllocation miss, uint64 missStride, Gfx::PPipelineLayout layout);
virtual ~RayTracingPipeline();
void bind(VkCommandBuffer handle);
VkStridedDeviceAddressRegionKHR getRayGenRegion() {
return VkStridedDeviceAddressRegionKHR{
.deviceAddress = rayGen->deviceAddress,
.stride = rayGenStride,
.size = rayGen->size,
};
}
VkStridedDeviceAddressRegionKHR getHitRegion() {
return VkStridedDeviceAddressRegionKHR{
.deviceAddress = hit->deviceAddress,
.stride = hitStride,
.size = hit->size,
};
}
VkStridedDeviceAddressRegionKHR getMissRegion() {
return VkStridedDeviceAddressRegionKHR{
.deviceAddress = miss->deviceAddress,
.stride = missStride,
.size = miss->size,
};
}
private:
PGraphics graphics;
VkPipeline pipeline;
OBufferAllocation rayGen;
uint64 rayGenStride;
OBufferAllocation hit;
uint64 hitStride;
OBufferAllocation miss;
uint64 missStride;
};
DEFINE_REF(RayTracingPipeline)
} // namespace Vulkan
src/Engine/Graphics/Vulkan/Shader.cpp
+2 -4
View File
@@ -20,10 +20,8 @@ Shader::~Shader() {
uint32 Seele::Vulkan::Shader::getShaderHash() const { return hash; }
void Shader::create(ShaderCreateInfo createInfo) {
Map<std::string, uint32> paramMapping;
Slang::ComPtr<slang::IBlob> kernelBlob = generateShader(createInfo, SLANG_SPIRV, paramMapping);
createInfo.rootSignature->addMapping(paramMapping);
void Shader::create(const ShaderCreateInfo& createInfo) {
Slang::ComPtr<slang::IBlob> kernelBlob = generateShader(createInfo);
VkShaderModuleCreateInfo moduleInfo = {
.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
.pNext = nullptr,
src/Engine/Graphics/Vulkan/Shader.h
+1 -1
View File
@@ -13,7 +13,7 @@ class Shader {
Shader(PGraphics graphics, VkShaderStageFlags stage);
virtual ~Shader();
void create(ShaderCreateInfo createInfo);
void create(const ShaderCreateInfo& createInfo);
constexpr VkShaderModule getModuleHandle() const { return module; }
constexpr const char* getEntryPointName() const {