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;
 
  [[nodiscard]] bool parseType(Cogs::StringView valueString, Cogs::Core::ValueDefinition& value, bool allowFormat)
  {
    using namespace Cogs::Core;
    const size_t spaceIndex = valueString.find(" ");
    const Cogs::StringView typeString = (spaceIndex != Cogs::StringView::NoPosition) ? valueString.substr(spaceIndex) : valueString;
 
    // Magic hook for when type is format
    if (allowFormat && typeString.hash() == Cogs::hash("format")) {
      value.type = MaterialDataType::Unknown;
      return true;
    }
 
    switch (typeString.hash()) {
    case Cogs::hash("float"):           value.type = MaterialDataType::Float; break;
    case Cogs::hash("float2"):          value.type = MaterialDataType::Float2; break;
    case Cogs::hash("float3"):          value.type = MaterialDataType::Float3; break;
    case Cogs::hash("float4"):          value.type = MaterialDataType::Float4; break;
    case Cogs::hash("float4x4"):        value.type = MaterialDataType::Float4x4; break;
    case Cogs::hash("float4[]"):        value.type = MaterialDataType::Float4Array; value.dimension = (size_t)-1; break;
    case Cogs::hash("float4x4[]"):      value.type = MaterialDataType::Float4x4Array; value.dimension = (size_t)-1; break;
    case Cogs::hash("bool"):            value.type = MaterialDataType::Bool; break;
    case Cogs::hash("uint"):            value.type = MaterialDataType::UInt; break;
    case Cogs::hash("uint2"):           value.type = MaterialDataType::UInt2; break;
    case Cogs::hash("uint3"):           value.type = MaterialDataType::UInt3; break;
    case Cogs::hash("uint4"):           value.type = MaterialDataType::UInt4; break;
    case Cogs::hash("int"):             value.type = MaterialDataType::Int; break;
    case Cogs::hash("int2"):            value.type = MaterialDataType::Int2; break;
    case Cogs::hash("int3"):            value.type = MaterialDataType::Int3; break;
    case Cogs::hash("int4"):            value.type = MaterialDataType::Int4; break;
    case Cogs::hash("VFACE"):           value.type = MaterialDataType::VFACE; break;
    case Cogs::hash("SV_IsFrontFace"):  value.type = MaterialDataType::SV_IsFrontFace; break;
    case Cogs::hash("SV_InstanceID"):   value.type = MaterialDataType::SV_InstanceID; break;
    case Cogs::hash("SV_ClipDistance"): value.type = MaterialDataType::ClipDistance; break;
    case Cogs::hash("SV_Position"):     value.type = MaterialDataType::Position; break;
    default:
 
      // Try to match (.*)[d+] where first match gets checked against float4 and float4x4
      for (size_t i = 0; i + 1 < typeString.size(); i++) {
        if ((typeString[i] == '[') && ('0' <= typeString[i + 1]) && (typeString[i + 1] <= '9')) {
 
          size_t dimension = typeString[i + 1] - '0';
          for (size_t j = i + 2; j < typeString.size(); j++) {
            if ('0' <= typeString[j] && typeString[j] <= '9') {
              dimension = 10 * dimension + (typeString[j] - '0');
            }
            else if ((typeString[j] == ']') && (j + 1 == typeString.size())) {
              switch (typeString.substr(0, i).hash()) {
 
              case Cogs::hash("float4"):
                value.type = MaterialDataType::Float4Array;
                value.dimension = dimension;
                value.dimensionString = typeString.substr(i + 1, j - i - 1).to_string();
                return true;
 
              case Cogs::hash("float4x4"):
                value.type = MaterialDataType::Float4x4Array;
                value.dimension = dimension;
                value.dimensionString = typeString.substr(i + 1, j - i - 1).to_string();
                return true;
 
              default:
                break;
              }
            }
            else {
              break;
            }
          }
          break;
        }
      }
      LOG_ERROR(logger, "Failed to parse datatype '%.*s'", StringViewFormat(valueString));
      return false;
    }
    return true;
  }
 
  [[nodiscard]] bool parseInterpolationModifier(const Value& jsonObject, Cogs::Core::ShaderInterfaceMemberDefinition& memberDefinition)
  {
    using namespace Cogs::Core;
    if (!jsonObject.IsString()) {
      LOG_ERROR(logger, "Interpolation modifier is not a JSON string");
      return false;
    }
 
    Cogs::StringView value = toView(jsonObject);
    switch (value.hash()) {
    case Cogs::hash("linear"):
      memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::LinearModifier);
      break;
    case Cogs::hash("centroid"):
      memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::CentroidModifier);
      break;
    case Cogs::hash("nointerpolation"):
      memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::NointerpolationModifier);
      break;
    case Cogs::hash("noperspective"):
      memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::NoperspectiveModifier);
      break;
    case Cogs::hash("sample"):
      memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::SampleModifier);
      break;
    default:
      LOG_ERROR(logger, "Unrecognized interpolation modifier '%.*s'", StringViewFormat(value));
      return false;
    }
    return true;
  }
 
  [[nodiscard]] bool parseShaderInterface(const Value& jsonObject, Cogs::Core::ShaderInterfaceDefinition& interfaceDefinition, uint8_t inheritanceLevel, bool allowFormat)
  {
    using namespace Cogs::Core;
    if (!jsonObject.IsObject()) {
      LOG_ERROR(logger, "Shader interface is not an JSON object");
      return false;
    }
 
    for (auto& m : jsonObject.GetObject()) {
      Cogs::StringView name = Cogs::Core::toView(m.name);
      auto& obj = m.value;
 
      Cogs::Core::ShaderInterfaceMemberDefinition value;
 
      if (obj.IsArray()) {
        auto arr = obj.GetArray();
 
 
 
        if (!parseType(toKey(arr[0]), value, allowFormat)) return false;
 
        if (value.dimension == size_t(-1)) {
          if (arr[1].IsString()) {
            value.dimensionString = toString(arr[1]);
          }
          else {
            value.dimension = arr[1].GetInt();
          }
        }
        else {
          if (arr.Size() >= 2) {
            if (arr[1].IsString()) {
              value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::None;
              value.semantic.slot = 0;
              Cogs::StringView semanticName(arr[1].GetString(), arr[1].GetStringLength());
 
              // Check for trailing digits, interpreted and chomp semanticName.
              for (size_t i = 0; i < semanticName.size(); i++) {
                if ('0' <= semanticName[i] && semanticName[i] <= '9') {
                  value.semantic.slot = semanticName[i] - '0';
                  size_t k = i + 1;
                  while ((k < semanticName.size()) &&
                    ('0' <= semanticName[k]) &&
                    (semanticName[k] <= '9'))
                  {
                    value.semantic.slot = uint8_t(10u * value.semantic.slot + (semanticName[k] - '0'));
                  }
                  semanticName = semanticName.substr(0, i);
                  break;
                }
              }
              switch (semanticName.hashLowercase()) {
              case Cogs::hash("position"):        value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Position; break;
              case Cogs::hash("normal"):          value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Normal; break;
              case Cogs::hash("color"):           value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Color; break;
              case Cogs::hash("texcoord"):        value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Texcoord; break;
              case Cogs::hash("tangent"):         value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Tangent; break;
              case Cogs::hash("instancevector"):  value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::InstanceVector; break;
              case Cogs::hash("instancematrix"):  value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::InstanceMatrix; break;
              case Cogs::hash("sv_position"):     value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_Position; break;
              case Cogs::hash("sv_vertexid"):     value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_VertexID; break;
              case Cogs::hash("sv_instanceid"):   value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_InstanceID; break;
              case Cogs::hash("sv_clipdistance"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_ClipDistance; break;
              case Cogs::hash("sv_vface"):        value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_VFace; break;
              case Cogs::hash("sv_isfrontface"):  value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_IsFrontFace; break;
              default:
                LOG_ERROR(logger, "Unrecognized semantic '%.*s'", StringViewFormat(semanticName));
                return false;
              }
            }
            else {
              LOG_ERROR(logger, "Semantic is not a string");
              return false;
            }
          }
 
          if (arr.Size() >= 3) {
            auto& modifiers = arr[2];
            if (modifiers.IsString()) {
              if (!parseInterpolationModifier(modifiers, value)) return false;
            }
            else if (modifiers.IsArray()) {
              for (auto& modifier : modifiers.GetArray()) {
                if (!parseInterpolationModifier(modifier, value)) return false;
              }
            }
          }
        }
      }
      else if (obj.IsString()) {
        if (!parseType(toKey(obj), value, allowFormat)) return false;
      }
 
      value.name = name.to_string();
      value.inheritanceLevel = inheritanceLevel;
 
      interfaceDefinition.members.push_back(value);
    }
 
    return true;
  }
 
  [[nodiscard]] bool parseOutputType(Cogs::StringView valueString, Cogs::Core::MaterialDataType& type)
  {
    using namespace Cogs::Core;
    const size_t spaceIndex = valueString.find(" ");
    const Cogs::StringView typeString = (spaceIndex != Cogs::StringView::NoPosition) ? valueString.substr(spaceIndex) : valueString;
 
    switch (typeString.hash()) {
    case Cogs::hash("float"):           type = MaterialDataType::Float; break;
    case Cogs::hash("float2"):          type = MaterialDataType::Float2; break;
    case Cogs::hash("float3"):          type = MaterialDataType::Float3; break;
    case Cogs::hash("float4"):          type = MaterialDataType::Float4; break;
    case Cogs::hash("uint"):            type = MaterialDataType::UInt; break;
    case Cogs::hash("uint2"):           type = MaterialDataType::UInt2; break;
    case Cogs::hash("uint3"):           type = MaterialDataType::UInt3; break;
    case Cogs::hash("uint4"):           type = MaterialDataType::UInt4; break;
    case Cogs::hash("int"):             type = MaterialDataType::Int; break;
    case Cogs::hash("int2"):            type = MaterialDataType::Int2; break;
    case Cogs::hash("int3"):            type = MaterialDataType::Int3; break;
    case Cogs::hash("int4"):            type = MaterialDataType::Int4; break;
    default:
      LOG_ERROR(logger, "Failed to parse effect ouput datatype '%.*s'", StringViewFormat(valueString));
      return false;
    }
    return true;
  }
 
  [[nodiscard]] bool parseEffectOutput(const Value& jsonObject, Cogs::Core::EffectOutputDefinition& outputDefinition)
  {
    using namespace Cogs::Core;
    if (!jsonObject.IsObject()) {
      LOG_ERROR(logger, "Effect output is not an JSON object");
      return false;
    }
 
    for (auto& m : jsonObject.GetObject()) {
      Cogs::StringView name = Cogs::Core::toView(m.name);
      auto& obj = m.value;
      EffectOutputMemberDefinition outputMember;
      outputMember.name = name;
      outputMember.target = static_cast<uint8_t>(outputDefinition.members.size());
      outputMember.dataType = MaterialDataType::Float4;
      Cogs::Core::EffectOutputMemberDefinition memberDefinition;
      if (!obj.IsObject()) {
        LOG_ERROR(logger, "Effect output parameter description %s is not a json object.", outputMember.name.c_str());
        return false;
      }
      for (auto& p : obj.GetObject()) {
        Cogs::StringView parameterName = Cogs::Core::toView(p.name);
        auto& parameter = p.value;
        switch (Cogs::hashLowercase(parameterName)) {
          case Cogs::hash("datatype"): {
            // Check that it is a string
            if (!parameter.IsString()) {
              LOG_ERROR(logger, "Datatype of effect output parameter %s for %s is not a string.", parameterName.to_string().c_str(), outputMember.name.c_str());
              return false;
            }
            std::string s = parameter.GetString();
            if (!parseOutputType(s, outputMember.dataType)) return false;
            break;
          }
          case Cogs::hash("target"): {
            if (!parameter.IsInt()) {
              LOG_ERROR(logger, "Target of effect output parameter %s for %s is not a number.", parameterName.to_string().c_str(), outputMember.name.c_str());
              return false;
            }
 
            outputMember.target = static_cast<uint8_t>(parameter.GetInt());
            break;
          }
          default: 
            LOG_ERROR(logger, "Unknown effect output parameter for %s.", parameterName.to_string().c_str());
            return false;
        }
      }
      outputDefinition.members.push_back(outputMember);
    }
    return true;
  }
}
 
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);
  if (enginePermutation->definition->outputs.members.empty()) {
    enginePermutation->definition->outputs = base->definition->outputs;
  }
 
  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;
          }
          else if (vKey == "vertexInterface") {
            if (!parseShaderInterface(v.value, definition->vertexInterface, 0, false)) return false;
          }
          else if (vKey == "surfaceInterface") {
            if (!parseShaderInterface(v.value, definition->surfaceInterface, 0, false)) return false;
          } else if (vKey == "output") {
            if (!parseEffectOutput(v.value, definition->outputs)) 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;
}