Rewrite AtlasEngine to allow arbitrary overhangs

src/host/CursorBlinker.cpp

@@ -55,7 +55,7 @@ void CursorBlinker::SettingsChanged() noexcept
     {
         KillCaretTimer();
         _uCaretBlinkTime = dwCaretBlinkTime;
-        //SetCaretTimer();
+        SetCaretTimer();
     }
 }
 
@@ -66,7 +66,7 @@ void CursorBlinker::FocusEnd() const noexcept
 
 void CursorBlinker::FocusStart() const noexcept
 {
-    //SetCaretTimer();
+    SetCaretTimer();
 }
 
 // Routine Description:

src/inc/til/small_vector.h

@@ -16,6 +16,8 @@
 #pragma warning(disable : 26459) // You called an STL function '...' with a raw pointer parameter at position '...' that may be unsafe ... (stl.1).
 // small_vector::_data references potentially uninitialized data and so we can't pass it regular iterators which reference initialized data.
 #pragma warning(disable : 26481) // Don't use pointer arithmetic. Use span instead (bounds.1).
+// small_vector::_buffer is explicitly uninitialized, because we manage it's initialization manually.
+#pragma warning(disable : 26495) // Variable '...' is uninitialized. Always initialize a member variable (type.6).
 
 namespace til
 {

src/renderer/atlas/AtlasEngine.r.cpp

@@ -82,6 +82,10 @@ void AtlasEngine::WaitUntilCanRender() noexcept
     {
         _b->WaitUntilCanRender();
     }
+    if constexpr (ATLAS_DEBUG_RENDER_DELAY)
+    {
+        Sleep(ATLAS_DEBUG_RENDER_DELAY);
+    }
 }
 
 #pragma endregion

src/renderer/atlas/Backend.h

@@ -7,12 +7,31 @@
 
 namespace Microsoft::Console::Render::Atlas
 {
+    // If set to 1, this will cause the entire viewport to be invalidated at all times.
+    // Helpful for benchmarking our text shaping code based on DirectWrite.
+#define ATLAS_DEBUG_DISABLE_PARTIAL_INVALIDATION 0
+
+    // Redraw at display refresh rate at all times. This helps with shader debugging.
 #define ATLAS_DEBUG_CONTINUOUS_REDRAW 0
+
+    // Disables the use of DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT.
+    // This helps with benchmarking the application as it'll run beyond display refresh rate.
 #define ATLAS_DEBUG_DISABLE_FRAME_LATENCY_WAITABLE_OBJECT 0
-#define ATLAS_DEBUG_DISABLE_PARTIAL_INVALIDATION 0
+
+    // Forces the use of Direct2D for text rendering (= BackendD2D).
 #define ATLAS_DEBUG_FORCE_D2D_MODE 0
+
+    // Adds an artificial delay before every render pass. In milliseconds.
+#define ATLAS_DEBUG_RENDER_DELAY 0
+
+    // Shows the dirty rects as given to IDXGISwapChain2::Present1() during each frame.
 #define ATLAS_DEBUG_SHOW_DIRTY 0
 
+    // Dumps the contents of the swap chain on each render pass into the given directory as PNG.
+    // I highly recommend setting ATLAS_DEBUG_RENDER_DELAY to 250 or similar if this is used.
+#define ATLAS_DEBUG_DUMP_RENDER_TARGET 0
+#define ATLAS_DEBUG_DUMP_RENDER_TARGET_PATH LR"(%USERPROFILE%\Downloads\AtlasEngine)"
+
     struct SwapChainManager
     {
         void UpdateSwapChainSettings(const RenderingPayload& p, IUnknown* device, auto&& prepareRecreate, auto&& prepareResize)

src/renderer/atlas/BackendD2D.cpp

@@ -4,6 +4,10 @@
 #include "pch.h"
 #include "BackendD2D.h"
 
+#if ATLAS_DEBUG_SHOW_DIRTY
+#include "colorbrewer.h"
+#endif
+
 TIL_FAST_MATH_BEGIN
 
 // Disable a bunch of warnings which get in the way of writing performant code.
@@ -34,6 +38,9 @@ void BackendD2D::Render(RenderingPayload& p)
     _drawGridlines(p);
     _drawCursor(p);
     _drawSelection(p);
+#if ATLAS_DEBUG_SHOW_DIRTY
+    _debugShowDirty(p);
+#endif
     THROW_IF_FAILED(_renderTarget->EndDraw());
 
     _swapChainManager.Present(p);
@@ -208,7 +215,7 @@ void BackendD2D::_drawText(RenderingPayload& p)
                 }
             } while (it != end);
         }
-        
+
         if (y >= p.invalidatedRows.x && y < p.invalidatedRows.y)
         {
             dirtyTop = std::min(dirtyTop, row->top);
@@ -486,6 +493,27 @@ void BackendD2D::_drawSelection(const RenderingPayload& p)
     }
 }
 
+void BackendD2D::_debugShowDirty(RenderingPayload& p)
+{
+    _presentRects[_presentRectsPos] = p.dirtyRectInPx;
+    _presentRectsPos = (_presentRectsPos + 1) % std::size(_presentRects);
+
+    for (size_t i = 0; i < std::size(_presentRects); ++i)
+    {
+        if (const auto& rect = _presentRects[i])
+        {
+            const D2D1_RECT_F rectF{
+                static_cast<f32>(rect.left),
+                static_cast<f32>(rect.top),
+                static_cast<f32>(rect.right),
+                static_cast<f32>(rect.bottom),
+            };
+            const auto color = 0x1f000000 | colorbrewer::pastel1[i];
+            _fillRectangle(rectF, color);
+        }
+    }
+}
+
 ID2D1Brush* BackendD2D::_brushWithColor(u32 color)
 {
     if (_brushColor != color)

src/renderer/atlas/BackendD2D.h

@@ -24,6 +24,7 @@ namespace Microsoft::Console::Render::Atlas
         void _drawGridlineRow(const RenderingPayload& p, const ShapedRow* row, u16 y);
         void _drawCursor(const RenderingPayload& p);
         void _drawSelection(const RenderingPayload& p);
+        void _debugShowDirty(RenderingPayload& p);
         ID2D1Brush* _brushWithColor(u32 color);
         void _fillRectangle(const D2D1_RECT_F& rect, u32 color);
 
@@ -46,5 +47,10 @@ namespace Microsoft::Console::Render::Atlas
         til::generation_t _generation;
         til::generation_t _fontGeneration;
         u16x2 _cellCount;
+
+#if ATLAS_DEBUG_SHOW_DIRTY
+        til::rect _presentRects[9]{};
+        size_t _presentRectsPos = 0;
+#endif
     };
 }

src/renderer/atlas/BackendD3D.cpp

@@ -13,7 +13,13 @@
 
 #include "dwrite.h"
 
+#if ATLAS_DEBUG_SHOW_DIRTY
 #include "colorbrewer.h"
+#endif
+
+#if ATLAS_DEBUG_DUMP_RENDER_TARGET
+#include "wic.h"
+#endif
 
 TIL_FAST_MATH_BEGIN
 
@@ -290,44 +296,33 @@ void BackendD3D::Render(RenderingPayload& p)
     // After a Present() the render target becomes unbound.
     _deviceContext->OMSetRenderTargets(1, _renderTargetView.addressof(), nullptr);
 
+    // Invalidating the render target helps with spotting invalid quad instances and Present1() bugs.
+#if ATLAS_DEBUG_SHOW_DIRTY || ATLAS_DEBUG_DUMP_RENDER_TARGET
+    {
+        static constexpr f32 clearColor[4]{};
+        _deviceContext->ClearView(_renderTargetView.get(), &clearColor[0], nullptr, 0);
+    }
+#endif
+
     _drawBackground(p);
     _drawCursorPart1(p);
     _drawText(p);
     _drawGridlines(p);
     _drawCursorPart2(p);
     _drawSelection(p);
-
 #if ATLAS_DEBUG_SHOW_DIRTY
-    {
-        _presentRects[_presentRectsPos] = p.dirtyRectInPx;
-        _presentRectsPos = (_presentRectsPos + 1) % std::size(_presentRects);
-
-        for (size_t i = 0; i < std::size(_presentRects); ++i)
-        {
-            if (const auto& rect = _presentRects[i])
-            {
-                const i16x2 position{
-                    static_cast<i16>(rect.left),
-                    static_cast<i16>(rect.top),
-                };
-                const u16x2 size{
-                    static_cast<u16>(rect.right - rect.left),
-                    static_cast<u16>(rect.bottom - rect.top),
-                };
-                const auto color = 0x3f000000 | colorbrewer::pastel1[i];
-                _appendQuad(position, size, color, ShadingType::SolidFill);
-            }
-        }
-    }
+    _debugShowDirty(p);
 #endif
-
     _flushQuads(p);
 
     if (_customPixelShader)
     {
         _executeCustomShader(p);
     }
 
+#if ATLAS_DEBUG_DUMP_RENDER_TARGET
+    _debugDumpRenderTarget(p);
+#endif
     _swapChainManager.Present(p);
 }
 
@@ -403,11 +398,6 @@ void BackendD3D::_handleSettingsUpdate(const RenderingPayload& p)
     _miscGeneration = p.s->misc.generation();
     _targetSize = p.s->targetSize;
     _cellCount = p.s->cellCount;
-
-#if ATLAS_DEBUG_SHOW_DIRTY
-    std::ranges::fill(_presentRects, til::rect{});
-    _presentRectsPos = 0;
-#endif
 }
 
 void BackendD3D::_recreateCustomShader(const RenderingPayload& p)
@@ -747,7 +737,7 @@ void BackendD3D::_d2dEndDrawing()
     }
 }
 
-void BackendD3D::_handleFontChangedResetGlyphAtlas(RenderingPayload& p)
+void BackendD3D::_handleFontChangedResetGlyphAtlas(const RenderingPayload& p)
 {
     _fontChangedResetGlyphAtlas = false;
     _resetGlyphAtlasAndBeginDraw(p);
@@ -860,7 +850,13 @@ void BackendD3D::_appendQuad(i16x2 position, u16x2 size, u16x2 texcoord, u32 col
 
 void BackendD3D::_bumpInstancesSize()
 {
-    _instances = Buffer<QuadInstance>{ std::max<size_t>(1024, _instances.size() << 1) };
+    const auto newSize = std::max<size_t>(256, _instances.size() * 2);
+    Expects(newSize > _instances.size());
+
+    auto newInstances = Buffer<QuadInstance>{ newSize };
+    std::copy_n(_instances.data(), _instances.size(), newInstances.data());
+
+    _instances = std::move(newInstances);
 }
 
 void BackendD3D::_flushQuads(const RenderingPayload& p)
@@ -1383,6 +1379,48 @@ void BackendD3D::_drawSelection(const RenderingPayload& p)
     }
 }
 
+#if ATLAS_DEBUG_SHOW_DIRTY
+void BackendD3D::_debugShowDirty(RenderingPayload& p)
+{
+    _presentRects[_presentRectsPos] = p.dirtyRectInPx;
+    _presentRectsPos = (_presentRectsPos + 1) % std::size(_presentRects);
+
+    for (size_t i = 0; i < std::size(_presentRects); ++i)
+    {
+        if (const auto& rect = _presentRects[i])
+        {
+            const i16x2 position{
+                static_cast<i16>(rect.left),
+                static_cast<i16>(rect.top),
+            };
+            const u16x2 size{
+                static_cast<u16>(rect.right - rect.left),
+                static_cast<u16>(rect.bottom - rect.top),
+            };
+            const auto color = 0x1f000000 | colorbrewer::pastel1[i];
+            _appendQuad(position, size, color, ShadingType::SolidFill);
+        }
+    }
+}
+#endif
+
+#if ATLAS_DEBUG_DUMP_RENDER_TARGET
+void BackendD3D::_debugDumpRenderTarget(RenderingPayload& p)
+{
+    const auto n = _dumpRenderTargetCounter.fetch_add(1, std::memory_order_relaxed);
+
+    if (n == 0)
+    {
+        ExpandEnvironmentStringsW(ATLAS_DEBUG_DUMP_RENDER_TARGET_PATH, &_dumpRenderTargetBasePath[0], std::size(_dumpRenderTargetBasePath));
+        std::filesystem::create_directories(_dumpRenderTargetBasePath);
+    }
+
+    wchar_t path[MAX_PATH];
+    swprintf_s(path, L"%s\\%u_%08u.png", &_dumpRenderTargetBasePath[0], GetCurrentProcessId(), n);
+    SaveTextureToPNG(_deviceContext.get(), _swapChainManager.GetBuffer().get(), p.s->font->dpi, &path[0]);
+}
+#endif
+
 void BackendD3D::_executeCustomShader(RenderingPayload& p)
 {
     {

src/renderer/atlas/BackendD3D.h

@@ -127,9 +127,11 @@ namespace Microsoft::Console::Render::Atlas
         void _recreateConstBuffer(const RenderingPayload& p);
         void _setupDeviceContextState(const RenderingPayload& p);
         void _debugUpdateShaders(const RenderingPayload& p) noexcept;
+        void _debugShowDirty(RenderingPayload& p);
+        void _debugDumpRenderTarget(RenderingPayload& p);
         void _d2dBeginDrawing() noexcept;
         void _d2dEndDrawing();
-        void _handleFontChangedResetGlyphAtlas(RenderingPayload& p);
+        void _handleFontChangedResetGlyphAtlas(const RenderingPayload& p);
         void _resetGlyphAtlasAndBeginDraw(const RenderingPayload& p);
         void _markStateChange(ID3D11BlendState* blendState);
         QuadInstance& _getLastQuad() noexcept;
@@ -226,12 +228,17 @@ namespace Microsoft::Console::Render::Atlas
         til::small_vector<CursorRect, 6> _cursorRects;
 
         bool _requiresContinuousRedraw = false;
-        
+
 #if ATLAS_DEBUG_SHOW_DIRTY
         til::rect _presentRects[9]{};
         size_t _presentRectsPos = 0;
 #endif
 
+#if ATLAS_DEBUG_DUMP_RENDER_TARGET
+        std::atomic<uint32_t> _dumpRenderTargetCounter;
+        wchar_t _dumpRenderTargetBasePath[MAX_PATH];
+#endif
+
 #ifndef NDEBUG
         std::filesystem::path _sourceDirectory;
         wil::unique_folder_change_reader_nothrow _sourceCodeWatcher;

src/renderer/atlas/colorbrewer.h

@@ -3,7 +3,8 @@
 
 #pragma once
 
-namespace Microsoft::Console::Render::Atlas::colorbrewer {
+namespace Microsoft::Console::Render::Atlas::colorbrewer
+{
     // The following list of colors is only used as a debug aid and not part of the final product.
     // They're licensed under:
     //

src/renderer/atlas/common.h

@@ -173,6 +173,7 @@ namespace Microsoft::Console::Render::Atlas
         {
         }
 
+#pragma warning(suppress : 26432) // If you define or delete any default operation in the type '...', define or delete them all (c.21).
         Buffer& operator=(Buffer&& other) noexcept
         {
             destroy();
@@ -181,40 +182,6 @@ namespace Microsoft::Console::Render::Atlas
             return *this;
         }
 
-#if 0
-        Buffer(const Buffer& other) noexcept :
-            _data{ allocate(other._size) },
-            _size{ other._size }
-        {
-#pragma warning(suppress : 26459) // You called an STL function '...' with a raw pointer parameter at position '...' that may be unsafe [...].
-            std::uninitialized_copy_n(other._data, other._size, _data);
-        }
-
-        Buffer& operator=(const Buffer& other) noexcept
-        {
-            destroy();
-            _data = nullptr;
-            _size = 0;
-
-            _data = allocate(other._size);
-            _size = other._size;
-
-#pragma warning(suppress : 26459) // You called an STL function '...' with a raw pointer parameter at position '...' that may be unsafe [...].
-            std::uninitialized_copy_n(other._data, other._size, _data);
-            return *this;
-        }
-
-        bool operator==(const Buffer& other) const
-        {
-            return memcmp(_data, other._data, _size * sizeof(T)) == 0;
-        }
-
-        bool operator!=(const Buffer& other) const
-        {
-            return memcmp(_data, other._data, _size * sizeof(T)) != 0;
-        }
-#endif
-
         explicit operator bool() const noexcept
         {
             return _data != nullptr;