From 3f38eb2cd64317498e028484330e07442477ed99 Mon Sep 17 00:00:00 2001 From: mklefrancois <38076163+mklefrancois@users.noreply.github.com> Date: Tue, 15 Dec 2020 09:07:23 +0100 Subject: [PATCH] Adding barriers to updateUniformBuffer --- ray_tracing__advance/hello_vulkan.cpp | 51 ++++++++++++++------ ray_tracing__before/hello_vulkan.cpp | 46 +++++++++++++----- ray_tracing__simple/hello_vulkan.cpp | 57 +++++++++++++++++------ ray_tracing_animation/hello_vulkan.cpp | 52 +++++++++++++++------ ray_tracing_anyhit/hello_vulkan.cpp | 52 +++++++++++++++------ ray_tracing_callable/hello_vulkan.cpp | 51 ++++++++++++++------ ray_tracing_gltf/hello_vulkan.cpp | 51 ++++++++++++++------ ray_tracing_instances/hello_vulkan.cpp | 51 ++++++++++++++------ ray_tracing_intersection/hello_vulkan.cpp | 51 ++++++++++++++------ ray_tracing_jitter_cam/hello_vulkan.cpp | 51 ++++++++++++++------ ray_tracing_manyhits/hello_vulkan.cpp | 51 ++++++++++++++------ ray_tracing_rayquery/hello_vulkan.cpp | 51 ++++++++++++++------ ray_tracing_reflections/hello_vulkan.cpp | 51 ++++++++++++++------ 13 files changed, 487 insertions(+), 179 deletions(-) diff --git a/ray_tracing__advance/hello_vulkan.cpp b/ray_tracing__advance/hello_vulkan.cpp index e0c0cb9..08b7532 100644 --- a/ray_tracing__advance/hello_vulkan.cpp +++ b/ray_tracing__advance/hello_vulkan.cpp @@ -93,25 +93,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #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(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing__before/hello_vulkan.cpp b/ray_tracing__before/hello_vulkan.cpp index 66052e0..50f725d 100644 --- a/ray_tracing__before/hello_vulkan.cpp +++ b/ray_tracing__before/hello_vulkan.cpp @@ -71,21 +71,45 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(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.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - //ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + // UBO on the device, and what stages access it. + vk::Buffer deviceUBO = m_cameraMat.buffer; + auto uboUsageStages = vk::PipelineStageFlagBits::eVertexShader; - cmdBuf.updateBuffer(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing__simple/hello_vulkan.cpp b/ray_tracing__simple/hello_vulkan.cpp index 68e1d32..be0ebd0 100644 --- a/ray_tracing__simple/hello_vulkan.cpp +++ b/ray_tracing__simple/hello_vulkan.cpp @@ -75,24 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #VKRay - ubo.projInverse = nvmath::invert(ubo.proj); + hostUBO.projInverse = nvmath::invert(hostUBO.proj); - cmdBuf.updateBuffer(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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}, {}); + + // 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(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( 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(missSM); m_device.destroy(shadowmissSM); diff --git a/ray_tracing_animation/hello_vulkan.cpp b/ray_tracing_animation/hello_vulkan.cpp index 8797eec..7186390 100644 --- a/ray_tracing_animation/hello_vulkan.cpp +++ b/ray_tracing_animation/hello_vulkan.cpp @@ -75,24 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #VKRay - ubo.projInverse = nvmath::invert(ubo.proj); + hostUBO.projInverse = nvmath::invert(hostUBO.proj); - cmdBuf.updateBuffer(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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}, {}); + + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing_anyhit/hello_vulkan.cpp b/ray_tracing_anyhit/hello_vulkan.cpp index 1160068..fb3c012 100644 --- a/ray_tracing_anyhit/hello_vulkan.cpp +++ b/ray_tracing_anyhit/hello_vulkan.cpp @@ -75,24 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #VKRay - ubo.projInverse = nvmath::invert(ubo.proj); + hostUBO.projInverse = nvmath::invert(hostUBO.proj); - cmdBuf.updateBuffer(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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}, {}); + + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing_callable/hello_vulkan.cpp b/ray_tracing_callable/hello_vulkan.cpp index 8301e47..24504c6 100644 --- a/ray_tracing_callable/hello_vulkan.cpp +++ b/ray_tracing_callable/hello_vulkan.cpp @@ -75,25 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #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(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing_gltf/hello_vulkan.cpp b/ray_tracing_gltf/hello_vulkan.cpp index b4ecbe4..085f043 100644 --- a/ray_tracing_gltf/hello_vulkan.cpp +++ b/ray_tracing_gltf/hello_vulkan.cpp @@ -80,25 +80,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #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(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing_instances/hello_vulkan.cpp b/ray_tracing_instances/hello_vulkan.cpp index 1c890ef..98485cc 100644 --- a/ray_tracing_instances/hello_vulkan.cpp +++ b/ray_tracing_instances/hello_vulkan.cpp @@ -91,25 +91,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #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(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing_intersection/hello_vulkan.cpp b/ray_tracing_intersection/hello_vulkan.cpp index 84d86fc..1f1f7b9 100644 --- a/ray_tracing_intersection/hello_vulkan.cpp +++ b/ray_tracing_intersection/hello_vulkan.cpp @@ -76,25 +76,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #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(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing_jitter_cam/hello_vulkan.cpp b/ray_tracing_jitter_cam/hello_vulkan.cpp index 5e337b1..d30f5e8 100644 --- a/ray_tracing_jitter_cam/hello_vulkan.cpp +++ b/ray_tracing_jitter_cam/hello_vulkan.cpp @@ -75,25 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #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(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing_manyhits/hello_vulkan.cpp b/ray_tracing_manyhits/hello_vulkan.cpp index 04c3fbb..8a77e57 100644 --- a/ray_tracing_manyhits/hello_vulkan.cpp +++ b/ray_tracing_manyhits/hello_vulkan.cpp @@ -74,25 +74,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #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(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing_rayquery/hello_vulkan.cpp b/ray_tracing_rayquery/hello_vulkan.cpp index c735210..a90bd23 100644 --- a/ray_tracing_rayquery/hello_vulkan.cpp +++ b/ray_tracing_rayquery/hello_vulkan.cpp @@ -73,25 +73,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #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(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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(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}, {}); } //-------------------------------------------------------------------------------------------------- diff --git a/ray_tracing_reflections/hello_vulkan.cpp b/ray_tracing_reflections/hello_vulkan.cpp index ce5b36e..4beba63 100644 --- a/ray_tracing_reflections/hello_vulkan.cpp +++ b/ray_tracing_reflections/hello_vulkan.cpp @@ -75,25 +75,48 @@ void HelloVulkan::setup(const vk::Instance& instance, // void HelloVulkan::updateUniformBuffer(const vk::CommandBuffer& cmdBuf) { + // Prepare new UBO contents on host. const float aspectRatio = m_size.width / static_cast(m_size.height); - - CameraMatrices ubo = {}; - ubo.view = CameraManip.getMatrix(); - ubo.proj = nvmath::perspectiveVK(CameraManip.getFov(), aspectRatio, 0.1f, 1000.0f); - // ubo.proj[1][1] *= -1; // Inverting Y for Vulkan - ubo.viewInverse = nvmath::invert(ubo.view); + 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); // #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(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 - vk::MemoryBarrier mb{vk::AccessFlagBits::eTransferWrite, vk::AccessFlagBits::eShaderRead}; - cmdBuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, - vk::PipelineStageFlagBits::eVertexShader - | vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR, - vk::DependencyFlagBits::eDeviceGroup, {mb}, {}, {}); + // 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(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}, {}); } //--------------------------------------------------------------------------------------------------