RenderTargetsD3D12.cpp

#include "RenderTargetsD3D12.h"
 
#include "TexturesD3D12.h"
#include "FormatsD3D12.h"
#include "GraphicsDeviceD3D12.h"
 
namespace {
 
  D3D12_BLEND Blends[] = {
    D3D12_BLEND_ZERO,
    D3D12_BLEND_ONE,
    D3D12_BLEND_SRC_COLOR,
    D3D12_BLEND_INV_SRC_COLOR,
    D3D12_BLEND_SRC_ALPHA,
    D3D12_BLEND_INV_SRC_ALPHA,
    D3D12_BLEND_DEST_ALPHA,
    D3D12_BLEND_INV_DEST_ALPHA,
    D3D12_BLEND_DEST_COLOR,
    D3D12_BLEND_INV_DEST_COLOR,
    D3D12_BLEND_SRC_ALPHA_SAT,
    D3D12_BLEND_BLEND_FACTOR,
    D3D12_BLEND_INV_BLEND_FACTOR,
  };
  static_assert(sizeof(Blends) == sizeof(Blends[0]) * size_t(Cogs::BlendState::Blend::Count));
 
  D3D12_BLEND_OP BlendOperations[] = {
    D3D12_BLEND_OP_ADD,
    D3D12_BLEND_OP_SUBTRACT,
    D3D12_BLEND_OP_REV_SUBTRACT,
    D3D12_BLEND_OP_MIN,
    D3D12_BLEND_OP_MAX
  };
  static_assert(sizeof(BlendOperations) == sizeof(BlendOperations[0]) * size_t(Cogs::BlendState::BlendOperation::Count));
 
 
  D3D12_BLEND BlendOptions[] = {
      D3D12_BLEND_ZERO,
      D3D12_BLEND_ONE,
      D3D12_BLEND_SRC_COLOR,
      D3D12_BLEND_INV_SRC_COLOR,
      D3D12_BLEND_SRC_ALPHA,
      D3D12_BLEND_INV_SRC_ALPHA,
      D3D12_BLEND_DEST_ALPHA,
      D3D12_BLEND_INV_DEST_ALPHA,
    };
}
 
 
HRESULT Cogs::RenderTargetsD3D12::initialize(struct GraphicsDeviceD3D12 * graphicsDevice)
{
  this->graphicsDevice = graphicsDevice;
  device = graphicsDevice->device;
  textures = &graphicsDevice->textures;
 
  rtvPool.initialize(device, 256, D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
  dsvPool.initialize(device, 256, D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
 
  return S_OK;
}
 
Cogs::RenderTargetHandle Cogs::RenderTargetsD3D12::createRenderTarget(ID3D12Resource * texture)
{
  auto textureDesc = texture->GetDesc();
 
  RenderTargetD3D12 renderTarget{};
  renderTarget.descriptor[0] = rtvPool.allocate();
  renderTarget.descriptorHandle[0] = renderTarget.descriptor[0]->handle;
  renderTarget.numViews = 1;
  renderTarget.numSamples = textureDesc.SampleDesc.Count;
 
  renderTarget.viewDesc[0].Format = textureDesc.Format;
  renderTarget.viewDesc[0].ViewDimension = textureDesc.SampleDesc.Count > 1 ? D3D12_RTV_DIMENSION_TEXTURE2DMS : D3D12_RTV_DIMENSION_TEXTURE2D;
 
  device->CreateRenderTargetView(texture, renderTarget.viewDesc, renderTarget.descriptorHandle[0]);
 
  renderTarget.resource = texture;
 
  return renderTargets.addResource(renderTarget);
}
 
Cogs::RenderTargetHandle Cogs::RenderTargetsD3D12::createRenderTarget(const RenderTargetViewDescription * renderTargetViews, const size_t numViews)
{
  RenderTargetD3D12 renderTarget{};
  renderTarget.numViews = static_cast<uint8_t>(numViews);
 
  for (size_t i = 0; i < numViews; ++i) {
    renderTarget.descriptor[i] = rtvPool.allocate();
    renderTarget.descriptorHandle[i] = renderTarget.descriptor[i]->handle;
 
    const auto & texture = textures->textures[renderTargetViews[i].texture];
 
    renderTarget.textures[i] = renderTargetViews[i].texture;
 
    renderTarget.viewDesc[i].Format = Direct3D12::Formats[(int)texture.format];
    renderTarget.viewDesc[i].ViewDimension = texture.numSamples > 1 ? D3D12_RTV_DIMENSION_TEXTURE2DMS : D3D12_RTV_DIMENSION_TEXTURE2D;
 
    if (texture.desc.layers == 1) {
      renderTarget.viewDesc[i].ViewDimension = texture.numSamples > 1 ? D3D12_RTV_DIMENSION_TEXTURE2DMS : D3D12_RTV_DIMENSION_TEXTURE2D;
      renderTarget.viewDesc[i].Texture2D.MipSlice = 0;
    } else {
      renderTarget.viewDesc[i].ViewDimension = texture.numSamples > 1 ? D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY : D3D12_RTV_DIMENSION_TEXTURE2DARRAY;
      renderTarget.viewDesc[i].Texture2DArray.ArraySize = 1;
      renderTarget.viewDesc[i].Texture2DArray.FirstArraySlice = renderTargetViews[i].layerIndex;
      renderTarget.viewDesc[i].Texture2DArray.MipSlice = renderTargetViews[i].levelIndex;
    }
 
    device->CreateRenderTargetView(texture.resource, &renderTarget.viewDesc[i], renderTarget.descriptorHandle[i]);
  }
 
  return renderTargets.addResource(renderTarget);
}
 
void Cogs::RenderTargetsD3D12::releaseRenderTarget(RenderTargetHandle handle)
{
  auto & renderTarget = renderTargets[handle];
 
  for (size_t i = 0; i < renderTarget.numViews; ++i) {
    graphicsDevice->context.currentFrameResources->orphanedRTVs.push_back(OrphanRTVDescriptor{ renderTarget.descriptor[i] });
  }
 
  renderTargets.removeResource(handle);
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsD3D12::createDepthStencilTarget(const RenderTargetHandle handle)
{
  auto & renderTarget = renderTargets[handle];
  auto & renderTexture = textures->textures[renderTarget.textures[0]];
  
  auto depthTextureHandle = textures->loadTexture(nullptr, renderTexture.width, renderTexture.height, TextureFormat::R32_TYPELESS, renderTexture.numSamples, TextureFlags::DepthBuffer);
 
  return createDepthStencilTarget(handle, depthTextureHandle);
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsD3D12::createDepthStencilTarget(const RenderTargetHandle handle, const TextureHandle textureHandle)
{
  DepthStencilViewDescription desc = {};
  desc.texture = textureHandle;
  desc.numLayers = 1;
 
  return createDepthStencilTarget(handle, desc);
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsD3D12::createDepthStencilTarget(const RenderTargetHandle handle, const DepthStencilViewDescription & depthStencilView)
{
  auto & texture = textures->textures[depthStencilView.texture];
 
  auto textureDesc = texture.resource->GetDesc();
 
  DepthStencilTargetD3D12 dsTarget{};
  dsTarget.descriptor = dsvPool.allocate();
  dsTarget.descriptorHandle = dsTarget.descriptor->handle;
 
  dsTarget.viewDesc.Format = textureDesc.Format == DXGI_FORMAT_R32_TYPELESS ? DXGI_FORMAT_D32_FLOAT : textureDesc.Format;
  if (texture.desc.layers == 1) {
    dsTarget.viewDesc.ViewDimension = textureDesc.SampleDesc.Count > 1 ? D3D12_DSV_DIMENSION_TEXTURE2DMS : D3D12_DSV_DIMENSION_TEXTURE2D;
    dsTarget.viewDesc.Texture2D.MipSlice = 0;
  } else {
    dsTarget.viewDesc.ViewDimension = textureDesc.SampleDesc.Count > 1 ? D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY : D3D12_DSV_DIMENSION_TEXTURE2DARRAY;
    dsTarget.viewDesc.Texture2DArray.ArraySize = 1;
    dsTarget.viewDesc.Texture2DArray.FirstArraySlice = depthStencilView.layerIndex;
    dsTarget.viewDesc.Texture2DArray.MipSlice = depthStencilView.levelIndex;
  }
 
  dsTarget.texture = depthStencilView.texture;
 
  device->CreateDepthStencilView(texture.resource, &dsTarget.viewDesc, dsTarget.descriptorHandle);
 
  return depthStencilTargets.addResource(dsTarget);
}
 
void Cogs::RenderTargetsD3D12::releaseDepthStencilTarget(DepthStencilHandle handle)
{
  dsvPool.deallocate(depthStencilTargets[handle].descriptor);
 
  depthStencilTargets.removeResource(handle);
}
 
namespace Cogs
{
  namespace Direct3D12
  {
    D3D12_COMPARISON_FUNC DepthFunctions[] = {
      D3D12_COMPARISON_FUNC_NEVER,
      D3D12_COMPARISON_FUNC_LESS,
      D3D12_COMPARISON_FUNC_LESS_EQUAL,
      D3D12_COMPARISON_FUNC_EQUAL,
      D3D12_COMPARISON_FUNC_GREATER_EQUAL,
      D3D12_COMPARISON_FUNC_GREATER,
      D3D12_COMPARISON_FUNC_NOT_EQUAL,
      D3D12_COMPARISON_FUNC_ALWAYS
    };
  }
}
 
Cogs::DepthStencilStateHandle Cogs::RenderTargetsD3D12::loadDepthStencilState(const DepthStencilState & depthStencilState)
{
  DepthStencilStateD3D12 depthStencilStateD3d12;
 
  // Depth test parameters
  depthStencilStateD3d12.depthStencilDesc.DepthEnable = depthStencilState.depthEnabled;
  depthStencilStateD3d12.depthStencilDesc.DepthWriteMask = depthStencilState.writeEnabled ? D3D12_DEPTH_WRITE_MASK_ALL : D3D12_DEPTH_WRITE_MASK_ZERO;
  depthStencilStateD3d12.depthStencilDesc.DepthFunc = Direct3D12::DepthFunctions[depthStencilState.depthFunction];
 
  // Stencil test parameters
  depthStencilStateD3d12.depthStencilDesc.StencilEnable = false;
  depthStencilStateD3d12.depthStencilDesc.StencilReadMask = 0xFF;
  depthStencilStateD3d12.depthStencilDesc.StencilWriteMask = 0xFF;
 
  // Stencil operations if pixel is front-facing
  depthStencilStateD3d12.depthStencilDesc.FrontFace.StencilFailOp = D3D12_STENCIL_OP_KEEP;
  depthStencilStateD3d12.depthStencilDesc.FrontFace.StencilDepthFailOp = D3D12_STENCIL_OP_INCR;
  depthStencilStateD3d12.depthStencilDesc.FrontFace.StencilPassOp = D3D12_STENCIL_OP_KEEP;
  depthStencilStateD3d12.depthStencilDesc.FrontFace.StencilFunc = D3D12_COMPARISON_FUNC_ALWAYS;
 
  // Stencil operations if pixel is back-facing
  depthStencilStateD3d12.depthStencilDesc.BackFace.StencilFailOp = D3D12_STENCIL_OP_KEEP;
  depthStencilStateD3d12.depthStencilDesc.BackFace.StencilDepthFailOp = D3D12_STENCIL_OP_DECR;
  depthStencilStateD3d12.depthStencilDesc.BackFace.StencilPassOp = D3D12_STENCIL_OP_KEEP;
  depthStencilStateD3d12.depthStencilDesc.BackFace.StencilFunc = D3D12_COMPARISON_FUNC_ALWAYS;
 
  return depthStencilStates.addResource(depthStencilStateD3d12);
}
 
void Cogs::RenderTargetsD3D12::releaseDepthStencilState(DepthStencilStateHandle handle)
{
  depthStencilStates.removeResource(handle);
}
 
namespace Cogs
{
  namespace Direct3D11
  {
    const D3D12_CULL_MODE CullModes[] = {
      D3D12_CULL_MODE_FRONT,
      D3D12_CULL_MODE_BACK,
      D3D12_CULL_MODE_NONE
    };
  }
}
 
Cogs::RasterizerStateHandle Cogs::RenderTargetsD3D12::loadRasterizerState(const RasterizerState & rasterizerState)
{
  RasterizerStateD3D12 rasterizerStateD3d12;
  rasterizerStateD3d12.rasterizerDesc = {};
 
  rasterizerStateD3d12.rasterizerDesc.FillMode = rasterizerState.wireFrame ? D3D12_FILL_MODE_WIREFRAME : D3D12_FILL_MODE_SOLID;
  rasterizerStateD3d12.rasterizerDesc.CullMode = Direct3D11::CullModes[rasterizerState.cullMode];
 
  rasterizerStateD3d12.rasterizerDesc.AntialiasedLineEnable = true;
  rasterizerStateD3d12.rasterizerDesc.FrontCounterClockwise = rasterizerState.frontCounterClockwise;
  rasterizerStateD3d12.rasterizerDesc.MultisampleEnable = rasterizerState.multiSample;
  rasterizerStateD3d12.rasterizerDesc.DepthClipEnable = true;
 
  rasterizerStateD3d12.rasterizerDesc.DepthBias = static_cast<INT>(rasterizerState.depthBias);
  rasterizerStateD3d12.rasterizerDesc.SlopeScaledDepthBias = rasterizerState.slopeScaledDepthBias;
  rasterizerStateD3d12.rasterizerDesc.DepthBiasClamp = rasterizerState.depthBiasClamp;
 
  return rasterizerStates.addResource(rasterizerStateD3d12);
}
 
void Cogs::RenderTargetsD3D12::releaseRasterizerState(RasterizerStateHandle handle)
{
  rasterizerStates.removeResource(handle);
}
 
 
Cogs::BlendStateHandle Cogs::RenderTargetsD3D12::loadBlendState(const BlendState& blendState)
{
  return loadBlendState(&blendState, &blendState, 1, BlendFlags::None);
}
 
Cogs::BlendStateHandle Cogs::RenderTargetsD3D12::loadBlendState(const BlendState& blendStateColor, const BlendState& blendStateAlpha)
{
  return loadBlendState(&blendStateColor, &blendStateAlpha, 1, BlendFlags::None);
}
 
Cogs::BlendStateHandle Cogs::RenderTargetsD3D12::loadBlendState(const BlendState& blendStateColor, const BlendState& blendStateAlpha, const uint32_t flags)
{
  return loadBlendState(&blendStateColor, &blendStateAlpha, 1, flags);
}
 
Cogs::BlendStateHandle Cogs::RenderTargetsD3D12::loadBlendState(const BlendState* blendStatesColor, const BlendState* blendStatesAlpha, const uint32_t numBlendStates, const uint32_t flags)
{
  if (!blendStatesColor || !numBlendStates) return BlendStateHandle::InvalidHandle;
 
  BlendStateD3D12 blendStateD3d12 = {};
  blendStateD3d12.blendDesc = {};
 
  blendStateD3d12.blendDesc.AlphaToCoverageEnable = (flags & BlendFlags::AlphaToCoverage) != 0 ? TRUE : FALSE;
  blendStateD3d12.blendDesc.IndependentBlendEnable = (flags & BlendFlags::IndependentBlend) != 0 ? TRUE : FALSE;
 
  const BlendState defaultBlendState = BlendState::DefaultState();
 
  const uint32_t numStates = blendStateD3d12.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;
 
    blendStateD3d12.blendDesc.RenderTarget[i].BlendEnable = blendStateColor.enabled;
    blendStateD3d12.blendDesc.RenderTarget[i].SrcBlend = Blends[size_t(blendStateColor.sourceBlend)];
    blendStateD3d12.blendDesc.RenderTarget[i].DestBlend = Blends[size_t(blendStateColor.destinationBlend)];
    blendStateD3d12.blendDesc.RenderTarget[i].BlendOp = BlendOperations[size_t(blendStateColor.operation)];
    blendStateD3d12.blendDesc.RenderTarget[i].SrcBlendAlpha = blendStateAlpha.enabled ? Blends[size_t(blendStateAlpha.sourceBlend)] : D3D12_BLEND_ZERO;
    blendStateD3d12.blendDesc.RenderTarget[i].DestBlendAlpha = blendStateAlpha.enabled ? Blends[size_t(blendStateAlpha.destinationBlend)] : D3D12_BLEND_ONE;
    blendStateD3d12.blendDesc.RenderTarget[i].BlendOpAlpha = blendStateAlpha.enabled ? BlendOperations[size_t(blendStateAlpha.operation)] : D3D12_BLEND_OP_ADD;
    blendStateD3d12.blendDesc.RenderTarget[i].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
  }
  return blendStates.addResource(blendStateD3d12);
}
 
void Cogs::RenderTargetsD3D12::releaseBlendState(BlendStateHandle handle)
{
  blendStates.removeResource(handle);
}
 
void Cogs::RenderTargetsD3D12::releaseResources()
{
  // Noop
}