3drayter.h

Go to the documentation of this file.

/**
 * \file 3drayter.h <gre/3drayter.h>
 * \brief 
 *
 * \if NODOC
 * $Id: 3drayter.h_v 1.10 2004/09/03 16:55:48 vdronov Exp $
 *
 * $Log: 3drayter.h_v $
 * Revision 1.10  2004/09/03 16:55:48  vdronov
 * *** empty log message ***
 *
 * Revision 1.9  2004/08/11 23:01:11  vdronov
 * *** empty log message ***
 *
 * Revision 1.8  2004/07/30 19:07:59  vdronov
 * *** empty log message ***
 *
 * Revision 1.7  2004/06/29 13:45:53  vdronov
 * *** empty log message ***
 *
 * Revision 1.6  2003/09/15 13:48:59  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.5  2003/08/19 17:24:24  vdronov
 * fixed screenrect problem
 *
 * Revision 1.4  2003/08/15 16:01:51  vdronov
 * nc
 *
 * Revision 1.3  2003/07/30 13:53:26  mju
 * Check inclusion guards.
 * Ignore private section.
 *
 * Revision 1.1  2003/05/05 20:03:19  vdronov
 * Initial revision
 * \endif
**/ 

#ifndef  INC_GRE_3DRAYTER_H
#define  INC_GRE_3DRAYTER_H

#ifndef  INC_GRE_3DTERRA_H
#include <gre/3dterra.h>
#endif

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

#ifndef  INC_MI32_ASURFACE_H
#include <mi32/asurface.h>
#endif

#ifndef  INC_MI32_SIMPLEAR_H
#include <mi32/simplear.h>
#endif

#ifndef  INC_RVC_OBJECT_H
#include <rvc/object.h>
#endif

#ifndef  INC_RVC_GEOREFER_H
#include <rvc/georefer.h>
#endif

namespace GRE {

//! Ray casting terrain model.
class RAYCASTING : public TERRAIN {
   public:

      RAYCASTING (                           //! Constructor 
         );

      ~RAYCASTING (                       //! Destructor 
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      struct ORDER {
         INT32 index;
         float distance;
         };

      struct INTERSECTION {
         const DOUBLE_ARRAY<double>& m_Buffer;
         const INT32 m_NumCells;
         const DPOINT3D m_Min;
         const DPOINT3D m_Max;
         const bool m_HasNullValue;
         const double m_NullValue;
         const DPOINT3D& m_Viewer;
         const DPOINT3D& m_Direction;
         const bool m_IsPerspective;

         POLYLINE m_Polyline;

         INTERSECTION (
            const DOUBLE_ARRAY<double>& buffer,
            const INT32 numCells,
            const DPOINT3D min,
            const DPOINT3D max,
            const bool hasNullValue,
            const double nullValue,
            const DPOINT3D& viewer,
            const DPOINT3D& direction,
            const bool isPerspective
            ) :
            m_Buffer(buffer),
            m_NumCells(numCells),
            m_Min(min),
            m_Max(max),
            m_HasNullValue(hasNullValue),
            m_NullValue(nullValue),
            m_Viewer(viewer),
            m_Direction(direction),
            m_IsPerspective(isPerspective)
            {
            };

         };

      #define  NUMPIXELS      4096

      #define  NUMCORNERS     8
      #define  NUMSEGMENTS    12

      static const INT32 s_Segments[NUMSEGMENTS][2];

      ABSTRACT_SURFACE *m_Surface;
      DRECT3D m_Extents;
      SPATREF::COORDREFSYS m_CoordRefSys;
      TRANS2D_MAPGEN m_Transformation;

      RVC::RASTER m_Raster;
      DOUBLE_ARRAY<double> m_Buffer;

      INT32 m_XBlocks;
      INT32 m_YBlocks;
      INT32 m_BlockSize;
      BITSET m_BlockBits;  
      DOUBLE_ARRAY<DRECT3D> m_Blocks;
      INT32 m_Index;
      bool m_BlockIsLoaded;

      SIMPLE_ARRAY<ORDER> m_Orders;

      BITSET m_ScreenBits;
      INT32 m_ScreenWidth;
      INT32 m_ScreenHeight;
      INT32 m_ScreenX;
      INT32 m_ScreenY;

      SIMPLE_ARRAY<DPOINT3D> m_Points;
      SIMPLE_ARRAY<LPOINT2D> m_Pixels;

      PIXALIZATION m_Pixalization;
      SCENE3D *m_Scene;
      CONTROLLER *m_Controller;
      DRAWINGCONTEXT3D *m_Drawing;

      DPOINT3D m_Viewer;
      DPOINT3D m_Direction;

      double m_ZMin;
      double m_ZMax;
      bool m_HasNullValue;
      double m_NullValue;

      RAYCASTING& operator= (             //! Assignment operator (not implemented)
         const RAYCASTING& rhs
         );

      static int OrderSort (
         ORDER* item1,
         ORDER* item2,
         void*
         ) { if (item1->distance < item2->distance) return 1; return 0; };

      static void GetCorners (
         const DRECT3D& rect,
         DPOINT3DH points[8]
         );

      static void GetCorners (
         const DRECT3D& rect,
         DPOINT3D points[8]
         );

      static double CalculateElevation (
         INTERSECTION& intersection,
         const DPOINT3D& pt,
         const int type
         );

      static bool GetIntersection (
         INTERSECTION& intersection,
         const DPOINT3D& lookAt,
         DPOINT3D& result
         );

      static void GetTriangle (
         INTERSECTION& intersection,
         const DPOINT3D& point,
         DPOINT3D points[3]
         );

      TERRAIN* v_CreateInstance (
         ) { return new RAYCASTING(); };

      ERRVALUE v_Build (
         const GRE_LAYER *layer
         );

      bool v_IsObjectTypeSupported (
         const RVC::OBJTYPE objtype
         ) const { return (objtype == RVC::OBJTYPE_Raster); };

      void v_Free (
         );

      ERRVALUE Create (              
         const GRE_LAYER *layer
         );

      void Delete (               
         );

      ERRVALUE v_GetDefaultScene ( 
         SCENE3D& scene
         ) const;

      ERRVALUE v_SetScene (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<TEXTURE*> &textures   
         );

      ERRVALUE v_DrawScene (
         CONTROLLER &controller,        
         DRAWINGCONTEXT3D& drawing,
         TEXTURE* texture,
         TEXTUREFILTER* texturefilter
         );

      float v_GetElevation (
         const float x,
         const float y
         ) const;

      ERRVALUE v_ComputeProfile (
         const POLYLINE& polyline,
         POLYLINE& profile,
         SIMPLE_ARRAY<INT32>& index
         );

      float v_GetAngleToNorth (
         const float x,
         const float y
         ) const;

      const ABSTRACT_SURFACE* v_GetAbstractSurface (
         ) { return m_Surface; }

      void v_SetCoordRefSys (
         const SPATREF::COORDREFSYS& CoordRefSys
         );

      const SPATREF::COORDREFSYS v_GetCoordRefSys (
         ) const { return m_CoordRefSys; };

      const DRECT3D& v_GetExtents (
         ) { return m_Extents; };

      void v_CreateBoundary (
         REGION2D& boundary
         );

      bool v_HasNull (
         ) const { return m_HasNullValue; };

      bool v_IsNull (
         const float x,
         const float y
         ) const;

      ERRVALUE CreateBlocks (
         const TRANS2D_MAPGEN& transformation
         );

      void DeleteBlocks (
         );
      ERRVALUE SetSceneForBlocks (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<TEXTURE*> &textures   
         );

      ERRVALUE DrawSceneForBlocks (
         CONTROLLER &controller,        
         DRAWINGCONTEXT3D& drawing,
         TEXTURE* texture,
         TEXTUREFILTER* texturefilter
         );

      void TransformBlocks (
         const TRANS2D_MAPGEN& transformation
         );

      void FillSpan (
         const INT32 col1,
         const INT32 col2,
         const INT32 lin
         );

      void DrawPixels (
         );

      #endif //!< GENERATING_DOXYGEN_OUTPUT
   };

};    //! End of namespace

#endif

---