EnginePermutations.cpp

#include "EnginePermutations.h"
 
#include "Context.h"
 
#include "ParameterBuffers.h"
 
#include "Resources/Material.h"
#include "Resources/MaterialBuilder.h"
 
#include "Serialization/JsonParser.h"
#include "Serialization/MaterialReader.h"
 
#include "Utilities/Parsing.h"
#include "Components/Core/LightComponent.h"
#include "Services/Variables.h"
#include "RenderList.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EnginePermutations");
 
  const size_t kMaxEnginePermutations = 64;
}
 
Cogs::Core::EnginePermutations::EnginePermutations(Context * context) :
  permutationDefinitions(MemBlockType::RenderResourceStorage), mContext(context)
{
  enginePermutations.reserve(kMaxEnginePermutations);
}
 
Cogs::Core::EnginePermutations::~EnginePermutations()
{
  EnginePermutationDefinition* def = firstDefinition;
  while (def) {
    EnginePermutationDefinition* n = def->next;
    permutationDefinitions.destroy(def);
    def = n;
  }
}
 
 
void Cogs::Core::EnginePermutations::initialize(Context * context)
{
  load("Default.permutations");
 
  //FIXME: When order-dependence for permutation masking is fixed, this section may be removed.
  assert(get(0) == get("Forward") && "Invalid default permutation order.");
  assert(get(1) == get("Deferred") && "Invalid default permutation order.");
  assert(get(2) == get("Shadow") && "Invalid default permutation order.");
  assert(get(3) == get("Transparent") && "Invalid default permutation order.");
 
  for (auto & e : enginePermutations) {
    auto & definitions = e.getDefinition()->definitions;
 
    definitions.push_back({ "COGS_MAX_LIGHTS", std::to_string(context->renderer->getMaxLights()) });
 
    if (context->variables->get("renderer.samples", 1) > 1) {
      definitions.push_back({ "COGS_MSAA", "1" });
    }
  }
}
 
Cogs::Core::EnginePermutationDefinition* Cogs::Core::EnginePermutations::createDefinition()
{
  EnginePermutationDefinition* rv = permutationDefinitions.create();
  rv->next = firstDefinition;
  firstDefinition = rv;
  return rv;
}
 
 
Cogs::Core::EnginePermutation * Cogs::Core::EnginePermutations::create(const StringView & name, EnginePermutation * base)
{
  auto definition = createDefinition();
  definition->name = name.to_string();
 
  return create(definition, base);
}
 
Cogs::Core::EnginePermutation * Cogs::Core::EnginePermutations::create(EnginePermutationDefinition * definition, EnginePermutation * base)
{
  assert(enginePermutations.size() < kMaxEnginePermutations && "Permutation limit reached.");
 
  auto name = StringView(definition->name);
  auto nameHash = name.hash();
 
  for (auto & e : enginePermutations) {
    if (e.getNameHash() == nameHash) {
      LOG_WARNING(logger, "Overwriting engine permutation %.*s.", StringViewFormat(name));
      return &e;
    }
  }
 
  enginePermutations.emplace_back();
  auto enginePermutation = &enginePermutations.back();
 
  enginePermutation->index = enginePermutations.size() - 1;
  enginePermutation->permutationMask = 1u << enginePermutation->index;
  enginePermutation->definition = definition;
 
  if (base) {
    assert(definition->inherits.empty());
    bool ret = inherit(enginePermutation, base);
    if (!ret) LOG_WARNING(logger, "EnginePermutation %s inherit %s failed", definition->name.c_str(), base->getName().c_str());
  } else if (definition->inherits.size()) {
    EnginePermutation* inherits = get(definition->inherits);
    bool ret = inherit(enginePermutation, inherits);
    if (!ret) LOG_WARNING(logger, "EnginePermutation %s inherit %s failed", definition->name.c_str(), inherits->getName().c_str());
  }
 
  enginePermutation->initialize(mContext, definition);
 
  return enginePermutation;
}
 
bool Cogs::Core::EnginePermutations::inherit(EnginePermutation * enginePermutation, const EnginePermutation * base)
{
  enginePermutation->permutationMask = base->permutationMask;
 
  auto inheritIfNotSet = [](std::string & a, const std::string & b) {
    if (a.empty()) a = b;
  };
 
  inheritIfNotSet(enginePermutation->definition->vertexShader, base->definition->vertexShader);
  inheritIfNotSet(enginePermutation->definition->geometryShader, base->definition->geometryShader);
  inheritIfNotSet(enginePermutation->definition->pixelShader, base->definition->pixelShader);
 
  enginePermutation->definition->flags |= base->definition->flags;
  enginePermutation->definition->requiredFlags |= base->definition->requiredFlags;
 
  for (auto & d : base->definition->definitions) {
    enginePermutation->definition->definitions.emplace_back(d);
  }
 
  return inheritMaterialVariants(enginePermutation->definition->variants, base->definition->variants,
                                 enginePermutation->definition->name, base->definition->name,
                                 true);
}
 
const Cogs::Core::EnginePermutation * Cogs::Core::EnginePermutations::get(size_t index) const
{
  if (index == static_cast<size_t>(-1) || index >= enginePermutations.size()) return &enginePermutations[0];
 
  return &enginePermutations[index];
}
 
const Cogs::Core::EnginePermutation * Cogs::Core::EnginePermutations::get(const StringView & name) const
{
  return get(getIndex(name));
}
 
Cogs::Core::EnginePermutation * Cogs::Core::EnginePermutations::get(size_t index)
{
  if (index == static_cast<size_t>(-1) || index >= enginePermutations.size()) return &enginePermutations[0];
 
  return &enginePermutations[index];
}
 
Cogs::Core::EnginePermutation * Cogs::Core::EnginePermutations::get(const StringView & name)
{
  return get(getIndex(name));
}
 
Cogs::Core::EnginePermutation * Cogs::Core::EnginePermutations::getInternal(size_t index)
{
  return &enginePermutations[index];
}
 
Cogs::Core::EnginePermutation * Cogs::Core::EnginePermutations::getInternal(const StringView & name)
{
  return getInternal(getIndex(name));
}
 
bool Cogs::Core::EnginePermutations::exists(const StringView & name) const
{
  const size_t nameHash = name.hash();
 
  for (auto & ep : enginePermutations) {
    if (nameHash == ep.nameHash) {
      return true;
    }
  }
 
  return false;
}
 
size_t Cogs::Core::EnginePermutations::getIndex(const StringView & name) const
{
  const size_t nameHash = name.hash();
 
  for (auto & ep : enginePermutations) {
    if (nameHash == ep.nameHash) {
      return ep.index;
    }
  }
 
  LOG_ERROR(logger, "Cannot retrieve invalid permutation index for %.*s.", StringViewFormat(name));
 
  return (size_t)-1;
}
 
bool Cogs::Core::EnginePermutations::load(const StringView & resource, bool isContent)
{
  const auto document = isContent ? parseJson(resource, JsonParseFlags::None) : parseJson(mContext, resource);
 
  if (!document.IsObject()) {
    if (!isContent) {
      LOG_ERROR(logger, "Could not read engine permutations from %.*s.", StringViewFormat(resource));
    }
 
    return false;
  }
 
  for (auto & m : document.GetObject()) {
    auto section = toKey(m.name);
 
    if (section == "permutations") {
      for (auto & p : m.value.GetObject()) {
        auto pKey = toKey(p.name);
 
        auto definition = createDefinition();
        definition->name = toString(p.name);
 
        for (auto & v : p.value.GetObject()) {
          auto vKey = toKey(v.name);
 
          if (vKey == "vertexShader") {
            definition->vertexShader = v.value.GetString();
          } else if (vKey == "geometryShader") {
            definition->geometryShader = v.value.GetString();
          } else if (vKey == "pixelShader") {
            definition->pixelShader = v.value.GetString();
          } else if (vKey == "definitions") {
            if (!v.value.IsObject()) {
              LOG_ERROR(logger, "Cannot read definitions from %.*s.", StringViewFormat(pKey));
              continue;
            }
 
            for (auto & d : v.value.GetObject()) {
              definition->definitions.push_back({ toString(d.name), toString(d.value) });
            }
          } else if (vKey == "requiredFlags") {
            if (v.value.IsArray()) {
              auto arr = v.value.GetArray();
 
              for (auto & element : arr) {
                if (!element.IsString()) {
                  LOG_ERROR(logger, "Invalid flag type.");
                  continue;
                }
 
                auto key = toKey(element);
                definition->requiredFlags |= parseEnum(key, RenderFlags::None);
              }
            } else if (v.value.IsString()) {
              definition->requiredFlags |= parseEnumFlags(toKey(v.value), RenderFlags::None);
            } else {
              LOG_ERROR(logger, "Invalid type for requiredFlags.");
              continue;
            }
          } else if (vKey == "inherits") {
            definition->inherits = toString(v.value);
          } else if (vKey == "flags") {
            if (v.value.IsString()) {
              definition->flags |= getFlag(toKey(v.value));
            } else {
              auto arr = v.value.GetArray();
 
              for (const auto & element : arr) {
                definition->flags |= getFlag(toKey(element));
              }
            }
          } else if (vKey == "variants") {
            if (!readMaterialVariants(mContext, v.value, definition->variants)) return false;
          } else if (vKey == "properties") {
            if (!readMaterialProperties(mContext, v.value, definition->properties, false)) return false;
          }
        }
 
        create(definition);
      }
    }
  }
 
  return true;
}
 
Cogs::Core::EnginePermutationFlags Cogs::Core::EnginePermutations::getFlag(const StringView & name)
{
  if (name == "DepthOnly")
    return EnginePermutationFlags::DepthOnly;
  else if (name == "NoShading")
    return EnginePermutationFlags::NoShading;
  else if (name == "ReverseDepth")
    return EnginePermutationFlags::ReverseDepth;
  else if (name == "HasBuiltins")
    return EnginePermutationFlags::HasBuiltins;
  else if (name != "None") {
    LOG_WARNING(logger, "EnginePermutationFlags mismatch %.*s", StringViewFormat(name));
  }
  return EnginePermutationFlags::None;
}
 
void Cogs::Core::EnginePermutation::initialize(Context * context, EnginePermutationDefinition * definition_in)
{
  definition = definition_in;
 
  nameHash = hash(definition->name);
 
  selectors.resize(definition->variants.size());
 
  for (const auto & v : definition->variants) {
    selectors[v.index].index = v.index;
    selectors[v.index].value = v.defaultValue;
  }
 
  applyConstantBuffers(context, definition->properties, constantBuffers);
 
  if ((definition->requiredFlags & RenderFlags::CastShadows) != 0) {
    requiredFlags |= RenderItemFlags::CastShadows;
  }
  updateFlags();
 
  dirty = true;
}
 
namespace
{
  void applySelectorValue(bool & dirty, size_t & selector, size_t value)
  {
    if (value != selector) {
      selector = value;
      dirty = true;
    }
  }
}
 
void Cogs::Core::EnginePermutation::updateFlags()
{
  flags = definition->flags;
  for (auto & v : definition->variants) {
    if (selectors[v.index].value != 0) {
      flags = flags | (EnginePermutationFlags)v.flags;
    }
  }
}
void Cogs::Core::EnginePermutation::setVariant(const StringView & key, const StringView & value)
{
  assert(selectors.size() == definition->variants.size() && "Variant selectors invalid.");
 
  for (auto & v : definition->variants) {
    if (key == v.name) {
      if (v.type == ShaderVariantType::Bool) {
        auto result = parseBool(value, v.defaultValue != 0);
 
        applySelectorValue(dirty, selectors[v.index].value, result ? 1 : 0);
      } else if (v.type == ShaderVariantType::Int) {
        auto result = parseInt(value, v.defaultValue);
 
        applySelectorValue(dirty, selectors[v.index].value, result);
      } else if (v.type == ShaderVariantType::Enum) {
        for (auto & e : v.values) {
          if (value == e.key) {
            applySelectorValue(dirty, selectors[v.index].value, e.index);
          }
        }
      } else {
        LOG_ERROR(logger, "Variant type %d not recognized.", static_cast<int>(v.type));
      }
 
      break;
    }
  }
  updateFlags();
}
 
void Cogs::Core::EnginePermutation::setVariant(const StringView & key, bool value)
{
  for (auto & v : definition->variants) {
    if (key == v.name) {
      if (v.type != ShaderVariantType::Bool) {
        LOG_WARNING(logger, "Variant type mismatch for %.*s (%d not Bool(%d)).", StringViewFormat(key), static_cast<int>(v.type), static_cast<int>(ShaderVariantType::Bool));
      }
      applySelectorValue(dirty, selectors[v.index].value, static_cast<size_t>(value));
      updateFlags();
      return;
    }
  }
 
  LOG_WARNING(logger, "No matching boolean variant found for key %.*s.", StringViewFormat(key));
}
 
void Cogs::Core::EnginePermutation::setVariant(const StringView & key, int value)
{
  for (auto & v : definition->variants) {
    if (key == v.name) {
      if (v.type != ShaderVariantType::Int && v.type != ShaderVariantType::Enum) {
        LOG_WARNING(logger, "Variant type mismatch for %.*s (%d not Int/Enum).", StringViewFormat(key), static_cast<int>(v.type));
      }
      applySelectorValue(dirty, selectors[v.index].value, static_cast<size_t>(value));
      updateFlags();
      return;
    }
  }
 
  LOG_WARNING(logger, "No matching integer variant found for key %.*s.", StringViewFormat(key));
}
 
bool Cogs::Core::EnginePermutation::hasVariant(const StringView & key)
{
  for (auto & v : definition->variants)
    if (key == v.name) return true;
  return false;
}
 
void Cogs::Core::EnginePermutation::setProperty(const StringView & name, const void * value, int valueSize)
{
  auto key = constantBuffers.getPropertyKey(name);
 
  if (key == NoProperty) {
    LOG_WARNING(logger, "Could not find property %.*s in engine permutation %s.", StringViewFormat(name), definition->name.c_str());
    return;
  }
 
  auto & variable = constantBuffers.variables[key];
 
  if (variable.flags != MaterialPropertyFlags::None) {
    enforcePropertyFlags(variable, variable.flags, &value);
  }
 
  constantBuffers.buffers[variable.buffer].setValue(variable.descriptor.offset, valueSize, static_cast<const uint8_t *>(value));
  updateFlags();
}
 
size_t Cogs::Core::EnginePermutation::getCode() const
{
  if (dirty) {
    code = hash(index, nameHash);
 
    for (auto & d : definition->definitions) {
      code = hash(d.second, code);
    }
    for (auto & s : selectors) {
      code = hash(s.value, code);
    }
    dirty = false;
  }
  return code;
}