[Indic-computing-devel] How are indic fonts rendered?

[<jk...@Fr...>]

I'm trying to refine my understanding of the basic algorithms involved
in Indic glyph rendering, for future inclusion into the Handbook.

My current understanding:

There seem to be two major issues when rendering Indic scripts ---
given a sequence of code points representing characters in some
encoding like Unicode or ISCII:

   (A) the presentation (i.e. visual) order of glyphs need not match
       the order of code points in the sequence.

   (B) these scripts use a number of glyph shapes representing
       combinations of characters, so there isn't a 1-1 mapping of
       character encoding code points to glyphs.

(A) can come about because of the structure of the character encoding
  used.  For example, UNICODE follows the convention that the code
  point for a 'base character' precedes the code points for any
  modifiers.  However, some indic scripts may require that glyphs
  representing these modifiers (e.g:- "vowel marks") be placed before
  the glyph for the 'base character'.

  [Note: You could possibly think of a character encoding where text
   is encoded in "visual" order.  Some transliteration schemes for
   indian languages use such "visual" order encodings. ]

(B) is a property of the script: most (all?) indic scripts have
  special glyph shapes for double-consonants, consonants+vowel
  combinations, etc.

So, our rendering process has to map:

   `M' code points -> `N' language glyph shapes

and in doing so we have to do glyph re-ordering "(A)" and composite
glyph selection "(B)".

[Q: Are there any other issues to be taken care of when rendering 
    indic scripts? ]

Some indian language fonts are designed to contain "partial glyphs";
these fonts require a sequence of glyphs to be specified to render a
full language glyph on screen (for example, Baraha (Kannada)).  For
such fonts, each of the `N' language glyph shapes selected above will
need to be mapped further into `O' font-specific glyph indices.

My questions are:

  - do we do reordering of glyphs (A) before looking for composite
    glyphs (B), or is it best done the other way round?

  - do (A) and (B) have to be done multiple times?

  - is there ONE algorithm that can handle correct glyph rendering for
    every indic script, or are the glyph selection/re-ordering
    algorithms language specific?

Thanks in advance for answers; this discussion will form the basis of
a section on Indic rendering in our Indic-Computing Handbook.

Regards,
Koshy
<jk...@fr...>