AtlasEngine: Implement LRU invalidation for glyph tiles

src/renderer/atlas/AtlasEngine.cpp

@@ -1402,7 +1402,7 @@ void AtlasEngine::_emplaceGlyph(IDWriteFontFace* fontFace, size_t bufferPos1, si
     attributes.cellCount = cellCount;
 
     AtlasKey key{ attributes, gsl::narrow<u16>(charCount), chars };
-    auto valueRef = _r.glyphs.find(key);
+    const AtlasValue* valueRef = _r.glyphs.find(key);
 
     if (!valueRef)
     {
@@ -1432,8 +1432,12 @@ void AtlasEngine::_emplaceGlyph(IDWriteFontFace* fontFace, size_t bufferPos1, si
             WI_SetFlagIf(flags, CellFlags::ColoredGlyph, fontFace2 && fontFace2->IsColorFont());
         }
 
+        // The AtlasValue constructor fills the `coords` variable with a pointer to an array
+        // of at least `cellCount` elements. I did this so that I don't have to type out
+        // `value.data()->coords` again, despite the constructor having all the data necessary.
         u16x2* coords;
         AtlasValue value{ flags, cellCount, &coords };
+
         for (u16 i = 0; i < cellCount; ++i)
         {
             coords[i] = _r.tileAllocator.allocate(_r.glyphs);

src/renderer/atlas/AtlasEngine.h

@@ -560,6 +560,7 @@ namespace Microsoft::Console::Render
                 const auto it = _map.find(key);
                 if (it != _map.end())
                 {
+                    // Move the key to the head of the LRU queue.
                     _lru.splice(_lru.begin(), _lru, *it);
                     return &(*it)->second;
                 }
@@ -568,8 +569,10 @@ namespace Microsoft::Console::Render
 
             std::list<std::pair<AtlasKey, AtlasValue>>::iterator insert(AtlasKey&& key, AtlasValue&& value)
             {
-                // && decays to & when passed as an argument to emplace().
-                // What a fantastic language.
+                // Insert the key/value right at the head of the LRU queue, just like find().
+                //
+                // && decays to & if the argument is named, because C++ is a simple language
+                // and so you have to std::move it again, because C++ is a simple language.
                 _lru.emplace_front(std::move(key), std::move(value));
                 auto it = _lru.begin();
                 _map.emplace(it);
@@ -602,6 +605,18 @@ namespace Microsoft::Console::Render
             std::unordered_set<std::list<std::pair<AtlasKey, AtlasValue>>::iterator, AtlasKeyHasher, AtlasKeyEq> _map;
         };
 
+        // TileAllocator yields `tileSize`-sized tiles for our texture atlas.
+        // While doing so it'll grow the atlas size() by a factor of 2 if needed.
+        // Once the setMaxArea() is exceeded it'll stop growing and instead
+        // snatch tiles back from the oldest TileHashMap entries.
+        //
+        // The quadratic growth works by alternating the size()
+        // between an 1:1 and 2:1 aspect ratio, like so:
+        //   (64,64) -> (128,64) -> (128,128) -> (256,128) -> (256,256)
+        // These initial tile positions allocate() returns are in a Z
+        // pattern over the available space in the atlas texture.
+        // You can log the `return _pos;` in allocate() using "Tracepoint"s
+        // in Visual Studio if you'd like to understand the Z pattern better.
         struct TileAllocator
         {
             TileAllocator() = default;
@@ -624,7 +639,7 @@ namespace Microsoft::Console::Render
             {
                 // _generate() uses a quadratic growth factor for _size's area.
                 // Once it exceeds the _maxArea, it'll start snatching tiles back from the
-                // TileHashMap using it's LRU queue. Since _size will at least reach half
+                // TileHashMap using its LRU queue. Since _size will at least reach half
                 // of _maxSize (because otherwise it could still grow by a factor of 2)
                 // and by ensuring that _maxArea is at least twice the window size
                 // we make it impossible* for _generate() to return false before
@@ -637,7 +652,10 @@ namespace Microsoft::Console::Render
 
             void setMaxArea(size_t max) noexcept
             {
-                _maxArea = clamp(max, _absoluteMinArea, _absoluteMaxArea);
+                // We need to reserve at least 1 extra `tileArea`, because the tile
+                // at position {0,0} is already reserved for the cursor texture.
+                const auto tileArea = static_cast<size_t>(_tileSize.x) * static_cast<size_t>(_tileSize.y);
+                _maxArea = clamp(max + tileArea, _absoluteMinArea, _absoluteMaxArea);
                 _updateCanGenerate();
             }
 
@@ -659,13 +677,20 @@ namespace Microsoft::Console::Render
             }
 
         private:
+            // This method generates the Z pattern coordinates
+            // described above in the TileAllocator comment.
             bool _generate() noexcept
             {
                 if (!_canGenerate)
                 {
                     return false;
                 }
 
+                // We need to backup _pos/_size in case our resize below exceeds _maxArea.
+                // In that case we have to restore _pos/_size so that if _maxArea is increased
+                // (window resize for instance), we can pick up were we previously left off.
+                const auto pos = _pos;
+
                 _pos.x += _tileSize.x;
                 if (_pos.x <= _limit.x)
                 {
@@ -679,9 +704,12 @@ namespace Microsoft::Console::Render
                     return true;
                 }
 
+                // Same as for pos.
+                const auto size = _size;
+
                 // This implements a quadratic growth factor for _size, by
                 // alternating between an 1:1 and 2:1 aspect ratio, like so:
-                // (64,64) -> (128,64) -> (128,128) -> (256,128) -> (256,256)
+                //   (64,64) -> (128,64) -> (128,128) -> (256,128) -> (256,256)
                 // This behavior is strictly dependent on setMaxArea(u16x2)'s
                 // behavior. See it's comment for an explanation.
                 if (_size.x == _size.y)
@@ -694,10 +722,19 @@ namespace Microsoft::Console::Render
                     _size.y *= 2;
                     _pos.x = 0;
                 }
-                _limit = { gsl::narrow_cast<u16>(_size.x - _tileSize.x), gsl::narrow_cast<u16>(_size.y - _tileSize.y) };
-                _originX = _pos.x;
 
                 _updateCanGenerate();
+                if (_canGenerate)
+                {
+                    _limit = { gsl::narrow_cast<u16>(_size.x - _tileSize.x), gsl::narrow_cast<u16>(_size.y - _tileSize.y) };
+                    _originX = _pos.x;
+                }
+                else
+                {
+                    _size = size;
+                    _pos = pos;
+                }
+
                 return _canGenerate;
             }
 
@@ -721,6 +758,8 @@ namespace Microsoft::Console::Render
             // Coincidentially that's exactly what we want as the cursor texture lives at {0, 0}.
             u16x2 _pos;
             u16 _originX = 0;
+            // Indicates whether we've exhausted our Z pattern across the atlas texture.
+            // If this is false, we have to snatch tiles back from TileHashMap.
             bool _canGenerate = true;
         };