ViewState.h

#pragma once
 
#include <Cesium3DTilesSelection/BoundingVolume.h>
#include <Cesium3DTilesSelection/Library.h>
#include <CesiumGeometry/CullingVolume.h>
#include <CesiumGeometry/Plane.h>
#include <CesiumGeospatial/Cartographic.h>
#include <CesiumGeospatial/Ellipsoid.h>
 
#include <glm/mat3x3.hpp>
#include <glm/mat4x4.hpp>
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
 
#include <optional>
#include <vector>
 
namespace Cesium3DTilesSelection {
 
class CESIUM3DTILESSELECTION_API ViewState final {
 
public:
  [[deprecated("Use ViewState::ViewState instead.")]] static ViewState create(
      const glm::dvec3& position,
      const glm::dvec3& direction,
      const glm::dvec3& up,
      const glm::dvec2& viewportSize,
      double horizontalFieldOfView,
      double verticalFieldOfView,
      const CesiumGeospatial::Ellipsoid& ellipsoid CESIUM_DEFAULT_ELLIPSOID);
 
  ViewState(
      const glm::dvec3& position,
      const glm::dvec3& direction,
      const glm::dvec3& up,
      const glm::dvec2& viewportSize,
      double horizontalFieldOfView,
      double verticalFieldOfView,
      const CesiumGeospatial::Ellipsoid& ellipsoid CESIUM_DEFAULT_ELLIPSOID);
 
  ViewState(
      const glm::dmat4& viewMatrix,
      const glm::dmat4& projectionMatrix,
      const glm::dvec2& viewportSize,
      const CesiumGeospatial::Ellipsoid& ellipsoid CESIUM_DEFAULT_ELLIPSOID);
 
  ViewState(
      const glm::dvec3& position,
      const glm::dvec3& direction,
      const glm::dvec3& up,
      const glm::dvec2& viewportSize,
      double left,
      double right,
      double bottom,
      double top,
      const CesiumGeospatial::Ellipsoid& ellipsoid CESIUM_DEFAULT_ELLIPSOID);
 
  const glm::dvec3& getPosition() const noexcept { return this->_position; }
 
  const glm::dvec3& getDirection() const noexcept { return this->_direction; }
 
  glm::dvec3 getUp() const noexcept {
    return {
        this->_viewMatrix[0][1],
        this->_viewMatrix[1][1],
        this->_viewMatrix[2][1]};
  }
 
  const std::optional<CesiumGeospatial::Cartographic>&
  getPositionCartographic() const noexcept {
    return this->_positionCartographic;
  }
 
  const glm::dvec2& getViewportSize() const noexcept {
    return this->_viewportSize;
  }
 
  double getHorizontalFieldOfView() const noexcept;
 
  double getVerticalFieldOfView() const noexcept;
 
  const glm::dmat4& getViewMatrix() const noexcept { return this->_viewMatrix; }
 
  const glm::dmat4& getProjectionMatrix() const noexcept {
    return this->_projectionMatrix;
  }
 
  bool
  isBoundingVolumeVisible(const BoundingVolume& boundingVolume) const noexcept;
 
  double computeDistanceSquaredToBoundingVolume(
      const BoundingVolume& boundingVolume) const noexcept;
 
  double computeScreenSpaceError(double geometricError, double distance)
      const noexcept;
 
private:
  const glm::dvec3 _position;
  const glm::dvec3 _direction;
  const glm::dvec2 _viewportSize;
  const CesiumGeospatial::Ellipsoid _ellipsoid;
 
  const std::optional<CesiumGeospatial::Cartographic> _positionCartographic;
 
  const CesiumGeometry::CullingVolume _cullingVolume;
  const glm::dmat4 _viewMatrix;
  const glm::dmat4 _projectionMatrix;
};
 
} // namespace Cesium3DTilesSelection