Use a TrueType font

From LuaTeXWiki
Revision as of 10:00, 8 December 2010 by Paul (talk | contribs) (Removed the useless definition of names_of_glyph (not used in the code).)

A TrueType (or Openype) font can be used without going through a TFM or an OFM file, like in XeTeX.

The best way to do so is to use the package luaotfload, on the CTAN, and developped here: http://github.com/mpg/luaotfload/

The code shows how we can use the table of a TrueType font to produce an internal TeX font table:

\pdfoutput1
\directlua{
callback.register('define_font',
  function(name, size)
    fonttype = nil
    filename = kpse.find_file(name,"opentype fonts")
    if (filename)
    then fonttype = 'opentype'
    else filename = kpse.find_file(name, "truetype fonts")
    end
    if filename and not fonttype then fonttype = 'truetype' end
    if fonttype then
      if (size < 0) then size = (- 655.36) * size end
      ttffont = fontforge.to_table(fontforge.open(filename))
      if ttffont then
        f = { }
        f.name = ttffont.fontname
        f.fullname = ttffont.names[1].names.fullname
        f.parameters = { }
        f.designsize = size
        f.size = size
        direction = 0
        f.parameters.slant = 0
        f.parameters.space = size * 0.25
        f.parameters.space_stretch = 0.3 * size
        f.parameters.space_shrink = 0.1 * size
        f.parameters.x_height = 0.4 * size
        f.parameters.quad = 1.0 * size
        f.parameters.extra_space = 0
        f.characters = { }
        local mag = size / ttffont.units_per_em

         names_of_char = { }
        for char, glyph in pairs(ttffont.map.map)
        do
          names_of_char[ttffont.glyphs[glyph].name]
            = ttffont.map.backmap[glyph]
        end

       for char, glyph in pairs(ttffont.map.map)
        do
          glyph_table = ttffont.glyphs[glyph]

          f.characters[char] = {
            index = glyph,
            width = glyph_table.width * mag,
            name = glyph_table.name,
          }
          if glyph_table.boundingbox[4] then
            f.characters[char].height = glyph_table.boundingbox[4] * mag
          end
          if glyph_table.boundingbox[2] then
            f.characters[char].depth = -glyph_table.boundingbox[2] * mag
          end

          if glyph_table.kerns then
            local kerns = { }
            for _, kern in pairs(glyph_table.kerns)
            do
              kerns[names_of_char[kern.char]] = kern.off * mag
            end
          f.characters[char].kerns = kerns
          end
        end
        f.filename = filename
        f.type = 'real'
        f.format = fonttype
        f.embedding = "subset"
        f.cidinfo = {
          registry = "Adobe",
          ordering = "Identity",
          supplement = 0,
          version = 1
        }
      end
    else
      f = font.read_tfm(name, size)
    end
  return f
  end
)
}

The index of the f.characters table is the Unicode value, among the properties of each entry of that table we have index which is the glyph index. Using this property we get the mapping between Unicode characters and glyphs. Kerning is handled via TeX font LKP.

What is missing in the code above is better calculation of standard TeX font parameters and OpenType features. � suivre...