BuffersVK.h

#pragma once
 
#include "../Base/BuffersCommon.h"
 
#include "CommonVK.h"
 
#include "../Base/ResourcePolicies.h"
 
#include "Foundation/Collections/ConfigurablePagedPool.h"
 
namespace Cogs
{
  struct PoolBufferVK
  {
    PoolBufferVK * next;
    uint8_t * mappedRegion;
    VkBuffer buffer;
    size_t offset;
    size_t size;
    struct BufferPoolVK * pool;
  };
 
  struct BufferContextVK
  {
    class GraphicsDeviceVK * graphicsDevice;
    VkDevice device;
    uint32_t elementSize;
    struct BufferPoolVK * pool;
  };
 
  struct BufferPageVK
  {
    BufferPageVK(BufferContextVK & context, size_t pageSize);
 
    PoolBufferVK * getHead() { return reinterpret_cast<PoolBufferVK *>(storage.data()); }
 
    VkBuffer buffer;
    VkDeviceMemory deviceMemory;
 
  private:
    std::vector<uint8_t> storage;
    uint8_t * mappedRegion;
  };
 
  struct BufferPoolVK : public Collections::ConfigurablePagedPool<BufferContextVK, BufferPageVK, PoolBufferVK>
  {
    void initialize(GraphicsDeviceVK * graphicsDevice, VkDevice device, size_t capacity, uint32_t elementSize, uint32_t pageSize = 128)
    {
      BufferContextVK context;
      context.graphicsDevice = graphicsDevice;
      context.device = device;
      context.elementSize = elementSize;
      context.pool = this;
 
      ConfigurablePagedPool::initialize(context, capacity, pageSize);
    }
  };
 
  struct BufferVK
  {
    PoolBufferVK * poolBuffer = nullptr;
 
    VkBuffer buffer;
    VkDeviceMemory deviceMemory;
 
    VkBufferView bufferView;
    VkDescriptorBufferInfo bufferInfo;
 
    size_t size;
 
    BindFlags::EBindFlags bindFlags;
 
    union
    {
      VertexFormat * vertexFormat;
      size_t indexSize;
    };
  };
 
  struct InputLayoutVK
  {
    VkPipelineVertexInputStateCreateInfo vertexInputState;
    std::vector<VkVertexInputBindingDescription> vertexInputBinding;
    std::vector<VkVertexInputAttributeDescription> vertexInputAttribs;
  };
 
  class BuffersVK : public BuffersCommon
  {
  public:
    void initialize(class GraphicsDeviceVK * graphicsDevice);
 
    class GraphicsDeviceVK * graphicsDevice;
 
    VertexBufferHandle loadVertexBuffer(const void * vertexData, const size_t count, const VertexFormat & vertexFormat) override;
    VertexBufferHandle loadVertexBuffer(const void * vertexData, const size_t count, VertexFormatHandle vertexFormatHandle) override;
    void releaseVertexBuffer(VertexBufferHandle vertexBufferHandle) override;
    IndexBufferHandle loadIndexBuffer(const void * indexData, const size_t count, const size_t indexSize) override;
    void releaseIndexBuffer(IndexBufferHandle indexBufferHandle) override;
 
    InputLayoutHandle loadInputLayout(const VertexFormatHandle * vertexFormats, const size_t count, EffectHandle effectHandle) override;
    void releaseInputLayout(InputLayoutHandle inputLayoutHandle) override;
    BufferHandle loadBuffer(const void * data, const size_t size, Usage::EUsage usage, uint32_t accessMode, uint32_t bindFlags, uint32_t stride = 0) override;
 
    void retrieveSubBuffer(void * data, BufferHandle source, const size_t offset, const size_t size) override;
    void releaseBuffer(BufferHandle bufferHandle) override;
    void * getNativeHandle(BufferHandle bufferHandle) override;
    void releaseResources() override;
 
    ResourceMap<BufferHandle, BufferVK> buffers;
    ResourceMap<InputLayoutHandle, InputLayoutVK> inputLayouts;
 
    std::unordered_map<size_t, VertexFormat> vertexFormats;
 
    BufferPoolVK pool256;
    BufferPoolVK pool1024;
  };
}