OgreFont.h

Go to the documentation of this file.

/*-------------------------------------------------------------------------
This source file is a part of OGRE
(Object-oriented Graphics Rendering Engine)

For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License (LGPL) as 
published by the Free Software Foundation; either version 2.1 of the 
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but 
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public 
License for more details.

You should have received a copy of the GNU Lesser General Public License 
along with this library; if not, write to the Free Software Foundation, 
Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA or go to
http://www.gnu.org/copyleft/lesser.txt
-------------------------------------------------------------------------*/

#ifndef _Font_H__
#define _Font_H__

#include "OgrePrerequisites.h"
#include "OgreResource.h"
#include "OgreTexture.h"
#include "OgreMaterial.h"

namespace Ogre
{
    // Define the number of glyphs allowed
    // We ignore 0-31 since these are control characters
#if OGRE_WCHAR_T_STRINGS
    // Allow wide chars
    #define OGRE_NUM_GLYPHS (1024 - 32)
#else
    // Allow 8-bit ASCII 
    // (we don't want to offend people with charcodes 127-256 in their name eh cearny? ;)
    // Only chars 33+ are any use though
    #define OGRE_NUM_GLYPHS (256 - 32)
#endif

    // How to look up chars
    #define OGRE_GLYPH_INDEX(c) c - 33

    enum FontType
    {
        FT_TRUETYPE = 1,
        FT_IMAGE = 2
    };


    class _OgreExport Font : public Resource, public ManualResourceLoader
    {
    protected:
        class _OgreExport CmdType : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class _OgreExport CmdSource : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class _OgreExport CmdSize : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class _OgreExport CmdResolution : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };

        // Command object for setting / getting parameters
        static CmdType msTypeCmd;
        static CmdSource msSourceCmd;
        static CmdSize msSizeCmd;
        static CmdResolution msResolutionCmd;

        FontType mType;

        String mSource;

        Real mTtfSize;
        uint mTtfResolution;


        Real mTexCoords_u1[OGRE_NUM_GLYPHS];
        Real mTexCoords_u2[OGRE_NUM_GLYPHS];
        Real mTexCoords_v1[OGRE_NUM_GLYPHS];
        Real mTexCoords_v2[OGRE_NUM_GLYPHS];

        Real mAspectRatio[OGRE_NUM_GLYPHS];

        MaterialPtr mpMaterial;

        TexturePtr mTexture;

        bool mAntialiasColour;

        void createTextureFromFont(void);

        virtual void loadImpl();
        virtual void unloadImpl();
        size_t calculateSize(void) const { return 0; } // permanent resource is in the texture 
    public:

        Font(ResourceManager* creator, const String& name, ResourceHandle handle,
            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
        virtual ~Font();

        void setType(FontType ftype);

        FontType getType(void) const;

        void setSource(const String& source);

        const String& getSource(void) const;

        void setTrueTypeSize(Real ttfSize);
        void setTrueTypeResolution(uint ttfResolution);

        Real getTrueTypeSize(void) const;
        uint getTrueTypeResolution(void) const;

        std::pair< uint, uint > StrBBox( const String & text, Real char_height, RenderWindow & window  );


        inline void getGlyphTexCoords(OgreChar id, Real& u1, Real& v1, Real& u2, Real& v2 ) const
        {
            unsigned OgreChar idx = OGRE_GLYPH_INDEX(id);
            u1 = mTexCoords_u1[ idx ];
            v1 = mTexCoords_v1[ idx ];
            u2 = mTexCoords_u2[ idx ];
            v2 = mTexCoords_v2[ idx ];
        }

        inline void setGlyphTexCoords( OgreChar id, Real u1, Real v1, Real u2, Real v2 )
        {
            unsigned OgreChar idx = OGRE_GLYPH_INDEX(id);
            mTexCoords_u1[ idx ] = u1;
            mTexCoords_v1[ idx ] = v1;
            mTexCoords_u2[ idx ] = u2;
            mTexCoords_v2[ idx ] = v2;
            mAspectRatio[ idx ] = ( u2 - u1 ) / ( v2 - v1 );
        }
        inline Real getGlyphAspectRatio( OgreChar id ) const
        {
            unsigned OgreChar idx = OGRE_GLYPH_INDEX(id);
            return mAspectRatio[ idx ];
        }
        inline void setGlyphAspectRatio( OgreChar id, Real ratio )
        {
            unsigned OgreChar idx = OGRE_GLYPH_INDEX(id);
            mAspectRatio[ idx ] = ratio;
        }
        inline const MaterialPtr& getMaterial() const
        {
            return mpMaterial;
        }
        inline const MaterialPtr& getMaterial()
        {
            return mpMaterial;
        }
        inline void setAntialiasColour(bool enabled)
        {
            mAntialiasColour = enabled;
        }

        inline bool getAntialiasColour(void) const
        {
            return mAntialiasColour;
        }

        void loadResource(Resource* resource);
    };
    class _OgreExport FontPtr : public SharedPtr<Font> 
    {
    public:
        FontPtr() : SharedPtr<Font>() {}
        explicit FontPtr(Font* rep) : SharedPtr<Font>(rep) {}
        FontPtr(const FontPtr& r) : SharedPtr<Font>(r) {} 
        FontPtr(const ResourcePtr& r) : SharedPtr<Font>()
        {
            // lock & copy other mutex pointer
            OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
            OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
            pRep = static_cast<Font*>(r.getPointer());
            pUseCount = r.useCountPointer();
            if (pUseCount)
            {
                ++(*pUseCount);
            }
        }

        FontPtr& operator=(const ResourcePtr& r)
        {
            if (pRep == static_cast<Font*>(r.getPointer()))
                return *this;
            release();
            // lock & copy other mutex pointer
            OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
            OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
            pRep = static_cast<Font*>(r.getPointer());
            pUseCount = r.useCountPointer();
            if (pUseCount)
            {
                ++(*pUseCount);
            }
            return *this;
        }
    };
}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:40 2006