GuiExtension.cpp

#include "GuiExtension.h"
 
#include "Context.h"
#include "ExtensionRegistry.h"
#include "Serialization/EntityReader.h"
#include "Resources/ResourceStore.h"
#include "Renderer/IRenderer.h"
#include "Renderer/Tasks/RenderTaskFactory.h"
#include "Renderer/RenderStateUpdater.h"
#include "Renderer/InspectorGui/InspectorGuiRenderer.h"
#include "Renderer/RenderTarget.h"
 
#include "GuiComponent.h"
#include "GuiRenderComponent.h"
#include "GuiManager.h"
 
#include "GuiSystem.h"
#include "GuiRenderSystem.h"
#include "GuiRenderTask.h"
 
#include "Rendering/IGraphicsDevice.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
 
#if defined( _WIN32 )
  #define GUI_EXT_API __declspec(dllexport)
#else
  #define GUI_EXT_API
#endif
 
namespace {
  using namespace Cogs::Core;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GuiExtension");
 
  RenderTask * createGuiRenderTask(RenderTaskContext*, const RenderTaskDefinition &, const PipelineOptions &)
  {
    return new GuiRenderTask();
  }
 
  void destroyGuiRenderTask(RenderTask ** task, RenderTaskContext *)
  {
    auto * myTask = dynamic_cast<GuiRenderTask*>(*task);
    if (myTask) {
      //myTask->~GuiRenderTask();
      delete myTask;
      *task = nullptr;
    }
  }
 
 
  struct GuiRenderer : public IRendererExtension
  {
 
    void setupPipelines(const DrawContext * drawContext)
    {
      Context * context = drawContext->context;
      Renderer * renderer = drawContext->renderer;
      RenderTaskContext * taskContext = drawContext->taskContext;
      RenderResources & resources = renderer->getRenderResources();
      GuiRenderSystem * guiRenderSystem = static_cast<GuiRenderSystem*>(context->getExtensionSystem(GuiRenderSystem::getTypeId()));
      RenderPipelineManager * pipelineManager = renderer->getPipelineManager();
 
      for (auto & gui : guiRenderSystem->pool) {
        if (gui.target) {
          auto it = pipelineManager->instanceByKey(context, Cogs::hashSequence("Gui", reinterpret_cast<intptr_t>(&gui), gui.getGeneration()));
          auto * instance = it.first;
 
          if (it.second) {
            instance->name = "GuiExtension";
            instance->priority = 300;
            instance->sanityCheck = &gui;
            instance->options.push_back({ "Pass", "Offscreen" });
            LOG_DEBUG(logger, "GuiRenderer added camera pipeline");
          }
          else {
            assert(instance->sanityCheck == &gui);
          }
 
          RenderTexture * renderTexture = resources.getRenderTexture(gui.target);
 
          size_t dataHash = 0;
          if (renderTexture) {
            if (!renderTexture->renderTarget) {
              RenderTexture * depthTexture = resources.createRenderTexture();
              depthTexture->description.flags = Cogs::TextureFlags::DepthBuffer;
              depthTexture->description.format = Cogs::TextureFormat::R32_TYPELESS;
              depthTexture->sizeSource = renderTexture;
              renderTexture->depthTexture = depthTexture;
 
              RenderTarget * renderTarget = resources.createRenderTarget();
              renderTarget->textures.push_back(renderTexture);
              renderTarget->depth = depthTexture;
              renderTarget->width = renderTexture->description.width;
              renderTarget->height = renderTexture->description.height;
              renderTexture->renderTarget = renderTarget;
            }
 
            dataHash = Cogs::hashSequence(reinterpret_cast<intptr_t>(renderTexture),
                                          reinterpret_cast<intptr_t>(renderTexture->renderTarget),
                                          reinterpret_cast<intptr_t>(renderTexture->depthTexture));
          }
 
          if (it.second || instance->dataHash != dataHash) {
            instance->dataHash = dataHash;
 
            RenderTaskDefinition def;
            def.type = "GuiRender";
 
            PipelineOptions options;
            std::list<std::unique_ptr<SubContext>> subs;
            auto guiTask = (GuiRenderTask *)createRenderTask(taskContext, def, subs, pipelineManager->getExpressionContextRoot(), options);
            instance->pipeline.tasks.push_back(guiTask);
 
            if (renderTexture) {
              instance->pipeline.updateResources.add(renderTexture->depthTexture);
              instance->pipeline.updateResources.add(renderTexture->renderTarget);
            }
 
            guiTask->guiRenderComponent = gui.getComponentHandle<GuiRenderComponent>();
            guiTask->renderTexture = renderTexture;
            instance->dataHash = dataHash;
          }
        }
      }
    }
 
    void renderGuiInstances(const DrawContext * drawContext)
    {
      Context * context = drawContext->context;
      GuiRenderSystem * guiRenderSystem = static_cast<GuiRenderSystem*>(context->getExtensionSystem(GuiRenderSystem::getTypeId()));
      Renderer * renderer = drawContext->renderer;
      InspectorGuiRenderer * inspectorGuiRenderer = renderer->getInspectorGuiRenderer();
 
      for (auto & gui : guiRenderSystem->pool) {
        if (!gui.target) {
          GuiRenderTask guiRenderTask;
          inspectorGuiRenderer->beginRender(context, renderer);
          guiRenderTask.guiRenderComponent = gui.getComponentHandle<GuiRenderComponent>();
 
          guiRenderTask.apply(drawContext->taskContext);
 
          inspectorGuiRenderer->endRender(context, renderer);
        }
      }
    }
 
 
    void initialize(Context * /*context*/, Cogs::IGraphicsDevice * /*device*/) override
    {
    }
 
    void handleEvent(uint32_t eventId, const DrawContext * drawContext) override
    {
      switch (eventId) {
      case RenderingEvent::PreRender:
        setupPipelines(drawContext);
        break;
      case RenderingEvent::RenderGui:
        renderGuiInstances(drawContext);
        break;
      }
    }
 
    void generateCommands(const RenderTaskContext * /*renderingContext*/, RenderList * /*renderList*/) override
    {
    }
 
  };
 
}
 
 
 
namespace Cogs::Core
{
 
  struct GuiExtension : public Extension
  {
    static  constexpr const char*   cExtensionKey = "Gui";
 
    GuiModuleAPI api = {
      reinterpret_cast<LoadHTMLFn>(&GuiExtension::loadHTML),
      reinterpret_cast<SetComponentHTMLFn>(&GuiExtension::setComponentHTML),
      reinterpret_cast<SetInnerHTMLFn>(&GuiExtension::setInnerHTML),
    };
 
    GuiExtension()
    {
      ExtensionRegistry::add(this, COGS_CORE_VERSION_STRING);
    }
 
    virtual bool initializeStatic() override
    {
      GuiComponent::registerType();
      GuiRenderComponent::registerType();
      return true;
    }
 
    virtual bool initialize(Context * context) override
    {
      context->engine->addResourceManager(std::make_unique<GuiManager>(context));
 
      addTaskType("GuiRender", createGuiRenderTask, destroyGuiRenderTask);
 
 
      ExtensionRegistry::registerExtensionSystem<GuiSystem>(context, SystemPriority::PreTransform, 128);
      ExtensionRegistry::registerExtensionSystem<GuiRenderSystem>(context, SystemPriority::PreTransform, 128);
 
      // TODO:  Fix this leak...
      context->renderer->registerExtension(new GuiRenderer());
      return true;
    }
 
    virtual const char * getExtensionKey() const override   { return cExtensionKey; }
    virtual const void * getPublicAPI() const override      { return &api; }
 
    static ResourceId loadHTML(Context* context, const char* path) {
      GuiManager* manager = static_cast<GuiManager*>(context->engine->getResourceManagerByValueType(static_cast<int>(DefaultValueType::Gui)));
 
      if (manager) {
        GuiDocumentHandle document = manager->load(path, -1);
 
        manager->processLoading();
 
        if (document->getId() == NoResourceId) {
          manager->setResourceId(document.resolve(), manager->getNextResourceId());
        }
        return document->getId();
      }
      return NoResourceId;
    }
 
    static void setComponentHTML(Context* context, GuiComponent* component, ResourceId id) {
      GuiManager* manager = static_cast<GuiManager*>(context->engine->getResourceManagerByValueType(static_cast<int>(DefaultValueType::Gui)));
 
      if (manager) {
        component->document = manager->getHandle(id);
      }
    }
 
    static void setInnerHTML(Context* context, GuiComponent* component, const char* elementId, const char* html) {
      GuiSystem*  guiSystem = static_cast<GuiSystem*>(context->getExtensionSystem(GuiSystem::getTypeId()));
      GuiData&    data = guiSystem->getData(component);
 
      if (data.htmlDocument) {
        std::shared_ptr<litehtml::element>  element = findElement(data.htmlDocument->root(), elementId);
 
        if (element) {
          element->set_inner_html(html);
          data.invalidated = true;
        }
      }
    }
 
  } guiExtensionInstance;
 
}
 
extern "C" GUI_EXT_API Cogs::Core::Extension* getExtension() {
  return &Cogs::Core::guiExtensionInstance;
}