ContextD3D12.h

#pragma once
 
#include "../Base/ContextCommon.h"
 
#include "BuffersD3D12.h"
#include "TexturesD3D12.h"
#include "EffectsD3D12.h"
#include "RenderTargetsD3D12.h"
 
#include <unordered_map>
#include <array>
#include <algorithm>
 
#include "FrameResourcesD3D12.h"
#include "ContextStateD3D12.h"
 
namespace Cogs
{
  struct ContextD3D12 : public ContextCommon
  {
    ContextD3D12();
    ~ContextD3D12();
 
    void initialize(struct GraphicsDeviceD3D12 * graphicsDevice);
 
    void beginFrame();
 
    void updateFrameResources();
 
    void endFrame();
 
    void executeCommandList();
    void flush();
 
    IEffects * getEffects() override;
 
    void setEffect(EffectHandle handle) override;
 
    void signal(FenceHandle fenceHandle) override;
 
    void beginRenderPass(const RenderPassInfo &info) override {}
    void endRenderPass() override {}
 
    void setRenderTarget(const RenderTargetHandle handle, const DepthStencilHandle depthStencilHandle) override;
    void setViewport(const float x, const float y, const float width, const float height) override;
    void setScissor(const int x, const int y, const int width, const int height) override;
 
    void clearRenderTarget(const float * color) override;
    void clearRenderTarget(const float ** colors, const int count) override;
    void clearDepth(const float depth = 1.0f) override;
 
    void setDepthStencilState(const DepthStencilStateHandle handle) override;
    void setRasterizerState(const RasterizerStateHandle handle) override;
    void setBlendState(const BlendStateHandle handle, const float* constant) override;
 
    void resolveResource(TextureHandle source, TextureHandle destination) override;
 
    void setInputLayout(const InputLayoutHandle inputLayoutHandle) override;
 
    void setVertexBuffers(const VertexBufferHandle * vertexBufferHandles, const size_t count) override;
    void setVertexBuffers(const VertexBufferHandle * vertexBufferHandles, const size_t count, const uint32_t * strides, const uint32_t * offsets) override;
    void setIndexBuffer(IndexBufferHandle indexBufferHandle, uint32_t stride, uint32_t offset) override;
    void setConstantBuffer(const ConstantBufferBindingHandle bufferBinding, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size) override;
 
    void setupConstantBuffers();
    void setupDrawBuffers();
    
    void draw(PrimitiveType::EPrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes) override;
 
    void drawIndexed(PrimitiveType::EPrimitiveType primitiveType, const size_t startIndex, const size_t numIndexes, const size_t startVertex) override;
 
    void drawInstanced(PrimitiveType::EPrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes, const size_t startInstance, const size_t numInstances) override;
    void drawInstancedIndexed(PrimitiveType::EPrimitiveType primitiveType, const size_t startInstance, const size_t numInstances, const size_t startIndex, const size_t numIndexes) override;
    void dispatchCompute(const unsigned int threadGroupsX, const unsigned int threadGroupsY, const unsigned int threadGroupsZ) override;
 
    void readDepthBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer::EFrameBuffer framebuffer) override;
    void readColorBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer::EFrameBuffer framebuffer) override;
    
    void * map(BufferHandle bufferHandle, MapMode::EMapMode accessMode, uint32_t * stride = 0) override;
    void unmap(BufferHandle bufferHandle) override;
 
    void * map(TextureHandle textureHandle, MapMode::EMapMode accessMode, uint32_t * rowPitch, uint32_t * depthPitch) override { return nullptr; }
    void unmap(TextureHandle textureHandle) {}
 
    void updateSubTexture(TextureHandle textureHandle, const size_t level, const void * data) override;
    void updateSubBuffer(BufferHandle bufferHandle, const size_t offset, const size_t size, const void * data) override;
 
    void copyResource(BufferHandle destinationHandle, BufferHandle sourceHandle) override;
    void copyResource(TextureHandle destinationHandle, TextureHandle sourceHandle) override;
 
    void copyTexture(TextureHandle dstHandle, unsigned dstSub, unsigned dstX, unsigned dstY, unsigned dstZ, TextureHandle sourceHandle, unsigned srcSub) override {}
 
    void clearResource(BufferHandle destinationHandle, uint32_t *Values) override {}
    void clearResource(BufferHandle destinationHandle, float *Values) override {}
 
    void setTexture(const TextureBindingHandle textureBindingHandle, const TextureHandle textureHandle) override;
    void setTexture(const TextureBindingHandle textureBindingHandle, TextureViewHandle textureViewHandle) override;
 
    void setSamplerState(const SamplerStateBindingHandle samplerStateBindingHandle, const SamplerStateHandle samplerStateHandle) override;
 
    void setBuffer(const BufferBindingHandle bufferBindingHandle, BufferHandle bufferHandle) override;
    
    void setBufferCounter(BufferHandle bufferHandle, uint32_t value);
    void setBufferCounter(BufferHandle bufferHandle, BufferHandle sourceBufferHandle);
    uint32_t getBufferCounter(BufferHandle bufferHandle);
    void getBufferCounter(BufferHandle bufferHandle, BufferHandle destinationBufferHandle);
 
    struct GraphicsDeviceD3D12 * graphicsDevice;
 
    void setupPipelineState(PrimitiveType::EPrimitiveType topology);
    void checkState(PrimitiveType::EPrimitiveType topology);
 
    void destroy();
 
    InputAssemblerStateCommon * getIAState() override { return &iaState; }
    EffectHandle getCurrentEffect() override { return currentEffect; }
 
    void checkTextureState(TextureD3D12 & texture);
 
    ResourcePointer<ID3D12DescriptorHeap> descriptorHeapCPU;
    ResourcePointer<ID3D12DescriptorHeap> descriptorHeap;
    CD3DX12_CPU_DESCRIPTOR_HANDLE cbvCurrentCpuHandle;
    CD3DX12_GPU_DESCRIPTOR_HANDLE cbvCurrentGpuHandle;
 
    CD3DX12_CPU_DESCRIPTOR_HANDLE cbvCurrentCpuHandleCPU;
 
    CD3DX12_CPU_DESCRIPTOR_HANDLE srvCurrentCpuHandle;
    CD3DX12_GPU_DESCRIPTOR_HANDLE srvCurrentGpuHandle;
 
    CD3DX12_CPU_DESCRIPTOR_HANDLE uavCurrentCpuHandle;
    CD3DX12_GPU_DESCRIPTOR_HANDLE uavCurrentGpuHandle;
    UINT descriptorSize;
 
    ResourcePointer<ID3D12DescriptorHeap> samplerDescriptorHeap;
    CD3DX12_CPU_DESCRIPTOR_HANDLE samplerCurrentCpuHandle;
    CD3DX12_GPU_DESCRIPTOR_HANDLE samplerCurrentGpuHandle;
    UINT samplerHandleIncrement;
 
    ResourcePointer<ID3D12Fence> fence;
    HANDLE eventHandle;
 
    std::array<FrameResources, 3> frameResources;
    size_t frameResourceIndex = 0;
    FrameResources * currentFrameResources = nullptr;
 
    uint64_t currentFenceValue = 0;
 
    ID3D12CommandAllocator * commandAllocator;
    ID3D12GraphicsCommandList * commandList;
 
    std::unordered_map<size_t, ResourcePointer<ID3D12PipelineState>> PSOs;
 
    bool constantBuffersUpdated;
 
    Direct3D12::InputAssemblerState iaState;
    Direct3D12::PipelineState state;
    Direct3D12::ShaderState shaderState;
 
    EffectHandle currentEffect;
 
    ResourcePointer<ID3D12Device> device;
 
    BuffersD3D12 * buffers;
    TexturesD3D12 * textures;
    EffectsD3D12 * effects;
    RenderTargetsD3D12 * renderTargets;
 
    DepthStencilStateHandle defaultDepthStencilState;
    RasterizerStateHandle defaultRasterizerState;
    BlendStateHandle defaultBlendState;
    SamplerStateHandle defaultSamplerState;
 
    RenderTargetHandle defaultRenderTarget;
    DepthStencilHandle defaultDepthStencil;
  };
}