ViewState.h

#pragma once
 
#include <Cesium3DTilesSelection/BoundingVolume.h>
#include <Cesium3DTilesSelection/GeneralCullingVolume.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 <functional>
#include <memory>
#include <optional>
#include <utility>
 
namespace Cesium3DTilesSelection {
 
class Tile;

class CESIUM3DTILESSELECTION_API ViewStateMeasureDelegate {
public:
  virtual double computeSelectionMeasure(
      const Tile& tile,
      double distance,
      uint32_t depth) const = 0;
  virtual ~ViewStateMeasureDelegate() = default;
};

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);

  ViewState(
      const BoundingVolume& boundingVolume,
      std::shared_ptr<ViewStateMeasureDelegate> pMeasureDelegate,
      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;

  double computeScreenSpaceError(
      const Tile& tile,
      double distance,
      uint32_t depth) const noexcept;
 
private:
  glm::dvec3 _position;
  glm::dvec3 _direction;
  glm::dvec2 _viewportSize;
  CesiumGeospatial::Ellipsoid _ellipsoid;
 
  std::optional<CesiumGeospatial::Cartographic> _positionCartographic;
 
  Cesium3DTilesSelection::GeneralCullingVolume _cullingVolume;
  glm::dmat4 _viewMatrix;
  glm::dmat4 _projectionMatrix;
  std::shared_ptr<ViewStateMeasureDelegate> _pMeasureDelegate;
};
 
} // namespace Cesium3DTilesSelection