TwinVisualsExtension.cpp

#include "Context.h"
#include "ExtensionRegistry.h"
#include "ResourceManifest.h"
#include "Resources/ResourceStore.h"
#include "Serialization/EntityReader.h"
 
#include "Renderer/Tasks/RenderTaskFactory.h"
 
#include "../../TexAtlas/Source/TexAtlasSystem.h"
 
#include "TwinVisualsComponent.h"
#include "TwinVisualsSystem.h"
#include "TwinCadModelComponent.h"
#include "TwinCadModelSystem.h"
#include "TwinVisualsTexAtlasRenderTask.h"
 
namespace Cogs::Core {
 
  static RenderTask* createTwinVisualsTexAtlasRenderTask(RenderTaskContext* renderTaskContext, const RenderTaskDefinition& renderTaskDefinition, const PipelineOptions& pipelineOptions)
  {
    TexAtlasSystem* texAtlasSystem = ExtensionRegistry::getExtensionSystem<TexAtlasSystem>(renderTaskContext->context);
    TwinVisualsSystem* twinVisualsSystem = ExtensionRegistry::getExtensionSystem<TwinVisualsSystem>(renderTaskContext->context);
    if (texAtlasSystem && twinVisualsSystem) {
      return new TwinVisualsTexAtlasRenderTask(renderTaskContext, texAtlasSystem, twinVisualsSystem, renderTaskDefinition, pipelineOptions);
    }
    return nullptr;
  }
 
  static void destroyTwinVisualsTexAtlasRenderTask(RenderTask** task, RenderTaskContext*)
  {
    if (TwinVisualsTexAtlasRenderTask* myTask = dynamic_cast<TwinVisualsTexAtlasRenderTask*>(*task); myTask) {
      delete myTask;
      *task = nullptr;
    }
  }
 
  struct TwinVisualsExtension : Extension
  {
    TwinVisualsExtension() {
      ExtensionRegistry::add(this, COGS_CORE_VERSION_STRING);
    }
 
    bool initializeStatic() override;
    bool initialize(Context* context) override;
    void cleanup(Context* context) override;
 
    const char* getExtensionKey() const override { return "TwinVisuals"; }
  } twinVisualsExtension;
 
}
 
 
bool Cogs::Core::TwinVisualsExtension::initializeStatic()
{
  TwinVisualsComponent::registerType();
  TwinCadModelComponent::registerType();
  return true;
}
 
bool Cogs::Core::TwinVisualsExtension::initialize(Context* context)
{
  const std::string resourceArchive = "Cogs.Core.Extensions.TwinVisuals.zip";
#ifdef __EMSCRIPTEN__
  bool resourceArchiveAdded = false;
  std::vector<std::string> manifest = getResourceManifest(context);
  for (auto& item : manifest) {
    if (item.find(resourceArchive) != std::string::npos) {
      context->resourceStore->addResourceArchive(item);
      resourceArchiveAdded = true;
      break;
    }
  }
  if (!resourceArchiveAdded) {
    context->resourceStore->addResourceArchive(resourceArchive);
  }
#else
  context->resourceStore->addSearchPath("../Extensions/TwinVisuals/Data/");
  context->resourceStore->addResourceArchive(resourceArchive);
#endif
 
  readEntityDefinition(R"(
{ "name": "TwinVisuals",
  "components" : [
    "TwinVisualsComponent"
  ]
})", context->store);
 
  readEntityDefinition(R"(
{ "name": "TwinCadModel",
  "components": [
    "TransformComponent",
    "SceneComponent",
    "AssetComponent",
    "RenderComponent",
    "TwinCadModelComponent"
  ]
})", context->store);
 
  ExtensionRegistry::registerExtensionSystem<TwinVisualsSystem>(context, SystemPriority::PreRendering, 1);
  ExtensionRegistry::registerExtensionSystem<TwinCadModelSystem>(context, SystemPriority::PreRendering, 1);
  addTaskType("TwinVisualsTexAtlasRender", createTwinVisualsTexAtlasRenderTask, destroyTwinVisualsTexAtlasRenderTask);
  return true;
}
 
void Cogs::Core::TwinVisualsExtension::cleanup(Context* /*context*/)
{
}