MergeCommand.cpp

#include "MergeCommand.h"
 
#include "Systems/Core/SceneSystem.h"
#include "Systems/Core/MeshSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/RenderSystem.h"
 
#include "Resources/MeshManager.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <regex>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("MergeCommand");
}
 
namespace Cogs::Core
{
  bool canMerge(SceneComponent * sc)
  {
    if (sc->children.empty()) return false;
 
    for (auto & c : sc->children) {
      auto childSc = c->getComponent<SceneComponent>();
 
      if (!childSc->children.empty()) return false;
 
      auto meshComponent = c->getComponent<MeshComponent>();
 
      if (!meshComponent) return false;
    }
 
    return true;
  }
 
  template<typename Container>
  void copyStream(Mesh * mesh, VertexDataType::EVertexDataType dataType, Container & container)
  {
    auto & stream = mesh->getStream(dataType);
 
    auto pData = (const typename Container::value_type *)stream.data();
 
    container.insert(container.end(), pData, pData + stream.numElements);
  }
 
  MeshHandle createMesh(Context * context, SceneComponent * sc)
  {
    auto mesh = context->meshManager->create();
 
    std::vector<glm::vec3> positions;
    std::vector<glm::vec3> normals;
    std::vector<glm::vec2> texCoords;
    std::vector<glm::vec3> tangents;
 
    std::vector<uint32_t> indexes;
 
    for (auto & c : sc->children) {
      if (c->getName().size() && c->getName()[0] == '/') continue;
 
      auto meshComponent = c->getComponent<MeshComponent>();
 
      uint32_t offset = (uint32_t)positions.size();
 
      auto childMesh = meshComponent->meshHandle.resolve();
 
      copyStream(childMesh, VertexDataType::Positions, positions);
      if (childMesh->hasStream(VertexDataType::Normals)) copyStream(childMesh, VertexDataType::Normals, normals);
      if (childMesh->hasStream(VertexDataType::TexCoords0)) copyStream(childMesh, VertexDataType::TexCoords0, texCoords);
      if (childMesh->hasStream(VertexDataType::Tangents)) copyStream(childMesh, VertexDataType::Tangents, tangents);
 
      auto meshIndexes = childMesh->getIndexes();
      for (auto i : meshIndexes) {
        indexes.emplace_back(i + offset);
      }
    }
 
    mesh->setPositions(positions);
    if (!normals.empty()) mesh->setNormals(normals);
    if (!texCoords.empty()) mesh->setTexCoords(texCoords);
    if (!tangents.empty()) mesh->setTangents(tangents);
    if (!indexes.empty()) mesh->setIndexes(indexes);
 
    mesh->setMeshFlag(MeshFlags::ClockwiseWinding);
    mesh->boundingBox = calculateBounds(mesh.resolve());
 
    return mesh;
  }
 
  void traverse(Context * context, Entity * entity, const std::regex & matchRegex)
  {
    auto sc = entity->getComponent<SceneComponent>();
 
    if (canMerge(sc)) {
      auto mesh = createMesh(context, sc);
      auto material = sc->children.front()->getComponent<MeshRenderComponent>()->material;
 
      if (!mesh->getCount()) return;
 
      auto oldChildren = sc->children;
      sc->children.clear();
 
      for (auto & oldChild : oldChildren) {
 
        const std::string & name = oldChild->getName();
        if (std::regex_match(name, matchRegex)) {
          sc->children.emplace_back(oldChild);
        }
      }
 
      const size_t numMerged = oldChildren.size() - sc->children.size();
 
      LOG_TRACE(logger, "Merged %zd children up the hierarchy.", numMerged);
 
      auto existingMc = entity->getComponent<MeshComponent>();
 
      if (!existingMc) {
        auto mc = context->meshSystem->createComponent();
        auto mrc = context->renderSystem->createComponent();
 
        entity->addComponent(mc);
        entity->addComponent(mrc);
 
        mc.resolveComponent<MeshComponent>()->meshHandle = mesh;
        mrc.resolveComponent<MeshRenderComponent>()->material = material;
      } else {
        auto newChild = context->store->createChildEntity("MeshPart", entity, "MergedChild");
 
        auto mc = newChild->getComponent<MeshComponent>();
 
        mc->meshHandle = mesh;
        mc->setChanged();
 
        auto mrc = newChild->getComponent<MeshRenderComponent>();
 
        mrc->material = material;
        mrc->setChanged();
      }
    } else {
      for (auto & child : sc->children) {
        traverse(context, child.get(), matchRegex);
      }
    }
  }
}
 
void Cogs::Core::MergeCommand::apply()
{
  // Statoil special tags starts with '/' and has only one '/'.
  const std::regex matchRegex = std::regex(getOption(options, "matchRegex", "^/[^/]*$").to_string(), std::regex_constants::ECMAScript);
 
  for (auto & id : entityIds) {
    auto entity = context->store->getEntityPtr(id);
 
    traverse(context, entity, matchRegex);
  }
}
 
void Cogs::Core::MergeCommand::undo()
{
 
}
 
namespace Cogs::Core
{
  struct MergeInstance
  {
    Mesh * mesh;
    MeshComponent * meshComponent;
    MeshRenderComponent * meshRenderComponent;
  };
 
  struct MergeMeshState
  {
    std::vector<MergeInstance> instances;
    size_t size = 0;
    uint32_t signature = 0;
 
    size_t vertexCountThreshold = 100000;
  };
 
  uint32_t getMeshSignature(const Mesh * mesh)
  {
    uint32_t signature = 0;
    for (size_t i = 0; i < 11; ++i) {
      if (mesh->streamIndexes[i] != Mesh::NoStream) {
        signature |= 1 << i;
      }
    }
 
    for (size_t i = 11; i < 15; ++i) {
      if (mesh->streamIndexes[i] != Mesh::NoStream) {
        signature = (uint32_t)-1;
      }
    }
 
    return signature;
  }
 
  void closeMergeState(Context * context, MergeMeshState & state)
  {
    if (state.instances.empty()) return;
 
    if (state.instances.size() >= 2) {
      auto mesh = context->meshManager->create();
 
      std::vector<glm::vec3> positions;
      std::vector<glm::vec3> normals;
      std::vector<glm::vec2> texCoords;
      std::vector<glm::vec3> tangents;
 
      std::vector<uint32_t> indexes;
 
      for (auto & instance : state.instances) {
        instance.meshComponent->meshHandle = mesh;
        instance.meshComponent->setChanged();
 
        uint32_t offset = (uint32_t)positions.size();
 
        auto childMesh = instance.mesh;
 
        copyStream(childMesh, VertexDataType::Positions, positions);
        if (childMesh->hasStream(VertexDataType::Normals)) copyStream(childMesh, VertexDataType::Normals, normals);
        if (childMesh->hasStream(VertexDataType::TexCoords0)) copyStream(childMesh, VertexDataType::TexCoords0, texCoords);
        if (childMesh->hasStream(VertexDataType::Tangents)) copyStream(childMesh, VertexDataType::Tangents, tangents);
 
        auto meshIndexes = childMesh->getIndexes();
        for (auto i : meshIndexes) {
          indexes.emplace_back(i + offset);
        }
 
        instance.meshRenderComponent->startIndex = offset;
        instance.meshRenderComponent->vertexCount = (uint32_t)meshIndexes.size();
        auto localBounds = context->renderSystem->getLocalBounds(instance.meshRenderComponent);
        context->renderSystem->setLocalBounds(instance.meshRenderComponent, localBounds);
        instance.meshRenderComponent->setChanged();
      }
 
      mesh->setPositions(positions);
      if (!normals.empty()) mesh->setNormals(normals);
      if (!texCoords.empty()) mesh->setTexCoords(texCoords);
      if (!tangents.empty()) mesh->setTangents(tangents);
      if (!indexes.empty()) mesh->setIndexes(indexes);
 
      mesh->setMeshFlag(MeshFlags::ClockwiseWinding);
 
      LOG_TRACE(logger, "Merged %zd meshes with %zd verts.", state.instances.size(), state.size);
    } else {
      LOG_TRACE(logger, "Skipped %zd mesh(es) with %zd verts.", state.instances.size(), state.size);
    }
 
    state.instances = {};
    state.size = 0;
  }
 
  void traverseMerge(Context * context, Entity * entity, MergeMeshState & state)
  {
    auto sc = entity->getComponent<SceneComponent>();
    auto meshComponent = entity->getComponent<MeshComponent>();
    auto meshRenderComponent = entity->getComponent<MeshRenderComponent>();
 
    if (meshComponent) {
      auto meshSignature = getMeshSignature(meshComponent->meshHandle.resolve());
 
      if (meshSignature != state.signature) {
        closeMergeState(context, state);
      } else if (state.size > state.vertexCountThreshold) {
        closeMergeState(context, state);
      }
 
      state.signature = meshSignature;
 
      state.instances.emplace_back(MergeInstance
      {
        meshComponent->meshHandle.resolve(),
        meshComponent,
        meshRenderComponent
      });
 
      state.size += meshComponent->meshHandle->getCount();
    }
 
    for (auto & child : sc->children) {
      traverseMerge(context, child.get(), state);
    }
  }
 
  void traverseScale(Context * context, Entity * entity, MergeMeshState & state)
  {
    auto sc = entity->getComponent<SceneComponent>();
    auto meshComponent = entity->getComponent<MeshComponent>();
    auto meshRenderComponent = entity->getComponent<MeshRenderComponent>();
 
    if (meshComponent) {
      auto mesh = meshComponent->getMesh(context);
      auto[pData, pSize, pStride] = mesh->getPositionStream();
      assert(pStride == sizeof(glm::vec3));
      auto positions = (glm::vec3 *)pData;
      
      printf("Scaling mesh resource %u...\n", pSize);
 
      for (size_t i = 0; i < pSize; ++i) {
        positions[i] = positions[i] * 0.001f;
      }
 
      mesh->unmap(VertexDataType::Positions);
      mesh->setChanged();
      mesh->unsetMeshFlag(MeshFlags::BoundingBoxSet);
      auto bounds = calculateBounds(mesh);
      mesh->setBounds(bounds);
 
      context->renderSystem->setLocalBounds(meshRenderComponent, bounds);
    }
 
    for (auto & child : sc->children) {
      traverseScale(context, child.get(), state);
    }
  }
}
 
void Cogs::Core::MergeMeshCommand::apply()
{
  MergeMeshState state;
 
  state.vertexCountThreshold = getOption(options, "vertexCountThreshold", state.vertexCountThreshold);
 
  for (auto & id : entityIds) {
    auto entity = context->store->getEntityPtr(id);
 
    traverseMerge(context, entity, state);
 
    if (state.instances.size()) closeMergeState(context, state);
  }
}
 
void Cogs::Core::MergeMeshCommand::undo()
{
 
}
 
 
void Cogs::Core::ScaleMeshCommand::apply()
{
  MergeMeshState state;
 
  state.vertexCountThreshold = getOption(options, "vertexCountThreshold", state.vertexCountThreshold);
 
 
  for (auto & id : entityIds) {
    printf("Scaling mesh entity...\n");
 
    auto entity = context->store->getEntityPtr(id);
 
    traverseScale(context, entity, state);
 
    if (state.instances.size()) closeMergeState(context, state);
  }
}
 
void Cogs::Core::ScaleMeshCommand::undo()
{
 
}