ContextD3D11.cpp

#include "ContextD3D11.h"
#include "GraphicsDeviceD3D11.h"
#include "FormatsD3D11.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <algorithm>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ContextD3D11");
 
  struct RenderStats 
  {
    size_t numVertices;
    size_t numIndices;
    size_t numFaces;
    size_t drawCalls;
  } renderStats = { 0 };
}
 
namespace Cogs
{
  namespace Direct3D11
  {
    const D3D11_PRIMITIVE_TOPOLOGY Topologies[] = {
      D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
      D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
      D3D11_PRIMITIVE_TOPOLOGY_LINELIST,
      D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP,
      D3D11_PRIMITIVE_TOPOLOGY_POINTLIST,
      D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
      D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
      D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
      D3D11_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 D3D11_MAP MapFlags[] = {
      D3D11_MAP_READ,
      D3D11_MAP_WRITE,
      D3D11_MAP_READ_WRITE,
      D3D11_MAP_WRITE_DISCARD
    };
  }
}
 
Cogs::ContextD3D11::ContextD3D11() :
  defaultBlendState(BlendStateHandle::InvalidHandle),
  defaultDepthStencilState(DepthStencilStateHandle::InvalidHandle),
  defaultRasterizerState(RasterizerStateHandle::InvalidHandle),
  currentRenderTarget(RenderTargetHandle::InvalidHandle),
  currentDepthStencil(DepthStencilHandle::InvalidHandle),
  currentInputLayout(InputLayoutHandle::InvalidHandle),
  isCompute(false)
{
  state = { 0 };
}
 
Cogs::ContextD3D11::~ContextD3D11()
{
  if (immediateContext) {
    immediateContext->ClearState();
    immediateContext->Flush();
  }
}
 
void Cogs::ContextD3D11::initialize(GraphicsDeviceD3D11 * graphicsDevice, BuffersD3D11 * buffers, TexturesD3D11 * textures, EffectsD3D11 * effects, RenderTargetsD3D11 * renderTargets, SyncObjectsD3D11* sync)
{
  this->constantBuffersUpdated = false;
 
  this->graphicsDevice = graphicsDevice;
  this->buffers = buffers;
  this->textures = textures;
  this->effects = effects;
  this->renderTargets = renderTargets;
  this->syncObjects = sync;
 
  // Ensure all default resources are pinned and not released by user code.
 
  this->defaultRasterizerState = this->renderTargets->loadRasterizerState(RasterizerState::DefaultState());
  this->renderTargets->rasterizerStates.pin(this->defaultRasterizerState);
 
  this->defaultBlendState = this->renderTargets->loadBlendState(BlendState::DefaultState());
  this->renderTargets->blendStates.pin(this->defaultBlendState);
 
  this->defaultDepthStencilState = this->renderTargets->loadDepthStencilState(DepthStencilState::DefaultState());
  this->renderTargets->depthStencilStates.pin(this->defaultDepthStencilState);
 
  this->defaultSamplerState = this->textures->loadSamplerState(SamplerState::DefaultState());
  this->textures->samplerStates.pin(this->defaultSamplerState);
 
  HRESULT hr = immediateContext->QueryInterface(__uuidof(annotationInterface), annotationInterface.internalVoidPointer());
  if (SUCCEEDED(hr)) {
    //Currently, NSIGHT 5.0 returns false here when running under graphics debugging. Bug submitted. 2015-10-3 chrisdy.
    //if (!annotationInterface->GetStatus()) {
    //  annotationInterface.Release();
    //}
  }
}
 
void Cogs::ContextD3D11::setDevice(ResourcePointer<ID3D11Device>& device, ResourcePointer<ID3D11Device1>& device1)
{
  assert(this->device == nullptr && "Device already set");
  assert(this->device1 == nullptr && "Device1 already set");
  assert(immediateContext == nullptr && "Immediate context already set");
  assert(immediateContext1 == nullptr && "Immediate context already set");
 
  this->device = device;
  this->device1 = device1;
  if (this->device1) {
        this->device1->GetImmediateContext1(this->immediateContext1.internalPointer());
  }
  this->device->GetImmediateContext(this->immediateContext.internalPointer());
 
  if (HRESULT hr = immediateContext->QueryInterface(__uuidof(ID3D11DeviceContext4), immediateContext4.internalVoidPointer()); SUCCEEDED(hr)) {
    LOG_DEBUG(logger, "Got ID3D11DeviceContext4 interface");
  }
 
}
 
 
void Cogs::ContextD3D11::setDefaults()
{
  this->constantBuffersUpdated = false;
  this->currentEffect = EffectHandle::NoHandle;
  this->isCompute = false;
 
  immediateContext->RSSetScissorRects(0, nullptr);
 
  this->setBlendState(defaultBlendState, nullptr);
  this->setRasterizerState(defaultRasterizerState);
  this->setDepthStencilState(defaultDepthStencilState);
 
  this->setRenderTarget(RenderTargetHandle::NoHandle, DepthStencilHandle::NoHandle);
 
  // Release all bound resources from last frame.
  ID3D11ShaderResourceView * shaderResourceViews[D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = { 0 };
  immediateContext->VSSetShaderResources(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT, shaderResourceViews);
  immediateContext->GSSetShaderResources(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT, shaderResourceViews);
  immediateContext->PSSetShaderResources(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT, shaderResourceViews);
  immediateContext->CSSetShaderResources(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT, shaderResourceViews);
 
  ID3D11SamplerState * samplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = { this->textures->samplerStates[defaultSamplerState] };
  immediateContext->VSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
  immediateContext->GSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
  immediateContext->PSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
  immediateContext->CSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
 
  ID3D11Buffer * constantBuffers[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = { 0 };
  immediateContext->VSSetConstantBuffers(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT, constantBuffers);
  immediateContext->GSSetConstantBuffers(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT, constantBuffers);
  immediateContext->PSSetConstantBuffers(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT, constantBuffers);
 
  state = { 0 };
 
  constantBuffersUpdated = false;
}
 
void Cogs::ContextD3D11::signal(FenceHandle fenceHandle)
{
  if (HandleIsValid(fenceHandle) && immediateContext4) {
    FenceD3D11& fence = syncObjects->fences[fenceHandle];
    immediateContext4->Signal(fence.fence, ++fence.value);
  }
}
 
 
void Cogs::ContextD3D11::pushCommandGroupAnnotation(const StringView & name)
{
  if (!annotationInterface) return;
 
  static thread_local std::wstring wname;
 
  if (annotationInterface->GetStatus()) {
    wname.assign(name.begin(), name.end());
 
    annotationInterface->BeginEvent(wname.c_str());
  }
}
 
void Cogs::ContextD3D11::popCommandGroupAnnotation()
{
  if (!annotationInterface) return;
 
  if (annotationInterface->GetStatus()) {
    annotationInterface->EndEvent();
  }
}
 
void Cogs::ContextD3D11::setAnnotationMarker(const StringView & name)
{
  if(!annotationInterface) return;
 
  static thread_local std::wstring wname;
 
  if (annotationInterface->GetStatus()) {
    wname.assign(name.begin(), name.end());
 
    annotationInterface->SetMarker(wname.c_str());
  }
}
 
void Cogs::ContextD3D11::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)];
 
    iaState.formats[i] = buffer.vertexBuffer.vertexFormat;
    iaState.currentVertexBuffers[i] = buffer.buffer;
    iaState.strides[i] = strides[i];
    iaState.offsets[i] = offsets ? offsets[i] : 0;
  }
 
  if (count) {
    immediateContext->IASetVertexBuffers(0, static_cast<UINT>(count), iaState.currentVertexBuffers, iaState.strides, iaState.offsets);
  } else {
    immediateContext->IASetVertexBuffers(0, 0, nullptr, nullptr, nullptr);
  }
}
 
void Cogs::ContextD3D11::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.vertexBuffer.vertexFormat && "Vertex buffer must have been created with format information attached.");
 
    strides[i] = getSize(*buffer.vertexBuffer.vertexFormat);
    offsets[i] = 0;
  }
 
  setVertexBuffers(handles, count, strides, offsets);
}
 
void Cogs::ContextD3D11::setIndexBuffer(IndexBufferHandle indexBufferHandle, uint32_t stride, uint32_t offset)
{
  if (HandleIsValid(indexBufferHandle)) {
    auto & indexBuffer = buffers->buffers[indexBufferHandle];
 
    iaState.currentIndexBuffer = &indexBuffer;
 
    assert(indexBuffer.bindFlags & BindFlags::IndexBuffer && "Buffer not bindable as index buffer.");
 
    auto format = stride == 0 ? iaState.currentIndexBuffer->indexBuffer.indexFormat : (stride == 4 ? DXGI_FORMAT_R32_UINT : DXGI_FORMAT_R16_UINT);
 
    if (format == DXGI_FORMAT_UNKNOWN) {
      iaState.currentIndexBuffer = nullptr;
      immediateContext->IASetIndexBuffer(nullptr, DXGI_FORMAT_UNKNOWN, 0);
    } else {
      immediateContext->IASetIndexBuffer(indexBuffer.buffer, format, offset);
    }
  } else {
    iaState.currentIndexBuffer = nullptr;
    immediateContext->IASetIndexBuffer(nullptr, DXGI_FORMAT_UNKNOWN, 0);
  }
}
 
void Cogs::ContextD3D11::setConstantBuffer(const ConstantBufferBindingHandle bufferBinding, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size)
{
  auto & effect = effects->effects[currentEffect];
  if (offset == 0 && size == ~0u) {
    if (this->isCompute) {
      const uint32_t csSlot = decode(bufferBinding.handle);
 
      if (HandleIsValid(bufferHandle)) {
        auto & buffer = buffers->buffers[bufferHandle];
 
        if (csSlot != NoBinding11) immediateContext->CSSetConstantBuffers(csSlot, 1, &buffer.buffer);
 
        constantBuffersUpdated = true;
 
        for (auto & constantBuffer : effect.shaders[ShaderType::ComputeShader].reflection.constantBuffers) {
          if (constantBuffer.slot == csSlot) {
            constantBuffer.manual = true;
          }
        }
      }
      else {
        if (csSlot != NoBinding11) immediateContext->CSSetConstantBuffers(csSlot, 0, nullptr);
      }
    }
    else {
      uint32_t slots[ShaderType::NumShaderTypes];
      decode(bufferBinding.handle, slots);
 
      if (HandleIsValid(bufferHandle)) {
        auto & buffer = buffers->buffers[bufferHandle];
 
        if (slots[0] != NoBinding11 && bufferHandle != state.vsCBs[slots[0]]) {
          immediateContext->VSSetConstantBuffers(slots[0], 1, &buffer.buffer);
          state.vsCBs[slots[0]] = bufferHandle;
        }
        if (slots[1] != NoBinding11) {
          immediateContext->HSSetConstantBuffers(slots[1], 1, &buffer.buffer);
        }
        if (slots[2] != NoBinding11) {
          immediateContext->DSSetConstantBuffers(slots[2], 1, &buffer.buffer);
        }
        if (slots[3] != NoBinding11) {
          immediateContext->GSSetConstantBuffers(slots[3], 1, &buffer.buffer);
        }
        if (slots[4] != NoBinding11 && bufferHandle != state.psCBs[slots[4]]) {
          immediateContext->PSSetConstantBuffers(slots[4], 1, &buffer.buffer);
          state.psCBs[slots[4]] = bufferHandle;
        }
 
        for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
          for (auto & constantBuffer : effect.shaders[i].reflection.constantBuffers) {
            if (constantBuffer.slot == slots[i]) {
              constantBuffer.manual = true;
            }
          }
        }
      }
      else {
        if (slots[0] != NoBinding11) {
          immediateContext->VSSetConstantBuffers(slots[0], 0, nullptr);
        }
        if (slots[1] != NoBinding11) {
          immediateContext->GSSetConstantBuffers(slots[1], 0, nullptr);
        }
        if (slots[2] != NoBinding11) {
          immediateContext->PSSetConstantBuffers(slots[2], 0, nullptr);
        }
      }
    }
  }
  else {
    if (!device1) {
      LOG_ERROR(logger, "Binding part of a constant buffer requires DX 11.1");
      return;
    }
    assert(immediateContext1);
 
    if (offset & 255) {
      LOG_ERROR(logger, "Constant buffer offset must be a multiple of 256 bytes.");
      return;
    }
    UINT firstConstant = offset / 16;
    UINT numConstant = 4096;
    if (size != ~0u) {
      if (size & 255) {
        LOG_ERROR(logger, "Constant buffer size must be a multiple of 256 bytes.");
        return;
      }
      numConstant = size / 16;
      if (4096 < numConstant) {
        LOG_ERROR(logger, "Constant buffer size cannot be larger than 16*4096 bytes.");
        return;
      }
    }
 
    if (this->isCompute) {
      const uint32_t csSlot = decode(bufferBinding.handle);
 
      if (HandleIsValid(bufferHandle)) {
        auto & buffer = buffers->buffers[bufferHandle];
 
        if (csSlot != NoBinding11) immediateContext1->CSSetConstantBuffers1(csSlot, 1, &buffer.buffer, &firstConstant, &numConstant);
 
        constantBuffersUpdated = true;
 
        for (auto & constantBuffer : effect.shaders[ShaderType::ComputeShader].reflection.constantBuffers) {
          if (constantBuffer.slot == csSlot) {
            constantBuffer.manual = true;
          }
        }
      }
      else {
        if (csSlot != NoBinding11) immediateContext1->CSSetConstantBuffers1(csSlot, 0, nullptr, nullptr, nullptr);
      }
    }
    else {
      uint32_t slots[ShaderType::NumShaderTypes];
      decode(bufferBinding.handle, slots);
 
      if (HandleIsValid(bufferHandle)) {
        auto & buffer = buffers->buffers[bufferHandle];
 
        if (slots[0] != NoBinding11) {
          immediateContext1->VSSetConstantBuffers1(slots[0], 1, &buffer.buffer, &firstConstant, &numConstant);
          state.vsCBs[slots[0]] = BufferHandle();
        }
        if (slots[1] != NoBinding11) {
          immediateContext1->HSSetConstantBuffers1(slots[1], 1, &buffer.buffer, &firstConstant, &numConstant);
        }
        if (slots[2] != NoBinding11) {
          immediateContext1->DSSetConstantBuffers1(slots[2], 1, &buffer.buffer, &firstConstant, &numConstant);
        }
        if (slots[3] != NoBinding11) {
          immediateContext1->GSSetConstantBuffers1(slots[3], 1, &buffer.buffer, &firstConstant, &numConstant);
        }
        if (slots[4] != NoBinding11) {
          immediateContext1->PSSetConstantBuffers1(slots[4], 1, &buffer.buffer, &firstConstant, &numConstant);
          state.psCBs[slots[4]] = BufferHandle();
        }
 
        for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
          for (auto & constantBuffer : effect.shaders[i].reflection.constantBuffers) {
            if (constantBuffer.slot == slots[i]) {
              constantBuffer.manual = true;
            }
          }
        }
      }
      else {
        if (slots[0] != NoBinding11) {
          immediateContext1->VSSetConstantBuffers1(slots[0], 0, nullptr, nullptr, nullptr);
        }
        if (slots[1] != NoBinding11) {
          immediateContext1->GSSetConstantBuffers1(slots[1], 0, nullptr, nullptr, nullptr);
        }
        if (slots[2] != NoBinding11) {
          immediateContext1->PSSetConstantBuffers1(slots[2], 0, nullptr, nullptr, nullptr);
        }
      }
    }
 
  }
}
 
void Cogs::ContextD3D11::draw(PrimitiveType::EPrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes)
{
  if (state.primitiveType != primitiveType) {
    state.primitiveType = primitiveType;
    immediateContext->IASetPrimitiveTopology(Direct3D11::Topologies[primitiveType]);
  }
 
  setupConstantBuffers();
 
  immediateContext->Draw(static_cast<UINT>(numVertexes), static_cast<UINT>(startVertex));
 
  renderStats.numFaces += numVertexes / 3;
  renderStats.numVertices += numVertexes;
  ++renderStats.drawCalls;
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numVertexes, false); }
}
 
void Cogs::ContextD3D11::drawIndexed(PrimitiveType::EPrimitiveType primitiveType, const size_t startIndex, const size_t numIndexes, const size_t startVertex)
{
  if (state.primitiveType != primitiveType) {
    state.primitiveType = primitiveType;
    immediateContext->IASetPrimitiveTopology(Direct3D11::Topologies[primitiveType]);
  }
 
  setupConstantBuffers();
 
  const UINT start = static_cast<UINT>(startIndex);
  const UINT count = numIndexes == 0 ? static_cast<UINT>(iaState.currentIndexBuffer->indexBuffer.count) : static_cast<UINT>(numIndexes);
 
  immediateContext->DrawIndexed(count, start, static_cast<UINT>(startVertex));
 
  renderStats.numIndices += numIndexes;
  renderStats.numFaces += numIndexes / 3;
  renderStats.numVertices += numIndexes;
  ++renderStats.drawCalls;
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(count, true); }
}
 
void Cogs::ContextD3D11::setRasterizerState(const RasterizerStateHandle handle)
{
  if (handle == RasterizerStateHandle::NoHandle) {
    immediateContext->RSSetState(this->renderTargets->rasterizerStates[defaultRasterizerState]);
  } else {
    assert(this->renderTargets->rasterizerStates.hasResource(handle) && "Invalid rasterizer state handle.");
    immediateContext->RSSetState(this->renderTargets->rasterizerStates[handle]);
  }
}
 
void Cogs::ContextD3D11::setBlendState(const BlendStateHandle handle, const float* constant)
{
  if (handle == BlendStateHandle::NoHandle) {
    immediateContext->OMSetBlendState(this->renderTargets->blendStates[defaultBlendState], 0, 0xffffffff);
  } else {
    assert(this->renderTargets->blendStates.hasResource(handle) && "Invalid blend state handle.");
    immediateContext->OMSetBlendState(this->renderTargets->blendStates[handle], constant, 0xffffffff);
  }
}
 
void Cogs::ContextD3D11::setDepthStencilState(const DepthStencilStateHandle handle)
{
  if (handle == DepthStencilStateHandle::NoHandle) {
    immediateContext->OMSetDepthStencilState(this->renderTargets->depthStencilStates[defaultDepthStencilState], 1);
  } else {
    assert(this->renderTargets->depthStencilStates.hasResource(handle) && "Invalid depth stencil state handle.");
    immediateContext->OMSetDepthStencilState(this->renderTargets->depthStencilStates[handle], 1);
  }
}
 
void Cogs::ContextD3D11::beginRenderPass(const RenderPassInfo &info)
{
  assert(!inRenderPass);
  setRenderTarget(info.renderTargetHandle, info.depthStencilHandle);
  {
    auto & renderTarget = renderTargets->renderTargets[currentRenderTarget];
    for (size_t i = 0; i < renderTarget.numViews; ++i) {
      if(info.loadOp[i] == LoadOp::Clear){
        immediateContext->ClearRenderTargetView(renderTarget.views[i], info.clearValue[i]);
      }
    }
  }
  if(info.depthLoadOp == LoadOp::Clear){
    clearDepth(info.depthClearValue);
  }
  inRenderPass = true;
  renderPassInfo = info;
}
 
void Cogs::ContextD3D11::endRenderPass()
{
  assert(inRenderPass);
  if(HandleIsValid(renderPassInfo.renderTargetHandle)){
    RenderTargetD3D11 &target = renderTargets->renderTargets[renderPassInfo.renderTargetHandle];
    for(size_t i=0; i<target.numViews; i++){
      if(HandleIsValid(renderPassInfo.resolveHandle[i])){
        resolveResource(target.texture[i], textures->textureViews[renderPassInfo.resolveHandle[i]].texture);
      }
    }
  }
  inRenderPass = false;
  renderPassInfo = {};
}
 
void Cogs::ContextD3D11::setRenderTarget(const RenderTargetHandle handle, const DepthStencilHandle depthStencilHandle)
{
  if (handle == RenderTargetHandle::NoHandle && depthStencilHandle == DepthStencilHandle::NoHandle) {
    SwapChainD3D11* swapChain = graphicsDevice->getDefaultSwapChain();
 
    currentRenderTarget = swapChain->getRenderTarget();
    currentDepthStencil = swapChain->getDepthStencil();
  }
  else {
    currentRenderTarget = handle;
    currentDepthStencil = depthStencilHandle;
  }
 
  resetSRVBindings();
 
  updateRenderTargets();
}
 
void Cogs::ContextD3D11::endFrame()
{
  renderStats = { 0 };
}
 
void Cogs::ContextD3D11::setViewport(const float x, const float y, const float width, const float height)
{
  D3D11_VIEWPORT viewport;
  viewport.TopLeftX = x;
  viewport.TopLeftY = y;
  viewport.Width = width;
  viewport.Height = height;
  viewport.MinDepth = 0.0f;
  viewport.MaxDepth = 1.0f;
 
  immediateContext->RSSetViewports(1, &viewport);
}
 
void Cogs::ContextD3D11::setScissor(const int x, const int y, const int z, const int w)
{
  D3D11_RECT scissor{ x, y, z, w };
 
  immediateContext->RSSetScissorRects(1, &scissor);
}
 
void Cogs::ContextD3D11::clearRenderTarget(const float * value)
{
  clearRenderTarget(&value, 1);
}
 
void Cogs::ContextD3D11::clearRenderTarget(const float ** values, const int numValues)
{
  assert(HandleIsValid(currentRenderTarget) && "No valid render target set.");
 
  auto & renderTarget = renderTargets->renderTargets[currentRenderTarget];
 
  for (size_t i = 0; i < renderTarget.numViews; ++i) {
    immediateContext->ClearRenderTargetView(renderTarget.views[i], numValues != 1 ? values[i] : values[0]);
  }
}
 
void Cogs::ContextD3D11::clearDepth(const float depth)
{
  assert(HandleIsValid(currentDepthStencil) && "No valid depth stencil target set.");
 
  immediateContext->ClearDepthStencilView(renderTargets->depthStencilViews[currentDepthStencil], D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, depth, 0);
}
 
void Cogs::ContextD3D11::setEffect(EffectHandle effectHandle)
{
  if (effectHandle == currentEffect) return;
 
  assert(HandleIsValid(effectHandle) && "Effect handle not valid.");
 
  if (HandleIsValid(currentEffect)) {
    // Reset previous shader resource and unordered access view bindings.
    ID3D11UnorderedAccessView * UAVs[D3D11_PS_CS_UAV_REGISTER_COUNT] = { 0 };
    immediateContext->CSSetUnorderedAccessViews(0, D3D11_PS_CS_UAV_REGISTER_COUNT, UAVs, nullptr);
 
    for (int i = 0; i < D3D11_PS_CS_UAV_REGISTER_COUNT; ++i) {
      uavs[i] = nullptr;
      uavCounts[i] = ~0u;
      uavDirty = false;
    }
    minUavSlot = ~0u;
    maxUavSlot = 0;
 
    ID3D11SamplerState * samplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = { this->textures->samplerStates[defaultSamplerState] };
    immediateContext->VSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
    immediateContext->GSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
    immediateContext->PSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
    immediateContext->CSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
 
    ID3D11Buffer * constantBuffers[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = { 0 };
    if (state.dirtyCB[ShaderType::VertexShader]) {
      immediateContext->VSSetConstantBuffers(0, state.dirtyCB[ShaderType::VertexShader], constantBuffers);
    }
    if (state.dirtyCB[ShaderType::GeometryShader]) {
      immediateContext->GSSetConstantBuffers(0, state.dirtyCB[ShaderType::GeometryShader], constantBuffers);
    }
    if (state.dirtyCB[ShaderType::PixelShader]) {
      immediateContext->PSSetConstantBuffers(0, state.dirtyCB[ShaderType::PixelShader], constantBuffers);
    }
    if (state.dirtyCB[ShaderType::ComputeShader]) {
      immediateContext->CSSetConstantBuffers(0, state.dirtyCB[ShaderType::ComputeShader], constantBuffers);
    }
 
    resetSRVBindings();
 
    state = { 0 };
  }
 
  currentEffect = effectHandle;
  constantBuffersUpdated = false;
  currentInputLayout = InputLayoutHandle::NoHandle;
 
  auto & effect = effects->effects[currentEffect];
 
  ContextCommon::setCurrentEffect(&effect);
 
  bool wasCompute = isCompute;
  if (effect.computeShader.shader) {
    immediateContext->CSSetShader(effect.computeShader.shader.get<ID3D11ComputeShader>(), nullptr, 0);
    isCompute = true;
  } else {
    immediateContext->VSSetShader(effect.vertexShader.shader.get<ID3D11VertexShader>(), nullptr, 0);
    immediateContext->HSSetShader(effect.hullShader.shader.get<ID3D11HullShader>(), nullptr, 0);
    immediateContext->DSSetShader(effect.domainShader.shader.get<ID3D11DomainShader>(), nullptr, 0);
    immediateContext->GSSetShader(effect.geometryShader.shader.get<ID3D11GeometryShader>(), nullptr, 0);
    immediateContext->PSSetShader(effect.pixelShader.shader.get<ID3D11PixelShader>(), nullptr, 0);
    isCompute = false;
  }
  if (wasCompute != isCompute) {
    updateRenderTargets();
  }
}
 
void Cogs::ContextD3D11::setInputLayout(const InputLayoutHandle inputLayoutHandle)
{
  if (inputLayoutHandle != currentInputLayout) {
    if (HandleIsValid(inputLayoutHandle)) {
      immediateContext->IASetInputLayout(buffers->inputLayouts[inputLayoutHandle].resource);
    }
    else {
      immediateContext->IASetInputLayout(nullptr);
    }
 
    if (inputLayoutHandle) {
      const auto & inputLayout = buffers->inputLayouts[inputLayoutHandle];
 
      iaState.numVertexBuffers = inputLayout.numFormats;
      for (size_t i = 0; i < inputLayout.numFormats; ++i) {
        iaState.formats[i] = inputLayout.formats[i];
      }
    }
 
    currentInputLayout = inputLayoutHandle;
  }
}
 
void Cogs::ContextD3D11::resolveResource(TextureHandle sourceTexture, TextureHandle destinationTexture)
{
  auto & source = textures->textures[sourceTexture];
  auto & destination = textures->textures[destinationTexture];
 
  auto formatD3D = Direct3D11::Formats[(int)source.format];
 
  immediateContext->ResolveSubresource(destination.resource(), 0, source.resource(), 0, formatD3D);
}
 
void Cogs::ContextD3D11::drawInstanced(PrimitiveType::EPrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes, const size_t startInstance, const size_t numInstances)
{
  if (state.primitiveType != primitiveType) {
    state.primitiveType = primitiveType;
    immediateContext->IASetPrimitiveTopology(Direct3D11::Topologies[primitiveType]);
  }
 
  this->setupConstantBuffers();
 
  immediateContext->DrawInstanced(static_cast<UINT>(numVertexes), static_cast<UINT>(numInstances), static_cast<UINT>(startVertex), static_cast<UINT>(startInstance));
 
  renderStats.numFaces += numVertexes / 3 * numInstances;
  renderStats.numVertices += numVertexes * numInstances;
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numVertexes * numInstances, false); }
}
 
void Cogs::ContextD3D11::drawInstancedIndexed(PrimitiveType::EPrimitiveType primitiveType, const size_t startInstance, const size_t numInstances, const size_t startIndex, const size_t numIndexes)
{
  if (state.primitiveType != primitiveType) {
    state.primitiveType = primitiveType;
    immediateContext->IASetPrimitiveTopology(Direct3D11::Topologies[primitiveType]);
  }
 
  this->setupConstantBuffers();
 
  UINT indexCount = (numIndexes == 0) ? iaState.currentIndexBuffer->indexBuffer.count : static_cast<UINT>(numIndexes);
 
  immediateContext->DrawIndexedInstanced(indexCount, static_cast<UINT>(numInstances), static_cast<UINT>(startIndex), 0, static_cast<UINT>(startInstance));
 
  renderStats.numFaces += numIndexes / 3 * numInstances;
  renderStats.numVertices += numIndexes * numInstances;
 
  if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(indexCount * numInstances, true); }
}
 
void Cogs::ContextD3D11::readDepthBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer::EFrameBuffer)
{
  if (!HandleIsValid(bufferHandle)) return;
 
  auto & depthStencilView = renderTargets->depthStencilViews[currentDepthStencil];
 
  ResourcePointer<ID3D11Texture2D> depthBuffer; 
  depthStencilView->GetResource((ID3D11Resource **)&depthBuffer);
 
  D3D11_TEXTURE2D_DESC depthBufferDesc;
  depthBuffer->GetDesc(&depthBufferDesc);
 
  D3D11_TEXTURE2D_DESC fpTextureDesc{};
  fpTextureDesc.Width = depthBufferDesc.Width;
  fpTextureDesc.Height = depthBufferDesc.Height;
  fpTextureDesc.ArraySize = 1;
  fpTextureDesc.MipLevels = 1; 
  fpTextureDesc.Format = DXGI_FORMAT_R32_FLOAT;
  fpTextureDesc.SampleDesc.Count = depthBufferDesc.SampleDesc.Count;
  fpTextureDesc.SampleDesc.Quality = depthBufferDesc.SampleDesc.Quality;
  fpTextureDesc.Usage = D3D11_USAGE_DEFAULT;
  fpTextureDesc.BindFlags = D3D11_BIND_RENDER_TARGET;
  fpTextureDesc.CPUAccessFlags = 0;
  fpTextureDesc.MiscFlags = 0;
 
  ResourcePointer<ID3D11Texture2D> fpDepthTexture;
  HRESULT hr = device->CreateTexture2D(&fpTextureDesc, nullptr, fpDepthTexture.internalPointer());
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Failed to create depth readback texture (%s): %s", getString(fpTextureDesc), direct3D11ReturnCodeAsString(hr));
    return;
  }
  else if ((graphicsDevice->getSettings().flags & GraphicsDeviceFlags::EnableTraceLogging) == GraphicsDeviceFlags::EnableTraceLogging) {
    LOG_TRACE(logger, "Created resource %p: %s", fpDepthTexture.get<void>(), getString(fpTextureDesc));
  }
 
  // Copy the depth buffer from its internal representation to a floating point representation since
  // we are not allowed to resolve directly from e.g D32_FLOAT format.
  immediateContext->CopyResource(fpDepthTexture, depthBuffer);
 
  const bool isMultisampled = depthBufferDesc.SampleDesc.Count > 1;
  ResourcePointer<ID3D11Texture2D> resolvedDepthTexture;
 
  if (isMultisampled) {
    D3D11_TEXTURE2D_DESC resolveTextureDesc = {};
    resolveTextureDesc.Width = depthBufferDesc.Width;
    resolveTextureDesc.Height = depthBufferDesc.Height;
    resolveTextureDesc.ArraySize = 1;
    resolveTextureDesc.MipLevels = 1;
    resolveTextureDesc.Format = DXGI_FORMAT_R32_FLOAT;
    resolveTextureDesc.SampleDesc.Count = 1;
    resolveTextureDesc.SampleDesc.Quality = 0;
    resolveTextureDesc.Usage = D3D11_USAGE_DEFAULT;
    resolveTextureDesc.BindFlags = 0;
    resolveTextureDesc.CPUAccessFlags = 0;
    resolveTextureDesc.MiscFlags = 0;
 
    hr = device->CreateTexture2D(&resolveTextureDesc, nullptr, resolvedDepthTexture.internalPointer());
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Failed to create depth readback resolve texture (%s): %s", getString(resolveTextureDesc), direct3D11ReturnCodeAsString(hr));
      return;
    }
    else if ((graphicsDevice->getSettings().flags & GraphicsDeviceFlags::EnableTraceLogging) == GraphicsDeviceFlags::EnableTraceLogging) {
      LOG_TRACE(logger, "Created resource %p: %s", resolvedDepthTexture.get<void>(), getString(resolveTextureDesc));
    }
 
    immediateContext->ResolveSubresource(resolvedDepthTexture, 0, fpDepthTexture, 0, resolveTextureDesc.Format);
  }
 
  auto & buffer = buffers->buffers[bufferHandle];
 
  if (!buffer.aliasedTexture || buffer.aliasedWidth != width || buffer.aliasedHeight != height) {
    D3D11_TEXTURE2D_DESC readTextureDesc{};
    readTextureDesc.Width = width;
    readTextureDesc.Height = height;
    readTextureDesc.ArraySize = 1;
    readTextureDesc.MipLevels = 1;
    readTextureDesc.Format = DXGI_FORMAT_R32_TYPELESS;
    readTextureDesc.SampleDesc.Count = 1;
    readTextureDesc.SampleDesc.Quality = 0;
    readTextureDesc.Usage = D3D11_USAGE_STAGING;
    readTextureDesc.BindFlags = 0;
    readTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
    readTextureDesc.MiscFlags = 0;
 
    hr = device->CreateTexture2D(&readTextureDesc, nullptr, buffer.aliasedTexture.internalPointer());
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Failed to create depth readback staging texture (%s): %s", getString(readTextureDesc), direct3D11ReturnCodeAsString(hr));
      return;
    }
    else if ((graphicsDevice->getSettings().flags & GraphicsDeviceFlags::EnableTraceLogging) == GraphicsDeviceFlags::EnableTraceLogging) {
      LOG_TRACE(logger, "Created resource %p: %s", buffer.aliasedTexture.get<void>(), getString(readTextureDesc));
    }
  }
 
  D3D11_BOX renderBox;
  renderBox.left = x;
  renderBox.right = x + width;
  renderBox.top = y;
  renderBox.bottom = y + height;
  renderBox.front = 0;
  renderBox.back = 1;
 
  immediateContext->CopySubresourceRegion(buffer.aliasedTexture, 0, 0, 0, 0, isMultisampled ? resolvedDepthTexture : fpDepthTexture, 0, &renderBox);
}
 
void Cogs::ContextD3D11::readColorBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer::EFrameBuffer)
{
  auto & renderTarget = renderTargets->renderTargets[currentRenderTarget];
 
  ResourcePointer<ID3D11Texture2D> renderTexture; 
  renderTarget.views[0]->GetResource((ID3D11Resource **)&renderTexture);
 
  D3D11_TEXTURE2D_DESC renderBufferDesc;
  renderTexture->GetDesc(&renderBufferDesc);
 
  const bool isMultisampled = renderBufferDesc.SampleDesc.Count > 1;
  ResourcePointer<ID3D11Texture2D> resolvedRenderTexture;
 
  if (isMultisampled) {
    D3D11_TEXTURE2D_DESC resolveTextureDesc{};
    resolveTextureDesc.Width = renderBufferDesc.Width;
    resolveTextureDesc.Height = renderBufferDesc.Height;
    resolveTextureDesc.ArraySize = 1;
    resolveTextureDesc.MipLevels = 1;
    resolveTextureDesc.Format = renderBufferDesc.Format;
    resolveTextureDesc.SampleDesc.Count = 1;
    resolveTextureDesc.SampleDesc.Quality = 0;
    resolveTextureDesc.Usage = D3D11_USAGE_DEFAULT;
    resolveTextureDesc.BindFlags = 0;
    resolveTextureDesc.CPUAccessFlags = 0;
    resolveTextureDesc.MiscFlags = 0;
 
    HRESULT hr = device->CreateTexture2D(&resolveTextureDesc, nullptr, resolvedRenderTexture.internalPointer());
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Failed to create readback resolve texture (%s): %s", getString(resolveTextureDesc), direct3D11ReturnCodeAsString(hr));
      return;
    }
    else if ((graphicsDevice->getSettings().flags & GraphicsDeviceFlags::EnableTraceLogging) == GraphicsDeviceFlags::EnableTraceLogging) {
      LOG_TRACE(logger, "Created resource %p: %s", resolvedRenderTexture.get<void>(), getString(resolveTextureDesc));
    }
    immediateContext->ResolveSubresource(resolvedRenderTexture, 0, renderTexture, 0, renderBufferDesc.Format);
  }
 
  BufferD3D11 & buffer = buffers->buffers[bufferHandle];
 
  if (!buffer.aliasedTexture || buffer.aliasedWidth != width || buffer.aliasedHeight != height) {
    D3D11_TEXTURE2D_DESC renderTextureDesc{};
    renderTextureDesc.Width = width;
    renderTextureDesc.Height = height;
    renderTextureDesc.ArraySize = 1;
    renderTextureDesc.MipLevels = 1;
    renderTextureDesc.Format = renderBufferDesc.Format;
    renderTextureDesc.SampleDesc.Count = 1;
    renderTextureDesc.SampleDesc.Quality = 0;
    renderTextureDesc.Usage = D3D11_USAGE_STAGING;
    renderTextureDesc.BindFlags = 0;
    renderTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
    renderTextureDesc.MiscFlags = 0;
 
    HRESULT hr = device->CreateTexture2D(&renderTextureDesc, nullptr, buffer.aliasedTexture.internalPointer());
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Failed to create readback staging texture (%s): %s", getString(renderTextureDesc), direct3D11ReturnCodeAsString(hr));
      return;
    }
    else if ((graphicsDevice->getSettings().flags & GraphicsDeviceFlags::EnableTraceLogging) == GraphicsDeviceFlags::EnableTraceLogging) {
      LOG_TRACE(logger, "Created resource %p: %s", buffer.aliasedTexture.get<void>(), getString(renderTextureDesc));
    }
    buffer.aliasedWidth = width;
    buffer.aliasedHeight = height;
  }
  
  D3D11_BOX renderBox;
  renderBox.left = x;
  renderBox.right = x + width;
  renderBox.top = y;
  renderBox.bottom = y + height;
  renderBox.front = 0;
  renderBox.back = 1;
 
  immediateContext->CopySubresourceRegion(buffer.aliasedTexture, 0, 0, 0, 0, isMultisampled ? resolvedRenderTexture : renderTexture, 0, &renderBox);
}
 
void * Cogs::ContextD3D11::map(BufferHandle bufferHandle, MapMode::EMapMode accessMode, uint32_t * stride)
{
  auto & buffer = this->buffers->buffers[bufferHandle];
 
  D3D11_MAPPED_SUBRESOURCE resource{};
 
  if (buffer.aliasedTexture && accessMode == MapMode::Read) {
    HRESULT hr = immediateContext->Map(buffer.aliasedTexture, 0, Direct3D11::MapFlags[accessMode], 0, &resource);
    buffer.aliasMapped = true;
    if (stride) {
      *stride = resource.RowPitch;
    }
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Failed to map alias texture resource %p: %s", buffer.aliasedTexture.get<void>(), direct3D11ReturnCodeAsString(hr));
      return nullptr;
    }
  }
  else {
    HRESULT hr = immediateContext->Map(buffer.buffer, 0, Direct3D11::MapFlags[accessMode], 0, &resource);
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Failed to map buffer resource %p: %s", buffer.buffer.get<void>(), direct3D11ReturnCodeAsString(hr));
      return nullptr;
    }
  }
 
  return resource.pData;
}
 
void Cogs::ContextD3D11::unmap(BufferHandle bufferHandle)
{
  auto & buffer = this->buffers->buffers[bufferHandle];
 
  if (buffer.aliasMapped) {
    immediateContext->Unmap(buffer.aliasedTexture, 0);
  } else {
    immediateContext->Unmap(buffer.buffer, 0);
  }
}
 
void * Cogs::ContextD3D11::map(TextureHandle textureHandle, MapMode::EMapMode accessMode, uint32_t * rowPitch, uint32_t * depthPitch)
{
  auto & texture = textures->textures[textureHandle];
 
  D3D11_MAPPED_SUBRESOURCE resource{};
  HRESULT hr = immediateContext->Map(texture.resource(), 0, Direct3D11::MapFlags[accessMode], 0, &resource);
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Failed to map texture resource %p: %s", texture.resource(), direct3D11ReturnCodeAsString(hr));
    return nullptr;
  }
  if (rowPitch) *rowPitch = resource.RowPitch;
  if (depthPitch) *depthPitch = resource.DepthPitch;
  return resource.pData;
}
 
void Cogs::ContextD3D11::unmap(TextureHandle textureHandle)
{
  auto & texture = textures->textures[textureHandle];
 
  immediateContext->Unmap(texture.resource(), 0);
}
 
 
void Cogs::ContextD3D11::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 = Cogs::getMipSize(texture.width, static_cast<uint32_t>(level));
  const uint32_t height = Cogs::getMipSize(texture.height, static_cast<uint32_t>(level));
 
  D3D11_BOX rectangle;
  rectangle.left = 0;
  rectangle.right = width;
  rectangle.top = 0;
  rectangle.bottom = height;
  rectangle.front = 0;
  rectangle.back = 1;
 
  // Copy the image data into the given mipmap level in the texture.
  immediateContext->UpdateSubresource(texture.resource(), static_cast<UINT>(level), &rectangle, data, width * static_cast<uint32_t>(getBlockSize(texture.format)), 1);
  if(uploadStatisticsEnabled){
    TextureExtent extent = getBlockExtent(texture.format);
    size_t size = width * height * getBlockSize(texture.format);
    uploadStatisticsTextureUpload(size);
  }
}
 
void Cogs::ContextD3D11::updateSubBuffer(BufferHandle bufferHandle, const size_t offset, const size_t size, const void * data)
{
  assert(HandleIsValid(bufferHandle) && "Buffer handle must point to a valid buffer.");
 
  auto & buffer = this->buffers->buffers[bufferHandle];
 
  assert(buffer.size >= offset + size && "Buffer size not sufficient to hold data.");
 
  D3D11_BOX rectangle;
  rectangle.left = static_cast<UINT>(offset);
  rectangle.right = static_cast<UINT>(offset + size);
  rectangle.top = 0;
  rectangle.bottom = 1;
  rectangle.front = 0;
  rectangle.back = 1;
 
  immediateContext->UpdateSubresource(buffer.buffer, 0u, &rectangle, data, 0, 0);
  if(uploadStatisticsEnabled) uploadStatisticsBufferUpload(size);
}
 
void Cogs::ContextD3D11::copyResource(BufferHandle destinationHandle, BufferHandle sourceHandle)
{
  auto & destination = buffers->buffers[destinationHandle];
  auto & source = buffers->buffers[sourceHandle];
 
  immediateContext->CopyResource(destination.buffer, source.buffer);
}
 
void Cogs::ContextD3D11::copyResource(TextureHandle destinationHandle, TextureHandle sourceHandle)
{
  auto & destination = textures->textures[destinationHandle];
  auto & source = textures->textures[sourceHandle];
 
  immediateContext->CopyResource(destination.resource(), source.resource());
}
 
void Cogs::ContextD3D11::copyTexture(TextureHandle dstHandle, unsigned dstSub,  unsigned dstX, unsigned dstY, unsigned dstZ, TextureHandle sourceHandle, unsigned srcSub)
{
  auto & destination = textures->textures[dstHandle];
  auto & source = textures->textures[sourceHandle];
  immediateContext->CopySubresourceRegion(destination.resource(), dstSub,
                                          dstX, dstY, dstZ,
                                          source.resource(), srcSub, NULL);
}
 
void Cogs::ContextD3D11::clearResource(BufferHandle destinationHandle, uint32_t *Values)
{
  auto & destination = buffers->buffers[destinationHandle];
  immediateContext->ClearUnorderedAccessViewUint(destination.uav, Values);
}
 
void Cogs::ContextD3D11::clearResource(BufferHandle destinationHandle, float *Values)
{
  auto & destination = buffers->buffers[destinationHandle];
  immediateContext->ClearUnorderedAccessViewFloat(destination.uav, Values);
}
 
void Cogs::ContextD3D11::setTexture(const TextureBindingHandle textureBindingHandle, const TextureHandle textureHandle)
{
  if (isCompute) {
    const uint32_t csSlot = decode(textureBindingHandle.handle);
 
    if (HandleIsValid(textureHandle)) {
      auto & texture = textures->textures[textureHandle];
 
      if (texture.unorderedAccessView) {
        if (csSlot != NoBinding11) immediateContext->CSSetUnorderedAccessViews(csSlot, 1, &texture.unorderedAccessView, nullptr);
      } else {
        if (csSlot != NoBinding11) immediateContext->CSSetShaderResources(csSlot, 1, &texture.shaderResourceView);
      }
    } else {
      ID3D11UnorderedAccessView * view = nullptr;
      if (csSlot != NoBinding11) immediateContext->CSSetUnorderedAccessViews(csSlot, 1, &view, nullptr);
      ID3D11ShaderResourceView * shaderResourceView = nullptr;
      if (csSlot != NoBinding11) immediateContext->CSSetShaderResources(csSlot, 1, &shaderResourceView);
    }
  } else {
    uint32_t slots[ShaderType::NumShaderTypes];
    decode(textureBindingHandle.handle, slots);
 
    ID3D11ShaderResourceView * shaderResourceView = nullptr;
    if (HandleIsValid(textureHandle)) {
      shaderResourceView = textures->textures[textureHandle].shaderResourceView;
    }
    setShaderResources(slots, &shaderResourceView);
 
  }
}
void Cogs::ContextD3D11::setShaderResources(uint32_t * slots, ID3D11ShaderResourceView *const *ppShaderResourceViews) {
  if (slots[0] != NoBinding11) immediateContext->VSSetShaderResources(slots[0], 1, ppShaderResourceViews);
  if (slots[1] != NoBinding11) immediateContext->HSSetShaderResources(slots[1], 1, ppShaderResourceViews);
  if (slots[2] != NoBinding11) immediateContext->DSSetShaderResources(slots[2], 1, ppShaderResourceViews);
  if (slots[3] != NoBinding11) immediateContext->GSSetShaderResources(slots[3], 1, ppShaderResourceViews);
  if (slots[4] != NoBinding11) immediateContext->PSSetShaderResources(slots[4], 1, ppShaderResourceViews);
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    if (slots[i] != NoBinding11) {
      state.dirtySRV[i] = std::max(state.dirtySRV[i], slots[i] + 1);
    }
  }
}
 
void Cogs::ContextD3D11::setTexture(const TextureBindingHandle textureBindingHandle, TextureViewHandle textureViewHandle)
{
  auto & view = textures->textureViews[textureViewHandle];
  auto & textureHandle = view.texture;
 
  if (isCompute) {
    const uint32_t csSlot = decode(textureBindingHandle.handle);
 
    if (HandleIsValid(textureHandle)) {
      auto & texture = textures->textures[textureHandle];
 
      if (texture.unorderedAccessView) {
        if (csSlot != NoBinding11) immediateContext->CSSetUnorderedAccessViews(csSlot, 1, &texture.unorderedAccessView, nullptr);
      } else {
        if (csSlot != NoBinding11) immediateContext->CSSetShaderResources(csSlot, 1, &view.shaderResourceView);
      }
    } else {
      ID3D11UnorderedAccessView * unorderedAccessView = nullptr;
      if (csSlot != NoBinding11) immediateContext->CSSetUnorderedAccessViews(csSlot, 1, &unorderedAccessView, nullptr);
      ID3D11ShaderResourceView * shaderResourceView = nullptr;
      if (csSlot != NoBinding11) immediateContext->CSSetShaderResources(csSlot, 1, &shaderResourceView);
    }
  } else {
    uint32_t slots[ShaderType::NumShaderTypes];
    decode(textureBindingHandle.handle, slots);
 
    ID3D11ShaderResourceView * shaderResourceView = view.shaderResourceView;
    setShaderResources(slots, &shaderResourceView);
  }
}
 
void Cogs::ContextD3D11::setSamplerState(const SamplerStateBindingHandle samplerStateBindingHandle, const SamplerStateHandle samplerStateHandle)
{
  if (isCompute) {
    const uint32_t csSlot = decode(samplerStateBindingHandle.handle);
 
    if (HandleIsValid(samplerStateHandle)) {
      auto & samplerState = textures->samplerStates[samplerStateHandle];
 
      if (csSlot != NoBinding11) immediateContext->CSSetSamplers(csSlot, 1, &samplerState);
    } else {
      ID3D11SamplerState * samplerState = nullptr;
      if (csSlot != NoBinding11) immediateContext->CSSetSamplers(csSlot, 1, &samplerState);
    }
  } else {
    uint32_t slots[ShaderType::NumShaderTypes];
    decode(samplerStateBindingHandle.handle, slots);
 
    auto & samplerState = textures->samplerStates[HandleIsValid(samplerStateHandle) ? samplerStateHandle : defaultSamplerState];
 
    if (slots[0] != NoBinding11) immediateContext->VSSetSamplers(slots[0], 1, &samplerState);
    if (slots[1] != NoBinding11) immediateContext->HSSetSamplers(slots[1], 1, &samplerState);
    if (slots[2] != NoBinding11) immediateContext->DSSetSamplers(slots[2], 1, &samplerState);
    if (slots[3] != NoBinding11) immediateContext->GSSetSamplers(slots[3], 1, &samplerState);
    if (slots[4] != NoBinding11) immediateContext->PSSetSamplers(slots[4], 1, &samplerState);
  }
}
 
void Cogs::ContextD3D11::setBuffer(const BufferBindingHandle bufferBindingHandle, BufferHandle bufferHandle)
{
  auto & buffer = buffers->buffers[bufferHandle];
  auto & binding = effects->bufferBindings[bufferBindingHandle];
 
  if (isCompute) {
    //TODO: Implement CS Support. 2015-08-11, oyshole.
    const uint32_t csSlot = static_cast<uint32_t>(binding.uavBindings);
    if (csSlot != NoBinding11) {
      uavs[csSlot] = buffer.uav;
      uavCounts[csSlot] = buffer.uavCount;
      minUavSlot = std::min(minUavSlot, csSlot);
      maxUavSlot = std::max(maxUavSlot, csSlot);
      uavDirty = true;
 
      updateRenderTargets();
 
      uavCounts[csSlot] = ~0u;
      buffer.uavCount = ~0u;
    }
 
  } else {
    {
      uint32_t slots[ShaderType::NumShaderTypes];
      decode(binding.uavBindings, slots);
 
      uint32_t psSlot = slots[ShaderType::PixelShader];
 
      if (psSlot != NoBinding11) {
        uavs[psSlot] = buffer.uav;
        uavCounts[psSlot] = buffer.uavCount;
        minUavSlot = std::min(minUavSlot, psSlot);
        maxUavSlot = std::max(maxUavSlot, psSlot);
        uavDirty = true;
 
        updateRenderTargets();
 
        uavCounts[psSlot] = ~0u;
        buffer.uavCount = ~0u;
      }
    }
 
    {
      uint32_t slots[ShaderType::NumShaderTypes];
      decode(binding.srvBindings, slots);
 
      setShaderResources(slots, &buffer.srv);
    }
  }
}
 
void Cogs::ContextD3D11::setBufferCounter(BufferHandle bufferHandle, uint32_t value)
{
  auto & buffer = buffers->buffers[bufferHandle];
 
  buffer.uavCount = value;
}
 
void Cogs::ContextD3D11::setBufferCounter(BufferHandle /*bufferHandle*/, BufferHandle /*sourceBufferHandle*/)
{
  // Noop
}
 
void Cogs::ContextD3D11::getBufferCounter(BufferHandle bufferHandle, BufferHandle destinationBufferHandle)
{
  auto & buffer = buffers->buffers[bufferHandle];
  auto & dstBuffer = buffers->buffers[destinationBufferHandle];
 
  immediateContext->CopyStructureCount(dstBuffer.buffer, 0, buffer.uav);
}
 
uint32_t Cogs::ContextD3D11::getBufferCounter(BufferHandle bufferHandle)
{
  auto dstBuffer = buffers->loadBuffer(nullptr, 4, Usage::Dynamic, AccessMode::Read, BindFlags::None);
 
  getBufferCounter(bufferHandle, dstBuffer);
 
  MappedBuffer<uint32_t> mapped(this, dstBuffer);
 
  return mapped ? *mapped : 0;
}
 
void Cogs::ContextD3D11::resetSRVBindings()
{
  ID3D11ShaderResourceView * resourceViews[D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = { 0 };
  if (state.dirtySRV[ShaderType::VertexShader]) immediateContext->VSSetShaderResources(0, state.dirtySRV[ShaderType::VertexShader], resourceViews);
  if (state.dirtySRV[ShaderType::GeometryShader]) immediateContext->GSSetShaderResources(0, state.dirtySRV[ShaderType::GeometryShader], resourceViews);
  if (state.dirtySRV[ShaderType::PixelShader]) immediateContext->PSSetShaderResources(0, state.dirtySRV[ShaderType::PixelShader], resourceViews);
  if (state.dirtySRV[ShaderType::ComputeShader]) immediateContext->CSSetShaderResources(0, state.dirtySRV[ShaderType::ComputeShader], resourceViews);
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    state.dirtySRV[i] = 0;
  }
}
 
void Cogs::ContextD3D11::updateRenderTargets()
{
  ID3D11RenderTargetView * views[kMaxRenderTargets11];
 
  if (isCompute) {
    if ((minUavSlot <= maxUavSlot) && uavDirty) {
      immediateContext->CSSetUnorderedAccessViews(minUavSlot,
                                                  maxUavSlot - minUavSlot + 1,
                                                  uavs + minUavSlot,
                                                  uavCounts + minUavSlot);
 
      uavDirty = false;
    }
  } else {
    uint32_t numViews = 0;
    if (HandleIsValid(currentRenderTarget)) {
      RenderTargetD3D11& renderTarget = renderTargets->renderTargets[currentRenderTarget];
      numViews = static_cast<uint32_t>(renderTarget.numViews);
      for (uint32_t i = 0; i < renderTarget.numViews; ++i) {
        views[i] = renderTarget.views[i];
      }
    }
 
    ID3D11DepthStencilView * depthStencilView = nullptr;
    if (HandleIsValid(currentDepthStencil)) {
      depthStencilView = renderTargets->depthStencilViews[currentDepthStencil];
    }
 
    if ((minUavSlot <= maxUavSlot) && uavDirty) {
      immediateContext->OMSetRenderTargetsAndUnorderedAccessViews(static_cast<UINT>(numViews),
                                                                  views,
                                                                  depthStencilView,
                                                                  minUavSlot,
                                                                  maxUavSlot - minUavSlot + 1,
                                                                  uavs + minUavSlot,
                                                                  uavCounts + minUavSlot);
 
      uavDirty = false;
    } else {
      immediateContext->OMSetRenderTargets(numViews, views, depthStencilView);
    }
  }
}
 
void Cogs::ContextD3D11::setupConstantBuffers()
{
  ContextCommon::updateConstantBuffers();
 
  auto & effect = effects->effects[currentEffect];
 
  for (auto & constantBuffer : effect.vertexShader.reflection.constantBuffers) {
    if (HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual && constantBuffer.buffer != state.vsCBs[constantBuffer.slot]) {
      immediateContext->VSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
      state.vsCBs[constantBuffer.slot] = constantBuffer.buffer;
    }
  }
 
  for (auto & constantBuffer : effect.hullShader.reflection.constantBuffers) {
    if (HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual) {
      immediateContext->HSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
    }
  }
 
  for (auto & constantBuffer : effect.domainShader.reflection.constantBuffers) {
    if (HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual) {
      immediateContext->DSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
    }
  }
 
  for (auto & constantBuffer : effect.geometryShader.reflection.constantBuffers) {
    if (HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual) {
      immediateContext->GSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
    }
  }
 
  for (auto & constantBuffer : effect.pixelShader.reflection.constantBuffers) {
    if (HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual && constantBuffer.buffer != state.psCBs[constantBuffer.slot]) {
      immediateContext->PSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
      state.psCBs[constantBuffer.slot] = constantBuffer.buffer;
    }
  }
 
  for (auto & constantBuffer : effect.computeShader.reflection.constantBuffers) {
    if (HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual) {
      immediateContext->CSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
    }
  }
 
  constantBuffersUpdated = true;
}
 
void Cogs::ContextD3D11::dispatchCompute(const unsigned int threadGroupsX, const unsigned int threadGroupsY, const unsigned int threadGroupsZ)
{
  this->setupConstantBuffers();
 
  immediateContext->Dispatch(threadGroupsX, threadGroupsY, threadGroupsZ);
}