gre/3dterra.h

Go to the documentation of this file.

/*** 
 * \file 3dterra.h <gre/3dterra.h>
 * \brief Base class for terrain algorithm
 *
 * \if NODOC
 * $Id: 3dterra.h_v 1.35 2011/10/20 12:34:34 mju Exp $
 *
 * $Log: 3dterra.h_v $
 * Revision 1.35  2011/10/20 12:34:34  mju
 * Remove redundant hdr.
 *
 * Revision 1.34  2011/10/06 15:21:14  mju
 * Remove dependencies and unused abstract surface methods.
 *
 * Revision 1.33  2011/10/05 21:52:59  mju
 * Use region2d hdr.
 *
 * Revision 1.30  2005/06/13 16:13:08  vdronov
 * removed sparse triangulation and dense raycasting
 *
 * Revision 1.19  2004/06/15 15:42:52  vdronov
 * added flat triangulation
 *
 * Revision 1.17  2003/12/22 17:37:25  vdronov
 * Added PiecewiseTIN model
 *
 * Revision 1.15  2003/08/26 15:34:35  vdronov
 * added VariableTriangulation
 *
 * Revision 1.10  2003/05/28 19:31:18  vdronov
 * added dense ray casting
 *
 * Revision 1.7  2003/04/14 17:31:04  vdronov
 * added GetModel
 *
 * Revision 1.6  2003/04/09 19:12:43  vdronov
 * terrain null value
 *
 * Revision 1.1  2003/03/10 15:07:45  vdronov
 * Initial revision
 * \endif
**/ 

#ifndef  INC_GRE_3DTERRA_H
#define  INC_GRE_3DTERRA_H

#ifndef  INC_GRE_3DDC_H
#include <gre/3ddc.h>
#endif

#ifndef  INC_GRE_3DPNTFLD_H
#include <gre/3dpntfld.h>
#endif

#ifndef  INC_MI32_REGION2D_H
#include <mi32/region2d.h>
#endif

#ifndef  INC_RVC_OBJTYPE_H
#include <rvc/objtype.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
namespace GRE {
   class TEXTUREFILTER;
   class TEXTURE;
   class GEOMETRIC3D;
   class CONTROLLER;
   }
#endif


namespace GRE {

class TERRAIN {
   public:

      enum MODEL {
         MODEL_Default = 0,
         MODEL_TIN = 0,
         MODEL_VariableTriangulation = 1,
         MODEL_PiecewiseTIN = 2,
         MODEL_FlatTriangulation = 3,
         MODEL_Count = 4
         };

      class IMPL_FACTORY {
         public:
            virtual TERRAIN *v_ConstructImpl () = 0;
         };

      static void Register (
         IMPL_FACTORY* factory,
         const MODEL model
         );

      static const char* GetName (
         const MODEL model
         );

      static const char* GetDescription (
         const MODEL model
         );

      static TERRAIN* GetInstance (
         const MODEL model
         );

      virtual ~TERRAIN (                                 
         );

      const char* GetName (
         ) const { return m_Name; }

      const char* GetDescription (
         ) const {return m_Description; }

      const MODEL GetModel (
         ) const {return m_Model; }

      TERRAIN* CreateInstance () { return v_CreateInstance(); }

      ERRVALUE Build (
         const GRE::LAYER *layer
         ) { return v_Build(layer); }

      bool IsBuilt (
         ) const { return m_Built; }

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

      void Free () {v_Free(); }

      ERRVALUE GetDefaultScene ( 
         SCENE3D& scene
         ) { return v_GetDefaultScene(scene); }

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

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

      ERRVALUE SetScene (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<GEOMETRIC3D*> &geometrics,
         const bool wireframe
         ) { return v_SetScene(scene, geometrics, wireframe); }

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

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


      float GetElevation (
         const float x,
         const float y
         ) {return v_GetElevation(x,y); }

      float GetAngleToNorth (
         const float x,
         const float y
         ) const { return v_GetAngleToNorth(x, y); }

      bool HasNull (
         ) const { return v_HasNull(); }


      bool IsNull (
         const float x,
         const float y
         ) const { return v_IsNull(x,y); }

      void SetCoordRefSys (
         const SPATREF::COORDREFSYS& CoordRefSys
         ) { v_SetCoordRefSys(CoordRefSys); }

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

      void ClearBoundary (
         ) { 
         m_Boundary.Clear();
         };

      const REGION2D& GetBoundary (
         ) { 
         if (m_Boundary.IsEmpty()) v_CreateBoundary(m_Boundary); 
         return m_Boundary;
         };

      bool IsBoundaryChanged (
         ) const { 
         return m_Boundary.IsEmpty();
         };

      bool IsTerrainDynamic (
         ) const { 
         return false;
         };

      POINTSFIELD& GetPointsField (
         ) { 
         return m_PointsField;
         };

   protected:

      TERRAIN (                                 
         const char* name,
         const char* desc,
         const MODEL model
         );

      void SetBuilt (
         const bool built
         ) { m_Built = built; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      static IMPL_FACTORY* s_ImplFactories[MODEL_Count];

      const char* m_Name;
      const char* m_Description;
      const MODEL m_Model;
      bool m_Built;                                
      GRE::POINTSFIELD m_PointsField;
      REGION2D m_Boundary;

      TERRAIN ();

      // Unimplemented
      TERRAIN (const TERRAIN &rhs);
      TERRAIN& operator= (const TERRAIN& rhs);

      #endif // GENERATING_DOXYGEN_OUTPUT

      virtual TERRAIN* v_CreateInstance (
         ) = 0;

      virtual ERRVALUE v_Build (
         const GRE::LAYER *layer
         ) = 0;

      virtual bool v_IsObjectTypeSupported (
         const RVC::OBJTYPE objtype
         ) const = 0;

      virtual void v_Free (
         ) = 0;

      virtual ERRVALUE v_GetDefaultScene ( 
         SCENE3D& scene
         ) const = 0;

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

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

      virtual ERRVALUE v_SetScene (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<GEOMETRIC3D*> &geometrics,
         const bool wireframe
         ) = 0;

      virtual const DRECT3D& v_GetExtents (
         ) = 0;

      virtual void v_CreateBoundary (
         REGION2D& boundary
         ) = 0;

      virtual float v_GetElevation (
         const float x,
         const float y
         ) const = 0;

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

      virtual float v_GetAngleToNorth (
         const float x,
         const float y
         ) const = 0;

      virtual bool v_HasNull (
         ) const  = 0;

      virtual bool v_IsNull (
         const float x,
         const float y
         ) const  = 0;

      virtual void v_SetCoordRefSys (
         const SPATREF::COORDREFSYS& CoordRefSys
         ) = 0;

      virtual const SPATREF::COORDREFSYS v_GetCoordRefSys (
         ) const = 0;
   };


class CONTROLLER {
   public:

      void OnBegin () { v_OnBegin(); }

      void OnEnd () { v_OnEnd(); }

      void OnTriangulation (  
         DRAWINGCONTEXT3D& drawing,
         const TRIANGULATION& triangulation
         ) { v_OnTriangulation(drawing, triangulation); }

      void OnPixalization (   
         DRAWINGCONTEXT3D& drawing,
         const PIXALIZATION& pixalization
         ) { v_OnPixalization(drawing, pixalization); }

   protected:

      CONTROLLER () {}

      virtual ~CONTROLLER () {}

   private:

      virtual void v_OnBegin () = 0;

      virtual void v_OnEnd (  
         ) { }

      virtual void v_OnTriangulation (    
         DRAWINGCONTEXT3D& drawing,
         const TRIANGULATION& triangulation
         ) = 0;

      virtual void v_OnPixalization (  
         DRAWINGCONTEXT3D& drawing,
         const PIXALIZATION& pixalization
         ) = 0;

   };


class SIMPLECONTROLLER : public GRE::CONTROLLER {
   public:
      virtual ~SIMPLECONTROLLER () {}

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      GRE::TRIANGULATIONVECTOR m_Triangulations;
      GRE::PIXALIZATIONVECTOR m_Pixalizations;

      void v_OnBegin ();

      void v_OnEnd ();

      void v_OnTriangulation (   
         DRAWINGCONTEXT3D& drawing,
         const GRE::TRIANGULATION& triangulation
         );

      void v_OnPixalization (    
         DRAWINGCONTEXT3D& drawing,
         const GRE::PIXALIZATION& pixalization
         );

      #endif // GENERATING_DOXYGEN_OUTPUT
   };


}     // End of namespace

#endif

---