gre/3dutils.h

Go to the documentation of this file.

/*** 
 * \file 3dutils.h <gre/3dutils.h>
 * \brief supporting structures
 *
 * \if NODOC
 * $Id: 3dutils.h_v 1.23 2012/01/26 15:34:27 mju Exp $
 *
 * $Log: 3dutils.h_v $
 * Revision 1.23  2012/01/26 15:34:27  mju
 * Remove log2i fn as now global.
 *
 * Revision 1.22  2011/10/06 15:21:42  mju
 * Remove dependencies.
 *
 * Revision 1.17  2005/07/22 21:50:00  vdronov
 * added bitmap pattern rendering
 *
 * Revision 1.16  2005/06/27 17:13:58  vdronov
 * added nullmask handling
 *
 * Revision 1.5  2003/04/22 19:52:02  vdronov
 * added pixalization
 *
 * Revision 1.2  2003/04/08 17:50:23  vdronov
 * changed triangulation structure
 *
 * Revision 1.1  2003/03/10 15:08:51  vdronov
 * Initial revision
 * \endif
 */ 

#ifndef  INC_GRE_3DUTILS_H
#define  INC_GRE_3DUTILS_H

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

#ifndef  INC_MI32_BITSET_H
   #include <mi32/bitset.h>
#endif

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

#ifndef  INC_MI32_DOUBLEAR_H
   #include <mi32/doublear.h>
#endif

#ifndef  INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif

#ifndef _VECTOR_
   #include <vector>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
class REGION2D;
namespace RVC {
   class RASTER;
   class STYLEPATTERN_BITMAP;
   }
namespace GRE {
   class TERRAIN;
   class TEXTURE;
   class TEXTUREFILTER;
   }
#endif // GENERATING_DOXYGEN_OUTPUT


namespace GRE {

enum DRAW3DMODE {
   DRAW3DMODE_Texture = 0,
   DRAW3DMODE_Color = 1,
   DRAW3DMODE_Wireframe = 2,
   DRAW3DMODE_PointsField = 3,
   DRAW3DMODE_Bitmap = 4
   };

enum TRIANGLEMODE {
   TRIANGLEMODE_List = 0,
   TRIANGLEMODE_Fan = 1,
   TRIANGLEMODE_Strip = 2,
   TRIANGLEMODE_TIN = 3
   };

struct TRIANGLEINDEX {
   INT32 vertex1;
   INT32 vertex2;
   INT32 vertex3;

   TRIANGLEINDEX () : vertex1(0), vertex2(0), vertex3(0) {};
   TRIANGLEINDEX (INT32 v1, INT32 v2, INT32 v3) : vertex1(v1), vertex2(v2), vertex3(v3) {};
   };

struct EDGEINDEX {
   INT32 vertexfrom;
   INT32 vertexto;
   EDGEINDEX () : vertexfrom(0), vertexto(0) {};
   EDGEINDEX (INT32 vf, INT32 vt) : vertexfrom(vf), vertexto(vt) {};
   };

struct INDEX {
   INT32 index;
   INDEX () : index(0) {};
   INDEX (INT32 i) : index(i) {};
   };

struct TRIANGULATION {
   TRIANGLEMODE m_Mode;
   SIMPLE_ARRAY<FPOINT3D> m_Vertices;
   SIMPLE_ARRAY<INDEX> m_Indices;
   SIMPLE_ARRAY<EDGEINDEX> m_Edges;                // used in TRIANGLEMODE_TIN
   SIMPLE_ARRAY<TRIANGLEINDEX> m_Triangles;        // used in TRIANGLEMODE_TIN
   BITSET m_EdgesBits;                             // used in TRIANGLEMODE_TIN
   BITSET m_TrianglesBits;                         // used in TRIANGLEMODE_TIN
   DRAW3DMODE m_Draw3DMode;
   TERRAIN *m_Terrain;
   TEXTURE *m_Texture;
   TEXTUREFILTER *m_TextureFilter;
   COLOR m_Color;

   TRIANGULATION (
      ) :
      m_Mode(TRIANGLEMODE_List),
      m_Draw3DMode(DRAW3DMODE_Texture),
      m_Terrain(0),
      m_Texture(0),
      m_TextureFilter(0)
      { }

   ~TRIANGULATION (
      ) {
      }
   };

typedef std::vector<const TRIANGULATION*> TRIANGULATIONVECTOR; 

struct PIXALIZATION {

   SIMPLE_ARRAY<LPOINT2D> m_Pixels;
   DOUBLE_ARRAY<DPOINT3D> m_Points;
   DOUBLE_ARRAY<DPOINT3D> m_Points0;
   DOUBLE_ARRAY<DPOINT3D> m_Points1;
   DOUBLE_ARRAY<DPOINT3D> m_Points2;
   DRAW3DMODE m_Draw3DMode;
   TERRAIN *m_Terrain;
   TEXTURE *m_Texture;
   TEXTUREFILTER *m_TextureFilter;
   COLOR m_Color;
   RVC::STYLEPATTERN_BITMAP* m_BitmapPattern;

   PIXALIZATION (
      ) :
      m_Draw3DMode(DRAW3DMODE_Texture),
      m_Terrain(0),
      m_Texture(0),
      m_TextureFilter(0)
      { }

   ~PIXALIZATION (
      ) {
      }

   };

typedef std::vector<const PIXALIZATION*> PIXALIZATIONVECTOR; 

class SCREENPLANE {
   public:

      SCREENPLANE (                                
         ) : 
         m_IsSet(false),
         m_DX(0.0), 
         m_DY(0.0), 
         m_DW(1.0) 
         { }

      ~SCREENPLANE (                               
         ) { }

      void Clear (
         ) { m_IsSet = false; return;};

      bool IsSet (
         ) const { return m_IsSet; };

      void Set (
         const DPOINT3DH& pt1, 
         const DPOINT3DH& pt2, 
         const DPOINT3DH& pt3
         );

      bool GetPoint (
         const INT32 line,
         const INT32 column,
         DPOINT3DH& point
         );

      bool GetCellExtents (
         const INT32 line,
         const INT32 column,
         DPOINT3DH hpoints[4]
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      double ALIGN8(m_DX); 
      double ALIGN8(m_DY); 
      double ALIGN8(m_DW); 
      double ALIGN8(m_DL);
      double ALIGN8(m_DXZ);
      double ALIGN8(m_DYZ);
      double ALIGN8(m_DWZ);
      bool m_IsSet;

      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class UTILS3D {
   public:

      enum CELLTRACE {
         CELLTRACE_Edge,
         CELLTRACE_Center
         };

      static ERRVALUE CreateBoundaryRegionFromRaster (
         SIMPLE_ARRAY<RVC::RASTER*>& rasters,
         RVC::RASTER& mask,
         REGION2D& region,
         const CELLTRACE celltrace
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      UTILS3D ();
      ~UTILS3D ();

      #endif // GENERATING_DOXYGEN_OUTPUT
   };


}     // End namespace GRE

#endif

---