OrbitingCameraController.cpp

#include "OrbitingCameraController.h"
 
#include "Bridge/SceneFunctions.h"
 
#include "Context.h"
#include "Engine.h"
#include "Types.h"
#include "ViewContext.h"
 
#include "Editor/IEditor.h"
 
#include "Components/Core/TransformComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/CameraComponent.h"
 
#include "Input/KeyboardMapping.h"
#include "Input/InputManager.h"
 
#include "Renderer/CustomRenderer/ImguiRenderer.h"
 
#include "Scene/RayPick.h"
#include "Systems/Core/CameraSystem.h"
 
#include "Utilities/CameraUtils.h"
 
#include "Foundation/Platform/Mouse.h"
#include "Foundation/Platform/Keyboard.h"
 
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/ext/quaternion_float.hpp>
#include <glm/gtx/compatibility.hpp>
 
#include "imgui.h"
#include "ImGuizmo.h"
 
using namespace Cogs::Reflection;
 
Cogs::Core::OrbitingCameraController::OrbitingCameraController()
{
  minVerticalAngle = 0.0f;
}
 
void Cogs::Core::OrbitingCameraController::registerType()
{
  Method methods[] = {
    { "initialize", &OrbitingCameraController::initialize },
    { "update", &OrbitingCameraController::update },
  };
 
  Field fields [] = {
    Field("cameraTarget",      &OrbitingCameraController::cameraTarget),
    Field("cameraLook",        &OrbitingCameraController::cameraLook),
    Field::create("verticalAngle",     &OrbitingCameraController::verticalAngle)
      .setRange(-glm::pi<float>(), glm::pi<float>()),
    Field::create("horizontalAngle",   &OrbitingCameraController::horizontalAngle)
      .setRange(-2.0f * glm::pi<float>(), 2.0f * glm::pi<float>()),
    Field("distance",          &OrbitingCameraController::distance),
    Field::create("minVerticalAngle",  &OrbitingCameraController::minVerticalAngle)
      .setRange(-glm::pi<float>(), glm::pi<float>()),
    Field::create("maxVerticalAngle",  &OrbitingCameraController::maxVerticalAngle)
      .setRange(-glm::pi<float>(), glm::pi<float>()),
    Field("minDistance",       &OrbitingCameraController::minDistance),
    Field("maxDistance",       &OrbitingCameraController::maxDistance),
    Field("minFOV",            &OrbitingCameraController::minFOV),
    Field("maxFOV",            &OrbitingCameraController::maxFOV),
    Field("enabled",           &OrbitingCameraController::enabled),
    Field("seek",              &OrbitingCameraController::seek),
    Field("moveCamera",        &OrbitingCameraController::moveCamera),
  };
 
  DynamicComponent::registerDerivedType<OrbitingCameraController>().setFields(fields).setMethods(methods);
}
 
 
void Cogs::Core::OrbitingCameraController::initialize(Context* ctx)
{
  context = ctx;
  // Use the view with the same camera as this component is attached to if it can be found, otherwise use the default view.
  if (auto camera = getComponent<CameraComponent>(); camera) {
    for (ViewContext* v : context->getViews()) {
      if (v->getCameraComponent() == camera) {
        view = v;
        return;
      }
    }
  }
  view = context->getDefaultView();
}
 
 
void Cogs::Core::OrbitingCameraController::handleSeek(float x, float y)
{
  if (auto camera = getComponent<CameraComponent>(); camera) {
    float viewportX = x - camera->viewportOrigin.x;
    float viewportY = context->renderer->getSize().y - (int)camera->viewportOrigin.y - (y - (int)camera->viewportOrigin.y) - 1;
    if (viewportX >= 0 && viewportY >= 0 && viewportX < camera->viewportSize.x && viewportY < camera->viewportSize.y) {
      std::vector<RayPicking::RayPickHit> picked;
      context->rayPicking->pickCamera(context, *camera, glm::vec2(viewportX, viewportY), std::numeric_limits<float>::max(),
                                      defaultPickingRadius, PickingFlags::None, PicksReturned::Closest, {}, picked);
      if (!picked.empty()) {
        cameraTarget = context->transformSystem->worldFromEngineCoords(picked.front().position);
      }
    }
  }
}
 
void Cogs::Core::OrbitingCameraController::handleRotate(float x0, float y0, float x1, float y1, bool first)
{
  if (first) {
    horizontalAngleStart = horizontalAngle;
    verticalAngleStart = verticalAngle;
  }
  horizontalAngle = fmodf(horizontalAngleStart - (x1 - x0) * 0.005f, 2.0f * glm::pi<float>());
  verticalAngle = glm::clamp(verticalAngleStart - (y1 - y0) * 0.005f, minVerticalAngle, maxVerticalAngle);
}
 
void Cogs::Core::OrbitingCameraController::handleTranslate(float x0, float y0, float x1, float y1, bool first)
{
  if (first) { cameraTargetStart = cameraTarget; }
  const CameraData& cameraData = context->cameraSystem->getData(getComponent<CameraComponent>());
 
  // Move camera target into view space and check if it is in front of the camera
  glm::vec4 cameraTargetView = cameraData.viewMatrix * glm::vec4(context->transformSystem->engineFromWorldCoords(cameraTarget), 1.f);
  if (cameraTargetView.z < 0.f) {
 
    // Camera target in clip space
    glm::vec4 cameraTargetClip = cameraData.projectionMatrix * cameraTargetView;
 
    // Mouse position xy in clip space
    glm::vec2 viewportScale = (2.f * cameraTargetClip.w) / cameraData.viewportSize;
    glm::vec2 p0 = viewportScale * (glm::vec2(x0, y0) - cameraData.viewportOrigin) - glm::vec2(1.f);
    glm::vec2 p1 = viewportScale * (glm::vec2(x1, y1) - cameraData.viewportOrigin) - glm::vec2(1.f);
 
    // Create mouse positions in clip space and transform to engine coords
    glm::vec4 ah = cameraData.inverseViewProjectionMatrix * glm::vec4(p0.x, -p0.y, cameraTargetClip.z, cameraTargetClip.w);
    glm::vec3 a = (1.f / ah.w) * glm::vec3(ah);
 
    glm::vec4 bh = cameraData.inverseViewProjectionMatrix * glm::vec4(p1.x, -p1.y, cameraTargetClip.z, cameraTargetClip.w);
    glm::vec3 b = (1.f / bh.w) * glm::vec3(bh);
 
    // Find relative movement and move target
    glm::dvec3 diff = glm::dvec3(b) - glm::dvec3(a);
    if (glm::all(glm::isfinite(diff)) && glm::length(diff) != 0) {
      cameraTarget = cameraTargetStart - diff;
    }
  }
}
 
void Cogs::Core::OrbitingCameraController::handleDolly(float delta, bool first)
{
  if (first) { distanceStart = distance; }
  distance = glm::clamp(distanceStart * expf(-delta), minDistance, maxDistance);
}
 
void Cogs::Core::OrbitingCameraController::handleZoom(float delta, bool first)
{
  if (CameraComponent* camera = getComponent<CameraComponent>(); camera != nullptr) {
    if (first) { fovStart = camera->fieldOfView; }
    camera->fieldOfView = glm::clamp(fovStart * expf(-delta), minFOV, maxFOV);
  }
}
 
void Cogs::Core::OrbitingCameraController::update()
{
  if(!enabled || view == nullptr) return;
  // If the OCC was marked as changed, update even when imgui has the focus.
  if(!hasChanged() && (ImGuizmo::IsUsing() || ImguiRenderer::isUsingMouse())) return;
 
  bool shiftIsDown = view->refKeyboard().isKeyDown(Key::Shift);
  bool sIsDown = view->refKeyboard().isKeyDown(Key::S);
  const std::vector<Gesture>& gestures = view->refGestures().getGestures();
  for (const Gesture& g : gestures) {
    bool started = g.state == Gesture::State::Started;
    switch (g.kind) {
    case Gesture::Kind::Press:
      if (g.state == Gesture::State::Ended && sIsDown) { handleSeek(g.press.coord.x, g.press.coord.y); }
      break;
    case Gesture::Kind::Tap:
      if (sIsDown) { handleSeek(g.tap.coord.x, g.tap.coord.y); }
      break;
    case Gesture::Kind::DoubleTap:
      handleSeek(g.doubleTap.coord.x, g.doubleTap.coord.y);
      break;
    case Gesture::Kind::Wheel:
      if (shiftIsDown) handleZoom(0.12f * g.wheel.delta, true);
      else handleDolly(0.12f * g.wheel.delta, true);
      break;
    case Gesture::Kind::Drag:
      switch (g.drag.button) {
      case MouseButton::Middle: handleTranslate(g.drag.startCoord.x, g.drag.startCoord.y, g.drag.currCoord.x, g.drag.currCoord.y, started); break;
      case MouseButton::Left: handleRotate(g.drag.startCoord.x, g.drag.startCoord.y, g.drag.currCoord.x, g.drag.currCoord.y, started); break;
      case MouseButton::Right:
      {
        // Make sure to reset the drag starting position when shift is pressed/released while right mouse btn dragging,
        // otherwise there will be a visible jump between zoom and dolly.
        if (g.state == Gesture::State::Started) {
          dragStartCoordY = g.drag.startCoord.y;
        }
        if (shiftIsDown != prevDragWithShift) {
          prevDragWithShift = shiftIsDown;
          dragStartCoordY = g.drag.currCoord.y;
          started = true;
        }
 
        if (shiftIsDown) handleZoom(0.01f * (g.drag.currCoord.y - dragStartCoordY), started);
        else handleDolly(0.01f * (g.drag.currCoord.y - dragStartCoordY), started);
        break;
      }
      default: break;
      }
      break;
    case Gesture::Kind::Pan:
      handleTranslate(g.pan.midStartCoord.x, g.pan.midStartCoord.y, g.pan.midCurrCoord.x, g.pan.midCurrCoord.y, started);
      break;
    case Gesture::Kind::Pinch:
      handleDolly(g.pinch.scale - 1.f, started);
      break;
    case Gesture::Kind::Hover:
    case Gesture::Kind::Swipe:
    case Gesture::Kind::Rotate:
    default:
      break;
    }
  }
 
  glm::quat horizontalRotation = glm::angleAxis(horizontalAngle, glm::vec3(0, 0, 1));
  glm::quat verticalRotation = glm::angleAxis(verticalAngle, glm::vec3(1, 0, 0));
  glm::quat rotation = horizontalRotation * verticalRotation;
 
  TransformComponent* transform = getComponent<TransformComponent>();
 
  const glm::vec3 cameraDirection = rotation * glm::vec3(0, 0, 1);
  const glm::dvec3 cameraPos = cameraTarget + glm::dvec3(distance *cameraDirection);
  if (moveCamera && glm::all(glm::isfinite(cameraPos))) {
 
    // Check if we are a root node or not
    const ComponentHandle parent = getComponent<SceneComponent>()->parent;
 
    // Camera is root node
    if (!parent) {
 
      // Avoid continuous updates
      if (transform->coordinates != cameraPos || transform->position != glm::vec3(0.f)) {
        transform->coordinates = cameraPos;
        transform->position = glm::vec3(0.f);
        transform->setChanged();
      }
    }
 
    // Camera is not a root node, get hold of root
    else {
      const SceneComponent* root = parent.resolveComponent<SceneComponent>();
      while (root && root->parent) {
        root = root->parent.resolveComponent<SceneComponent>();
      }
      if (root) {
        const TransformComponent* rootTransform = root->getComponent<TransformComponent>();
        if (rootTransform) {
 
          // Remove coordinates of root entity.
          glm::vec3 cameraPosInRoot = glm::vec3(cameraPos - rootTransform->coordinates);
 
          // FIXME: Reverse all transforms up the chain. Need a good case before tackling that.
 
          // Avoid continuous updates
          if (transform->position != cameraPosInRoot) {
            transform->position = cameraPosInRoot;
            transform->setChanged();
          }
        }
      }
    }
 
  }
 
  // Avoid continuous updates of camera.
  cameraLook = -cameraDirection;
  const glm::vec3 cameraUp = rotation * glm::vec3(0, 1, 0);
  const glm::quat cameraRot = glm::quat_cast(glm::inverse(glm::lookAt(cameraDirection, glm::vec3(0.f), cameraUp)));
  if (cameraRot != transform->rotation) {
    transform->rotation = cameraRot;
    transform->setChanged();
  }
}