ContextD3D12.cpp

#include "ContextD3D12.h"
 
#include "GraphicsDeviceD3D12.h"
 
#include "Foundation/Logging/LogManager.h"
 
#include "Foundation/HashFunctions.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ContextD3D12");
 
  struct RenderStats 
  {
    size_t numVertices;
    size_t numIndices;
    size_t numFaces;
  };
 
  RenderStats renderStats;
}
 
namespace Cogs
{
  namespace Direct3D12
  {
    const D3D_PRIMITIVE_TOPOLOGY Topologies[] = {
      D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
      D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
      D3D_PRIMITIVE_TOPOLOGY_LINELIST,
      D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
      D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
      D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
      D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
      D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
      D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
      D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST,
      D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST,
      D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST,
      D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST,
    };
 
    const D3D12_PRIMITIVE_TOPOLOGY_TYPE TopologyTypes[] = {
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE, 
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH,
      D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH,
    };
  }
}
 
Cogs::ContextD3D12::ContextD3D12() :
  defaultBlendState(BlendStateHandle::InvalidHandle),
  defaultDepthStencilState(DepthStencilStateHandle::InvalidHandle),
  defaultRasterizerState(RasterizerStateHandle::InvalidHandle),
  defaultRenderTarget(RenderTargetHandle::InvalidHandle),
  defaultDepthStencil(DepthStencilHandle::InvalidHandle),
  currentFrameResources(frameResources.data())
{
 
}
 
Cogs::ContextD3D12::~ContextD3D12()
{
  destroy();
 
  CloseHandle(eventHandle);
}
 
void Cogs::ContextD3D12::destroy()
{
  auto fenceValue = currentFenceValue;
  auto completedFenceValue = fence->GetCompletedValue();
 
  graphicsDevice->commandQueue->Signal(fence, fenceValue);
 
  if (fenceValue > completedFenceValue) {
    fence->SetEventOnCompletion(fenceValue, eventHandle);
    WaitForSingleObject(eventHandle, INFINITE);
  }
}
 
void Cogs::ContextD3D12::initialize(GraphicsDeviceD3D12 * graphicsDevice)
{
  this->device = graphicsDevice->device;
  this->graphicsDevice = graphicsDevice;
 
  HRESULT hr = S_OK;
 
  for (auto & frameResource : frameResources) {
    hr = device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(frameResource.commandAllocator.internalPointer()));
 
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Could not create command allocator.");
      return;
    }
 
    hr = device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, frameResource.commandAllocator, nullptr, IID_PPV_ARGS(frameResource.commandList.internalPointer()));
 
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Could not create command list.");
      return;
    }
 
    frameResource.commandList->Close();
  }
 
  eventHandle = CreateEventEx(NULL, FALSE, FALSE, EVENT_ALL_ACCESS);
  assert(eventHandle != NULL);
 
  ++currentFenceValue;
 
  D3D12_DESCRIPTOR_HEAP_DESC descHeapCbv = {};
  descHeapCbv.NumDescriptors = 96000;
  descHeapCbv.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
  descHeapCbv.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
 
  hr = device->CreateDescriptorHeap(&descHeapCbv, IID_PPV_ARGS(descriptorHeap.internalPointer()));
 
  descHeapCbv.NumDescriptors = 256;
  descHeapCbv.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
  descHeapCbv.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
 
  hr = device->CreateDescriptorHeap(&descHeapCbv, IID_PPV_ARGS(descriptorHeapCPU.internalPointer()));
 
  D3D12_DESCRIPTOR_HEAP_DESC descHeapSampler = {};
  descHeapSampler.NumDescriptors = 2048;
  descHeapSampler.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
  descHeapSampler.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
 
  hr = device->CreateDescriptorHeap(&descHeapSampler, IID_PPV_ARGS(samplerDescriptorHeap.internalPointer()));
 
  hr = device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(fence.internalPointer()));
 
  constantBuffersUpdated = false;
 
  buffers = &graphicsDevice->buffers;
  textures = &graphicsDevice->textures;
  effects = &graphicsDevice->effects;
  renderTargets = &graphicsDevice->renderTargets;
 
  // Ensure all default resources are pinned and not released by user code.
 
  defaultRasterizerState = renderTargets->loadRasterizerState(RasterizerState::DefaultState());
  renderTargets->rasterizerStates.pin(defaultRasterizerState);
 
  defaultBlendState = renderTargets->loadBlendState(BlendState::DefaultState());
  renderTargets->blendStates.pin(defaultBlendState);
 
  defaultDepthStencilState = renderTargets->loadDepthStencilState(DepthStencilState::DefaultState());
  renderTargets->depthStencilStates.pin(defaultDepthStencilState);
 
  defaultSamplerState = textures->loadSamplerState(SamplerState::DefaultState());
  textures->samplerStates.pin(defaultSamplerState);
}
 
void Cogs::ContextD3D12::signal(FenceHandle fenceHandle)
{
  if (HandleIsValid(fenceHandle)) {
    FenceD3D12& fence = graphicsDevice->syncObjects.fences[fenceHandle];
    graphicsDevice->commandQueue->Signal(fence.fence, ++fence.value);
  }
}
 
void Cogs::ContextD3D12::beginFrame()
{
  ID3D12DescriptorHeap * heaps[2] = {
    descriptorHeap,
    samplerDescriptorHeap,
  };
 
  commandList->SetDescriptorHeaps(2, heaps);
 
  constantBuffersUpdated = false;
  currentEffect = EffectHandle::NoHandle;
  state.currentStateHash = 0;
  state.dirty = true;
 
  ContextCommon::setCurrentEffect(nullptr);
 
  setBlendState(defaultBlendState, nullptr);
  setRasterizerState(defaultRasterizerState);
  setDepthStencilState(defaultDepthStencilState);
 
  setRenderTarget(defaultRenderTarget, defaultDepthStencil);
 
  constantBuffersUpdated = false;
  shaderState = {};
 
  renderStats = {};
}
 
void Cogs::ContextD3D12::updateFrameResources()
{
  if (frameResourceIndex == frameResources.size()) frameResourceIndex = 0;
 
  if (frameResourceIndex == 0) {
    descriptorSize = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
    
    cbvCurrentCpuHandleCPU = descriptorHeapCPU->GetCPUDescriptorHandleForHeapStart();
 
    cbvCurrentCpuHandle = descriptorHeap->GetCPUDescriptorHandleForHeapStart();
    cbvCurrentGpuHandle = descriptorHeap->GetGPUDescriptorHandleForHeapStart();
 
    srvCurrentCpuHandle.InitOffsetted(cbvCurrentCpuHandle, 32000, descriptorSize);
    srvCurrentGpuHandle.InitOffsetted(cbvCurrentGpuHandle, 32000, descriptorSize);
 
    uavCurrentCpuHandle.InitOffsetted(srvCurrentCpuHandle, 32000, descriptorSize);
    uavCurrentGpuHandle.InitOffsetted(srvCurrentGpuHandle, 32000, descriptorSize);
 
    samplerHandleIncrement = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
    samplerCurrentCpuHandle = samplerDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
    samplerCurrentGpuHandle = samplerDescriptorHeap->GetGPUDescriptorHandleForHeapStart();
  }
 
  currentFrameResources = &frameResources[frameResourceIndex++];
 
  currentFrameResources->closed = false;
 
  if (currentFrameResources->fenceValue > fence->GetCompletedValue()) {
    fence->SetEventOnCompletion(currentFrameResources->fenceValue, eventHandle);
    WaitForSingleObject(eventHandle, INFINITE);
  }
 
  for (auto & orphan : currentFrameResources->orphanedBuffers) {
    orphan.pool->deallocate(orphan.poolHandle);
  }
 
  for (auto & orphan : currentFrameResources->orphanedRTVs) {
    renderTargets->rtvPool.deallocate(orphan.poolHandle);
  }
 
  currentFrameResources->orphanedRTVs.clear();
  currentFrameResources->orphanedResources.clear();
  currentFrameResources->orphanedBuffers.clear();
 
  commandAllocator = currentFrameResources->commandAllocator;
  commandList = currentFrameResources->commandList;
 
  commandAllocator->Reset();
 
  // Reset our command list, with no initial pipeline state.
  commandList->Reset(commandAllocator, nullptr);
}
 
void Cogs::ContextD3D12::endFrame()
{
  executeCommandList();
 
  currentFrameResources->closed = true;
 
  renderStats = {};
}
 
void Cogs::ContextD3D12::executeCommandList()
{
  commandList->Close();
 
  ID3D12CommandList * ppCommandLists[] = { commandList };
  graphicsDevice->commandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists);
 
  currentFrameResources->fenceValue = currentFenceValue;
 
  graphicsDevice->commandQueue->Signal(fence, currentFenceValue);
 
  ++currentFenceValue;
}
 
void Cogs::ContextD3D12::flush()
{
  if (!currentFrameResources->closed) {
    executeCommandList();
  }
 
  if (currentFrameResources->fenceValue > fence->GetCompletedValue()) {
    fence->SetEventOnCompletion(currentFrameResources->fenceValue, eventHandle);
    WaitForSingleObject(eventHandle, INFINITE);
  }
 
  if (!currentFrameResources->closed) {
    commandList->Reset(commandAllocator, PSOs[state.currentStateHash]);
 
    ID3D12DescriptorHeap * heaps[2] = {
      descriptorHeap,
      samplerDescriptorHeap,
    };
 
    commandList->SetDescriptorHeaps(2, heaps);
  }
}
 
Cogs::IEffects * Cogs::ContextD3D12::getEffects()
{
  return graphicsDevice->getEffects();
}
 
void Cogs::ContextD3D12::setVertexBuffers(const VertexBufferHandle * handles, const size_t count)
{
  uint32_t strides[kMaxVertexInputSlots];
  uint32_t offsets[kMaxVertexInputSlots];
 
  for (size_t i = 0; i < count; i++) {
    auto & buffer = buffers->buffers[BufferHandle(handles[i].handle)];
 
    assert(buffer.vertexFormat && "Vertex buffer must have been created with format information attached.");
 
    strides[i] = getSize(*buffer.vertexFormat);
    offsets[i] = 0;
  }
 
  setVertexBuffers(handles, count, strides, offsets);
}
 
void Cogs::ContextD3D12::setVertexBuffers(const VertexBufferHandle * handles, const size_t count, const uint32_t * strides, const uint32_t * offsets)
{
  iaState.numVertexBuffers = count;
 
  for (size_t i = 0; i < count; i++) {
    auto & buffer = buffers->buffers[BufferHandle(handles[i].handle)];
 
    assert(buffer.bindFlags & BindFlags::VertexBuffer && "Buffer not bindable as vertex buffer.");
    
    iaState.currentVertexBuffers[i] = &buffer;
    iaState.formats[i] = buffer.vertexFormat;
    iaState.strides[i] = strides[i];
    iaState.offsets[i] = offsets ? offsets[i] : 0;
  }
 
  setupDrawBuffers();
}
 
void Cogs::ContextD3D12::setIndexBuffer(IndexBufferHandle indexBufferHandle, uint32_t stride, uint32_t offset)
{
  iaState.currentIndexBuffer = &buffers->buffers[indexBufferHandle];
 
  commandList->IASetIndexBuffer(&iaState.currentIndexBuffer->indexBufferView);
}
 
namespace
{
  void decode(int64_t handle, uint32_t & vsSlot, uint32_t & gsSlot, uint32_t & psSlot)
  {
    const uint64_t value = static_cast<uint64_t>(handle);
 
    vsSlot = (value >> 32) & 0xFFFF;
    gsSlot = (value >> 48);
    psSlot = value & 0xFFFF;
  }
}
 
void Cogs::ContextD3D12::setConstantBuffer(const ConstantBufferBindingHandle bufferBinding, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size)
{
  assert(offset == 0 && size == ~0u && "Offset into constant buffers is not implemented");
  uint32_t slots[ShaderType::NumShaderTypes];
  decode(bufferBinding.handle, slots);
 
  auto & buffer = buffers->buffers[bufferHandle];
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    if (slots[i] != NoBinding) {
      shaderState.CBVs[i].setChanged(slots[i], &buffer, false);
    }
  }
 
  constantBuffersUpdated = true;
}
 
void Cogs::ContextD3D12::setupDrawBuffers()
{
  D3D12_VERTEX_BUFFER_VIEW views[32];
 
  for (size_t i = 0; i < iaState.numVertexBuffers; ++i) {
    views[i] = iaState.currentVertexBuffers[i]->vertexBufferView;
    views[i].StrideInBytes = iaState.strides[i];
  }
 
  commandList->IASetVertexBuffers(0, static_cast<UINT>(iaState.numVertexBuffers), views);
}
 
void Cogs::ContextD3D12::setupPipelineState(PrimitiveType::EPrimitiveType topology)
{
  checkState(topology);
 
  setupConstantBuffers();
 
  {
    D3D12_CONSTANT_BUFFER_VIEW_DESC nullCbvDesc = {};
    UINT offset = 0;
 
    for (UINT j = 0; j < ShaderType::NumShaderTypes; ++j) {
      const UINT slots = shaderState.effectSignature.slots[SlotType::CBV].values[j];
 
      if (slots && shaderState.CBVs[j].hasChanged()) {
        for (UINT i = 0; i < slots; ++i) {
          const auto & bindings = shaderState.CBVs[j];
 
          if (bindings.getChanged(i)) {
            if (bindings[i]) {
              device->CreateConstantBufferView(&bindings[i]->cbvDesc, CD3DX12_CPU_DESCRIPTOR_HANDLE(cbvCurrentCpuHandleCPU, offset + i, descriptorSize));
            } else {
              device->CreateConstantBufferView(&nullCbvDesc, CD3DX12_CPU_DESCRIPTOR_HANDLE(cbvCurrentCpuHandleCPU, offset + i, descriptorSize));
            }
          }
        }
 
        device->CopyDescriptorsSimple(slots, cbvCurrentCpuHandle, CD3DX12_CPU_DESCRIPTOR_HANDLE(cbvCurrentCpuHandleCPU, offset, descriptorSize), D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
 
        commandList->SetGraphicsRootDescriptorTable(shaderState.effectSignature.slots[SlotType::CBV].rangeIndex[j], cbvCurrentGpuHandle);
 
        offset += slots;
 
        shaderState.CBVs[j].setUnchanged();
 
        cbvCurrentCpuHandle.Offset(slots, descriptorSize);
        cbvCurrentGpuHandle.Offset(slots, descriptorSize);
      }
    }
  }
 
  {
    D3D12_UNORDERED_ACCESS_VIEW_DESC nullUavDesc{};
    nullUavDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
    nullUavDesc.Format = DXGI_FORMAT_R32_FLOAT;
 
    for (UINT j = 0; j < ShaderType::NumShaderTypes; ++j) {
      const UINT slots = shaderState.effectSignature.slots[SlotType::UAV].values[j];
 
      if (slots && shaderState.UAVs[j].hasChanged()) {
        for (UINT i = 0; i < slots; ++i) {
          const auto & bindings = shaderState.UAVs[j];
 
          if (bindings.getChanged(i)) {
            if (bindings[i]) {
              auto buffer = bindings[i];
              device->CreateUnorderedAccessView(buffer->resource, buffer->counterResource, &buffer->uavDesc, CD3DX12_CPU_DESCRIPTOR_HANDLE(uavCurrentCpuHandle, i, descriptorSize));
            } else {
              device->CreateUnorderedAccessView(nullptr, nullptr, &nullUavDesc, CD3DX12_CPU_DESCRIPTOR_HANDLE(uavCurrentCpuHandle, i, descriptorSize));
            }
          }
        }
 
        commandList->SetGraphicsRootDescriptorTable(shaderState.effectSignature.slots[SlotType::UAV].rangeIndex[j], uavCurrentGpuHandle);
 
        shaderState.UAVs[j].setUnchanged();
 
        uavCurrentCpuHandle.Offset(slots, descriptorSize);
        uavCurrentGpuHandle.Offset(slots, descriptorSize);
      }
    }
  }
 
  {
    D3D12_SHADER_RESOURCE_VIEW_DESC nullShaderResourceViewDesc = {};
    nullShaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
    nullShaderResourceViewDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
    nullShaderResourceViewDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    nullShaderResourceViewDesc.Texture2D.MipLevels = 1;
    nullShaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
    nullShaderResourceViewDesc.Texture2D.ResourceMinLODClamp = 0.0f;
 
    for (UINT j = 0; j < ShaderType::NumShaderTypes; ++j) {
      const UINT slots = shaderState.effectSignature.slots[SlotType::SRV].values[j];
 
      if (slots && shaderState.SRVs[j].hasChanged()) {
        for (UINT i = 0; i < slots; ++i) {
          const auto & bindings = shaderState.SRVs[j];
 
          if (bindings[i]) {
            auto & resource = bindings[i];
            device->CreateShaderResourceView(resource->resource, &resource->srvDesc, CD3DX12_CPU_DESCRIPTOR_HANDLE(srvCurrentCpuHandle, i, descriptorSize));
          } else {
            device->CreateShaderResourceView(nullptr, &nullShaderResourceViewDesc, CD3DX12_CPU_DESCRIPTOR_HANDLE(srvCurrentCpuHandle, i, descriptorSize));
          }
        }
 
        commandList->SetGraphicsRootDescriptorTable(shaderState.effectSignature.slots[SlotType::SRV].rangeIndex[j], srvCurrentGpuHandle);
 
        shaderState.SRVs[j].setUnchanged();
 
        srvCurrentCpuHandle.Offset(slots, descriptorSize);
        srvCurrentGpuHandle.Offset(slots, descriptorSize);
      }
    }
  }
 
  {
    D3D12_SAMPLER_DESC nullSamplerDesc = {};
    nullSamplerDesc.AddressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
    nullSamplerDesc.AddressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
    nullSamplerDesc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
    nullSamplerDesc.ComparisonFunc = D3D12_COMPARISON_FUNC_ALWAYS;
    nullSamplerDesc.Filter = D3D12_FILTER_ANISOTROPIC;
    nullSamplerDesc.MaxAnisotropy = 0;
    nullSamplerDesc.MaxLOD = 16;
 
    for (UINT j = 0; j < ShaderType::NumShaderTypes; ++j) {
      const UINT slots = shaderState.effectSignature.slots[SlotType::Sampler].values[j];
 
      if (slots && shaderState.Samplers[j].hasChanged()) {
        for (UINT i = 0; i < slots; ++i) {
          const auto & bindings = shaderState.Samplers[j];
          const auto sampler = bindings[i];
 
          if (sampler) {
            device->CreateSampler(sampler, CD3DX12_CPU_DESCRIPTOR_HANDLE(samplerCurrentCpuHandle, i, samplerHandleIncrement));
          } else {
            device->CreateSampler(&nullSamplerDesc, CD3DX12_CPU_DESCRIPTOR_HANDLE(samplerCurrentCpuHandle, i, samplerHandleIncrement));
          }
        }
 
        commandList->SetGraphicsRootDescriptorTable(shaderState.effectSignature.slots[SlotType::Sampler].rangeIndex[j], samplerCurrentGpuHandle);
 
        shaderState.Samplers[j].setUnchanged();
    
        samplerCurrentCpuHandle.Offset(slots, samplerHandleIncrement);
        samplerCurrentGpuHandle.Offset(slots, samplerHandleIncrement);
      }
    }
  }
}
 
void Cogs::ContextD3D12::draw(PrimitiveType::EPrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes)
{
  setupPipelineState(primitiveType);
 
  commandList->IASetPrimitiveTopology(Direct3D12::Topologies[primitiveType]);
 
  commandList->DrawInstanced(static_cast<UINT>(numVertexes), 1, static_cast<UINT>(startVertex), 0);
}
 
void Cogs::ContextD3D12::drawIndexed(PrimitiveType::EPrimitiveType primitiveType, const size_t startIndex, const size_t numIndexes, const size_t startVertex)
{
  setupPipelineState(primitiveType);
 
  commandList->IASetPrimitiveTopology(Direct3D12::Topologies[primitiveType]);
 
  const size_t indexCount = numIndexes ? numIndexes : iaState.currentIndexBuffer->count;
 
  commandList->DrawIndexedInstanced(static_cast<UINT>(indexCount), 1, static_cast<UINT>(startIndex), static_cast<UINT>(startVertex), 0);
}
 
void Cogs::ContextD3D12::setRasterizerState(const RasterizerStateHandle handle)
{
  state.currentRasterizerState = &renderTargets->rasterizerStates[handle];
  state.dirty = true;
}
 
void Cogs::ContextD3D12::setBlendState(const BlendStateHandle handle, const float* constant)
{
  state.currentBlendState = &renderTargets->blendStates[handle];
 
  // Even though doc indicates that NULL is OK, it segfaults
  const float white[4] = { 1.f, 1.f, 1.f, 1.f };
  commandList->OMSetBlendFactor(constant ? constant : white);
 
  state.dirty = true;
}
 
void Cogs::ContextD3D12::setDepthStencilState(const DepthStencilStateHandle handle)
{
  state.currentDepthStencilState = &renderTargets->depthStencilStates[HandleIsValid(handle) ? handle : defaultDepthStencilState];
  state.dirty = true;
}
 
void Cogs::ContextD3D12::setRenderTarget(const RenderTargetHandle renderTargetHandle, const DepthStencilHandle depthStencilHandle)
{
  auto rtHandle = (renderTargetHandle == RenderTargetHandle::NoHandle) ? defaultRenderTarget : renderTargetHandle;
  auto dsHandle = (depthStencilHandle == DepthStencilHandle::NoHandle) ? defaultDepthStencil : depthStencilHandle;
 
  state.currentRenderTarget = rtHandle != RenderTargetHandle::InvalidHandle ? &renderTargets->renderTargets[rtHandle] : nullptr;
  state.currentDepthStencil = dsHandle != DepthStencilHandle::InvalidHandle ? &renderTargets->depthStencilTargets[dsHandle] : nullptr;
  state.dirty = true;
 
  if (state.currentRenderTarget && !state.currentRenderTarget->resource) {
    auto & renderTarget = *state.currentRenderTarget;
 
    for (int i = 0; i < renderTarget.numViews; ++i) {
      if (HandleIsValid(renderTarget.textures[i])) {
        auto & renderTexture = textures->textures[renderTarget.textures[i]];
        setResourceState(commandList, renderTexture, D3D12_RESOURCE_STATE_RENDER_TARGET);
      }
    }
  }
 
  if (state.currentDepthStencil && HandleIsValid(state.currentDepthStencil->texture)) {
    auto & depthTexture = textures->textures[state.currentDepthStencil->texture];
    setResourceState(commandList, depthTexture, D3D12_RESOURCE_STATE_DEPTH_WRITE);
  }
 
  if (state.currentRenderTarget) {
    auto & renderTarget = *state.currentRenderTarget;
 
    commandList->OMSetRenderTargets(renderTarget.numViews, renderTarget.descriptorHandle, renderTarget.numViews == 1, state.currentDepthStencil ? &state.currentDepthStencil->descriptorHandle : nullptr);
  } else {
    commandList->OMSetRenderTargets(0, nullptr, false, state.currentDepthStencil ? &state.currentDepthStencil->descriptorHandle : nullptr);
  }
}
 
void Cogs::ContextD3D12::setViewport(const float x, const float y, const float width, const float height)
{
  D3D12_VIEWPORT viewPort = {
    0.0f,
    0.0f,
    static_cast<float>(width),
    static_cast<float>(height),
    0.0f,
    1.0f
  };
 
  D3D12_RECT mRectScissor = { 0, 0, static_cast<LONG>(width), static_cast<LONG>(height) };
 
  commandList->RSSetViewports(1, &viewPort);
  commandList->RSSetScissorRects(1, &mRectScissor);
}
 
void Cogs::ContextD3D12::setScissor(const int x, const int y, const int width, const int height)
{
  D3D12_RECT mRectScissor = { static_cast<LONG>(x), static_cast<LONG>(y), static_cast<LONG>(width), static_cast<LONG>(height) };
  commandList->RSSetScissorRects(1, &mRectScissor);
}
 
void Cogs::ContextD3D12::clearRenderTarget(const float * color)
{
  auto renderTarget = state.currentRenderTarget;
 
  for (size_t i = 0; i < renderTarget->numViews; ++i) {
    commandList->ClearRenderTargetView(renderTarget->descriptorHandle[i], color, 0, nullptr);
  }
}
 
void Cogs::ContextD3D12::clearRenderTarget(const float ** colors, const int count)
{
  auto renderTarget = state.currentRenderTarget;
 
  for (size_t i = 0; i < count; ++i) {
    commandList->ClearRenderTargetView(renderTarget->descriptorHandle[i], colors[i], 0, nullptr);
  }
}
 
void Cogs::ContextD3D12::clearDepth(const float depth)
{
  auto depthTarget = state.currentDepthStencil;
 
  if (depthTarget) {
    commandList->ClearDepthStencilView(depthTarget->descriptorHandle, D3D12_CLEAR_FLAG_DEPTH, depth, 0, 0, nullptr);
  }
}
 
void Cogs::ContextD3D12::setEffect(EffectHandle effectHandle)
{
  currentEffect = effectHandle;
 
  state.currentEffect = &effects->effects[effectHandle];
  state.dirty = true;
 
  ContextCommon::setCurrentEffect(state.currentEffect);
 
  assert(state.currentEffect->rootSignature && "Effect signature not valid.");
 
  shaderState.effectSignature = state.currentEffect->signature;
 
  if (true) { // Root signature changed
    shaderState.rootSignature = state.currentEffect->rootSignature;
 
    commandList->SetGraphicsRootSignature(state.currentEffect->rootSignature);
 
    for (uint32_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
      for (uint32_t j = 0; j < shaderState.effectSignature.slots[SlotType::CBV].values[i]; ++j) {
        shaderState.CBVs[i].setChanged();
      }
 
      for (uint32_t j = 0; j < shaderState.effectSignature.slots[SlotType::Sampler].values[i]; ++j) {
        shaderState.Samplers[i].setChanged();
      }
 
      for (uint32_t j = 0; j < shaderState.effectSignature.slots[SlotType::SRV].values[i]; ++j) {
        shaderState.SRVs[i].setChanged();
      }
 
      for (uint32_t j = 0; j < shaderState.effectSignature.slots[SlotType::UAV].values[i]; ++j) {
        shaderState.UAVs[i].setChanged();
      }
    }
  }
}
 
void Cogs::ContextD3D12::setInputLayout(const InputLayoutHandle inputLayoutHandle)
{
  state.currentInputLayout = &buffers->inputLayouts[inputLayoutHandle];
  state.dirty = true;
}
 
void Cogs::ContextD3D12::checkState(PrimitiveType::EPrimitiveType topology)
{
  if (!state.dirty) return;
 
  const auto topologyType = Direct3D12::TopologyTypes[topology];
  size_t hashCode = fnv1a(reinterpret_cast<const uint8_t *>(&state), sizeof(Direct3D12::PipelineState)) + topologyType;
 
  if (hashCode != state.currentStateHash) {
    auto it = PSOs.find(hashCode);
 
    if (it == PSOs.end()) {
      auto & inputLayout = *state.currentInputLayout;
      auto & effect = *state.currentEffect;
 
      D3D12_GRAPHICS_PIPELINE_STATE_DESC descPso = {};
      descPso.InputLayout = { inputLayout.inputElements, inputLayout.inputElementCount };
      descPso.pRootSignature = state.currentEffect->rootSignature;
 
      descPso.VS = { reinterpret_cast<BYTE *>(effect.vertexShader.byteCode->GetBufferPointer()), effect.vertexShader.byteCode->GetBufferSize() };
 
      if (effect.hullShader.byteCode) {
        descPso.HS = { reinterpret_cast<BYTE *>(effect.hullShader.byteCode->GetBufferPointer()), effect.hullShader.byteCode->GetBufferSize() };
      }
 
      if (effect.domainShader.byteCode) {
        descPso.DS = { reinterpret_cast<BYTE *>(effect.domainShader.byteCode->GetBufferPointer()), effect.domainShader.byteCode->GetBufferSize() };
      }
 
      if (effect.geometryShader.byteCode) {
        descPso.GS = { reinterpret_cast<BYTE *>(effect.geometryShader.byteCode->GetBufferPointer()), effect.geometryShader.byteCode->GetBufferSize() };
      }
 
      if (effect.pixelShader.byteCode) {
        descPso.PS = { reinterpret_cast<BYTE *>(effect.pixelShader.byteCode->GetBufferPointer()), effect.pixelShader.byteCode->GetBufferSize() };
      }
 
      descPso.RasterizerState = state.currentRasterizerState->rasterizerDesc;
      descPso.BlendState = state.currentBlendState->blendDesc;
      descPso.DepthStencilState = state.currentDepthStencilState->depthStencilDesc;
 
      descPso.SampleMask = UINT_MAX;
      descPso.PrimitiveTopologyType = Direct3D12::TopologyTypes[topology];
 
      if (state.currentRenderTarget) {
        descPso.NumRenderTargets = state.currentRenderTarget->numViews;
 
        //TODO: Fetch render target sample count.
        if (HandleIsValid(state.currentRenderTarget->textures[0])) {
          descPso.SampleDesc.Count = textures->textures[state.currentRenderTarget->textures[0]].numSamples;
        } else {
          descPso.SampleDesc.Count = state.currentRenderTarget->numSamples;
        }
 
        for (size_t i = 0; i < state.currentRenderTarget->numViews; ++i) {
          descPso.RTVFormats[i] = state.currentRenderTarget->viewDesc[i].Format;
        }
      }
 
      if (state.currentDepthStencil) {
        if (!state.currentRenderTarget) {
          auto & texture = textures->textures[state.currentDepthStencil->texture];
          descPso.SampleDesc.Count = texture.numSamples;
        }
        descPso.DSVFormat = state.currentDepthStencil->viewDesc.Format;
      }
 
      device->CreateGraphicsPipelineState(&descPso, IID_PPV_ARGS(PSOs[hashCode].internalPointer()));
 
      commandList->SetPipelineState(PSOs[hashCode]);
    } else {
      commandList->SetPipelineState(it->second);
    }
 
    state.currentStateHash = hashCode;
  }
}
 
void Cogs::ContextD3D12::resolveResource(TextureHandle source, TextureHandle destinationTexture)
{
  auto & sourceTexture = textures->textures[source];
  auto & destination = textures->textures[destinationTexture];
 
  setResourceState(commandList, sourceTexture, D3D12_RESOURCE_STATE_RESOLVE_SOURCE);
  setResourceState(commandList, destination, D3D12_RESOURCE_STATE_RESOLVE_DEST);
 
  commandList->ResolveSubresource(destination.resource, 0, sourceTexture.resource, 0, sourceTexture.srvDesc.Format);
}
 
void Cogs::ContextD3D12::drawInstanced(PrimitiveType::EPrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes, const size_t startInstance, const size_t numInstances)
{
  setupPipelineState(primitiveType);
 
  commandList->IASetPrimitiveTopology(Direct3D12::Topologies[primitiveType]);
 
  commandList->DrawInstanced(static_cast<UINT>(numVertexes), static_cast<UINT>(numInstances), static_cast<UINT>(startVertex), static_cast<UINT>(startInstance));
}
 
void Cogs::ContextD3D12::drawInstancedIndexed(PrimitiveType::EPrimitiveType primitiveType, const size_t startInstance, const size_t numInstances, const size_t startIndex, const size_t numIndexes)
{
  setupPipelineState(primitiveType);
 
  commandList->IASetPrimitiveTopology(Direct3D12::Topologies[primitiveType]);
 
  const size_t indexCount = numIndexes ? numIndexes : iaState.currentIndexBuffer->count;
 
  commandList->DrawIndexedInstanced(static_cast<UINT>(indexCount), static_cast<UINT>(numInstances), static_cast<UINT>(startIndex), 0, static_cast<UINT>(startInstance));
}
 
void Cogs::ContextD3D12::readDepthBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer::EFrameBuffer)
{
  auto & buffer = buffers->buffers[bufferHandle];
 
  auto & texture = textures->textures[state.currentDepthStencil->texture];
  setResourceState(commandList, texture, D3D12_RESOURCE_STATE_COPY_SOURCE);
  auto resource = texture.resource;
 
  auto desc = resource->GetDesc();
 
  if (desc.Format == DXGI_FORMAT_D32_FLOAT || desc.Format == DXGI_FORMAT_D24_UNORM_S8_UINT) {
    D3D12_RESOURCE_DESC textureDesc;
    textureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
    textureDesc.DepthOrArraySize = 1;
    textureDesc.Alignment = 0;
    textureDesc.Width = desc.Width;
    textureDesc.Height = desc.Height;
    textureDesc.Format = DXGI_FORMAT_R32_FLOAT;
    textureDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
    textureDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
    textureDesc.MipLevels = static_cast<UINT16>(1);
    textureDesc.SampleDesc.Count = desc.SampleDesc.Count;
    textureDesc.SampleDesc.Quality = 0;
 
    ResourcePointer<ID3D12Resource> copyTexture;
    if (FAILED(device->CreateCommittedResource(
      &defaultHeapProperties,
      D3D12_HEAP_FLAG_NONE,
      &textureDesc,
      D3D12_RESOURCE_STATE_COMMON,
      nullptr,
      IID_PPV_ARGS(copyTexture.internalPointer())))) {
      // LOG ERROR
      return;
    }
 
    currentFrameResources->orphanedResources.push_back(copyTexture);
 
    setResourceState(commandList, texture, D3D12_RESOURCE_STATE_COPY_SOURCE);
    setResourceBarrier(commandList, copyTexture, D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_COPY_DEST);
 
    commandList->CopyResource(copyTexture, resource);
 
    setResourceBarrier(commandList, copyTexture, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COMMON);
 
    resource = copyTexture;
    desc = resource->GetDesc();
  }
 
  if (desc.SampleDesc.Count > 1) {
    D3D12_RESOURCE_DESC textureDesc;
    textureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
    textureDesc.DepthOrArraySize = 1;
    textureDesc.Alignment = 0;
    textureDesc.Width = desc.Width;
    textureDesc.Height = desc.Height;
    textureDesc.Format = DXGI_FORMAT_R32_FLOAT;
    textureDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
    textureDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
    textureDesc.MipLevels = static_cast<UINT16>(1);
    textureDesc.SampleDesc.Count = 1;
    textureDesc.SampleDesc.Quality = 0;
 
    ResourcePointer<ID3D12Resource> resolveTexture;
    if (FAILED(device->CreateCommittedResource(
      &defaultHeapProperties,
      D3D12_HEAP_FLAG_NONE,
      &textureDesc,
      D3D12_RESOURCE_STATE_COMMON,
      nullptr,
      IID_PPV_ARGS(resolveTexture.internalPointer())))) {
      // LOG ERROR
      return;
    }
 
    currentFrameResources->orphanedResources.push_back(resolveTexture);
 
    if (resource == texture.resource) {
      setResourceState(commandList, texture, D3D12_RESOURCE_STATE_RESOLVE_SOURCE);
    } else {
      setResourceBarrier(commandList, resource, D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_RESOLVE_SOURCE);
    }
 
    setResourceBarrier(commandList, resolveTexture, D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_RESOLVE_DEST);
 
    commandList->ResolveSubresource(resolveTexture, 0, resource, 0, textureDesc.Format);
 
    setResourceBarrier(commandList, resolveTexture, D3D12_RESOURCE_STATE_RESOLVE_DEST, D3D12_RESOURCE_STATE_COPY_SOURCE);
 
    resource = resolveTexture;
    desc = resource->GetDesc();
  }
 
  const int maxSubresources = 16;
  UINT firstSubresource = 0;
  UINT64 requiredSize = 0;
  D3D12_PLACED_SUBRESOURCE_FOOTPRINT layouts[maxSubresources];
  UINT numRows[maxSubresources];
  UINT64 rowSizesInBytes[maxSubresources];
 
  device->GetCopyableFootprints(&desc, 0, 1, 0, layouts, numRows, rowSizesInBytes, &requiredSize);
 
  CD3DX12_RESOURCE_DESC           bufferDesc = CD3DX12_RESOURCE_DESC::Buffer(requiredSize);
  ResourcePointer<ID3D12Resource> temp;
 
  device->CreateCommittedResource(
    &defaultHeapProperties,
    D3D12_HEAP_FLAG_NONE,
    &bufferDesc,
    D3D12_RESOURCE_STATE_GENERIC_READ,
    nullptr,
    IID_PPV_ARGS(temp.internalPointer()));
 
  currentFrameResources->orphanedResources.push_back(temp);
 
  setResourceBarrier(commandList, temp, D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_COPY_DEST);
 
  CD3DX12_TEXTURE_COPY_LOCATION src(resource, firstSubresource);
  CD3DX12_TEXTURE_COPY_LOCATION dst(temp, layouts[0]);
 
  D3D12_BOX box;
  box.left = x;
  box.right = x + width;
  box.top = y;
  box.bottom = y + height;
  box.front = 0;
  box.back = 1;
 
  commandList->CopyTextureRegion(&dst, x, y, 0, &src, &box);
 
  setResourceState(commandList, texture, D3D12_RESOURCE_STATE_DEPTH_WRITE);
 
  setResourceState(commandList, buffer, D3D12_RESOURCE_STATE_COPY_DEST);
  setResourceBarrier(commandList, temp, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COPY_SOURCE);
 
  for (int i = 0; i < height; ++i) {
    auto sourceOffset = layouts[0].Footprint.RowPitch * (y + i) + 4 * x;
 
    commandList->CopyBufferRegion(buffer.resource, i * width * 4, temp, sourceOffset, width * 4);
  }
}
 
void Cogs::ContextD3D12::readColorBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer::EFrameBuffer)
{
  auto & buffer = buffers->buffers[bufferHandle];
 
  ResourcePointer<ID3D12Resource> resource;
  if (state.currentRenderTarget->resource) {
    resource = state.currentRenderTarget->resource;
    setResourceBarrier(commandList, resource, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE);
  } else {
    auto & texture = textures->textures[state.currentRenderTarget->textures[0]];
    setResourceState(commandList, texture, D3D12_RESOURCE_STATE_COPY_SOURCE);
    resource = texture.resource;
  }
  
  auto desc = resource->GetDesc();
  if (desc.SampleDesc.Count > 1) {
    D3D12_RESOURCE_DESC textureDesc;
    textureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
    textureDesc.DepthOrArraySize = static_cast<UINT16>(1);
    textureDesc.Alignment = 0;
    textureDesc.Width = desc.Width;
    textureDesc.Height = desc.Height;
    textureDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    textureDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
    textureDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
    textureDesc.MipLevels = static_cast<UINT16>(1);
    textureDesc.SampleDesc.Count = 1;
    textureDesc.SampleDesc.Quality = 0;
 
    ResourcePointer<ID3D12Resource> resolveTexture;
    if (FAILED(device->CreateCommittedResource(
      &defaultHeapProperties,
      D3D12_HEAP_FLAG_NONE,
      &textureDesc,
      D3D12_RESOURCE_STATE_COMMON,
      nullptr,
      IID_PPV_ARGS(resolveTexture.internalPointer())))) {
      // LOG ERROR
      return;
    }
 
    currentFrameResources->orphanedResources.push_back(resolveTexture);
 
    setResourceBarrier(commandList, resource, D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RESOLVE_SOURCE);
    setResourceBarrier(commandList, resolveTexture, D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_RESOLVE_DEST);
 
    commandList->ResolveSubresource(resolveTexture, 0, resource, 0, textureDesc.Format);
 
    setResourceBarrier(commandList, resource, D3D12_RESOURCE_STATE_RESOLVE_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET);
    setResourceBarrier(commandList, resolveTexture, D3D12_RESOURCE_STATE_RESOLVE_DEST, D3D12_RESOURCE_STATE_COPY_SOURCE);
 
    resource = resolveTexture;
    desc = resource->GetDesc();
  }
  
  const int maxSubresources = 16;
  UINT firstSubresource = 0;
  UINT64 requiredSize = 0;
  D3D12_PLACED_SUBRESOURCE_FOOTPRINT layouts[maxSubresources];
  UINT numRows[maxSubresources];
  UINT64 rowSizesInBytes[maxSubresources];
 
  device->GetCopyableFootprints(&desc, 0, 1, 0, layouts, numRows, rowSizesInBytes, &requiredSize);
 
  CD3DX12_RESOURCE_DESC           bufferDesc = CD3DX12_RESOURCE_DESC::Buffer(requiredSize);
  ResourcePointer<ID3D12Resource> temp;
 
  device->CreateCommittedResource(
    &defaultHeapProperties,
    D3D12_HEAP_FLAG_NONE,
    &bufferDesc,
    D3D12_RESOURCE_STATE_GENERIC_READ,
    nullptr,
    IID_PPV_ARGS(temp.internalPointer()));
 
  currentFrameResources->orphanedResources.push_back(temp);
 
  setResourceBarrier(commandList, temp, D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_COPY_DEST);
 
  CD3DX12_TEXTURE_COPY_LOCATION src(resource, firstSubresource);
  CD3DX12_TEXTURE_COPY_LOCATION dst(temp, layouts[0]);
 
  D3D12_BOX box;
  box.left = x;
  box.right = x + width;
  box.top = y;
  box.bottom = y + height;
  box.front = 0;
  box.back = 1;
 
  commandList->CopyTextureRegion(&dst, x, y, 0, &src, &box);
 
  if (state.currentRenderTarget->resource && state.currentRenderTarget->numSamples == 1) {
    resource = state.currentRenderTarget->resource;
    setResourceBarrier(commandList, resource, D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET);
  }
 
  setResourceState(commandList, buffer, D3D12_RESOURCE_STATE_COPY_DEST);
  setResourceBarrier(commandList, temp, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COPY_SOURCE);
 
  for (int i = 0; i < height; ++i) {
    auto sourceOffset = layouts[0].Footprint.RowPitch * (y + i) + 4 * x;
 
    commandList->CopyBufferRegion(buffer.resource, i * width * 4, temp, sourceOffset, width * 4);
  }
}
 
void * Cogs::ContextD3D12::map(BufferHandle bufferHandle, MapMode::EMapMode accessMode, uint32_t * stride)
{
  auto & buffer = buffers->buffers[bufferHandle];
 
  if (accessMode == MapMode::WriteDiscard) {
    if (buffer.resource) {
      UINT8 * resourceData;
      buffer.resource->Map(0, nullptr, reinterpret_cast<void **>(&resourceData));
      return resourceData;
    } else {
      currentFrameResources->orphanedBuffers.push_back(OrphanBufferD3D12{ buffer.pooledResource, &buffers->getBufferPool(buffer.size) });
    
      buffer.pooledResource = buffers->getBufferPool(buffer.size).allocate();
      buffer.cbvDesc.BufferLocation = buffer.pooledResource->mappedGpuRegion;
 
      for (auto & cbv : shaderState.CBVs) {
        cbv.setAnyChanged(&buffer);
      }
 
      return buffer.pooledResource->mappedRegion;
    }
  } else if (accessMode == MapMode::Write) {
    if (buffer.resource) {
      UINT8 * resourcePointer;
 
      buffer.resource->Map(0, nullptr, reinterpret_cast<void **>(&resourcePointer));
 
      return resourcePointer;
    } else {
      return buffer.pooledResource->mappedRegion;
    }
  } else if (accessMode == MapMode::Read) {
    flush();
 
    if (buffer.resource) {
      UINT8 * resourcePointer;
      
      D3D12_RANGE range{};
      range.Begin = 0;
      range.End = buffer.size;
 
      buffer.resource->Map(0, &range, reinterpret_cast<void **>(&resourcePointer));
 
      return resourcePointer;
    }
  }
 
  return nullptr;
}
 
void Cogs::ContextD3D12::unmap(BufferHandle bufferHandle)
{
  auto & buffer = buffers->buffers[bufferHandle];
 
  if (buffer.resource) {
    buffer.resource->Unmap(0, nullptr);
  }
}
 
void Cogs::ContextD3D12::updateSubTexture(TextureHandle textureHandle, const size_t level, const void * data)
{
  assert(HandleIsValid(textureHandle) && "Texture handle must be a valid texture.");
 
  auto & texture = this->textures->textures[textureHandle];
 
  const uint32_t width = std::max(1u, texture.width / static_cast<uint32_t>(std::pow(2, level)));
  const uint32_t height = std::max(1u, texture.height / static_cast<uint32_t>(std::pow(2, level)));
 
  D3D12_BOX rectangle;
  rectangle.left = 0;
  rectangle.right = width;
  rectangle.top = 0;
  rectangle.bottom = height;
  rectangle.front = 0;
  rectangle.back = 1;
 
  D3D12_SUBRESOURCE_DATA d{};
  d.pData = data;
  d.RowPitch = width * static_cast<uint32_t>(getBlockSize(texture.format));
 
  if (!texture.uploadResource) {
    ResourceD3D12 buffer;
    buffers->allocateBuffer(buffer, height * width * getBlockSize(texture.format), nullptr);
    texture.uploadResource = buffer.resource;
  }
 
  setResourceState(commandList, texture, D3D12_RESOURCE_STATE_COPY_DEST);
 
  UpdateSubresources(commandList, texture.resource, texture.uploadResource, 0, 0, 1, &d);
}
 
void Cogs::ContextD3D12::updateSubBuffer(BufferHandle bufferHandle, const size_t offset, const size_t size, const void * data)
{
  auto & buffer = buffers->buffers[bufferHandle];
 
  auto tempBufferHandle = buffers->loadBuffer(data, size, Usage::Default, AccessMode::Write, BindFlags::None);
  auto & tempBuffer = buffers->buffers[tempBufferHandle];
 
  setResourceState(commandList, buffer, D3D12_RESOURCE_STATE_COPY_DEST);
  commandList->CopyBufferRegion(buffer.resource, offset, tempBuffer.resource, 0, size);
 
  buffers->releaseBuffer(tempBufferHandle);
}
 
void Cogs::ContextD3D12::copyResource(BufferHandle destinationHandle, BufferHandle sourceHandle)
{
  auto & destination = buffers->buffers[destinationHandle];
  auto & source = buffers->buffers[sourceHandle];
 
  setResourceState(commandList, destination, D3D12_RESOURCE_STATE_COPY_DEST);
  commandList->CopyResource(destination.resource, source.resource);
}
 
void Cogs::ContextD3D12::copyResource(TextureHandle destinationHandle, TextureHandle sourceHandle)
{
}
 
void Cogs::ContextD3D12::setTexture(const TextureBindingHandle textureBindingHandle, const TextureHandle textureHandle)
{
  uint32_t slots[ShaderType::NumShaderTypes];
  decode(textureBindingHandle.handle, slots);
 
  if (!HandleIsValid(textureHandle)) return;
 
  auto & texture = textures->textures[textureHandle];
 
  checkTextureState(texture);
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    if (slots[i] != NoBinding) {
      shaderState.SRVs[i].setChanged(slots[i], &texture, true);
    }
  }
}
 
void Cogs::ContextD3D12::setTexture(const TextureBindingHandle textureBindingHandle, TextureViewHandle textureViewHandle)
{
  uint32_t slots[ShaderType::NumShaderTypes];
  decode(textureBindingHandle.handle, slots);
 
  if (!HandleIsValid(textureViewHandle)) return;
 
  auto & textureView = textures->textureViews[textureViewHandle];
  auto & texture = textures->textures[textureView.texture];
 
  checkTextureState(texture);
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    if (slots[i] != NoBinding) {
      shaderState.SRVs[i].setChanged(slots[i], &texture, true);
    }
  }
}
 
void Cogs::ContextD3D12::checkTextureState(TextureD3D12 & texture)
{
  if (texture.needsUpload) {
    setResourceState(commandList, texture, D3D12_RESOURCE_STATE_COPY_DEST);
 
    const int maxSubresources = 16;
    UINT numSubresources = texture.numSubResources;
    UINT firstSubresource = 0;
    UINT64 requiredSize = 0;
    D3D12_PLACED_SUBRESOURCE_FOOTPRINT layouts[maxSubresources];
    UINT numRows[maxSubresources];
    UINT64 rowSizesInBytes[maxSubresources];
 
    auto desc = texture.resource->GetDesc();
    device->GetCopyableFootprints(&desc, 0, texture.numSubResources, 0, layouts, numRows, rowSizesInBytes, &requiredSize);
 
    for (UINT i = 0; i < numSubresources; ++i)
    {
      CD3DX12_TEXTURE_COPY_LOCATION dst(texture.resource, i + firstSubresource);
      CD3DX12_TEXTURE_COPY_LOCATION src(texture.uploadResource, layouts[i]);
 
      commandList->CopyTextureRegion(&dst, 0, 0, 0, &src, nullptr);
    }
 
    texture.needsUpload = false;
  }
 
  if (texture.usage != D3D12_RESOURCE_STATE_GENERIC_READ) {
    setResourceState(commandList, texture, D3D12_RESOURCE_STATE_GENERIC_READ);
  }
}
 
void Cogs::ContextD3D12::setBufferCounter(BufferHandle bufferHandle, uint32_t value)
{
  auto sourceBufferHandle = buffers->loadBuffer(&value, sizeof(uint32_t), Usage::Staging, AccessMode::Write, BindFlags::None);
 
  setBufferCounter(bufferHandle, sourceBufferHandle);
 
  //TODO: Release when safe.
  //buffers->releaseBuffer(sourceBufferHandle);
}
 
void Cogs::ContextD3D12::setBufferCounter(BufferHandle bufferHandle, BufferHandle sourceBufferHandle)
{
  auto & buffer = buffers->buffers[bufferHandle];
  auto & sourceBuffer = buffers->buffers[sourceBufferHandle];
 
  assert(buffer.bindFlags == BindFlags::StructuredBufferWithCounter && "Buffer does not have atomic counter associated with it.");
  
  setResourceBarrier(commandList, buffer.counterResource, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_DEST);
 
  if (sourceBuffer.pooledResource) {
    commandList->CopyBufferRegion(buffer.counterResource, 0, sourceBuffer.pooledResource->resource, sourceBuffer.pooledResource->offset, 4);
  } else {
    commandList->CopyResource(buffer.counterResource, sourceBuffer.resource);
  }
  
  setResourceBarrier(commandList, buffer.counterResource, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
}
 
uint32_t Cogs::ContextD3D12::getBufferCounter(BufferHandle bufferHandle)
{
  auto destinationBufferHandle = buffers->loadBuffer(nullptr, sizeof(uint32_t), Usage::Staging, AccessMode::Read, BindFlags::None);
 
  return 0;
}
 
void Cogs::ContextD3D12::getBufferCounter(BufferHandle bufferHandle, BufferHandle destinationBufferHandle)
{
 
}
 
void Cogs::ContextD3D12::setBuffer(const BufferBindingHandle bufferBindingHandle, BufferHandle bufferHandle)
{
  auto & binding = effects->bufferBindings[bufferBindingHandle];
  auto & buffer = buffers->buffers[bufferHandle];
 
  if (buffer.uploadResource.resource) {
    setResourceState(commandList, buffer, D3D12_RESOURCE_STATE_COPY_DEST);
    commandList->CopyResource(buffer.resource, buffer.uploadResource.resource);
    setResourceState(commandList, buffer, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
 
    currentFrameResources->orphanedResources.push_back(buffer.uploadResource.resource);
    buffer.uploadResource.resource = nullptr;
  }
 
  if (false) {
    //TODO: Implement CS Support. 2015-08-11, oyshole.
  } else {
    {
      uint32_t slots[ShaderType::NumShaderTypes];
      decode(binding.uavBindings, slots);
 
      for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
        if (slots[i] != NoBinding) {
          shaderState.UAVs[i].setChanged(slots[i], &buffer, false);
        }
      }
    }
 
    {
      uint32_t slots[ShaderType::NumShaderTypes];
      decode(binding.srvBindings, slots);
 
      for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
        if (slots[i] != NoBinding) {
          shaderState.SRVs[i].setChanged(slots[i], &buffer, false);
        }
      }
    }
 
    if (buffer.usage != D3D12_RESOURCE_STATE_UNORDERED_ACCESS) {
      setResourceState(commandList, buffer, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
    }
  }
}
 
void Cogs::ContextD3D12::setSamplerState(const SamplerStateBindingHandle samplerStateBindingHandle, const SamplerStateHandle samplerStateHandle)
{
  auto handle = HandleIsValid(samplerStateHandle) ? samplerStateHandle : defaultSamplerState;
 
  uint32_t slots[ShaderType::NumShaderTypes];
  decode(samplerStateBindingHandle.handle, slots);
 
  auto & sampler = textures->samplerStates[handle];
  
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    if (slots[i] != NoBinding) {
      shaderState.Samplers[i].setChanged(slots[i], &sampler.samplerDesc, false);
    }
  }
}
 
void Cogs::ContextD3D12::setupConstantBuffers()
{
  if (constantBuffersUpdated) return;
 
  ContextCommon::updateConstantBuffers();
 
  auto & effect = this->effects->effects[this->currentEffect];
 
  auto updateConstantBuffer = [&](ShaderConstantBuffer & constantBuffer) {
    if (!constantBuffer.dirty) return;
 
    MappedBuffer<UINT8> mappedBuffer(this, constantBuffer.buffer, MapMode::WriteDiscard);
 
    std::memcpy(mappedBuffer, constantBuffer.memoryBuffer.data(), constantBuffer.memoryBuffer.size());
 
    constantBuffer.dirty = false;
  };
 
  for (auto & shader : effect.shaders) {
    for (auto & constantBuffer : shader.reflection.constantBuffers) {
      if (HandleIsValid(constantBuffer.buffer)) {
        updateConstantBuffer(constantBuffer);
      }
    }
  }
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    for (auto & cb : effect.shaders[i].reflection.constantBuffers) {
      shaderState.CBVs[i].setChanged(cb.slot, &buffers->buffers[cb.buffer]);
    }
  }
}
 
void Cogs::ContextD3D12::dispatchCompute(const unsigned int threadGroupsX, const unsigned int threadGroupsY, const unsigned int threadGroupsZ)
{
  
}