EditorExtension.cpp

#include "EditorExtension.h"
 
#include "ExtensionRegistry.h"
#include "Context.h"
 
#include "Editor.h"
#include "Renderer/IRenderer.h"
#include "Renderer/RenderStateUpdater.h"
 
#include "Commands/SparseBuildOctreeCommand.h"
#include "Commands/AssetPipeCommand.h"
#include "Commands/AssetStatsCommand.h"
#include "Resources/ResourceStore.h"
 
#include "EditorRenderTask.h"
 
using namespace Cogs::Core;
using namespace Cogs::Reflection;
 
namespace Cogs::Core
{
  struct EditorRenderExtension : public IRendererExtension
  {
    void initialize(Context* context, IGraphicsDevice* device) override
    {
      editorTask.init(context->getDefaultView(), device);
    }
 
    void handleEvent(uint32_t eventId, const DrawContext * renderingContext) override
    {
      if (eventId == RenderingEvent::RenderGui) {
 
        editorTask.apply(renderingContext->taskContext);
      }
    }
 
    void generateCommands(const RenderTaskContext * /*renderingContext*/, RenderList * /*renderList*/) override
    {
    }
 
    EditorRenderTask editorTask;
  };
 
  struct EditorExtension : public Extension
  {
    EditorExtension() { ExtensionRegistry::add(this, COGS_CORE_VERSION_STRING); }
 
    bool initialize(Context * context) override
    {
      const std::string resourceArchive = "Cogs.Core.Extensions.Editor.zip";
#ifdef EMSCRIPTEN
      bool resourceArchiveAdded = false;
      auto 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/Editor/Data/");
      context->resourceStore->addResourceArchive(resourceArchive);
#endif
 
      Editor::registerExtensionCommand("SparseBuildOctree", [](EditorState* state) { return new SparseBuildOctreeCommand(state); });
      Editor::registerExtensionCommand("AssetPipe", [](EditorState* state) { return new AssetPipeCommand(state); });
      Editor::registerExtensionCommand("AssetStats", [](EditorState* state) { return new AssetStatsCommand(state); });
 
      renderExtension = new EditorRenderExtension();
      context->renderer->registerExtension(renderExtension);
 
      context->engine->setEditor(new Editor(context));
      context->engine->getEditor()->initialize();
 
      return true;
    }
 
    void cleanup(Context* context) override
    {
      context->renderer->unregisterExtension(renderExtension);
      delete renderExtension;
      renderExtension = nullptr;
    }
 
    const char * getExtensionKey() const override { return "Editor"; }
 
    EditorRenderExtension* renderExtension = nullptr;
 
  } const editorExtension;
}