text.C

Go to the documentation of this file.

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <iostream>

#include <ft2build.h>
#include FT_FREETYPE_H

#include <GL/gl.h>

#include <archon/util/file.H>
#include <archon/util/unicode.H>
#include <archon/util/image.H>

#include <archon/x3d/server/field_type.H>
#include <archon/x3d/server/field.H>
#include <archon/x3d/server/text.H>

namespace Archon
{
  namespace X3D
  {
    const NodeType *FontStyleNode::type = 0;
    const NodeType *FontStyle::type = 0;
    const NodeType *TextNode::type = 0;
    const NodeType *Text::type = 0;

    void initializeTextComponent()
    {
      vector<const FieldBase *> fields;

      // FontStyleNode

      FontStyleNode::type =
        NodeType::newAbstract("FontStyleNode", false, 0,
                              GeometricPropertyNode::type);


      // FontStyle

      fields.push_back(newPrivateField("family", MFString::type,
                                       &FontStyle::family));
      fields.push_back(newPrivateField("horizontal", SFBool::type,
                                       &FontStyle::horizontal));
      fields.push_back(newPrivateField("justify", MFString::type,
                                       &FontStyle::justify));
      fields.push_back(newPrivateField("language", SFString::type,
                                       &FontStyle::language));
      fields.push_back(newPrivateField("leftToRight", SFBool::type,
                                       &FontStyle::leftToRight));
      fields.push_back(newPrivateField("size", SFFloat::type,
                                       &FontStyle::size));
      fields.push_back(newPrivateField("spacing", SFFloat::type,
                                       &FontStyle::spacing));
      fields.push_back(newPrivateField("style", SFString::type,
                                       &FontStyle::style));
      fields.push_back(newPrivateField("topToBottom", SFBool::type,
                                       &FontStyle::topToBottom));
      FontStyle::type =
        NodeType::newConcrete("FontStyle", "fontStyle",
                              FontStyle::instantiate, &fields,
                              FontStyleNode::type);
      fields.clear();


      // TextNode

      TextNode::type =
        NodeType::newAbstract("TextNode", false, 0,
                              GeometryNode::type);


      // Text

      fields.push_back(newExposedField("string", MFString::type,
                                       &Text::_string,
                                       &Text::stringChanged,
                                       &Text::stringStamp));
      fields.push_back(newExposedField("fontStyle",
                                       &Text::fontStyle,
                                       &Text::fontStyleChanged,
                                       &Text::fontStyleStamp));
      fields.push_back(newExposedField("length", MFFloat::type,
                                       &Text::length,
                                       &Text::lengthChanged,
                                       &Text::lengthStamp));
      fields.push_back(newExposedField("maxExtent", SFFloat::type,
                                       &Text::maxExtent,
                                       &Text::maxExtentChanged,
                                       &Text::maxExtentStamp));
      fields.push_back(newPrivateField("solid", SFBool::type,
                                       &Text::solid));

      Text::type =
        NodeType::newConcrete("Text", "geometry",
                              Text::instantiate, &fields,
                              TextNode::type);
      fields.clear();
    }

    int Text::intersect(const Math::Ray3 &, double &dist) const
    {
      return 0;
    }

    void Text::getNormalAndTexCoord(Vector3 hitPoint, int where,
                                    const Shape *,
                                    Vector3 *hitNormal,
                                    Vector2 *hitTexCoord) const
    {
    }


    namespace
    {
      struct Glyph
      {
        Vector2 size;

        Vector2 horizontalLowerLeft;

        double horizontalAdvance;

        Vector2 verticalLowerLeft;

        double verticalAdvance;

        Vector2 textureLowerLeft;
        Vector2 textureUpperRight;

        Glyph(Vector2 size,
              Vector2 horizontalLowerLeft,
              double horizontalAdvance,
              Vector2 verticalUpperRight,
              double verticalAdvance,
              Vector2 textureLowerLeft,
              Vector2 textureUpperRight):
          size(size),
          horizontalLowerLeft(horizontalLowerLeft),
          horizontalAdvance(horizontalAdvance),
          verticalLowerLeft(verticalLowerLeft),
          verticalAdvance(verticalAdvance),
          textureLowerLeft(textureLowerLeft),
          textureUpperRight(textureUpperRight) {}
      };

      struct FontFace;

      struct FontList
      {
        Mutex mutex;

        static vector<string> fontPaths;
        static int pixelSize;

        struct Entry
        {
          string plainFilePath;
          int plainFileIndex;
          FontFace *plainFace;

          string boldFilePath;
          int boldFileIndex;
          FontFace *boldFace;

          string italicFilePath;
          int italicFileIndex;
          FontFace *italicFace;

          string bolditalicFilePath;
          int bolditalicFileIndex;
          FontFace *bolditalicFace;

          Entry():
            plainFace(0), boldFace(0),
            italicFace(0), bolditalicFace(0) {}
        };

        map<string, Entry> fontFamilies;

        FT_Library library;

        bool addFace(string path, int index, FT_Face face)
        {
          string family = face->family_name;

          bool bold   = face->style_flags&FT_STYLE_FLAG_BOLD;
          bool italic = face->style_flags&FT_STYLE_FLAG_ITALIC;

          //string style = bold ? italic ? "bolditalic" : "bold" : italic ? "italic" : "plain";
          //cerr << "Found \"" << family << "\" " << style << "\n";

          /*
          cerr << "Style name       = " << face->style_name << "\n";
          cerr << "Number of glyphs = " << face->num_faces << "\n";
          cerr << "Units per EM     = " << face->units_per_EM << "\n";
          cerr << "Height           = " << face->height << "\n";
          cerr << "Ascender         = " << face->ascender << "\n";
          cerr << "Descender        = " << face->descender << "\n";
          cerr << "Num fixed sizes  = " << face->num_fixed_sizes << "\n";
          cerr << "Num charmaps     = " << face->num_charmaps << "\n";
          if(face->face_flags&FT_FACE_FLAG_SCALABLE)
            cerr << "                   FT_FACE_FLAG_SCALABLE\n";
          if(face->face_flags&FT_FACE_FLAG_FIXED_SIZES)
            cerr << "                   FT_FACE_FLAG_FIXED_SIZES\n";
          if(face->face_flags&FT_FACE_FLAG_FIXED_WIDTH)
            cerr << "                   FT_FACE_FLAG_FIXED_WIDTH\n";
          if(face->face_flags&FT_FACE_FLAG_HORIZONTAL)
            cerr << "                   FT_FACE_FLAG_HORIZONTAL\n";
          if(face->face_flags&FT_FACE_FLAG_VERTICAL)
            cerr << "                   FT_FACE_FLAG_VERTICAL\n";
          if(face->face_flags&FT_FACE_FLAG_SFNT)
            cerr << "                   FT_FACE_FLAG_SFNT\n";
          if(face->face_flags&FT_FACE_FLAG_KERNING)
            cerr << "                   FT_FACE_FLAG_KERNING\n";
          if(face->face_flags&FT_FACE_FLAG_MULTIPLE_MASTERS)
            cerr << "                   FT_FACE_FLAG_MULTIPLE_MASTERS\n";
          if(face->face_flags&FT_FACE_FLAG_GLYPH_NAMES)
            cerr << "                   FT_FACE_FLAG_GLYPH_NAMES\n";
          if(face->face_flags&FT_FACE_FLAG_EXTERNAL_STREAM)
            cerr << "                   FT_FACE_FLAG_EXTERNAL_STREAM\n";
          if(face->face_flags&FT_FACE_FLAG_FAST_GLYPHS)
            cerr << "                   FT_FACE_FLAG_FAST_GLYPHS\n";
          */

          Entry &entry = fontFamilies[family];

          if(!bold && !italic)
          {
            if(entry.plainFilePath.size()) return false;
            entry.plainFilePath = path;
            entry.plainFileIndex = index;
          }
          else if(bold && !italic)
          {
            if(entry.boldFilePath.size()) return false;
            entry.boldFilePath = path;
            entry.boldFileIndex = index;
          }
          else if(!bold && italic)
          {
            if(entry.italicFilePath.size()) return false;
            entry.italicFilePath = path;
            entry.italicFileIndex = index;
          }
          else if(bold && italic)
          {
            if(entry.bolditalicFilePath.size()) return false;
            entry.bolditalicFilePath = path;
            entry.bolditalicFileIndex = index;
          }

          return true;
        }

        FontList()
        {
          if(FT_Init_FreeType(&library))
            ARCHON_THROW1(ResourceException,
                          "Error initializing FreeType library");
          
          int n = 0;

          for(unsigned i=0; i<fontPaths.size(); ++i)
          {
            //cerr << "Searching for fonts in \"" << fontPaths[i] << "\"\n";
            vector<string> dirNames = File::getDirNames(fontPaths[i]);
            for(unsigned j=0; j<dirNames.size(); ++j)
            {
              string name = dirNames[j];
              if(name == "." || name == "..") continue;
              string p = fontPaths[i]+"/"+name;
              if(File::Stat(p).getType() != File::Stat::type_regular) continue;

              FT_Face face;
              if(FT_New_Face(library, p.c_str(), 0, &face)) continue;

              //cerr << "Found font file \"" << p << "\"\n";

              if(addFace(p, 0, face)) ++n;

              unsigned m = face->num_faces;
              FT_Done_Face(face);

              for(unsigned k=1; k<m; ++k)
              {
                if(FT_New_Face(library, p.c_str(), k, &face)) break;
                if(addFace(p, k, face)) ++n;
                FT_Done_Face(face);
              }
            }
          }

          cerr << "Found " + Archon::Utilities::Text::toString(n) +
            " font faces in " + Archon::Utilities::Text::toString(fontPaths.size()) +
            " directories\n";
        }

        FontFace *getFace(string familyName, bool bold, bool italic);
        FontFace *getDefaultFace();
      };

      vector<string> FontList::fontPaths;
      int FontList::pixelSize = 32;

      struct FontFace
      {
        Mutex mutex;

        double horizontalBottom;
        double horizontalTop;

        double verticalLeft;
        double verticalRight;

        vector<const Glyph *> glyphs;

        GLuint textureId;

        FontFace(string filePath, int faceIndex, int pixelSize)
        {
          const FontList *fontList = getFontList();

          FT_Face face;
          if(FT_New_Face(fontList->library, filePath.c_str(), faceIndex, &face))
            ARCHON_THROW1(ResourceException,
                          "Font file \"" + filePath + "\" is no longer available");

          if(FT_Set_Pixel_Sizes(face, 0, pixelSize))
            ARCHON_THROW1(InternalException,
                          "Error setting pixel size of font face");

          FT_GlyphSlot slot = face->glyph;

          glyphs.resize(256);

          int imageWidth  = 16*pixelSize;
          int imageHeight = 16*pixelSize;
          Image texture(imageWidth, imageHeight, Image::components_la, 8); // Could be reduced to 1 bit per component

          for(int x=0; x<imageWidth; ++x)
            for(int y=0; y<imageHeight; ++y)
              texture.setPixel(x, y, 255u, 0u);

          /*
           * Minimum vertical and horizontal distance between glyphs
           * in texture mesured in number of texels. This spacing is
           * introduced to prevent the texels from one glyph to
           * "bleed" into the bbox of an adjacent glyph due to the
           * filtering done by OpenGL.
           */
          const int textureSpacing = 4;

          /*
           * Number of texels to expand the minimum bbox of the glyph
           * in the texture by to get the bbox to use for the actual
           * texture mapping. This of cause increases the size of the
           * rendered quad for the glyph. The reason for expanding the
           * minimum bbox is to allow the filtering done by OpenGL to
           * work correctly at the edges of the glyph. If there were
           * no padding then otherwise smooth edges of the glyph would
           * be cut off too sharply. Note that half the size of
           * 'textureSpacing' will usually be optimal.
           */
          const double texturePadding = textureSpacing/2.0;

          int xPos = textureSpacing;
          int yPos = textureSpacing;
          int maxHeight = 0;

          // Load first Unicode page into texture
          for(unsigned i=0; i<256; ++i)
          {
            if(FT_Load_Char(face, static_cast<unsigned char>(i), FT_LOAD_RENDER))
              continue;
            if(int(slot->bitmap.pixel_mode) != 2)
              ARCHON_THROW1(InternalException,
                            "Unsupported pixel data encoding in font");

            if(slot->bitmap.width+textureSpacing > imageWidth - xPos)
            {
              yPos += maxHeight+textureSpacing;
              xPos = textureSpacing;
              maxHeight = 0;
            }

            if(slot->bitmap.width+textureSpacing > imageWidth - xPos ||
               slot->bitmap.rows+textureSpacing > imageHeight - yPos)
              ARCHON_THROW1(InternalException,
                            "All glyphs won't fit inside texture");

            for(int x=0; x<slot->bitmap.width; ++x)
              for(int y=0; y<slot->bitmap.rows; ++y)
              {
                unsigned l = (static_cast<unsigned char *>(slot->bitmap.buffer))
                  [x + y * slot->bitmap.width];
                texture.setPixel(xPos+x, imageHeight-1-yPos-y, 255, l);
              }

            double linesPerTexel = face->units_per_EM/double(face->height*pixelSize);

            horizontalBottom = 0;
            horizontalTop    = pixelSize*linesPerTexel;
            verticalLeft     = 0;
            verticalRight    = pixelSize*linesPerTexel;

            Vector2 horizontalLowerLeft;
            double horizontalAdvance;
            Vector2 verticalLowerLeft;
            double verticalAdvance;

            if(face->face_flags&FT_FACE_FLAG_HORIZONTAL)
            {
              horizontalLowerLeft = verticalLowerLeft =
                Vector2(slot->bitmap_left-texturePadding,
                        slot->bitmap_top-slot->bitmap.rows-texturePadding)*
                linesPerTexel;

              horizontalAdvance = slot->advance.x/64 * linesPerTexel;
              verticalAdvance   = 1;
            }
            else
            {
              horizontalLowerLeft = verticalLowerLeft =
                Vector2(slot->bitmap_left-texturePadding,
                        slot->bitmap_top-slot->bitmap.rows-texturePadding)*
                linesPerTexel;

              horizontalAdvance = 1;
              verticalAdvance   = slot->advance.y/64 * linesPerTexel;
            }

            glyphs[i] =
              new Glyph(Vector2(slot->bitmap.width + 2*texturePadding,
                                slot->bitmap.rows  + 2*texturePadding) *
                        linesPerTexel,
                        horizontalLowerLeft, horizontalAdvance,
                        verticalLowerLeft, verticalAdvance,
                        Vector2(double(xPos-texturePadding)/imageWidth,
                                double(imageHeight-1-yPos-slot->bitmap.rows-texturePadding)/imageHeight),
                        Vector2(double(xPos+slot->bitmap.width+texturePadding)/imageWidth,
                                double(imageHeight-1-yPos+texturePadding)/imageHeight));

            xPos += slot->bitmap.width+textureSpacing;
            if(slot->bitmap.rows > maxHeight) maxHeight = slot->bitmap.rows;
          }

          {
            string family = face->family_name;
            bool bold   = face->style_flags&FT_STYLE_FLAG_BOLD;
            bool italic = face->style_flags&FT_STYLE_FLAG_ITALIC;
            string style = bold ? italic ? "bolditalic" : "bold" : italic ? "italic" : "plain";
            //texture.save(family + " " + style + ".png");
          }

          FT_Done_Face(face);

          {
            int colorMode;
            switch(texture.getComponentSpecifier())
            {
            case Utilities::Image::components_l:    colorMode = GL_LUMINANCE;       break;
            case Utilities::Image::components_la:   colorMode = GL_LUMINANCE_ALPHA; break;
            case Utilities::Image::components_rgb:  colorMode = GL_RGB;             break;
            case Utilities::Image::components_rgba: colorMode = GL_RGBA;            break;
            default:
              ARCHON_THROW1(InternalException,
                            "Unsuported color components");
            }

            int componentType;
            switch(texture.getBitsPerComponent())
            {
            case 8:  componentType = GL_UNSIGNED_BYTE;  break;
            case 16: componentType = GL_UNSIGNED_SHORT; break;
            default:
              ARCHON_THROW1(InternalException,
                            "Unsuported color component width");
            }

            glGenTextures(1, &textureId);
            glBindTexture(GL_TEXTURE_2D, textureId);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_CLAMP);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

            glTexImage2D(GL_TEXTURE_2D, 0, colorMode, texture.getWidth(),
                         texture.getHeight(), 0, colorMode, componentType,
                         texture.getPixelBuffer());
          }
        }

        const Glyph *getGlyph(uchar i)
        {
          Mutex::Lock l(mutex);
          if(i > 255) return 0;
          return glyphs[i];
        }

        static FontFace *get()
        {
          FontList *fontList = getFontList();
          return fontList->getDefaultFace();
        }

        static FontFace *get(string familyName, bool bold, bool italic)
        {
          FontList *fontList = getFontList();
          return fontList->getFace(familyName, bold, italic);
        }

      private:
        static FontList *getFontList()
        {
          static FontList fontList;
          return &fontList;
        }
      };
    }

    FontFace *FontList::getDefaultFace()
    {
      FontFace *f = getFace("Times New Roman", false, false);
      if(f) return f;
      ARCHON_THROW1(InternalException,
                    "Could not find default font face");
    }

    FontFace *FontList::getFace(string familyName, bool bold, bool italic)
    {
      Mutex::Lock l(mutex);

      map<string, Entry>::iterator i = fontFamilies.find(familyName);
      if(i == fontFamilies.end()) return 0;

      if(!bold && !italic)
      {
        if(!i->second.plainFilePath.size()) return 0;
        if(!i->second.plainFace)
          i->second.plainFace =
            new FontFace(i->second.plainFilePath, i->second.plainFileIndex, pixelSize);
        return i->second.plainFace;
      }

      if(bold && !italic)
      {
        if(!i->second.boldFilePath.size()) return 0;
        if(!i->second.boldFace)
          i->second.boldFace =
            new FontFace(i->second.boldFilePath, i->second.boldFileIndex, pixelSize);
        return i->second.boldFace;
      }

      if(!bold && italic)
      {
        if(!i->second.italicFilePath.size()) return 0;
        if(!i->second.italicFace)
          i->second.italicFace =
            new FontFace(i->second.italicFilePath, i->second.italicFileIndex, pixelSize);
        return i->second.italicFace;
      }

      if(!i->second.bolditalicFilePath.size()) return 0;
      if(!i->second.bolditalicFace)
        i->second.bolditalicFace =
          new FontFace(i->second.bolditalicFilePath, i->second.bolditalicFileIndex, pixelSize);
      return i->second.bolditalicFace;
    }



    void Text::render(bool texture,
                      const Shape *shape,
                      const RenderConfig *renderConfig)
    {
      const FontStyle *f = dynamic_cast<const FontStyle *>(fontStyle.get());

      if(!f && fontStyle)
        ARCHON_THROW1(InternalException,
                      "'" + fontStyle->getType()->getName() +
                      "' is not supported yet");

      FontFace *face = 0;

      if(f) for(unsigned i=0; i<f->getFamily().size(); ++i)
      {
        bool bold   = false;
        bool italic = false;
        if(f->getStyle() == "BOLD") bold = true;
        else if(f->getStyle() == "ITALIC") italic = true;
        else if(f->getStyle() == "BOLDITALIC") bold = italic = true;

        face = FontFace::get(f->getFamily()[i], bold, italic);
        if(face) break;

        if(f->getFamily()[i] == "SERIF")
        {
          face = FontFace::get("Times New Roman", bold, italic);
          if(face) break;
        }
        else if(f->getFamily()[i] == "SANS")
        {
          face = FontFace::get("Arial", bold, italic);
          if(face) break;
        }
        else if(f->getFamily()[i] == "TYPEWRITER")
        {
          face = FontFace::get("Courier New", bold, italic);
          if(face) break;
        }
      }

      if(!face) face = FontFace::get();

      bool horizontal  = f ? f->getHorizontal()  : true;
      bool leftToRight = f ? f->getLeftToRight() : true;
      bool topToBottom = f ? f->getTopToBottom() : true;

      const double size = f ? f->getSize() : 1;
      double lineAdvance = f ? f->getSpacing()*size : 1;
      if(topToBottom) lineAdvance = -lineAdvance;

      vector<vector<const Glyph *> > stringGlyphs;
      vector<double> stringExtents;
      vector<double> stringAjusts; // Inter character ajustment

      stringGlyphs.resize(_string.size());
      stringExtents.resize(_string.size());
      stringAjusts.resize(_string.size());

      // Find glyphs and calculate extents of strings
      double max = 0;
      for(unsigned i=0; i<_string.size(); ++i)
      {
        ustring s = Unicode::decodeUtf8(_string[i]);

        stringGlyphs[i].reserve(s.size());
        double extent = 0;

        for(unsigned j=0; j<s.size(); ++j)
        {
          const Glyph *g = face->getGlyph(s[j]);
          if(!g) continue;
          stringGlyphs[i].push_back(g);
          extent += (horizontal ? g->horizontalAdvance : g->verticalAdvance)*size;
        }

        if(i >= length.size() || length[i] == 0)
        {
          stringExtents[i] = extent;
          stringAjusts[i] = 0;
        }
        else
        {
          stringExtents[i] = length[i];
          if(stringGlyphs[i].size() > 1)
            stringAjusts[i] = (length[i] - extent)/(stringGlyphs[i].size()-1);
        }

        if(stringExtents[i] > max) max = stringExtents[i];
      }

      double compress = maxExtent > 0 && max > maxExtent ? maxExtent/max : 1;

      /*
       * The displacement of the lines in the primary direction of the
       * lines and relative the the effective length of each line.
       * before the origin of alignment
       */
      double primaryAlignment = 0;
      if(f && f->getJustify().size())
      {
        string s = f->getJustify()[0];
        if(s == "MIDDLE") primaryAlignment = -0.5;
        else if(s == "END") primaryAlignment = -1;
      }
      const bool primaryDirection = horizontal ? leftToRight : topToBottom;
      if(!primaryDirection) primaryAlignment = - primaryAlignment;

      double totalSecondaryExtent =
        (horizontal ? face->horizontalTop - face->horizontalBottom :
         face->verticalRight - face->verticalLeft)+_string.size()-1;

      double lineOrigin = 0;
      if(f && f->getJustify().size()>1)
      {
        string s = f->getJustify()[1];
        if(s == "BEGIN") lineOrigin = topToBottom ? -face->horizontalTop : 0;
        else if(s == "MIDDLE")
          lineOrigin =
            topToBottom ? totalSecondaryExtent/2 - face->horizontalTop :
            -totalSecondaryExtent/2;
        else if(s == "END")
          lineOrigin =
            topToBottom ? totalSecondaryExtent - face->horizontalTop :
            -totalSecondaryExtent;
      }

      glFrontFace(GL_CCW);
      glDisable(GL_COLOR_MATERIAL);
      if(solid)
      {
        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
        glEnable(GL_CULL_FACE);
      }
      else
      {
        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
        glDisable(GL_CULL_FACE);
      }
      glNormal3d(0, 0, 1);

      if(renderConfig->textAsQuadsMode || renderConfig->wireframeMode)
      {
        glDisable(GL_TEXTURE_2D);
      }
      else
      {
        glAlphaFunc(GL_GREATER, 0); // Pass if incoming alpha is greater that 0
        glEnable(GL_ALPHA_TEST);
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, face->textureId);
      }

      glBegin(GL_QUADS);

      for(unsigned i=0; i<_string.size(); ++i)
      {
        Vector2 pen(stringExtents[i] * primaryAlignment, lineOrigin);
        const double ajust = stringAjusts[i];

        for(unsigned j=0; j<stringGlyphs[i].size(); ++j)
        {
          const Glyph *g = stringGlyphs[i][j];

          if(!leftToRight)
            pen[0] -= g->horizontalAdvance*size+ajust;

          Vector2 layoutLowerLeft  = pen + g->horizontalLowerLeft * size;
          Vector2 layoutUpperRight = layoutLowerLeft + g->size * size;

          layoutLowerLeft[0]  *= compress;
          layoutUpperRight[0] *= compress;

          glTexCoord2d(g->textureUpperRight[0], g->textureUpperRight[1]);
          glVertex2d(layoutUpperRight[0], layoutUpperRight[1]);

          glTexCoord2d(g->textureLowerLeft[0], g->textureUpperRight[1]);
          glVertex2d(layoutLowerLeft[0], layoutUpperRight[1]);

          glTexCoord2d(g->textureLowerLeft[0], g->textureLowerLeft[1]);
          glVertex2d(layoutLowerLeft[0], layoutLowerLeft[1]);

          glTexCoord2d(g->textureUpperRight[0], g->textureLowerLeft[1]);
          glVertex2d(layoutUpperRight[0], layoutLowerLeft[1]);

          if(leftToRight)
            pen[0] += g->horizontalAdvance*size+ajust;
        }

        lineOrigin += lineAdvance;
      }
      glEnd();

      glDisable(GL_ALPHA_TEST);
    }

    void addFontPath(string p)
    {
      FontList::fontPaths.push_back(p);
    }
  }
}

---