Edit

kc3-lang/ftgl/include/FTVectoriser.h

Branch :

  • Show log

    Commit

  • Author : sammy
    Date : 2008-04-12 22:44:48
    Hash : 141112c4
    Message : * Add licensing information to all files in the library.

  • include/FTVectoriser.h
  • /*
     * FTGL - OpenGL font library
     *
     * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
     *
     * Permission is hereby granted, free of charge, to any person obtaining
     * a copy of this software and associated documentation files (the
     * "Software"), to deal in the Software without restriction, including
     * without limitation the rights to use, copy, modify, merge, publish,
     * distribute, sublicense, and/or sell copies of the Software, and to
     * permit persons to whom the Software is furnished to do so, subject to
     * the following conditions:
     * 
     * The above copyright notice and this permission notice shall be
     * included in all copies or substantial portions of the Software.
     * 
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
     * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     *
     * Alternatively, you can redistribute and/or modify this software under
     * the terms of the GNU Lesser General Public License as published by
     * the Free Software Foundation; either version 2.1 of the License,
     * or (at your option) any later version.
     *
     * You should have received a copy of the GNU Lesser General Public
     * License along with this software; if not, write to the Free Software
     * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA.
     */
    
    #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();
            
            /**
             * Add a point to the mesh
             */
            void AddPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z);
            
            /**
             *  Create a combine point for the gluTesselator
             */
            const FTGL_DOUBLE* Combine( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z);
            
            /**
             * Begin a new polygon
             */
            void Begin( GLenum meshType);
            
            /**
             * End a polygon
             */
            void End();
            
            /**
             * Record a gluTesselation error
             */
            void Error( GLenum e) { err = e;}
            
            /**
             * The number of tesselations in the mesh
             */
            unsigned int TesselationCount() const { return tesselationList.size();}
    
            /**
             * Get a tesselation by index
             */
            const FTTesselation* const Tesselation( unsigned int index) const;
            
            /**
             * Return the temporary point list. For testing only.
             */
            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__