source/builders/font.h

   1 #ifndef MSP_GL_FONT_H_
   2 #define MSP_GL_FONT_H_
   3
   4 #include <map>
   5 #include <string>
   6 #include <msp/datafile/objectloader.h>
   7 #include <msp/stringcodec/utf8.h>
   8
   9 namespace Msp {
  10 namespace GL {
  11
  12 class PrimitiveBuilder;
  13 class Texture2D;
  14
  15 /**
  16 Stores a set of glyphs and creates strings out of them.
  17 */
  18 class Font
  19 {
  20 public:
  21         class Loader: public DataFile::CollectionObjectLoader<Font>
  22         {
  23         public:
  24                 Loader(Font &);
  25                 Loader(Font &, Collection &);
  26
  27         private:
  28                 void init();
  29                 void glyph(unsigned);
  30                 void kerning(unsigned, unsigned, float);
  31                 void ligature(unsigned, unsigned, unsigned);
  32                 void texture();
  33                 void texture_ref(const std::string &);
  34         };
  35
  36         struct Glyph
  37         {
  38                 class Loader: public Msp::DataFile::ObjectLoader<Glyph>
  39                 {
  40                 public:
  41                         Loader(Glyph &);
  42                 private:
  43                         void texcoords(float, float, float, float);
  44                 };
  45
  46                 unsigned code;
  47                 float x1, y1;
  48                 float x2, y2;
  49                 float w, h;
  50                 float off_x, off_y;
  51                 float advance;
  52
  53                 Glyph();
  54         };
  55
  56 private:
  57         typedef std::map<unsigned, Glyph> GlyphMap;
  58         typedef std::pair<unsigned, unsigned> CodePair;
  59         typedef std::map<CodePair, float> KerningMap;
  60         typedef std::map<CodePair, unsigned> LigatureMap;
  61
  62         const Texture2D *texture;
  63         float native_size;
  64         float ascent;
  65         float descent;
  66         float cap_height;
  67         float x_height;
  68         GlyphMap glyphs;
  69         KerningMap kerning;
  70         LigatureMap ligatures;
  71
  72 public:
  73         Font();
  74         ~Font();
  75
  76         void set_texture(const Texture2D &);
  77         const Texture2D &get_texture() const;
  78
  79         /** Adds a glyph to the font.  There must not be an existing glyph with the
  80         same code. */
  81         void add_glyph(const Glyph &);
  82         void set_kerning(unsigned, unsigned, float);
  83
  84         /** Returns the size used to generate the font texture.  This serves as a
  85         hint for obtaining the best quality when rendering strings. */
  86         float get_native_size() const { return native_size; }
  87
  88         float get_ascent() const { return ascent; }
  89         float get_descent() const { return descent; }
  90         float get_cap_height() const { return cap_height; }
  91         float get_x_height() const { return x_height; }
  92
  93         /** Returns the width of a string, in multiples of the font size.  Scale the
  94         result according to the size used in rendering. */
  95         float get_string_width(const std::string &, StringCodec::Decoder &) const;
  96
  97         template<class C>
  98         float get_string_width(const std::string &str) const
  99         {
 100                 typename C::Decoder dec;
 101                 return get_string_width(str, dec);
 102         }
 103
 104         float get_string_width(const std::string &str) const
 105         { return get_string_width<StringCodec::Utf8>(str); }
 106
 107         /** Builds the primitives for a string.  Two-dimensional vertex and texture
 108         coordinates are generated.  Size 1.0 is used for building; set up the
 109         builder's matrix before the call.  The texture is not bound, to avoid
 110         unnecessary bindings when creating meshes. */
 111         void build_string(const std::string &, StringCodec::Decoder &, PrimitiveBuilder &) const;
 112
 113         template<class C>
 114         void build_string(const std::string &str, PrimitiveBuilder &pb) const
 115         {
 116                 typename C::Decoder dec;
 117                 build_string(str, dec, pb);
 118         }
 119
 120         void build_string(const std::string &str, PrimitiveBuilder &pb) const
 121         { return build_string<StringCodec::Utf8>(str, pb); }
 122
 123 private:
 124         void create_glyph_quad(const Glyph &, PrimitiveBuilder &) const;
 125         float get_glyph_advance(unsigned, unsigned = 0) const;
 126         unsigned get_ligature(unsigned, unsigned) const;
 127 };
 128
 129 } // namespace GL
 130 } // namespace Msp
 131
 132 #endif