MaterialManager.cpp

#include "MaterialManager.h"
 
#include <bitset>
 
#include "Context.h"
 
#include "Material.h"
#include "MaterialBuilder.h"
#include "ResourceStore.h"
#include "ShaderBuilder.h"
 
#include "Components/Core/ClipShapeComponent.h"
#include "Renderer/IRenderer.h"
#include "Serialization/MaterialReader.h"
#include "Systems/Core/CameraSystem.h"
 
#include "TextureManager.h"
#include "EffectManager.h"
#include "DefaultMaterial.h"
#include "MaterialDefinition.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/FileSystemWatcher.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Platform/Timer.h"
 
#include "Rendering/IGraphicsDevice.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("MaterialManager");
}
 
namespace Cogs::Core
{
  struct ShaderTypes
  {
    enum EShaderTypes
    {
      Vertex = 0,
      Hull,
      Domain,
      Geometry,
      Pixel,
      ShaderTypeCount
    };
  };
 
  const static char * ShaderNames[ShaderTypes::ShaderTypeCount] = {
    "VertexShader",
    "HullShader",
    "DomainShader",
    "GeometryShader",
    "PixelShader",
  };
}
 
Cogs::Core::MaterialManager::~MaterialManager()
{
  materials.clear();
  ResourceManager::clear();
 
  reportLeaks("Material");
}
 
void Cogs::Core::MaterialManager::releaseAll()
{
  materialBase = MaterialHandle();
  materials.clear();
  ResourceManager::clear();
}
 
void Cogs::Core::MaterialManager::initializeDefaultMaterial()
{
  context->resourceStore->addSearchPath("../Data/Materials/");
  context->resourceStore->addSearchPath("Materials/");
 
  materialBase = loadMaterial("MaterialBase.material");
 
  defaultResource = loadMaterial("DefaultMaterial.material");
 
  static_cast<void>(loadMaterial("LineMaterial.material"));
  static_cast<void>(loadMaterial("PointMaterial.material"));
  static_cast<void>(loadMaterial("StandardMaterial.material"));
 
  DefaultMaterial::initialize(this);
 
  defaultResource->setTextureProperty(DefaultMaterial::DiffuseMap, context->textureManager->white);
}
 
Cogs::Core::MaterialHandle Cogs::Core::MaterialManager::getDefaultMaterial()
{
  return defaultResource;
}
 
Cogs::Core::MaterialHandle Cogs::Core::MaterialManager::getMaterial(const StringView & name)
{
  auto found = materials.find(name.to_string());
 
  if (found != materials.end()) return found->second;
 
  return MaterialHandle::NoHandle;
}
 
Cogs::Core::MaterialHandle Cogs::Core::MaterialManager::loadMaterial(const StringView & fileName, MaterialLoadFlags materialLoadFlags, ResourceId resourceId)
{
  auto existing = getMaterial(fileName);
 
  if (existing) {
    return existing;
  }
 
  //TODO: Do full path resolve of fileName param before load check, send resolved path as resourcePath to
  // load info.
 
  auto loaded = getAllocatedResources();
 
  for (auto & m : loaded) {
    if (fileName == m->getSource()) {
      return MaterialHandle(m);
    }
  }
 
  MaterialLoadInfo & loadInfo = *createLoadInfo();
  loadInfo.resourceId = resourceId;
  loadInfo.resourcePath = fileName.to_string();
  loadInfo.materialLoadFlags = materialLoadFlags;
 
  if (context->variables->get("resources.materials.autoReload", false)) {
    loadInfo.loadFlags |= ResourceLoadFlags::AutoReload;
  }
 
  return loadResource(&loadInfo);
}
 
void Cogs::Core::MaterialManager::handleLoad(MaterialLoadInfo * loadInfo)
{
  auto material = get(loadInfo->handle);
 
  if (loadInfo->resourcePath.size()) {
    if (!parseMaterial(context, loadInfo->resourcePath, material->definition)) {
      loadInfo->handle->setFailedLoad();
      setProcessed(loadInfo);
      return;
    }
  }
 
  if (!setupMaterial(material)) {
    LOG_WARNING(logger, "Failed set up material %.*s", StringViewFormat(material->getName()));
    loadInfo->handle->setFailedLoad();
    setProcessed(loadInfo);
    return;
  }
 
  auto found = materials.find(material->getName().to_string());
 
  if (found != materials.end()) {
    LOG_WARNING(logger, "Overwriting registered material with name %s. Existing instances will not be affected, but retrieving by name will return new material.", material->getName().data());
  }
 
  materials[material->getName().to_string()] = loadInfo->handle;
 
  setProcessed(loadInfo);
}
 
void Cogs::Core::MaterialManager::handleReload(ResourceHandleBase handle)
{
  MaterialHandle material(handle);
 
  auto loadInfo = createLoadInfo();
  loadInfo->resourceId = material->getId();
  loadInfo->resourcePath = material->getSource().to_string();
  loadInfo->resourceName = material->getName().to_string();
  loadInfo->loadFlags = ResourceLoadFlags::Reload;
  loadInfo->handle = material;
 
  static_cast<void>(loadResource(loadInfo));
}
 
bool Cogs::Core::MaterialManager::setupMaterial(Material * material)
{
  auto & definition = material->definition;
 
  if (!definition.isTemplate()) {
    if (!material->constantBuffers.buffers.size()) {
      if (!applyMaterialDefinition(context, material->definition, *material)) return false;
    } else {
      material->constantBuffers.buffers.clear();
      MaterialDefinition definition_;
      if (!applyMaterialDefinition(context, definition_, *material)) return false;
      material->definition = definition_;
      ++material->constantBuffers.buffersGeneration;
    }
  }
 
  if (definition.isTemplate()) {
    material->setResident();
    return true;
  }
 
  material->permutationKeys.resize(definition.permutations.size());
 
  for (auto & materialPermutation : definition.permutations) {
    material->permutationKeys[materialPermutation.permutationIndex] = materialPermutation.permutationName;
  }
 
  return true;
}
 
namespace
{
  using namespace Cogs::Core;
 
  MaterialDataType formatShaderType(Cogs::Format format)
  {
    // This should match the appropriate shader type
    switch (format) {
    case Cogs::Format::R8_UNORM:
    case Cogs::Format::R16_UNORM:
    case Cogs::Format::R8_SNORM:
    case Cogs::Format::R16_SNORM:
    case Cogs::Format::R16_FLOAT:
    case Cogs::Format::R32_FLOAT:
      return MaterialDataType::Float;// return "float";
    case Cogs::Format::R8G8_UNORM:
    case Cogs::Format::R16G16_UNORM:
    case Cogs::Format::R8G8_SNORM:
    case Cogs::Format::R16G16_SNORM:
    case Cogs::Format::R16G16_FLOAT:
    case Cogs::Format::R32G32_FLOAT:
      return MaterialDataType::Float2;//return "float2";
    case Cogs::Format::R8G8B8_UNORM:
    case Cogs::Format::R16G16B16_UNORM:
    case Cogs::Format::R8G8B8_SNORM:
    case Cogs::Format::R16G16B16_SNORM:
    case Cogs::Format::R16G16B16_FLOAT:
    case Cogs::Format::R32G32B32_FLOAT:
    case Cogs::Format::R8G8B8_UNORM_SRGB:
    case Cogs::Format::R11G11B10_FLOAT:
    case Cogs::Format::R5G6B5_UNORM:
      return MaterialDataType::Float3;//return "float3";
    case Cogs::Format::R8G8B8A8_UNORM:
    case Cogs::Format::R16G16B16A16_UNORM:
    case Cogs::Format::R8G8B8A8_SNORM:
    case Cogs::Format::R16G16B16A16_SNORM:
    case Cogs::Format::R16G16B16A16_FLOAT:
    case Cogs::Format::R32G32B32A32_FLOAT:
    case Cogs::Format::R8G8B8A8_UNORM_SRGB:
    case Cogs::Format::R10G10B10A2_UNORM:
    case Cogs::Format::R5G5B5A1_UNORM:
    case Cogs::Format::R4G4B4A4_UNORM:
    case Cogs::Format::R9G9B9E5_FLOAT:
      return MaterialDataType::Float4;//return "float4";
    case Cogs::Format::R8_UINT:
    case Cogs::Format::R16_UINT:
    case Cogs::Format::R32_UINT:
      return MaterialDataType::UInt;//return "uint";
    case Cogs::Format::R8G8_UINT:
    case Cogs::Format::R16G16_UINT:
    case Cogs::Format::R32G32_UINT:
      return MaterialDataType::UInt2;//return "uint2";
    case Cogs::Format::R8G8B8_UINT:
    case Cogs::Format::R16G16B16_UINT:
    case Cogs::Format::R32G32B32_UINT:
      return MaterialDataType::UInt3;//return "uint3";
    case Cogs::Format::R8G8B8A8_UINT:
    case Cogs::Format::R16G16B16A16_UINT:
    case Cogs::Format::R32G32B32A32_UINT:
    case Cogs::Format::R10G10B10A2_UINT:
      return MaterialDataType::UInt4;//return "uint4";
    case Cogs::Format::R8_SINT:
    case Cogs::Format::R16_SINT:
    case Cogs::Format::R32_SINT:
      return MaterialDataType::Int;//return "int";
    case Cogs::Format::R8G8_SINT:
    case Cogs::Format::R16G16_SINT:
    case Cogs::Format::R32G32_SINT:
      return MaterialDataType::Int2;//return "int2";
    case Cogs::Format::R8G8B8_SINT:
    case Cogs::Format::R16G16B16_SINT:
    case Cogs::Format::R32G32B32_SINT:
      return MaterialDataType::Int3;//return "int3";
    case Cogs::Format::R8G8B8A8_SINT:
    case Cogs::Format::R16G16B16A16_SINT:
    case Cogs::Format::R32G32B32A32_SINT:
      return MaterialDataType::Int4;//return "int4";
    case Cogs::Format::MAT4X4_FLOAT:
      return MaterialDataType::Float4x4;//return "float4x4";
    default:
      LOG_ERROR(logger, "Illegal format %u", unsigned(format));
      return MaterialDataType::Unknown;
    }
  }
 
  const char* formatShaderTypeString(Cogs::Format format)
  {
    switch (formatShaderType(format)) {
    case MaterialDataType::Float:     return "float";
    case MaterialDataType::Float2:    return "float2";
    case MaterialDataType::Float3:    return "float3";
    case MaterialDataType::Float4:    return "float4";
    case MaterialDataType::UInt:      return "uint";
    case MaterialDataType::UInt2:     return "uint2";
    case MaterialDataType::UInt3:     return "uint3";
    case MaterialDataType::UInt4:     return "uint4";
    case MaterialDataType::Int:       return "int";
    case MaterialDataType::Int2:      return "int2";
    case MaterialDataType::Int3:      return "int3";
    case MaterialDataType::Int4:      return "int4";
    case MaterialDataType::Float4x4:  return "float4x4";
    default:
      return "error";
    }
  }
 
  void moveSystemGeneratedParametersLast(std::vector<ShaderInterfaceMemberDefinition>& parameters)
  {
    std::sort(parameters.begin(), parameters.end(),
              [](const ShaderInterfaceMemberDefinition& a, const ShaderInterfaceMemberDefinition& b)
              {
                int aValue = (a.type == MaterialDataType::SV_IsFrontFace || a.type == MaterialDataType::VFACE || a.type == MaterialDataType::SV_InstanceID) ? 1 : 0;
                int bValue = (b.type == MaterialDataType::SV_IsFrontFace || b.type == MaterialDataType::VFACE || b.type == MaterialDataType::SV_InstanceID) ? 1 : 0;
                return aValue < bValue;
              });
  }
 
  void addShaderStageInterfaceMembers(const std::string& materialName,
                                      std::vector<ShaderInterfaceMemberDefinition>& existingMembers,
                                      std::span<const ShaderInterfaceMemberDefinition> newMembers)
  {
    for (const ShaderInterfaceMemberDefinition& member : newMembers) {
 
      // If semantic exists, we just override the name and modifiers
      for (ShaderInterfaceMemberDefinition& existing : existingMembers) {
 
        // Try to filter out duplicates.
 
        if ((member.semantic.name != ShaderInterfaceMemberDefinition::SemanticName::None) &&
            (member.semantic.name == existing.semantic.name) &&
            (member.semantic.slot == existing.semantic.slot))
        {
 
          // Ignore cases where there is no conflict
          if (member.modifiers == existing.modifiers &&
              member.name == existing.name &&
              member.type == existing.type &&
              member.dimension == existing.dimension &&
              member.dimensionString == existing.dimensionString)
          {
            // This can happen because permutations inherit root material etc.
            // We retain the minimum inheritance level
            existing.inheritanceLevel = std::min(existing.inheritanceLevel, member.inheritanceLevel);
          }
          else if (member.inheritanceLevel < existing.inheritanceLevel) {
            LOG_DEBUG(logger, "%s: Replacing '%s' (level=%d) with '%s' (level=%d) (semantic=%d:%d)",
                      materialName.c_str(),
                      existing.name.c_str(), int(existing.inheritanceLevel),
                      member.name.c_str(), int(member.inheritanceLevel),
                      int(existing.semantic.name), int(existing.semantic.slot));
            existing.name = member.name;
            existing.modifiers = member.modifiers;
            existing.type = member.type;
            existing.dimension = member.dimension;
            existing.dimensionString = member.dimensionString;
          }
          else if (existing.inheritanceLevel < member.inheritanceLevel) {
            LOG_DEBUG(logger, "%s: Keeping '%s' (level=%d) over '%s' (level=%d) (semantic=%d:%d)",
                      materialName.c_str(),
                      existing.name.c_str(), int(existing.inheritanceLevel),
                      member.name.c_str(), int(member.inheritanceLevel),
                      int(existing.semantic.name), int(existing.semantic.slot));
          }
          else {
            LOG_ERROR(logger, "%s: Conflicting inheritance levels: '%s' (level=%d) over '%s' (level=%d) (semantic=%d:%d)",
                      materialName.c_str(),
                      existing.name.c_str(), int(existing.inheritanceLevel),
                      member.name.c_str(), int(member.inheritanceLevel),
                      int(existing.semantic.name), int(existing.semantic.slot));
          }
          goto next;
        }
 
        if (member.name == existing.name) {
          // If name match, assume it is a duplicate
          goto next;
        }
      }
 
      // Create new interface member
      existingMembers.emplace_back(member);
    next:
      ;
    }
  }
 
 
  void resolveShaderInterfaceMembers(MaterialDefinition& materialPermutation)
  {
    std::vector<ShaderInterfaceMemberDefinition>& vertexMembers = materialPermutation.effect.vertexShader.shaderInterface.members;
    std::vector<ShaderInterfaceMemberDefinition>& geometryMembers = materialPermutation.effect.geometryShader.shaderInterface.members;
    std::vector<ShaderInterfaceMemberDefinition>& surfaceMembers = materialPermutation.effect.pixelShader.shaderInterface.members;
 
    std::vector<ShaderInterfaceMemberDefinition> tmp;
    addShaderStageInterfaceMembers(materialPermutation.name, tmp, vertexMembers);
    vertexMembers.swap(tmp);
 
    tmp.clear();
    addShaderStageInterfaceMembers(materialPermutation.name, tmp, geometryMembers);
    geometryMembers.swap(tmp);
 
    tmp.clear();
    addShaderStageInterfaceMembers(materialPermutation.name, tmp, surfaceMembers);
    surfaceMembers.swap(tmp);
  }
 
  void addShaderInterfaceMembersFromVariants(MaterialDefinition& materialPermutation,
                                             std::span<const ShaderVariantSelector> selectors,
                                             std::span<const ShaderVariantDefinition> variants)
  {
    std::vector<ShaderInterfaceMemberDefinition>& vertexMembers = materialPermutation.effect.vertexShader.shaderInterface.members;
    std::vector<ShaderInterfaceMemberDefinition>& geometryMembers = materialPermutation.effect.geometryShader.shaderInterface.members;
    std::vector<ShaderInterfaceMemberDefinition>& surfaceMembers = materialPermutation.effect.pixelShader.shaderInterface.members;
 
    for (const ShaderVariantSelector& v : selectors) {
      const ShaderVariantDefinition& variant = variants[v.index];
      if ((variant.type == ShaderVariantType::Bool && v.value == 1) ||
          (variant.type == ShaderVariantType::Format && v.value != 0))
      {
        size_t a = vertexMembers.size();
        addShaderStageInterfaceMembers(materialPermutation.name, vertexMembers, variant.vertexInterface.members);
        size_t b = vertexMembers.size();
 
        // Override format if requested
        if (variant.type == ShaderVariantType::Format) {
          for (size_t i = a; i < b; i++) {
            if (vertexMembers[i].type == MaterialDataType::Unknown) {
              vertexMembers[i].type = formatShaderType(Cogs::Format(selectors[variant.index].value));
            }
          }
        }
        addShaderStageInterfaceMembers(materialPermutation.name, geometryMembers, variant.geometryInterface.members);
        addShaderStageInterfaceMembers(materialPermutation.name, surfaceMembers, variant.surfaceInterface.members);
      }
    }
    moveSystemGeneratedParametersLast(materialPermutation.effect.pixelShader.shaderInterface.members);
  }
 
 
  void addDefinesFromVariants(std::vector<std::pair<std::string, std::string>>& definitions,
                              const MaterialInstance* materialInstance,
                              std::span<const ShaderVariantSelector> selectors,
                              std::span<const ShaderVariantDefinition> variants)
  {
    for (const ShaderVariantSelector& selector : selectors) {
      const ShaderVariantDefinition& variant = variants[selector.index];
 
      if (variant.type == ShaderVariantType::Bool && selector.value == 1) {
        definitions.emplace_back(variant.value, "1");
      }
      
      else if (variant.type == ShaderVariantType::Int) {
        definitions.emplace_back(variant.value, std::to_string(selector.value));
      }
      
      else if (variant.type == ShaderVariantType::Enum) {
        for (auto & enumerator : variant.values) {
          if (enumerator.index == selector.value) {
            definitions.emplace_back(enumerator.value, "1");
            break;
          }
        }
      }
      
      else if (variant.type == ShaderVariantType::Format && selector.value != 0) {
 
        const char* value = nullptr;
        switch (formatShaderType(Cogs::Format(selector.value))) {
        case MaterialDataType::Float:     value = "COGS_FLOAT";     break;
        case MaterialDataType::Float2:    value = "COGS_FLOAT2";    break;
        case MaterialDataType::Float3:    value = "COGS_FLOAT3";    break;
        case MaterialDataType::Float4:    value = "COGS_FLOAT4";    break;
        case MaterialDataType::UInt:      value = "COGS_UINT";      break;
        case MaterialDataType::UInt2:     value = "COGS_UINT2";     break;
        case MaterialDataType::UInt3:     value = "COGS_UINT3";     break;
        case MaterialDataType::UInt4:     value = "COGS_UINT4";     break;
        case MaterialDataType::Int:       value = "COGS_INT";       break;
        case MaterialDataType::Int2:      value = "COGS_INT2";      break;
        case MaterialDataType::Int3:      value = "COGS_INT3";      break;
        case MaterialDataType::Int4:      value = "COGS_INT4";      break;
        case MaterialDataType::Float4x4:  value = "COGS_FLOAT4X4";  break;
        default:
          LOG_ERROR(logger, "Variant selector value is not a valid vertex format");
          value = "ERROR";
          break;
        }
        definitions.emplace_back(variant.value, value);
      }
 
      else if (variant.type == ShaderVariantType::String) {
        if (selector.value == size_t(-1)) continue;
 
        assert(selector.value <= materialInstance->variantStrings.size() && "Variant selector string index out of range.");
        definitions.emplace_back(variant.value, materialInstance->variantStrings[selector.value]);
      }
    }
  }
 
  bool sanityCheckVertexElements(std::span<const Cogs::VertexElement> vertexElements)
  {
    for (size_t i = 1; i < vertexElements.size(); i++) {
      for (size_t j = i; j < vertexElements.size(); j++) {
 
        if ((vertexElements[i - 1].semantic == vertexElements[j].semantic) &&
            (vertexElements[i - 1].semanticIndex == vertexElements[j].semanticIndex))
        {
          LOG_ERROR(logger, "Invalid streams layout, vertex element semantic %.*s%u is specified more than once",
                    StringViewFormat(Cogs::getElementSemanticName(vertexElements[j].semantic)),
                    unsigned(vertexElements[j].semanticIndex));
          return false;
        }
      }
    }
    return true;
  }
 
 
  void adjustVariantsUsingVertexElements(ShaderVariantSelectors& variantSelectors,
                                         const MaterialInstance* materialInstance,
                                         std::span<const Cogs::VertexElement> vertexElements)
  {
    const size_t indexLimit = variantSelectors.size();
    const ShaderVariants& variantDefinitions = materialInstance->material->definition.variants;
    assert(variantDefinitions.size() == indexLimit);
 
    std::string variantKeyBase;
    for (const Cogs::VertexElement& element : vertexElements) {
 
      switch (element.semantic) {
      case Cogs::ElementSemantic::Position:           variantKeyBase = "VertexStreamPosition"; break;
      case Cogs::ElementSemantic::Normal:             variantKeyBase = "VertexStreamNormal"; break;
      case Cogs::ElementSemantic::Color:              variantKeyBase = "VertexStreamColor"; break;
      case Cogs::ElementSemantic::TextureCoordinate:  variantKeyBase = "VertexStreamTexCoord"; break;
      case Cogs::ElementSemantic::Tangent:            variantKeyBase = "VertexStreamTangent"; break;
      case Cogs::ElementSemantic::InstanceVector:     variantKeyBase = "InstanceVector"; break;
      case Cogs::ElementSemantic::InstanceMatrix:     variantKeyBase = "InstanceMatrix"; break;
      default:
        assert(false && "Illegal semantic");
        break;
      }
 
      assert(element.semanticIndex < 10);
      variantKeyBase.push_back(char('0' + element.semanticIndex));
      if (size_t index = materialInstance->material->getVariantIndex(variantKeyBase); index != Material::NoVariantIndex) {
        assert(index < indexLimit);
        assert(variantSelectors[index].index == index);
        assert(variantDefinitions[index].type == ShaderVariantType::Format && "Error in MaterialBase.material");
        variantSelectors[index].value = size_t(element.format);
      }
 
    }
  }
 
  [[nodiscard]] bool checkSingleRequirement(const ShaderVariantSelectors& variantSelectors,
                                            const MaterialInstance* materialInstance,
                                            const ShaderVariantRequirement& requirement)
  {
    if (requirement.variant.empty()) {
      LOG_ERROR(logger, "Empty variant requirement");
      return false;
    }
 
    // Just check for presence, here we allow | in key
    if (requirement.value.empty()) {
      const char* a = requirement.variant.c_str();
      assert(a);
      do {
        const char* b = a;
        while (*b != '\0' && *b != '|') { b++; }
        Cogs::StringView key(a, b - a);
 
        if (size_t ix = materialInstance->material->getVariantIndex(key); ix != Material::NoVariantIndex) {
          const ShaderVariantDefinition& target = materialInstance->material->definition.variants[ix];
          switch (target.type) {
          case ShaderVariantType::Bool:
          case ShaderVariantType::Int:
          case ShaderVariantType::Format:
            if (variantSelectors[ix].value != 0) return true;
            break;
 
          case ShaderVariantType::Enum:
          case ShaderVariantType::String:
            LOG_ERROR(logger, "Requirement '%.*s' references variant with unsupported type", StringViewFormat(key));
            break;
          default:
            assert(false);
          }
        }
        else {
          LOG_ERROR(logger, "Variant requirement '%.*s' refers non-existing variant", StringViewFormat(key));
        }
 
        if (*b == '\0') {
          break;
        }
 
        a = b + 1;
      } while (true);
 
      return false;
    }
 
    size_t ix = materialInstance->material->getVariantIndex(requirement.variant);
    
    if (ix == Material::NoVariantIndex) {
      LOG_ERROR(logger, "Variant requirement %s=%s refers non-existing variant", requirement.variant.c_str(), requirement.value.c_str());
      return false;
    }
 
    assert(ix < materialInstance->material->definition.variants.size());
    const ShaderVariantDefinition& target = materialInstance->material->definition.variants[ix];
 
    // We have an expression. We allow multiple checks to be or'ed together using |
    bool anySuccess = false;
    Cogs::StringView expression = requirement.value;
    size_t a = 0;
    do {
      size_t b = expression.find_first_of('|', a);
      assert(a <= b);
      if (a < b) {
        Cogs::StringView value = expression.substr(a, b == Cogs::StringView::NoPosition ? b : b - a);
 
        // Check for specific value
        switch (target.type) {
        case ShaderVariantType::Format:
 
          if (variantSelectors[ix].value && value == formatShaderTypeString(Cogs::Format(variantSelectors[ix].value))) {
            anySuccess = true;
          }
          else if (const Cogs::FormatInfo* info = Cogs::getFormatInfo(Cogs::Format(variantSelectors[ix].value)); info) {
            if (value == info->vName || value == info->name) {
              anySuccess = true;
            }
          }
          break;
 
        case ShaderVariantType::Bool:
        case ShaderVariantType::Int:
        case ShaderVariantType::Enum:
        case ShaderVariantType::String:
          LOG_ERROR(logger, "Requirement '%s' references variant with type with unimplemented handling", requirement.variant.c_str());
          return false;
        default:
          assert(false);
        }
      }
      if (b == Cogs::StringView::NoPosition) break;
      a = b + 1;
    } while (!anySuccess);
 
    return anySuccess;
  }
 
  void checkVariantTriggers(ShaderVariantSelectors& variantSelectors,
                            const MaterialInstance* materialInstance)
  {
    std::vector<size_t> unsatisifiedSet;
    for (const ShaderVariantSelector& selector : variantSelectors) {
      const ShaderVariantDefinition& variant = materialInstance->material->definition.variants[selector.index];
      if (/*selector.value == 0 &&*/ variant.type == ShaderVariantType::Bool && !variant.triggers.empty()) {
        unsatisifiedSet.push_back(selector.index);
      }
    }
 
    bool anyChange = true;
    std::vector<size_t> nextSet;
    while (!unsatisifiedSet.empty() && anyChange) {
      anyChange = false;
      nextSet.clear();
 
      while (!unsatisifiedSet.empty()) {
        size_t unsatisfiedIx = unsatisifiedSet.back();
        unsatisifiedSet.pop_back();
 
        const ShaderVariantDefinition& unsatisifed = materialInstance->material->definition.variants[unsatisfiedIx];
 
        bool allSatisfied = true;
        for (const ShaderVariantRequirement& requirement : unsatisifed.triggers) {
          allSatisfied = checkSingleRequirement(variantSelectors, materialInstance, requirement);
          if (!allSatisfied) break;
        }
 
        if (allSatisfied) {
          variantSelectors[unsatisfiedIx].value = 1;
          anyChange = true;
        }
        else {
          nextSet.push_back(unsatisfiedIx);
        }
      }
      unsatisifiedSet.swap(nextSet);
    }
  }
 
  [[nodiscard]] bool checkMaterialRequirements(const ShaderVariantSelectors& variantSelectors,
                                               const MaterialInstance* materialInstance)
  {
 
    for (const ShaderVariantRequirement& requirement : materialInstance->material->definition.requirements) {
      if (!checkSingleRequirement(variantSelectors, materialInstance, requirement)) {
        LOG_ERROR(logger, "Material requirement %s=%s not met", requirement.variant.c_str(), requirement.value.c_str());
        return false;
      }
    }
    return true;
  }
 
  [[nodiscard]] bool checkVariantRequirements(const ShaderVariantSelectors& variantSelectors,
                                              const MaterialInstance* materialInstance)
  {
    for (const ShaderVariantSelector& selector : variantSelectors) {
 
      const ShaderVariantDefinition& variant = materialInstance->material->definition.variants[selector.index];
      if (selector.value && variant.type == ShaderVariantType::Bool && !variant.requirements.empty()) {
 
        for(const ShaderVariantRequirement& requirement : variant.requirements) {
 
          if (!checkSingleRequirement(variantSelectors, materialInstance, requirement)) {
            LOG_ERROR(logger, "Material '%.*s' instance '%.*s' variant requirement %s=%s not met",
                      StringViewFormat(materialInstance->material->getName()),
                      StringViewFormat(materialInstance->getName()),
                      requirement.variant.c_str(),
                      requirement.value.c_str());
            return false;
          }
 
        }
      }
    }
    return true;
 
  }
 
 
  bool matchInterfaceMemberToVertexElement(std::span<size_t> memberElementIndex,
                                           std::span<const ShaderInterfaceMemberDefinition> interfaceMembers,
                                           std::span<const Cogs::VertexElement> vertexElements)
 
  {
    assert(memberElementIndex.size() == interfaceMembers.size());
 
    for (size_t j = 0; j < memberElementIndex.size(); j++) {
      const ShaderInterfaceMemberDefinition& member = interfaceMembers[j];
 
      // Match Cogs.Core semantic name to Cogs.Rendering semantic name
      Cogs::ElementSemantic semanticName = Cogs::ElementSemantic::Position;
      switch (member.semantic.name) {
 
      // Semantic not set, report issue and give up.
      case ShaderInterfaceMemberDefinition::SemanticName::None:
        LOG_ERROR(logger, "Vertex shader input '%s' has no associated semantic", member.name.c_str());
        return false;
 
      case ShaderInterfaceMemberDefinition::SemanticName::Position:       semanticName = Cogs::ElementSemantic::Position; break;
      case ShaderInterfaceMemberDefinition::SemanticName::Normal:         semanticName = Cogs::ElementSemantic::Normal; break;
      case ShaderInterfaceMemberDefinition::SemanticName::Color:          semanticName = Cogs::ElementSemantic::Color; break;
      case ShaderInterfaceMemberDefinition::SemanticName::Texcoord:       semanticName = Cogs::ElementSemantic::TextureCoordinate; break;
      case ShaderInterfaceMemberDefinition::SemanticName::Tangent:        semanticName = Cogs::ElementSemantic::Tangent;  break;
      case ShaderInterfaceMemberDefinition::SemanticName::InstanceVector: semanticName = Cogs::ElementSemantic::InstanceVector; break;
      case ShaderInterfaceMemberDefinition::SemanticName::InstanceMatrix: semanticName = Cogs::ElementSemantic::InstanceMatrix; break;
      default:
 
        // System semantics are not sourced by vertex streams
        assert(size_t(ShaderInterfaceMemberDefinition::SemanticName::FirstSystemValueSemantic) <= size_t(member.semantic.name));
        memberElementIndex[j] = ~size_t(0);
        continue;
      }
 
      // Try to match semantic name and slot to the vertex streams
      for (size_t i = 0; i < vertexElements.size(); i++) {
 
        const Cogs::VertexElement& element = vertexElements[i];
        if ((element.semantic == semanticName) && (element.semanticIndex == member.semantic.slot)) {
 
          // Yay.
          memberElementIndex[j] = i;
          goto found;
        }
      }
 
      // Didn't find a match, report issue and give up.
      LOG_ERROR(logger, "Failed to match vertex shader input '%s' with semantic %.*s:%u to a vertex stream semantic",
                member.name.c_str(),
                StringViewFormat(ShaderInterfaceMemberDefinition::semanticNameString(member.semantic.name)),
                unsigned(member.semantic.slot));
      return false;
    found:
      ;
    }
    return true;
  }
 
  void setEnumVariant(ShaderVariantSelectors& variantSelectors, const MaterialInstance* materialInstance, const Cogs::StringView& key, const Cogs::StringView& value)
  {
    if (size_t index = materialInstance->material->getVariantIndex(key); index != Material::NoVariantIndex) {
      assert(index < variantSelectors.size());
      assert(variantSelectors[index].index == index);
      const ShaderVariants& variantDefinitions = materialInstance->material->definition.variants;
      assert(variantDefinitions[index].type == ShaderVariantType::Enum && "Error in MaterialBase.material");
      for (const ShaderVariantEnum& e : variantDefinitions[index].values)
        if (e.key == value) {
          variantSelectors[index].value = e.index;
        }
    }
  }
 
  void setBoolVariant(ShaderVariantSelectors& variantSelectors, const MaterialInstance* materialInstance, const Cogs::StringView& key, bool value)
  {
    if (size_t index = materialInstance->material->getVariantIndex(key); index != Material::NoVariantIndex) {
      assert(index < variantSelectors.size());
      assert(variantSelectors[index].index == index);
      const ShaderVariants& variantDefinitions = materialInstance->material->definition.variants;
      assert(variantDefinitions[index].type == ShaderVariantType::Bool && "Error in MaterialBase.material");
      variantSelectors[index].value = value ? 1 : 0;
    }
  }
 
}
 
Cogs::Core::EffectHandle Cogs::Core::MaterialManager::loadMaterialVariant(Material* material,
                                                                          const MaterialInstance* materialInstance,
                                                                          const MeshStreamsLayout* streamsLayout,
                                                                          const EnginePermutation* permutation,
                                                                          const RenderPassOptions& passOptions,
                                                                          const ClipShapeType clipShape)
{
  assert(materialInstance);
  assert(streamsLayout);
  assert(permutation);
  static int id = 0;
 
  Cogs::GraphicsDeviceType graphicsDeviceType = context->renderer->getDevice()->getType();
 
  if (material->definition.permutations.empty() || materialInstance->permutationIndex > (material->definition.permutations.size() - 1)) {
    LOG_ERROR(logger, "Permutation out of range.");
    return EffectHandle::NoHandle;
  }
 
  // Concatenate all vertex elements into a single array for convenience
  std::vector<VertexElement> vertexElements;
  for (size_t i = 0; i < streamsLayout->numStreams; i++) {
    const VertexFormat* format = VertexFormats::getVertexFormat(streamsLayout->vertexFormats[i]);
    vertexElements.insert(vertexElements.end(),
                          format->elements.begin(),
                          format->elements.end());
  }
  if (!sanityCheckVertexElements(vertexElements)) {
    return EffectHandle::NoHandle;
  }
 
  ShaderVariantSelectors variantSelectors = materialInstance->variantSelectors;
  adjustVariantsUsingVertexElements(variantSelectors, materialInstance, vertexElements);
 
  if (clipShape != ClipShapeType::None) {
 
    bool clipInPixelShader = graphicsDeviceType == GraphicsDeviceType::OpenGLES30;
 
    switch (clipShape) {
    case ClipShapeType::None:
      break;
    case ClipShapeType::Cube:
      setEnumVariant(variantSelectors, materialInstance, "ClipShape", "Cube");
      break;
    case ClipShapeType::InvertedCube:
      setEnumVariant(variantSelectors, materialInstance, "ClipShape", "InvertedCube");
      clipInPixelShader = true;
      break;
    default:
      assert(false && "Invalid enum");
    }
 
    if (clipInPixelShader) {
      setBoolVariant(variantSelectors, materialInstance, "ClipInPixelShader", true);
    }
    else {
      setBoolVariant(variantSelectors, materialInstance, "ClipInVertexShader", true);
    }
  }
 
 
  checkVariantTriggers(variantSelectors, materialInstance);
 
 
  if (!checkMaterialRequirements(variantSelectors, materialInstance)
      || !checkVariantRequirements(variantSelectors, materialInstance))
  {
    return EffectHandle::NoHandle;
  }
 
  // Create a new material permutation
  // ---------------------------------
 
  // Start off with a copy from the material definition and add a running number to its name
  MaterialDefinition materialPermutation = material->definition.permutations[materialInstance->permutationIndex];
  materialPermutation.name += std::to_string(id++);
  materialPermutation.effect.streamsLayout = *streamsLayout;
 
  // Set shared variant values from material
  assert(variantSelectors.size() == material->definition.variants.size());
  for (const ShaderVariantDefinition& definition : material->definition.variants) {
    if (definition.isShared) {
      variantSelectors[definition.index].value = definition.defaultValue;
    }
  }
 
  // Resolve any interface members if there are conflicts
  resolveShaderInterfaceMembers(materialPermutation);
 
  // Add shader stage interface members, handling conflicts as they appear
  addShaderInterfaceMembersFromVariants(materialPermutation, variantSelectors, materialPermutation.variants);
  addShaderInterfaceMembersFromVariants(materialPermutation, permutation->getSelectors(), permutation->getVariants());
 
  // Match vertex stage elements to input streams
  std::vector<size_t> memberElementIndex(materialPermutation.effect.vertexShader.shaderInterface.members.size());
  if (!matchInterfaceMemberToVertexElement(memberElementIndex,
                                           materialPermutation.effect.vertexShader.shaderInterface.members,
                                           vertexElements))
  {
    return EffectHandle::NoHandle;
  }
 
  const std::string& permutationName = permutation->getDefinition()->name;
 
  // Set up the effect definition
  materialPermutation.effect.name = materialPermutation.name + permutationName;
  materialPermutation.effect.vertexShader.loadPath = materialPermutation.name + ShaderNames[ShaderTypes::Vertex] + permutationName;
  if (materialPermutation.effect.hullShader.customSourcePath.size()) {
    materialPermutation.effect.hullShader.loadPath = materialPermutation.name + ShaderNames[ShaderTypes::Hull] + permutationName;
    materialPermutation.effect.domainShader.loadPath = materialPermutation.name + ShaderNames[ShaderTypes::Domain] + permutationName;
  }
  if (materialPermutation.effect.geometryShader.customSourcePath.size()) {
    materialPermutation.effect.geometryShader.loadPath = materialPermutation.name + ShaderNames[ShaderTypes::Geometry] + permutationName;
  }
  materialPermutation.effect.pixelShader.loadPath = materialPermutation.name + ShaderNames[ShaderTypes::Pixel] + permutationName;
 
  // Aggregate preprocessor definitions
  std::vector<std::pair<std::string, std::string>> definitions{
 
    // Define values that BASE_MATERIAL_VERTEX_XYZ can take
    { "COGS_FLOAT",     "1" },
    { "COGS_FLOAT2",    "2" },
    { "COGS_FLOAT3",    "3" },
    { "COGS_FLOAT4",    "4" },
    { "COGS_UINT",      "5" },
    { "COGS_UINT2",     "6" },
    { "COGS_UINT3",     "7" },
    { "COGS_UINT4",     "8" },
    { "COGS_INT",       "9" },
    { "COGS_INT2",      "10" },
    { "COGS_INT3",      "11" },
    { "COGS_INT4",      "12" },
    { "COGS_FLOAT4X4",  "13" }
 
  };
 
  for (auto & d : materialPermutation.effect.definitions) {
    definitions.emplace_back(d.first, d.second);
  }
  for (auto & d : permutation->getDefinition()->definitions) {
    definitions.emplace_back(d.first, d.second);
  }
  addDefinesFromVariants(definitions, materialInstance, permutation->getSelectors(), permutation->getVariants());
  addDefinesFromVariants(definitions, materialInstance, variantSelectors, materialPermutation.variants);
 
  {
    bool success;
    switch (graphicsDeviceType)
    {
    case Cogs::GraphicsDeviceType::OpenGLES30:
      success = buildEffectES3(context, definitions, materialPermutation, *permutation, passOptions.multiViews);
      break;
    case Cogs::GraphicsDeviceType::WebGPU:
      success = buildEffectWebGPU(context, definitions, materialPermutation, *permutation, passOptions.multiViews);
      break;
    default:
      success = buildEffect(context, definitions, materialPermutation, *permutation);
      break;
    }
    if (!success) {
      LOG_ERROR(logger, "Failed to build material shader source");
      return Cogs::Core::EffectHandle::NoHandle;
    }
  }
 
  materialPermutation.effect.definitions.clear();
  materialPermutation.effect.definitions.reserve(definitions.size());
  for (const std::pair<std::string,std::string>& d : definitions) {
    materialPermutation.effect.definitions.emplace_back(PreprocessorDefinition{ d.first, d.second });
  }
 
  EffectHandle effect = context->effectManager->loadEffect(materialPermutation.effect);
 
  effect->material = material;
 
  if (context->watcher && context->variables->get("resources.effects.autoReload", false)) {
    auto watchShader = [&](const StringView & fileName) {
      auto path = context->resourceStore->getResourcePath(fileName);
 
      auto callback = [this, e = effect.get(), path](FileSystemWatcher::Event) {
        context->resourceStore->purge(path);
 
        context->effectManager->handleReload(ResourceHandleBase(e));
      };
 
      auto absolute = IO::absolute(path);
 
      context->watcher->watchFile(absolute, callback);
    };
 
    watchShader(materialPermutation.effect.vertexShader.customSourcePath);
    watchShader(materialPermutation.effect.pixelShader.customSourcePath);
 
    watchShader(permutation->getDefinition()->vertexShader);
    watchShader(permutation->getDefinition()->pixelShader);
  }
 
  return effect;
}
 
Cogs::Core::ActivationResult Cogs::Core::MaterialManager::handleActivation(MaterialHandle handle, Material * /*resource*/)
{
  return context->renderer->getResources()->updateResource(handle);
}
 
void Cogs::Core::MaterialManager::handleDeletion(Material * resource)
{
  context->renderer->getResources()->releaseResource(resource);
}
 
Cogs::Core::MaterialInstanceManager::~MaterialInstanceManager()
{
  reportLeaks("MaterialInstance");
}
 
void Cogs::Core::MaterialInstanceManager::initialize()
{
  ResourceManager::initialize();
 
  resources.resize(16384);
}
 
void Cogs::Core::MaterialInstanceManager::initializeDefaultMaterialInstance()
{
  defaultResource = createMaterialInstance(context->materialManager->getDefaultMaterial());
}
 
Cogs::Core::MaterialInstanceHandle Cogs::Core::MaterialInstanceManager::createMaterialInstance(const MaterialHandle & materialHandle)
{
  auto material = materialHandle.resolve();
 
  auto handle = create();
  auto instance = handle.resolve();
 
  instance->setupInstance(material);
 
  Cogs::GraphicsDeviceType graphicsDeviceType = context->renderer->getDevice()->getType();
  if(graphicsDeviceType == GraphicsDeviceType::WebGPU){
    bool useArrayObjectBuffer = true; // Default on for WebGPU
    const StringView arrayObjectBufferKey = "renderer.arrayObjectBuffer";
    if (Variable* var = context->variables->get(arrayObjectBufferKey); !var->isEmpty()) {
      useArrayObjectBuffer = var->getBool();
    }
    else {
      context->variables->set(arrayObjectBufferKey, useArrayObjectBuffer);
    }
    if(useArrayObjectBuffer){
      size_t index = instance->material->getVariantIndex("UseObjectArray");
      if (index != Material::NoVariantIndex) { // Don't error if variant not defined
        instance->setVariant(index, true);
      }
    }
  }
 
  instance->setLoaded();
  instance->setChanged();
 
  return handle;
}
 
Cogs::Core::MaterialInstanceHandle Cogs::Core::MaterialInstanceManager::getMaterialInstance(const StringView & name)
{
  return getByName(name);
}
 
Cogs::Core::ActivationResult Cogs::Core::MaterialInstanceManager::handleActivation(MaterialInstanceHandle handle, MaterialInstance * /*resource*/)
{
  return context->renderer->getResources()->updateResource(handle);
}
 
void Cogs::Core::MaterialInstanceManager::handleDeletion(MaterialInstance * resource)
{
  context->renderer->getResources()->releaseResource(resource);
}
 
int Cogs::Core::MaterialInstanceManager::getUpdateQuota() const
{
  return context->variables->get("resources.materialInstances.frameUpdateQuota", 0);
}