RenderTargetsD3D12.h

#pragma once
 
#include "../IRenderTargets.h"
 
#include "Foundation/Collections/ConfigurablePagedPool.h"
 
#include "CommonD3D12.h"
 
namespace Cogs
{
  struct TexturesD3D12;
 
  struct PoolDescriptor
  {
    PoolDescriptor * next;
    D3D12_CPU_DESCRIPTOR_HANDLE handle;
  };
 
  struct DescriptorContext
  {
    ResourcePointer<ID3D12Device> device;
    D3D12_DESCRIPTOR_HEAP_TYPE heapType;
  };
 
  struct DescriptorPage
  {
    DescriptorPage(DescriptorContext & context, size_t pageSize)
    {
      storage.resize(sizeof(PoolDescriptor) * pageSize);
 
      D3D12_DESCRIPTOR_HEAP_DESC heapDesc = {};
      heapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
      heapDesc.Type = context.heapType;
      heapDesc.NumDescriptors = static_cast<UINT>(pageSize);
      heapDesc.NodeMask = 0;
 
      context.device->CreateDescriptorHeap(&heapDesc, IID_PPV_ARGS(heap.internalPointer()));
 
      auto heapStart = heap->GetCPUDescriptorHandleForHeapStart();
      auto descriptorSize = context.device->GetDescriptorHandleIncrementSize(context.heapType);
 
      for (size_t i = 0; i < pageSize; ++i) {
        PoolDescriptor * block = reinterpret_cast<PoolDescriptor *>(storage.data() + i * static_cast<size_t>(sizeof(PoolDescriptor)));
 
        CD3DX12_CPU_DESCRIPTOR_HANDLE::InitOffsetted(block->handle, heapStart, static_cast<int>(i), descriptorSize);
        block->next = (i == pageSize - 1) ? nullptr : block + 1;
      }
    }
 
    PoolDescriptor * getHead() { return reinterpret_cast<PoolDescriptor *>(storage.data()); }
 
  private:
    ResourcePointer<ID3D12DescriptorHeap> heap;
    std::vector<uint8_t> storage;
  };
 
  struct DescriptorPool : public Collections::ConfigurablePagedPool<DescriptorContext, DescriptorPage, PoolDescriptor>
  {
    void initialize(ResourcePointer<ID3D12Device> device, size_t capacity, D3D12_DESCRIPTOR_HEAP_TYPE heapType)
    {
      DescriptorContext context;
      context.device = device;
      context.heapType = heapType;
 
      ConfigurablePagedPool::initialize(context, capacity, capacity);
    }
  };
 
  const size_t kMaxRenderTargets = 8;
 
  struct RenderTargetD3D12
  {
    PoolDescriptor * descriptor[kMaxRenderTargets];
 
    D3D12_RENDER_TARGET_VIEW_DESC viewDesc[kMaxRenderTargets];
    ResourcePointer<ID3D12Resource> resource;
    uint32_t numSamples = 1;
 
    TextureHandle textures[kMaxRenderTargets];
 
    D3D12_CPU_DESCRIPTOR_HANDLE descriptorHandle[kMaxRenderTargets];
    uint8_t numViews = 1;
  };
 
  struct DepthStencilTargetD3D12
  {
    PoolDescriptor * descriptor;
 
    D3D12_DEPTH_STENCIL_VIEW_DESC viewDesc;
 
    D3D12_CPU_DESCRIPTOR_HANDLE descriptorHandle;
 
    TextureHandle texture;
  };
 
  struct RasterizerStateD3D12
  {
    D3D12_RASTERIZER_DESC rasterizerDesc;
  };
 
  struct DepthStencilStateD3D12
  {
    D3D12_DEPTH_STENCIL_DESC depthStencilDesc;
  };
 
  struct BlendStateD3D12
  {
    D3D12_BLEND_DESC blendDesc;
  };
 
  struct RenderTargetsD3D12 : IRenderTargets
  {
    HRESULT initialize(struct GraphicsDeviceD3D12 * graphicsDevice);
 
    TexturesD3D12 * textures;
 
    RenderTargetHandle createRenderTarget(ID3D12Resource * resource);
    RenderTargetHandle createRenderTarget(const RenderTargetViewDescription * renderTargetViews, const size_t numViews) override;
    void releaseRenderTarget(RenderTargetHandle handle);
 
    DepthStencilHandle createDepthStencilTarget(const RenderTargetHandle handle);
    DepthStencilHandle createDepthStencilTarget(const RenderTargetHandle handle, const TextureHandle textureHandle);
    DepthStencilHandle createDepthStencilTarget(const RenderTargetHandle handle, const DepthStencilViewDescription & depthStencilView) override;
    void releaseDepthStencilTarget(DepthStencilHandle handle);
 
    DepthStencilStateHandle loadDepthStencilState(const DepthStencilState & depthStencilState);
    void releaseDepthStencilState(DepthStencilStateHandle handle);
 
    RasterizerStateHandle loadRasterizerState(const RasterizerState & rasterizerState);
    void releaseRasterizerState(RasterizerStateHandle handle);
 
    BlendStateHandle loadBlendState(const BlendState& blendState);
    BlendStateHandle loadBlendState(const BlendState& blendStateColor, const BlendState& blendStateAlpha) override;
    BlendStateHandle loadBlendState(const BlendState& blendStateColor, const BlendState& blendStateAlpha, const uint32_t flags) override;
    BlendStateHandle loadBlendState(const BlendState* blendStateColor, const BlendState* blendStateAlpha, const uint32_t numBlendState, const uint32_t flags) override;
    void releaseBlendState(BlendStateHandle handle);
    
    void releaseResources();
 
    ResourceMap<RenderTargetHandle, RenderTargetD3D12> renderTargets;
    ResourceMap<DepthStencilHandle, DepthStencilTargetD3D12> depthStencilTargets;
 
    ResourceMap<BlendStateHandle, BlendStateD3D12> blendStates;
    ResourceMap<RasterizerStateHandle, RasterizerStateD3D12> rasterizerStates;
    ResourceMap<DepthStencilStateHandle, DepthStencilStateD3D12> depthStencilStates;
 
    DescriptorPool rtvPool;
    DescriptorPool dsvPool;
 
  private:
    ResourcePointer<ID3D12Device> device;
    GraphicsDeviceD3D12 * graphicsDevice;
  };
}