kc3-lang/ftgl/include/FTVectoriser.h

Branch : - branch - master - tag -

• Show log

  Commit

• Author : henry
  Date : 2004-04-09 03:51:36
  Hash : 325066d2
  Message : Added symbol for front and rear facing

• include/FTVectoriser.h

• #ifndef     __FTVectoriser__
  #define     __FTVectoriser__
  
  
  #include "FTContour.h"
  #include "FTList.h"
  #include "FTPoint.h"
  #include "FTVector.h"
  #include "FTGL.h"
  
  
  #ifndef CALLBACK
  #define CALLBACK
  #endif
  
  
  /**
   * FTTesselation captures points that are output by OpenGL's gluTesselator.
   */
  class FTGL_EXPORT FTTesselation
  {
      public:
          /**
           * Default constructor
           */
          FTTesselation( GLenum m)
          :	meshType(m)
          {
              pointList.reserve( 128);
          }
  
          /**
           *  Destructor
           */
          ~FTTesselation()
          {
              pointList.clear();
          }
  
          /**
           * Add a point to the mesh.
           */
          void AddPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z)
          {   
              pointList.push_back( FTPoint( x, y, z));
          }
  
          /**
           * The number of points in this mesh
           */
          size_t PointCount() const { return pointList.size();}
          
          /**
           *
           */
          const FTPoint& Point( unsigned int index) const { return pointList[index];}
          
          /**
           * Return the OpenGL polygon type.
           */
          GLenum PolygonType() const { return meshType;}
          
      private:
          /**
           * Points generated by gluTesselator.
           */
          typedef FTVector<FTPoint> PointVector;
          PointVector pointList;
  
          /**
           * OpenGL primitive type from gluTesselator.
           */
          GLenum meshType;
  };
  
  
  /**
   * FTMesh is a container of FTTesselation's that make up a polygon glyph
   */
  class FTGL_EXPORT FTMesh
  {
  	typedef FTVector<FTTesselation*> TesselationVector;
  	typedef FTList<FTPoint> PointList;
  
      public:
          /**
           * Default constructor
           */
          FTMesh();
  
          /**
           *  Destructor
           */
          ~FTMesh();
          
          /**
           *
           */
          void AddPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z);
          
          /**
           *
           */
          FTGL_DOUBLE* Combine( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z);
          
          /**
           *
           */
          void Begin( GLenum meshType);
          
          /**
           *
           */
          void End();
          
          /**
           *
           */
          void Error( GLenum e) { err = e;}
          
          /**
           *
           */
          unsigned int TesselationCount() const { return tesselationList.size();}
  
          /**
           *
           */
          const FTTesselation* const Tesselation( unsigned int index) const;
          
          /**
           *
           */
          const PointList& TempPointList() const { return tempPointList;}
  
          /**
           * Get the GL ERROR returned by the glu tesselator
           */
          GLenum Error() const { return err;}
  
      private:
          /**
           * The current sub mesh that we are constructing.
           */
          FTTesselation* currentTesselation;
          
          /**
           * Holds each sub mesh that comprises this glyph.
           */
          TesselationVector tesselationList;
          
          /**
           * Holds extra points created by gluTesselator. See ftglCombine.
           */
          PointList tempPointList;
          
          /**
           * GL ERROR returned by the glu tesselator
           */
          GLenum err;
  
  };
  
  const FTGL_DOUBLE FTGL_FRONT_FACING = 1.0;
  const FTGL_DOUBLE FTGL_BACK_FACING = -1.0;
  
  /**
   * FTVectoriser class is a helper class that converts font outlines into
   * point data.
   *
   * @see FTExtrdGlyph
   * @see FTOutlineGlyph
   * @see FTPolyGlyph
   * @see FTContour
   * @see FTPoint
   *
   */
  class FTGL_EXPORT FTVectoriser
  {
      public:
          /**
           * Constructor
           *
           * @param glyph The freetype glyph to be processed
           */
          FTVectoriser( const FT_GlyphSlot glyph);
  
          /**
           *  Destructor
           */
          virtual ~FTVectoriser();
  
          /**
           * Build an FTMesh from the vector outline data. 
           *
           * @param zNormal   The direction of the z axis of the normal
           *                  for this mesh
           */
          void MakeMesh( FTGL_DOUBLE zNormal = FTGL_FRONT_FACING);
          
          /**
           * Get the current mesh.
           */
          const FTMesh* const GetMesh() const { return mesh;}
          
          /**
           * Get the total count of points in this outline
           *
           * @return the number of points
           */
          size_t PointCount();
  
          /**
           * Get the count of contours in this outline
           *
           * @return the number of contours
           */
          size_t ContourCount() const { return ftContourCount;}
  
          /**
           * Return a contour at index
           *
           * @return the number of contours
           */
           const FTContour* const Contour( unsigned int index) const;
  
          /**
           * Get the number of points in a specific contour in this outline
           *
           * @param c     The contour index
           * @return      the number of points in contour[c]
           */
          size_t ContourSize( int c) const { return contourList[c]->PointCount();}
  
          /**
           * Get the flag for the tesselation rule for this outline
           *
           * @return The contour flag
           */
          int ContourFlag() const { return contourFlag;}
          
      private:
          /**
           * Process the freetype outline data into contours of points
           */
          void ProcessContours();
  
          /**
           * The list of contours in the glyph
           */
          FTContour** contourList;
  
          /**
           * A Mesh for tesselations
           */
          FTMesh* mesh;
          
          /**
           * The number of contours reported by Freetype
           */
          short ftContourCount;
  
          /**
           * A flag indicating the tesselation rule for the glyph
           */
          int contourFlag;
  
          /**
           * A Freetype outline
           */
          FT_Outline outline;
  };
  
  
  #endif  //  __FTVectoriser__