3dscene.h

Go to the documentation of this file.

/**
 * \file 3dscene.h <gre/3dscene.h>
 * \brief class for scene algorithms
 *
 * \if NODOC
 * $Id: 3dscene.h_v 1.18 2004/08/11 23:01:41 vdronov Exp $
 *
 * $Log: 3dscene.h_v $
 * Revision 1.18  2004/08/11 23:01:41  vdronov
 * *** empty log message ***
 *
 * Revision 1.17  2004/07/23 22:57:53  vdronov
 * *** empty log message ***
 *
 * Revision 1.16  2004/07/20 20:57:40  vdronov
 * *** empty log message ***
 *
 * Revision 1.15  2004/07/19 21:00:57  vdronov
 * *** empty log message ***
 *
 * Revision 1.14  2004/06/02 22:25:02  vdronov
 * *** empty log message ***
 *
 * Revision 1.13  2004/06/01 23:47:38  vdronov
 * *** empty log message ***
 *
 * Revision 1.12  2004/02/13 17:02:54  vdronov
 * fixed warnings
 *
 * Revision 1.11  2003/09/23 13:10:00  mju
 * Fix compiler warnings.
 *
 * Revision 1.10  2003/09/15 13:48:59  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.9  2003/08/15 22:10:52  vdronov
 * add docs
 *
 * Revision 1.8  2003/07/30 13:57:26  mju
 * Check inclusion guards.
 * Ignore private section.
 *
 * Revision 1.7  2003/04/07 20:41:50  vdronov
 * parallel projection
 *
 * Revision 1.6  2003/03/20 23:14:22  vdronov
 * new trans
 *
 * Revision 1.5  2003/03/13 15:57:46  vdronov
 * added const for GetFrustum
 *
 * Revision 1.4  2003/03/13 15:50:40  vdronov
 * added GetFrustum
 *
 * Revision 1.3  2003/03/12 20:26:53  vdronov
 * changed transformation
 *
 * Revision 1.2  2003/03/11 21:58:10  vdronov
 * used ScreenRect instead of w, h
 *
 * Revision 1.1  2003/03/10 15:06:32  vdronov
 * Initial revision
 * \endif
**/ 

#ifndef  INC_GRE_3DSCENE_H
#define  INC_GRE_3DSCENE_H

#ifndef  INC_MI32_POINT_H
#include <mi32/point.h>
#endif

#ifndef  INC_MI32_MXSTEREO_H
#include <mi32/mxstereo.h>
#endif

#ifndef  INC_MI32_RECT_H
#include <mi32/rect.h>
#endif

#ifndef  INC_MI32_TRANS3D_H
#include <mi32/trans3d.h>
#endif

#ifndef  INC_MI32_DOUBLEAR_H
#include <mi32/doublear.h>
#endif

namespace GRE {

//! SCENE3D class describes view scene and all transformation beetween
//! model and world and view and unit cube and screne
//!
//! All angles are in degrees;
//! All distances are in meters;
//! All points are in orthogonal coordinate system
class SCENE3D {
   public:

      SCENE3D (                                 //! Constructor 
         const float FieldOfViewAngle = 45
         );

      ~SCENE3D (                                //! Destructor 
         );

      SCENE3D& operator= (
         const SCENE3D& rhs
         );


      //! Calculate scene parameters for given screen rectangle
      //! 
      //! @return true if calculation is completed
      bool CalculateParameters (
         const DRECT2D& screenrect
         );

      //! Clear scene parameters
      void Clear (
         );

      //! Clear Model to World transformation to identity transformation
      void ClearModelToWorld ();

   //! Clip segment with endpoints pts and pte with frustum. If segment intersects frustum than
      //! pts and pte contains endpoints of intersection in return.
      //!
      //! @return true if segment intersects frustum 
      bool ClipSegment (
         FPOINT3D &pts,
         FPOINT3D &pte
         );

      //! Get azimuth angle in degrees
      //! 
      //! @return azimuth angle
      float GetAzimuth (
         ) const;

      //! Get view direction
      //! 
      //! @return view direction
      const FPOINT3D& GetDirection (
         ) const;

      //! Get elevation in meters
      //! 
      //! @return elevation in meters
      float GetElevation (
         ) const {return m_Elevation;};

      //! Retrieve base elevation.
      float GetBaseElevation (
         ) const;

      //! Get field of view angle in degrees
      //! 
      //! @return field of view angle in degrees
      float GetFieldOfViewAngle (
         ) const;

      //! Get frustum   as DRECT3D
      //! 
      //! @return frustum sa DRECT3D
      const DRECT3D& GetFrustum (
         ) const;

      //! Get look at point
      //! 
      //! @return look at point
      const FPOINT3D& GetLookAt (
         ) const;

      //! Get parallel projection distance
      //! 
      //! @return parallel projection distance
      float GetParallelProjectionDistance (
         ) const;

      //! Get roll angle in degrees
      //! 
      //! @return roll angle
      float GetRoll (
         ) const;

      //! Get screen rectangle
      //! 
      //! @return screen rectangle
      const DRECT2D& GetScreenRect (
         ) const;

      float GetSunAzimuthAngle (
         ) const;

      float GetSunElevationAngle (
         ) const;

      //! Get viewer point
      //! 
      //! @return viewer point
      FPOINT3D GetViewer (
         ) const;

      //! Get up direction
      //! 
      //! @return up direction
      const FPOINT3D& GetUp (
         ) const;

      //! Are scene parameters calculated
      //! 
      //! @return true if scene parameters are calculated
      bool IsCalculated (
         ) const;

      //! Is projection perspective
      //! 
      //! @return true if projecton is perspective
      bool IsPerspective (
         ) const;

      //! Is given rectangle overlapped with scene frustum
      //! 
      //! @return true if rectangle is overlapped
      bool IsRectangleOverlapped (
         const DRECT3D& rect
         ) const;

      //! Is segment with given endpoints overlapped with scene frustum
      //! 
      //! @return true if segement is overlapped
      bool IsSegmentOverlapped (
         const FPOINT3D &pts,
         const FPOINT3D &pte
         ) const;

      //! Is sphere with given center and given radius overlapped with scene frustum
      //! 
      //! @return true if sphere is overlapped
      bool IsSphereOverlapped (
         const FPOINT3D &center,
         const float radiussquared = 0.0f
         ) const;

      //! Is stereo set
      //! 
      //! @return true if stereo is set
      bool IsStereo (
         ) const;

      //! Is triangle with given vertices overlapped with scene frustum
      //! 
      //! @return true if triangle is overlapped
      bool IsTriangleOverlapped (
         const FPOINT3D &pt1,
         const FPOINT3D &pt2,
         const FPOINT3D &pt3
         ) const;

      //! Set azimuth angle in degrees
      void SetAzimuth (
         const float azimuth,
         const bool recalculate = true
         );

      //! Set elevation angle in degrees
      void SetElevation (
         const float elevation
         );

      //! Set base elevation  in meters
      void SetBaseElevation (
         const float BaseElevation
         );

      //! Set clipping extents for scene
      void SetExtents (
         DOUBLE_ARRAY<DRECT3D>& extents
         );

      //! Set field of view angle in degrees
      void SetFieldOfViewAngle (
         const float FieldOfViewAngle
         );

      //! Set frustum   as DRECT2D
      void SetFrustum (
         const DRECT2D& frustum
         );

      //! Set look at point
      void SetLookAt (
         const FPOINT3D& lookAt
         );

      //! Get Model to World transformation
      void SetModelToWorld (const TRANS3D& ModelToWorld);

      //! Get near and far planes
      void SetNearFarPlanes (
         const double nearplane,
         const double farplane,
         const bool use = false
         );

      //! Set parallel projection distance
      void SetParallelProjectionDistance (
         const float distance
         );

      //! Set perspective projection on or off
      void SetPerspective (
         const bool isPerspective
         );

      //! Set roll angle in degrees
      void SetRoll (
         const float roll,
         const bool recalculate = true
         );

      void SetSunAzimuthAngle (
         const float SunAzimuthAngle
         );

      void SetSunElevationAngle (
         const float SunElevationAngle
         );

      //! Set stereo  on or off
      void SetStereo (
         const bool isStereo
         );

      void SetStereoDistance (
         const double distance
         );

      void SetStereoMode (
         const STEREOMODE mode
         );

      void SetOpticalSeparation (
         const double optical
         );

      void SetMonitorSeparation (
         const double monitor
         );

      void SetStereoScale (
         const double scale
         );

      void SetStereoView (
         const STEREOVIEW view
         );

      //! Set viewer point
      void SetViewer (
         const FPOINT3D& viewer
         );

      //! Update azimuth angle in degrees
      void UpdateAzimuth (
         const float update
         );

      //! Update elevation in meters
      void UpdateElevation (
         const float update
         );

      //! Update roll angle in degrees
      void UpdateRoll (
         const float update
         );

      //! Move viewer point along view direction
      void ViewerMoveAlongDirection (
         const float distance
         );

      //! Update viewer point z coordinate
      void ViewerUpdateZ (
         const float distance
         );

      //! Get Model to World transformation
      //! 
      //! @return Model to World transformation
      const TRANS3D& GetModelToWorld () const     { return m_Parameters[m_Index].m_ModelToWorld;       };

      //! Get Model to View transformation
      //! 
      //! @return Model to View transformation
      const TRANS3D& GetModelToView () const      { return m_Parameters[m_Index].m_ModelToView;     };

      //! Get Model to UnitCube transformation
      //! 
      //! @return Model to UnitCube transformation
      const TRANS3D& GetModelToUnitCube () const  { return m_Parameters[m_Index].m_ModelToUnitCube;  };

      //! Get Model to Screen transformation
      //! 
      //! @return Model to Screen transformation
      const TRANS3D& GetModelToScreen () const    { return m_Parameters[m_Index].m_ModelToScreen;   };

      //! Get World to View transformation
      //! 
      //! @return World to View transformation
      const TRANS3D& GetWorldToView () const      { return m_Parameters[m_Index].m_WorldToView;     };

      //! Get World to UnitCube transformation
      //! 
      //! @return World to UnitCube transformation
      const TRANS3D& GetWorldToUnitCube () const  { return m_Parameters[m_Index].m_WorldToUnitCube;  };

      //! Get World to Screen transformation
      //! 
      //! @return World to Screen transformation
      const TRANS3D& GetWorldToScreen () const    { return m_Parameters[m_Index].m_WorldToScreen;   };

      //! Get View to UnitCube transformation
      //! 
      //! @return View to UnitCube transformation
      const TRANS3D& GetViewToUnitCube () const   { return m_Parameters[m_Index].m_ViewToUnitCube;   };

      //! Get View to Screen transformation
      //! 
      //! @return View to Screen transformation
      const TRANS3D& GetViewToScreen () const     { return m_Parameters[m_Index].m_ViewToScreen;     };

      //! Get UnitCube to Screen transformation
      //! 
      //! @return UnitCube to Screen transformation
      const TRANS3D& GetUnitCubeToScreen () const { return m_Parameters[m_Index].m_UnitCubeToScreen; };


   private:

      enum INDEX {
         INDEX_Left = 0,
         INDEX_Center = 1,
         INDEX_Right = 2,
         INDEX_Count = 3
         };

      #ifndef GENERATING_DOXYGEN_OUTPUT

      class PARAMETERS {

         public:

         #define NUMPLANES 4
         typedef FPOINT3D FRUSTUMVECTORS[NUMPLANES];
         typedef FLOAT FRUSTUMSCALARS[NUMPLANES];

         FPOINT3D m_Viewer;
         FPOINT3D m_LookAt;

         TRANS3D m_ModelToWorld;              
         TRANS3D m_ModelToView;               
         TRANS3D m_ModelToUnitCube;              
         TRANS3D m_ModelToScreen;                
         TRANS3D m_WorldToView;               
         TRANS3D m_WorldToUnitCube;              
         TRANS3D m_WorldToScreen;                 
         TRANS3D m_ViewToUnitCube;
         TRANS3D m_ViewToScreen;
         TRANS3D m_UnitCubeToScreen;

         DRECT2D m_ScreenRect;                  //!< Destination or screen rectangle

         DRECT3D m_Frustum;                     //!< 6 parameters 
                                          //! (xinit = left, xlast = right, 
                                          //! yinit = bottom, ylast = top, 
                                          //! zinit = near, zlast = far) specify frustum in meters 

         FRUSTUMVECTORS m_Normals;              //!<  Bounding Planes {p[i].normal.x * x + p[i].normal.y * y + p[i].normal.z * z + p[i].D = 0}
         FRUSTUMSCALARS m_D;                    //!< { right, bottom, left, top}
         FRUSTUMVECTORS m_Lines;                //!< Bounding Line Vectors {right-bottom,bottom-left,left-top,top-right}
         FRUSTUMVECTORS m_Corners;

         PARAMETERS ();
         PARAMETERS& operator= (const PARAMETERS& rhs);
         };

      static const UINT8 s_OutCodes[NUMPLANES];

      bool m_Calculated;

      float m_FieldOfViewAngle;

      FPOINT3D m_Dir;
      FPOINT3D m_Up;

      float m_Azimuth;
      float m_Elevation;
      float m_Roll;

      float m_Distance;

      float m_BaseElevation;
      float m_SunAzimuthAngle;            
      float m_SunElevationAngle;                

      bool m_IsPerspective;
      float m_ParallelProjectionDistance;

      float m_NearPlane;
      float m_FarPlane;
      bool m_UseNearFarPlanes;

      bool m_IsStereo;
      float m_StereoDistance;
      float m_StereoScale;
      STEREOMODE m_StereoMode;
      STEREOVIEW m_StereoView;
      float m_OpticalSeparation;
      float m_MonitorSeparation;

      DRECT2D m_ScreenRect;                  //!< Destination or screen rectangle

      DOUBLE_ARRAY<DRECT3D> m_Extents;       //!< Extents of all terrains for this scene

      INDEX m_Index;
      PARAMETERS m_Parameters[INDEX_Count];


      UINT8 AssignCodes (const FPOINT3D &pt) const;

      void CalculateAngles ();

      bool CalculateCenterParameters ();

      void CalculateDependantTransformations ();

      void CalculateFrustum ();

      void CalculateFrustumParameters (const INDEX index);

      void CalculateLookAt ();

      float CalculateSquaredDistanceToLine (const FPOINT3D &pt, const int index) const;

      float CalculateSquaredDistanceToPlane (const FPOINT3D &pt, const int index) const;

      bool CalculateStereoParameters ();

      void CalculateUnitCubeToScreen (const INDEX index);

      bool CalculateViewToUnitCube (const INDEX index);

      void CalculateWorldToView (INDEX index);

      void CalculateZRange (double& zmin, double& zmax);

      #endif //!< GENERATING_DOXYGEN_OUTPUT
   };


};    //! End of namespace

#endif

---