OpenSceneGraph/include/osgText/Font

//C++ header - Open Scene Graph - Copyright (C) 1998-2001 Robert Osfield
//Distributed under the terms of the GNU Library General Public License (LGPL)
//as published by the Free Software Foundation.

/* --------------------------------------------------------------------------
 *
 *    openscenegraph textLib / FTGL wrapper
 *
 * --------------------------------------------------------------------------
 *    
 *    prog:    max rheiner;mrn@paus.ch
 *    date:    4/25/2001    (m/d/y)
 *
 * --------------------------------------------------------------------------
 *
 * --------------------------------------------------------------------------
 */


#ifndef OSGTEXT_FONT
#define OSGTEXT_FONT 1 

#include <osg/Object>
#include <osg/State>

#include <osgText/Export>

#include <string>

// http://homepages.paradise.net.nz/henryj/code/

class FTFont;

namespace osgText {

/** META_Font macro define the standard clone, isSameKindAs,
  * className and getType methods.
  * Use when subclassing from Object to make it more convinient to define 
  * the standard pure virtual methods which are required for all Object 
  * subclasses.*/
#define META_Font(name) \
        virtual osg::Object* cloneType() const { return new name(); } \
        virtual osg::Object* clone(const osg::Cloner& cloner) const { return new name (*this,cloner); } \
        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const name *>(obj)!=NULL; } \
        virtual const char* className() const { return #name; } \



class OSGTEXT_EXPORT Font : public osg::Object
{
    public:

        Font();
        Font(const Font& font,const osg::Cloner& cloner=osg::ShallowCopy()):
            Object(font,cloner),
            _init(false),
            _created(false),
            _font(0L),
            _fontName(font._fontName),
            _pointSize(font._pointSize),
            _res(font._res),
            _textureSize(font._textureSize)
            {}

        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const Font *>(obj)!=NULL; }
        virtual const char* className() const { return "Font"; } 

        bool open(const char* font);
        bool open(const std::string& font);

        virtual bool create(osg::State& state,int  pointSize, const unsigned int res = 72 );
        virtual bool create(osg::State& state);
        virtual void output(osg::State& state,const char* text);

        virtual bool isOk(void) const { return _init; }
        virtual bool isCreated(void) const { return isOk() && _created; }

        virtual float getWidth(const char* text) const;
        virtual int getHeight() const;
        virtual int getDescender() const;
        virtual int getAscender() const;

        int        getPointSize(void) const    { return _pointSize; }
        int        getTextureSize(void) const    { return _textureSize; }
        const std::string& getFontName();

        FTFont*     getFont(void) { return _font; }

    protected:

        virtual    ~Font();

        virtual void    clear();

        virtual FTFont* createFontObj(void)=0;

        bool init(const std::string& font);

        bool            _init;
        bool            _created;

        FTFont*            _font;
        std::string        _fontName;
        int                _pointSize;
        int                _res;
        int 		_textureSize;
};



class OSGTEXT_EXPORT RasterFont:public Font
{
    public:

        RasterFont():Font(){}
        RasterFont(const RasterFont& font,const osg::Cloner& cloner=osg::ShallowCopy()):
            Font(font,cloner) {}            
        RasterFont(const std::string& font):Font() {}

        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const RasterFont *>(obj)!=NULL; } 
        virtual const char* className() const { return "RasterFont"; } 

    protected:

};



class OSGTEXT_EXPORT VectorFont:public Font
{
    public:
        VectorFont():Font(){}
        VectorFont(const VectorFont& font,const osg::Cloner& cloner=osg::ShallowCopy()):
            Font(font,cloner) {}
        VectorFont(const std::string& font):Font(){}

        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const VectorFont *>(obj)!=NULL; } 
        virtual const char* className() const { return "VectorFont"; } 

    protected:
        double    _precision;
};



class OSGTEXT_EXPORT BitmapFont:public RasterFont
{
    public:


        BitmapFont() {}
        BitmapFont(const BitmapFont& font,const osg::Cloner& cloner=osg::ShallowCopy()):
            RasterFont(font,cloner) {}
        BitmapFont(const std::string&    font, 
                   int                    point_size);

        META_Font(BitmapFont);

    protected:


        virtual FTFont* createFontObj(void);
};


class OSGTEXT_EXPORT PixmapFont:public RasterFont
{
    public:

        PixmapFont() {}
        PixmapFont(const PixmapFont& font,const osg::Cloner& cloner=osg::ShallowCopy()):
            RasterFont(font,cloner) {}

        PixmapFont(const std::string&    font, 
                   int                    point_size);

        META_Font(PixmapFont);

    protected:

        virtual FTFont* createFontObj(void);

};


class OSGTEXT_EXPORT TextureFont:public RasterFont
{
    public:

        TextureFont() {}
        TextureFont(const TextureFont& font,const osg::Cloner& cloner=osg::ShallowCopy()):
            RasterFont(font,cloner) {}

        TextureFont(const std::string&    font, 
                   int                    point_size);

        TextureFont(const std::string&    font, 
                   int                    point_size,
		    int textureSize );

        META_Font(TextureFont);

    protected:

        virtual FTFont* createFontObj(void);

};

class OSGTEXT_EXPORT OutlineFont:public VectorFont
{
    public:

        OutlineFont() {}
        OutlineFont(const OutlineFont& font,const osg::Cloner& cloner=osg::ShallowCopy()):
            VectorFont(font,cloner) {}

        OutlineFont(const std::string&    font, 
                    int                    point_size,
                    double                precision);

        META_Font(OutlineFont);

    protected:

        virtual FTFont* createFontObj(void);


};

class OSGTEXT_EXPORT PolygonFont:public VectorFont
{
public:

    PolygonFont() {}
    PolygonFont(const PolygonFont& font,const osg::Cloner& cloner=osg::ShallowCopy()):
        VectorFont(font,cloner) {}
    
    PolygonFont(const std::string&    font, 
                int                    point_size,
                double                precision);
    
    PolygonFont(const char* font, 
                int         point_size,
                double      precision);
    
    META_Font(PolygonFont);

protected:

    virtual FTFont* createFontObj(void);

};


};

#endif // OSGTEXT_FONT