ModelSystem.cpp

#include "ModelSystem.h"
#include "Context.h"
#include "EntityStore.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Appearance/MaterialComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/AnimationComponent.h"
#include "Components/Core/PropertiesComponent.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/SceneSystem.h"
#include "Systems/Core/MeshSystem.h"
#include "Systems/Core/RenderSystem.h"
#include "Systems/Appearance/MaterialSystem.h"
 
#include "Services/DeferredNameResolution.h"
 
#include "Resources/ModelManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/DefaultMaterial.h"
#include "Resources/Texture.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/Timer.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ModelSystem");
}
 
namespace Cogs
{
  namespace Core
  {
    void forwardRenderProperties(SceneComponent * sceneComp, const RenderComponent * masterRenderComp)
    {
      for (auto & child : sceneComp->children) {
        auto * childRenderComp = child->getComponent<RenderComponent>();
 
        if (childRenderComp) {
          childRenderComp->layer = masterRenderComp->layer;
          childRenderComp->objectId = masterRenderComp->objectId;
          childRenderComp->drawOrder = masterRenderComp->drawOrder;
          childRenderComp->renderFlags |= masterRenderComp->renderFlags & RenderFlags::CastShadows;
          childRenderComp->setChanged();
        }
        forwardRenderProperties(child->getComponent<SceneComponent>(), masterRenderComp);
      }
    }
 
    MaterialInstanceHandle getMaterialInstance(Context * context)
    {
      return context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
    }
 
    void updateMasterMaterial(Context * /*context*/, ModelData & modelData, MaterialInstanceHandle masterMaterial)
    {
      modelData.masterMaterial = masterMaterial;
 
      for (auto & materialInstance : modelData.materials) {
        if (!materialInstance->isDefaultMaterial()) continue;
 
        materialInstance->masterInstance = masterMaterial;
 
        if (masterMaterial->isDefaultMaterial()) {
          const bool overrideColor = (masterMaterial->getMaterialFlags() & MaterialFlags::OverrideColor) != 0;
          const bool overrideAlpha = (masterMaterial->getMaterialFlags() & MaterialFlags::OverrideAlpha) != 0;
 
          if (overrideColor || overrideAlpha) {
            auto masterColor = masterMaterial->getVec4Property(DefaultMaterial::DiffuseColor);
 
            materialInstance->setVec4Property(DefaultMaterial::MasterColor, masterColor);
            materialInstance->setBoolProperty(DefaultMaterial::OverrideColor, overrideColor);
            materialInstance->setBoolProperty(DefaultMaterial::OverrideAlpha, overrideAlpha);
 
            if (overrideAlpha && masterColor.a != 1) {
              materialInstance->setMaterialFlag(MaterialFlags::MasterTransparency);
            } else {
              materialInstance->unsetMaterialFlag(MaterialFlags::MasterTransparency);
            }
          } else {
            materialInstance->setBoolProperty(DefaultMaterial::OverrideColor, false);
            materialInstance->setBoolProperty(DefaultMaterial::OverrideAlpha, false);
 
            materialInstance->unsetMaterialFlag(MaterialFlags::MasterTransparency);
          }
        }
      }
    }
  }
}
 
void Cogs::Core::ModelSystem::initialize(Context * context)
{
  hierarchyUpdatedMessage = context->dynamicComponentSystem->registerMessage("hierarchyUpdated");
 
  ComponentSystemWithDataPools::initialize(context);
}
 
void Cogs::Core::ModelSystem::update(Context * context)
{
  for (auto & component : pool) {
    auto & modelData = getData<ModelData>(&component);
 
    auto model = HandleIsValid(component.model) ? context->modelManager->get(component.model) : nullptr;
 
    if (component.hasChanged() || !modelData.isLoaded() ||
      (model && (!modelData.isGeneration((uint8_t)model->getGeneration()) || modelData.getResourceId() != model->getId()))) {
 
      modelData.clearResourcesLoaded();
      if (model) {
        if (model->isLoaded()) {
 
          if (component.waitForSubresources) {
            bool ready = true;
            for (auto& mesh : model->meshes) {
              ready &= mesh->isResident();
            }
 
            for (const MaterialInstanceHandle& material : model->materials) {
              ready &= material->isResident();
 
              for (const TextureValue& texture : material->textureVariables) {
                ready &= texture.texture.handle && texture.texture.handle->isResident();
              }
            }
 
            if (!ready) continue;
            modelData.setResourcesLoaded();
          }
 
          loadModel(context, component, modelData, model);
 
          auto id = component.getContainer()->getId();
          for (auto c : callbacks) {
            c.second(context, id);
          }
 
          context->dynamicComponentSystem->sendMessage(component.getContainer(), hierarchyUpdatedMessage);
 
          auto renderComp = component.getComponent<RenderComponent>();
          if (renderComp) {
            forwardRenderProperties(component.getComponent<SceneComponent>(), renderComp);
          }
 
        }
      } else if (modelData.isLoaded()) {
        clearModel(context, component);
      }
    }
 
    auto renderComp = component.getComponent<RenderComponent>();
    if (renderComp && renderComp->hasChanged()) {
      forwardRenderProperties(component.getComponent<SceneComponent>(), renderComp);
    }
  }
}
 
float Cogs::Core::ModelSystem::getLoadProgress(ModelComponent* modelComponent)
{
  if (modelComponent == nullptr || !HandleIsValid(modelComponent->model)) return 0.5f;
 
  ModelData& modelData = getData<ModelData>(modelComponent);
  if (modelData.isResourcesLoaded()) return 1.f;
 
  Model* model = context->modelManager->get(modelComponent->model);
  if (!model->isLoaded()) return 0.f;
 
  size_t progress = 0;
  size_t total = model->meshes.size() + model->materials.size();
  for (const MeshHandle& mesh : model->meshes) {
    if (mesh->isActive()) progress++;
  }
  bool ready = true;
  for (const MaterialInstanceHandle& material : model->materials) {
      ready &= material->isResident();
 
      for (const TextureValue& texture : material->textureVariables) {
          ready &= texture.texture.handle && texture.texture.handle->isResident();
      }
      if (ready) progress++;
  }
 
  return static_cast<float>(progress) / static_cast<float>(total);
}
 
void Cogs::Core::ModelSystem::postUpdate(Context * context)
{
  for (auto & component : pool) {
    auto & modelData = getData<ModelData>(&component);
    auto materialComponent = component.getComponent<MaterialComponent>();
 
    if (!materialComponent) continue;
 
    auto& materialData = context->materialSystem->getData(materialComponent);
 
    if (!materialData.instance) continue;
 
    if (materialData.instance != modelData.masterMaterial || materialData.instance->hasChanged()) {
      updateMasterMaterial(context, modelData, materialData.instance);
    }
  }
 
  ComponentSystem::postUpdate(context);
}
 
void Cogs::Core::ModelSystem::loadModel(Context * context, const ModelComponent & component, ModelData & modelData, Model * model)
{
  if (modelData.isLoaded()) {
    clearModel(context, component);
  }
 
  Entity* modelEntity = component.getContainer();
 
  // Optionally forward modelOrigin to rootEntity coordinate
  if (component.setCoordinate) {
 
    // Check if "modelOrigin" is among the first attributes before the attributes of the first part.
    uint32_t maxProp = model->parts.empty() ? model->properties.size() : model->parts[0].firstProperty;
    if (uint32_t ix = model->properties.findProperty(0, maxProp, Strings::add("modelOrigin")); ix != PropertyStore::NoProperty) {
 
      // We have a model origin
      if (std::span<const double> view = model->properties.getDoubleArray(ix); view.size() == 3) {
 
        // Find root entity.
        Entity* root = modelEntity;
        while (Entity* parent = context->store->getEntityParent(root)) {
          root = parent;
        }
 
        // Set coordinate of root entity
        if (TransformComponent* trComp = root->getComponent<TransformComponent>(); trComp) {
          for (glm::dvec3::length_type i = 0; i < 3; i++) {
            trComp->coordinates[i] = view[i];
          }
          trComp->setChanged();
        }
      }
    }
  }
 
 
  const MaterialComponent* materialComponent = modelEntity->getComponent<MaterialComponent>();
 
  MaterialInstanceHandle modelMaterialInstance;
  if (component.materialInstance) {
    modelMaterialInstance = component.materialInstance;
  } else {
 
    if (materialComponent) {
      auto& materialData = context->materialSystem->getData(materialComponent);
      modelMaterialInstance = materialData.instance;
    }
  }
 
  ComponentHandle animationHandle = {};
  if (model->animation) {
    auto animationComponent = modelEntity->getComponent<AnimationComponent>();
 
    if (!animationComponent) {
      animationComponent = context->store->addComponent<AnimationComponent>(modelEntity);
    }
 
    animationComponent->animation = model->animation;
 
    animationHandle = modelEntity->getComponentHandle<AnimationComponent>();
  }
 
  Timer t = Timer::startNew();
 
  {
    std::vector<EntityPtr> entities(model->parts.size());
    std::vector<ComponentHandle> transformComponents(model->parts.size());
    std::vector<ComponentHandle> sceneComponents(model->parts.size());
 
    const auto groupId = hash("Group");
    const auto meshPartId = hash("MeshPart");
 
    auto store = context->store;
 
    store->createEntities(model->parts.size(), entities);
 
    bool shareMaterial = component.shareMaterial;
    bool inheritMaterial = component.inheritMaterial;
 
    for (size_t i = 0; i < model->parts.size(); ++i) {
      const auto & part = model->parts[i];
      auto & entity = entities[i];
 
      auto partName = model->getPartName(part);
      if (!partName.empty()) {
        entity->setName(partName);
        context->deferredResolution->scheduleRescan();
      }
 
      auto transformComponent = context->transformSystem->createComponent();
      transformComponents[i] = transformComponent;
 
      entity->addComponent(transformComponent);
 
      sceneComponents[i] = context->sceneSystem->createComponent();
      entity->addComponent(sceneComponents[i]);
 
      if (part.parentIndex != NoParentPart) {
        sceneComponents[part.parentIndex].resolveComponent<SceneComponent>()->children.emplace_back(entity);
        transformComponent.resolveComponent<TransformComponent>()->parent = transformComponents[part.parentIndex];
      } else {
        context->store->addChild(component.getContainer(), entity);
      }
 
      EntityData* entityData = static_cast<EntityData *>(entity->getUserData());
      entityData->templateId = (part.meshIndex != static_cast<uint32_t>(-1) ? meshPartId : groupId);
 
      if (part.meshIndex != static_cast<uint32_t>(-1)) {
        auto & mesh = model->meshes[part.meshIndex];
 
        auto mcHandle = context->meshSystem->createComponent();
        entity->addComponent(mcHandle);
 
        auto meshComponent = mcHandle.resolveComponent<MeshComponent>();
        meshComponent->meshHandle = mesh;
        meshComponent->setChanged();
 
        auto mrcHandle = context->renderSystem->createComponent();
        entity->addComponent(mrcHandle);
 
        auto renderComponent = mrcHandle.resolveComponent<MeshRenderComponent>();
        if (part.boundsIndex != static_cast<uint32_t>(-1) && model->bounds.size() > part.boundsIndex) {
          context->renderSystem->setLocalBounds(renderComponent, model->bounds[part.boundsIndex]);
        } else {
          // Warn...
        }
 
        renderComponent->startIndex = part.startIndex;
        renderComponent->vertexCount = part.vertexCount;
        renderComponent->primitiveType = (PrimitiveType::EPrimitiveType)part.primitiveType;
 
        MaterialInstanceHandle partMaterial = part.materialIndex < model->materials.size()
                                            ? model->materials[part.materialIndex]
                                            : MaterialInstanceHandle::NoHandle;
        // FIXME: Accessing mesh flags here could cause a race condition. Currently that's not a huge concern as it might happen
        // just for skinned meshes without materials with the inheritMaterial flag set.
        // Setting the "Skinned" variant here should be removed once the material properties are set based on RenderMesh layout and properties.
 
        if(shareMaterial){
          if(inheritMaterial){
            renderComponent->material = modelMaterialInstance;
          }
          else if (partMaterial) {
            renderComponent->material = partMaterial;
          }
          else {
            MaterialInstanceHandle master = context->materialManager->getDefaultMaterial();
            renderComponent->material = context->materialInstanceManager->createMaterialInstance(master);
          }
        }
        else{
          // Create a clone of master material
          if(inheritMaterial){
            auto master = context->materialManager->generateHandle(modelMaterialInstance->material);
            renderComponent->material = context->materialInstanceManager->createMaterialInstance(master);
            renderComponent->material->clone(modelMaterialInstance.resolve());
          }
          else{
            MaterialHandle master;
            if(HandleIsValid(partMaterial)){
              master = context->materialManager->generateHandle(partMaterial->material);
            }
            else{
              master = context->materialManager->getDefaultMaterial();
            }
            renderComponent->material = context->materialInstanceManager->createMaterialInstance(master);
            modelData.materials.push_back(renderComponent->material);
          }
          // Copy over settings from partMaterial
          if(partMaterial){
            renderComponent->material->setPermutation(partMaterial->getPermutation());
            renderComponent->material->instanceFlags = partMaterial->instanceFlags;
            renderComponent->material->options = partMaterial->options;
            renderComponent->material->cloneMatchingProperties(partMaterial.resolve());
            renderComponent->material->cloneMatchingVariants(partMaterial.resolve());
          }
        }
 
        if (animationHandle) {
          auto animationComponent = context->store->addComponent<AnimationComponent>(entity.get());
          animationComponent->animation = model->animation;
          animationComponent->master = animationHandle;
          animationComponent->setChanged();
        }
      }
 
      if (part.numProperties) {
        auto propertiesComponent = entity->getComponent<PropertiesComponent>();
 
        if (!propertiesComponent) {
          propertiesComponent = context->store->addComponent<PropertiesComponent>(entity.get());
        }
 
        propertiesComponent->properties.copyProperties(model->properties, part.firstProperty, part.numProperties);
      }
    }
 
    for (size_t i = 0; i < model->parts.size(); ++i) {
      const auto & part = model->parts[i];
 
      context->transformSystem->setLocalTransform(transformComponents[i].resolveComponent<TransformComponent>(), model->getPartTransform(part));
    }
  }
 
  LOG_TRACE(logger, "Model spawn elapsed: %f.", t.elapsedSeconds());
 
  if (modelMaterialInstance) {
    updateMasterMaterial(context, modelData, modelMaterialInstance);
  }
 
  modelData.setLoaded();
  modelData.setGeneration((uint8_t)model->getGeneration());
  modelData.setResourceId(model->getId());
}
 
void Cogs::Core::ModelSystem::clearModel(Context * /*context*/, const ModelComponent & component)
{
  // Remove all children, clearing the loaded model.
  auto sceneComponent = component.getComponent<SceneComponent>();
 
  sceneComponent->children.clear();
}
 
int Cogs::Core::ModelSystem::addHierarchyCallback(HierarchyChangedCallback callback)
{
  int id = nextId++;
  callbacks[id] = callback;
  return id;
}
 
void Cogs::Core::ModelSystem::removeHierarchyCallback(int id)
{
  callbacks.erase(id);
}