InstancedModelSystem.cpp

#include "InstancedModelSystem.h"
 
#include "EntityStore.h"
 
#include "Systems/Core/SceneSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/MeshSystem.h"
#include "Systems/Core/InstancedMeshRenderSystem.h"
 
#include "Resources/ModelManager.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
 
#include "Services/DeferredNameResolution.h"
 
void Cogs::Core::InstancedModelSystem::update(Context * context)
{
  for (auto & component : pool) {
    auto & modelData = getData<InstancedModelData>(&component);
 
    auto model = HandleIsValid(component.model) ? context->modelManager->get(component.model) : nullptr;
 
    if (component.hasChanged() || model) {
      if (model) {
        if (model->isLoaded() && !modelData.isLoaded) {
          bool ready = true;
          for (auto & mesh : model->meshes) {
            ready &= mesh->isActive();
          }
 
          if (ready) {
            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("InstancedMeshPart");
 
            auto store = context->store;
            store->createEntities(model->parts.size(), entities);
 
            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->instancedMeshRenderSystem->createComponent();
                entity->addComponent(mrcHandle);
 
                auto renderComponent = mrcHandle.resolveComponent<InstancedMeshRenderComponent>();
                renderComponent->startIndex = part.startIndex;
                renderComponent->vertexCount = part.vertexCount;
                renderComponent->primitiveType = (PrimitiveType::EPrimitiveType)part.primitiveType;
                renderComponent->instanceMesh = component.instanceMesh;
 
                if (part.materialIndex >= model->materials.size()) {
                  continue;
                }
 
                auto & material = model->materials[part.materialIndex];
                if (component.material) {
                  if (component.cloneModelMaterialProperties) {
                    renderComponent->material = context->materialInstanceManager->createMaterialInstance(component.material);
 
                    renderComponent->material->setPermutation(material->getPermutation());
                    renderComponent->material->instanceFlags = material->instanceFlags;
                    renderComponent->material->options = material->options;
                    renderComponent->material->cloneMatchingProperties(material.resolve());
                    renderComponent->material->cloneMatchingVariants(material.resolve());
                  } else {
                    renderComponent->material = component.material;
                  }
                } else {
                  renderComponent->material = material;
                  material->setVariant("InstancedPositions", true);
                }
              }
            }
 
            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));
            }
 
            modelData.isLoaded = true;
          }
        }
      }
    }
  }
}