MaterialSystem.cpp

#include "MaterialSystem.h"
 
#include "Context.h"
 
#include "Resources/MaterialManager.h"
#include "Resources/DefaultMaterial.h"
 
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/SubMeshRenderComponent.h"
 
#include "Foundation/ComponentModel/Entity.h"
 
namespace Cogs
{
  namespace Core
  {
    size_t getMaterialHash(const MaterialComponent & component)
    {
      const uint8_t * beginByte = reinterpret_cast<const uint8_t *>(&component.diffuseMap);
      const uint8_t * endByte = reinterpret_cast<const uint8_t *>(&component.enableTextureOverride) + sizeof(component.enableTextureOverride);
 
      return fnv1a(beginByte, endByte - beginByte);
    }
 
    void applyRenderMaterial(const MaterialComponent & component, const MaterialData& data)
    {
      auto renderComponent = component.getComponent<MeshRenderComponent>();
 
      // If the material component for example is located in an entity of type Material, there will
      // be no render component, so we must check for its availability here.
      if (renderComponent) {
        if (renderComponent->material != data.instance && !renderComponent->customMaterial()) {
          renderComponent->material = data.instance;
        }
      }
 
      auto subMeshRenderComponent = component.getComponent<SubMeshRenderComponent>();
 
      if (subMeshRenderComponent) {
        if (subMeshRenderComponent->materials.empty()) {
          subMeshRenderComponent->materials.resize(1);
        }
 
        if (subMeshRenderComponent->materials.front() != data.instance && !subMeshRenderComponent->customMaterial()) {
          subMeshRenderComponent->materials.front() = data.instance;
        }
      }
    }
  }
}
 
void Cogs::Core::MaterialSystem::update(Context * context)
{
  auto & materialManager = *context->materialManager;
  auto & materialInstanceManager = *context->materialInstanceManager;
 
  for (auto & component : pool) {
    auto & data = getData(&component);
    auto masterMaterial = component.material.lock();
 
    if (masterMaterial) {
      continue;
    } else if (component.hasChanged() || data.instance == MaterialInstanceHandle::NoHandle) {
      bool needsPropertyUpdate = false;
      bool needsRenderChange = false;
 
      if (!data.lockInstance) {
        const size_t materialHash = getMaterialHash(component);
 
        // See if we can find a matching material instance in the shared instances.
        const auto mIt = instances.find(materialHash);
 
        if (mIt != instances.end()) {
          // If the current instance is a custom material, we don't override it.
          if (HandleIsValid(data.instance)) {
            auto instance = materialInstanceManager.get(data.instance);
 
            if (!instance->isDefaultMaterial()) {
              continue;
            }
          }
 
          if (mIt->second != data.instance) {
            data.instance = mIt->second;
            data.sharedInstance = true;
            component.setChanged();
            needsRenderChange = true;
          }
        } else {
          if (HandleIsValid(data.instance)) {
            auto instance = materialInstanceManager.get(data.instance);
 
            if (!instance->isDefaultMaterial()) {
              continue;
            } else if (instance->referenceCount() == 1) {
              instances[materialHash] = data.instance;
              data.sharedInstance = true;
              needsPropertyUpdate = true;
            } else {
              data.instance = materialInstanceManager.createMaterialInstance(materialManager.getDefaultMaterial());
              data.sharedInstance = true;
              component.setChanged();
 
              instances[materialHash] = data.instance;
              needsPropertyUpdate = true;
              needsRenderChange = true;
            }
          } else {
            data.instance = materialInstanceManager.createMaterialInstance(materialManager.getDefaultMaterial());
            data.sharedInstance = true;
            component.setChanged();
 
            instances[materialHash] = data.instance;
            needsPropertyUpdate = true;
            needsRenderChange = true;
          }
        }
      } else {
        if (!HandleIsValid(data.instance)) {
          data.instance = materialInstanceManager.createMaterialInstance(materialManager.getDefaultMaterial());
          needsRenderChange = true;
        }
 
        needsPropertyUpdate = true;
      }
 
      if (needsPropertyUpdate) {
        auto materialInstance = materialInstanceManager.get(data.instance);
 
        if (!materialInstance->isDefaultMaterial()) continue;
 
        auto diffuseColor = component.transparency != 0 ? glm::vec4(glm::vec3(component.diffuseColor), 1.0f - component.transparency) : component.diffuseColor;
 
        materialInstance->setVec4Property(DefaultMaterial::DiffuseColor, diffuseColor);
        materialInstance->setVec3Property(DefaultMaterial::EmissiveColor, glm::vec3(component.emissiveColor));
        materialInstance->setVec3Property(DefaultMaterial::SpecularColor, glm::vec3(component.specularColor));
 
        materialInstance->setFloatProperty(DefaultMaterial::SpecularPower, component.specularPower);
 
        if (component.backdrop) {
          materialInstance->setBackdrop();
        } else {
          materialInstance->unsetBackdrop();
        }
 
        if (component.transparency || component.diffuseColor.a != 1.0f) {
          materialInstance->setTransparent();
        } else {
          materialInstance->setOpaque();
        }
 
        materialInstance->setBoolProperty(DefaultMaterial::EnableLighting, component.enableLighting);
 
        materialInstance->setFloatProperty(DefaultMaterial::LineWidth, component.lineWidth);
 
        if (component.diffuseMapScale != glm::vec2(1, 1)) {
          materialInstance->setVec2Property(DefaultMaterial::DiffuseMapScale, component.diffuseMapScale);
        }
 
        materialInstance->setTextureProperty(DefaultMaterial::DiffuseMap, component.diffuseMap);
        materialInstance->setTextureAddressMode(DefaultMaterial::DiffuseMap, component.addressMode);
        materialInstance->setTextureFilterMode(DefaultMaterial::DiffuseMap, component.filterMode);
 
        materialInstance->setTextureProperty(DefaultMaterial::NormalMap, component.normalMap);
        materialInstance->setTextureAddressMode(DefaultMaterial::NormalMap, component.addressMode);
        materialInstance->setVec2Property(DefaultMaterial::NormalMapScale, component.normalMapScale);
        materialInstance->setFloatProperty(DefaultMaterial::NormalMapFactor, component.normalMapFactor);
 
        materialInstance->setTextureProperty(DefaultMaterial::SpecularMap, component.specularMap);
        materialInstance->setTextureAddressMode(DefaultMaterial::SpecularMap, component.addressMode);
        materialInstance->setVec2Property(DefaultMaterial::SpecularMapScale, component.specularMapScale);
 
        materialInstance->options.blendMode = component.blendMode;
        materialInstance->options.drawOrder = component.drawOrder;
 
        bool hasAdjacency = component.primitiveType == PrimitiveType::LineListAdjacency || component.primitiveType == PrimitiveType::LineStripAdjacency;
        bool isLine = hasAdjacency || component.primitiveType == PrimitiveType::LineList || component.primitiveType == PrimitiveType::LineStrip || component.primitiveType == PrimitiveType::LineStripAdjacency;
        bool isPoints = component.primitiveType == PrimitiveType::PointList;
 
        if (isLine) {
          if (component.instancedLine) {
            materialInstance->setPermutation("InstancedLine");
          }
          else {
            std::string linePermutation = hasAdjacency ? "LineAdj" : "Line";
            materialInstance->setPermutation(linePermutation);
          }
          materialInstance->options.blendMode = BlendMode::Blend;
          materialInstance->setVariant("Textured", HandleIsValid(component.diffuseMap));
          materialInstance->setUIntProperty(materialInstance->material->getUIntKey("stipplePattern"), component.stipplePattern);
          materialInstance->setUIntProperty(materialInstance->material->getUIntKey("stippleFactor"), component.stippleFactor);
        }
        else if (isPoints) {
          materialInstance->setPermutation("Points");
          materialInstance->options.blendMode = BlendMode::Blend;
          materialInstance->setFloatProperty(DefaultMaterial::PointSize, component.pointSize);
        }
        else {
          materialInstance->setPermutation("Default");
 
          materialInstance->setVariant("EnableLighting", component.enableLighting);
          materialInstance->setVariant("LightModel", component.enableLighting ? "Phong" : "BaseColor");
 
          materialInstance->setVariant("ShadowReceiver", component.shadowReceiver);
 
          if (component.diffuseMap || component.normalMap || component.specularMap) {
            materialInstance->setVariant("Textured", true);
 
            if (component.normalMap) {
              materialInstance->setVariant("TangentSpaceNormalMap", true);
            }
 
            if (component.specularMap) {
              materialInstance->setVariant("SpecularMap", true);
            }
          }
        }
 
        if (component.vertexColor) {
          materialInstance->setVariant("VertexColor", true);
        }
 
        materialInstance->options.cullMode = component.cullMode;
 
        materialInstance->options.depthWriteEnabled  = component.depthWriteEnabled;
        materialInstance->options.depthTestEnabled   = component.depthTestEnabled;
        materialInstance->options.depthBiasEnabled   = component.depthBiasEnable;
        materialInstance->options.depthBias.constant = component.depthBiasConstant;
        materialInstance->options.depthBias.slope    = component.depthBiasSlope;
        materialInstance->options.depthBias.clamp    = component.depthBiasClamp;
        materialInstance->options.depthFunc = component.depthTestAlwaysPass ? DepthFunc::Always : DepthFunc::Less;
 
        if (component.enableOverride) {
          materialInstance->setMaterialFlag(MaterialFlags::OverrideColor, component.enableColorOverride);
          materialInstance->setMaterialFlag(MaterialFlags::OverrideAlpha, component.enableAlphaOverride);
          materialInstance->setMaterialFlag(MaterialFlags::OverrideTextures, component.enableTextureOverride);
        } else {
          materialInstance->unsetMaterialFlag(MaterialFlags::Override);
        }
 
        materialInstance->setChanged();
      }
 
      if (needsRenderChange) {
        applyRenderMaterial(component, data);
      }
    }
  }
 
  for (auto & component : pool) {
    auto& data = getData(&component);
    auto masterMaterial = component.material.lock();
 
    if (masterMaterial) {
      auto masterComponent = masterMaterial->getComponent<MaterialComponent>();
 
      assert(masterComponent && "Entity without material components cannot be used as master material.");
 
      if (component.hasChanged() || masterComponent->hasChanged()) {
        auto& masterData = getData(masterComponent);
        auto masterInstance = masterData.instance;
 
        if (data.instance != masterInstance) {
          // Only apply changes if the master material updated its actual material instance.
          data.instance = masterInstance;
 
          component.setChanged();
 
          applyRenderMaterial(component, data);
        }
      }
    }
  }
 
  removeUnusedSharedInstances();
}
 
void Cogs::Core::MaterialSystem::removeUnusedSharedInstances()
{
  std::vector<size_t> removal;
 
  for (auto & sharedInstance : instances) {
    // If the reference count of an instance is equal to 1, the only handle to the instance
    // must be the one we are holding in the \a instances array, and it can therefore be safely
    // removed.
    if (sharedInstance.second.resolve()->referenceCount() == 1) {
      removal.push_back(sharedInstance.first);
    }
  }
 
  for (auto & r : removal) {
    instances.erase(r);
  }
}
 
void Cogs::Core::MaterialSystem::cleanup(Context * /*context*/)
{
  instances.clear();
}