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         for(const PendingTransfer &t: transfers)
  38         {
  39                 VkBuffer buffer = buffers[t.buffer_index].buffer;
  40                 t.callback(command_buffer, buffer, t.offset);
  41         }
  42
  43         transfers.clear();
  44 }
  45
  46
  47 TransferQueue::StagingBuffer::StagingBuffer(Device &d, size_t s):
  48         device(d),
  49         size(s)
  50 {
  51         const VulkanFunctions &vk = device.get_functions();
  52
  53         VkBufferCreateInfo buffer_info = { };
  54         buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
  55         buffer_info.size = size;
  56         buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
  57         buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
  58
  59         vk.CreateBuffer(buffer_info, buffer);
  60
  61         MemoryAllocator &allocator = device.get_allocator();
  62         memory_id = allocator.allocate(buffer, STAGING_MEMORY);
  63         mapped_address = allocator.map(memory_id, 0, size);
  64 }
  65
  66 TransferQueue::StagingBuffer::StagingBuffer(StagingBuffer &&other):
  67         device(other.device),
  68         buffer(other.buffer),
  69         memory_id(other.memory_id),
  70         size(other.size),
  71         used(other.used),
  72         mapped_address(other.mapped_address)
  73 {
  74         other.buffer = 0;
  75         other.memory_id = 0;
  76         other.mapped_address = 0;
  77 }
  78
  79 TransferQueue::StagingBuffer::~StagingBuffer()
  80 {
  81         const VulkanFunctions &vk = device.get_functions();
  82         MemoryAllocator &allocator = device.get_allocator();
  83
  84         if(mapped_address)
  85         {
  86                 allocator.unmap(mapped_address);
  87                 allocator.release(memory_id);
  88         }
  89         if(buffer)
  90                 vk.DestroyBuffer(buffer);
  91 }
  92
  93 } // namespace GL
  94 } // namespace Msp