clara/bluenoise-raytracer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Improving updateUniformBuffer and search paths

Browse source
This commit is contained in:
mklefrancois 2020-11-24 16:31:21 +01:00
parent 9dc142760f
commit 0bac428ad5
40 changed files with 458 additions and 363 deletions
Download patch file Download diff file Expand all files Collapse all files

34
ray_tracing__advance/hello_vulkan.cpp
View file

@ -91,7 +91,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -103,20 +103,15 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
#if defined(NVVK_ALLOC_DEDICATED)
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(CameraMatrices)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
memcpy(data, &ubo, sizeof(ubo));
m_device.unmapMemory(m_cameraMat.allocation); // Making sure the matrix buffer will be available
#elif defined(NVVK_ALLOC_DMA) vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
void* data = m_memAllocator.map(m_cameraMat.allocation); cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
memcpy(data, &ubo, sizeof(ubo)); vk::PipelineStageFlagBits::eVertexShader
m_memAllocator.unmap(m_cameraMat.allocation); | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
#elif defined(NVVK_ALLOC_VMA) vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
void* data;
vmaMapMemory(m_memAllocator, m_cameraMat.allocation, &data);
memcpy(data, &ubo, sizeof(ubo));
vmaUnmapMemory(m_memAllocator, m_cameraMat.allocation);
#endif
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -312,12 +307,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
#ifndef NVVK_ALLOC_VMA vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
vkMP::eHostVisible | vkMP::eHostCoherent);
#else
VMA_MEMORY_USAGE_CPU_TO_GPU);
#endif // _DEBUG
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -497,6 +488,7 @@ void HelloVulkan::onResize(int /*w*/, int /*h*/)
m_offscreen.createFramebuffer(m_size); m_offscreen.createFramebuffer(m_size);
m_offscreen.updateDescriptorSet(); m_offscreen.updateDescriptorSet();
m_raytrace.updateRtDescriptorSet(m_offscreen.colorTexture().descriptor.imageView); m_raytrace.updateRtDescriptorSet(m_offscreen.colorTexture().descriptor.imageView);
resetFrame();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

2
ray_tracing__advance/hello_vulkan.h
View file

@ -61,7 +61,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

30
ray_tracing__advance/main.cpp
View file

@ -148,6 +148,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + "..", NVPSystem::exePath() + "..",
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
@ -287,9 +289,6 @@ int main(int argc, char** argv)
// Start the Dear ImGui frame // Start the Dear ImGui frame
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -317,9 +316,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -339,13 +341,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -358,17 +360,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
offscreen.draw(cmdBuff, helloVk.getSize()); offscreen.draw(cmdBuf, helloVk.getSize());
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

16
ray_tracing__advance/raytrace.cpp
View file

@ -99,10 +99,10 @@ nvvk::RaytracingBuilderKHR::BlasInput Raytracer::objectToVkGeometryKHR(const Obj
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
@ -131,10 +131,10 @@ nvvk::RaytracingBuilderKHR::BlasInput Raytracer::implicitToVkGeometryKHR(
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }

17
ray_tracing__before/hello_vulkan.cpp
View file

@ -69,7 +69,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -78,9 +78,14 @@ void HelloVulkan::updateUniformBuffer()
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
//ubo.proj[1][1] *= -1; // Inverting Y for Vulkan //ubo.proj[1][1] *= -1; // Inverting Y for Vulkan
ubo.viewInverse = nvmath::invert(ubo.view); ubo.viewInverse = nvmath::invert(ubo.view);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo));
memcpy(data, &ubo, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
m_device.unmapMemory(m_cameraMat.allocation);
// Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -248,8 +253,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }

2
ray_tracing__before/hello_vulkan.h
View file

@ -54,7 +54,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

29
ray_tracing__before/main.cpp
View file

@ -117,6 +117,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + "..", NVPSystem::exePath() + "..",
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
@ -197,9 +199,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -217,9 +216,13 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -237,9 +240,9 @@ int main(int argc, char** argv)
offscreenRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); offscreenRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
// Rendering Scene // Rendering Scene
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
@ -252,17 +255,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

73
ray_tracing__simple/hello_vulkan.cpp
View file

@ -73,7 +73,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -85,9 +85,14 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
memcpy(data, &ubo, sizeof(ubo));
m_device.unmapMemory(m_cameraMat.allocation); // Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -147,12 +152,12 @@ void HelloVulkan::updateDescriptorSet()
std::vector<vk::DescriptorBufferInfo> dbiMatIdx; std::vector<vk::DescriptorBufferInfo> dbiMatIdx;
std::vector<vk::DescriptorBufferInfo> dbiVert; std::vector<vk::DescriptorBufferInfo> dbiVert;
std::vector<vk::DescriptorBufferInfo> dbiIdx; std::vector<vk::DescriptorBufferInfo> dbiIdx;
for(size_t i = 0; i < m_objModel.size(); ++i) for(auto& obj : m_objModel)
{ {
dbiMat.push_back({m_objModel[i].matColorBuffer.buffer, 0, VK_WHOLE_SIZE}); dbiMat.emplace_back(obj.matColorBuffer.buffer, 0, VK_WHOLE_SIZE);
dbiMatIdx.push_back({m_objModel[i].matIndexBuffer.buffer, 0, VK_WHOLE_SIZE}); dbiMatIdx.emplace_back(obj.matIndexBuffer.buffer, 0, VK_WHOLE_SIZE);
dbiVert.push_back({m_objModel[i].vertexBuffer.buffer, 0, VK_WHOLE_SIZE}); dbiVert.emplace_back(obj.vertexBuffer.buffer, 0, VK_WHOLE_SIZE);
dbiIdx.push_back({m_objModel[i].indexBuffer.buffer, 0, VK_WHOLE_SIZE}); dbiIdx.emplace_back(obj.indexBuffer.buffer, 0, VK_WHOLE_SIZE);
} }
writes.emplace_back(m_descSetLayoutBind.makeWriteArray(m_descSet, 1, dbiMat.data())); writes.emplace_back(m_descSetLayoutBind.makeWriteArray(m_descSet, 1, dbiMat.data()));
writes.emplace_back(m_descSetLayoutBind.makeWriteArray(m_descSet, 4, dbiMatIdx.data())); writes.emplace_back(m_descSetLayoutBind.makeWriteArray(m_descSet, 4, dbiMatIdx.data()));
@ -273,8 +278,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -633,44 +638,47 @@ void HelloVulkan::initRayTracing()
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Converting a OBJ primitive to the ray tracing geometry used for the BLAS // Convert an OBJ model into the ray tracing geometry used to build the BLAS
// //
nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const ObjModel& model) nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const ObjModel& model)
{ {
// Building part // BLAS builder requires raw device addresses.
vk::DeviceAddress vertexAddress = m_device.getBufferAddress({model.vertexBuffer.buffer}); vk::DeviceAddress vertexAddress = m_device.getBufferAddress({model.vertexBuffer.buffer});
vk::DeviceAddress indexAddress = m_device.getBufferAddress({model.indexBuffer.buffer}); vk::DeviceAddress indexAddress = m_device.getBufferAddress({model.indexBuffer.buffer});
uint32_t maxPrimitiveCount = model.nbIndices / 3; uint32_t maxPrimitiveCount = model.nbIndices / 3;
// Describe buffer as array of VertexObj.
vk::AccelerationStructureGeometryTrianglesDataKHR triangles; vk::AccelerationStructureGeometryTrianglesDataKHR triangles;
triangles.setVertexFormat(vk::Format::eR32G32B32Sfloat); triangles.setVertexFormat(vk::Format::eR32G32B32Sfloat); // vec3 vertex position data.
triangles.setVertexData(vertexAddress); triangles.setVertexData(vertexAddress);
triangles.setVertexStride(sizeof(VertexObj)); triangles.setVertexStride(sizeof(VertexObj));
// Describe index data (32-bit unsigned int)
triangles.setIndexType(vk::IndexType::eUint32); triangles.setIndexType(vk::IndexType::eUint32);
triangles.setIndexData(indexAddress); triangles.setIndexData(indexAddress);
// Indicate identity transform by setting transformData to null device pointer.
triangles.setTransformData({}); triangles.setTransformData({});
triangles.setMaxVertex(model.nbVertices); triangles.setMaxVertex(model.nbVertices);
// Setting up the build info of the acceleration // Identify the above data as containing opaque triangles.
vk::AccelerationStructureGeometryKHR asGeom; vk::AccelerationStructureGeometryKHR asGeom;
asGeom.setGeometryType(vk::GeometryTypeKHR::eTriangles); asGeom.setGeometryType(vk::GeometryTypeKHR::eTriangles);
asGeom.setFlags(vk::GeometryFlagBitsKHR::eOpaque); asGeom.setFlags(vk::GeometryFlagBitsKHR::eOpaque);
asGeom.geometry.setTriangles(triangles); asGeom.geometry.setTriangles(triangles);
// The primitive itself // The entire array will be used to build the BLAS.
vk::AccelerationStructureBuildRangeInfoKHR offset; vk::AccelerationStructureBuildRangeInfoKHR offset;
offset.setFirstVertex(0); offset.setFirstVertex(0);
offset.setPrimitiveCount(maxPrimitiveCount); offset.setPrimitiveCount(maxPrimitiveCount);
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
// Our blas is only one geometry, but could be made of many geometries // Our blas is made from only one geometry, but could be made of many geometries
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -832,8 +840,9 @@ void HelloVulkan::createRtPipeline()
rayPipelineInfo.setStageCount(static_cast<uint32_t>(stages.size())); // Stages are shaders rayPipelineInfo.setStageCount(static_cast<uint32_t>(stages.size())); // Stages are shaders
rayPipelineInfo.setPStages(stages.data()); rayPipelineInfo.setPStages(stages.data());
rayPipelineInfo.setGroupCount(static_cast<uint32_t>( // In this case, m_rtShaderGroups.size() == 4: we have one raygen group,
m_rtShaderGroups.size())); // 1-raygen, n-miss, n-(hit[+anyhit+intersect]) // two miss shader groups, and one hit group.
rayPipelineInfo.setGroupCount(static_cast<uint32_t>(m_rtShaderGroups.size()));
rayPipelineInfo.setPGroups(m_rtShaderGroups.data()); rayPipelineInfo.setPGroups(m_rtShaderGroups.data());
rayPipelineInfo.setMaxPipelineRayRecursionDepth(2); // Ray depth rayPipelineInfo.setMaxPipelineRayRecursionDepth(2); // Ray depth
@ -849,27 +858,29 @@ void HelloVulkan::createRtPipeline()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// The Shader Binding Table (SBT) // The Shader Binding Table (SBT)
// - getting all shader handles and writing them in a SBT buffer // - getting all shader handles and write them in a SBT buffer
// - Besides exception, this could be always done like this // - Besides exception, this could be always done like this
// See how the SBT buffer is used in run() // See how the SBT buffer is used in run()
// //
void HelloVulkan::createRtShaderBindingTable() void HelloVulkan::createRtShaderBindingTable()
{ {
auto groupCount = auto groupCount =
static_cast<uint32_t>(m_rtShaderGroups.size()); // 3 shaders: raygen, miss, chit static_cast<uint32_t>(m_rtShaderGroups.size()); // 4 shaders: raygen, 2 miss, chit
uint32_t groupHandleSize = m_rtProperties.shaderGroupHandleSize; // Size of a program identifier uint32_t groupHandleSize = m_rtProperties.shaderGroupHandleSize; // Size of a program identifier
// Compute the actual size needed per SBT entry (round-up to alignment needed).
uint32_t groupSizeAligned = uint32_t groupSizeAligned =
nvh::align_up(groupHandleSize, m_rtProperties.shaderGroupBaseAlignment); nvh::align_up(groupHandleSize, m_rtProperties.shaderGroupBaseAlignment);
// Bytes needed for the SBT.
// Fetch all the shader handles used in the pipeline, so that they can be written in the SBT
uint32_t sbtSize = groupCount * groupSizeAligned; uint32_t sbtSize = groupCount * groupSizeAligned;
// Fetch all the shader handles used in the pipeline. This is opaque data,
// so we store it in a vector of bytes.
std::vector<uint8_t> shaderHandleStorage(sbtSize); std::vector<uint8_t> shaderHandleStorage(sbtSize);
auto result = m_device.getRayTracingShaderGroupHandlesKHR(m_rtPipeline, 0, groupCount, sbtSize, auto result = m_device.getRayTracingShaderGroupHandlesKHR(m_rtPipeline, 0, groupCount, sbtSize,
shaderHandleStorage.data()); shaderHandleStorage.data());
assert(result == vk::Result::eSuccess); assert(result == vk::Result::eSuccess);
// Write the handles in the SBT // Allocate a buffer for storing the SBT. Give it a debug name for NSight.
m_rtSBTBuffer = m_alloc.createBuffer( m_rtSBTBuffer = m_alloc.createBuffer(
sbtSize, sbtSize,
vk::BufferUsageFlagBits::eTransferSrc | vk::BufferUsageFlagBits::eShaderDeviceAddress vk::BufferUsageFlagBits::eTransferSrc | vk::BufferUsageFlagBits::eShaderDeviceAddress
@ -877,17 +888,15 @@ void HelloVulkan::createRtShaderBindingTable()
vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent); vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent);
m_debug.setObjectName(m_rtSBTBuffer.buffer, std::string("SBT").c_str()); m_debug.setObjectName(m_rtSBTBuffer.buffer, std::string("SBT").c_str());
// Write the handles in the SBT // Map the SBT buffer and write in the handles.
void* mapped = m_alloc.map(m_rtSBTBuffer); void* mapped = m_alloc.map(m_rtSBTBuffer);
auto* pData = reinterpret_cast<uint8_t*>(mapped); auto* pData = reinterpret_cast<uint8_t*>(mapped);
for(uint32_t g = 0; g < groupCount; g++) for(uint32_t g = 0; g < groupCount; g++)
{ {
memcpy(pData, shaderHandleStorage.data() + g * groupHandleSize, groupHandleSize); // raygen memcpy(pData, shaderHandleStorage.data() + g * groupHandleSize, groupHandleSize);
pData += groupSizeAligned; pData += groupSizeAligned;
} }
m_alloc.unmap(m_rtSBTBuffer); m_alloc.unmap(m_rtSBTBuffer);
m_alloc.finalizeAndReleaseStaging(); m_alloc.finalizeAndReleaseStaging();
} }

2
ray_tracing__simple/hello_vulkan.h
View file

@ -58,7 +58,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

29
ray_tracing__simple/main.cpp
View file

@ -113,6 +113,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + "..", NVPSystem::exePath() + "..",
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
@ -217,8 +219,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
@ -240,9 +240,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -262,13 +265,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -281,17 +284,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

25
ray_tracing_animation/hello_vulkan.cpp
View file

@ -73,7 +73,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -85,9 +85,14 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
memcpy(data, &ubo, sizeof(ubo));
m_device.unmapMemory(m_cameraMat.allocation); // Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -272,8 +277,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -666,10 +671,10 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const O
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
void HelloVulkan::createBottomLevelAS() void HelloVulkan::createBottomLevelAS()

2
ray_tracing_animation/hello_vulkan.h
View file

@ -57,7 +57,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

29
ray_tracing_animation/main.cpp
View file

@ -114,6 +114,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + "..", NVPSystem::exePath() + "..",
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
@ -228,8 +230,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
@ -255,9 +255,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -277,13 +280,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -296,17 +299,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

26
ray_tracing_anyhit/hello_vulkan.cpp
View file

@ -73,7 +73,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -85,9 +85,14 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
memcpy(data, &ubo, sizeof(ubo));
m_device.unmapMemory(m_cameraMat.allocation); // Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -275,8 +280,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -460,6 +465,7 @@ void HelloVulkan::onResize(int /*w*/, int /*h*/)
createOffscreenRender(); createOffscreenRender();
updatePostDescriptorSet(); updatePostDescriptorSet();
updateRtDescriptorSet(); updateRtDescriptorSet();
resetFrame();
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -662,10 +668,10 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const O
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
void HelloVulkan::createBottomLevelAS() void HelloVulkan::createBottomLevelAS()

2
ray_tracing_anyhit/hello_vulkan.h
View file

@ -57,7 +57,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

30
ray_tracing_anyhit/main.cpp
View file

@ -113,6 +113,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + "..", NVPSystem::exePath() + "..",
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
@ -222,9 +224,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -244,9 +243,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -266,13 +268,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -285,17 +287,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

27
ray_tracing_callable/hello_vulkan.cpp
View file

@ -73,7 +73,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -85,9 +85,15 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo));
memcpy(data, &ubo, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
m_device.unmapMemory(m_cameraMat.allocation);
// Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -272,8 +278,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -636,8 +642,6 @@ void HelloVulkan::initRayTracing()
// //
nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const ObjModel& model) nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const ObjModel& model)
{ {
nvvk::RaytracingBuilderKHR::BlasInput blas;
vk::DeviceAddress vertexAddress = m_device.getBufferAddress({model.vertexBuffer.buffer}); vk::DeviceAddress vertexAddress = m_device.getBufferAddress({model.vertexBuffer.buffer});
vk::DeviceAddress indexAddress = m_device.getBufferAddress({model.indexBuffer.buffer}); vk::DeviceAddress indexAddress = m_device.getBufferAddress({model.indexBuffer.buffer});
@ -663,9 +667,10 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const O
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
blas.asGeometry.emplace_back(asGeom); nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asBuildOffsetInfo.emplace_back(offset); input.asGeometry.emplace_back(asGeom);
return blas; input.asBuildOffsetInfo.emplace_back(offset);
return input;
} }
void HelloVulkan::createBottomLevelAS() void HelloVulkan::createBottomLevelAS()

2
ray_tracing_callable/hello_vulkan.h
View file

@ -58,7 +58,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

30
ray_tracing_callable/main.cpp
View file

@ -130,6 +130,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + "..", NVPSystem::exePath() + "..",
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
@ -235,9 +237,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -257,9 +256,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -279,13 +281,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -298,17 +300,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

27
ray_tracing_gltf/hello_vulkan.cpp
View file

@ -76,7 +76,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -88,9 +88,15 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo));
memcpy(data, &ubo, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
m_device.unmapMemory(m_cameraMat.allocation);
// Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -278,8 +284,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -428,6 +434,7 @@ void HelloVulkan::onResize(int /*w*/, int /*h*/)
createOffscreenRender(); createOffscreenRender();
updatePostDescriptorSet(); updatePostDescriptorSet();
updateRtDescriptorSet(); updateRtDescriptorSet();
resetFrame();
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -633,10 +640,10 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::primitiveToGeometry(
offset.setPrimitiveOffset(prim.firstIndex * sizeof(uint32_t)); offset.setPrimitiveOffset(prim.firstIndex * sizeof(uint32_t));
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

2
ray_tracing_gltf/hello_vulkan.h
View file

@ -57,7 +57,7 @@ public:
void updateDescriptorSet(); void updateDescriptorSet();
void createUniformBuffer(); void createUniformBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, tinygltf::Model& gltfModel); void createTextureImages(const vk::CommandBuffer& cmdBuf, tinygltf::Model& gltfModel);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

30
ray_tracing_gltf/main.cpp
View file

@ -113,6 +113,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
}; };
@ -215,9 +217,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -237,9 +236,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -259,13 +261,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -278,17 +280,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

26
ray_tracing_instances/hello_vulkan.cpp
View file

@ -89,7 +89,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -101,9 +101,15 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_alloc.map(m_cameraMat);
memcpy(data, &ubo, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
m_alloc.unmap(m_cameraMat);
// Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -288,8 +294,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -681,10 +687,10 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const O
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
void HelloVulkan::createBottomLevelAS() void HelloVulkan::createBottomLevelAS()

2
ray_tracing_instances/hello_vulkan.h
View file

@ -61,7 +61,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

30
ray_tracing_instances/main.cpp
View file

@ -114,6 +114,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + "..", NVPSystem::exePath() + "..",
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
@ -234,9 +236,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -256,9 +255,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -278,13 +280,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -297,17 +299,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

34
ray_tracing_intersection/hello_vulkan.cpp
View file

@ -74,7 +74,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -86,9 +86,15 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo));
memcpy(data, &ubo, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
m_device.unmapMemory(m_cameraMat.allocation);
// Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -282,8 +288,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -675,10 +681,10 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const O
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -706,10 +712,10 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::sphereToVkGeometryKHR()
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

2
ray_tracing_intersection/hello_vulkan.h
View file

@ -57,7 +57,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

30
ray_tracing_intersection/main.cpp
View file

@ -114,6 +114,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
}; };
@ -218,9 +220,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -240,9 +239,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -262,13 +264,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -281,17 +283,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

27
ray_tracing_jitter_cam/hello_vulkan.cpp
View file

@ -73,7 +73,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -85,9 +85,15 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo));
memcpy(data, &ubo, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
m_device.unmapMemory(m_cameraMat.allocation);
// Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -272,8 +278,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -457,6 +463,7 @@ void HelloVulkan::onResize(int /*w*/, int /*h*/)
createOffscreenRender(); createOffscreenRender();
updatePostDescriptorSet(); updatePostDescriptorSet();
updateRtDescriptorSet(); updateRtDescriptorSet();
resetFrame();
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -659,10 +666,10 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const O
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
void HelloVulkan::createBottomLevelAS() void HelloVulkan::createBottomLevelAS()

2
ray_tracing_jitter_cam/hello_vulkan.h
View file

@ -57,7 +57,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

30
ray_tracing_jitter_cam/main.cpp
View file

@ -121,6 +121,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + "..", NVPSystem::exePath() + "..",
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
@ -226,9 +228,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -253,9 +252,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -275,13 +277,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -294,17 +296,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

26
ray_tracing_manyhits/hello_vulkan.cpp
View file

@ -72,7 +72,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -84,9 +84,15 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo));
memcpy(data, &ubo, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
m_device.unmapMemory(m_cameraMat.allocation);
// Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -271,8 +277,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -658,10 +664,10 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const O
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
void HelloVulkan::createBottomLevelAS() void HelloVulkan::createBottomLevelAS()

2
ray_tracing_manyhits/hello_vulkan.h
View file

@ -57,7 +57,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

30
ray_tracing_manyhits/main.cpp
View file

@ -112,6 +112,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + "..", NVPSystem::exePath() + "..",
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
@ -227,9 +229,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -249,9 +248,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -271,13 +273,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -290,17 +292,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }

26
ray_tracing_rayquery/hello_vulkan.cpp
View file

@ -71,7 +71,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -83,9 +83,15 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo));
memcpy(data, &ubo, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
m_device.unmapMemory(m_cameraMat.allocation);
// Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -279,8 +285,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -663,11 +669,11 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const O
offset.setTransformOffset(0); offset.setTransformOffset(0);
// Our blas is only one geometry, but could be made of many geometries // Our blas is only one geometry, but could be made of many geometries
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

2
ray_tracing_rayquery/hello_vulkan.h
View file

@ -57,7 +57,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

28
ray_tracing_rayquery/main.cpp
View file

@ -115,6 +115,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
}; };
@ -215,9 +217,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -236,9 +235,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -257,9 +259,9 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -272,17 +274,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }
catch(const std::system_error& e) catch(const std::system_error& e)

26
ray_tracing_reflections/hello_vulkan.cpp
View file

@ -73,7 +73,7 @@ void HelloVulkan::setup(const vk::Instance& instance,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
// Called at each frame to update the camera matrix // Called at each frame to update the camera matrix
// //
void HelloVulkan::updateUniformBuffer() void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
@ -85,9 +85,15 @@ void HelloVulkan::updateUniformBuffer()
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); ubo.projInverse = nvmath::invert(ubo.proj);
void* data = m_device.mapMemory(m_cameraMat.allocation, 0, sizeof(ubo));
memcpy(data, &ubo, sizeof(ubo)); cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo);
m_device.unmapMemory(m_cameraMat.allocation);
// Making sure the matrix buffer will be available
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead};
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -272,8 +278,8 @@ void HelloVulkan::createUniformBuffer()
using vkBU = vk::BufferUsageFlagBits; using vkBU = vk::BufferUsageFlagBits;
using vkMP = vk::MemoryPropertyFlagBits; using vkMP = vk::MemoryPropertyFlagBits;
m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices), vkBU::eUniformBuffer, m_cameraMat = m_alloc.createBuffer(sizeof(CameraMatrices),
vkMP::eHostVisible | vkMP::eHostCoherent); vkBU::eUniformBuffer | vkBU::eTransferDst, vkMP::eDeviceLocal);
m_debug.setObjectName(m_cameraMat.buffer, "cameraMat"); m_debug.setObjectName(m_cameraMat.buffer, "cameraMat");
} }
@ -659,10 +665,10 @@ nvvk::RaytracingBuilderKHR::BlasInput HelloVulkan::objectToVkGeometryKHR(const O
offset.setPrimitiveOffset(0); offset.setPrimitiveOffset(0);
offset.setTransformOffset(0); offset.setTransformOffset(0);
nvvk::RaytracingBuilderKHR::BlasInput blas; nvvk::RaytracingBuilderKHR::BlasInput input;
blas.asGeometry.emplace_back(asGeom); input.asGeometry.emplace_back(asGeom);
blas.asBuildOffsetInfo.emplace_back(offset); input.asBuildOffsetInfo.emplace_back(offset);
return blas; return input;
} }
void HelloVulkan::createBottomLevelAS() void HelloVulkan::createBottomLevelAS()

2
ray_tracing_reflections/hello_vulkan.h
View file

@ -57,7 +57,7 @@ public:
void createSceneDescriptionBuffer(); void createSceneDescriptionBuffer();
void createTextureImages(const vk::CommandBuffer& cmdBuf, void createTextureImages(const vk::CommandBuffer& cmdBuf,
const std::vector<std::string>& textures); const std::vector<std::string>& textures);
void updateUniformBuffer(); void updateUniformBuffer(const vk::CommandBuffer& cmdBuf);
void onResize(int /*w*/, int /*h*/) override; void onResize(int /*w*/, int /*h*/) override;
void destroyResources(); void destroyResources();
void rasterize(const vk::CommandBuffer& cmdBuff); void rasterize(const vk::CommandBuffer& cmdBuff);

30
ray_tracing_reflections/main.cpp
View file

@ -113,6 +113,8 @@ int main(int argc, char** argv)
// Search path for shaders and other media // Search path for shaders and other media
defaultSearchPaths = { defaultSearchPaths = {
PROJECT_ABSDIRECTORY,
PROJECT_ABSDIRECTORY "..",
NVPSystem::exePath(), NVPSystem::exePath(),
NVPSystem::exePath() + "..", NVPSystem::exePath() + "..",
NVPSystem::exePath() + std::string(PROJECT_NAME), NVPSystem::exePath() + std::string(PROJECT_NAME),
@ -225,9 +227,6 @@ int main(int argc, char** argv)
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
// Updating camera buffer
helloVk.updateUniformBuffer();
// Show UI window. // Show UI window.
if(helloVk.showGui()) if(helloVk.showGui())
{ {
@ -248,9 +247,12 @@ int main(int argc, char** argv)
// Start command buffer of this frame // Start command buffer of this frame
auto curFrame = helloVk.getCurFrame(); auto curFrame = helloVk.getCurFrame();
const vk::CommandBuffer& cmdBuff = helloVk.getCommandBuffers()[curFrame]; const vk::CommandBuffer& cmdBuf = helloVk.getCommandBuffers()[curFrame];
cmdBuff.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit}); cmdBuf.begin({vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// Updating camera buffer
helloVk.updateUniformBuffer(cmdBuf);
// Clearing screen // Clearing screen
vk::ClearValue clearValues[2]; vk::ClearValue clearValues[2];
@ -270,13 +272,13 @@ int main(int argc, char** argv)
// Rendering Scene // Rendering Scene
if(useRaytracer) if(useRaytracer)
{ {
helloVk.raytrace(cmdBuff, clearColor); helloVk.raytrace(cmdBuf, clearColor);
} }
else else
{ {
cmdBuff.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(offscreenRenderPassBeginInfo, vk::SubpassContents::eInline);
helloVk.rasterize(cmdBuff); helloVk.rasterize(cmdBuf);
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
} }
@ -289,17 +291,17 @@ int main(int argc, char** argv)
postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]); postRenderPassBeginInfo.setFramebuffer(helloVk.getFramebuffers()[curFrame]);
postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()}); postRenderPassBeginInfo.setRenderArea({{}, helloVk.getSize()});
cmdBuff.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline); cmdBuf.beginRenderPass(postRenderPassBeginInfo, vk::SubpassContents::eInline);
// Rendering tonemapper // Rendering tonemapper
helloVk.drawPost(cmdBuff); helloVk.drawPost(cmdBuf);
// Rendering UI // Rendering UI
ImGui::Render(); ImGui::Render();
ImGui::RenderDrawDataVK(cmdBuff, ImGui::GetDrawData()); ImGui::RenderDrawDataVK(cmdBuf, ImGui::GetDrawData());
cmdBuff.endRenderPass(); cmdBuf.endRenderPass();
} }
// Submit for display // Submit for display
cmdBuff.end(); cmdBuf.end();
helloVk.submitFrame(); helloVk.submitFrame();
} }