Merge pull request AristurtleDev#4 from AristurtleDev/feature/dialation

Add dynamic glyph dilation to prevent thin strokes

Author: AristurtleDev

Directory.Build.props

@@ -8,7 +8,7 @@
 
     <!-- Version Configuration -->
     <PropertyGroup>
-        <Version>0.0.1</Version>
+        <Version>0.0.2</Version>
         <MonoGameVersion>3.8.4.1</MonoGameVersion>
     </PropertyGroup>
 

src/Forme.MonoGame/FormeFontDevice.cs

@@ -23,6 +23,11 @@ namespace Forme.MonoGame;
 /// <see cref="SurfaceFormat.Vector4"/> with RG32F data packed into XY and ZW set to zero;
 /// this is required because SM3/MojoShader cannot sample RG32F directly.
 /// </para>
+/// <para>
+/// The band LUT texture uses <see cref="SurfaceFormat.Vector4"/> (RGBA32F) and stores
+/// per-glyph band transform data (bandScaleX, bandScaleY, bandOffsetX, bandOffsetY) indexed
+/// by glyph.
+/// </para>
 /// </remarks>
 public sealed class FormeFontDevice : IDisposable
 {
@@ -41,11 +46,25 @@ public sealed class FormeFontDevice : IDisposable
     /// </summary>
     public Texture2D BandTexture { get; }
 
+    /// <summary>
+    /// Gets the band LUT texture containing per-glyph band transform data (RGBA32F).
+    /// </summary>
+    /// <remarks>
+    /// Each texel stores (bandScaleX, bandScaleY, bandOffsetX, bandOffsetY) for one glyph.
+    /// The texture is at most 4096 texels wide; tall fonts use multiple rows.
+    /// </remarks>
+    public Texture2D BandLutTexture { get; }
+
     /// <summary>
     /// Gets the glyph metadata dictionary, keyed by Unicode code point.
     /// </summary>
     public IReadOnlyDictionary<int, FormeGlyph> Glyphs { get; }
 
+    /// <summary>
+    /// Gets the precomputed band LUT UV coordinates, keyed by Unicode code point.
+    /// </summary>
+    internal IReadOnlyDictionary<int, Vector2> GlyphLutUVs { get; }
+
     /// <summary>
     /// Gets the font metrics (ascent, descent, units per em).
     /// </summary>
@@ -79,6 +98,9 @@ public FormeFontDevice(GraphicsDevice graphicsDevice, FormeFont font)
 
         CurveTexture = UploadCurveTexture(graphicsDevice, font);
         BandTexture = UploadBandTexture(graphicsDevice, font);
+
+        BandLutTexture = BuildBandLut(graphicsDevice, font, out Dictionary<int, Vector2> glyphLutUVs);
+        GlyphLutUVs = glyphLutUVs;
     }
 
     private static Texture2D UploadCurveTexture(GraphicsDevice graphicsDevice, FormeFont font)
@@ -128,6 +150,40 @@ private static Texture2D UploadBandTexture(GraphicsDevice graphicsDevice, FormeF
         return texture;
     }
 
+    private static Texture2D BuildBandLut(
+        GraphicsDevice graphicsDevice, FormeFont font, out Dictionary<int, Vector2> uvs)
+    {
+        int glyphCount = Math.Max(1, font.Glyphs.Count);
+        int lutWidth   = Math.Min(glyphCount, 4096);
+        int lutHeight  = (glyphCount + 4095) / 4096;
+
+        Vector4[] data = new Vector4[lutWidth * lutHeight];
+        uvs = new Dictionary<int, Vector2>(glyphCount);
+
+        int index = 0;
+        foreach (KeyValuePair<int, FormeGlyph> kvp in font.Glyphs)
+        {
+            FormeGlyph g = kvp.Value;
+            float scaleX = 1.0f / Math.Max(1f, (float)g.BandInfo.DimX);
+            float scaleY = 1.0f / Math.Max(1f, (float)g.BandInfo.DimY);
+            data[index] = new Vector4(
+                scaleX,
+                scaleY,
+                -(float)g.BoundingBox.X1 * scaleX,
+                -(float)g.BoundingBox.Y1 * scaleY);
+
+            float u = (index % 4096 + 0.5f) / lutWidth;
+            float v = (index / 4096 + 0.5f) / lutHeight;
+            uvs[kvp.Key] = new Vector2(u, v);
+            index++;
+        }
+
+        Texture2D texture = new Texture2D(
+            graphicsDevice, lutWidth, lutHeight, false, SurfaceFormat.Vector4);
+        texture.SetData(data);
+        return texture;
+    }
+
     /// <summary>
     /// Releases the GPU textures owned by this instance.
     /// </summary>
@@ -141,5 +197,6 @@ public void Dispose()
         IsDisposed = true;
         CurveTexture.Dispose();
         BandTexture.Dispose();
+        BandLutTexture.Dispose();
     }
 }

src/Forme.MonoGame/FormeRenderer.cs

@@ -48,6 +48,7 @@ public sealed class FormeRenderer : IDisposable
     private RasterizerState? _savedRasterizerState;
     private SamplerState? _savedSamplerState0;
     private SamplerState? _savedSamplerState1;
+    private SamplerState? _savedSamplerState2;
 
     private Matrix _transformMatrix;
     private bool _hasCustomTransform;
@@ -148,6 +149,7 @@ public void Begin(Matrix? transformMatrix = null)
         _savedRasterizerState = _graphicsDevice.RasterizerState;
         _savedSamplerState0 = _graphicsDevice.SamplerStates[0];
         _savedSamplerState1 = _graphicsDevice.SamplerStates[1];
+        _savedSamplerState2 = _graphicsDevice.SamplerStates[2];
 
         if (transformMatrix.HasValue)
         {
@@ -205,7 +207,7 @@ public void DrawString(FormeFontDevice font, string text, Vector2 position, floa
 
             if (font.Glyphs.TryGetValue(rune.Value, out FormeGlyph glyph))
             {
-                _queue.Add(new QueuedDraw(font, glyph, new Vector2(cursorX, position.Y), sizePixels, color));
+                _queue.Add(new QueuedDraw(font, glyph, rune.Value, new Vector2(cursorX, position.Y), sizePixels, color));
                 cursorX += glyph.AdvanceWidth * scale;
             }
         }
@@ -254,7 +256,7 @@ public void DrawString(FormeFontDevice font, string text, Vector2 position, floa
             }
 
             Vector2 glyphPos = new(position.X + placement.BaselineX, position.Y + placement.BaselineY);
-            _queue.Add(new QueuedDraw(font, glyph, glyphPos, sizePixels, color));
+            _queue.Add(new QueuedDraw(font, glyph, placement.CodePoint, glyphPos, sizePixels, color));
         }
     }
 
@@ -289,7 +291,7 @@ public void DrawGlyph(FormeFontDevice font, int codepoint, Vector2 position, flo
 
         if (font.Glyphs.TryGetValue(codepoint, out FormeGlyph glyph))
         {
-            _queue.Add(new QueuedDraw(font, glyph, position, sizePixels, color));
+            _queue.Add(new QueuedDraw(font, glyph, codepoint, position, sizePixels, color));
         }
     }
 
@@ -318,6 +320,7 @@ public void End()
         _graphicsDevice.RasterizerState = RasterizerState.CullNone;
         _graphicsDevice.SamplerStates[0] = SamplerState.PointClamp;
         _graphicsDevice.SamplerStates[1] = SamplerState.PointClamp;
+        _graphicsDevice.SamplerStates[2] = SamplerState.PointClamp;
 
         FormeFontDevice? currentFont = null;
         _glyphCount = 0;
@@ -354,6 +357,7 @@ public void End()
         _graphicsDevice.RasterizerState = _savedRasterizerState!;
         _graphicsDevice.SamplerStates[0] = _savedSamplerState0!;
         _graphicsDevice.SamplerStates[1] = _savedSamplerState1!;
+        _graphicsDevice.SamplerStates[2] = _savedSamplerState2!;
     }
 
     private void FlushBatch(FormeFontDevice font)
@@ -379,6 +383,7 @@ private void FlushBatch(FormeFontDevice font)
         _effect.Parameters["forme_matrix"].SetValue(matrix);
         _effect.Parameters["curveTexture"].SetValue(font.CurveTexture);
         _effect.Parameters["bandTexture"].SetValue(font.BandTexture);
+        _effect.Parameters["bandLUTTexture"].SetValue(font.BandLutTexture);
 
         // curveTexSize and bandTexSize are used by the OpenGL shader for UV-based texel
         // sampling but are not present in the DirectX 11 shader, which uses Load() instead.
@@ -433,11 +438,6 @@ private bool AppendGlyphQuad(in QueuedDraw draw)
         float ex1 = g.BoundingBox.X2;
         float ey1 = g.BoundingBox.Y2;
 
-        float bandScaleX = 1.0f / Math.Max(1f, (float)g.BandInfo.DimX);
-        float bandScaleY = 1.0f / Math.Max(1f, (float)g.BandInfo.DimY);
-        float bandOffsetX = -(float)g.BoundingBox.X1 * bandScaleX;
-        float bandOffsetY = -(float)g.BoundingBox.Y1 * bandScaleY;
-
         // Pack band texture origin using the texture width as the row stride.
         // The shader unpacks this using the runtime uniform bandTexSize.x, avoiding
         // compile-time constant folding that the MGCB/MojoShader transpiler gets wrong.
@@ -456,7 +456,15 @@ private bool AppendGlyphQuad(in QueuedDraw draw)
             draw.Color.B / 255f,
             draw.Color.A / 255f);
 
-        Vector4 bnd = new Vector4(bandScaleX, bandScaleY, bandOffsetX, bandOffsetY);
+        // Inverse Jacobian: maps a screen-space displacement to an em-space displacement.
+        float invJxx =  (ex1 - ex0) / (px1 - px0);
+        float invJyy =  (ey0 - ey1) / (py1 - py0);  // negative; font Y up, screen Y down
+
+        Vector2 lutUV = draw.Font.GlyphLutUVs.TryGetValue(draw.CodePoint, out Vector2 uv)
+            ? uv
+            : Vector2.Zero;
+
+        Vector4 dilation = new Vector4(lutUV.X, lutUV.Y, invJxx, invJyy);
 
         int baseVertex = _glyphCount * 4;
 
@@ -465,31 +473,31 @@ private bool AppendGlyphQuad(in QueuedDraw draw)
             Pos = new Vector4(px0, py0, -InvSqrt2, -InvSqrt2),
             Tex = new Vector4(ex0, ey1, packedBandTexLoc, packedBandCount),
             Color = color,
-            Bnd = bnd
+            Dilation = dilation
         };
 
         _vertices[baseVertex + 1] = new FormeVertex
         {
             Pos = new Vector4(px1, py0, InvSqrt2, -InvSqrt2),
             Tex = new Vector4(ex1, ey1, packedBandTexLoc, packedBandCount),
             Color = color,
-            Bnd = bnd
+            Dilation = dilation
         };
 
         _vertices[baseVertex + 2] = new FormeVertex
         {
             Pos = new Vector4(px1, py1, InvSqrt2, InvSqrt2),
             Tex = new Vector4(ex1, ey0, packedBandTexLoc, packedBandCount),
             Color = color,
-            Bnd = bnd
+            Dilation = dilation
         };
 
         _vertices[baseVertex + 3] = new FormeVertex
         {
             Pos = new Vector4(px0, py1, -InvSqrt2, InvSqrt2),
             Tex = new Vector4(ex0, ey0, packedBandTexLoc, packedBandCount),
             Color = color,
-            Bnd = bnd
+            Dilation = dilation
         };
 
         int baseIndex = _glyphCount * 6;
@@ -534,14 +542,16 @@ private readonly struct QueuedDraw
     {
         internal FormeFontDevice Font { get; }
         internal FormeGlyph Glyph { get; }
+        internal int CodePoint { get; }
         internal Vector2 Position { get; }
         internal float SizePixels { get; }
         internal Color Color { get; }
 
-        internal QueuedDraw(FormeFontDevice font, FormeGlyph glyph, Vector2 position, float sizePixels, Color color)
+        internal QueuedDraw(FormeFontDevice font, FormeGlyph glyph, int codePoint, Vector2 position, float sizePixels, Color color)
         {
             Font = font;
             Glyph = glyph;
+            CodePoint = codePoint;
             Position = position;
             SizePixels = sizePixels;
             Color = color;

src/Forme.MonoGame/FormeVertex.cs

@@ -16,8 +16,8 @@ internal struct FormeVertex
     // TEXCOORD1: xyzw = normalized RGBA color (R/255, G/255, B/255, A/255)
     internal Vector4 Color;
 
-    // TEXCOORD2: bandScaleX, bandScaleY, bandOffsetX, bandOffsetY
-    internal Vector4 Bnd;
+    // TEXCOORD2: x=band LUT U, y=band LUT V, z=invJxx, w=invJyy
+    internal Vector4 Dilation;
 
     internal const int SizeInBytes = 4 * 4 * 4;
 

src/Forme.MonoGame/Shaders/FormeShader.dx11.mgfxo

@@ -16,7 +16,7 @@
 //   POSITION0: pos.xy = object-space position, pos.zw = outward corner normal
 //   TEXCOORD0: tex.xy = em-space sample coords, tex.z = packed band tex location, tex.w = band count
 //   TEXCOORD1: color.xyzw = normalized RGBA (R/255, G/255, B/255, A/255)
-//   TEXCOORD2: bnd = (bandScaleX, bandScaleY, bandOffsetX, bandOffsetY)
+//   TEXCOORD2: dil = (lutU, lutV, invJxx, invJyy)
 //
 // This shader targets SM3 for OpenGL and SM4 for DirectX 11. No integer bitwise ops are used
 // so that the shader compiles cleanly at SM3 where they are unavailable.
@@ -54,6 +54,17 @@ sampler2D bandSampler = sampler_state
     AddressV  = Clamp;
 };
 
+texture2D bandLUTTexture;
+sampler2D bandLUTSampler = sampler_state
+{
+    Texture   = <bandLUTTexture>;
+    MinFilter = Point;
+    MagFilter = Point;
+    MipFilter = None;
+    AddressU  = Clamp;
+    AddressV  = Clamp;
+};
+
 float2 curveTexSize;   // (width, height) in texels
 float2 bandTexSize;    // (width, height) in texels
 
@@ -62,37 +73,27 @@ struct VSInput
     float4 pos   : POSITION0;  // xy = position, zw = outward corner normal
     float4 tex   : TEXCOORD0;  // xy = em-space coords, z = packed band tex location, w = band count
     float4 color : TEXCOORD1;  // normalized RGBA color
-    float4 bnd   : TEXCOORD2;  // bandScaleX, bandScaleY, bandOffsetX, bandOffsetY
+    float4 dil   : TEXCOORD2;  // x=lutU, y=lutV, z=invJxx, w=invJyy
 };
 
 struct VSOutput
 {
     float4 position : SV_POSITION;
-    float2 texcoord : TEXCOORD0;  // em-space sample coords
-    float4 banding  : TEXCOORD1;  // band transform
-    float4 glyphLoc : TEXCOORD2;  // packed band texture location and band count
-    float4 color    : TEXCOORD3;  // RGBA color
+    float2 texcoord : TEXCOORD0;  // em-space sample coords (dilated)
+    float4 glyphLoc : TEXCOORD1;  // xy=packed band tex loc + band count, zw=band LUT UV
+    float4 color    : TEXCOORD2;  // RGBA color
 };
 
 VSOutput VS_Main(VSInput input)
 {
     VSOutput output;
 
-    // NOTE:
-    //      Dynamic dilation (Lengyel 2017, Section 4) is not implemented.
-    //      The math assumes a perspective projection to compute a half-pixel
-    //      outward displacement along the vertex normal, but with an orthographic
-    //      projection the intermediate values diverge and corrupt glyph geometry.
-    //
-    //      Dilation is a cosmetic sub-pixel refinement and not required for
-    //      correct coverage rendering.
-    //
-    //      If you can get it working with orthographic projection, please open
-    //      a pull request.
-    output.position = mul(float4(input.pos.xy, 0, 1), forme_matrix);
-    output.texcoord = input.tex.xy;
-    output.glyphLoc = float4(input.tex.z, input.tex.w, 0.0, 0.0);
-    output.banding  = input.bnd;
+    float2 n            = input.pos.zw;
+    float2 screenOffset = n * 0.5;
+
+    output.position = mul(float4(input.pos.xy + screenOffset, 0, 1), forme_matrix);
+    output.texcoord = input.tex.xy + screenOffset * float2(input.dil.z, input.dil.w);
+    output.glyphLoc = float4(input.tex.z, input.tex.w, input.dil.x, input.dil.y);
     output.color    = input.color;
 
     return output;
@@ -263,7 +264,8 @@ float FormeRender(float2 renderCoord, float4 bandTransform, float4 glyphTexInfo)
 
 float4 PS_Main(VSOutput input) : COLOR0
 {
-    float  coverage = FormeRender(input.texcoord, input.banding, input.glyphLoc);
+    float4 bandTransform = tex2D(bandLUTSampler, input.glyphLoc.zw);
+    float  coverage      = FormeRender(input.texcoord, bandTransform, input.glyphLoc);
     return float4(input.color.rgb * coverage, coverage * input.color.a);
 }