RenderTargetsD3D11.cpp

#include "RenderTargetsD3D11.h"
 
 
#include "TexturesD3D11.h"
#include "FormatsD3D11.h"
#include "GraphicsDeviceD3D11.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderTargetsD3D11");
 
  D3D11_BLEND Blends[] = {
    D3D11_BLEND_ZERO,
    D3D11_BLEND_ONE,
    D3D11_BLEND_SRC_COLOR,
    D3D11_BLEND_INV_SRC_COLOR,
    D3D11_BLEND_SRC_ALPHA,
    D3D11_BLEND_INV_SRC_ALPHA,
    D3D11_BLEND_DEST_ALPHA,
    D3D11_BLEND_INV_DEST_ALPHA,
    D3D11_BLEND_DEST_COLOR,
    D3D11_BLEND_INV_DEST_COLOR,
    D3D11_BLEND_SRC_ALPHA_SAT,
    D3D11_BLEND_BLEND_FACTOR,
    D3D11_BLEND_INV_BLEND_FACTOR,
  };
  static_assert(sizeof(Blends) == sizeof(Blends[0]) * size_t(Cogs::BlendState::Blend::Count));
 
  D3D11_BLEND_OP BlendOperations[] = {
    D3D11_BLEND_OP_ADD,
    D3D11_BLEND_OP_SUBTRACT,
    D3D11_BLEND_OP_REV_SUBTRACT,
    D3D11_BLEND_OP_MIN,
    D3D11_BLEND_OP_MAX
  };
  static_assert(sizeof(BlendOperations) == sizeof(BlendOperations[0]) * size_t(Cogs::BlendState::BlendOperation::Count));
 
  }
 
 
void Cogs::RenderTargetsD3D11::annotate(RenderTargetHandle handle, const StringView& name)
{
#ifdef COGSRENDERING_GFX_ANNOTATE
  if (name.empty()) {
    return;
  }
  auto & rt = renderTargets[handle];
 
  for (size_t i = 0; i < rt.numViews; i++) {
    if (rt.views[i]) {
      std::string m(name);
      m.append("[");
      m.append(std::to_string(i));
      m.append("]");
      rt.views[i]->SetPrivateData(WKPDID_D3DDebugObjectName, static_cast<UINT>(m.length()), m.c_str());
    }
  }
#else
  (void)handle;
  (void)name;
#endif
}
 
void Cogs::RenderTargetsD3D11::annotate(DepthStencilHandle handle, const StringView& name)
{
#ifdef COGSRENDERING_GFX_ANNOTATE
  if (name.empty()) {
    return;
  }
  auto & rt = depthStencilViews[handle];
  if (rt) {
    rt->SetPrivateData(WKPDID_D3DDebugObjectName, static_cast<UINT>(name.length()), name.data());
  }
#else
  (void)handle;
  (void)name;
#endif
}
 
Cogs::RenderTargetHandle Cogs::RenderTargetsD3D11::createRenderTarget(ID3D11Texture2D * texture, bool persistent)
{
  if (texture == nullptr) {
    return RenderTargetHandle::InvalidHandle;
  }
 
  RenderTargetD3D11 renderTarget;
  renderTarget.numViews = 1;
 
  HRESULT hr = graphicsDevice->getDevice()->CreateRenderTargetView(texture, NULL, renderTarget.views[0].internalPointer());
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Failed to create render target: %s", direct3D11ReturnCodeAsString(hr));
    return RenderTargetHandle::InvalidHandle;
  }
 
  return renderTargets.addResource(std::move(renderTarget), persistent);
}
 
void Cogs::RenderTargetsD3D11::releaseRenderTarget(RenderTargetHandle handle)
{
  this->renderTargets.removeResource(handle);
}
 
Cogs::RenderTargetHandle Cogs::RenderTargetsD3D11::createRenderTarget(const RenderTargetViewDescription * renderTargetViews, const size_t numViews)
{
  RenderTargetD3D11 renderTarget;
  renderTarget.numViews = numViews;
 
  for (size_t i = 0; i < numViews; ++i) {
    auto & texture = textures->textures[renderTargetViews[i].texture];
    renderTarget.texture[i] = renderTargetViews[i].texture;
 
    D3D11_TEXTURE2D_DESC textureDesc;
    texture.texture2D->GetDesc(&textureDesc);
 
    D3D11_RENDER_TARGET_VIEW_DESC renderTargetDesc = {};
 
    if (textureDesc.Format == DXGI_FORMAT_R8G8B8A8_TYPELESS) {
      renderTargetDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    } else {
      renderTargetDesc.Format = textureDesc.Format;
    }
 
    if (texture.desc.layers > 1) {
      renderTargetDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
      renderTargetDesc.Texture2DArray.FirstArraySlice = renderTargetViews[i].layerIndex;
      renderTargetDesc.Texture2DArray.ArraySize = renderTargetViews[i].numLayers;
      renderTargetDesc.Texture2DArray.MipSlice = renderTargetViews[i].levelIndex;
    }
    else if (textureDesc.SampleDesc.Count > 1) {
      renderTargetDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
    }
    else {
      renderTargetDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
      renderTargetDesc.Texture2D.MipSlice = renderTargetViews[i].levelIndex;
    }
 
    HRESULT hr = graphicsDevice->getDevice()->CreateRenderTargetView(texture.resource(), &renderTargetDesc, renderTarget.views[i].internalPointer());
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Failed to create render target: %s", direct3D11ReturnCodeAsString(hr));
      return RenderTargetHandle::InvalidHandle;
    }
  }
 
  return renderTargets.addResource(std::move(renderTarget));
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsD3D11::createDepthStencilTarget(const RenderTargetHandle /*handle*/, const DepthStencilViewDescription& textureView)
{
  auto & texture = textures->textures[textureView.texture];
 
  D3D11_TEXTURE2D_DESC textureDesc;
  texture.texture2D->GetDesc(&textureDesc);
 
  D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc = {};
 
  depthStencilViewDesc.Format = textureDesc.Format;
 
  if (textureDesc.Format == DXGI_FORMAT_R32_TYPELESS) {
    depthStencilViewDesc.Format = DXGI_FORMAT_D32_FLOAT;
  } else if (textureDesc.Format == DXGI_FORMAT_R16_TYPELESS) {
    depthStencilViewDesc.Format = DXGI_FORMAT_D16_UNORM;
  }
 
  if (texture.desc.faces == 6) {
    depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
    depthStencilViewDesc.Texture2DArray.FirstArraySlice = textureView.layerIndex;
    depthStencilViewDesc.Texture2DArray.ArraySize = textureView.numLayers;
    depthStencilViewDesc.Texture2DArray.MipSlice = textureView.levelIndex;
  } else {
    if (texture.desc.layers > 1) {
      depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
      depthStencilViewDesc.Texture2DArray.FirstArraySlice = textureView.layerIndex;
      depthStencilViewDesc.Texture2DArray.ArraySize = textureView.numLayers;
      depthStencilViewDesc.Texture2DArray.MipSlice = textureView.levelIndex;
    } else {
      depthStencilViewDesc.ViewDimension = textureDesc.SampleDesc.Count > 1 ? D3D11_DSV_DIMENSION_TEXTURE2DMS : D3D11_DSV_DIMENSION_TEXTURE2D;
    }
  }
 
  ResourcePointer<ID3D11DepthStencilView> depthStencilView;
  HRESULT hr = graphicsDevice->getDevice()->CreateDepthStencilView(texture.resource(), &depthStencilViewDesc, depthStencilView.internalPointer());
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Failed to create depth stencil target: %s", direct3D11ReturnCodeAsString(hr));
    return DepthStencilHandle::InvalidHandle;
  }
 
  return depthStencilViews.addResource(std::move(depthStencilView));
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsD3D11::createDepthStencilTarget(const RenderTargetHandle handle)
{
  ResourcePointer<ID3D11Texture2D> texture; 
  renderTargets[handle].views[0]->GetResource((ID3D11Resource **)&texture);
 
  D3D11_TEXTURE2D_DESC textureDesc;
  texture->GetDesc(&textureDesc);
 
  TextureHandle textureHandle = textures->loadTexture(nullptr,
    textureDesc.Width,
    textureDesc.Height,
    graphicsDevice->getSettings().depthFormat,
    textureDesc.SampleDesc.Count,
    TextureFlags::DepthBuffer);
 
  if (!HandleIsValid(textureHandle)) {
    LOG_ERROR(logger, "Failed to create depth stencil target: Illegal texture handle.");
    return DepthStencilHandle::InvalidHandle;
  }
 
  D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc = {};
  depthStencilViewDesc.Format = Direct3D11::Formats[(int)graphicsDevice->getSettings().depthFormat];
  depthStencilViewDesc.ViewDimension = textureDesc.SampleDesc.Count > 1 ? D3D11_DSV_DIMENSION_TEXTURE2DMS : D3D11_DSV_DIMENSION_TEXTURE2D;
 
  ResourcePointer<ID3D11DepthStencilView> depthStencilView;
  HRESULT hr = graphicsDevice->getDevice()->CreateDepthStencilView(textures->getTexture(textureHandle), &depthStencilViewDesc, depthStencilView.internalPointer());
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Failed to create depth stencil target: %s", direct3D11ReturnCodeAsString(hr));
    textures->releaseTexture(textureHandle);
    return DepthStencilHandle::InvalidHandle;
  }
 
  textures->releaseTexture(textureHandle);
 
  return depthStencilViews.addResource(std::move(depthStencilView));
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsD3D11::createDepthStencilTarget(const RenderTargetHandle, const TextureHandle textureHandle)
{
  auto & texture = this->textures->textures[textureHandle];
 
  D3D11_TEXTURE2D_DESC textureDesc;
  texture.texture2D->GetDesc(&textureDesc);
 
  D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc = {};
  depthStencilViewDesc.Format = textureDesc.Format;
 
  if (textureDesc.Format == DXGI_FORMAT_R32_TYPELESS) {
    depthStencilViewDesc.Format = DXGI_FORMAT_D32_FLOAT;
  } else if (textureDesc.Format == DXGI_FORMAT_R16_TYPELESS) {
    depthStencilViewDesc.Format = DXGI_FORMAT_D16_UNORM;
  }
 
  depthStencilViewDesc.ViewDimension = textureDesc.SampleDesc.Count > 1 ? D3D11_DSV_DIMENSION_TEXTURE2DMS : D3D11_DSV_DIMENSION_TEXTURE2D;
 
  ResourcePointer<ID3D11DepthStencilView> depthStencilView;
  HRESULT hr = graphicsDevice->getDevice()->CreateDepthStencilView(texture.resource(), &depthStencilViewDesc, depthStencilView.internalPointer());
  if(FAILED(hr)) {
    LOG_ERROR(logger, "Failed to create depth stencil target: %s", direct3D11ReturnCodeAsString(hr));
    return DepthStencilHandle::InvalidHandle;
  }
 
  return this->depthStencilViews.addResource(std::move(depthStencilView));
}
 
void Cogs::RenderTargetsD3D11::releaseDepthStencilTarget(DepthStencilHandle handle)
{
  this->depthStencilViews.removeResource(handle);
}
 
namespace
{
  Cogs::TextureFormat depthFormatFromDXGI(DXGI_FORMAT format)
  {
    switch (format) {
    case DXGI_FORMAT_D16_UNORM: return Cogs::TextureFormat::D16_UNORM;
    case DXGI_FORMAT_D24_UNORM_S8_UINT: return Cogs::TextureFormat::D24S8_UNORM;
    case DXGI_FORMAT_D32_FLOAT: return Cogs::TextureFormat::D32_FLOAT;
    default: return Cogs::TextureFormat::Unknown;
    }
  }
}
 
Cogs::RenderTargetLayout Cogs::RenderTargetsD3D11::getLayout(const RenderTargetHandle renderTargetHandle, const DepthStencilHandle depthStencilHandle)
{
  RenderTargetLayout layout;
 
  if (HandleIsValid(renderTargetHandle)) {
    const RenderTargetD3D11 & renderTarget = renderTargets[renderTargetHandle];
    layout.numColorTargets = static_cast<uint8_t>(renderTarget.numViews);
 
    for (size_t i = 0; i < renderTarget.numViews; ++i) {
      layout.colorFormats[i] = textures->textures[renderTarget.texture[i]].format;
    }
 
    if (renderTarget.numViews) {
      D3D11_TEXTURE2D_DESC textureDesc;
      textures->textures[renderTarget.texture[0]].texture2D->GetDesc(&textureDesc);
      layout.samples = static_cast<uint8_t>(textureDesc.SampleDesc.Count);
    }
  } else {
    const GraphicsDeviceSettings & settings = graphicsDevice->getSettings();
    layout.numColorTargets = 1;
    layout.colorFormats[0] = settings.colorFormat;
    layout.samples = static_cast<uint8_t>(settings.numSamples);
  }
 
  if (HandleIsValid(depthStencilHandle)) {
    D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
    ID3D11DepthStencilView * view = depthStencilViews[depthStencilHandle];
    view->GetDesc(&dsvDesc);
 
    layout.depthStencilFormat = depthFormatFromDXGI(dsvDesc.Format);
  } else if (!HandleIsValid(renderTargetHandle)) {
    layout.depthStencilFormat = graphicsDevice->getSettings().depthFormat;
  }
 
  return layout;
}
 
namespace Cogs
{
  namespace Direct3D11
  {
    D3D11_COMPARISON_FUNC DepthFunctions[] = {
      D3D11_COMPARISON_NEVER,
      D3D11_COMPARISON_LESS,
      D3D11_COMPARISON_LESS_EQUAL,
      D3D11_COMPARISON_EQUAL,
      D3D11_COMPARISON_GREATER_EQUAL,
      D3D11_COMPARISON_GREATER,
      D3D11_COMPARISON_NOT_EQUAL,
      D3D11_COMPARISON_ALWAYS
    };
  }
}
 
Cogs::DepthStencilStateHandle Cogs::RenderTargetsD3D11::loadDepthStencilState(const DepthStencilState & depthStencilState)
{
  D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
 
  // Depth test parameters
  depthStencilDesc.DepthEnable = depthStencilState.depthEnabled;
  depthStencilDesc.DepthWriteMask = depthStencilState.writeEnabled ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO;
  depthStencilDesc.DepthFunc = Direct3D11::DepthFunctions[depthStencilState.depthFunction];
 
  // Stencil test parameters
  depthStencilDesc.StencilEnable = false;
  depthStencilDesc.StencilReadMask = 0xFF;
  depthStencilDesc.StencilWriteMask = 0xFF;
 
  // Stencil operations if pixel is front-facing
  depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
  depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
  depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
  depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
 
  // Stencil operations if pixel is back-facing
  depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
  depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
  depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
  depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
 
  // Create depth stencil state
  ResourcePointer<ID3D11DepthStencilState> d3dDepthStencilState;
  HRESULT hr = graphicsDevice->getDevice()->CreateDepthStencilState(&depthStencilDesc, d3dDepthStencilState.internalPointer());
 
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Failed to load depth stencil state: %s", direct3D11ReturnCodeAsString(hr));
    return DepthStencilStateHandle::InvalidHandle;
  }
 
  return this->depthStencilStates.addResource(std::move(d3dDepthStencilState));
}
 
void Cogs::RenderTargetsD3D11::releaseDepthStencilState(DepthStencilStateHandle handle)
{
  this->depthStencilStates.removeResource(handle);
}
 
namespace Cogs
{
  namespace Direct3D11
  {
    const D3D11_CULL_MODE CullModes[] = {
      D3D11_CULL_FRONT,
      D3D11_CULL_BACK,
      D3D11_CULL_NONE
    };
  }
}
 
Cogs::RasterizerStateHandle Cogs::RenderTargetsD3D11::loadRasterizerState(const RasterizerState & rasterizerState)
{
  D3D11_RASTERIZER_DESC rasterizerDesc = {};
 
  rasterizerDesc.FillMode = rasterizerState.wireFrame ? D3D11_FILL_WIREFRAME : D3D11_FILL_SOLID;
  rasterizerDesc.CullMode = Direct3D11::CullModes[rasterizerState.cullMode];
 
  rasterizerDesc.AntialiasedLineEnable = true;
  rasterizerDesc.FrontCounterClockwise = rasterizerState.frontCounterClockwise;
  rasterizerDesc.MultisampleEnable = rasterizerState.wireFrame ? rasterizerState.multiSample : false;
  rasterizerDesc.DepthClipEnable = rasterizerState.noDepthClip == false;
 
  rasterizerDesc.DepthBias = static_cast<INT>(rasterizerState.depthBias);
  rasterizerDesc.SlopeScaledDepthBias = rasterizerState.slopeScaledDepthBias;
  rasterizerDesc.DepthBiasClamp = rasterizerState.depthBiasClamp;
  rasterizerDesc.ScissorEnable = rasterizerState.scissor;
 
  ResourcePointer<ID3D11RasterizerState> d3dRasterizerState;
  HRESULT hr = graphicsDevice->getDevice()->CreateRasterizerState(&rasterizerDesc, d3dRasterizerState.internalPointer());
 
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Failed to load rasterizer state: %s", direct3D11ReturnCodeAsString(hr));
    return RasterizerStateHandle::InvalidHandle;
  }
 
  return this->rasterizerStates.addResource(std::move(d3dRasterizerState));
}
 
void Cogs::RenderTargetsD3D11::releaseRasterizerState(RasterizerStateHandle handle)
{
  this->rasterizerStates.removeResource(handle);
}
 
Cogs::BlendStateHandle Cogs::RenderTargetsD3D11::loadBlendState(const BlendState & blendState)
{
  return loadBlendState(&blendState, &blendState, 1, BlendFlags::None);
}
 
Cogs::BlendStateHandle Cogs::RenderTargetsD3D11::loadBlendState(const BlendState & blendStateColor, const BlendState& blendStateAlpha)
{
  return loadBlendState(&blendStateColor, &blendStateAlpha, 1, BlendFlags::None);
}
 
Cogs::BlendStateHandle Cogs::RenderTargetsD3D11::loadBlendState(const BlendState & blendStateColor, const BlendState& blendStateAlpha, const BlendFlags flags)
{
  return loadBlendState(&blendStateColor, &blendStateAlpha, 1, flags);
}
 
Cogs::BlendStateHandle Cogs::RenderTargetsD3D11::loadBlendState(const BlendState * blendStatesColor, const BlendState * blendStatesAlpha, const uint32_t numBlendStates, const BlendFlags flags)
{
  if (!blendStatesColor || !numBlendStates) return BlendStateHandle::InvalidHandle;
 
  D3D11_BLEND_DESC blendDesc = {};
  blendDesc.AlphaToCoverageEnable = ((flags & BlendFlags::AlphaToCoverage) != BlendFlags::None) ? TRUE : FALSE;
  blendDesc.IndependentBlendEnable = ((flags & BlendFlags::IndependentBlend) != BlendFlags::None) ? TRUE : FALSE;
 
  const BlendState defaultBlendState = BlendState::DefaultState();
 
  const uint32_t numStates = blendDesc.IndependentBlendEnable ? 8 : 1;
  for (uint32_t i = 0; i < numStates; ++i) {
    const Cogs::BlendState& blendStateColor = i < numBlendStates ? blendStatesColor[i] : defaultBlendState;
    const Cogs::BlendState& blendStateAlpha = blendStatesAlpha ? (i < numBlendStates ? blendStatesAlpha[i] : defaultBlendState) : defaultBlendState;
 
    blendDesc.RenderTarget[i].BlendEnable           = blendStateColor.enabled;
    blendDesc.RenderTarget[i].SrcBlend              = Blends[size_t(blendStateColor.sourceBlend)];
    blendDesc.RenderTarget[i].DestBlend             = Blends[size_t(blendStateColor.destinationBlend)];
    blendDesc.RenderTarget[i].BlendOp               = BlendOperations[size_t(blendStateColor.operation)];
    blendDesc.RenderTarget[i].SrcBlendAlpha         = blendStateAlpha.enabled ? Blends[size_t(blendStateAlpha.sourceBlend)]        : D3D11_BLEND_ZERO;
    blendDesc.RenderTarget[i].DestBlendAlpha        = blendStateAlpha.enabled ? Blends[size_t(blendStateAlpha.destinationBlend)]   : D3D11_BLEND_ONE;
    blendDesc.RenderTarget[i].BlendOpAlpha          = blendStateAlpha.enabled ? BlendOperations[size_t(blendStateAlpha.operation)] : D3D11_BLEND_OP_ADD;
    blendDesc.RenderTarget[i].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
  }
 
  ResourcePointer<ID3D11BlendState> d3dBlendState;
  HRESULT hr = graphicsDevice->getDevice()->CreateBlendState(&blendDesc, d3dBlendState.internalPointer());
 
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Failed to load blend state: %s", direct3D11ReturnCodeAsString(hr));
    return BlendStateHandle::InvalidHandle;
  }
 
  return this->blendStates.addResource(std::move(d3dBlendState));
}
 
void Cogs::RenderTargetsD3D11::releaseBlendState(BlendStateHandle handle)
{
  this->blendStates.removeResource(handle);
}
 
void Cogs::RenderTargetsD3D11::releaseResources()
{
  this->depthStencilStates.clear();
  this->rasterizerStates.clear();
  this->blendStates.clear();
 
  this->depthStencilViews.clear();
  this->renderTargets.clear();
}