gre/3dgeomet.h

Go to the documentation of this file.

/*** 
 * \file gre/3dgeomet.h
 * \brief Base class for geometric algorithm
 *
 * \if NODOC
 * $Id: 3dgeomet.h_v 1.10 2011/10/10 13:37:30 mju Exp $
 *
 * $Log: 3dgeomet.h_v $
 * Revision 1.10  2011/10/10 13:37:30  mju
 * Remove unneeded hdrs.
 *
 * Revision 1.9  2007/06/14 23:00:27  vdronov
 * *** empty log message ***
 *
 * Revision 1.1  2005/02/01 17:25:31  vdronov
 * Initial revision
 * \endif
**/ 

#ifndef  INC_GRE_3DGEOMET_H
#define  INC_GRE_3DGEOMET_H

#ifndef  INC_GRE_3DGMELEM_H
#include <gre/3dgmelem.h>
#endif

namespace GRE {

#ifndef GENERATING_DOXYGEN_OUTPUT
class CONTROLLER;
class TERRAIN;
class DRAWINGCONTEXT3D;
#endif // GENERATING_DOXYGEN_OUTPUT


class GEOMETRIC3D {
   public:

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


      enum MODEL {
         MODEL_Default = 0,
         MODEL_Vector = 0,
         MODEL_CAD = 1,
         MODEL_Shape = 2,
         MODEL_Pinmap = 3,
         MODEL_TIN = 4,
         MODEL_Count = 5
         };

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

      static const char* GetName (
         MODEL model
         );

      static const char* GetDescription (
         MODEL model
         );

      static GEOMETRIC3D* GetInstance (
         MODEL model
         );

      virtual ~GEOMETRIC3D (                       
         );

      const char* GetName (
         ) const;

      const char* GetDescription (
         ) const;

      const MODEL GetModel (
         ) const {return m_Model; };

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

      virtual bool IsTerrainNeeded (
         );

      virtual bool IsPointsFieldNeeded (
         );

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

      void Free (
         ) { v_Free(); return; };

      bool IsBuilt (
         );

      void SetScene (
         SCENE3D& scene
         ) { 
         m_Scene = &scene; 
         m_Viewer = DPOINT3D(m_Scene->GetViewer().x, m_Scene->GetViewer().y, m_Scene->GetViewer().z);
         m_Direction = DPOINT3D(m_Scene->GetDirection().x, m_Scene->GetDirection().y, m_Scene->GetDirection().z);
         return; 
         };

      ERRVALUE DrawScene (
         CONTROLLER &controller,        
         DRAWINGCONTEXT3D& drawing,
         TERRAIN *terrain,
         const bool wireframe = false
         );

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

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

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


      const TRANS2D_MAPGEN& GetTransformationInternalToModel (
         ) { return v_GetTransformationInternalToModel(); };

   protected:

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

      void SetBuilt (
         const bool built
         );

      void AppendElements (
         GEOMETRIC3D_ELEMENTS *elements
         ) { m_ElementsArray.Append(elements); return; };

      void ClearElements (
         );

      double ComputeScaleForPoint (
         const DPOINT2D& point
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class BUILDER_IMPL : public GEOMETRIC3D_BUILDER {
         public :

            BUILDER_IMPL (
               const GEOMETRIC3D& geometric
               ) : m_Geometric(geometric) {};

            ~BUILDER_IMPL (
               ) {};

         private:

            const GEOMETRIC3D& m_Geometric;

            BUILDER_IMPL (
               );

            void OnConstruction (
               GRE::TRIANGULATION& triangulation
               );

            void OnConstruction (
               GRE::PIXALIZATION& pixalization
               );

            friend class GEOMETRIC3D;
         };

      static IMPL_FACTORY *s_ImplFactories[MODEL_Count];

      const char *m_Name;
      const char *m_Description;
      const MODEL m_Model;
      BUILDER_IMPL m_Builder;

      bool m_Built;                             

      SCENE3D *m_Scene;
      DPOINT3D m_Viewer;
      DPOINT3D m_Direction;
      CONTROLLER *m_Controller;
      DRAWINGCONTEXT3D *m_Drawing;
      TERRAIN *m_Terrain;

      GEOMETRIC3D_ELEMENTS_ARRAY m_ElementsArray;

      GEOMETRIC3D (  
         );

      GEOMETRIC3D (                                
         const GEOMETRIC3D &rhs
         );

      GEOMETRIC3D& operator= (                        
         const GEOMETRIC3D& rhs
         );

      #endif // GENERATING_DOXYGEN_OUTPUT

      virtual GEOMETRIC3D* v_CreateInstance (
         ) = 0;

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

      virtual void v_Free (
         ) = 0;

      virtual const DRECT3D& v_GetExtents (
         ) = 0;

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

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

      virtual const TRANS2D_MAPGEN& v_GetTransformationInternalToModel (
         ) = 0;

      virtual void OnDrawBegin (GRE::GEOMETRIC3D_BUILDER *builder, const bool wireframe = false);

      virtual void OnDrawEnd ();

   };

}     // End of GRE namespace

#endif

---