Material.cpp

#include "Foundation/Logging/Logger.h"
 
#include "Material.h"
 
#include <algorithm>
#include <limits>
#include <sstream>
#include "MaterialManager.h"
 
#include "MaterialBuilder.h"
 
 
namespace {
  using namespace Cogs::Core;
 
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("Material");
 
 
  void checkNameNotInBuffer(const ConstantBuffers & contantBuffers, const PropertyName & name)
  {
    for (auto & buffer : contantBuffers.buffers) {
      if (buffer.name == name) {
        assert(false && "Buffer with the given name already exists.");
      }
    }
  }
 
  bool checkVariableKey(const char* method, VariableKey key, size_t numKeys)
  {
    if (key >= numKeys) {
      LOG_ERROR(logger, "%s: Invalid VariableKey: %d", method, key);
      return false;
    }
    else {
      return true;
    }
  }
}
 
Cogs::Core::ConstantBufferKey Cogs::Core::ConstantBuffers::addBuffer(const PropertyName & name, bool isPerInstance)
{
  checkNameNotInBuffer(*this, name);
 
  buffers.emplace_back();
 
  const ConstantBufferKey key = static_cast<ConstantBufferKey>(buffers.size() - 1);
 
  auto & buffer = buffers[key];
  buffer.index = key;
  buffer.name = name;
  buffer.isPerInstance = isPerInstance;
 
  ++buffersGeneration;
 
  return key;
}
 
void Cogs::Core::enforcePropertyFlags(const MaterialProperty & prop, MaterialPropertyFlags flags, void * data)
{
  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]), 2.2f);
    }
  }
 
  if ((int)(flags) & (int)MaterialPropertyFlags::Normalized) {
    float l = 0.f;
    for (int i = 0; i < length; i++) {
      l += values[i] * values[i];
    }
    l = l < std::numeric_limits<float>::epsilon() ? 0.f : 1.f / l;
    for (int i = 0; i < length; i++) {
      values[i] = l * values[i];
    }
  }
 
  if ((int)(flags) & (int)MaterialPropertyFlags::PartitionOfUnity) {
    float l = 0.f;
    for (int i = 0; i < length; i++) {
      values[i] = std::max(0.f, values[i]);
      l += values[i];
    }
    l = l < std::numeric_limits<float>::epsilon() ? 0.f : 1.f / l;
    for (int i = 0; i < length; i++) {
      values[i] = l * values[i];
    }
  }
}
 
 
void Cogs::Core::Material::setTextureProperty(const VariableKey key, TextureHandle value)
{
  if (!checkVariableKey("setTextureProperty", key, textureProperties.size())) {
    return;
  }
 
  TextureProperty& textureVariable = textureProperties[key];
  if (value != textureVariable.texture.handle) {
    textureVariable.texture.handle = value;
    textureVariable.dirty = true;
    setChanged();
  }
}
 
MaterialDataType Cogs::Core::Material::getPropertyDataType(const StringView& key)
{
  const VariableKey variableKey = constantBuffers.getPropertyKey(key);
 
  if (variableKey == NoProperty) {
    return MaterialDataType::Unknown;
  }
 
  const auto& materialProperty = constantBuffers.variables[variableKey];
  return materialProperty.type;
}
 
void Cogs::Core::Material::setTextureAddressMode(const VariableKey key, SamplerState::AddressMode mode)
{
  setTextureAddressMode(key, mode, mode, mode);
}
 
void Cogs::Core::Material::setTextureAddressMode(const VariableKey key, SamplerState::AddressMode smode, SamplerState::AddressMode tmode, SamplerState::AddressMode umode)
{
  if (!checkVariableKey("setTextureAddressMode", key, textureProperties.size())) {
    return;
  }
 
  TextureProperty& textureVariable = textureProperties[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::Material::setTextureFilterMode(const VariableKey key, SamplerState::FilterMode filterMode)
{
  if (!checkVariableKey("setTextureFilterMode", key, textureProperties.size())) {
    return;
  }
 
  TextureProperty& textureVariable = textureProperties[key];
  if (textureVariable.texture.filterMode != filterMode) {
    textureVariable.texture.filterMode = filterMode;
    textureVariable.dirty = true;
    setChanged();
  }
}
 
size_t Cogs::Core::Material::getVariantIndex(const StringView& key) const
{
  for (const ShaderVariantDefinition& v : definition.variants) {
    if (key == v.name) {
      return v.index;
    }
  }
 
  return NoVariantIndex;
}
 
void Cogs::Core::Material::setVariant(size_t index, int value)
{
  if (definition.variants.size() <= index) {
    LOG_ERROR(logger, "Variant index out of range.");
    return;
  }
  assert(definition.variants[index].index == index && "Variant selector index invalid.");
  ShaderVariantDefinition& variantDefinition = definition.variants[index];
  if (!variantDefinition.isShared) {
    LOG_ERROR_ONCE(logger, "Trying to set a non-shared variant via the material.");
    return;
  }
 
  if (variantDefinition.type != ShaderVariantType::Int) {
    LOG_ERROR(logger, "Variant type is not Int");
    return;
  }
  if (variantDefinition.defaultValue != value) {
    variantDefinition.defaultValue = value;
    variantGeneration++;
    setChanged();
  }
}
 
void Cogs::Core::Material::setVariant(const StringView& key, int value)
{
  size_t ix = getVariantIndex(key);
  if (ix == Material::NoVariantIndex) {
    LOG_ERROR(logger, "Unrecognized variant name '%.*s'", StringViewFormat(key));
    return;
  }
  setVariant(ix, value);
}
 
Cogs::Core::EffectHandle Cogs::Core::Material::getEffect(size_t code,
                                                         const MaterialInstance* materialInstance,
                                                         const MeshStreamsLayout* streamsLayout,
                                                         const EnginePermutation* enginePermutation,
                                                         const RenderPassOptions& passOptions,
                                                         const ClipShapeType clipShape)
{
  for (auto & e : effects) {
    if (e.code == code) return e.handle;
  }
 
  MaterialManager* materialManager = (MaterialManager *)getOwner();
 
  EffectHandle effect = materialManager->loadMaterialVariant(this, materialInstance, streamsLayout, enginePermutation, passOptions, clipShape);
 
  effects.push_back(EffectInstance{ effect, code });
 
  return effect;
}
 
void Cogs::Core::Material::setProperty(const StringView& name, const void* data, const size_t sizeInBytes)
{
  VariableKey key = constantBuffers.getPropertyKey(name);
  MaterialProperty& materialProperty = constantBuffers.variables[key];
 
  // For smaller elements, take a copy so we may modify the value if necessary.
  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;
  }
  constantBuffers.buffers[materialProperty.buffer].setValue(materialProperty.descriptor, static_cast<const uint8_t*>(data));
 
  setChanged();
}