StaticModelSystem.cpp

#include "StaticModelSystem.h"
#include "Context.h"
#include "EntityStore.h"
 
#include "Resources/ModelManager.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/MeshSystem.h"
#include "Systems/Core/SceneSystem.h"
#include "Systems/Core/RenderSystem.h"
 
#include "Renderer/RenderList.h"
 
#include "Foundation/Platform/Timer.h"
 
namespace Cogs::Core
{
  struct StaticModelContext
  {
    StaticModelContext(Context * context, Memory::Allocator * allocator, SizeType size) :
      transformSystem(allocator, size),
      meshSystem(allocator, size),
      sceneSystem(allocator, size),
      renderSystem(allocator, size)
    {
      meshSystem.transformSystem = &transformSystem;
      renderSystem.transformSystem = &transformSystem;
 
      entityContext.transformSystem = &transformSystem;
      entityContext.meshSystem = &meshSystem;
      entityContext.renderSystem = &renderSystem;
 
      transformSystem.initialize(context);
      meshSystem.initialize(context);
      sceneSystem.initialize(context);
      renderSystem.initialize(context);
    }
 
    StaticModelContext(StaticModelContext &) = delete;
 
    void update(Context * context)
    {
      if (batch.missing || dirty) {
        transformSystem.update(context);
        meshSystem.update(context);
        sceneSystem.update(context);
        renderSystem.update(context);
 
        dirty = false;
      }
 
      meshSystem.postUpdate(context);
    }
 
    TransformSystem transformSystem;
    MeshSystem meshSystem;
    SceneSystem sceneSystem;
    RenderSystem renderSystem;
 
    RenderBatch batch;
 
    ContextBase entityContext;
 
    bool dirty = true;
  };
}
 
Cogs::Core::StaticModelData::~StaticModelData()
{
 
}
 
Cogs::Core::StaticModelSystem::~StaticModelSystem()
{
}
 
void Cogs::Core::StaticModelSystem::update(Context * context)
{
  for (auto & component : pool) {
    auto & modelData = getData(&component);
 
    auto model = HandleIsValid(component.model) ? context->modelManager->get(component.model) : nullptr;
 
    if (component.hasChanged() || (model && model->isLoaded() && !modelData.isGeneration((uint8_t)model->getGeneration()))) {
      if (model) {
        const SizeType numParts = (SizeType)model->parts.size();
 
        modelData.modelContext = std::make_shared<StaticModelContext>(context, context->memory->componentAllocator, numParts);
 
        loadModel(context, component, modelData, model);
      }
    }
 
    if (!modelData.modelContext) continue;
 
    auto transformComponent = component.getComponent<TransformComponent>();
 
    if (context->transformSystem->hasChanged(transformComponent)) {
      modelData.modelContext->dirty = true;
 
      for (auto & root : modelData.roots) {
        auto rootTransform = root->getComponent<TransformComponent>();
        rootTransform->position = transformComponent->position;
        rootTransform->setChanged();
      }
    }
 
    modelData.modelContext->update(context);
  }
}
 
Cogs::Core::RenderSystem * Cogs::Core::StaticModelSystem::getRenderSystem(StaticModelComponent * modelComponent)
{
  auto & data = getData(modelComponent);
 
  if (!data.modelContext) return nullptr;
 
  return &data.modelContext->renderSystem;
}
 
Cogs::Core::MeshSystem * Cogs::Core::StaticModelSystem::getMeshSystem(StaticModelComponent * modelComponent)
{
  auto & data = getData(modelComponent);
 
  if (!data.modelContext) return nullptr;
 
  return &data.modelContext->meshSystem;
}
 
Cogs::Core::RenderBatch * Cogs::Core::StaticModelSystem::getRenderBatch(StaticModelComponent * modelComponent)
{
  auto & data = getData(modelComponent);
 
  if (!data.modelContext) return nullptr;
 
  return &data.modelContext->batch;
}
 
void Cogs::Core::StaticModelSystem::initializeCulling(CullingSource* cullingSource)
{
  for (auto & component : pool) {
    auto & data = getData(&component);
 
    if (!data.modelContext) continue;
 
    data.modelContext->renderSystem.initializeCulling(cullingSource);
  }
}
 
void Cogs::Core::StaticModelSystem::loadModel(Context * context, const StaticModelComponent & component, StaticModelData & modelData, Model * model)
{
  auto transformSystem = &modelData.modelContext->transformSystem;
  auto meshSystem = &modelData.modelContext->meshSystem;
  auto sceneSystem = &modelData.modelContext->sceneSystem;
  auto renderSystem = &modelData.modelContext->renderSystem;
 
  {
    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, [transformSystem, meshSystem, sceneSystem, renderSystem](Entity* e) {
        if (auto h = e->getComponentHandle<TransformComponent>(); h) {
          transformSystem->destroyComponent(h);
        }
        if (auto h = e->getComponentHandle<SceneComponent>(); h) {
          sceneSystem->destroyComponent(h);
        }
        if (auto h = e->getComponentHandle<MeshComponent>(); h) {
          meshSystem->destroyComponent(h);
        }
        if (auto h = e->getComponentHandle<MeshRenderComponent>(); h) {
          renderSystem->destroyComponent(h);
        }
    });
 
    bool shareMaterial = true; // component.shareMaterial;
    bool inheritMaterial = false;// 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);
      }
 
      auto transformComponent = transformSystem->createComponent();
      transformComponents[i] = transformComponent;
 
      entity->addComponent(transformComponent);
 
      sceneComponents[i] = 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 {
        component.getComponent<SceneComponent>()->children.emplace_back(entity);
        modelData.roots.emplace_back(entity.get());
      }
 
      EntityData* entityData = static_cast<EntityData *>(entity->getUserData());
      entityData->templateId = (part.meshIndex != NoIndex ? meshPartId : groupId);
      entityData->entityContext = &modelData.modelContext->entityContext;
 
      if (part.meshIndex < model->meshes.size() && part.materialIndex < model->materials.size()) {
        auto mesh = model->meshes[part.meshIndex];
        auto material = model->materials[part.materialIndex];
 
        auto mcHandle = meshSystem->createComponent();
        entity->addComponent(mcHandle);
 
        auto meshComponent = mcHandle.resolveComponent<MeshComponent>();
        meshComponent->meshHandle = mesh;
        meshComponent->setChanged();
 
        auto mrcHandle = renderSystem->createComponent();
        entity->addComponent(mrcHandle);
 
        auto renderComponent = mrcHandle.resolveComponent<MeshRenderComponent>();
        renderComponent->startIndex = part.startIndex;
        renderComponent->vertexCount = part.vertexCount;
 
        if (model->bounds.size() > i) {
          renderSystem->setLocalBounds(renderComponent, model->bounds[i]);
        }
 
        if (!inheritMaterial && HandleIsValid(material)) {
          if (shareMaterial) {
            renderComponent->material = material;
          }
        }
      }
    }
 
    for (size_t i = 0; i < model->parts.size(); ++i) {
      const auto & part = model->parts[i];
 
      transformSystem->setLocalTransform(transformComponents[i].resolveComponent<TransformComponent>(), model->getPartTransform(part));
    }
  }
 
  modelData.setGeneration((uint8_t)model->getGeneration());
}