include/cinder/gl/TextureFont.h

Go to the documentation of this file.

/*
 Copyright (c) 2011, The Cinder Project: http://libcinder.org All rights reserved.
 This code is intended for use with the Cinder C++ library: http://libcinder.org

 Redistribution and use in source and binary forms, with or without modification, are permitted provided that
 the following conditions are met:

    * Redistributions of source code must retain the above copyright notice, this list of conditions and
    the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
    the following disclaimer in the documentation and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
*/

#pragma once

#include "cinder/Cinder.h"
#include "cinder/Text.h"
#include "cinder/Font.h"
#include "cinder/gl/Texture.h"

#include <map>
#if defined( _MSC_VER ) && ( _MSC_VER >= 1600 ) || defined( _LIBCPP_VERSION )
    #include <unordered_map>
#else
    #include <boost/unordered_map.hpp>
#endif

namespace cinder { namespace gl {

typedef std::shared_ptr<class TextureFont>  TextureFontRef;

class TextureFont {
  public:
    class Format {
      public:
        Format() : mTextureWidth( 1024 ), mTextureHeight( 1024 ), mPremultiply( false ), mMipmapping( false )
        {}
        
        Format&     textureWidth( int32_t textureWidth ) { mTextureWidth = textureWidth; return *this; }
        int32_t     getTextureWidth() const { return mTextureWidth; }
        Format&     textureHeight( int32_t textureHeight ) { mTextureHeight = textureHeight; return *this; }
        int32_t     getTextureHeight() const { return mTextureHeight; }
        
        Format&     premultiply( bool premult = true ) { mPremultiply = premult; return *this; }
        bool        getPremultiply() const { return mPremultiply; }
        
        Format&     enableMipmapping( bool enable = true ) { mMipmapping = enable; return *this; }
        bool        hasMipmapping() const { return mMipmapping; }
        
      protected:
        int32_t     mTextureWidth, mTextureHeight;
        bool        mPremultiply;
        bool        mMipmapping;
    };

    struct DrawOptions {
        DrawOptions() : mClipHorizontal( true ), mClipVertical( true ), mPixelSnap( true ), mLigate( false ), mScale( 1 ) {}

        bool            getClipHorizontal() const { return mClipHorizontal; }       
        DrawOptions&    clipHorizontal( bool clipH = true ) { mClipHorizontal = clipH; return *this; }

        bool            getClipVertical() const { return mClipVertical; }       
        DrawOptions&    clipVertical( bool clipV = true ) { mClipVertical = clipV; return *this; }

        bool            getPixelSnap() const { return mPixelSnap; }     
        DrawOptions&    pixelSnap( bool pixelSnap = true ) { mPixelSnap = pixelSnap; return *this; }

        bool            getLigate() const { return mLigate; }
        DrawOptions&    ligate( bool useLigatures = true ) { mLigate = useLigatures; return *this; }

        float           getScale() const { return mScale; }
        DrawOptions&    scale( float sc ) { mScale = sc; return *this; }


      protected:
        bool        mClipHorizontal, mClipVertical, mPixelSnap, mLigate;
        float       mScale;
    };

    static TextureFontRef       create( const Font &font, const Format &format = Format(), const std::string &supportedChars = TextureFont::defaultChars() )
    { return TextureFontRef( new TextureFont( font, supportedChars, format ) ); }
    
    void    drawString( const std::string &str, const Vec2f &baseline, const DrawOptions &options = DrawOptions() );
    void    drawString( const std::string &str, const Rectf &fitRect, const Vec2f &offset = Vec2f::zero(), const DrawOptions &options = DrawOptions() );
    void    drawStringWrapped( const std::string &str, const Rectf &fitRect, const Vec2f &offset = Vec2f::zero(), const DrawOptions &options = DrawOptions() );
    void    drawGlyphs( const std::vector<std::pair<uint16_t,Vec2f> > &glyphMeasures, const Vec2f &baseline, const DrawOptions &options = DrawOptions(), const std::vector<ColorA8u> &colors = std::vector<ColorA8u>() );
    void    drawGlyphs( const std::vector<std::pair<uint16_t,Vec2f> > &glyphMeasures, const Rectf &clip, Vec2f offset, const DrawOptions &options = DrawOptions(), const std::vector<ColorA8u> &colors = std::vector<ColorA8u>() );

    Vec2f   measureString( const std::string &str, const DrawOptions &options = DrawOptions() ) const;
#if defined( CINDER_COCOA )

    Vec2f   measureStringWrapped( const std::string &str, const Rectf &fitRect, const DrawOptions &options = DrawOptions() ) const;
#endif
    
    std::vector<std::pair<uint16_t,Vec2f> >     getGlyphPlacements( const std::string &str, const DrawOptions &options = DrawOptions() ) const;
    std::vector<std::pair<uint16_t,Vec2f> >     getGlyphPlacements( const std::string &str, const Rectf &fitRect, const DrawOptions &options = DrawOptions() ) const;
    std::vector<std::pair<uint16_t,Vec2f> >     getGlyphPlacementsWrapped( const std::string &str, const Rectf &fitRect, const DrawOptions &options = DrawOptions() ) const;

    const Font&     getFont() const { return mFont; }
    std::string getName() const { return mFont.getName(); }
    float   getAscent() const { return mFont.getAscent(); }
    float   getDescent() const { return mFont.getDescent(); }
    bool    isPremultiplied() const { return mFormat.getPremultiply(); }

    static std::string      defaultChars() { return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890().?!,:;'\"&*=+-/\\@#_[]<>%^llflfiphrids\303\251\303\241\303\250\303\240"; }

  protected:
    TextureFont( const Font &font, const std::string &supportedChars, const Format &format );

    struct GlyphInfo {
        uint8_t     mTextureIndex;
        Area        mTexCoords;
        Vec2f       mOriginOffset;
    };
    
#if defined( _MSC_VER ) && ( _MSC_VER >= 1600 ) || defined( _LIBCPP_VERSION )
    std::unordered_map<Font::Glyph, GlyphInfo>      mGlyphMap;
#else
    boost::unordered_map<Font::Glyph, GlyphInfo>    mGlyphMap;
#endif
    std::vector<gl::Texture>                        mTextures;
    Font                                            mFont;
    Format                                          mFormat;
};

} } // namespace cinder::gl