gre/3dtextur.h

Go to the documentation of this file.

/*** 
 * \file gre/3dtextur.h
 * \brief Base class for texturing algorithm
 *
 * \if NODOC
 * $Id: 3dtextur.h_v 1.31 2012/06/07 21:01:31 mju Exp $
 *
 * $Log: 3dtextur.h_v $
 * Revision 1.31  2012/06/07 21:01:31  mju
 * Use const in drawBoundaryWall.
 *
 * Revision 1.30  2011/10/20 12:41:43  mju
 * Remove redundant hdr.
 *
 * Revision 1.29  2006/09/14 19:44:06  mju
 * Include region2d hdr.
 *
 * Revision 1.23  2004/09/20 17:37:00  vdronov
 * added fence drawing
 *
 * Revision 1.21  2004/08/12 22:17:23  vdronov
 * added SetPedestalcoordRef
 *
 * Revision 1.20  2004/08/12 19:39:10  vdronov
 * added ClearPedestal
 *
 * Revision 1.15  2004/06/17 17:26:47  vdronov
 * added formula texture class
 *
 * Revision 1.1  2003/03/10 15:08:04  vdronov
 * Initial revision
 * \endif
**/ 

#ifndef  INC_GRE_3DTEXTUR_H
#define  INC_GRE_3DTEXTUR_H

#ifndef  INC_GRE_3DUTILS_H
#include <gre/3dutils.h>
#endif

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

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

#ifndef  INC_MI32_MGD2_H
#include <mi32/mgd2.h>
#endif

namespace GRE {

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

class TEXTURE {
   public:

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

#define  DECLARE_TEXTURE_IMPL_FACTORY(name,model)                    \
   class TEXTURE_IMPL_FACTORY_##name : public GRE::TEXTURE::IMPL_FACTORY { \
      public:                                               \
      TEXTURE_IMPL_FACTORY_##name (                            \
      ) { GRE::TEXTURE::Register(this,model); }                   \
      virtual GRE::TEXTURE *v_ConstructImpl () {                     \
      return (new GRE::name);                                  \
         }                                               \
      };                                                 \
   static TEXTURE_IMPL_FACTORY_##name s_TextureImplFactory_##name;

      enum MODEL {
         MODEL_Default = 0,
         MODEL_SimpleRaster = 0,
         MODEL_Formula = 1,
         MODEL_Count = 2
         };

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

      static const char* GetName (
         MODEL model
         );

      static const char* GetDescription (
         MODEL model
         );

      static TEXTURE* GetInstance (
         MODEL model
         );

      virtual ~TEXTURE (                        
         );

      const char* GetName (
         ) const;

      const char* GetDescription (
         ) const;

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

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

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

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

      bool IsBuilt (
         );

      void Begin (
         const SCENE3D& scene
         ) { v_Begin(scene); return; };

      void End (
         ) { v_End(); return; };

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

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

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

      bool GetColor (
         const INT32 line,
         const INT32 column,
         const UINT8 depth,
         COLOR& color 
         ) { return v_GetColor(line, column, depth, color); };

      bool GetColor (
         const DPOINT2D& point,
         const UINT8 depth,
         COLOR& color 
         ) { return v_GetColor(point, depth, color); };

      UINT8 CheckDepth (
         const UINT8 depth
         ) { return v_CheckDepth(depth); };

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

      ERRVALUE SetBoundaryWall (
         const SCENE3D& scene,
         TERRAIN* terrain
         );

      ERRVALUE DrawBoundaryWall (
         CONTROLLER &controller,        
         DRAWINGCONTEXT3D& drawing,
         const GRE::BOUNDPARM& boundparm
         );

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


      void ClearPedestal (
         ) { 
         m_PolyLineList.Clear();
         return;
         };


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

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

   protected:

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

      void SetBuilt (
         const bool built
         );

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT

      typedef SIMPLE_ARRAY<INT32> BASEINDEX;
      typedef MILIST<BASEINDEX> BASEINDEXLIST;

      static IMPL_FACTORY* s_ImplFactories[MODEL_Count];

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

      bool m_Built;                             

      REGION2D m_Boundary;

      REGION2D m_FinalBoundary;
      POLYLINELIST m_PolyLineList;
      BASEINDEXLIST m_BaseIndexList;
      SPATREF::COORDREFSYS m_PolyLineCoordRefSys;
      TRIANGULATION m_Triangulation;
      SCENE3D *m_Scene;

      TEXTURE (   
         );

      TEXTURE (                                 
         const TEXTURE &rhs
         );

      TEXTURE& operator= (                      
         const TEXTURE& rhs
         );

      #endif // GENERATING_DOXYGEN_OUTPUT

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

      virtual TEXTURE* v_CreateInstance (
         ) = 0;

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

      virtual void v_Free (
         ) = 0;

      virtual void v_Begin (
         const SCENE3D& scene
         ) = 0;

      virtual void v_End (
         ) = 0;

      virtual const DRECT2D& v_GetExtents (
         ) = 0;

      virtual void v_CreateBoundary (
         REGION2D& boundary
         ) = 0;

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

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

      virtual bool v_GetColor (
         const INT32 line,
         const INT32 column,
         const UINT8 depth,
         COLOR& color 
         ) = 0;

      virtual bool v_GetColor (
         const DPOINT2D& point,
         const UINT8 depth,
         COLOR& color 
         ) = 0;

      virtual UINT8 v_CheckDepth (
         const UINT8 depth
         ) = 0;

      virtual const TRANS2D_MAPGEN& v_GetTransformationInternalToModel (
         ) = 0;

   };

}     // End of GRE namespace

#endif

---