CameraHelper.cpp

#include "CameraHelper.h"
 
#include <cmath>
 
namespace Cogs::Utility
{
  glm::dvec3 CameraHelper::getCenter(const Cogs::Geometry::DBoundingBox& boundingBox)
  {
    glm::dvec3 center = (boundingBox.min + boundingBox.max) * 0.5;
    return center;
  }
 
  float CameraHelper::getFarDistance(const glm::dvec3& position, const Cogs::Geometry::DBoundingBox& boundingBox)
  {
    float radius = getRadius(boundingBox);
    return getFocalDistance(position, boundingBox) + radius;
  }
 
  float CameraHelper::getFocalDistance(const glm::dvec3& position, const Cogs::Geometry::DBoundingBox& boundingBox)
  {
    const glm::dvec3 center = getCenter(boundingBox);
    float distance_to_midpoint = static_cast<float>(glm::length(position - center));
    return distance_to_midpoint;
  }
 
  glm::quat CameraHelper::getOrientation(float horizontalAngle, float verticalAngle)
  {
    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;
    return rotation;
  }
 
  float CameraHelper::getOrthoHeight(const Cogs::Geometry::DBoundingBox& boundingBox)
  {
    // Get the radius of the bounding sphere.
    const float radius = getRadius(boundingBox);
 
    const float orthoHeight = radius * 2;
 
    return orthoHeight;
  }
 
  float CameraHelper::getRadius(const Cogs::Geometry::DBoundingBox& boundingBox)
  {
    const glm::dvec3 size = boundingBox.max - boundingBox.min;
    const float radius = static_cast<float>(glm::length(size) / 2.0);
    return radius;
  }
 
  glm::dvec3 CameraHelper::getFocalPosition(const glm::dvec3& position, const glm::quat& orientation, float focalDistance)
  {
    const glm::vec3 direction = orientation * glm::vec3(0, 0, -1);
    glm::normalize(direction);
    const glm::dvec3 result = position + glm::dvec3(direction * focalDistance);
    return result;
  }
 
  glm::dvec3 CameraHelper::getViewAllPosition(const Cogs::Geometry::DBoundingBox& boundingBox,
                                              const glm::quat& orientation, float fieldOfView, glm::vec2 viewport)
  {
    const float viewportWidth = viewport.x;
    const float viewportHeight = viewport.y;
 
    float aspect = 1.0f;
    if ((viewportWidth > 0.0f) && (viewportHeight > 0.0f))
      aspect = viewportWidth / viewportHeight;
 
    // First, we want to move the camera in such a way that it is
    // pointing straight at the center of the scene bounding box 
    const glm::vec3 cameraDirection = orientation * glm::vec3(0, 0, -1);
    const glm::dvec3 center = getCenter(boundingBox);
 
    // Get the radius of the bounding sphere.
    const float radius = getRadius(boundingBox);
 
    // Make sure that everything will still be inside the viewing volume
    // even if the aspect ratio "favors" width over height.
    const float aspectRadius = radius / (aspect < 1.0f ? aspect : 1.0f);
 
    // Move the camera to the edge of the bounding sphere, while still
    // pointing at the scene.
    glm::vec3 direction = -cameraDirection;
    glm::normalize(direction);
 
    // There's a small chance that the frustum will intersect the
    // bounding box when we calculate the movelength like this, but for
    // all normal heightAngles it will yield a much better fit than
    // the 100% safe version which also adds radius to movelength
 
    const float movelength = aspectRadius / std::tan(fieldOfView / 2.0f);
    const glm::dvec3 position = center + glm::dvec3(direction * movelength);
    return position;
  }
}