EffectsCommon.cpp

#include "EffectsCommon.h"
#include "DefaultIOHandler.h"
#include "Utilities.h"
 
#include "../IBuffers.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EffectsCommon");
}
 
#ifdef COGSRENDERING_GFX_ANNOTATE
Cogs::StringView Cogs::tryToName(const Cogs::StringView filename)
{
  size_t first = 0, t;
  size_t last = filename.length();
 
  t = filename.find_last_of("/\\");
  if (t != std::string::npos) {
    first = t;
  }
 
  t = filename.find_last_of('.', first);
  if (t != std::string::npos) {
    last = t;
  }
 
  if (first < last) {
    return filename.substr(first, last - first);
  }
  else {
    return "";
  }
}
#endif
 
void Cogs::EffectsCommon::initialize(IBuffers * buffers)
{
  if (!handler) {
    defaultHandler = std::make_unique<DefaultIOHandler>();
    handler = defaultHandler.get();
  }
  else{
    LOG_DEBUG(logger, "Custom IOHandler set.");
  }
  this->buffers = buffers;
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffect(const EffectDescription & description)
{
  if (description.type == EffectDescriptionType::File) {
    EffectDescription sourceDescription = description;
    sourceDescription.type = EffectDescriptionType::Source;
 
    EffectContents contents = {};
 
    if (description.effect.size()) {
      Utilities::readFile(handler, description.effect, contents.effect);
    } else {
      if (!Utilities::readFile(handler, description.vertexShader, contents.vertexShader)) {
        LOG_WARNING(logger, "Failed to read vertex shader %s.", std::string(description.vertexShader).c_str());
        return EffectHandle::InvalidHandle;
      }
      if(!contents.vertexShader.content.size()) {
        LOG_WARNING(logger, "Vertex shader %s is empty.", std::string(description.vertexShader).c_str());
        return EffectHandle::InvalidHandle;
      }
 
      if (description.geometryShader.size()) {
        Utilities::readFile(handler, description.geometryShader, contents.geometryShader);
      }
 
      if (description.pixelShader.size()) {
        Utilities::readFile(handler, description.pixelShader, contents.pixelShader);
      }
 
      if (description.hullShader.size()) {
        Utilities::readFile(handler, description.hullShader, contents.hullShader);
      }
 
      if (description.domainShader.size()) {
        Utilities::readFile(handler, description.domainShader, contents.domainShader);
      }
    }
 
    return loadEffectContents(sourceDescription, contents);
  } else {
    return loadEffectSource(description);
  }
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffectSource(const EffectDescription & description)
{
  if (description.type == EffectDescriptionType::File) return EffectHandle::InvalidHandle;
 
  EffectContents contents = {};
 
  if (description.effect.size()) {
    Utilities::preprocessContent(handler, description.effect, contents.effect);
  } else {
    Utilities::preprocessContent(handler, description.vertexShader, contents.vertexShader);
 
    if (description.geometryShader.size()) {
      Utilities::preprocessContent(handler, description.geometryShader, contents.geometryShader);
    }
 
    if (description.hullShader.size()) {
      Utilities::preprocessContent(handler, description.hullShader, contents.hullShader);
    }
 
    if (description.domainShader.size()) {
      Utilities::preprocessContent(handler, description.domainShader, contents.domainShader);
    }
 
    Utilities::preprocessContent(handler, description.pixelShader, contents.pixelShader);
  }
 
  return loadEffectContents(description, contents);
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffectContents(const EffectDescription & description, const EffectContents & contents)
{
  if (contents.effect.content.size()) {
    return load(contents.effect,
      (description.flags & EffectFlags::GeometryShader) ? contents.effect : ProcessedContent(),
      contents.effect,
      description.vsEntryPoint.size() ? description.vsEntryPoint.data() : "VShader",
      description.gsEntryPoint.size() ? description.gsEntryPoint.data() : "GShader",
      description.psEntryPoint.size() ? description.psEntryPoint.data() : "PShader",
      description);
  } else {
    return load(contents.vertexShader,
      contents.hullShader,
      contents.domainShader,
      contents.geometryShader,
      contents.pixelShader,
      description.vsEntryPoint.size() ? description.vsEntryPoint.data() : "main",
      description.hsEntryPoint.size() ? description.hsEntryPoint.data() : "main",
      description.dsEntryPoint.size() ? description.dsEntryPoint.data() : "main",
      description.gsEntryPoint.size() ? description.gsEntryPoint.data() : "main",
      description.psEntryPoint.size() ? description.psEntryPoint.data() : "main",
      description);
  }
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffect(const StringView & fileName, EffectFlags::EEffectFlags effectFlags)
{
  auto e = loadEffect(fileName, PreprocessorDefinitions(), effectFlags);
 
#ifdef COGSRENDERING_GFX_ANNOTATE
  annotate(e, tryToName(fileName));
#endif
 
  return e;
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffect(const StringView & vsFileName, const StringView & psFileName, EffectFlags::EEffectFlags effectFlags)
{
  auto e = loadEffect(vsFileName, psFileName, PreprocessorDefinitions(), effectFlags);
 
#ifdef COGSRENDERING_GFX_ANNOTATE
  annotateVS(e, tryToName(vsFileName));
  annotatePS(e, tryToName(psFileName));
#endif
 
  return e;
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffect(const StringView & vsFileName, const StringView & psFileName, const PreprocessorDefinitions & defines, EffectFlags::EEffectFlags effectFlags)
{
  EffectDescription desc;
  desc.vertexShader = vsFileName;
  desc.pixelShader = psFileName;
  desc.definitions = defines;
  desc.flags = effectFlags;
  desc.type = EffectDescriptionType::File;
 
  auto e = loadEffect(desc);
 
#ifdef COGSRENDERING_GFX_ANNOTATE
  annotateVS(e, tryToName(vsFileName));
  annotatePS(e, tryToName(psFileName));
#endif
 
  return e;
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffectSource(const StringView & vsSource, const StringView & psSource, EffectFlags::EEffectFlags effectFlags)
{
  return loadEffectSource(vsSource, psSource, PreprocessorDefinitions(), effectFlags);
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffectSource(const StringView & vsSource, const StringView & psSource, const PreprocessorDefinitions & defines, EffectFlags::EEffectFlags flags)
{
  EffectDescription desc;
  desc.vertexShader = vsSource;
  desc.pixelShader = psSource;
  desc.definitions = defines;
  desc.flags = static_cast<EffectFlags::EEffectFlags>(flags);
  desc.type = EffectDescriptionType::Source;
 
  return loadEffectSource(desc);
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffectSource(const StringView & vsSource, const StringView & gsSource, const StringView & psSource, EffectFlags::EEffectFlags effectFlags)
{
  return loadEffectSource(vsSource, gsSource, psSource, PreprocessorDefinitions(), effectFlags);
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffectSource(const StringView & vsSource, const StringView & gsSource, const StringView & psSource, const PreprocessorDefinitions & defines, EffectFlags::EEffectFlags flags)
{
  EffectDescription desc;
  desc.vertexShader = vsSource;
  desc.geometryShader = gsSource;
  desc.pixelShader = psSource;
  desc.definitions = defines;
  desc.flags = static_cast<EffectFlags::EEffectFlags>(flags);
  desc.type = EffectDescriptionType::Source;
 
  return loadEffectSource(desc);
}
 
Cogs::EffectHandle Cogs::EffectsCommon::loadEffect(const StringView & fileName, const PreprocessorDefinitions & defines, EffectFlags::EEffectFlags flags)
{
  EffectDescription desc;
  desc.effect = fileName;
  desc.definitions = defines;
  desc.flags = flags;
  desc.type = EffectDescriptionType::File;
 
  auto e = loadEffect(desc);
 
  return e;
}
 
Cogs::EffectHandle Cogs::EffectsCommon::load(const ProcessedContent & vsSource,
  const ProcessedContent & psSource,
  const StringView & vsEntryPoint,
  const StringView & psEntryPoint,
  const EffectDescription & desc)
{
  return load(vsSource, ProcessedContent(), psSource, vsEntryPoint, nullptr, psEntryPoint, desc);
}
 
Cogs::EffectHandle Cogs::EffectsCommon::load(const ProcessedContent & vsSource,
  const ProcessedContent & gsSource,
  const ProcessedContent & psSource,
  const StringView & vsEntryPoint,
  const StringView & gsEntryPoint,
  const StringView & psEntryPoint,
  const EffectDescription & desc)
{
  return load(vsSource,
    ProcessedContent(),
    ProcessedContent(),
    gsSource,
    psSource,
    vsEntryPoint,
    StringView(),
    StringView(),
    gsEntryPoint,
    psEntryPoint,
    desc);
}
 
namespace Cogs
{
  template<typename Collection>
  uint8_t getSlot(Collection & collection, const StringView & name)
  {
    auto it = collection.find(Cogs::hash(name));
 
    if (it == collection.end()) return Cogs::NoBinding;
 
    return (uint8_t)it->second;
  }
 
  uint64_t encode(uint8_t vsSlot, uint8_t hsSlot, uint8_t dsSlot, uint8_t gsSlot, uint8_t psSlot)
  {
    if ((vsSlot == NoBinding) &&
        (hsSlot == NoBinding) &&
        (dsSlot == NoBinding) &&
        (gsSlot == NoBinding) &&
        (psSlot == NoBinding))
    {
      return 0;
    }
    else {
      return ((static_cast<uint64_t>(vsSlot) <<  0) |
              (static_cast<uint64_t>(hsSlot) <<  8) |
              (static_cast<uint64_t>(dsSlot) << 16) |
              (static_cast<uint64_t>(gsSlot) << 24) |
              (static_cast<uint64_t>(psSlot) << 32) |
              (static_cast<uint64_t>(1) << 63));
    }
  }
 
  uint64_t encode(uint8_t csSlot)
  {
    return encode(csSlot, NoBinding, NoBinding, NoBinding, NoBinding);
  }
 
  template<typename Effect>
  uint64_t getSlots(Effect & effect, const StringView & name)
  {
    const uint8_t vsSlot = getSlot(effect.vertexShader.reflection.slots, name);
    const uint8_t hsSlot = getSlot(effect.hullShader.reflection.slots, name);
    const uint8_t dsSlot = getSlot(effect.domainShader.reflection.slots, name);
    const uint8_t gsSlot = getSlot(effect.geometryShader.reflection.slots, name);
    const uint8_t psSlot = getSlot(effect.pixelShader.reflection.slots, name);
 
    return encode(vsSlot, hsSlot, dsSlot, gsSlot, psSlot);
  }
 
  template<typename Effect>
  int64_t getTextureSlots(Effect & effect, const StringView & name)
  {
    const uint8_t vsSlot = getSlot(effect.vertexShader.reflection.textures, name);
    const uint8_t hsSlot = getSlot(effect.hullShader.reflection.textures, name);
    const uint8_t dsSlot = getSlot(effect.domainShader.reflection.textures, name);
    const uint8_t gsSlot = getSlot(effect.geometryShader.reflection.textures, name);
    const uint8_t psSlot = getSlot(effect.pixelShader.reflection.textures, name);
 
    return encode(vsSlot, hsSlot, dsSlot, gsSlot, psSlot);
  }
 
  template<typename Effect>
  int64_t getSamplerSlots(Effect & effect, const StringView & name)
  {
    const uint8_t vsSlot = getSlot(effect.vertexShader.reflection.samplers, name);
    const uint8_t hsSlot = getSlot(effect.hullShader.reflection.samplers, name);
    const uint8_t dsSlot = getSlot(effect.domainShader.reflection.samplers, name);
    const uint8_t gsSlot = getSlot(effect.geometryShader.reflection.samplers, name);
    const uint8_t psSlot = getSlot(effect.pixelShader.reflection.samplers, name);
 
    return encode(vsSlot, hsSlot, dsSlot, gsSlot, psSlot);
  }
 
  template<typename Effect>
  int64_t getBufferUAVSlots(Effect & effect, const StringView & name)
  {
    const uint8_t vsSlot = getSlot(effect.vertexShader.reflection.bufferUAVs, name);
    const uint8_t hsSlot = getSlot(effect.hullShader.reflection.bufferUAVs, name);
    const uint8_t dsSlot = getSlot(effect.domainShader.reflection.bufferUAVs, name);
    const uint8_t gsSlot = getSlot(effect.geometryShader.reflection.bufferUAVs, name);
    const uint8_t psSlot = getSlot(effect.pixelShader.reflection.bufferUAVs, name);
 
    return encode(vsSlot, hsSlot, dsSlot, gsSlot, psSlot);
  }
 
  template<typename Effect>
  int64_t getBufferSRVSlots(Effect & effect, const StringView & name)
  {
    const uint8_t vsSlot = getSlot(effect.vertexShader.reflection.bufferSRVs, name);
    const uint8_t hsSlot = getSlot(effect.hullShader.reflection.bufferSRVs, name);
    const uint8_t dsSlot = getSlot(effect.domainShader.reflection.bufferSRVs, name);
    const uint8_t gsSlot = getSlot(effect.geometryShader.reflection.bufferSRVs, name);
    const uint8_t psSlot = getSlot(effect.pixelShader.reflection.bufferSRVs, name);
 
    return encode(vsSlot, hsSlot, dsSlot, gsSlot, psSlot);
  }
}
 
Cogs::EffectVariableHandle Cogs::EffectsCommon::getEffectVariable(EffectHandle effectHandle, const StringView & name)
{
  if (!HandleIsValid(effectHandle)) return EffectVariableHandle::InvalidHandle;
 
  auto id = Cogs::hash(name);
  auto & effect = effects[effectHandle];
 
  auto existingEffectVariable = effect.effectVariables.find(id);
 
  if (existingEffectVariable != effect.effectVariables.end()) {
    return EffectVariableHandle(reinterpret_cast<int64_t>(&(existingEffectVariable->second)));
  }
 
  EffectVariable effectVariable;
 
  auto addEffectVariable = [&](ShaderConstantBuffer & constantBuffer) {
    auto cbVariable = constantBuffer.variables.find(id);
 
    if (!HandleIsValid(constantBuffer.buffer)) {
      constantBuffer.memoryBuffer.resize(constantBuffer.size);
      constantBuffer.buffer = buffers->loadBuffer(nullptr, constantBuffer.size, Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
    }
 
    if (cbVariable != constantBuffer.variables.end()) {
      ConstantBufferVariable variable;
      variable.buffer = &constantBuffer;
      variable.offset = constantBuffer.offsets[cbVariable->second];
      variable.size = constantBuffer.sizes[cbVariable->second];
 
      effectVariable.variables.push_back(variable);
    }
  };
 
  for (auto & shader : effect.shaders) {
    for (auto & constantBuffer : shader.reflection.constantBuffers) {
      addEffectVariable(constantBuffer);
    }
  }
 
  auto variablePointer = &(effect.effectVariables[id] = effectVariable);
 
  return EffectVariableHandle(reinterpret_cast<int64_t>(variablePointer));
}
 
Cogs::ConstantBufferBindingHandle Cogs::EffectsCommon::getConstantBufferBinding(EffectHandle effectHandle, const StringView & name)
{
  auto & effect = effects[effectHandle];
 
  if (effect.computeShader.shader) {
    return ConstantBufferBindingHandle(encode(getSlot(effect.computeShader.reflection.slots, name)));
  } else {
    return ConstantBufferBindingHandle(getSlots(effect, name));
  }
}
 
Cogs::TextureBindingHandle Cogs::EffectsCommon::getTextureBinding(EffectHandle effectHandle, const StringView & name, const unsigned int)
{
  auto & effect = this->effects[effectHandle];
 
  if (effect.computeShader.shader) {
    return TextureBindingHandle(encode(getSlot(effect.computeShader.reflection.textures, name)));
  } else {
    return TextureBindingHandle(getTextureSlots(effect, name));
  }
}
 
Cogs::SamplerStateBindingHandle Cogs::EffectsCommon::getSamplerStateBinding(EffectHandle effectHandle, const StringView & name, const unsigned int)
{
  auto & effect = this->effects[effectHandle];
 
  if (effect.computeShader.shader) {
    return SamplerStateBindingHandle(encode(getSlot(effect.computeShader.reflection.samplers, name)));
  } else {
    return SamplerStateBindingHandle(getSamplerSlots(effect, name));
  }
}
 
Cogs::BufferBindingHandle Cogs::EffectsCommon::getBufferBinding(EffectHandle effectHandle, const StringView & name)
{
  auto & effect = this->effects[effectHandle];
 
  if (effect.computeShader.shader) {
    BufferBinding binding = { getSlot(effect.computeShader.reflection.bufferUAVs, name), getSlot(effect.computeShader.reflection.bufferSRVs, name) };
 
    return bufferBindings.addResource(std::move(binding));
  } else {
    BufferBinding binding = { getBufferUAVSlots(effect, name), getBufferSRVSlots(effect, name) };
 
    return bufferBindings.addResource(std::move(binding));
  }
}
 
void Cogs::EffectsCommon::releaseBufferBinding(BufferBindingHandle bufferBindingHandle)
{
  bufferBindings.removeResource(bufferBindingHandle);
}
 
void Cogs::Effect::buildSignature()
{
  signature = {};
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    auto & shader = shaders[i];
 
    signature.slots[SlotType::CBV].values[i] = static_cast<uint32_t>(shader.reflection.slots.size());
    signature.slots[SlotType::SRV].values[i] = shader.reflection.srvSlots;
    signature.slots[SlotType::Sampler].values[i] = static_cast<uint32_t>(shader.reflection.samplers.size());
    signature.slots[SlotType::UAV].values[i] = static_cast<uint32_t>(shader.reflection.bufferUAVs.size());
  }
 
  const uint32_t numUAVSlotsReservedForRT = 1;
  signature.slots[SlotType::UAV].values[ShaderType::PixelShader] += numUAVSlotsReservedForRT;
 
  int range = 0;
  for (size_t i = 0; i < SlotType::NumSlotTypes; ++i) {
    for (size_t j = 0; j < ShaderType::NumShaderTypes; ++j) {
      if (signature.slots[i].values[j]) {
        signature.slots[i].rangeIndex[j] = range++;
      }
    }
  }
}