AtlasEngine: Clip box glyphs to their cells

lhecker · lhecker · commit 1e4b8dc41fbc · 2023-05-15T17:08:12.000+02:00
diff --git a/src/inc/til/flat_set.h b/src/inc/til/flat_set.h
@@ -28,14 +28,19 @@ namespace til
     // A basic, hashmap with linear probing. A `LoadFactor` of 2 equals
     // a max. load of roughly 50% and a `LoadFactor` of 4 roughly 25%.
     //
+    // `GrowthExponent` controls how fast the set grows and corresponds to
+    // a rate of 2^GrowthExponent. In other words, a `GrowthExponent` of 3
+    // equals a growth rate of 8x every time the capacity has been reached.
+    //
     // It performs best with:
     // * small and cheap T
     // * >= 50% successful lookups
     // * <= 50% load factor (LoadFactor >= 2, which is the minimum anyways)
-    template<typename T, size_t LoadFactor = 2>
+    template<typename T, size_t LoadFactor = 2, size_t GrowthExponent = 1>
     struct linear_flat_set
     {
         static_assert(LoadFactor >= 2);
+        static_assert(GrowthExponent >= 1);
 
         linear_flat_set() = default;
 
@@ -85,6 +90,30 @@ namespace til
             }
         }
 
+        template<typename U>
+        T* lookup(U&& key) const noexcept
+        {
+            if (!_map)
+            {
+                return nullptr;
+            }
+
+            const auto hash = ::std::hash<T>{}(key) >> _shift;
+
+            for (auto i = hash;; ++i)
+            {
+                auto& slot = _map[i & _mask];
+                if (!slot)
+                {
+                    return nullptr;
+                }
+                if (slot == key) [[likely]]
+                {
+                    return &slot;
+                }
+            }
+        }
+
         template<typename U>
         std::pair<T&, bool> insert(U&& key)
         {
@@ -121,14 +150,15 @@ namespace til
     private:
         __declspec(noinline) void _bumpSize()
         {
+            // For instance at a GrowthExponent of 1:
             // A _shift of 0 would result in a newShift of 0xfffff...
             // A _shift of 1 would result in a newCapacity of 0
-            if (_shift < 2)
+            if (_shift <= GrowthExponent)
             {
                 throw std::bad_array_new_length{};
             }
 
-            const auto newShift = _shift - 1;
+            const auto newShift = _shift - GrowthExponent;
             const auto newCapacity = size_t{ 1 } << (digits - newShift);
             const auto newMask = newCapacity - 1;
             auto newMap = std::make_unique<T[]>(newCapacity);
@@ -161,12 +191,13 @@ namespace til
         }
 
         static constexpr auto digits = std::numeric_limits<size_t>::digits;
+        // This results in an initial capacity of 8 items, independent of the LoadFactor.
+        static constexpr auto initialShift = digits - LoadFactor - 1;
 
         std::unique_ptr<T[]> _map;
         size_t _capacity = 0;
         size_t _load = 0;
-        // This results in an initial capacity of 8 items, independent of the LoadFactor.
-        size_t _shift = digits - LoadFactor - 1;
+        size_t _shift = initialShift;
         size_t _mask = 0;
     };
 }
diff --git a/src/renderer/atlas/BackendD3D.cpp b/src/renderer/atlas/BackendD3D.cpp
@@ -36,10 +36,23 @@ TIL_FAST_MATH_BEGIN
 #pragma warning(disable : 26481) // Don't use pointer arithmetic. Use span instead (bounds.1).
 #pragma warning(disable : 26482) // Only index into arrays using constant expressions (bounds.2).
 
+// Initializing large arrays can be very costly compared to how cheap some of these functions are.
+#define ALLOW_UNINITIALIZED_BEGIN _Pragma("warning(push)") _Pragma("warning(disable : 26494)")
+#define ALLOW_UNINITIALIZED_END _Pragma("warning(pop)")
+
 using namespace Microsoft::Console::Render::Atlas;
 
 template<>
-struct ::std::hash<BackendD3D::AtlasGlyphEntry>
+struct std::hash<u16>
+{
+    constexpr size_t operator()(u16 key) const noexcept
+    {
+        return til::flat_set_hash_integer(key);
+    }
+};
+
+template<>
+struct std::hash<BackendD3D::AtlasGlyphEntry>
 {
     constexpr size_t operator()(u16 key) const noexcept
     {
@@ -53,7 +66,7 @@ struct ::std::hash<BackendD3D::AtlasGlyphEntry>
 };
 
 template<>
-struct ::std::hash<BackendD3D::AtlasFontFaceEntry>
+struct std::hash<BackendD3D::AtlasFontFaceEntry>
 {
     using T = BackendD3D::AtlasFontFaceEntry;
 
@@ -982,7 +995,13 @@ void BackendD3D::_drawText(RenderingPayload& p)
         // We need to goto here, because a retry will cause the atlas texture as well as the
         // _glyphCache hashmap to be cleared, and so we'll have to call insert() again.
         drawGlyphRetry:
-            auto& fontFaceEntry = *_glyphAtlasMap.insert(fontFaceKey).first.inner;
+            const auto [fontFaceEntryOuter, fontFaceInserted] = _glyphAtlasMap.insert(fontFaceKey);
+            auto& fontFaceEntry = *fontFaceEntryOuter.inner;
+
+            if (fontFaceInserted)
+            {
+                _initializeFontFaceEntry(fontFaceEntry);
+            }
 
             while (x < m.glyphsTo)
             {
@@ -1124,7 +1143,30 @@ void BackendD3D::_drawTextOverlapSplit(const RenderingPayload& p, u16 y)
     }
 }
 
-bool BackendD3D::_drawGlyph(const RenderingPayload& p, const BackendD3D::AtlasFontFaceEntryInner& fontFaceEntry, BackendD3D::AtlasGlyphEntry& glyphEntry)
+void BackendD3D::_initializeFontFaceEntry(AtlasFontFaceEntryInner& fontFaceEntry)
+{
+    ALLOW_UNINITIALIZED_BEGIN
+    std::array<u32, 0x100> codepoints;
+    std::array<u16, 0x100> indices;
+    ALLOW_UNINITIALIZED_END
+
+    for (u32 i = 0; i < codepoints.size(); ++i)
+    {
+        codepoints[i] = 0x2500 + i;
+    }
+
+    THROW_IF_FAILED(fontFaceEntry.fontFace->GetGlyphIndicesW(codepoints.data(), codepoints.size(), indices.data()));
+
+    for (u32 i = 0; i < indices.size(); ++i)
+    {
+        if (const auto idx = indices[i])
+        {
+            fontFaceEntry.boxGlyphs.insert(idx);
+        }
+    }
+}
+
+bool BackendD3D::_drawGlyph(const RenderingPayload& p, const AtlasFontFaceEntryInner& fontFaceEntry, AtlasGlyphEntry& glyphEntry)
 {
     if (!fontFaceEntry.fontFace)
     {
@@ -1246,7 +1288,7 @@ bool BackendD3D::_drawGlyph(const RenderingPayload& p, const BackendD3D::AtlasFo
     bool isColorGlyph = false;
     D2D1_RECT_F bounds = GlyphRunEmptyBounds;
 
-    const auto cleanup = wil::scope_exit([&]() {
+    const auto antialiasingCleanup = wil::scope_exit([&]() {
         if (isColorGlyph)
         {
             _d2dRenderTarget4->SetTextAntialiasMode(static_cast<D2D1_TEXT_ANTIALIAS_MODE>(p.s->font->antialiasingMode));
@@ -1273,7 +1315,23 @@ bool BackendD3D::_drawGlyph(const RenderingPayload& p, const BackendD3D::AtlasFo
         }
     }
 
-    // box may be empty if the glyph is whitespace.
+    // Overhangs for box glyphs can produce unsightly effects, where the antialiased edges of horizontal
+    // and vertical lines overlap between neighboring glyphs and produce "boldened" intersections.
+    // It looks a little something like this:
+    //   ---+---+---
+    // This avoids the issue in most cases by simply clipping the glyph to the size of a single cell.
+    // The downside is that it fails to work well for custom line heights, etc.
+    const auto isBoxGlyph = fontFaceEntry.boxGlyphs.lookup(glyphEntry.glyphIndex) != nullptr;
+    if (isBoxGlyph)
+    {
+        // NOTE: As mentioned above, the "origin" of a glyph's coordinate system is its baseline.
+        bounds.left = std::max(bounds.left, 0.0f);
+        bounds.top = std::max(bounds.top, static_cast<f32>(-p.s->font->baseline));
+        bounds.right = std::min(bounds.right, static_cast<f32>(p.s->font->cellSize.x));
+        bounds.bottom = std::min(bounds.bottom, static_cast<f32>(p.s->font->descender));
+    }
+
+    // The bounds may be empty if the glyph is whitespace.
     if (bounds.left >= bounds.right || bounds.top >= bounds.bottom)
     {
         return true;
@@ -1309,6 +1367,23 @@ bool BackendD3D::_drawGlyph(const RenderingPayload& p, const BackendD3D::AtlasFo
 
     _d2dBeginDrawing();
 
+    if (isBoxGlyph)
+    {
+        const D2D1_RECT_F clipRect{
+            static_cast<f32>(rect.x),
+            static_cast<f32>(rect.y),
+            static_cast<f32>(rect.x + rect.w),
+            static_cast<f32>(rect.y + rect.h),
+        };
+        _d2dRenderTarget4->PushAxisAlignedClip(&clipRect, D2D1_ANTIALIAS_MODE_ALIASED);
+    }
+    const auto boxGlyphCleanup = wil::scope_exit([&]() {
+        if (isBoxGlyph)
+        {
+            _d2dRenderTarget4->PopAxisAlignedClip();
+        }
+    });
+
     if (!isColorGlyph)
     {
         _d2dRenderTarget->DrawGlyphRun(baselineOrigin, &glyphRun, _brush.get(), DWRITE_MEASURING_MODE_NATURAL);
diff --git a/src/renderer/atlas/BackendD3D.h b/src/renderer/atlas/BackendD3D.h
@@ -151,6 +151,9 @@ namespace Microsoft::Console::Render::Atlas
             LineRendition lineRendition = LineRendition::SingleWidth;
 
             til::linear_flat_set<AtlasGlyphEntry> glyphs;
+            // boxGlyphs gets an increased growth rate of 2^2 = 4x, because presumably fonts either contain very
+            // few or almost all of the box glyphs. This reduces the cost of _initializeFontFaceEntry quite a bit.
+            til::linear_flat_set<u16, 2, 2> boxGlyphs;
         };
 
         struct AtlasFontFaceEntry
@@ -214,6 +217,7 @@ namespace Microsoft::Console::Render::Atlas
         void _uploadBackgroundBitmap(const RenderingPayload& p);
         void _drawText(RenderingPayload& p);
         ATLAS_ATTR_COLD void _drawTextOverlapSplit(const RenderingPayload& p, u16 y);
+        ATLAS_ATTR_COLD static void _initializeFontFaceEntry(AtlasFontFaceEntryInner& fontFaceEntry);
         ATLAS_ATTR_COLD [[nodiscard]] bool _drawGlyph(const RenderingPayload& p, const AtlasFontFaceEntryInner& fontFaceEntry, AtlasGlyphEntry& glyphEntry);
         bool _drawSoftFontGlyph(const RenderingPayload& p, const AtlasFontFaceEntryInner& fontFaceEntry, AtlasGlyphEntry& glyphEntry);
         void _drawGlyphPrepareRetry(const RenderingPayload& p);
