GuiSystem.cpp

#include "GuiSystem.h"
#include "GuiContainer.h"
#include "GuiDocument.h"
#include "GuiRenderComponent.h"
#include "GuiRenderSystem.h"
 
#include "Context.h"
#include "ViewContext.h"
 
#include "Resources/ResourceStore.h"
#include "Resources/Texture.h"
 
#include "Renderer/Renderer.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/CameraSystem.h"
 
#include "Math/Projection.h"
#include "Input/InputManager.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/Mouse.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GuiSystem");
}
 
Cogs::Core::GuiData::~GuiData() {
  if (htmlDocument) {
    GuiContainer* container = static_cast<GuiContainer*>(htmlDocument->container());
 
    htmlDocument = nullptr;
    delete container;
  }
}
 
Cogs::Core::GuiSystem::~GuiSystem() {
  for (auto i = themes.begin(), e = themes.end(); i != e; ++i) {
    delete i->second;
  }
}
 
void Cogs::Core::GuiSystem::update(Context * context) {
  Renderer* renderer = dynamic_cast<Renderer*>(context->renderer);
 
  // Skip initialization until the renderer has been initialized.
  if (!renderer->getRenderContext().device) return;
 
  for (const auto & guiComponent : pool) {
    auto& guiData = getData(&guiComponent);
    auto  guiDocument = guiComponent.document.resolve();
 
    if (guiDocument && !guiData.htmlDocument && guiDocument->htmlContent.size()) {
      GuiContainer* container = new GuiContainer();
 
      if (guiComponent.listenerID) {
        container->addListener(guiComponent.listenerID);
      }
      container->initialize(&renderer->getRenderContext(), context->renderer->getInspectorGuiRenderer());
      container->pushState(guiComponent.getContainer(), context->renderer->getSize());
 
      guiData.htmlDocument = litehtml::document::createFromString(guiDocument->htmlContent.c_str(), container, &guiDocument->htmlContext);
 
      if (!guiData.htmlDocument) {
        LOG_ERROR(logger, "Could not create GUI document from string.");
        continue;
      }
 
      guiData.htmlDocument->set_userdata(guiComponent.getContainer());
 
      container->on_load(guiData.htmlDocument);
 
      guiData.invalidated = true;
    }
 
    if (!guiDocument) continue;
    if (!guiData.htmlDocument) continue;
 
    if (guiComponent.alwaysInvalidate) guiData.invalidated = true;
 
    if (guiComponent.theme != guiData.theme) {
      auto            i = themes.find(guiComponent.theme);
      litehtml::css*  theme = nullptr;
 
      if (i == themes.end()) {
        std::string css = context->resourceStore->getResourceContentString(guiComponent.theme, ResourceStoreFlags::None);
 
        theme = new litehtml::css();
        theme->parse_stylesheet(css.c_str(), guiComponent.theme.c_str(), std::shared_ptr<litehtml::document>(), litehtml::media_query_list::ptr());
        theme->sort_selectors();
        themes[guiComponent.theme] = theme;
      }
      else {
        theme = i->second;
      }
      guiData.htmlDocument->apply_styles(theme);
      guiData.invalidated = true;
      guiData.theme = guiComponent.theme;
    }
 
    updateInputs(guiComponent, guiData);
 
    auto renderComponent = guiComponent.getComponent<GuiRenderComponent>();
    auto & texture = renderComponent->target;
 
    guiData.size = texture ? glm::vec2{ texture->description.width, texture->description.height } : context->renderer->getSize();
 
    static_cast<GuiContainer*>(guiData.htmlDocument->container())->pushState(guiComponent.getContainer(), guiData.size);
 
    float x = guiData.pointerX;
    float y = guiData.pointerY;
 
    if (guiData.pointerRelative) {
      x *= guiData.size.x;
      y *= guiData.size.y;
    }
 
    litehtml::position::vector pos;
    if (guiData.pointerInside) {
      guiData.htmlDocument->on_mouse_over((int)x, (int)y, 0, 0, pos);
 
      if (guiData.pointerX != guiData.lastX || guiData.pointerY != guiData.lastY) {
        guiData.htmlDocument->on_mouse_move((int)x, (int)y);
 
        guiData.lastX = guiData.pointerX;
        guiData.lastY = guiData.pointerY;
      }
 
      if (guiData.pointerDown) {
        guiData.htmlDocument->on_lbutton_down((int)x, (int)y, 0, 0, pos);
      } else if (guiData.pointerUp) {
        guiData.htmlDocument->on_lbutton_up((int)x, (int)y, 0, 0, pos);
      }
    } else {
      guiData.htmlDocument->on_mouse_leave(pos);
    }
 
    guiData.invalidated = guiData.invalidated || static_cast<GuiContainer*>(guiData.htmlDocument->container())->isInvalidated() || !renderComponent->target;
  }
}
 
void Cogs::Core::GuiSystem::updateInputs(const GuiComponent & guiComponent, GuiData & data)
{
  auto & mouseState = context->getDefaultView()->refMouse().getState();
  const bool pointerState = context->getDefaultView()->inputManager->getActionState(guiComponent.pointerAction);
  int x = mouseState.position.x;
  int y = mouseState.position.y;
 
  data.pointerDown = data.pointerUp = false;
  data.pointerInside = false;
 
  if (pointerState != data.pointerState) {
    data.pointerState = pointerState;
    if (pointerState) {
      data.pointerDown = true;
    } else {
      data.pointerUp = true;
    }
  }
 
  auto pointerSource = guiComponent.pointerSource;
  if (guiComponent.pointerSource == GuiPointerSource::Auto) {
    auto guiRenderComponent = guiComponent.getComponent<GuiRenderComponent>();
 
    if (!guiComponent.projector && !guiRenderComponent->target) {
      pointerSource = GuiPointerSource::Mouse;
    } else if (!guiComponent.projector && guiRenderComponent->target) {
      pointerSource = GuiPointerSource::ProjectedMouse;
    } else if (guiComponent.projector) {
      pointerSource = GuiPointerSource::Projector;
    }
  }
 
  auto transformComponent = guiComponent.getComponent<TransformComponent>();
 
  if (!transformComponent) return;
 
  auto worldTransform = context->transformSystem->getLocalToWorld(transformComponent);
 
  glm::vec3 planeNormal = glm::vec3(worldTransform * glm::vec4(0, 0, 1, 0));
  glm::vec3 planeOrigin = glm::vec3(worldTransform * glm::vec4(0, 0, 0, 1));
 
  auto inverseWorldTransform = glm::inverse(worldTransform);
 
  auto projectPointer = [&](float /*nX*/, float /*nY*/, const glm::vec3 & rayOrigin, const glm::vec3 & rayDirection) -> bool
  {
    glm::vec3 coords;
    float t;
    bool intersects = Cogs::Geometry::projectToPlane(
      rayOrigin,
      rayDirection,
      planeOrigin,
      planeNormal,
      coords,
      &t
    );
 
    if (intersects && t < 0.0f) {
      auto inPlaneCoords = glm::vec3(inverseWorldTransform * glm::vec4(coords, 1));
      data.pointerInside = true;
 
      // Diff vector in plane
      glm::vec3 ll = -glm::vec3(guiComponent.planeSize.x * 0.5f, guiComponent.planeSize.y * 0.5f, 0);
      glm::vec3 diff = inPlaneCoords - ll;
 
      diff.x *= (1.0f / guiComponent.planeSize.x);
      diff.y *= (1.0f / guiComponent.planeSize.y);
 
      data.pointerX = diff.x;
      data.pointerY = 1.0f - diff.y;
      data.pointerRelative = true;
 
      return true;
    }
 
    return false;
  };
 
  auto projectViewPointer = [&](float nX, float nY, const glm::mat4 & invViewProj) -> bool
  {
    glm::vec4 hp = invViewProj * glm::vec4(nX, nY, -1.f, 1.f);
    glm::vec3 rayOrigin = (1.f / hp.w) * glm::vec3(hp);
 
    glm::vec4 hq = invViewProj * glm::vec4(nX, nY, 1.f, 1.f);
    glm::vec3 rayDirection = -glm::normalize((1.f / hq.w) * glm::vec3(hq) - rayOrigin);
 
    return projectPointer(nX, nY, rayOrigin, rayDirection);
  };
 
  switch (pointerSource)
  {
  case GuiPointerSource::Mouse:
  {
    data.pointerInside = true;
    data.pointerX = (float)x;
    data.pointerY = (float)y;
    data.pointerRelative = false;
    break;
  }
  case GuiPointerSource::ProjectedMouse:
  {
    auto & cameraData = context->cameraSystem->getData(context->cameraSystem->getMainCamera());
    auto invViewProj = glm::inverse(cameraData.rawProjectionMatrix * cameraData.viewMatrix);
 
    const auto size = context->renderer->getSize();
 
    const float nx = ((2.0f * (static_cast<float>(x) / size.x)) - 1.0f);
    const float ny = -((2.0f * (static_cast<float>(y) / size.y)) - 1.0f);
 
    projectViewPointer(nx, ny, invViewProj);
 
    break;
  }
  case GuiPointerSource::ProjectedCenter:
  {
    auto & cameraData = context->cameraSystem->getData(context->cameraSystem->getMainCamera());
    auto invViewProj = glm::inverse(cameraData.rawProjectionMatrix * cameraData.viewMatrix);
 
    projectViewPointer(0, 0, invViewProj);
 
    break;
  }
  case GuiPointerSource::Projector:
  {
    const auto projectorTransform = guiComponent.projector->getComponent<TransformComponent>();
    const auto projectorWorld = context->transformSystem->getLocalToWorld(projectorTransform);
 
    auto rayOrigin = glm::vec3(projectorWorld * glm::vec4(0, 0, 0, 1));
    auto rayDir = -glm::normalize(glm::vec3(projectorWorld * glm::vec4(0, 0, -1, 0)));
 
    projectPointer(0, 0, rayOrigin, rayDir);
 
    break;
  }
  default:
    LOG_ERROR(logger, "Invalid pointer source.");
    break;
  }
}