BuffersD3D12.h

#pragma once
 
#include "../Base/BuffersCommon.h"
 
#include "CommonD3D12.h"
 
#include <unordered_map>
 
#include "Foundation/Collections/ConfigurablePagedPool.h"
 
namespace Cogs
{
  struct PoolBuffer
  {
    PoolBuffer * next;
    uint8_t * mappedRegion;
    D3D12_GPU_VIRTUAL_ADDRESS mappedGpuRegion;
    size_t offset;
    struct BufferPool * pool;
    ID3D12Resource * resource;
  };
 
  struct BufferContext
  {
    ResourcePointer<ID3D12Device> device;
    uint32_t elementSize;
    D3D12_HEAP_TYPE heapType;
    D3D12_RESOURCE_STATES resourceState;
    struct BufferPool * pool;
  };
 
  struct BufferPage
  {
    BufferPage(BufferContext & context, size_t pageSize);
    BufferPage(BufferPage &&) = default;
    BufferPage(BufferPage &) = delete;
 
    PoolBuffer * getHead() { return reinterpret_cast<PoolBuffer *>(storage.data()); }
 
    ResourcePointer<ID3D12Resource> buffer;
  private:
    std::vector<uint8_t> storage;
    uint8_t * mappedRegion;
    D3D12_GPU_VIRTUAL_ADDRESS mappedGpuRegion;
  };
 
  struct BufferPool : public Collections::ConfigurablePagedPool<BufferContext, BufferPage, PoolBuffer>
  {
    void initialize(ResourcePointer<ID3D12Device> device, size_t capacity, uint32_t elementSize, uint32_t pageSize = 128)
    {
      BufferContext context;
      context.device = device;
      context.elementSize = elementSize;
      context.heapType = D3D12_HEAP_TYPE_UPLOAD;
      context.resourceState = D3D12_RESOURCE_STATE_GENERIC_READ;
      context.pool = this;
 
      ConfigurablePagedPool::initialize(context, capacity, pageSize);
    }
  };
 
  struct BufferD3D12 : public ResourceD3D12
  {
    union
    {
      D3D12_VERTEX_BUFFER_VIEW vertexBufferView;
      D3D12_INDEX_BUFFER_VIEW indexBufferView;
      D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc;
      D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc;
    };
 
    union
    {
      const VertexFormat * vertexFormat;
      const DXGI_FORMAT * indexFormat;
    };
 
    union
    {
      size_t count;
      size_t size;
    };
 
    uint32_t bindFlags = 0;
    ResourcePointer<ID3D12Resource> counterResource;
    
    ResourceD3D12 uploadResource;
  };
 
  struct InputLayoutD3D12
  {
    D3D12_INPUT_ELEMENT_DESC inputElements[D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT];
    UINT inputElementCount = 0;
  };
 
  struct BuffersD3D12 : public BuffersCommon
  {
    void initialize(struct GraphicsDeviceD3D12 * graphicsDevice);
 
    struct GraphicsDeviceD3D12 * graphicsDevice;
 
    VertexBufferHandle loadVertexBuffer(const void * vertexData, const size_t count, const VertexFormat & vertexFormat) override;
    VertexBufferHandle loadVertexBuffer(const void * vertexData, const size_t count, VertexFormatHandle vertexFormat) override;
    void releaseVertexBuffer(VertexBufferHandle vertexBufferHandle);
 
    IndexBufferHandle loadIndexBuffer(const void * vertexData, const size_t count, const size_t indexSize);
    void releaseIndexBuffer(IndexBufferHandle indexBufferHandle);
 
    InputLayoutHandle loadInputLayout(const VertexFormatHandle * vertexFormats, const size_t count, EffectHandle effectHandle);
    void releaseInputLayout(InputLayoutHandle vertexFormatHandle);
 
    BufferHandle loadBuffer(const void * data, const size_t size, Usage::EUsage usage, uint32_t accessMode, uint32_t bindFlags, uint32_t stride = 0);
    void releaseBuffer(BufferHandle bufferHandle);
 
    void retrieveSubBuffer(void * data, BufferHandle source, const size_t offset, const size_t size);
 
    void * getNativeHandle(BufferHandle bufferHandle) override;
 
    void releaseResources();
 
    BufferPool & getBufferPool(const size_t size, uint32_t bindFlags = 0);
    void releaseBufferInternal(BufferHandle bufferHandle);
 
    ResourceMap<BufferHandle, BufferD3D12> buffers;
    ResourceMap<InputLayoutHandle, InputLayoutD3D12> inputLayouts;
 
    std::unordered_map<size_t, VertexFormat> vertexFormats;
 
    void allocateBuffer(ResourceD3D12 & resource, size_t size, const void * data = nullptr);
  private:
 
    BufferPool bufferPool256;
    BufferPool bufferPool1024;
 
    ResourcePointer<ID3D12Device> device;
 
    struct EffectsD3D12 * effects;
  };
}