GraphicsDeviceD3D11.cpp

#include "GraphicsDeviceD3D11.h"
 
#include "BuffersD3D11.h"
#include "TexturesD3D11.h"
#include "ContextD3D11.h"
#include "EffectsD3D11.h"
#include "FormatsD3D11.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/Unicode.h"
#include "Foundation/Platform/WindowData.h"
 
#include <atomic>
 
namespace {
  enum {
    ENV_COGS_USE_DEBUG_LAYER = 0,
    ENV_COGS_USE_WARP,
    ENV_COGS_USE_REF,
    ENV_COGS_USE_DX11_0,
    ENV_N
  };
 
  const char* env_keys[ENV_N] {
    "COGS_USE_DEBUG_LAYER",
    "COGS_USE_WARP",
    "COGS_USE_REF",
    "COGS_USE_DX11_0"
  };
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GraphicsDeviceD3D11");
}
 
#ifdef COGS_RENDERING_D3D9SUPPORT
#include "d3d9.h"
 
namespace Cogs {
  struct SharedResources {
    ResourcePointer<IDirect3D9Ex> d3D9Interface;
    ResourcePointer<IDirect3DDevice9Ex> d3d9Device;
    // The shared handle of the D3D resource.
    HANDLE sharedHandle = 0;
    // Shared surface, pulled through the shared texture.
    ResourcePointer<IDirect3DSurface9> sharedSurface;
  };
}
#endif
 
namespace Cogs {
  struct ResourceAllocator : public Memory::Allocator {
    ResourceAllocator(Allocator* baseAllocator) : baseAllocator(baseAllocator ? baseAllocator : defaultAllocator()) {
    }
 
    ~ResourceAllocator() {
      assert(!memorySize && "Rendering resource memory leaked.");
    }
 
    void* allocate(size_t size, size_t alignment, MemBlockType type = MemBlockType::Block) override {
      memorySize += size;
 
      return baseAllocator->allocate(size, alignment, type);
    }
 
    void deallocate(void* ptr, size_t size, MemBlockType type = MemBlockType::Block) override {
      memorySize -= size;
      baseAllocator->deallocate(ptr, size, type);
    }
 
    Memory::Allocator* baseAllocator;
    std::atomic<size_t> memorySize = 0;
  };
}
 
Cogs::GraphicsDeviceD3D11::GraphicsDeviceD3D11(RenderingAllocatorInfo * allocateInfo) :
  resourceAllocator(new ResourceAllocator(allocateInfo ? allocateInfo->resourceAllocator : nullptr)),
#ifdef COGS_RENDERING_D3D9SUPPORT
  sharedResources(std::make_unique<SharedResources>()),
#endif
  defaultSwapChain(this),
  buffers(this),
  textures(this) {
}
 
bool Cogs::GraphicsDeviceD3D11::initialize() {
  if (settings.ioHandler) {
    effects.setIOHandler(settings.ioHandler);
  }
 
  renderTargets.initialize(this, &textures);
 
  if ((settings.flags & GraphicsDeviceFlags::UseSharedSurface) == GraphicsDeviceFlags::UseSharedSurface) {
    if (!initializeDeviceShared()) {
      return false;
    }
  }
  else {
    if (!initializeDeviceAndSwapChain()) {
      return false;
    }
  }
 
  device->QueryInterface(__uuidof(ID3D11InfoQueue), infoQueue.internalVoidPointer());
 
  if (device5) {
    capabilities.initialize(device5);
    syncObjects.setDevice(device5);
  }
  else if (device1) {
    capabilities.initialize(device1);
  }
  else {
    capabilities.initialize(device);
  }
  buffers.setDevice(device);
  effects.setDevice(this, device);
  context.setDevice(device, device1);
 
  buffers.initialize(&context, &effects);
  textures.initialize(&context);
  context.initialize(this, &buffers, &textures, &effects, &renderTargets, &syncObjects);
  return true;
}
 
void Cogs::GraphicsDeviceD3D11::beginFrame() {
  inFrame = true;
 
  context.frameStatisticsBeginFrame();
  context.setDefaults();
 
  defaultSwapChain.beginFrame();
 
  for (ISwapChain* swapChain : swapChains) {
    swapChain->beginFrame();
  }
}
 
void Cogs::GraphicsDeviceD3D11::endFrame(uint32_t syncInterval, uint32_t presentFlags) {
  static std::vector<uint8_t>         buffer;
  static constexpr Logging::Category  categories[] = {
    Logging::Category::Fatal,
    Logging::Category::Error,
    Logging::Category::Warning,
    Logging::Category::Debug,
    Logging::Category::Trace
  };
 
  for (ISwapChain* swapChain : swapChains) {
    swapChain->endFrame(0, presentFlags);
  }
  defaultSwapChain.endFrame(syncInterval, presentFlags);
  context.endFrame();
 
  if (infoQueue) {
    for(uint64_t idx = 0, messageCount = infoQueue->GetNumStoredMessages(); idx < messageCount; ++idx) {
      size_t  messageSize = 0;
 
      infoQueue->GetMessage(idx, nullptr, &messageSize);
      buffer.resize(messageSize);
 
      D3D11_MESSAGE*  message = reinterpret_cast<D3D11_MESSAGE*>(buffer.data());
 
      infoQueue->GetMessage(idx, message, &messageSize);
 
      logger.logFileLine(__FILE__, __LINE__, categories[message->Severity], Cogs::Logging::ErrorGroup::Unspecified, message->pDescription);
    }
    infoQueue->ClearStoredMessages();
  }
  inFrame = false;
}
 
void Cogs::GraphicsDeviceD3D11::releaseResources() {
  effects.releaseResources();
  renderTargets.releaseResources();
  textures.releaseResources();
  buffers.releaseResources();
}
 
Cogs::ISwapChain* Cogs::GraphicsDeviceD3D11::createSwapChain(struct WindowData* windowData) {
  SwapChainD3D11* swapChain = new SwapChainD3D11(this);
 
  if (swapChain->initialize(windowData)) {
    swapChains.push_back(swapChain);
    return swapChain;
  }
  delete swapChain;
  return nullptr;
}
 
void Cogs::GraphicsDeviceD3D11::deleteSwapChain(ISwapChain* swapChain) {
  auto e = swapChains.end();
  auto i = std::find(swapChains.begin(), e, swapChain);
 
  if (i != e) {
    swapChains.erase(i);
    delete swapChain;
  }
}
 
void Cogs::GraphicsDeviceD3D11::setSize(int newWidth, int newHeight) {
  defaultSwapChain.setSize(newWidth, newHeight);
}
 
bool Cogs::GraphicsDeviceD3D11::getSize(int& w, int& h) const {
  w = defaultSwapChain.getWidth();
  h = defaultSwapChain.getHeight();
  return true;
}
 
bool Cogs::GraphicsDeviceD3D11::resizeSharedSurfaces()
{
#ifdef COGS_RENDERING_D3D9SUPPORT
  ResourcePointer<IDXGIResource> dxgiSurface;
  HRESULT hr = defaultSwapChain.getSharedBackBuffer()->QueryInterface(__uuidof(IDXGIResource), dxgiSurface.internalVoidPointer());
 
  if (FAILED(hr)) {
    LOG_ERROR(logger, "QueryInterface failed in resizeSharedSurfaces: %s", direct3D11ReturnCodeAsString(hr));
    return false;
  }
  hr = dxgiSurface->GetSharedHandle(&sharedResources->sharedHandle);
 
  if (FAILED(hr)) {
    LOG_ERROR(logger, "GetSharedHandle failed in resizeSharedSurfaces: %s", direct3D11ReturnCodeAsString(hr));
    return false;
  }
 
  sharedResources->sharedSurface = {};
 
  ResourcePointer<IDirect3DTexture9> sharedTexture;
  D3DFORMAT d3D9Format = D3DFMT_A8R8G8B8;
 
  hr = sharedResources->d3d9Device->CreateTexture(defaultSwapChain.getWidth(),
                                                  defaultSwapChain.getHeight(),
                                                  1,
                                                  D3DUSAGE_RENDERTARGET,
                                                  d3D9Format,
                                                  D3DPOOL_DEFAULT,
                                                  sharedTexture.internalPointer(),
                                                  &sharedResources->sharedHandle);
 
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Failed to create D3D9 texture in resizeSharedSurfaces: %s", direct3D11ReturnCodeAsString(hr));
    return false;
  }
 
  hr = sharedTexture->GetSurfaceLevel(0, sharedResources->sharedSurface.internalPointer());
 
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Get surface level failed in resizeSharedSurfaces: %s", direct3D11ReturnCodeAsString(hr));
    return false;
  }
  if (settings.sharedSurface) {
    *settings.sharedSurface = sharedResources->sharedSurface;
  }
#endif
  return true;
}
 
bool Cogs::GraphicsDeviceD3D11::initializeDeviceAndSwapChain() {
  HRESULT hr = S_OK;
 
  char tmp[256];
  auto * tmp_p = &tmp[0];
  auto * tmp_e = tmp_p + sizeof(tmp);
 
  bool envvars[ENV_N];
  for (unsigned i = 0; i < ENV_N; i++) {
    envvars[i] = getenv(env_keys[i]);
    auto n = strlen(env_keys[i]);
    if (i != 0 && tmp_p + 1 < tmp_e) *tmp_p++ = ' ';
    for (size_t k = 0; k < n && tmp_p + 1 < tmp_e; k++) {
      *tmp_p++ = env_keys[i][k];
    }
    if (tmp_p + 1 < tmp_e) *tmp_p++ = '=';
    if (tmp_p + 1 < tmp_e) *tmp_p++ = envvars[i] ? '1' : '0';
  }
  assert(tmp_p < tmp_e);
  *tmp_p++ = '\0';
  LOG_DEBUG(logger, "envvars: %s", tmp);
 
  std::vector<ResourcePointer<IDXGIAdapter>>  adapters;
 
  std::vector<D3D_DRIVER_TYPE> driverTypes;
  if (((settings.flags & GraphicsDeviceFlags::ForceSoftwareRendering) == GraphicsDeviceFlags::ForceSoftwareRendering) || envvars[ENV_COGS_USE_WARP]) {
    driverTypes.push_back(D3D_DRIVER_TYPE_WARP);
  }
  else if (envvars[ENV_COGS_USE_REF]) {
    driverTypes.push_back(D3D_DRIVER_TYPE_REFERENCE);
  }
  else {
    driverTypes = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP, D3D_DRIVER_TYPE_REFERENCE };
 
    ResourcePointer<IDXGIFactory5>  dxgiFactory;
    
    if (SUCCEEDED(CreateDXGIFactory(__uuidof(IDXGIFactory5), dxgiFactory.internalVoidPointer()))) {
      ResourcePointer<IDXGIAdapter> adapter;
    
      for (uint32_t idx = 0; dxgiFactory->EnumAdapters(idx, adapter.internalPointer()) != DXGI_ERROR_NOT_FOUND; ++idx) {
        DXGI_ADAPTER_DESC desc;
    
        adapter->GetDesc(&desc);
    
        if (desc.VendorId == 0x10DE) {  // 0x10DE == NVIDIA
          adapters.push_back(adapter);
        }
      }
    }
  }
 
  adapters.push_back({});   // Add a default adapter if no nvidia gpus are present.
 
  std::vector<D3D_FEATURE_LEVEL> FeatureLevelsRequested;
  if (envvars[ENV_COGS_USE_DX11_0]) {
    FeatureLevelsRequested.push_back(D3D_FEATURE_LEVEL_11_0);
  }
  else {
    FeatureLevelsRequested = {
      D3D_FEATURE_LEVEL_11_1,
      D3D_FEATURE_LEVEL_11_0
    };
  }
 
  bool              debug = isDebug() || ((settings.flags & GraphicsDeviceFlags::Debug) == GraphicsDeviceFlags::Debug) || envvars[ENV_COGS_USE_DEBUG_LAYER];
  D3D_FEATURE_LEVEL apiFeatureLevel = D3D_FEATURE_LEVEL_11_0;
 
  assert(!driverTypes.empty());
  assert(!FeatureLevelsRequested.empty());
 
  for (auto i = adapters.begin(), e = adapters.end(); (i != e) && !device; ++i) {
    for (auto driverType : driverTypes) {
 
      // If we're specifying an adapter, we must ignore the driver type.
      hr = E_INVALIDARG;
      if (debug) {
        hr = createDevice(*i, driverType, D3D11_CREATE_DEVICE_DEBUG, FeatureLevelsRequested, apiFeatureLevel);
      }
      if (FAILED(hr)) {
        hr = createDevice(*i, driverType, 0, FeatureLevelsRequested, apiFeatureLevel);
      }
 
      if (SUCCEEDED(hr)) {
        if (driverType == D3D_DRIVER_TYPE_WARP) {
          LOG_WARNING(logger, "Software rendering via WARP device.");
        }
        else if (driverType == D3D_DRIVER_TYPE_REFERENCE) {
          LOG_WARNING(logger, "Software rendering via reference driver.");
        }
        if (apiFeatureLevel == D3D_FEATURE_LEVEL_11_0) {
          LOG_WARNING(logger, "Got feature level 11.0");
        }
        break;
      }
    }
  }
  if (FAILED(hr)) {
    LOG_FATAL(logger, "Could not create Direct3D 11 device: %s", direct3D11ReturnCodeAsString(hr));
    return false;
  }
 
  device1 = nullptr;
  if (apiFeatureLevel != D3D_FEATURE_LEVEL_11_0) {
    hr = device->QueryInterface(__uuidof(ID3D11Device1), (void **)&device1);
    if (SUCCEEDED(hr)) {
      LOG_DEBUG(logger, "Got ID3D11Device1 interface");
    }
  }
 
  if (hr = device->QueryInterface(__uuidof(ID3D11Device5), (void**)&device5); SUCCEEDED(hr)) {
    LOG_DEBUG(logger, "Got ID3D11Device5 interface");
  }
 
  if (debug) {
    setupDebugging();
  }
 
  return defaultSwapChain.initialize(settings.windowData);
}
 
bool Cogs::GraphicsDeviceD3D11::initializeDeviceShared() {
#ifdef COGS_RENDERING_D3D9SUPPORT
  LOG_DEBUG(logger, "Initializing D3D11 with shared surface support...");
  // Fetch desktop window to create dummy Direct3D9Ex device in.
  auto desktopHwnd = GetDesktopWindow();
  HRESULT hr;
  if (FAILED(hr = Direct3DCreate9Ex(D3D_SDK_VERSION, sharedResources->d3D9Interface.internalPointer()))) {
    LOG_ERROR(logger, "Could not create Direct3D 9 Ex interface: %s", direct3D11ReturnCodeAsString(hr));
    return false;
  }
  D3DPRESENT_PARAMETERS presentParameters = {};
  presentParameters.Windowed = TRUE;
  presentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
  presentParameters.hDeviceWindow = desktopHwnd;
  presentParameters.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
  if (FAILED(hr = sharedResources->d3D9Interface->CreateDeviceEx(D3DADAPTER_DEFAULT,
                                                D3DDEVTYPE_HAL,
                                                desktopHwnd,
                                                D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_MULTITHREADED | D3DCREATE_FPU_PRESERVE,
                                                &presentParameters,
                                                nullptr,
                                                sharedResources->d3d9Device.internalPointer()))) {
    LOG_ERROR(logger, "Could not create Direct3D 9 Ex device: %s", direct3D11ReturnCodeAsString(hr));
    return false;
  }
  const UINT deviceFlags = isDebug() ? D3D11_CREATE_DEVICE_DEBUG : 0;
  const D3D_FEATURE_LEVEL level = D3D_FEATURE_LEVEL_11_0;
  if (FAILED(hr = D3D11CreateDevice(nullptr,
                                    D3D_DRIVER_TYPE_HARDWARE,
                                    nullptr,
                                    deviceFlags,
                                    &level,
                                    1,
                                    D3D11_SDK_VERSION,
                                    device.internalPointer(),
                                    nullptr,
                                    nullptr))) {
    LOG_ERROR(logger, "Could not create Direct3D 11 device: %s", direct3D11ReturnCodeAsString(hr));
    return false;
  }
  if (defaultSwapChain.recreateOffscreenBuffers()) {
    return resizeSharedSurfaces();
  }
#endif
  return false;
}
 
void Cogs::GraphicsDeviceD3D11::setupDebugging()
{
  HRESULT hr;
  ResourcePointer<ID3D11Debug> d3dDebug;
  if (FAILED(hr = device->QueryInterface(__uuidof(ID3D11Debug), (void**)&d3dDebug))) {
    LOG_WARNING(logger, "Could not get ID3D11Debug interface: %s", direct3D11ReturnCodeAsString(hr));
    return;
  }
 
  ResourcePointer<ID3D11InfoQueue> d3dInfoQueue;
  if (FAILED(hr = d3dDebug->QueryInterface(__uuidof(ID3D11InfoQueue), (void**)&d3dInfoQueue))) {
    LOG_WARNING(logger, "Could not get ID3D11InfoQueue interface: %s", direct3D11ReturnCodeAsString(hr));
    return;
  }
 
#ifdef COGSRENDERING_GFX_BREAK
  d3dInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true);
  d3dInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true);
  LOG_DEBUG(logger, "Break to debugger on D3D errors.");
#endif
 
  // Messages to ignore
  D3D11_MESSAGE_ID hide[] = {
    D3D11_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS,
  };
 
  D3D11_INFO_QUEUE_FILTER filter = {};
  filter.DenyList.NumIDs = _countof(hide);
  filter.DenyList.pIDList = hide;
 
  if (FAILED(hr = d3dInfoQueue->AddStorageFilterEntries(&filter))) {
    LOG_WARNING(logger, "Could not add storage filter entries: %s", direct3D11ReturnCodeAsString(hr));
  }
  LOG_DEBUG(logger, "Set up debug layer.");
}
 
Cogs::ResourceStatistics Cogs::GraphicsDeviceD3D11::getResourceStatistics() {
  ResourceStatistics stats{};
 
  stats.bufferMemoryConsumption = buffers.bufferMemoryConsumption;
  stats.textureMemoryConsumption = textures.textureMemoryConsumption;
  stats.bufferCount = static_cast<uint32_t>(buffers.buffers.size());
  stats.inputLayoutCount = static_cast<uint32_t>(buffers.inputLayouts.size());
  stats.textureCount = static_cast<uint32_t>(textures.textures.size());
  stats.samplerStateCount = static_cast<uint32_t>(textures.samplerStates.size());
  stats.effectCount = static_cast<uint32_t>(effects.effects.size());
  stats.blendStateCount = static_cast<uint32_t>(renderTargets.blendStates.size());
  stats.rasterizerStateCount = static_cast<uint32_t>(renderTargets.rasterizerStates.size());
  stats.depthStencilStateCount = static_cast<uint32_t>(renderTargets.depthStencilStates.size());
  stats.rendertargetsCount = static_cast<uint32_t>(renderTargets.renderTargets.size());
  stats.framebufferCount = ~0u;
 
  return stats;
}
 
HRESULT Cogs::GraphicsDeviceD3D11::createDevice(IDXGIAdapter*                         adapter,
                                                D3D_DRIVER_TYPE                       driverType,
                                                UINT                                  flags,
                                                const std::vector<D3D_FEATURE_LEVEL>& featureLevelsRequested,
                                                D3D_FEATURE_LEVEL&                    apiFeatureLevel) {
  if (adapter) {
    driverType = D3D_DRIVER_TYPE_UNKNOWN;
  }
  HRESULT hr = D3D11CreateDevice(adapter,
                                 driverType,
                                 nullptr,
                                 flags,
                                 featureLevelsRequested.data(),
                                 (UINT)featureLevelsRequested.size(),
                                 D3D11_SDK_VERSION,
                                 device.internalPointer(),
                                 &apiFeatureLevel,
                                 nullptr);
  if (FAILED(hr)) {
    constexpr D3D_FEATURE_LEVEL featureLevel_11_0 = D3D_FEATURE_LEVEL_11_0;
 
    // If we failed, retry immediately with just a 11.0 feature level.
    //
    // "If you provide a D3D_FEATURE_LEVEL array that contains D3D_FEATURE_LEVEL_11_1
    // on a computer that doesn't have the Direct3D 11.1 runtime installed, this
    // function immediately fails with E_INVALIDARG."
    hr = D3D11CreateDevice(adapter,
                           driverType,
                           nullptr,
                           flags,
                           &featureLevel_11_0,
                           1,
                           D3D11_SDK_VERSION,
                           device.internalPointer(),
                           &apiFeatureLevel,
                           nullptr);
    if (SUCCEEDED(hr)) {
      LOG_WARNING(logger, "D3D11CreateDevice didn't recognize feature level 11.1, KB2670838 is probably missing.");
    }
  }
  return hr;
}