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.17 2005/07/22 21:50:00 vdronov Exp $
 *
 * $Log: 3dutils.h_v $
 * 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.15  2005/04/08 19:09:41  vdronov
 * *** empty log message ***
 *
 * Revision 1.14  2005/03/11 00:27:05  vdronov
 * *** empty log message ***
 *
 * Revision 1.13  2005/02/17 17:56:53  vdronov
 * *** empty log message ***
 *
 * Revision 1.12  2004/12/01 18:12:01  vdronov
 * ALIGN
 *
 * Revision 1.11  2004/08/11 23:04:31  vdronov
 * *** empty log message ***
 *
 * Revision 1.10  2004/07/30 22:01:50  vdronov
 * added DRAW3DMODE
 *
 * Revision 1.9  2003/09/15 13:48:59  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.8  2003/08/15 20:01:58  vdronov
 * add docs.
 *
 * Revision 1.7  2003/07/30 14:42:18  mju
 * Check inclusion guards.
 * Ignore private sections.
 *
 * 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_MI32_ASURFACE_H
#include <mi32/asurface.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_RVC_NULLMASK_H
#include <rvc/nullmask.h>
#endif

#ifndef  INC_RVC_STYLE_H
#include <rvc/style.h>
#endif

#ifndef _VECTOR_
#include <vector>
#endif

namespace GRE {

#ifndef GENERATING_DOXYGEN_OUTPUT
class TERRAIN;
class TEXTURE;
class TEXTUREFILTER;
#endif //!< GENERATING_DOXYGEN_OUTPUT

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::STYLE::BITMAPPATTERN *m_BitmapPattern;

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

   ~PIXALIZATION (
      ) {
      };

   };

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

//! SCREENPLANE class describes plane in screen space in homogenius coordinates.
class SCREENPLANE {

public:

   SCREENPLANE (                                //! Constructor 
      ) : 
      m_IsSet(false),
      m_DX(0.0), 
      m_DY(0.0), 
      m_DW(1.0) 
      {};

   ~SCREENPLANE (                               //! Destructor 
      ) {};

   //! Clear plane parameters
   void Clear (
      ) { m_IsSet = false; return;};

   //! Is plane set
   //! 
   //! @return true if plane is set
   bool IsSet (
      ) const { return m_IsSet; };

   //! Set plane by three points in homogenius coordinates.
   void Set (
      const DPOINT3DH& pt1, 
      const DPOINT3DH& pt2, 
      const DPOINT3DH& pt3
      );

   //! Get point on screen plane that projected to screen at center of screen pixel with coordinates (column, line)
   //! 
   //! @return true if point exists
   bool GetPoint (
      const INT32 line,
      const INT32 column,
      DPOINT3DH& point
      );

   //! Get extents on screen plane that projected to screen at screen pixel with coordinates (column, line)
   //! 
   //! @return true if extents exist
   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
   };


//! UTILS3D class contains supportive static methods
class UTILS3D {
   public:

      enum CELLTRACE {
         CELLTRACE_Edge,
         CELLTRACE_Center
         };


      static UINT8 log2i (
         const UINT32 value,
         const bool up = true
         );

      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 of namespace

#endif

---