GraphicsDeviceD3D12.cpp

#include "GraphicsDeviceD3D12.h"
 
#include "BuffersD3D12.h"
#include "TexturesD3D12.h"
#include "ContextD3D12.h"
#include "EffectsD3D12.h"
#include "FormatsD3D12.h"
#include "Foundation/Platform/WindowData.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GraphicsDeviceD3D12");
}
 
Cogs::GraphicsDeviceD3D12::GraphicsDeviceD3D12(RenderingAllocatorInfo *) :
  verticalSync(false),
  width(1260),
  height(720)
{
  
}
 
Cogs::GraphicsDeviceD3D12::~GraphicsDeviceD3D12()
{
  context.destroy();
 
  // Shared resources are freed by unique_ptr destructor.
}
 
bool Cogs::GraphicsDeviceD3D12::initialize()
{
  if (settings.ioHandler) effects.setIOHandler(settings.ioHandler);
 
  return SUCCEEDED(this->initializeDevice());
}
 
HRESULT Cogs::GraphicsDeviceD3D12::initializeDevice()
{
  HRESULT hr = initializeDeviceAndSwapChain();
 
  if (FAILED(hr)) {
    return hr;
  }
 
  this->capabilities.initialize(device);
  syncObjects.setDevice(device);
  this->buffers.initialize(this);
  this->textures.setDevice(this->device);
  this->effects.setDevice(this->device, this);
  this->renderTargets.initialize(this);
 
  this->context.initialize(this);
 
  hr = this->createRenderTargetView();
 
  if (FAILED(hr)) {
    return hr;
  }
 
  hr = this->createDepthStencilView();
 
  waitForPreviousFrame();
 
  return hr;
}
 
HRESULT Cogs::GraphicsDeviceD3D12::initializeDeviceAndSwapChain()
{
  HRESULT hr = S_OK;
 
  {
    if (isDebug() || ((settings.flags & GraphicsDeviceFlags::Debug) == GraphicsDeviceFlags::Debug)) {
      ResourcePointer<ID3D12Debug> debugController;
      hr = D3D12GetDebugInterface(IID_PPV_ARGS(debugController.internalPointer()));
 
      if (FAILED(hr) || !debugController) {
        LOG_WARNING(logger, "Failed to get debug interface.");
      } else {
        debugController->EnableDebugLayer();
      }
    }
  }
 
  D3D_DRIVER_TYPE driverTypes[] = {
    D3D_DRIVER_TYPE_HARDWARE,
    D3D_DRIVER_TYPE_WARP,
    D3D_DRIVER_TYPE_REFERENCE,
  };
 
  UINT numDriverTypes = sizeof(driverTypes) / sizeof(driverTypes[0]);
 
  DXGI_SWAP_CHAIN_DESC swapChainDesc{};
  swapChainDesc.BufferCount = numSwapBufs;
  auto format = Direct3D12::Formats[(int)settings.colorFormat];
  if (format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) {
    swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
  } else {
    swapChainDesc.BufferDesc.Format = format;
  }
  swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
  swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
  swapChainDesc.OutputWindow = settings.windowData->windowHandle;
  swapChainDesc.SampleDesc.Count = 1;
  swapChainDesc.Windowed = TRUE;
 
  D3D_DRIVER_TYPE driverType;
 
  for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++) {
    driverType = driverTypes[driverTypeIndex];
 
    hr = D3D12CreateDevice(
      nullptr,
      D3D_FEATURE_LEVEL_12_0,
      IID_PPV_ARGS(device.internalPointer())
    );
 
    ResourcePointer<ID3D12InfoQueue> infoQueue;
    device->QueryInterface<ID3D12InfoQueue>(infoQueue.internalPointer());
 
    if (infoQueue) {
      infoQueue->SetMuteDebugOutput(false);
      infoQueue->SetBreakOnCategory(D3D12_MESSAGE_CATEGORY_CLEANUP, true);
    }
 
    if (SUCCEEDED(hr)) {
      break;
    }
  }
 
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Could not create device.");
    return hr;
  }
 
  D3D12_FEATURE_DATA_D3D12_OPTIONS featureData;
  hr = device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &featureData, sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS));
 
  if (FAILED(hr) || featureData.ResourceBindingTier == D3D12_RESOURCE_BINDING_TIER_1) {
    LOG_ERROR(logger, "Resource binding tier 1 not supported. Check hardware or drivers installed.");
 
    return E_FAIL;
  }
 
  D3D12_COMMAND_QUEUE_DESC queueDesc{};
  queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
  queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
 
  hr = device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(commandQueue.internalPointer()));
 
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Could not create command queue.");
    return hr;
  }
 
  {
    ResourcePointer<IDXGIFactory> dxgiFactory;
 
    hr = CreateDXGIFactory1(IID_PPV_ARGS(dxgiFactory.internalPointer()));
 
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Could not create DXGI factory.");
      return hr;
    }
 
    hr = dxgiFactory->CreateSwapChain(
      commandQueue, // Swap chain needs the queue so it can force a flush on it
      &swapChainDesc,
      swapChain.internalPointer()
    );
 
    if (FAILED(hr)) {
      LOG_ERROR(logger, "Could not create swap chain.");
      return hr;
    }
  }
 
  device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(deviceFence.internalPointer()));
  currentFence = 1;
 
  eventHandle = CreateEventEx(nullptr, FALSE, FALSE, EVENT_ALL_ACCESS);
 
  return hr;
}
 
 
 
HRESULT Cogs::GraphicsDeviceD3D12::initializeDeviceShared()
{
  LOG_ERROR(logger, "Shared surface support not enabled. Enable D3D9 shared surface support.");
 
  return E_FAIL;
}
 
HRESULT Cogs::GraphicsDeviceD3D12::resizeSharedSurfaces()
{
  return E_FAIL;
}
 
HRESULT Cogs::GraphicsDeviceD3D12::createRenderTargetView()
{
  if (settings.numSamples > 1) {
    if (HandleIsValid(renderTarget[0])) {
      renderTargets.releaseRenderTarget(renderTarget[0]);
      renderTarget[0] = RenderTargetHandle::NoHandle;
    }
 
    if (multisampleBackBuffer) {
      context.currentFrameResources->orphanedResources.push_back(multisampleBackBuffer);
      
      multisampleBackBuffer = {};
    }
 
    D3D12_RESOURCE_DESC textureDesc;
    textureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
    textureDesc.DepthOrArraySize = static_cast<UINT16>(1);
    textureDesc.Alignment = 0;
    textureDesc.Width = width;
    textureDesc.Height = height;
    textureDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    textureDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
    textureDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
    textureDesc.MipLevels = static_cast<UINT16>(1);
    textureDesc.SampleDesc.Count = settings.numSamples;
    textureDesc.SampleDesc.Quality = 0;
 
    if (FAILED(device->CreateCommittedResource(
      &defaultHeapProperties,
      D3D12_HEAP_FLAG_NONE,
      &textureDesc,
      D3D12_RESOURCE_STATE_COMMON,
      nullptr,
      IID_PPV_ARGS(multisampleBackBuffer.internalPointer())))) {
      return E_FAIL;
    }
 
    multisampleBackBuffer->AddRef();
  }
 
  if (multisampleBackBuffer) {
    renderTarget[0] = renderTargets.createRenderTarget(multisampleBackBuffer);
 
    for (int i = 1; i < numSwapBufs; ++i) {
      renderTarget[i] = renderTarget[0];
    }
  } else {
    for (int i = 0; i < numSwapBufs; ++i) {
      ResourcePointer<ID3D12Resource> resource;
      swapChain->GetBuffer(i, IID_PPV_ARGS(resource.internalPointer()));
 
      renderTarget[i] = renderTargets.createRenderTarget(resource);
    }
  }
 
  return S_OK;
}
 
HRESULT Cogs::GraphicsDeviceD3D12::createDepthStencilView()
{
  if (HandleIsValid(depthTarget)) {
    renderTargets.releaseDepthStencilTarget(depthTarget);
    textures.releaseTexture(depthTexture);
  }
 
  TextureFormat textureFormat = settings.depthFormat;
  depthTexture = textures.loadTexture(nullptr, width, height, textureFormat, settings.numSamples, TextureFlags::DepthBuffer);
  
  depthTarget = renderTargets.createDepthStencilTarget(renderTarget[0], depthTexture);
 
  context.defaultDepthStencil = depthTarget;
  
  return S_OK;
}
 
void Cogs::GraphicsDeviceD3D12::beginFrame()
{
  auto currentRenderTarget = this->renderTarget[indexLastSwapBuf];
  auto & renderTarget = renderTargets.renderTargets[currentRenderTarget];
  context.defaultRenderTarget = currentRenderTarget;
 
  context.updateFrameResources();
 
  setResourceBarrier(context.commandList, renderTarget.resource, multisampleBackBuffer ? D3D12_RESOURCE_STATE_RESOLVE_SOURCE : D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET);
 
  context.beginFrame();
}
 
void Cogs::GraphicsDeviceD3D12::endFrame(uint32_t syncInterval, uint32_t presentFlags)
{
  ID3D12Resource * backBuffer;
  swapChain->GetBuffer(indexLastSwapBuf, IID_PPV_ARGS(&backBuffer));
 
  if (settings.numSamples > 1) {
    auto & renderTarget = renderTargets.renderTargets[this->renderTarget[indexLastSwapBuf]];
 
    setResourceBarrier(context.commandList, renderTarget.resource, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_RESOLVE_SOURCE);
    setResourceBarrier(context.commandList, backBuffer, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RESOLVE_DEST);
 
    context.commandList->ResolveSubresource(backBuffer, 0, renderTarget.resource, 0, DXGI_FORMAT_R8G8B8A8_UNORM);
 
    setResourceBarrier(context.commandList, backBuffer, D3D12_RESOURCE_STATE_RESOLVE_DEST, D3D12_RESOURCE_STATE_PRESENT);
  } else {
    setResourceBarrier(context.commandList, backBuffer, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT);
  }
 
  context.endFrame();
 
  swapChain->Present(verticalSync ? 1 : 0, 0);
 
  indexLastSwapBuf = (1 + indexLastSwapBuf) % numSwapBufs;
}
 
void Cogs::GraphicsDeviceD3D12::waitForPreviousFrame()
{
  const UINT64 fence = currentFence;
  commandQueue->Signal(deviceFence, fence);
  currentFence++;
 
  if (deviceFence->GetCompletedValue() < fence)
  {
    deviceFence->SetEventOnCompletion(fence, eventHandle);
    WaitForSingleObject(eventHandle, INFINITE);
  }
}
 
void Cogs::GraphicsDeviceD3D12::setSize(int width, int height)
{
  if (width == this->width && height == this->height) return;
 
  this->width = width;
  this->height = height;
 
  renderTargets.releaseDepthStencilTarget(depthTarget);
  textures.releaseTexture(depthTexture);
  depthTarget = DepthStencilHandle::InvalidHandle;
 
  if (settings.numSamples == 1) {
    for (int i = 0; i < numSwapBufs; ++i) {
      renderTargets.releaseRenderTarget(renderTarget[i]);
      renderTarget[i] = RenderTargetHandle::InvalidHandle;
    }
  }
 
  swapChain->ResizeBuffers(numSwapBufs, width, height, DXGI_FORMAT_R8G8B8A8_UNORM, 0);
 
  createRenderTargetView();
  createDepthStencilView();
}
 
bool Cogs::GraphicsDeviceD3D12::getSize(int& w, int& h) const
{
  w = this->width;
  h = this->height;
  return true;
}
 
 
void Cogs::GraphicsDeviceD3D12::waitForCommandSync()
{
 
}
 
void Cogs::GraphicsDeviceD3D12::releaseResources()
{
  /*this->effects.releaseResources();
  this->renderTargets.releaseResources();
  this->textures.releaseResources();
  this->buffers.releaseResources();*/
}