gre/3dscene.h

Go to the documentation of this file.

#ifndef  INC_GRE_3DSCENE_H
#define  INC_GRE_3DSCENE_H

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

#ifndef  INC_MI32_STEREOVIEW_H
#include <mi32/stereoview.h>
#endif

#ifndef  INC_MI32_STEREODEVICE_H
#include <mi32/stereodevice.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 {

class SCENE3D {
   public:

      SCENE3D (
         const float FieldOfViewAngle = 45
         );

      ~SCENE3D ();

      SCENE3D& operator= (
         const SCENE3D& rhs
         );

      bool CalculateParameters (
         const DRECT2D& screenrect
         );

      void Clear (
         );

      void ClearModelToWorld ();

      bool ClipSegment (
         FPOINT3D &pts,
         FPOINT3D &pte
         );

      float GetAzimuth (
         ) const;

      const FPOINT3D& GetDirection (
         ) const;

      float GetElevation (
         ) const {return m_Elevation;};

      float GetBaseElevation (
         ) const;

      float GetFieldOfViewAngle (
         ) const;

      const DRECT3D& GetFrustum (
         ) const;

      const FPOINT3D& GetLookAt (
         ) const;

      float GetParallelProjectionDistance (
         ) const;

      double GetPixelSizeInMeters (
         ) const;

      float GetRoll (
         ) const;

      const DRECT2D& GetScreenRect (
         ) const;

      STEREOVIEW GetStereoView (
         ) const { return (m_StereoView); }

      float GetSunAzimuthAngle (
         ) const;

      float GetSunElevationAngle (
         ) const;

      FPOINT3D GetViewer (
         ) const;

      const FPOINT3D& GetUp (
         ) const;

      bool IsCalculated (
         ) const;

      bool IsPerspective (
         ) const;

      bool IsRectangleOverlapped (
         const DRECT3D& rect
         ) const;

      bool IsSegmentOverlapped (
         const FPOINT3D &pts,
         const FPOINT3D &pte
         ) const;

      bool IsSphereOverlapped (
         const FPOINT3D &center,
         const float radiussquared = 0.0f
         ) const;

      bool IsStereo (
         ) const;

      bool IsTriangleOverlapped (
         const FPOINT3D &pt1,
         const FPOINT3D &pt2,
         const FPOINT3D &pt3
         ) const;

      void SetAzimuth (
         const float azimuth,
         const bool recalculate = true
         );

      void SetElevation (
         const float elevation
         );

      void SetBaseElevation (
         const float BaseElevation
         );

      void SetExtents (
         DOUBLE_ARRAY<DRECT3D>& extents
         );

      void SetFieldOfViewAngle (
         const float FieldOfViewAngle
         );

      void SetFrustum (
         const DRECT2D& frustum
         );

      void SetLookAt (
         const FPOINT3D& lookAt
         );

      void SetModelToWorld (const TRANS3D& ModelToWorld);

      void SetMonitorSeparation (
         const double monitor
         );

      void SetNearFarPlanes (
         const double nearplane,
         const double farplane,
         const bool use = false
         );

      void SetOpticalSeparation (
         const double optical
         );

      void SetParallelProjectionDistance (
         const float distance
         );

      void SetPerspective (
         const bool isPerspective
         );

      void SetRoll (
         const float roll,
         const bool recalculate = true
         );

      void SetSunAzimuthAngle (
         const float SunAzimuthAngle
         );

      void SetSunElevationAngle (
         const float SunElevationAngle
         );

      void SetStereo (
         const bool isStereo
         );

      void SetStereoDistance (
         const double distance
         );

      void SetStereoMode (
         const STEREODEVICE::METHOD mode
         );

      void SetStereoScale (
         const double scale
         );

      void SetStereoView (
         const STEREOVIEW stereoview
         );

      void SetViewer (
         const FPOINT3D& viewer
         );

      void UpdateAzimuth (
         const float update
         );

      void UpdateElevation (
         const float update
         );

      void UpdateRoll (
         const float update
         );

      void ViewerMoveAlongDirection (
         const float distance
         );

      void ViewerUpdateZ (
         const float distance
         );

      const TRANS3D& GetModelToWorld () const     { return m_Parameters[m_Index].m_ModelToWorld;       };

      const TRANS3D& GetModelToView () const      { return m_Parameters[m_Index].m_ModelToView;     };

      const TRANS3D& GetModelToUnitCube () const  { return m_Parameters[m_Index].m_ModelToUnitCube;  };

      const TRANS3D& GetModelToScreen () const    { return m_Parameters[m_Index].m_ModelToScreen;   };

      const TRANS3D& GetWorldToView () const      { return m_Parameters[m_Index].m_WorldToView;     };

      const TRANS3D& GetWorldToUnitCube () const  { return m_Parameters[m_Index].m_WorldToUnitCube;  };

      const TRANS3D& GetWorldToScreen () const    { return m_Parameters[m_Index].m_WorldToScreen;   };

      const TRANS3D& GetViewToUnitCube () const   { return m_Parameters[m_Index].m_ViewToUnitCube;   };

      const TRANS3D& GetViewToScreen () const     { return m_Parameters[m_Index].m_ViewToScreen;     };

      const TRANS3D& GetUnitCubeToScreen () const { return m_Parameters[m_Index].m_UnitCubeToScreen; };

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

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

      class PARAMETERS {

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

            FPOINT3D m_Viewer;
            FPOINT3D m_LookAt;
            TRANS3D ALIGN16(m_ModelToWorld);              
            TRANS3D ALIGN16(m_ModelToView);               
            TRANS3D ALIGN16(m_ModelToUnitCube);              
            TRANS3D ALIGN16(m_ModelToScreen);                
            TRANS3D ALIGN16(m_WorldToView);               
            TRANS3D ALIGN16(m_WorldToUnitCube);              
            TRANS3D ALIGN16(m_WorldToScreen);                 
            TRANS3D ALIGN16(m_ViewToUnitCube);
            TRANS3D ALIGN16(m_ViewToScreen);
            TRANS3D ALIGN16(m_UnitCubeToScreen);
            DRECT2D ALIGN16(m_ScreenRect);         // Destination or screen rectangle
            DRECT3D ALIGN16(m_Frustum);            // (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;
      STEREODEVICE::METHOD m_StereoMode;
      STEREOVIEW m_StereoView;
      float m_OpticalSeparation;
      float m_MonitorSeparation;
      DRECT2D ALIGN16(m_ScreenRect);            
      DOUBLE_ARRAY<DRECT3D> m_Extents;       
      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 
   };


};    

#endif

---