Track the order of transfers involving the same objects

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

diff --git a/source/backends/vulkan/transferqueue.h b/source/backends/vulkan/transferqueue.h
index 419760bdf4d6b709bd4b28a393428f8da45f9383..b8719d627513bd8962dec3df4c1b52ddd2a8dbc5 100644 (file)
--- a/source/backends/vulkan/transferqueue.h
+++ b/source/backends/vulkan/transferqueue.h
@@ -28,39 +28,41 @@ private:
                ~StagingBuffer();
        };
 
-       using TransferCallback = void(VkCommandBuffer, VkBuffer, std::size_t);
-
        struct PendingTransfer
        {
+               unsigned order = 0;
                unsigned buffer_index = 0;
                std::size_t offset = 0;
                std::size_t size = 0;
-               std::function<TransferCallback> callback;
+               std::function<void()> synchronize;
+               std::function<void(VkCommandBuffer, VkBuffer, std::size_t)> transfer;
        };
 
        Device &device;
        std::size_t default_buffer_size = 16*1048576;
        std::vector<StagingBuffer> buffers;
        std::vector<PendingTransfer> transfers;
+       std::map<void *, unsigned> next_orders;
 
 public:
        TransferQueue(Device &);
 
-       template<typename T>
-       void *prepare_transfer(std::size_t, T &&);
+       template<typename S, typename T>
+       void *prepare_transfer(void *, bool, std::size_t, S &&, T &&);
 
 private:
-       PendingTransfer &prepare_transfer(std::size_t);
+       PendingTransfer &prepare_transfer(void *, bool, std::size_t);
 
 public:
        void dispatch_transfers(VkCommandBuffer);
 };
 
-template<typename T>
-void *TransferQueue::prepare_transfer(std::size_t size, T &&callback)
+template<typename S, typename T>
+void *TransferQueue::prepare_transfer(void *object, bool ordered, std::size_t size, S &&synchronize, T &&transfer)
 {
-       PendingTransfer &pt = prepare_transfer(size);
-       pt.callback = std::forward<T>(callback);
+       PendingTransfer &pt = prepare_transfer(object, ordered, size);
+       pt.synchronize = std::forward<S>(synchronize);
+       pt.transfer = std::forward<T>(transfer);
        return static_cast<char *>(buffers[pt.buffer_index].mapped_address)+pt.offset;
 }