CameraUtils.h

#pragma once
 
#include "CameraHelper.h"
#include "Math/Projection.h"
#include "Components/Core/TransformComponent.h"
#include <type_traits>
 
 
namespace Cogs::Utility::CameraUtils
{
  namespace detail
  {
    template<class TransformComponent>
    inline auto getRotation(const TransformComponent transformComponent)
    {
      using TransformType = std::remove_cv_t<std::remove_pointer_t<TransformComponent>>;
      if constexpr (std::is_same_v<TransformType, Cogs::Core::TransformComponent>) {
        return transformComponent->transform.trs.rotation;
      }
      else {
        return glm::quat(transformComponent->rotation);
      }
    }
 
    template<class TransformComponent>
    inline void setPosition(const TransformComponent transformComponent, const glm::vec3& position)
    {
      using TransformType = std::remove_cv_t<std::remove_pointer_t<TransformComponent>>;
      if constexpr (std::is_same_v<TransformType, Cogs::Core::TransformComponent>) {
        transformComponent->transform.trs.position = position;
      }
      else {
        transformComponent->position = position;
      }
    }
  }
 
  template<class TransformComponent, class OrbitingCameraController>
  inline glm::quat getCameraOrientation(const TransformComponent transformComponent, const OrbitingCameraController orbitingCameraController)
  {
    glm::quat orientation;
    if (orbitingCameraController) {
      orientation = Cogs::Utility::CameraHelper::getOrientation(orbitingCameraController->horizontalAngle, orbitingCameraController->verticalAngle);
    }
    else {
      orientation = detail::getRotation(transformComponent);
    }
 
    return orientation;
  }
 
  template<class CameraComponent, class TransformComponent, class OrbitingCameraController, typename ProjectionMode>
  inline glm::dvec3 viewAll(const CameraComponent cameraComponent, const TransformComponent transformComponent, const OrbitingCameraController orbitingCameraController, const ProjectionMode projectionMode, const Cogs::Geometry::DBoundingBox& boundingBox, glm::vec2 viewport = glm::vec2(0.0f, 0.0f))
  {
    float fieldOfView = cameraComponent->fieldOfView;
    glm::quat orientation = Cogs::Utility::CameraUtils::getCameraOrientation(transformComponent, orbitingCameraController);
    glm::dvec3 position = Cogs::Utility::CameraHelper::getViewAllPosition(boundingBox, orientation, fieldOfView, viewport);
    float focalDistance = Cogs::Utility::CameraHelper::getFocalDistance(position, boundingBox);
    if (orbitingCameraController) {
      const glm::dvec3 center = Cogs::Utility::CameraHelper::getCenter(boundingBox);
      orbitingCameraController->cameraTarget = center;
      orbitingCameraController->distance = focalDistance;
      orbitingCameraController->setChanged();
    }
    else {
      transformComponent->coordinates = position;
      detail::setPosition(transformComponent, glm::vec3(0, 0, 0));
      transformComponent->setChanged();
    }
 
    const float farDistance = Cogs::Utility::CameraHelper::getFarDistance(position, boundingBox);
    const float oldFarDistance = cameraComponent->farDistance;
    if (oldFarDistance < farDistance) {
      cameraComponent->farDistance = farDistance;
    }
 
    cameraComponent->focalDistance = focalDistance;
 
    if (projectionMode == ProjectionMode::Orthographic) {
      cameraComponent->orthoHeight = Cogs::Utility::CameraHelper::getOrthoHeight(boundingBox);
    }
 
    cameraComponent->setChanged();
 
    return position;
  }
 
  template<class CameraData>
  inline bool getProjectedCoordinates(const glm::vec2& coordinatesToProject, const CameraData& cameraData, const glm::vec3& targetPlaneNormal, const glm::vec3& targetPlanePosition, glm::vec3& projectedCoordinates)
  {
    glm::vec3 planeNormal = targetPlaneNormal;
    if (planeNormal.x == 0.f && planeNormal.y == 0.f && planeNormal.z == 0.f) {
      planeNormal = -glm::vec3(cameraData.inverseViewMatrix[2]);
    }
 
    const glm::vec3 cameraPosition = glm::vec3(cameraData.inverseViewMatrix[3]);
    glm::mat4 invViewProj = glm::inverse(cameraData.rawProjectionMatrix * cameraData.viewMatrix);
    float     nx = ((2.0f * (static_cast<float>(coordinatesToProject.x) / cameraData.viewportSize.x)) - 1.0f);
    float     ny = -((2.0f * (static_cast<float>(coordinatesToProject.y) / cameraData.viewportSize.y)) - 1.0f);
    glm::vec4 nearPlaneHit = invViewProj * glm::vec4(nx, ny, -1.f, 1.f);
    glm::vec3 rayOrigin = (1.f / nearPlaneHit.w)*glm::vec3(nearPlaneHit);
    glm::vec4 farPlaneHit = invViewProj * glm::vec4(nx, ny, 1.f, 1.f);
 
    if (farPlaneHit.w == 0) {
      farPlaneHit.w = glm::epsilon<float>();
    }
    glm::vec3 rayDirection = glm::normalize((1.f / farPlaneHit.w)*glm::vec3(farPlaneHit) - rayOrigin);
    float     t;
    bool      intersects = Cogs::Geometry::projectToPlane(rayOrigin, rayDirection, targetPlanePosition, planeNormal, projectedCoordinates, &t);
    bool      isInFrontOfCamera = t + glm::distance(cameraPosition, rayOrigin) >= 0;
 
    return intersects && isInFrontOfCamera;
  }
}