FTVectoriser.h

Go to the documentation of this file.

#ifndef     __FTVectoriser__
#define     __FTVectoriser__


#include "FTContour.h"
#include "FTList.h"
#include "FTPoint.h"
#include "FTVector.h"
#include "FTGL.h"


#ifndef CALLBACK
#define CALLBACK
#endif


class FTGL_EXPORT FTTesselation
{
    public:
        FTTesselation( GLenum m)
        :   meshType(m)
        {
            pointList.reserve( 128);
        }

        ~FTTesselation()
        {
            pointList.clear();
        }

        void AddPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z)
        {   
            pointList.push_back( FTPoint( x, y, z));
        }

        size_t PointCount() const { return pointList.size();}
        
        const FTPoint& Point( unsigned int index) const { return pointList[index];}
        
        GLenum PolygonType() const { return meshType;}
        
    private:
        typedef FTVector<FTPoint> PointVector;
        PointVector pointList;

        GLenum meshType;
};


class FTGL_EXPORT FTMesh
{
    typedef FTVector<FTTesselation*> TesselationVector;
    typedef FTList<FTPoint> PointList;

    public:
        FTMesh();

        ~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;}

        GLenum Error() const { return err;}

    private:
        FTTesselation* currentTesselation;
        
        TesselationVector tesselationList;
        
        PointList tempPointList;
        
        GLenum err;

};

const FTGL_DOUBLE FTGL_FRONT_FACING = 1.0;
const FTGL_DOUBLE FTGL_BACK_FACING = -1.0;

class FTGL_EXPORT FTVectoriser
{
    public:
        FTVectoriser( const FT_GlyphSlot glyph);

        virtual ~FTVectoriser();

        void MakeMesh( FTGL_DOUBLE zNormal = FTGL_FRONT_FACING);
        
        const FTMesh* const GetMesh() const { return mesh;}
        
        size_t PointCount();

        size_t ContourCount() const { return ftContourCount;}

         const FTContour* const Contour( unsigned int index) const;

        size_t ContourSize( int c) const { return contourList[c]->PointCount();}

        int ContourFlag() const { return contourFlag;}
        
    private:
        void ProcessContours();

        FTContour** contourList;

        FTMesh* mesh;
        
        short ftContourCount;

        int contourFlag;

        FT_Outline outline;
};


#endif  //  __FTVectoriser__

---