MaterialInstance.cpp

#include "MaterialInstance.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Texture.h"
 
#include "Utilities/Parsing.h"
 
#include <cstring>
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("MaterialInstance");
 
  void initializeInstanceTextureVariables(std::vector<TextureValue>& variables, const std::span<const TextureProperty>& properties)
  {
    for (const TextureProperty& p : properties) {
      TextureValue& v = variables.emplace_back();
      v.property = &p;
      v.key = p.key;
      v.texture = p.texture;
    }
  }
 
  void reversePropertyFlags(const MaterialProperty& prop, MaterialPropertyFlags flags, void* data, size_t /*size*/)
  {
    float* values = nullptr;
    int length = 0;
    switch (prop.type) {
    case MaterialDataType::Float:
      values = (float*)data;
      length = 1;
      break;
    case MaterialDataType::Float2:
      values = (float*)data;
      length = 2;
      break;
    case MaterialDataType::Float3:
      values = (float*)data;
      length = 3;
      break;
    case MaterialDataType::Float4:
      values = (float*)data;
      length = 4;
      break;
    default:
      break;
    }
 
    if (!values || !length) return;
 
    if ((int)(flags) & (int)MaterialPropertyFlags::sRGB) {
      for (int i = 0; i < std::min(3, length); i++) {
        values[i] = std::pow(std::abs(values[i]), 1.0f / 2.2f);
      }
    }
  }
 
  static constexpr const char* shaderVariantTypeName[] = {
    "None",
    "Bool",
    "Int",
    "Enum",
    "Format",
    "String",
  };
 
  bool setVariantImpl(MaterialInstance* that, const ShaderVariantDefinition& definition, ShaderVariantType type, size_t value)
  {
    if (definition.type != type) {
      LOG_ERROR(logger, "Variant type is not %s", shaderVariantTypeName[size_t(type)]);
      return false;
    }
    if (definition.isShared) {
      LOG_ERROR(logger, "Cannot set shared variant through material instance");
      return false;
    }
    assert(definition.index < that->variantSelectors.size());
    ShaderVariantSelector& selector = that->variantSelectors[definition.index];
 
    assert(selector.index == definition.index);
    if (selector.value != value) {
      selector.value = value;
      that->variantGeneration++;
      that->setChanged();
    }
    return true;
  }
 
  bool setVariantImpl(MaterialInstance* that, size_t index, ShaderVariantType type, size_t value)
  {
    if (that->material->definition.variants.size() <= index) {
      LOG_ERROR(logger, "Variant index %zu out of range.", index);
      return false;
    }
    const ShaderVariantDefinition& definition = that->material->definition.variants[index];
    assert(definition.index == index);
    return setVariantImpl(that, definition, type, value);
  }
 
  size_t lookupVariantValue(const MaterialInstance* that, const ShaderVariantDefinition& definition)
  {
    if (definition.isShared) return definition.defaultValue;
    
    assert(definition.index < that->variantSelectors.size());
    const ShaderVariantSelector& selector = that->variantSelectors[definition.index];
 
    assert(selector.index == definition.index);
    return selector.value;
  }
 
  bool lookupVariantIndex(const MaterialInstance* that, size_t& index, const Cogs::StringView& key)
  {
    index = that->material->getVariantIndex(key);
    if (index != Material::NoVariantIndex) {
      return true;
    }
    LOG_ERROR(logger, "Unrecognized variant name '%.*s'", StringViewFormat(key));
    return false;
  }
 
}
 
void Cogs::Core::MaterialInstance::setupInstance(Material * material)
{
  this->material = material;
 
  for (auto & buffer : material->constantBuffers.buffers) {
    buffers.emplace_back();
 
    auto & instanceBuffer = buffers[buffers.size() - 1];
 
    if (buffer.isPerInstance) {
      instanceBuffer.content = buffer.content;
    }
    instanceBuffer.name = buffer.name;
    instanceBuffer.isPerInstance = buffer.isPerInstance;
    instanceBuffer.index = buffer.index;
    instanceBuffer.size = buffer.size;
  }
 
  options = material->options;
 
  variantSelectors.resize(material->definition.variants.size());
 
  for (auto & v : material->definition.variants) {
    variantSelectors[v.index].index = v.index;
    variantSelectors[v.index].value = v.defaultValue;
  }
 
  initializeInstanceTextureVariables(textureVariables, material->textureProperties);
}
 
void Cogs::Core::MaterialInstance::clone(MaterialInstance * instance)
{
  if (material != instance->material) {
    buffersGeneration++;
    material = instance->material;
  }
 
  masterInstance = instance->masterInstance;
  buffers = instance->buffers;
  for (MaterialPropertyBufferInstance& b : buffers) b.generation++;
 
  textureVariables = instance->textureVariables;
  instanceFlags = instance->instanceFlags;
  options = instance->options;
  variantSelectors = instance->variantSelectors;
  variantStrings = instance->variantStrings;
  variantGeneration++;
  permutationIndex = instance->permutationIndex;
 
  setChanged();
}
 
int Cogs::Core::MaterialInstance::cloneMatchingProperties(MaterialInstance * instance)
{
  if (!instance) {
    LOG_ERROR(logger, "Material instance not valid.");
    return 0;
  }
 
  if (!material || !instance->material) {
    LOG_ERROR(logger, "Invalid or missing materials.");
    return 0;
  }
 
  int cloned = 0;
 
  for (auto & dp : material->constantBuffers.variables) {
    for (auto & sp : instance->material->constantBuffers.variables) {
      if (dp.name == sp.name && dp.type == sp.type && dp.flags == sp.flags) {
        auto numBytes = DataTypeSizes[(unsigned)dp.type];
 
        union alignas(float) {
          char buffer[64];
        };
 
        if (dp.type == MaterialDataType::Bool) {
          auto value = instance->getBoolProperty(sp.key);
          setBoolProperty(dp.key, value);
        } else if (instance->getProperty(sp.key, buffer, numBytes)) {
          setProperty(dp.key, buffer, numBytes);
          ++cloned;
        } else {
          LOG_ERROR(logger, "Could not clone property %s.", dp.name.c_str());
        }
      }
    }
  }
 
  for (auto & tp : material->textureProperties) {
    for (auto & dp : instance->material->textureProperties) {
      if (dp.name == tp.name) {
        setTextureProperty(tp.key, instance->getTextureProperty(dp.key).texture.handle);
      }
    }
  }
 
  return cloned;
}
 
void Cogs::Core::MaterialInstance::cloneMatchingVariants(MaterialInstance* srcInstance)
{
  if (!srcInstance) {
    LOG_ERROR(logger, "Material instance not valid.");
    return;
  }
 
  if (!material || !srcInstance->material) {
    LOG_ERROR(logger, "Invalid or missing materials.");
    return;
  }
 
  for (const ShaderVariantDefinition& srcDefinition : srcInstance->material->definition.variants) {
    if (srcDefinition.isShared) continue; // We do not clone from shared variants
 
 
    if (size_t dstIndex = material->getVariantIndex(srcDefinition.name); dstIndex != Material::NoVariantIndex) {
 
      const ShaderVariantDefinition& dstDefinition = material->definition.variants[dstIndex];
      if (srcDefinition.type != dstDefinition.type) continue; // Silently ignore mis-matched types.
      if (dstDefinition.isShared) continue; // We do not clone into shared variants
 
      size_t srcValue =  lookupVariantValue(srcInstance, srcDefinition);
      if (dstDefinition.type == ShaderVariantType::String) {
        assert(srcValue < srcInstance->variantStrings.size());
        setVariant(dstIndex, srcInstance->variantStrings[srcValue]);
      }
      else {
        setVariantImpl(this, dstDefinition, srcDefinition.type, srcValue);
      }
    }
  }
}
 
void Cogs::Core::MaterialInstance::reset()
{
  assert(material);
 
  for (size_t i = 0; i < material->constantBuffers.buffers.size(); ++i) {
    auto & buffer = material->constantBuffers.buffers[i];
    auto & instanceBuffer = buffers[i];
 
    if (buffer.isPerInstance) {
      instanceBuffer.content = buffer.content;
    }
  }
 
  options = material->options;
 
  textureVariables.clear();
  initializeInstanceTextureVariables(textureVariables, material->textureProperties);
}
 
bool Cogs::Core::MaterialInstance::hasTransparency() const
{
  if ((instanceFlags & MaterialFlags::MasterTransparency) != 0) return true;
 
  switch (options.transparencyMode)
  {
  case TransparencyMode::Off:
    return false;
  case TransparencyMode::On:
    return true;
  case TransparencyMode::Auto:
  {
    VariableKey diffuseKey = material->getVec4Key("diffuseColor");
    if (diffuseKey != NoProperty && getVec4Property(diffuseKey).a < 1.0f) {
      return true;
    }
    for (const TextureValue& t : textureVariables) {
      if (HandleIsValid(t.texture.handle) && t.texture.handle->hasAlpha) {
        return true;
      }
    }
    return false;
  }
  default:
    break;
  }
 
  return false;
}
 
void Cogs::Core::MaterialInstance::setTransparent()
{
  options.transparencyMode = TransparencyMode::On;
  setVariant("ShadowCast", "Transparent");
}
 
void Cogs::Core::MaterialInstance::setOpaque()
{
  options.transparencyMode = TransparencyMode::Off;
  setVariant("ShadowCast", "Opaque");
}
 
void Cogs::Core::MaterialInstance::setOption(const StringView & key, const StringView & value)
{
  applyMaterialOption(options, key, value);
}
 
void Cogs::Core::MaterialInstance::setProperty(const StringView & name, const void * data, const size_t sizeInBytes)
{
  auto key = material->constantBuffers.getPropertyKey(name);
 
  if (key == NoProperty) {
    LOG_ERROR(logger, "Could not get key for property %.*s.", StringViewFormat(name));
    return;
  }
 
  setProperty(key, data, sizeInBytes);
}
 
void Cogs::Core::MaterialInstance::setProperty(VariableKey key, const void * data, const size_t sizeInBytes)
{
  auto & materialProperty = material->constantBuffers.variables[key];
 
  // For smaller elements, take a copy so we may modify the value if necessary.
  // FIXME: Handle arrays
  uint8_t valueBuffer[sizeof(glm::mat4)];
  if (sizeInBytes <= sizeof(glm::mat4)) {
    std::memcpy(valueBuffer, data, sizeInBytes);
    if (materialProperty.flags != MaterialPropertyFlags::None) {
      enforcePropertyFlags(materialProperty, materialProperty.flags, valueBuffer);
    }
    data = &valueBuffer;
  }
 
  bool okSize = true;
  if (materialProperty.descriptor.size == 4) {
    // Possibly Boolean - accept 1(bool) or 4(int)
    if (sizeInBytes != 1 && sizeInBytes != 4) {
      okSize = false;
    }
  }
  else if (sizeInBytes != materialProperty.descriptor.size) {
    // Size mismatch also for types with Size=0.
    okSize = false;
  }
 
  if (!okSize) {
    LOG_ERROR(logger, "setProperty: Invalid size given Property=%s, Expected=%zu, Given=%zu",
      materialProperty.name.data(), materialProperty.descriptor.size, sizeInBytes);
    return;
  }
 
  buffers[materialProperty.buffer].setValue(materialProperty.descriptor, static_cast<const uint8_t *>(data));
 
  setChanged();
}
 
bool Cogs::Core::MaterialInstance::getProperty(const StringView & name, void * value, const size_t sizeInBytes) const
{
  auto key = material->constantBuffers.getPropertyKey(name);
 
  if (key == NoProperty) {
    LOG_ERROR(logger, "Could not get key for property %.*s.", StringViewFormat(name));
    return false;
  }
 
  return getProperty(key, value, sizeInBytes);
}
 
bool Cogs::Core::MaterialInstance::getProperty(VariableKey key, void * value, const size_t sizeInBytes) const
{
  if (key > material->constantBuffers.variables.size()) {
    LOG_ERROR(logger, "Key %d out of range.", key);
    return false;
  }
 
  auto & materialProperty = material->constantBuffers.variables[key];
 
  if (materialProperty.isPerInstance) {
    std::memcpy(value, buffers[materialProperty.buffer].content.data() + materialProperty.descriptor.offset, sizeInBytes);
  }
  else {
    std::memcpy(value, material->constantBuffers.buffers[materialProperty.buffer].content.data() + materialProperty.descriptor.offset, sizeInBytes);
  }
  
 
  if (materialProperty.flags != MaterialPropertyFlags::None) {
    reversePropertyFlags(materialProperty, materialProperty.flags, value, sizeInBytes);
  }
 
  return true;
}
 
void Cogs::Core::MaterialInstance::setTextureAddressMode(const StringView & name, const StringView & addressMode)
{
  if (VariableKey key = material->getTextureKey(name); key != NoProperty) {
 
    switch (addressMode.hashLowercase()) {
    case Cogs::hash("clamp"):
    case Cogs::hash("clamptoedge"):   // GL name
      setTextureAddressMode(key, SamplerState::Clamp);
      break;
 
    case Cogs::hash("wrap"):
    case Cogs::hash("repeat"):        // GL name
      setTextureAddressMode(key, SamplerState::Wrap);
      break;
 
    case Cogs::hash("mirror"):
    case Cogs::hash("mirrorrepeat"):  // GL name
      setTextureAddressMode(key, SamplerState::Mirror);
      break;
 
    case Cogs::hash("border"):
    case Cogs::hash("clamptoborder"): // GL name
      setTextureAddressMode(key, SamplerState::Border);
      break;
 
    default:
      LOG_WARNING_ONCE(logger, "Unrecognized address mode '%.*s'", StringViewFormat(addressMode));
      break;
    }
  }
}
 
void Cogs::Core::MaterialInstance::setTextureFilterMode(const StringView& name, const StringView& filterMode)
{
  if (VariableKey key = material->getTextureKey(name); key != NoProperty) {
    switch (filterMode.hashLowercase()) {
 
    case Cogs::hash("point"):
    case Cogs::hash("minmagmippoint"):
      setTextureFilterMode(key, SamplerState::FilterMode::MinMagMipPoint);
      break;
 
    case Cogs::hash("linear"):
    case Cogs::hash("minmagmiplinear"):
      setTextureFilterMode(key, SamplerState::FilterMode::MinMagMipLinear);
      break;
 
    case Cogs::hash("comparisonpoint"):
    case Cogs::hash("comparisonminmagmiploint"):
      setTextureFilterMode(key, SamplerState::FilterMode::ComparisonMinMagMipPoint);
      break;
 
    case Cogs::hash("comparisonlinear"):
    case Cogs::hash("comparisonminmagmiplinear"):
      setTextureFilterMode(key, SamplerState::FilterMode::ComparisonMinMagMipLinear);
      break;
 
    default:
      LOG_WARNING_ONCE(logger, "Unrecognized filter mode '%.*s'", StringViewFormat(filterMode));
      break;
    }
  }
}
 
void Cogs::Core::MaterialInstance::setTextureProperty(const StringView & key, TextureHandle value)
{
  setTextureProperty(material->getTextureKey(key), value);
}
 
void Cogs::Core::MaterialInstance::setTextureProperty(const VariableKey key, TextureHandle value)
{
  if (key == NoProperty) {
    LOG_ERROR(logger, "Cannot set texture property with invalid key.");
    return;
  }
 
  auto & textureVariable = textureVariables[key];
 
  if (value != textureVariable.texture.handle) {
    textureVariable.texture.handle = value;
    textureVariable.dirty = true;
 
    setChanged();
  }
}
 
void Cogs::Core::MaterialInstance::setTextureAddressMode(const VariableKey key, SamplerState::AddressMode mode)
{
  setTextureAddressMode(key, mode, mode, mode);
}
 
void Cogs::Core::MaterialInstance::setTextureAddressMode(const VariableKey key, SamplerState::AddressMode sMode, SamplerState::AddressMode tMode, SamplerState::AddressMode uMode)
{
  if (key == NoProperty) {
    LOG_ERROR(logger, "Cannot set texture property with invalid key.");
    return;
  }
 
  auto & textureVariable = textureVariables[key];
 
  if (sMode != textureVariable.texture.sMode || tMode != textureVariable.texture.tMode || uMode != textureVariable.texture.uMode) {
    textureVariable.texture.sMode = sMode;
    textureVariable.texture.tMode = tMode;
    textureVariable.texture.uMode = uMode;
    textureVariable.dirty = true;
 
    setChanged();
  }
}
 
void  Cogs::Core::MaterialInstance::setTextureFilterMode(const VariableKey key, SamplerState::FilterMode filterMode)
{
  if (key == NoProperty) {
    LOG_ERROR(logger, "Cannot set texture property with invalid key.");
    return;
  }
 
  TextureValue& textureVariable = textureVariables[key];
  if (textureVariable.texture.filterMode != filterMode) {
    textureVariable.texture.filterMode = filterMode;
    setChanged();
  }
}
 
 
size_t Cogs::Core::MaterialInstance::getPermutationIndex(const StringView & key) const
{
  for (size_t i = 0; i < material->permutationKeys.size(); ++i) {
    if (key == material->permutationKeys[i]) {
      return i;
    }
  }
 
  return 0;
}
 
void Cogs::Core::MaterialInstance::setPermutation(const StringView & key)
{
  size_t ix = getPermutationIndex(key);
  if (permutationIndex == ix) return;  // No change
 
  // Update permutation index
  permutationIndex = ix;
 
  // Initialize variant selectors to be used with new permutation
  const MaterialDefinition& definition = material->definition.permutations[permutationIndex];
  const ShaderVariants& variants = definition.variants;
 
  variantSelectors.resize(variants.size());
  for (auto& v : variants) {
    variantSelectors[v.index].index = v.index;
    variantSelectors[v.index].value = v.defaultValue;
  }
  variantGeneration++;
  setChanged();
}
 
Cogs::StringView Cogs::Core::MaterialInstance::getPermutation() const
{
  return material->permutationKeys[permutationIndex];
}
 
void Cogs::Core::MaterialInstance::setVariant(size_t index, bool value)
{
  setVariantImpl(this, index, ShaderVariantType::Bool, value ? 1 : 0);
}
 
void Cogs::Core::MaterialInstance::setVariant(size_t index, int value)
{
  setVariantImpl(this, index, ShaderVariantType::Int, size_t(value));
}
 
void Cogs::Core::MaterialInstance::setVariant(size_t index, const StringView & value)
{
  assert(index < material->definition.variants.size());
  const ShaderVariantDefinition& variantDefinition = material->definition.variants[index];
  switch (variantDefinition.type) {
  case ShaderVariantType::None:
    if (!value.empty()) {
      LOG_ERROR(logger, "Trying to set variant %s with no type to '%.*s'.", variantDefinition.name.c_str(), StringViewFormat(value));
    }
    break;
 
  case ShaderVariantType::Bool:
    if (bool val = false; parseBool_(val, value)) {
      setVariantImpl(this, variantDefinition, ShaderVariantType::Bool, val ? 1 : 0);
    }
    break;
 
  case ShaderVariantType::Int:
    if (int val = 0; parseInt_(val, value)) {
      setVariantImpl(this, variantDefinition, ShaderVariantType::Int, val);
    }
    break;
 
  case ShaderVariantType::Format:
    if (Cogs::DataFormat format = Cogs::parseDataFormat(value); format != Cogs::DataFormat::Unknown) {
      setVariantImpl(this, variantDefinition, ShaderVariantType::Format, size_t(format));
    }
    else {
      LOG_ERROR(logger, "Failed to parse data format \"%.*s\"", StringViewFormat(value));
    }
    break;
 
  case ShaderVariantType::Enum:
    for (const ShaderVariantEnum& e : variantDefinition.values) {
      if (value == e.key) {
        setVariantImpl(this, variantDefinition, Cogs::Core::ShaderVariantType::Enum, e.index);
        return;
      }
    }
    LOG_ERROR(logger, "Unrecognized enum value '%.*s'", StringViewFormat(value));
    break;
 
  case ShaderVariantType::String:
    for (size_t strIx = 0, strCnt = variantStrings.size(); strIx < strCnt; strIx++) {
      if (variantStrings[strIx] == value) {
        setVariantImpl(this, variantDefinition, Cogs::Core::ShaderVariantType::String, strIx);
        return;
      }
    }
    setVariantImpl(this, variantDefinition, Cogs::Core::ShaderVariantType::String, variantStrings.size());
    variantStrings.emplace_back(value.begin(), value.end());
    break;
 
  default:
    assert(false && "Invalid ShaderVariantType enum value");
    break;
  }
}
 
void Cogs::Core::MaterialInstance::setVariant(const StringView& key, bool value)
{
  if (size_t index; lookupVariantIndex(this, index, key)) {
    setVariant(index, value);
  }
}
 
void Cogs::Core::MaterialInstance::setVariant(const StringView& key, int value)
{
  if (size_t index; lookupVariantIndex(this, index, key)) {
    setVariant(index, value);
  }
}
 
void Cogs::Core::MaterialInstance::setVariant(const StringView& key, const StringView& value)
{
  if (size_t index; lookupVariantIndex(this, index, key)) {
    setVariant(index, value);
  }
}
 
std::string Cogs::Core::MaterialInstance::getVariant(const StringView& key) const
{
  size_t index;
  if (!lookupVariantIndex(this, index, key)) {
    return std::string();
  }
  assert(index < material->definition.variants.size());
  const ShaderVariantDefinition& definition = material->definition.variants[index];
 
  size_t value = lookupVariantValue(this, definition);
 
  switch (definition.type) {
  case ShaderVariantType::None:
    return std::string();
 
  case ShaderVariantType::Bool:
    return value ? "true" : "false";
 
  case ShaderVariantType::Int:
    return std::to_string(int(value));
 
  case ShaderVariantType::Format:
    if (const Cogs::FormatInfo* info = Cogs::getFormatInfo(Cogs::Format(value)); info) {
      return info->vName;
    }
    LOG_ERROR(logger, "Variant '%.*s' has invalid format enum %zd", StringViewFormat(key), value);
    break;
 
  case ShaderVariantType::Enum:
    for (const ShaderVariantEnum& e : definition.values) {
      if (value == e.index) {
        return e.key;
      }
    }
    LOG_ERROR(logger, "Variant '%.*s' contains illegal enum index %zd", StringViewFormat(key), value);
    break;
 
  case ShaderVariantType::String:
    if (value < variantStrings.size()) {
      return variantStrings[value];
    }
    LOG_ERROR(logger, "Variant '%.*s' contains illegal string index %zd", StringViewFormat(key), value);
    break;
 
  default:
    assert(false && "Invalid ShaderVariantType enum value");
    break;
  }
 
  return std::string();
}