feat(D.2b): UI render infra — overlay layer, DrawFill, crisp text, write-mode focus

The retail-look render + focus primitives this chat pass builds on:

- TextRenderer: an OVERLAY layer (sprite/rect/text buckets flushed AFTER the
  normal layer) so an open popup composites on top of everything incl. rect
  panel backgrounds; a DrawFill primitive (solid quad via a 1x1 white texture)
  routed through the SPRITE bucket so a panel background draws UNDER its text
  instead of being washed by the later rect bucket; and the text pass now
  disables SampleAlphaToCoverage + Multisample so glyph alpha edges aren't
  dithered into MSAA coverage (the "fuzzy text") — self-contained GL state
  per feedback_render_self_contained_gl_state.
- UiRenderContext.DrawStringDat: snap the line baseline to a whole pixel ONCE
  then add the integer per-glyph offset (retail DrawCharacter takes an int
  pen-Y + schar m_VerticalOffsetBefore) — fixes the "letters dip down" jitter
  at a fractional line origin. Outline pass is now opt-in (retail gates it per
  element via SetOutline; default off = crisp fill-only). Adds DrawFill +
  Begin/EndOverlayLayer.
- UiElement: OnDrawOverlay + DrawOverlays (second traversal), FindRoot (blur
  self), ResetAnchorCapture (re-baseline an anchored element after reflow).
- UiRoot: runs the overlay pass after the main tree; Tab/Enter focuses the
  DefaultTextInput (write-mode activation); a left click on a non-edit target
  blurs the focused input (exit write mode without submitting).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

src/AcDream.App/UI/UiRenderContext.cs

@@ -68,11 +68,23 @@ public sealed class UiRenderContext
 
     public Vector2 CurrentOrigin => _current;
 
+    /// <summary>Route subsequent draws to the overlay layer (flushed on top of the whole
+    /// UI). Used by the root for the popup/overlay traversal. Pair with <see cref="EndOverlayLayer"/>.</summary>
+    public void BeginOverlayLayer() => TextRenderer.OverlayMode = true;
+    public void EndOverlayLayer() => TextRenderer.OverlayMode = false;
+
     // ── Pass-through draw helpers (add current translate) ──────────────
 
     public void DrawRect(float x, float y, float w, float h, Vector4 color)
         => TextRenderer.DrawRect(_current.X + x, _current.Y + y, w, h, ApplyAlpha(color));
 
+    /// <summary>Solid-colour fill drawn in the SPRITE bucket (painter order with text), for
+    /// a panel BACKGROUND that text draws on top of. <see cref="DrawRect"/> composites after
+    /// all sprites and would cover the text — use this for backgrounds, that for foreground
+    /// fills (carets, vital bars).</summary>
+    public void DrawFill(float x, float y, float w, float h, Vector4 color)
+        => TextRenderer.DrawFill(_current.X + x, _current.Y + y, w, h, ApplyAlpha(color));
+
     public void DrawRectOutline(float x, float y, float w, float h, Vector4 color, float thickness = 1f)
         => TextRenderer.DrawRectOutline(_current.X + x, _current.Y + y, w, h, ApplyAlpha(color), thickness);
 
@@ -102,10 +114,17 @@ public sealed class UiRenderContext
     /// <c>HorizontalOffsetBefore + Width + HorizontalOffsetAfter</c> and each
     /// glyph is positioned at <c>pen + HorizontalOffsetBefore</c> on the X axis
     /// and at <c>baseline + VerticalOffsetBefore - (BaselineOffset)</c> via the
-    /// glyph's OffsetY into the atlas. If the font has no background atlas the
-    /// outline pass is skipped.
+    /// glyph's OffsetY into the atlas.
+    ///
+    /// <para><paramref name="outline"/> gates the black outline pass. Retail decides
+    /// this PER text element: <c>UIElement_Text::DrawSelf</c> (acclient 0x00467aa0)
+    /// runs the outline pass only when <c>m_bitField &amp; 0x10</c> is set — i.e. the
+    /// element called <c>SetOutline(true)</c> (LayoutDesc property 0xd). The DEFAULT
+    /// is OFF (one fill-only pass): the talk-focus menu items set no outline, so an
+    /// always-on outline shows as a grey halo over the solid menu panel. Pass
+    /// <c>outline:true</c> only for elements retail outlines.</para>
     /// </summary>
-    public void DrawStringDat(UiDatFont font, string text, float x, float y, Vector4 color)
+    public void DrawStringDat(UiDatFont font, string text, float x, float y, Vector4 color, bool outline = false)
     {
         if (font is null || string.IsNullOrEmpty(text)) return;
 
@@ -116,32 +135,44 @@ public sealed class UiRenderContext
         float originY = _current.Y + y;
         float pen = originX;
 
-        var outline = new Vector4(0f, 0f, 0f, color.W);
+        // Snap the LINE baseline to a whole pixel ONCE. Retail's
+        // SurfaceWindow::DrawCharacter (acclient 0x00442bd0) takes an int32 pen Y
+        // (arg3) and adds the glyph's integer m_VerticalOffsetBefore (a schar) — every
+        // glyph on a line shares one integer baseline. If we instead round EACH glyph's
+        // Y independently and the caller passes a fractional line Y (e.g. a channel-menu
+        // item centered in a 17px row over a 16px font → y = 0.5), adjacent letters round
+        // to different rows and the line looks crooked ("letters dip down"). The vitals
+        // digits never showed it because their bar baseline lands on an integer; chat text
+        // does. Snapping the baseline once, then adding the integer offset, keeps the whole
+        // line on one row and pixel-aligned.
+        float baseY = System.MathF.Round(originY);
+
+        var outlineTint = new Vector4(0f, 0f, 0f, color.W);
 
         for (int i = 0; i < text.Length; i++)
         {
             if (!font.TryGetGlyph(text[i], out var g))
                 continue;
 
-            // Pixel-snap each glyph's destination to whole pixels so the atlas samples
-            // texel-aligned. Without this, a fractional bar width after resize puts the
-            // centered number on a sub-pixel x and linear filtering smears the glyphs
-            // (the "unsharp at certain sizes" artifact). The pen keeps its true
-            // fractional advance, so only the per-glyph dest is snapped.
+            // Horizontal: snap each glyph's dest X to a whole pixel (the pen keeps its
+            // true fractional advance). Vertical: integer baseline + integer per-glyph
+            // offset — never an independent per-glyph round (see baseY note above).
             float gx = System.MathF.Round(pen + g.HorizontalOffsetBefore);
-            float gy = System.MathF.Round(originY + g.VerticalOffsetBefore);
+            float gy = baseY + g.VerticalOffsetBefore;
             float gw = g.Width;
             float gh = g.Height;
 
             if (gw > 0f && gh > 0f)
             {
-                // Background (outline) atlas pass, tinted black — drawn behind.
-                if (font.BackgroundTexture != 0)
+                // Background (outline) atlas pass, tinted black — drawn behind. Gated by
+                // `outline` (retail's per-element m_bitField & 0x10); off by default so UI
+                // text is crisp fill-only and free of the grey halo over solid panels.
+                if (outline && font.BackgroundTexture != 0)
                 {
                     var (bu0, bv0, bu1, bv1) = AtlasUv(
                         g.OffsetX, g.OffsetY, g.Width, g.Height,
                         font.BackgroundWidth, font.BackgroundHeight);
-                    TextRenderer.DrawSprite(font.BackgroundTexture, gx, gy, gw, gh, bu0, bv0, bu1, bv1, outline);
+                    TextRenderer.DrawSprite(font.BackgroundTexture, gx, gy, gw, gh, bu0, bv0, bu1, bv1, outlineTint);
                 }
 
                 // Foreground (fill) atlas pass, tinted with the requested color.