ExportCommand.cpp

#include "ExportCommand.h"
#include "CommandParseHelpers.h"
 
#include "Components/Core/ModelComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/StaticModelComponent.h"
#include "Resources/Model.h"
#include "Serialization/ModelWriter.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
#include <iostream>
#include <iomanip>
#include <sstream>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ExportCommand");
 
  void getEntity(Cogs::Core::Context* /*context*/, std::vector<Cogs::ComponentModel::Entity*>& entities, Cogs::ComponentModel::Entity* entity)
  {
    if (entity == nullptr) return;
 
    if (auto result = std::find_if(entities.begin(), entities.end(), [e = entity](Cogs::ComponentModel::Entity*& x) { return x->getId() == e->getId(); });
      result != entities.end()) {
      return;
    }
 
    Cogs::Core::SceneComponent* sceneComp = entity->getComponent<Cogs::Core::SceneComponent>();
    if (!sceneComp) return;
 
    Cogs::Core::MeshComponent* meshComp = entity->getComponent<Cogs::Core::MeshComponent>();
    Cogs::Core::StaticModelComponent* staticModelComp = entity->getComponent<Cogs::Core::StaticModelComponent>();
    if (!meshComp && !staticModelComp) return;
 
    LOG_DEBUG(logger, "export entity id: %zu", entity->getId());
    entities.push_back(entity);
  }
}
 
namespace Cogs::Core
{
}
 
#ifndef EMSCRIPTEN
void Cogs::Core::ExportCommand::apply()
{
  std::string fileName = getOption(options, "fileName").to_string();
 
  std::string stem = getOption(options, "stem").to_string();
  if (fileName.empty() && !stem.empty()) {
      fileName = stem + ".cogsbin";
  }
 
  if (!fileName.empty()) {
    std::string outputName = replaceFileMacros(fileName, options);
 
    std::string destination = getOption(options, "destination").to_string();
 
    if (destination.size()) {
      if (!IO::exists(destination)) {
        fs::create_directories(destination);
      }
 
      outputName = IO::combine(destination, outputName);
    }
 
    fileName = outputName;
  }
 
  if (fileName.empty()) {
    std::string name = "Model.cogsbin";
 
    Cogs::Core::ModelComponent* modelComp = state->getSelected()->getComponent<Cogs::Core::ModelComponent>();
    if (modelComp && modelComp->model) {
      std::string modelPath = modelComp->model->getSource().to_string();
      std::string modelFileName = IO::fileName(modelPath);
 
      stem = IO::stem(modelFileName);
 
      if (!stem.empty()) {
        name = stem + ".cogsbin";
      }
    } else if (state->getSelected()->getName().size()) {
      name = fixInvalidPathChars(state->getSelected()->getName()) + ".cogsbin";
    }
 
    fileName = name;
  }
 
  std::string path = fileName;
 
  if (IO::isRelative(path)) {
    path = IO::combine(state->directory, path);
  }
 
  bool ok = false;
  if (exportScene) {
    uint32_t numVertes;
    uint32_t numIndexes;
 
    std::vector<ComponentModel::Entity*> entities;
    const std::unordered_map<EntityId, EntityPtr>& entityMap = context->store->getEntities();
    
    for (const auto& e : entityMap) {
      Cogs::ComponentModel::Entity* entity = context->store->getEntityPtr(static_cast<EntityId>(e.first));
      getEntity(context, entities, entity);
    }
    
    ok = writeModels(context, numVertes, numIndexes, path, entities.data(), entities.size(), WriteModelFlags::COMPRESS_ZSTD | WriteModelFlags::COMPRESS_MAX);
  }
  else {
    if (1 < state->selected.size()) {
      uint32_t numVertes;
      uint32_t numIndexes;
 
      std::vector<ComponentModel::Entity*> entities;
 
      for (auto id : state->selected) {
        entities.push_back(context->store->getEntityPtr(id));
      }
      ok = writeModels(context, numVertes, numIndexes, path, entities.data(), entities.size(), WriteModelFlags::COMPRESS_ZSTD | WriteModelFlags::COMPRESS_MAX);
    }
    else {
      ok = writeModel(context, path, state->getSelected(), WriteModelFlags::COMPRESS_ZSTD | WriteModelFlags::COMPRESS_MAX);
    }
  }
 
  if (!ok) {
    LOG_ERROR(logger, "Could not save model to: %s", path.c_str());
  }
  else {
    LOG_DEBUG(logger, "Wrote %s", path.c_str());
  }
}
#else
void Cogs::Core::ExportCommand::apply() {}
#endif
 
void Cogs::Core::ExportCommand::undo()
{
}