Check the flat qualifier from the correct member

[libs/gl.git] / source / backends / vulkan / transferqueue.h

diff --git a/source/backends/vulkan/transferqueue.h b/source/backends/vulkan/transferqueue.h
index 58b1bc2d6fa5f4743964c72d1e15e01305a97af0..536edbd8782830f1352444e2c5f38419653523f4 100644 (file)
--- a/source/backends/vulkan/transferqueue.h
+++ b/source/backends/vulkan/transferqueue.h
@@ -10,6 +10,7 @@ namespace GL {
 
 class Buffer;
 class Device;
+class VulkanCommandRecorder;
 
 class TransferQueue
 {
@@ -22,6 +23,8 @@ private:
                std::size_t size = 0;
                std::size_t used = 0;
                void *mapped_address = 0;
+               unsigned async_count = 0;
+               unsigned last_frame = 0;
 
                StagingBuffer(Device &, std::size_t);
                StagingBuffer(StagingBuffer &&);
@@ -30,19 +33,23 @@ private:
 
        struct PendingTransfer
        {
+               const void *object = 0;
                unsigned order = 0;
                int buffer_index = -1;
                std::size_t offset = 0;
                std::size_t size = 0;
+               void *staging_address = 0;
                std::function<void()> synchronize;
-               std::function<void(VkCommandBuffer, VkBuffer, std::size_t)> transfer;
+               std::function<void(const VulkanCommandRecorder &, VkBuffer, std::size_t)> transfer;
        };
 
        Device &device;
        std::size_t default_buffer_size = 16*1048576;
        std::vector<StagingBuffer> buffers;
        std::vector<PendingTransfer> transfers;
+       std::vector<PendingTransfer> async_transfers;
        std::map<const void *, unsigned> next_orders;
+       unsigned current_frame = 0;
 
 public:
        TransferQueue(Device &);
@@ -50,11 +57,19 @@ public:
        template<typename S, typename T>
        void *prepare_transfer(const void *, bool, std::size_t, S &&, T &&);
 
+       template<typename S, typename T>
+       void prepare_transfer(const void *o, bool r, S &&s, T &&t)
+       { prepare_transfer(o, r, 0, std::forward<S>(s), std::forward<T>(t)); }
+
+       void finalize_transfer(void *);
+
 private:
+       void allocate_staging(PendingTransfer &, std::size_t);
        PendingTransfer &prepare_transfer(const void *, bool, std::size_t);
+       PendingTransfer &insert_transfer(PendingTransfer &&);
 
 public:
-       void dispatch_transfers(VkCommandBuffer);
+       void dispatch_transfers(const VulkanCommandRecorder &);
 };
 
 template<typename S, typename T>
@@ -63,7 +78,7 @@ void *TransferQueue::prepare_transfer(const void *object, bool ordered, std::siz
        PendingTransfer &pt = prepare_transfer(object, ordered, size);
        pt.synchronize = std::forward<S>(synchronize);
        pt.transfer = std::forward<T>(transfer);
-       return (pt.buffer_index<0 ? 0 : static_cast<char *>(buffers[pt.buffer_index].mapped_address)+pt.offset);
+       return pt.staging_address;
 }
 
 } // namespace GL