font.H

/*
 * 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).
 */







// OBS: THIS FILE IS NOT CURRENTLY IN USE






#ifndef ARCHON_X3D_FONT_H
#define ARCHON_X3D_FONT_H

#include <string>
#include <vector>

#include <archon/util/ref.H>

namespace Archon
{
  namespace X3D
  {
    using namespace std;
    using namespace Utilities;

    struct Server;

    struct FontServer: virtual RefObjectBase
    {
      FontServer(Ref<Server>, vector<string> fontDirs);

      const BackRef<Server> server;

    private:
      vector<string> fontDirs;
    };






    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;
            try
            {
              dirNames = File::getDirNames(fontPaths[i]);
            }
            catch(File::ArgumentException &)
            {
              // ************************************   ISSUE A WARNING THROUGH THE SERVERS LOGGER ****************************
              continue;
            }
            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);

          // Create an image that is hopefully big enough for all the glyphs (we shoul really just add new images when needed)
          int imageWidth  = 16*pixelSize;
          int imageHeight = 16*pixelSize;
          Image texture(imageWidth, imageHeight, Image::components_la, 8); // Could be reduced to 1 bit per component

          // Clear the image to be totally transparent
          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");

            // New row of glyphs in the texture
            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");

            // Copy the glyph into the texture image
            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.getDataPtr());
          }
        }

        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;
    }



  }
}

#endif // ARCHON_X3D_FONT_H

---