OrientedBoundingBox.h

#pragma once
 
#include <CesiumGeometry/AxisAlignedBox.h>
#include <CesiumGeometry/BoundingSphere.h>
#include <CesiumGeometry/CullingResult.h>
#include <CesiumGeometry/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