DtCamera.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2023 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/

#pragma once

#include <vrvMath/DtCommonTypes.h>
#include <vrvMath/DtAssert.h>
#include <vrvMath/DtMatrixUtils.h>
#include <vrvMath/DtAxisAlignedBoundingBox.h>
#include <vrvMath/DtPlane.h>
#include <vrvMath/DtScreenRect.h>
#include <vrvMath/DtVector2.h>
#include <vrvMath/DtIntSize.h>
#include <vrvMath/DtMatrix4.h>

#include <array>

namespace makVrv {

   enum FrustumPlane
   {
      FRUSTUM_PLANE_NEAR = 0,
      FRUSTUM_PLANE_FAR = 1,
      FRUSTUM_PLANE_LEFT = 2,
      FRUSTUM_PLANE_RIGHT = 3,
      FRUSTUM_PLANE_TOP = 4,
      FRUSTUM_PLANE_BOTTOM = 5
   };

   enum VisibilityFromCamera
   {
      VISIBILITY_NONE = 0, VISIBILITY_PARTIAL = 1, VISIBILITY_FULL = 2
   };

   template <class T>
   class DtCamera
   {
   public:
      DtCamera();
      virtual ~DtCamera();

      void setNearPlane(T fNearPlane);
      T    nearPlane(void) const;

      void setFarPlane(T fFarPlane);
      T    farPlane(void) const;

      void setFieldOfView(T fFOVy);
      T fieldOfView(void) const;

      void setPosition(const DtVector3<T>& vPosition);
      DtVector3<T> position(void) const;

      void setDirection(const DtVector3<T>& vDirection);
      DtVector3<T> direction(void) const;

      DtVector3<T> upVector(void) const;
      DtVector3<T> sideVector(void) const;

      void lookAt(const DtVector3<T>& vEye, const DtVector3<T>& vLook, const DtVector3<T>& vUp);
      const DtMatrix4<T>& ViewMatrix(void) const;

      void SetPerspective(T fFOVy, T fAspectRatio, T fNearPlane, T fFarPlane);
      const DtMatrix4<T>& ProjectionMatrix(void) const;

      const DtMatrix4<T>& ViewProjectionMatrix(void) const;

      void setFixedUpVector(bool fixed);
      bool isFixedUpVector(void) const;

      T aspectRatio(void) const;

      bool IsVisible(const DtAxisAlignedBoundingBox<T>& box) const;

      VisibilityFromCamera getVisibility(const DtAxisAlignedBoundingBox<T>& box) const;

      DtScreenRect screenAABB(const DtAxisAlignedBoundingBox<T>& worldBox
         , const Vector2_uint32& viewPortSize) const;
   private:
      DtVector3<T> myVecPosition;
      DtVector3<T> myVecDirection;
      DtVector3<T> myVecUpVector;
      DtVector3<T> myVecSideVector;

      T myfNearPlane;
      T myfFarPlane;
      T myfFieldOfViewY;
      T myfAspectRatio;

      DtMatrix4<T> myViewMatrix;
      DtMatrix4<T> myProjectionMatrix;
      DtMatrix4<T> myViewProjectionMatrix;

      bool mybFixedUpVector;

      DtPlane<T> myFrustumPlanes[6];
      void updateFrustumPlanes(void);
      void updateViewProjectionMatrix(void);
   };

   template <class T>
   class ProjectionUtils
   {
   public:
      static DtVector2<T> project(const DtVector3<T>& vPosition
         , const DtMatrix4<T>& view_projection_matrix
         , bool clip = true);

      static Vector2_int project(const DtVector3<T>& vPosition
         , const DtMatrix4<T>& view_projection_matrix
         , const Vector2_uint32& viewPortSize
         , bool clip = true);

      static DtScreenRect screenAABB(const DtAxisAlignedBoundingBox<T>& worldBox
         , const DtMatrix4<T>& view_projection_matrix
         , const Vector2_uint32& viewPortSize
         , bool clip = true);
   };


   template <class T>
   class Frustum
   {
   public:
      Frustum();

      virtual ~Frustum();

      template <class RHS>
      Frustum(const Frustum<RHS>& rhs);

      template <class RHS>
      Frustum& operator=(const Frustum<RHS>& rhs);
   public:
      virtual void setPlane(FrustumPlane plane, T d, const DtVector3<T>& vNormal);

      virtual const DtPlane<T>& plane(FrustumPlane plane) const;

      virtual DtVector4<T> planeAsVector(FrustumPlane plane) const;

      virtual bool isVisible(const DtAxisAlignedBoundingBox<T>& box) const;

      virtual bool isSphereVisible(const DtVector3<T>& center, T radius) const;

      virtual bool isSphereVisibleRadiusSquared(const DtVector3<T>& center, double radiusSquared) const;

      virtual VisibilityFromCamera visibility(const DtAxisAlignedBoundingBox<T>& box, bool ignoreNearFar = false) const;

      virtual void setFromModelViewProjectionMatrix(const DtMatrix4<T>& modelViewMat, const DtMatrix4<T>& projMat);

      virtual void setFromModelViewProjectionMatrix(const DtMatrix4<T>& mvp);

      virtual void frustumPlanes(std::array<DtVector4<T>, 6>& planes) const;

      virtual bool operator==(const Frustum<T>& rhs) const;

      virtual bool operator!=(const Frustum<T>& rhs) const;

   protected:

      void computePlaneFromPoints(DtPlane<T>& plane, const DtVector3<T>& point0,
         const DtVector3<T>& point1, const DtVector3<T>& point2) const;

   protected:
      std::array< DtPlane<T>, 6 > myFrustumPlanes;
   };

} //namespace makVrv

#include "DtCamera.inl"