Bidi + Font Shaping Support

src/SixLabors.Fonts/AppliedFontStyle.cs

@@ -17,6 +17,8 @@ internal struct AppliedFontStyle
         public int End;
         public bool ApplyKerning;
 
+        // TODO: This should accept all the glyphs in the range to
+        // allow complex substitutions.
         public GlyphMetrics[] GetGlyphLayers(CodePoint codePoint, ColorFontSupport colorFontOptions)
         {
             GlyphMetrics glyph = this.MainFont.GetGlyphMetrics(codePoint);

src/SixLabors.Fonts/BigEndianBinaryReader.cs

@@ -167,10 +167,17 @@ public ushort ReadUInt16()
             return BinaryPrimitives.ReadUInt16BigEndian(this.buffer);
         }
 
+        /// <summary>
+        /// Reads a 16-bit unsigned integer from the stream representing an offset position.
+        /// 2 bytes are read.
+        /// </summary>
+        /// <returns>The 16-bit unsigned integer read</returns>
+        public ushort ReadOffset16() => this.ReadUInt16();
+
         public TEnum ReadUInt16<TEnum>() => CastTo<TEnum>.From(this.ReadUInt16());
 
         /// <summary>
-        /// Reads array or 16-bit unsigned integers from the stream.
+        /// Reads array of 16-bit unsigned integers from the stream.
         /// 2 bytes are read.
         /// </summary>
         /// <param name="length">The length.</param>
@@ -189,12 +196,12 @@ public ushort[] ReadUInt16Array(int length)
         }
 
         /// <summary>
-        /// Reads array or 16-bit unsigned integers from the stream.
-        /// 2 bytes are read.
+        /// Reads array or 32-bit unsigned integers from the stream.
+        /// 4 bytes are read.
         /// </summary>
         /// <param name="length">The length.</param>
         /// <returns>
-        /// The 16-bit unsigned integer read
+        /// The 32-bit unsigned integer read
         /// </returns>
         public uint[] ReadUInt32Array(int length)
         {
@@ -278,6 +285,17 @@ public byte ReadUInt8()
             return this.buffer[0];
         }
 
+        /// <summary>
+        /// Reads a 24-bit unsigned integer from the stream, using the bit converter
+        /// for this reader. 3 bytes are read.
+        /// </summary>
+        /// <returns>The 24-bit unsigned integer read.</returns>
+        public int ReadUInt24()
+        {
+            byte highByte = this.ReadByte();
+            return (highByte << 16) | this.ReadUInt16();
+        }
+
         /// <summary>
         /// Reads a 32-bit unsigned integer from the stream, using the bit converter
         /// for this reader. 4 bytes are read.
@@ -290,6 +308,11 @@ public uint ReadUInt32()
             return BinaryPrimitives.ReadUInt32BigEndian(this.buffer);
         }
 
+        /// <summary>
+        /// Reads a 32-bit unsigned integer from the stream representing an offset position.
+        /// 4 bytes are read.
+        /// </summary>
+        /// <returns>The 32-bit unsigned integer read</returns>
         public uint ReadOffset32() => this.ReadUInt32();
 
         /// <summary>

src/SixLabors.Fonts/FontMetrics.cs

@@ -157,8 +157,6 @@ internal FontMetrics(
         /// <inheritdoc/>
         public GlyphMetrics GetGlyphMetrics(CodePoint codePoint)
         {
-            // TODO: Check this. It looks like we could potentially return the metrics
-            // for the glyph at position zero when a matching codepoint cannot be found.
             bool foundGlyph = this.TryGetGlyphIndex(codePoint, out ushort idx);
             if (!foundGlyph)
             {
@@ -320,6 +318,9 @@ public static FontMetrics[] LoadFontCollection(Stream stream)
         internal bool TryGetGlyphIndex(CodePoint codePoint, out ushort glyphId)
             => this.cmap.TryGetGlyphId(codePoint, out glyphId);
 
+        internal bool TryGetGlyphIndex(CodePoint codePoint, CodePoint nextCodePoint, out ushort glyphId, out bool skipNextCodePoint)
+            => this.cmap.TryGetGlyphId(codePoint, nextCodePoint, out glyphId, out skipNextCodePoint);
+
         internal bool TryGetColoredVectors(CodePoint codePoint, ushort idx, [NotNullWhen(true)] out GlyphMetrics[]? vectors)
         {
             if (this.colrTable == null || this.colorGlyphCache == null)

src/SixLabors.Fonts/GlyphSubstitutionCollection.cs

@@ -0,0 +1,142 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Collections.Generic;
+
+namespace SixLabors.Fonts
+{
+    /// <summary>
+    /// Represents a collection of glyph indices that are mapped to input codepoints.
+    /// </summary>
+    internal class GlyphSubstitutionCollection
+    {
+        private readonly List<ushort> glyphIndices = new List<ushort>();
+        private readonly List<int> inputCodePointIndices = new List<int>();
+        private ushort originalCodePointOffset;
+        private readonly List<GlyphIndexToCodePoint> glyphIndexToCodePointMap = new List<GlyphIndexToCodePoint>();
+
+        /// <summary>
+        /// Gets the glyph count.
+        /// This may be more or less than original user codepoint count (from substitution process).
+        /// </summary>
+        public int Count => this.glyphIndices.Count;
+
+        /// <summary>
+        /// Gets the glyph index at the given index.
+        /// </summary>
+        /// <param name="index">The index.</param>
+        /// <returns>The <see cref="ushort"/>.</returns>
+        public ushort this[int index] => this.glyphIndices[index];
+
+        /// <summary>
+        /// Clears the collection.
+        /// </summary>
+        public void Clear()
+        {
+            this.glyphIndices.Clear();
+            this.originalCodePointOffset = 0;
+            this.inputCodePointIndices.Clear();
+            this.glyphIndexToCodePointMap.Clear();
+        }
+
+        /// <summary>
+        /// Add a codepoint index and its glyph index.
+        /// </summary>
+        /// <param name="codePointIndex">Index to codepoint element in code point collection.</param>
+        /// <param name="glyphIndex">Map to glyphindex</param>
+        public void AddGlyph(int codePointIndex, ushort glyphIndex)
+        {
+            // So we can monitor what substituion process
+            this.inputCodePointIndices.Add(codePointIndex);
+            this.glyphIndices.Add(glyphIndex);
+
+            var glyphIndexToCodePointMap = new GlyphIndexToCodePoint(this.originalCodePointOffset, 1);
+            this.glyphIndexToCodePointMap.Add(glyphIndexToCodePointMap);
+            this.originalCodePointOffset++;
+        }
+
+        public void GetGlyphIndexAndMap(int index, out ushort glyphIndex, out ushort codepointOffset, out ushort mapLength)
+        {
+            glyphIndex = this.glyphIndices[index];
+            GlyphIndexToCodePoint glyphIndexToUserCodePoint = this.glyphIndexToCodePointMap[index];
+            codepointOffset = glyphIndexToUserCodePoint.CodePointOffset;
+            mapLength = glyphIndexToUserCodePoint.Length;
+        }
+
+        /// <summary>
+        /// Performs a 1:1 replacement of a glyph index at the given position.
+        /// </summary>
+        /// <param name="index">The zero-based index of the element to replace.</param>
+        /// <param name="newGlyphIndex">The replacement glyph index.</param>
+        public void Replace(int index, ushort newGlyphIndex)
+            => this.glyphIndices[index] = newGlyphIndex;
+
+        /// <summary>
+        /// Replaces a series of glyph indices starting at the given position with a new index.
+        /// </summary>
+        /// <param name="index">The zero-based starting index of the range of elements to replace.</param>
+        /// <param name="count">The number of elements to replace.</param>
+        /// <param name="newGlyphIndex">The replacement glyph index.</param>
+        public void Replace(int index, int count, ushort newGlyphIndex)
+        {
+            // e.g. f-i ligation
+            // original 'f' glyph and 'i' glyph are removed
+            // and then replace with a single glyph.
+            this.glyphIndices.RemoveRange(index, count);
+            this.glyphIndices.Insert(index, newGlyphIndex);
+            GlyphIndexToCodePoint firstRemove = this.glyphIndexToCodePointMap[index];
+
+            var newMap = new GlyphIndexToCodePoint(firstRemove.CodePointOffset, (ushort)count);
+            this.glyphIndexToCodePointMap.RemoveRange(index, count);
+            this.glyphIndexToCodePointMap.Insert(index, newMap);
+        }
+
+        /// <summary>
+        /// Replaces a single glyph index with a collection of glyph indices.
+        /// </summary>
+        /// <param name="index">The zero-based index of the element to replace.</param>
+        /// <param name="newGlyphIndices">The collection of replacement glyph indices.</param>
+        public void Replace(int index, ushort[] newGlyphIndices)
+        {
+            this.glyphIndices.RemoveAt(index);
+            this.glyphIndices.InsertRange(index, newGlyphIndices);
+            GlyphIndexToCodePoint current = this.glyphIndexToCodePointMap[index];
+            this.glyphIndexToCodePointMap.RemoveAt(index);
+
+            // Insert
+            int j = newGlyphIndices.Length;
+            for (int i = 0; i < j; ++i)
+            {
+                var newGlyph = new GlyphIndexToCodePoint(current.CodePointOffset, 1);
+
+                // May point to the same user codepoint.
+                this.glyphIndexToCodePointMap.Insert(index, newGlyph);
+            }
+        }
+
+        /// <summary>
+        /// Maps from glyph index to original user code point.
+        /// </summary>
+        private readonly struct GlyphIndexToCodePoint
+        {
+            public GlyphIndexToCodePoint(ushort codePointOffset, ushort length)
+            {
+                this.CodePointOffset = codePointOffset;
+                this.Length = length;
+            }
+
+            /// <summary>
+            /// Gets the offset from start layout codepoint
+            /// </summary>
+            public ushort CodePointOffset { get; }
+
+            /// <summary>
+            /// Gets the number of codepoints represented by the glyph.
+            /// </summary>
+            public readonly ushort Length { get; }
+
+            public override string ToString()
+                => $"CodePointOffset: {this.CodePointOffset} - Length: {this.Length}";
+        }
+    }
+}

src/SixLabors.Fonts/RendererOptions.cs

@@ -173,7 +173,7 @@ internal AppliedFontStyle GetStyle(int index, int length)
 
             return new AppliedFontStyle
             {
-                Start = 0,
+                Start = index,
                 End = length - 1,
                 PointSize = this.Font.Size,
                 MainFont = this.Font.FontMetrics,

src/SixLabors.Fonts/SixLabors.Fonts.csproj

@@ -19,17 +19,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <None Remove="Unicode\Resources\Bidi.trie" />
-    <None Remove="Unicode\Resources\Grapheme.trie" />
-    <None Remove="Unicode\Resources\LineBreak.trie" />
-    <None Remove="Unicode\Resources\UnicodeCategory.trie" />
+    <None Remove="Unicode\Resources\**" />
   </ItemGroup>
 
   <ItemGroup>
-    <EmbeddedResource Include="Unicode\Resources\Bidi.trie" />
-    <EmbeddedResource Include="Unicode\Resources\Grapheme.trie" />
-    <EmbeddedResource Include="Unicode\Resources\LineBreak.trie" />
-    <EmbeddedResource Include="Unicode\Resources\UnicodeCategory.trie" />
+    <EmbeddedResource Include="Unicode\Resources\**" />
   </ItemGroup>
 
   <ItemGroup>

src/SixLabors.Fonts/Tables/General/CMap/Format12SubTable.cs

@@ -30,7 +30,7 @@ public override bool TryGetGlyphId(CodePoint codePoint, out ushort glyphId)
 
                 if (charAsInt >= seg.StartCodePoint && charAsInt <= seg.EndCodePoint)
                 {
-                    glyphId = (ushort)((charAsInt - seg.StartCodePoint) + seg.StartGlyphId);
+                    glyphId = (ushort)(charAsInt - seg.StartCodePoint + seg.StartGlyphId);
                     return true;
                 }
             }