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

Adding barriers to updateUniformBuffer

Browse source
This commit is contained in:
mklefrancois 2020-12-15 09:07:23 +01:00
parent a6690f149a
commit 3f38eb2cd6
13 changed files with 487 additions and 179 deletions
Download patch file Download diff file Expand all files Collapse all files

51
ray_tracing__advance/hello_vulkan.cpp
View file

@ -93,25 +93,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
// UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // Ensure that the modified UBO is not visible to previous frames.
vk::BufferMemoryBarrier beforeBarrier;
beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
beforeBarrier.setBuffer(deviceUBO);
beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Making sure the matrix buffer will be available // Schedule the host-to-device upload. (hostUBO is copied into the cmd
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; // buffer so it is okay to deallocate when the function returns).
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, // Making sure the updated UBO will be visible.
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

46
ray_tracing__before/hello_vulkan.cpp
View file

@ -71,21 +71,45 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
hostUBO.view = CameraManip.getMatrix();
hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
// hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
hostUBO.viewInverse = nvmath::invert(hostUBO.view);
CameraMatrices ubo = {}; // UBO on the device, and what stages access it.
ubo.view = CameraManip.getMatrix(); vk::Buffer deviceUBO = m_cameraMat.buffer;
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader;
//ubo.proj[1][1] *= -1; // Inverting Y for Vulkan
ubo.viewInverse = nvmath::invert(ubo.view);
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // Ensure that the modified UBO is not visible to previous frames.
vk::BufferMemoryBarrier beforeBarrier;
beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
beforeBarrier.setBuffer(deviceUBO);
beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Making sure the matrix buffer will be available // Schedule the host-to-device upload. (hostUBO is copied into the cmd
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; // buffer so it is okay to deallocate when the function returns).
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
vk::PipelineStageFlagBits::eVertexShader,
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); // Making sure the updated UBO will be visible.
vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

57
ray_tracing__simple/hello_vulkan.cpp
View file

@ -75,24 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
// Making sure the matrix buffer will be available // Ensure that the modified UBO is not visible to previous frames.
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; vk::BufferMemoryBarrier beforeBarrier;
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
vk::PipelineStageFlagBits::eVertexShader beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, beforeBarrier.setBuffer(deviceUBO);
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Schedule the host-to-device upload. (hostUBO is copied into the cmd
// buffer so it is okay to deallocate when the function returns).
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
// Making sure the updated UBO will be visible.
vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -850,6 +874,11 @@ void HelloVulkan::createRtPipeline()
m_rtPipeline = static_cast<const vk::Pipeline&>( m_rtPipeline = static_cast<const vk::Pipeline&>(
m_device.createRayTracingPipelineKHR({}, {}, rayPipelineInfo)); m_device.createRayTracingPipelineKHR({}, {}, rayPipelineInfo));
// Spec only guarantees 1 level of "recursion". Check for that sad possibility here.
if (m_rtProperties.maxRayRecursionDepth <= 1) {
throw std::runtime_error("Device fails to support ray recursion (m_rtProperties.maxRayRecursionDepth <= 1)");
}
m_device.destroy(raygenSM); m_device.destroy(raygenSM);
m_device.destroy(missSM); m_device.destroy(missSM);
m_device.destroy(shadowmissSM); m_device.destroy(shadowmissSM);

52
ray_tracing_animation/hello_vulkan.cpp
View file

@ -75,24 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
// Making sure the matrix buffer will be available // Ensure that the modified UBO is not visible to previous frames.
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; vk::BufferMemoryBarrier beforeBarrier;
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
vk::PipelineStageFlagBits::eVertexShader beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, beforeBarrier.setBuffer(deviceUBO);
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Schedule the host-to-device upload. (hostUBO is copied into the cmd
// buffer so it is okay to deallocate when the function returns).
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
// Making sure the updated UBO will be visible.
vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

52
ray_tracing_anyhit/hello_vulkan.cpp
View file

@ -75,24 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
// Making sure the matrix buffer will be available // Ensure that the modified UBO is not visible to previous frames.
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; vk::BufferMemoryBarrier beforeBarrier;
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
vk::PipelineStageFlagBits::eVertexShader beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, beforeBarrier.setBuffer(deviceUBO);
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Schedule the host-to-device upload. (hostUBO is copied into the cmd
// buffer so it is okay to deallocate when the function returns).
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
// Making sure the updated UBO will be visible.
vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

51
ray_tracing_callable/hello_vulkan.cpp
View file

@ -75,25 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
// UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // Ensure that the modified UBO is not visible to previous frames.
vk::BufferMemoryBarrier beforeBarrier;
beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
beforeBarrier.setBuffer(deviceUBO);
beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Making sure the matrix buffer will be available // Schedule the host-to-device upload. (hostUBO is copied into the cmd
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; // buffer so it is okay to deallocate when the function returns).
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, // Making sure the updated UBO will be visible.
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

51
ray_tracing_gltf/hello_vulkan.cpp
View file

@ -80,25 +80,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
// UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // Ensure that the modified UBO is not visible to previous frames.
vk::BufferMemoryBarrier beforeBarrier;
beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
beforeBarrier.setBuffer(deviceUBO);
beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Making sure the matrix buffer will be available // Schedule the host-to-device upload. (hostUBO is copied into the cmd
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; // buffer so it is okay to deallocate when the function returns).
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, // Making sure the updated UBO will be visible.
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

51
ray_tracing_instances/hello_vulkan.cpp
View file

@ -91,25 +91,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
// UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // Ensure that the modified UBO is not visible to previous frames.
vk::BufferMemoryBarrier beforeBarrier;
beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
beforeBarrier.setBuffer(deviceUBO);
beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Making sure the matrix buffer will be available // Schedule the host-to-device upload. (hostUBO is copied into the cmd
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; // buffer so it is okay to deallocate when the function returns).
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, // Making sure the updated UBO will be visible.
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

51
ray_tracing_intersection/hello_vulkan.cpp
View file

@ -76,25 +76,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
// UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // Ensure that the modified UBO is not visible to previous frames.
vk::BufferMemoryBarrier beforeBarrier;
beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
beforeBarrier.setBuffer(deviceUBO);
beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Making sure the matrix buffer will be available // Schedule the host-to-device upload. (hostUBO is copied into the cmd
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; // buffer so it is okay to deallocate when the function returns).
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, // Making sure the updated UBO will be visible.
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

51
ray_tracing_jitter_cam/hello_vulkan.cpp
View file

@ -75,25 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
// UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // Ensure that the modified UBO is not visible to previous frames.
vk::BufferMemoryBarrier beforeBarrier;
beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
beforeBarrier.setBuffer(deviceUBO);
beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Making sure the matrix buffer will be available // Schedule the host-to-device upload. (hostUBO is copied into the cmd
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; // buffer so it is okay to deallocate when the function returns).
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, // Making sure the updated UBO will be visible.
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

51
ray_tracing_manyhits/hello_vulkan.cpp
View file

@ -74,25 +74,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
// UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // Ensure that the modified UBO is not visible to previous frames.
vk::BufferMemoryBarrier beforeBarrier;
beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
beforeBarrier.setBuffer(deviceUBO);
beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Making sure the matrix buffer will be available // Schedule the host-to-device upload. (hostUBO is copied into the cmd
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; // buffer so it is okay to deallocate when the function returns).
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, // Making sure the updated UBO will be visible.
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

51
ray_tracing_rayquery/hello_vulkan.cpp
View file

@ -73,25 +73,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
// UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // Ensure that the modified UBO is not visible to previous frames.
vk::BufferMemoryBarrier beforeBarrier;
beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
beforeBarrier.setBuffer(deviceUBO);
beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Making sure the matrix buffer will be available // Schedule the host-to-device upload. (hostUBO is copied into the cmd
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; // buffer so it is okay to deallocate when the function returns).
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, // Making sure the updated UBO will be visible.
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

51
ray_tracing_reflections/hello_vulkan.cpp
View file

@ -75,25 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance,
// //
void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf)
{ {
// Prepare new UBO contents on host.
const float aspectRatio = m_size.width / static_cast<float>(m_size.height); const float aspectRatio = m_size.width / static_cast<float>(m_size.height);
CameraMatrices hostUBO = {};
CameraMatrices ubo = {}; hostUBO.view = CameraManip.getMatrix();
ubo.view = CameraManip.getMatrix(); hostUBO.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f);
ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); // hostUBO.proj[1][1] *= -1; // Inverting Y for Vulkan (not needed with perspectiveVK).
// ubo.proj[1][1] *= -1; // Inverting Y for Vulkan hostUBO.viewInverse = nvmath::invert(hostUBO.view);
ubo.viewInverse = nvmath::invert(ubo.view);
// #VKRay // #VKRay
ubo.projInverse = nvmath::invert(ubo.proj); hostUBO.projInverse = nvmath::invert(hostUBO.proj);
// UBO on the device, and what stages access it.
vk::Buffer deviceUBO = m_cameraMat.buffer;
auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eRayTracingShaderKHR;
cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, ubo); // Ensure that the modified UBO is not visible to previous frames.
vk::BufferMemoryBarrier beforeBarrier;
beforeBarrier.setSrcAccessMask(vk::AccessFlagBits::eShaderRead);
beforeBarrier.setDstAccessMask(vk::AccessFlagBits::eTransferWrite);
beforeBarrier.setBuffer(deviceUBO);
beforeBarrier.setOffset(0);
beforeBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
uboUsageStages,
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eDeviceGroup, {}, {beforeBarrier}, {});
// Making sure the matrix buffer will be available // Schedule the host-to-device upload. (hostUBO is copied into the cmd
vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; // buffer so it is okay to deallocate when the function returns).
cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdBuf.updateBuffer<CameraMatrices>(m_cameraMat.buffer, 0, hostUBO);
vk::PipelineStageFlagBits::eVertexShader
| vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, // Making sure the updated UBO will be visible.
vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); vk::BufferMemoryBarrier afterBarrier;
afterBarrier.setSrcAccessMask(vk::AccessFlagBits::eTransferWrite);
afterBarrier.setDstAccessMask(vk::AccessFlagBits::eShaderRead);
afterBarrier.setBuffer(deviceUBO);
afterBarrier.setOffset(0);
afterBarrier.setSize(sizeof hostUBO);
cmdBuf.pipelineBarrier(
vk::PipelineStageFlagBits::eTransfer,
uboUsageStages,
vk::DependencyFlagBits::eDeviceGroup, {}, {afterBarrier}, {});
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------