atlas: display underlines in the right color when they're highlighted

This pull request resolves a longstanding issue (which probably nobody
but me cared about :P) where gridlines and underlines did not change
color to match the selection or search highlight foreground.

During brush preparation, we stash the underline color; during line
rendering we store it in a third bitmap and during rendering in each
backend we read the colors out of the appropriate bitmap.

The gridlines come from the foreground bitmap and the underlines from
the new underline bitmap.

I've updated each instance of append*Line to break the line-to-render up
by color span.

We are, therefore, no longer passing the stroke color in each gridline
payload.

The original console renderer supports painting the gridlines in
different colors for each half of a 2-cell glyph. That functionality no
longer works in Atlas. To fix it, we would need to move underline _span_
preparation into PaintBufferLine (so that we could apply the right
colors to the bitmap mid-cell.)

Known Issues
------------

- D2D only; dotted lines which are broken by a highlight have doubled
  dots (because we draw them as individual line segments and without a
  global geometry like curly lines.)
- Atlas (all); grid line colors can no longer change in the middle of
  a 2-cell glyph.

Tested By
---------

RenderingTests

Author: DHowett

src/renderer/atlas/AtlasEngine.cpp

@@ -203,7 +203,7 @@ try
             auto dst = _p.colorBitmap.data() + dstOffset;
             const auto bytes = count * sizeof(u32);
 
-            for (size_t i = 0; i < 2; ++i)
+            for (size_t i = 0; i < 3; ++i)
             {
                 // Avoid bumping the colorBitmapGeneration unless necessary. This approx. further halves
                 // the (already small) GPU load. This could easily be replaced with some custom SIMD
@@ -353,7 +353,7 @@ CATCH_RETURN()
     return S_OK;
 }
 
-void AtlasEngine::_fillColorBitmap(const size_t y, const size_t x1, const size_t x2, const u32 fgColor, const u32 bgColor) noexcept
+void AtlasEngine::_fillColorBitmap(const size_t y, const size_t x1, const size_t x2, const u32 fgColor, const u32 bgColor, const u32 ulColor) noexcept
 {
     const auto bitmap = _p.colorBitmap.begin() + _p.colorBitmapRowStride * y;
     const auto shift = gsl::narrow_cast<u8>(_p.rows[y]->lineRendition != LineRendition::SingleWidth);
@@ -363,10 +363,11 @@ void AtlasEngine::_fillColorBitmap(const size_t y, const size_t x1, const size_t
     const u32 colors[] = {
         u32ColorPremultiply(bgColor),
         fgColor,
+        ulColor,
     };
 
     // This fills the color in the background bitmap, and then in the foreground bitmap.
-    for (size_t i = 0; i < 2; ++i)
+    for (size_t i = 0; i < 3; ++i)
     {
         const auto color = colors[i];
 
@@ -428,7 +429,7 @@ try
     {
         const auto isFinalRow = y == hiEnd.y;
         const auto end = isFinalRow ? std::min(hiEnd.x, x2) : x2;
-        _fillColorBitmap(row, x1, end, fgColor, bgColor);
+        _fillColorBitmap(row, x1, end, fgColor, bgColor, fgColor);
 
         // Return early if we couldn't paint the whole region (either this was not the last row, or
         // it was the last row but the highlight ends outside of our x range.)
@@ -451,7 +452,7 @@ try
         const auto isEndInside = y == hiEnd.y && hiEnd.x <= x2;
         if (isStartInside && isEndInside)
         {
-            _fillColorBitmap(row, hiStart.x, static_cast<size_t>(hiEnd.x), fgColor, bgColor);
+            _fillColorBitmap(row, hiStart.x, static_cast<size_t>(hiEnd.x), fgColor, bgColor, fgColor);
             ++it;
         }
         else
@@ -460,7 +461,7 @@ try
             if (isStartInside)
             {
                 const auto start = std::max(x1, hiStart.x);
-                _fillColorBitmap(y, start, x2, fgColor, bgColor);
+                _fillColorBitmap(y, start, x2, fgColor, bgColor, fgColor);
             }
 
             break;
@@ -517,7 +518,7 @@ try
     }
 
     // Apply the current foreground and background colors to the cells
-    _fillColorBitmap(y, x, columnEnd, _api.currentForeground, _api.currentBackground);
+    _fillColorBitmap(y, x, columnEnd, _api.currentForeground, _api.currentBackground, _api.currentUnderlineColor);
 
     // Apply the highlighting colors to the highlighted cells
     RETURN_IF_FAILED(_drawHighlighted(_api.searchHighlights, y, x, columnEnd, highlightFg, highlightBg));
@@ -532,14 +533,14 @@ CATCH_RETURN()
 [[nodiscard]] HRESULT AtlasEngine::PaintBufferGridLines(const GridLineSet lines, const COLORREF gridlineColor, const COLORREF underlineColor, const size_t cchLine, const til::point coordTarget) noexcept
 try
 {
+    UNREFERENCED_PARAMETER(gridlineColor);
+    UNREFERENCED_PARAMETER(underlineColor);
     const auto shift = gsl::narrow_cast<u8>(_api.lineRendition != LineRendition::SingleWidth);
     const auto x = std::max(0, coordTarget.x - (_api.viewportOffset.x >> shift));
     const auto y = gsl::narrow_cast<u16>(clamp<til::CoordType>(coordTarget.y, 0, _p.s->viewportCellCount.y - 1));
     const auto from = gsl::narrow_cast<u16>(clamp<til::CoordType>(x << shift, 0, _p.s->viewportCellCount.x - 1));
     const auto to = gsl::narrow_cast<u16>(clamp<size_t>((x + cchLine) << shift, from, _p.s->viewportCellCount.x));
-    const auto glColor = gsl::narrow_cast<u32>(gridlineColor) | 0xff000000;
-    const auto ulColor = gsl::narrow_cast<u32>(underlineColor) | 0xff000000;
-    _p.rows[y]->gridLineRanges.emplace_back(lines, glColor, ulColor, from, to);
+    _p.rows[y]->gridLineRanges.emplace_back(lines, from, to);
     return S_OK;
 }
 CATCH_RETURN()
@@ -650,7 +651,9 @@ CATCH_RETURN()
 try
 {
     auto [fg, bg] = renderSettings.GetAttributeColorsWithAlpha(textAttributes);
+    auto ul = renderSettings.GetAttributeUnderlineColor(textAttributes);
     fg |= 0xff000000;
+    ul |= 0xff000000;
     bg |= _api.backgroundOpaqueMixin;
 
     if (!isSettingDefaultBrushes)
@@ -666,6 +669,7 @@ try
 
         _api.currentBackground = gsl::narrow_cast<u32>(bg);
         _api.currentForeground = gsl::narrow_cast<u32>(fg);
+        _api.currentUnderlineColor = gsl::narrow_cast<u32>(ul);
         _api.attributes = attributes;
     }
     else
@@ -680,6 +684,11 @@ try
         {
             _api.s.write()->misc.write()->foregroundColor = fg;
         }
+
+        if (textAttributes.GetUnderlineColor().IsDefault() && fg != _api.s->misc->underlineColor)
+        {
+            _api.s.write()->misc.write()->underlineColor = ul;
+        }
     }
 
     return S_OK;
@@ -791,9 +800,10 @@ void AtlasEngine::_recreateCellCountDependentResources()
     // so we round up to multiple of 8 because 8 * sizeof(u32) == 32.
     _p.colorBitmapRowStride = alignForward<size_t>(_p.s->viewportCellCount.x, 8);
     _p.colorBitmapDepthStride = _p.colorBitmapRowStride * _p.s->viewportCellCount.y;
-    _p.colorBitmap = Buffer<u32, 32>(_p.colorBitmapDepthStride * 2);
+    _p.colorBitmap = Buffer<u32, 32>(_p.colorBitmapDepthStride * 3);
     _p.backgroundBitmap = { _p.colorBitmap.data(), _p.colorBitmapDepthStride };
     _p.foregroundBitmap = { _p.colorBitmap.data() + _p.colorBitmapDepthStride, _p.colorBitmapDepthStride };
+    _p.underlineBitmap = { _p.colorBitmap.data() + (_p.colorBitmapDepthStride << 1), _p.colorBitmapDepthStride };
 
     memset(_p.colorBitmap.data(), 0, _p.colorBitmap.size() * sizeof(u32));
 

src/renderer/atlas/AtlasEngine.h

@@ -89,7 +89,7 @@ namespace Microsoft::Console::Render::Atlas
         void _mapCharacters(const wchar_t* text, u32 textLength, u32* mappedLength, IDWriteFontFace2** mappedFontFace) const;
         void _mapComplex(IDWriteFontFace2* mappedFontFace, u32 idx, u32 length, ShapedRow& row);
         ATLAS_ATTR_COLD void _mapReplacementCharacter(u32 from, u32 to, ShapedRow& row);
-        void _fillColorBitmap(const size_t y, const size_t x1, const size_t x2, const u32 fgColor, const u32 bgColor) noexcept;
+        void _fillColorBitmap(const size_t y, const size_t x1, const size_t x2, const u32 fgColor, const u32 bgColor, const u32 ulColor) noexcept;
         [[nodiscard]] HRESULT _drawHighlighted(std::span<const til::point_span>& highlights, const u16 row, const u16 begX, const u16 endX, const u32 fgColor, const u32 bgColor) noexcept;
 
         // AtlasEngine.api.cpp
@@ -162,6 +162,7 @@ namespace Microsoft::Console::Render::Atlas
             u32 backgroundOpaqueMixin = 0xff000000;
             u32 currentBackground = 0;
             u32 currentForeground = 0;
+            u32 currentUnderlineColor = 0;
             FontRelevantAttributes attributes = FontRelevantAttributes::None;
             u16x2 lastPaintBufferLineCoord{};
             // UpdateHyperlinkHoveredId()

src/renderer/atlas/BackendD2D.cpp

@@ -619,38 +619,52 @@ void BackendD2D::_drawGridlineRow(const RenderingPayload& p, const ShapedRow* ro
     const auto cellCenter = row->lineRendition == LineRendition::DoubleHeightTop ? rowBottom : rowTop;
     const auto scaleHorizontal = row->lineRendition != LineRendition::SingleWidth ? 0.5f : 1.0f;
     const auto scaledCellWidth = cellWidth * scaleHorizontal;
+    const auto horizontalShift = static_cast<u8>(row->lineRendition != LineRendition::SingleWidth);
 
     const auto appendVerticalLines = [&](const GridLineRange& r, FontDecorationPosition pos) {
         const auto from = r.from * scaledCellWidth;
         const auto to = r.to * scaledCellWidth;
         auto x = from + pos.position;
 
+        const auto colors = &p.foregroundBitmap[p.colorBitmapRowStride * y];
+
         D2D1_POINT_2F point0{ 0, cellCenter };
         D2D1_POINT_2F point1{ 0, cellCenter + cellHeight };
-        const auto brush = _brushWithColor(r.gridlineColor);
         const f32 w = pos.height;
         const f32 hw = w * 0.5f;
 
-        for (; x < to; x += cellWidth)
+        auto c = r.from;
+        for (; x < to; x += cellWidth, c += 1 << horizontalShift)
         {
+            const auto brush = _brushWithColor(colors[c]);
             const auto centerX = x + hw;
             point0.x = centerX;
             point1.x = centerX;
             _renderTarget->DrawLine(point0, point1, brush, w, nullptr);
         }
     };
-    const auto appendHorizontalLine = [&](const GridLineRange& r, FontDecorationPosition pos, ID2D1StrokeStyle* strokeStyle, const u32 color) {
-        const auto from = r.from * scaledCellWidth;
-        const auto to = r.to * scaledCellWidth;
+    const auto appendHorizontalLine = [&](const GridLineRange& r, FontDecorationPosition pos, ID2D1StrokeStyle* strokeStyle, const std::span<const u32>& colorBitmap) {
+        const auto colors = &colorBitmap[p.colorBitmapRowStride * y];
 
-        const auto brush = _brushWithColor(color);
         const f32 w = pos.height;
         const f32 centerY = cellCenter + pos.position + w * 0.5f;
-        const D2D1_POINT_2F point0{ from, centerY };
-        const D2D1_POINT_2F point1{ to, centerY };
-        _renderTarget->DrawLine(point0, point1, brush, w, strokeStyle);
+
+        for (auto from = r.from; from < r.to;)
+        {
+            const auto start = colors[from];
+            u16 run = 1u;
+            for (; colors[from + run] == start && run < (r.to - from); ++run)
+                ;
+
+            const auto brush = _brushWithColor(start);
+            const D2D1_POINT_2F point0{ from * scaledCellWidth, centerY };
+            const D2D1_POINT_2F point1{ (from + run) * scaledCellWidth, centerY };
+            _renderTarget->DrawLine(point0, point1, brush, w, strokeStyle);
+
+            from += run;
+        }
     };
-    const auto appendCurlyLine = [&](const GridLineRange& r) {
+    const auto appendCurlyLine = [&](const GridLineRange& r, const std::span<const u32>& colorBitmap) {
         const auto& font = *p.s->font;
 
         const auto duTop = static_cast<f32>(font.doubleUnderline[0].position);
@@ -672,11 +686,16 @@ void BackendD2D::_drawGridlineRow(const RenderingPayload& p, const ShapedRow* ro
         const auto step = roundf(0.5f * height);
         const auto period = 4.0f * step;
 
-        const auto from = r.from * scaledCellWidth;
-        const auto to = r.to * scaledCellWidth;
+        const auto colors = &colorBitmap[p.colorBitmapRowStride * y];
+
+        // Calculate the wave over the entire region to be underlined, even if
+        // it has multiple colors in it. That way, when we clip it to render each
+        // color, it is seamless.
+        const auto fullSpanFrom = r.from * scaledCellWidth;
+        const auto fullSpanTo = r.to * scaledCellWidth;
         // Align the start of the wave to the nearest preceding period boundary.
         // This ensures that the wave is continuous across color and cell changes.
-        auto x = floorf(from / period) * period;
+        auto x = floorf(fullSpanFrom / period) * period;
 
         wil::com_ptr<ID2D1PathGeometry> geometry;
         THROW_IF_FAILED(p.d2dFactory->CreatePathGeometry(geometry.addressof()));
@@ -686,7 +705,7 @@ void BackendD2D::_drawGridlineRow(const RenderingPayload& p, const ShapedRow* ro
 
         // This adds complete periods of the wave until we reach the end of the range.
         sink->BeginFigure({ x, center }, D2D1_FIGURE_BEGIN_HOLLOW);
-        for (D2D1_QUADRATIC_BEZIER_SEGMENT segment; x < to;)
+        for (D2D1_QUADRATIC_BEZIER_SEGMENT segment; x < fullSpanTo;)
         {
             x += step;
             segment.point1.x = x;
@@ -708,11 +727,21 @@ void BackendD2D::_drawGridlineRow(const RenderingPayload& p, const ShapedRow* ro
 
         THROW_IF_FAILED(sink->Close());
 
-        const auto brush = _brushWithColor(r.underlineColor);
-        const D2D1_RECT_F clipRect{ from, rowTop, to, rowBottom };
-        _renderTarget->PushAxisAlignedClip(&clipRect, D2D1_ANTIALIAS_MODE_ALIASED);
-        _renderTarget->DrawGeometry(geometry.get(), brush, duHeight, nullptr);
-        _renderTarget->PopAxisAlignedClip();
+        for (auto from = r.from; from < r.to;)
+        {
+            const auto start = colors[from];
+            u16 run = 1u;
+            for (; colors[from + run] == start && run < (r.to - from); ++run)
+                ;
+
+            const auto brush = _brushWithColor(start);
+            const D2D1_RECT_F clipRect{ (from * scaledCellWidth), rowTop, (from + run) * scaledCellWidth, rowBottom };
+            _renderTarget->PushAxisAlignedClip(&clipRect, D2D1_ANTIALIAS_MODE_ALIASED);
+            _renderTarget->DrawGeometry(geometry.get(), brush, duHeight, nullptr);
+            _renderTarget->PopAxisAlignedClip();
+
+            from += run;
+        }
     };
 
     for (const auto& r : row->gridLineRanges)
@@ -730,20 +759,20 @@ void BackendD2D::_drawGridlineRow(const RenderingPayload& p, const ShapedRow* ro
         }
         if (r.lines.test(GridLines::Top))
         {
-            appendHorizontalLine(r, p.s->font->gridTop, nullptr, r.gridlineColor);
+            appendHorizontalLine(r, p.s->font->gridTop, nullptr, p.foregroundBitmap);
         }
         if (r.lines.test(GridLines::Bottom))
         {
-            appendHorizontalLine(r, p.s->font->gridBottom, nullptr, r.gridlineColor);
+            appendHorizontalLine(r, p.s->font->gridBottom, nullptr, p.foregroundBitmap);
         }
         if (r.lines.test(GridLines::Strikethrough))
         {
-            appendHorizontalLine(r, p.s->font->strikethrough, nullptr, r.gridlineColor);
+            appendHorizontalLine(r, p.s->font->strikethrough, nullptr, p.foregroundBitmap);
         }
 
         if (r.lines.test(GridLines::Underline))
         {
-            appendHorizontalLine(r, p.s->font->underline, nullptr, r.underlineColor);
+            appendHorizontalLine(r, p.s->font->underline, nullptr, p.underlineBitmap);
         }
         else if (r.lines.any(GridLines::DottedUnderline, GridLines::HyperlinkUnderline))
         {
@@ -753,7 +782,7 @@ void BackendD2D::_drawGridlineRow(const RenderingPayload& p, const ShapedRow* ro
                 static constexpr FLOAT dashes[2]{ 1, 1 };
                 THROW_IF_FAILED(p.d2dFactory->CreateStrokeStyle(&props, &dashes[0], 2, _dottedStrokeStyle.addressof()));
             }
-            appendHorizontalLine(r, p.s->font->underline, _dottedStrokeStyle.get(), r.underlineColor);
+            appendHorizontalLine(r, p.s->font->underline, _dottedStrokeStyle.get(), p.underlineBitmap);
         }
         else if (r.lines.test(GridLines::DashedUnderline))
         {
@@ -763,17 +792,17 @@ void BackendD2D::_drawGridlineRow(const RenderingPayload& p, const ShapedRow* ro
                 static constexpr FLOAT dashes[2]{ 2, 2 };
                 THROW_IF_FAILED(p.d2dFactory->CreateStrokeStyle(&props, &dashes[0], 2, _dashedStrokeStyle.addressof()));
             }
-            appendHorizontalLine(r, p.s->font->underline, _dashedStrokeStyle.get(), r.underlineColor);
+            appendHorizontalLine(r, p.s->font->underline, _dashedStrokeStyle.get(), p.underlineBitmap);
         }
         else if (r.lines.test(GridLines::CurlyUnderline))
         {
-            appendCurlyLine(r);
+            appendCurlyLine(r, p.underlineBitmap);
         }
         else if (r.lines.test(GridLines::DoubleUnderline))
         {
             for (const auto pos : p.s->font->doubleUnderline)
             {
-                appendHorizontalLine(r, pos, nullptr, r.underlineColor);
+                appendHorizontalLine(r, pos, nullptr, p.underlineBitmap);
             }
         }
     }