EffectsD3D12.cpp

#include "EffectsD3D12.h"
 
#include <D3Dcompiler.h>
 
#include "../Base/Utilities.h"
 
#include "GraphicsDeviceD3D12.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EffectsD3D12");
 
  void dumpSource(const std::string & src, const std::vector<D3D_SHADER_MACRO> & macros, Cogs::EffectFlags::EEffectFlags effectFlags)
  {
    if ((effectFlags & Cogs::EffectFlags::EEffectFlags::LogShaderSource) == Cogs::EffectFlags::EEffectFlags::LogShaderSource) {
      for (size_t i = 0; i < macros.size(); i++) {
        LOG_DEBUG(logger, "PPM: %s: %s", macros[i].Name, macros[i].Definition);
      }
 
      const char* start = src.data();
      const char* stop;
      int line = 1;
      do {
        stop = start;
        while ((*stop != '\0') && (*stop != '\n') && (*stop != '\r')) { stop++; }
 
        LOG_DEBUG(logger, "%3d: %s", line++, std::string(start, stop - start).c_str());
 
        while ((*stop != '\0') && (*stop != '\n')) { stop++; }
        while ((*stop != '\0') && (*stop == '\r')) { stop++; }
 
        start = stop + 1;
      } while (*stop != '\0');
    }
  }
 
}
 
void Cogs::EffectsD3D12::releaseEffect(EffectHandle handle)
{
  this->effects.removeResource(handle);
}
 
HRESULT Cogs::EffectsD3D12::compileShader(const std::string & source, const std::vector<D3D_SHADER_MACRO> & macros, const std::string & entryPoint, const std::string & profile, UINT flags, ID3DBlob ** byteCode, Cogs::EffectFlags::EEffectFlags effectFlags)
{
  ResourcePointer<ID3DBlob> errorBlob;
 
  if (FAILED(D3DCompile(source.c_str(), source.size(), nullptr, macros.data(), nullptr, entryPoint.c_str(), profile.c_str(), flags, 0, byteCode, errorBlob.internalPointer()))) {
    dumpSource(source, macros, effectFlags);
 
    LOG_ERROR(logger, "%s", errorBlob->GetBufferPointer());
 
    return E_FAIL;
  } else if (errorBlob) {
    dumpSource(source, macros, effectFlags);
 
    LOG_WARNING(logger, "%s", errorBlob->GetBufferPointer());
  }
 
  return S_OK;
}
 
void Cogs::EffectsD3D12::setDevice(const ResourcePointer<ID3D12Device>& device, GraphicsDeviceD3D12 * graphicsDevice)
{
  this->device = device;
  this->persistentEffects = 0;
  this->graphicsDevice = graphicsDevice;
 
  EffectsCommon::initialize(graphicsDevice->getBuffers());
}
 
Cogs::EffectHandle Cogs::EffectsD3D12::loadComputeEffect(const StringView & fileName, EffectFlags::EEffectFlags effectFlags)
{
  return this->loadComputeEffect(fileName, PreprocessorDefinitions(), effectFlags); 
}
 
Cogs::EffectHandle Cogs::EffectsD3D12::loadComputeEffect(const StringView & fileName, const PreprocessorDefinitions & defines, EffectFlags::EEffectFlags effectFlags)
{
  ProcessedContent csSource;
  Utilities::readFile(handler, fileName, csSource);
 
  EffectD3D12 effect;
  ResourcePointer<ID3DBlob> errorBlob;
 
  std::vector<D3D_SHADER_MACRO> macros(defines.size() + 1);
 
  for (size_t i = 0; i < defines.size(); ++i) {
    D3D_SHADER_MACRO macro = { defines[i].first.c_str(), defines[i].second.c_str() };
    macros[i] = macro;
  }
 
#ifdef _DEBUG
  UINT flags = D3DCOMPILE_OPTIMIZATION_LEVEL0 | D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY | D3DCOMPILE_DEBUG | D3DCOMPILE_PACK_MATRIX_ROW_MAJOR;
#else
  UINT flags = D3DCOMPILE_OPTIMIZATION_LEVEL3 | D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY | D3DCOMPILE_PACK_MATRIX_ROW_MAJOR;
#endif
 
  if (FAILED(D3DCompile(csSource.content.c_str(), csSource.content.size(), nullptr, macros.data(), nullptr, "main", "cs_5_0", flags, 0, effect.computeShader.byteCode.internalPointer(), errorBlob.internalPointer()))) {
    LOG_ERROR(logger, "%s", errorBlob->GetBufferPointer());
    return EffectHandle::InvalidHandle;
  } else if (errorBlob) {
    LOG_WARNING(logger, "%s", errorBlob->GetBufferPointer());
  }
  
  reflectShader(effect.computeShader);
 
  return effects.addResource(effect);
}
 
Cogs::EffectHandle Cogs::EffectsD3D12::load(const ProcessedContent & vsSource,
  const ProcessedContent & hsSource,
  const ProcessedContent & dsSource,
  const ProcessedContent & gsSource,
  const ProcessedContent & psSource,
  const StringView & vsEntryPoint,
  const StringView & hsEntryPoint,
  const StringView & dsEntryPoint,
  const StringView & gsEntryPoint,
  const StringView & psEntryPoint,
  const EffectDescription & desc)
{
  ResourcePointer<ID3DBlob> errorBlob;
  std::vector<D3D_SHADER_MACRO> macros(desc.definitions.size() + 1);
 
  for (size_t i = 0; i < desc.definitions.size(); ++i) {
    D3D_SHADER_MACRO macro = { desc.definitions[i].first.c_str(), desc.definitions[i].second.c_str() };
    macros[i] = macro;
  }
 
#ifdef _DEBUG
  UINT flags = D3DCOMPILE_OPTIMIZATION_LEVEL0 | D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY | D3DCOMPILE_DEBUG | D3DCOMPILE_PACK_MATRIX_ROW_MAJOR;
#else
  UINT flags = D3DCOMPILE_OPTIMIZATION_LEVEL3 | D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY | D3DCOMPILE_PACK_MATRIX_ROW_MAJOR;
#endif
 
  const char * profiles[ShaderType::NumShaderTypes] = { "vs_5_0", "hs_5_0", "ds_5_0", "gs_5_0", "ps_5_0" };
  const ProcessedContent * sources[ShaderType::NumShaderTypes] = { &vsSource, &hsSource, &dsSource, &gsSource, &psSource };
  const StringView * entryPoints[ShaderType::NumShaderTypes] = { &vsEntryPoint, &hsEntryPoint, &dsEntryPoint, &gsEntryPoint, &psEntryPoint };
  ResourcePointer<ID3DBlob> byteCode[ShaderType::NumShaderTypes];
 
  EffectD3D12 effect;
  for (int i = 0; i < ShaderType::NumShaderTypes; i++) {
    if (sources[i]->content.empty()) {
      continue;
    }
 
    if (FAILED(D3DCompile(sources[i]->content.c_str(),
      sources[i]->content.size(),
      nullptr,
      macros.data(),
      nullptr,
      entryPoints[i]->data(),
      profiles[i],
      flags, 0, byteCode[i].internalPointer(), errorBlob.internalPointer())))
    {
      //logCompilerOutput(Rendering::Logging::Category::Error, *sources[i], static_cast<const char*>(errorBlob->GetBufferPointer()));
      return EffectHandle::InvalidHandle;
    } else if (errorBlob) {
      //logCompilerOutput(Rendering::Logging::Category::Warning, *sources[i], static_cast<const char*>(errorBlob->GetBufferPointer()));
    }
 
    effect.shaders[i].byteCode = &*byteCode[i];
    effect.shaders[i].byteCode->AddRef();
 
    reflectShader(effect.shaders[i]);
  }
 
  effect.buildSignature();
 
  effect.rootSignature = createSignature(effect.signature);
 
  auto handle = this->effects.addResource(effect);
  if (desc.flags & EffectFlags::Pinned) this->effects.pin(handle);
  return handle;
}
 
void Cogs::EffectsD3D12::releaseResources()
{
  this->effects.clear();
}
 
void Cogs::EffectsD3D12::reflectShader(Shader & shader)
{
  auto code = shader.byteCode.get<ID3DBlob>();
 
  ID3D12ShaderReflection * reflector = nullptr; 
  D3DReflect(code->GetBufferPointer(), code->GetBufferSize(), IID_ID3D12ShaderReflection, (void **) &reflector);
 
  D3D12_SHADER_DESC shaderDesc;
  reflector->GetDesc(&shaderDesc);
 
  shader.reflection.constantBuffers.resize(shaderDesc.ConstantBuffers);
 
  for (UINT i = 0; i < shaderDesc.ConstantBuffers; ++i) {
    auto constantBufferReflect = reflector->GetConstantBufferByIndex(i);
    auto & constantBuffer = shader.reflection.constantBuffers[i];
    constantBuffer.slot = i;
    constantBuffer.dirty = true;
 
    D3D12_SHADER_BUFFER_DESC cbDesc;
    constantBufferReflect->GetDesc(&cbDesc);
 
    shader.reflection.slots[StringId(cbDesc.Name)] = i;
 
    constantBuffer.memoryBuffer.resize(cbDesc.Size);
 
    constantBuffer.buffer = graphicsDevice->buffers.loadBuffer(nullptr, cbDesc.Size, Usage::Default, AccessMode::Write, BindFlags::ConstantBuffer);
 
    constantBuffer.offsets.resize(cbDesc.Variables);
    constantBuffer.sizes.resize(cbDesc.Variables);
 
    for (UINT j = 0; j < cbDesc.Variables; ++j) {
      auto variable = constantBufferReflect->GetVariableByIndex(j);
 
      D3D12_SHADER_VARIABLE_DESC vDesc;
      variable->GetDesc(&vDesc);
 
      D3D12_SHADER_TYPE_DESC tDesc;
      variable->GetType()->GetDesc(&tDesc);
 
      constantBuffer.variables[StringId(vDesc.Name)] = static_cast<uint16_t>(j);
      constantBuffer.offsets[j] = vDesc.StartOffset;
      constantBuffer.sizes[j] = vDesc.Size;
    }
  }
 
  for (UINT i = 0; i < shaderDesc.BoundResources; ++i) {
    D3D12_SHADER_INPUT_BIND_DESC iDesc;
    reflector->GetResourceBindingDesc(i, &iDesc);
 
    if (iDesc.Type == D3D_SIT_TEXTURE || iDesc.Type == D3D_SIT_UAV_RWTYPED) {
      shader.reflection.textures[StringId(iDesc.Name)] = iDesc.BindPoint;
      shader.reflection.srvSlots = std::max(shader.reflection.srvSlots, iDesc.BindPoint + 1);
    } else if (iDesc.Type == D3D_SIT_SAMPLER) {
      shader.reflection.samplers[StringId(iDesc.Name)] = iDesc.BindPoint;
    } else if (iDesc.Type == D3D_SIT_UAV_RWSTRUCTURED || iDesc.Type == D3D_SIT_UAV_RWBYTEADDRESS || iDesc.Type == D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER) {
      shader.reflection.bufferUAVs[StringId(iDesc.Name)] = iDesc.BindPoint;
    } else if (iDesc.Type == D3D_SIT_STRUCTURED || iDesc.Type == D3D_SIT_BYTEADDRESS) {
      shader.reflection.bufferSRVs[StringId(iDesc.Name)] = iDesc.BindPoint;
      shader.reflection.srvSlots = std::max(shader.reflection.srvSlots, iDesc.BindPoint + 1);
    }
  }
}
 
Cogs::ResourcePointer<ID3D12RootSignature> Cogs::EffectsD3D12::createSignature(EffectSignature & signature)
{
  const D3D12_DESCRIPTOR_RANGE_TYPE rangeTypes[] = {
    D3D12_DESCRIPTOR_RANGE_TYPE_CBV,
    D3D12_DESCRIPTOR_RANGE_TYPE_SRV,
    D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER,
    D3D12_DESCRIPTOR_RANGE_TYPE_UAV,
  };
 
  const D3D12_SHADER_VISIBILITY shaderVisibilities[] = {
    D3D12_SHADER_VISIBILITY_VERTEX,
    D3D12_SHADER_VISIBILITY_HULL,
    D3D12_SHADER_VISIBILITY_DOMAIN,
    D3D12_SHADER_VISIBILITY_GEOMETRY,
    D3D12_SHADER_VISIBILITY_PIXEL
  };
 
  std::vector<CD3DX12_DESCRIPTOR_RANGE> ranges(size_t(SlotType::NumSlotTypes) * size_t(ShaderType::NumShaderTypes));
  std::vector<CD3DX12_ROOT_PARAMETER> slotRootParameter;
 
  for (uint32_t i = 0; i < SlotType::NumSlotTypes; ++i) {
    for (uint32_t j = 0; j < ShaderType::NumShaderTypes; ++j) {
      auto & rangeDesc = ranges[i * ShaderType::NumShaderTypes + j];
 
      auto & slots = signature.slots[i].values[j];
 
      if (slots) {
        rangeDesc.Init(rangeTypes[i], slots, 0);
 
        slotRootParameter.emplace_back();
 
        auto & parameter = slotRootParameter.back();
        parameter.InitAsDescriptorTable(1, &rangeDesc, shaderVisibilities[j]);
      }
    }
  }
 
  const D3D12_ROOT_SIGNATURE_FLAGS rootSignatureFlags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
 
  CD3DX12_ROOT_SIGNATURE_DESC descRootSignature;
  descRootSignature.Init(static_cast<UINT>(slotRootParameter.size()), slotRootParameter.data(), 0, nullptr, rootSignatureFlags);
 
  ResourcePointer<ID3D12RootSignature> rootSignature;
  ResourcePointer<ID3DBlob> pOutBlob;
  ResourcePointer<ID3DBlob> pErrorBlob;
  if (FAILED(D3D12SerializeRootSignature(&descRootSignature, D3D_ROOT_SIGNATURE_VERSION_1, pOutBlob.internalPointer(), pErrorBlob.internalPointer()))) {
    LOG_ERROR(logger, "Could not serialize root signature: %s", pErrorBlob->GetBufferPointer());
 
    return nullptr;
  }
 
  if (FAILED(device->CreateRootSignature(0, pOutBlob->GetBufferPointer(), pOutBlob->GetBufferSize(), IID_PPV_ARGS(rootSignature.internalPointer())))) {
    LOG_ERROR(logger, "Could not create root signature.");
 
    return nullptr;
  }
 
  return rootSignature;
}