Add ring buffering for encoders

Author: floppyhammer

demo/native/main.cpp

@@ -50,6 +50,7 @@ int main() {
         }
 
         device->begin_frame();
+        queue->begin_frame(device->get_current_frame_index());
 
         auto current_window_size = window->get_physical_size();
 

pathfinder/core/d3d9/renderer.cpp

@@ -59,7 +59,7 @@ RendererD3D9::RendererD3D9(const std::shared_ptr<Device> &_device, const std::sh
                           quad_vertex_data_size,
                           QUAD_VERTEX_POSITIONS);
 
-    queue->submit(encoder, fence);
+    queue->submit(encoder, nullptr);
 }
 
 void RendererD3D9::set_dest_texture(const std::shared_ptr<Texture> &texture) {
@@ -365,7 +365,7 @@ void RendererD3D9::draw(const std::shared_ptr<SceneBuilder> &_scene_builder, boo
 
     upload_and_draw_tiles(scene_builder->tile_batches, encoder);
 
-    queue->submit(encoder, fence);
+    queue->submit(encoder, nullptr);
 
     // Clean up.
     if (fill_vertex_buffer_id) {

pathfinder/core/paint/palette.cpp

@@ -162,7 +162,7 @@ std::vector<PaintMetadata> Palette::build_paint_info(Renderer *renderer) {
         }
     }
 
-    renderer->queue->submit(encoder, renderer->fence);
+    renderer->queue->submit(encoder, nullptr);
 
     // Free transient locations and unused images, now that they're no longer needed.
     free_transient_locations(*paint_texture_manager, transient_paint_locations);

pathfinder/core/renderer.cpp

@@ -33,7 +33,7 @@ Renderer::Renderer(const std::shared_ptr<Device> &_device, const std::shared_ptr
 
     encoder->write_texture(allocator->get_texture(area_lut_texture_id), {}, image_buffer->get_data());
 
-    queue->submit(encoder, fence);
+    queue->submit(encoder, nullptr);
 }
 
 Renderer::~Renderer() {

pathfinder/gpu/device.h

@@ -98,7 +98,7 @@ class Device : public std::enable_shared_from_this<Device> {
         }
     }
 
-    int get_frames_in_flight() const {
+    uint32_t get_frames_in_flight() const {
         return frames_in_flight_;
     }
 
@@ -126,7 +126,7 @@ class Device : public std::enable_shared_from_this<Device> {
 
     std::vector<StagingBucket> staging_buckets_;
 
-    int frames_in_flight_;
+    uint32_t frames_in_flight_;
 
     uint32_t current_frame_index_ = 0;
 

pathfinder/gpu/queue.h

@@ -18,6 +18,11 @@ class Queue {
     virtual ~Queue() = default;
 
     virtual void submit(const std::shared_ptr<CommandEncoder> &encoder, const std::shared_ptr<Fence> &fence) = 0;
+
+    virtual void begin_frame(uint32_t current_frame_index) {}
+
+protected:
+    uint32_t current_frame_index_{};
 };
 
 } // namespace Pathfinder

pathfinder/gpu/vk/queue.cpp

@@ -39,10 +39,17 @@ void QueueVk::submit(const std::shared_ptr<CommandEncoder> &encoder, const std::
         // A simple way is to wait for the queue to be idle.
         if (!encoder->callbacks_.empty()) {
             vkQueueWaitIdle(vk_graphics_queue_);
+        } else {
+            encoders_in_flight_[current_frame_index_ % frames_in_flight_].push_back(encoder);
         }
     }
 
     encoder->invoke_callbacks();
 }
 
+void QueueVk::begin_frame(uint32_t current_frame_index) {
+    current_frame_index_ = current_frame_index;
+    encoders_in_flight_[current_frame_index_ % frames_in_flight_].clear();
+}
+
 } // namespace Pathfinder

pathfinder/gpu/vk/queue.h

@@ -12,18 +12,26 @@ class QueueVk : public Queue {
 public:
     void submit(const std::shared_ptr<CommandEncoder> &encoder, const std::shared_ptr<Fence> &fence) override;
 
+    void begin_frame(uint32_t current_frame_index) override;
+
 private:
     VkDevice vk_device_{};
 
     VkQueue vk_graphics_queue_{};
 
     VkQueue vk_present_queue_{};
 
+    std::vector<std::vector<std::shared_ptr<CommandEncoder>>> encoders_in_flight_;
+
+    uint32_t frames_in_flight_{};
+
 public:
-    QueueVk(VkDevice vk_device, VkQueue vk_graphics_queue, VkQueue vk_present_queue) {
+    QueueVk(VkDevice vk_device, VkQueue vk_graphics_queue, VkQueue vk_present_queue, uint32_t frames_in_flight) {
         vk_device_ = vk_device;
         vk_graphics_queue_ = vk_graphics_queue;
         vk_present_queue_ = vk_present_queue;
+        frames_in_flight_ = frames_in_flight;
+        encoders_in_flight_.resize(frames_in_flight);
     }
 };
 

pathfinder/gpu/vk/window_builder.cpp

@@ -155,7 +155,7 @@ std::shared_ptr<Device> WindowBuilderVk::request_device() {
 }
 
 std::shared_ptr<Queue> WindowBuilderVk::create_queue() {
-    auto queue = std::shared_ptr<QueueVk>(new QueueVk(device_, graphics_queue_, present_queue_));
+    auto queue = std::shared_ptr<QueueVk>(new QueueVk(device_, graphics_queue_, present_queue_, MAX_FRAMES_IN_FLIGHT));
     return queue;
 }