OrientedBoundingBox.h

#pragma once
 
#include "AxisAlignedBox.h"
#include "BoundingSphere.h"
#include "CullingResult.h"
#include "Library.h"
 
#include <glm/mat3x3.hpp>
#include <glm/vec3.hpp>
 
namespace CesiumGeometry {
 
class Plane;
 
class CESIUMGEOMETRY_API OrientedBoundingBox final {
public:
  OrientedBoundingBox(
      const glm::dvec3& center,
      const glm::dmat3& halfAxes) noexcept
      : _center(center),
        _halfAxes(halfAxes),
        // TODO: what should we do if halfAxes is singular?
        _inverseHalfAxes(glm::inverse(halfAxes)),
        _lengths(
            2.0 * glm::length(_halfAxes[0]),
            2.0 * glm::length(_halfAxes[1]),
            2.0 * glm::length(_halfAxes[2])) {}
 
  constexpr const glm::dvec3& getCenter() const noexcept {
    return this->_center;
  }
 
  constexpr const glm::dmat3& getHalfAxes() const noexcept {
    return this->_halfAxes;
  }
 
  constexpr const glm::dmat3& getInverseHalfAxes() const noexcept {
    return this->_inverseHalfAxes;
  }
 
  constexpr const glm::dvec3& getLengths() const noexcept {
    return this->_lengths;
  }
 
  CullingResult intersectPlane(const Plane& plane) const noexcept;
 
  double
  computeDistanceSquaredToPosition(const glm::dvec3& position) const noexcept;
 
  bool contains(const glm::dvec3& position) const noexcept;
 
  OrientedBoundingBox
  transform(const glm::dmat4& transformation) const noexcept;
 
  AxisAlignedBox toAxisAligned() const noexcept;
 
  BoundingSphere toSphere() const noexcept;
 
  static OrientedBoundingBox
  fromAxisAligned(const AxisAlignedBox& axisAligned) noexcept;
 
  static OrientedBoundingBox fromSphere(const BoundingSphere& sphere) noexcept;
 
private:
  glm::dvec3 _center;
  glm::dmat3 _halfAxes;
  glm::dmat3 _inverseHalfAxes;
  glm::dvec3 _lengths;
};
 
} // namespace CesiumGeometry