Added support for events, improved texture loading further

Author: DethRaid

RenderCore/render/backend/buffer_usage_token.hpp

@@ -4,10 +4,24 @@
 
 #include <volk.h>
 
+#include "render/backend/handles.hpp"
+
 struct BufferUsageToken {
     VkPipelineStageFlags2KHR stage;
 
     VkAccessFlags2KHR access;
 };
 
+struct BufferBarrier {
+    BufferHandle buffer = BufferHandle::None;
+
+    BufferUsageToken src = {};
+
+    BufferUsageToken dst = {};
+
+    uint32_t offset = 0;
+
+    uint32_t size = 0;
+};
+
 using BufferUsageMap = std::unordered_map<BufferHandle, BufferUsageToken>;

RenderCore/render/backend/command_buffer.cpp

@@ -288,6 +288,53 @@ void CommandBuffer::dispatch(const uint32_t width, const uint32_t height, const
     vkCmdDispatch(commands, width, height, depth);
 }
 
+void CommandBuffer::reset_event(const VkEvent event, const VkPipelineStageFlags stages) const {
+    vkCmdResetEvent2KHR(commands, event, stages);
+}
+
+void CommandBuffer::set_event(const VkEvent event, const std::vector<BufferBarrier>& buffers) {
+    auto& allocator = backend->get_global_allocator();
+
+    auto buffer_barriers = std::vector<VkBufferMemoryBarrier2KHR>{};
+    buffer_barriers.reserve(buffers.size());
+    for (const auto& buffer_barrier : buffers) {
+        const auto& buffer_actual = allocator.get_buffer(buffer_barrier.buffer);
+        const auto barrier = VkBufferMemoryBarrier2{
+            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR,
+            .srcStageMask = buffer_barrier.src.stage,
+            .srcAccessMask = buffer_barrier.src.access,
+            .dstStageMask = buffer_barrier.dst.stage,
+            .dstAccessMask = buffer_barrier.dst.access,
+            .buffer = buffer_actual.buffer,
+            .offset = buffer_barrier.offset,
+            .size = buffer_barrier.size
+        };
+        buffer_barriers.emplace_back(barrier);
+    }
+
+    const auto dependency = VkDependencyInfoKHR{
+        .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR,
+        .bufferMemoryBarrierCount = static_cast<uint32_t>(buffer_barriers.size()),
+        .pBufferMemoryBarriers = buffer_barriers.data()
+    };
+    vkCmdSetEvent2KHR(commands, event, &dependency);
+
+    event_buffer_barriers.emplace(event, std::move(buffer_barriers));
+}
+
+void CommandBuffer::wait_event(const VkEvent event) {
+    const auto& buffer_barriers = event_buffer_barriers.at(event);
+
+    const auto dependency = VkDependencyInfoKHR{
+        .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR,
+        .bufferMemoryBarrierCount = static_cast<uint32_t>(buffer_barriers.size()),
+        .pBufferMemoryBarriers = buffer_barriers.data()
+    };
+    vkCmdWaitEvents2KHR(commands, 1, &event, &dependency);
+
+    event_buffer_barriers.erase(event);
+}
+
 void CommandBuffer::begin_label(const std::string& event_name) const {
     if (vkCmdBeginDebugUtilsLabelEXT == nullptr) {
         return;

RenderCore/render/backend/command_buffer.hpp

@@ -7,6 +7,7 @@
 #include <volk.h>
 #include <tracy/TracyVulkan.hpp>
 
+#include "buffer_usage_token.hpp"
 #include "render/backend/handles.hpp"
 #include "render/backend/pipeline.hpp"
 #include "render/backend/framebuffer.hpp"
@@ -68,7 +69,8 @@ class CommandBuffer {
      * Issues a batch of pipeline barriers
      */
     void barrier(
-        const std::vector<VkMemoryBarrier2KHR>& memory_barriers, const std::vector<VkBufferMemoryBarrier2>& buffer_barriers,
+        const std::vector<VkMemoryBarrier2KHR>& memory_barriers,
+        const std::vector<VkBufferMemoryBarrier2>& buffer_barriers,
         const std::vector<VkImageMemoryBarrier2>& image_barriers
     ) const;
 
@@ -148,6 +150,12 @@ class CommandBuffer {
 
     void dispatch(uint32_t width, uint32_t height, uint32_t depth);
 
+    void reset_event(VkEvent event, VkPipelineStageFlags stages) const;
+
+    void set_event(VkEvent event, const std::vector<BufferBarrier>& buffers);
+    
+    void wait_event(VkEvent);
+
     void begin_label(const std::string& event_name) const;
 
     void end_label() const;
@@ -157,7 +165,7 @@ class CommandBuffer {
     tracy::VkCtx* const get_tracy_context() const;
 
     VkCommandBuffer get_vk_commands() const;
-    
+
     VkRenderPass get_current_renderpass() const;
 
     uint32_t get_current_subpass() const;
@@ -185,6 +193,14 @@ class CommandBuffer {
 
     bool are_bindings_dirty = false;
 
+    /**
+     * Cache of buffer barriers for events
+     *
+     * The spec states that the dependency info for each set/wait event call for the same event must match. The backend
+     * should handle that noise
+     */
+    std::unordered_map<VkEvent, std::vector<VkBufferMemoryBarrier2KHR>> event_buffer_barriers;
+
     void commit_bindings();
 };
 

RenderCore/render/backend/render_backend.cpp

@@ -238,7 +238,7 @@ void RenderBackend::create_instance_and_device() {
         throw std::runtime_error{error_message};
     }
     physical_device = phys_device_ret.value();
-    
+
 
     auto multiview_features = VkPhysicalDeviceMultiviewFeatures{
         .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
@@ -327,6 +327,10 @@ VkPhysicalDevice RenderBackend::get_physical_device() const {
     return physical_device.physical_device;
 }
 
+bool RenderBackend::supports_etc2() const { return physical_device.features.textureCompressionETC2; }
+
+bool RenderBackend::supports_bc() const { return physical_device.features.textureCompressionBC; }
+
 vkb::Device RenderBackend::get_device() const {
     return device;
 }

RenderCore/render/backend/render_backend.hpp

@@ -46,6 +46,10 @@ class RenderBackend {
     VkInstance get_instance() const;
 
     VkPhysicalDevice get_physical_device() const;
+    
+    bool supports_etc2() const;
+
+    bool supports_bc() const;
 
     vkb::Device get_device() const;
 

RenderCore/render/scene_renderer.cpp

@@ -48,6 +48,8 @@ SceneRenderer::SceneRenderer() :
 }
 
 void SceneRenderer::set_render_resolution(const glm::uvec2& resolution) {
+    ZoneScoped;
+
     if (resolution == scene_render_resolution) {
         return;
     }