viewpoint3d.h

Go to the documentation of this file.

/**
 * \file viewpoint3d.h <gre/viewpoint3d.h>
 * \brief GRE VIEWPOINT3D class
 *
 * \if NODOC
 * $Id: viewpoint3d.h_v 1.5 2003/10/31 23:02:27 vdronov Exp $
 *
 * $Log: viewpoint3d.h_v $
 * Revision 1.5  2003/10/31 23:02:27  vdronov
 * removed rollangle
 *
 * Revision 1.4  2003/10/31 15:32:11  vdronov
 * removed roll angle variable
 *
 * Revision 1.3  2003/09/15 13:48:59  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.2  2003/07/30 15:49:21  mju
 * Ignore private sections.
 *
 * Revision 1.1  2003/06/24 16:50:05  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_GRE_VIEWPOINT3D_H
#define  INC_GRE_VIEWPOINT3D_H

#ifndef  INC_GRE_BASE_H
   #include <gre/base.h>
#endif

#ifndef  INC_GRE_3DSCENE_H
   #include <gre/3dscene.h>
#endif

#ifndef  INC_MI32_SERIALIZ_H
   #include <mi32/serializ.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
struct SMLCONTEXT;
#endif //!< GENERATING_DOXYGEN_OUTPUT

//===================================================================================================================

class GRE_VIEWPOINT3D {
   public:

      static ERRVALUE SerializerCB (
         SERIALIZER& serializer,
         const SERIALIZER::ITEMDEF *item,
         void *pvvp,
         SERIALIZER::ITEMDEF::ACTION action
         );

      //! Install SML class, called by internal SML function.
      static void SMLClassInstall (
         SMLCONTEXT *context
         );

      //! Constructor.
      explicit GRE_VIEWPOINT3D (
         GRE_GROUP *group,
         GRE_VIEW *view = 0
         );

      //! Copy constructor.
      GRE_VIEWPOINT3D (
         const GRE_VIEWPOINT3D& rhs
         );

      //! Destructor.
      ~GRE_VIEWPOINT3D (
         );

      //! Assignment.
      GRE_VIEWPOINT3D& operator= (
         const GRE_VIEWPOINT3D& rhs
         );

      bool Calculate (
         );

      void CalculateAutoCenter (
         );

      void CalculateCenterPoint (
         );

      void CalculateCenterFromViewPoint (
         );

      void CalculateParameters (
         );

      void CalculatePoint (
         const bool center                      //!< if center is true - calculate center point, othewise - viewpoint
         );

      void CalculateTransVD (
         MAT3X3,
         MAT3X3
         );

      void CalculateViewDirFromAzimAngle (
         double angle
         );

      void CalculateTransVRCToWorld (
         TRANS3D&
         );

      void CalculateUsedRect (
         const DRECT2D&,
         const DPOINT2D&
         );

      void CalculateUsedRect (
         double aspect                          //!< Width/Height aspect
         );

      //! Get distance to center of view in auto-center mode.
      double GetAutoCenterDistance (
         ) const;

      //! Retrieve background clipping distance.
      double GetBackClipDistance (
         ) const;

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

      //! Retrieve center point.
      const DPOINT3D& GetCenterPoint (
         ) const;

      //! Retrieve destination rectangle.
      const DRECT2D& GetDestRect (
         ) const;

      //! Get foreground clipping distance.
      double GetFrontClipDistance (
         ) const;

      //! Get group associated with viewpoint.
      GRE_GROUP* GetGroup (
         ) const;

      //! Get heading relative to north or projection.
      double GetHeading (
         bool FromNorth = true
         ) const;

      double GetParallelProjDistance (
         ) const;

      //! Get pitch angle for current viewpoint.
      double GetPitch (
         ) const;

      //! Get roll angle for current viewpoint.
//    double GetRoll (
//       ) const;

      double GetStereoDepthScale (
         ) const;

      double GetStereoDistance0 (
         ) const;

      double GetSunAzimuthAngle (
         );

      double GetSunElevationAngle (
         );

      GRE_VIEW* GetView (
         ) const;

      double GetViewAngle (
         ) const;

      const DPOINT3D& GetViewDirection (
         ) const;

      double GetViewPlaneDistance (
         ) const;

      const DPOINT3D& GetViewPosition (
         ) const;

      const DRECT2D& GetViewRectUsed (
         ) const;

      GRE::SCENE3D& GetScene3D (
         );

      const GRE::SCENE3D& GetScene3D (
         ) const;

      const DPOINT3D& GetViewUp (
         ) const;

      const double GetZScale (
         ) const;

      void IniRead (
         INIHANDLE handle,
         const char *inigroup
         );

      void IniWrite (
         INIHANDLE handle,
         const char *inigroup
         );

      bool IsAutoCentered (
         ) const;

      bool IsCalculated (
         ) const;

      bool IsClipBackPlane (
         ) const;

      bool IsPerspective (
         ) const;

      bool IsStereo (
         ) const;

      void SetAutoCenter (
         bool AutoCenter
         );

      void SetAutoCenterAzimAngle (
         double AzimAngle
         );

      void SetAutoCenterDistance (
         double Distance
         );

      void SetAutoCenterElevAngle (
         double ElevAngle
         );

      void SetAutoCenterPoint (
         const DPOINT2D& point
         );

      void SetAutoCenterPoint (
         const DPOINT3D& point
         );

      void SetBackClipDistance (
         double BackClipDist
         );

      void SetBaseElevation (
         double BaseElevation
         );

      void SetClipBackPlane (
         bool ClipBackPlane
         );

      void SetDestRect (
         const DRECT2D& DestRect
         );

      void SetFrontClipDistance (
         double FrontClipDist
         );

      void SetHeading (
         double Heading,
         bool FromNorth = true
         );

      void SetParallelProjDistance (
         double ParallelProjDist
         );

      void SetPerspective (
         bool isPerspective = true
         );

      void SetPitch (
         double Pitch
         );

//    void SetRoll (
//       double RollAngle
//       );

      void SetStereo (
         bool isStereo
         );

      void SetStereoDepthScale (
         double StereoDepthScale
         );

      void SetStereoDistance0 (
         double StereoDistance0
         );

      void SetSunAzimuthAngle (
         double SunAzimAngle
         );

      void SetSunElevationAngle (
         double SunElevAngle
         );

      void SetViewDirection (
         const DPOINT3D& ViewDir
         );

      void SetViewPosition (
         const DPOINT2D& ViewPos
         );

      void SetViewPosition (
         const DPOINT3D& ViewPos
         );

      void SetViewPositionZ (
         double z
         );

      void SetViewRectUsed (
         const DRECT2D& ViewRectUsed
         );

      void SetViewPlaneDistance (
         double ViewPlaneDistance
         );

      void SetViewUp (
         const DPOINT3D& ViewUp
         );

      void SetZScale (
         double ZScale
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      GRE_GROUP *m_group;                 //!< Group this viewpoint refers to
      GRE_VIEW *m_view;                   //!< View this viewpoint refers to, may be 0
      DPOINT3D m_ViewPos;                 //!< Viewer position in specified map coordinates
      DPOINT3D m_ViewDir;                 //!< Direction of view in map coordinates (normalized)
      DPOINT3D m_ViewUp;                  //!< View-Up vector in map coordinates (normalized)
      DRECT2D m_ViewRectUsed;             //!< Rectangle on view plane for visible area (viewing reference coordinates)
      double m_ViewPlaneDist;             //!< Distance to view plane in meters
      double m_FrontClipDist;             //!< Front clipping distance (from view plane, usually 0.0)
      double m_BackClipDist;              //!< Back clipping distance
      double m_ParallelProjDist;          //!< Effective distance for parallel projection
      double m_StereoDistance0;           //!< Stereo zero-parallax distance
      double m_StereoDepthScale;          //!< Stereo depth scaling
      DPOINT3D m_CenterPoint;             //!< Point at center of view in map coordinates
      double m_AzimAngle;                 //!< Azimuth angle
      double m_ElevAngle;                 //!< Elevation angle
//    double m_RollAngle;                 //!< Roll angle
      double m_AutoCenterDist;            //!< Distance from center point in meters
      double m_ZScale;                    //!< Overall Z-Scale
      double m_BaseElevation;             //!< Base elevation
      DRECT2D m_DestRect;                 //!< Destination rectangle to project into
//!      GRE_VIEWTRANS3D m_Trans[2];         // Transformations for left(center)/right views
      bool m_IsPerspective;
      bool m_ClipBackPlane;
      bool m_IsStereo;
      bool m_AutoCenter;
      bool m_CenterSet;
      UINT32 m_oldflags;                     //!< Old "flag" bits, used in serialization only
      double m_SunAzimAngle;                 //!< Sun azimuth angle
      double m_SunElevAngle;                 //!< Sun elevation angle

      GRE::SCENE3D m_Scene3D;

      static ERRVALUE SerializerCB_OldFlags (
         SERIALIZER& serializer,
         const SERIALIZER::ITEMDEF *item,
         void *vgroup,
         SERIALIZER::ITEMDEF::ACTION action
         );

      void CalcCVPtoD ();
      const TRANS3D& GetNormTrans (
         int vindex = 0
         ) const;
      void CalcNormTrans ();

      #endif //!< GENERATING_DOXYGEN_OUTPUT
   };


//===================================================================================================================

#endif   //!< INC_GRE_VIEWPOINT3D_H

---