source/backends/vulkan/transferqueue.cpp

   1 #include <msp/core/algorithm.h>
   2 #include "device.h"
   3 #include "transferqueue.h"
   4 #include "vulkan.h"
   5
   6 using namespace std;
   7
   8 namespace Msp {
   9 namespace GL {
  10
  11 TransferQueue::TransferQueue(Device &d):
  12         device(d)
  13 { }
  14
  15 TransferQueue::PendingTransfer &TransferQueue::prepare_transfer(size_t size)
  16 {
  17         auto i = find_if(buffers, [size](const StagingBuffer &b){ return b.used+size<=b.size; });
  18         if(i==buffers.end())
  19         {
  20                 buffers.emplace_back(device, max(default_buffer_size, size));
  21                 i = prev(buffers.end());
  22         }
  23
  24         PendingTransfer transfer;
  25         transfer.buffer_index = distance(buffers.begin(), i);
  26         transfer.offset = i->used;
  27         transfer.size = size;
  28         transfers.push_back(transfer);
  29
  30         i->used += size;
  31
  32         return transfers.back();
  33 }
  34
  35 void TransferQueue::dispatch_transfers(VkCommandBuffer command_buffer)
  36 {
  37         if(!transfers.empty())
  38                 device.get_synchronizer().barrier(command_buffer);
  39
  40         for(const PendingTransfer &t: transfers)
  41         {
  42                 VkBuffer buffer = buffers[t.buffer_index].buffer;
  43                 t.callback(command_buffer, buffer, t.offset);
  44         }
  45
  46         transfers.clear();
  47 }
  48
  49
  50 TransferQueue::StagingBuffer::StagingBuffer(Device &d, size_t s):
  51         device(d),
  52         size(s)
  53 {
  54         const VulkanFunctions &vk = device.get_functions();
  55
  56         VkBufferCreateInfo buffer_info = { };
  57         buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
  58         buffer_info.size = size;
  59         buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
  60         buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
  61
  62         vk.CreateBuffer(buffer_info, buffer);
  63
  64         MemoryAllocator &allocator = device.get_allocator();
  65         memory_id = allocator.allocate(buffer, STAGING_MEMORY);
  66         mapped_address = allocator.map(memory_id, 0, size);
  67 }
  68
  69 TransferQueue::StagingBuffer::StagingBuffer(StagingBuffer &&other):
  70         device(other.device),
  71         buffer(other.buffer),
  72         memory_id(other.memory_id),
  73         size(other.size),
  74         used(other.used),
  75         mapped_address(other.mapped_address)
  76 {
  77         other.buffer = 0;
  78         other.memory_id = 0;
  79         other.mapped_address = 0;
  80 }
  81
  82 TransferQueue::StagingBuffer::~StagingBuffer()
  83 {
  84         const VulkanFunctions &vk = device.get_functions();
  85         MemoryAllocator &allocator = device.get_allocator();
  86
  87         if(mapped_address)
  88         {
  89                 allocator.unmap(mapped_address);
  90                 allocator.release(memory_id);
  91         }
  92         if(buffer)
  93                 vk.DestroyBuffer(buffer);
  94 }
  95
  96 } // namespace GL
  97 } // namespace Msp