AtlasEngine: Implement support for custom shaders #13885
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
* Fill gutters with color * Detect RDP via DXGI flags * Detect device changes via DXGI * Properly treat selection and cursor changes as invalidations * The D2D mode renderer used to redraw the entire viewport whenever the dirty rect is empty which happens when dragging a selection * With the above fix in place we sometimes don't Present() so we now also need to sometimes not wait on the frame event * Listen to const-buffer data being changed and redraw everything * Stop setting the const-buffer on every frame
ghost
added
Area-Rendering
lhecker
force-pushed
the
dev/lhecker/atlas-engine-custom-shaders
branch
from
43895da
to
3c359c4
Compare
lhecker
commented
Aug 30, 2022
Comment on lines
+43
to
+44
| samplePos.y = tex_coord.y + (y - sampleCount / 2.0f) * texelHeight; | ||
| color += input.Sample(samplerState, samplePos) * Gaussian2D(x - sampleCount / 2.0f, y - sampleCount / 2.0f, sigma); |
There was a problem hiding this comment.
FYI with D3D11_TEXTURE_ADDRESS_BORDER we already ensure that Sample() returns float4(0, 0, 0, 0). This removes the need for the if condition, which is one of the things that produces a warning by default (and for a good reason - loops like that are impossible on GPUs).
DHowett
reviewed
Aug 30, 2022
| @@ -0,0 +1,82 @@ | |||
| // The original retro pixel shader | |||
There was a problem hiding this comment.
What's up with this copy? Can it be contributed back to the other copy since it was made to build without warnings?
Do users have to rewrite their shaders when Atlas comes on line?
There was a problem hiding this comment.
We used to have 2 copies of this shader and I contributed it back to the one in the samples directory. Do you want me to make the change for DxEngine as well? I figured it wouldn't make a difference for it...
Do users have to rewrite their shaders when Atlas comes on line?
Some users might. Out of all shaders we have only the retro shader produces warnings (which are now treated as errors).
zadjii-msft
approved these changes
Aug 31, 2022
| if (!_api.customPixelShaderPath.empty()) | ||
| { | ||
| const auto target = _r.device->GetFeatureLevel() == D3D_FEATURE_LEVEL_10_1 ? "ps_4_1" : "ps_5_0"; | ||
| static constexpr auto flags = D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS |
There was a problem hiding this comment.
D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS
We need to very clearly add to the release notes that we've added these, so that pixel shaders in atlas engine will enforce them now.
src/renderer/atlas/AtlasEngine.cpp
Outdated
|
|
||
| if (!_api.customPixelShaderPath.empty()) | ||
| { | ||
| const auto target = _r.device->GetFeatureLevel() == D3D_FEATURE_LEVEL_10_1 ? "ps_4_1" : "ps_5_0"; |
There was a problem hiding this comment.
DxEngine also supported D3D_FEATURE_LEVEL_10_0 -> vs_4_0, do we still need that?
There was a problem hiding this comment.
The minimum this engine supports right now is D3D 10.1 (which is about 2008).
Looking at it again though, there doesn't seem to be any reason to not support 10.0 hardware.
| const auto hr = D3DCompileFromFile( | ||
| /* pFileName */ _api.customPixelShaderPath.c_str(), | ||
| /* pDefines */ nullptr, | ||
| /* pInclude */ D3D_COMPILE_STANDARD_FILE_INCLUDE, |
There was a problem hiding this comment.
oh neat, so now folks can relative-include other files in their shaders? that's neat
| @@ -27,6 +27,28 @@ | |||
| <ClInclude Include="AtlasEngine.h" /> | |||
| </ItemGroup> | |||
| <ItemGroup> | |||
| <FxCompile Include="custom_shader_ps.hlsl"> | |||
There was a problem hiding this comment.
hmm i don't believe so... but perhaps close?
There was a problem hiding this comment.
Yeah not yet. This just compiles the shader into a more compact binary format which is included as a header.
|
@msftbot make sure @winobjc-bot signs off |
ghost
added
the
AutoMerge
|
Hello @DHowett! Because you've given me some instructions on how to help merge this pull request, I'll be modifying my merge approach. Here's how I understand your requirements for merging this pull request:
If this doesn't seem right to you, you can tell me to cancel these instructions and use the auto-merge policy that has been configured for this repository. Try telling me "forget everything I just told you". |
lhecker
removed
the
AutoMerge
DHowett
approved these changes
Aug 31, 2022
|
|
||
| #pragma warning(suppress : 26494) // Variable 'mapped' is uninitialized. Always initialize an object (type.5). | ||
| D3D11_MAPPED_SUBRESOURCE mapped; | ||
| THROW_IF_FAILED(_r.deviceContext->Map(_r.customShaderConstantBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped)); |
There was a problem hiding this comment.
do we need to re-map the ConstBuffer in every time? Or can we map it once and update it like we do with the other Atlas bits?
There was a problem hiding this comment.
We need to map/unmap it every time. Here's Nvidia's documentation for it: https://developer.nvidia.com/content/constant-buffers-without-constant-pain-0
| _r.deviceContext->PSSetShaderResources(0, 1, _r.customOffscreenTextureView.addressof()); | ||
| _r.deviceContext->PSSetSamplers(0, 1, _r.customShaderSamplerState.addressof()); | ||
|
|
||
| _r.deviceContext->Draw(4, 0); |
There was a problem hiding this comment.
4 is a weird magic number; what is it?
There was a problem hiding this comment.
The 4 vertices form the 2 triangles covering the rectangular viewport.
| // Our vertex shader uses a trick from Bill Bilodeau published in | ||
| // "Vertex Shader Tricks" at GDC14 to draw a fullscreen triangle | ||
| // without vertex/index buffers. This prepares our context for this. | ||
| _r.deviceContext->IASetVertexBuffers(0, 0, nullptr, nullptr, nullptr); | ||
| _r.deviceContext->IASetIndexBuffer(nullptr, DXGI_FORMAT_UNKNOWN, 0); | ||
| _r.deviceContext->IASetInputLayout(nullptr); | ||
| _r.deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); | ||
| _r.deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); |
There was a problem hiding this comment.
any meaningful difference here for Atlas w/o shaders?
There was a problem hiding this comment.
No, there shouldn't be any difference. Both a list and a strip require at least 3 vertices to define the initial rectangle. But specifying 4 vertices is invalid for a triangle list (which expects a list of distinct triangles) and valid for a strip (which appends the 4th and following vertex to the initial triangle to form a "strip").
DHowett
approved these changes
Aug 31, 2022
|
@msftbot make sure @winobjc-bot signs off |
ghost
added
the
AutoMerge
|
Hello @DHowett! Because you've given me some instructions on how to help merge this pull request, I'll be modifying my merge approach. Here's how I understand your requirements for merging this pull request:
If this doesn't seem right to you, you can tell me to cancel these instructions and use the auto-merge policy that has been configured for this repository. Try telling me "forget everything I just told you". |
DHowett
pushed a commit
that referenced
this pull request
Sep 9, 2022
AtlasEngine: Implement LRU invalidation for glyph tiles (#13458) So far AtlasEngine would only grow the backing texture atlas once it gets full, without the ability to reuse tiles once it gets full. This commit adds LRU capabilities to the glyph-to-tile hashmap, allowing us to reuse the least recently used tiles for new ones once the atlas texture is full. This commit uses a quadratic growth factor with power-of-2 textures, resulting in a backing atlas of 1x to 2x the size of the window. While AtlasEngine is still incapable of shrinking the texture, it'll now at least not grow to 128MB or result in weird glitches under most circumstances. * Print `utf8_sequence_0-0x2ffff_assigned_printable_unseparated.txt` from https://github.com/bits/UTF-8-Unicode-Test-Documents * Scroll back up to the top * PowerShell input line is still there rendering as ASCII. ✅ AtlasEngine: Improve glyph generation performance (#13477) so that we stop running out of GPU memory for complex Unicode. This however can result in our glyph generation being a performance issue in edge cases, to the point that the application may feel outright unuseable. CJK glyphs for instance can easily exceed the maximum atlas texture size (twice the window size), but take a significant amount of CPU and GPU time to rasterize and draw, which results in "jelly scrolling" down to ~1 FPS. This PR improves the situation of the latter half by directly drawing glyphs into the texture atlas without an intermediate scratchpad texture. This reduces GPU usage by 96% on my system (33% -> 2%) which improves general render performance by ~100% (15 -> 30 FPS). CPU usage remains the same however, but that's not really something we can do anything about at this time. The atlas texture is already our primary means to reduce the CPU cost after all. * Disable V-Sync for OpenConsole in NVIDIA Control Panel * Enable `debugGlyphGenerationPerformance` * Print the entire CJK block U+4E00..U+9FFF * Measure the above GPU usage and FPS improvements ✅ (Alternatively: Just scroll around and judge the "jellyness".) AtlasEngine: Fix bugs introduced in 66f4f9d and d74b66a (#13496) We only process glyphs within the dirtyRect, but glyphs outside of the dirtyRect are still in use and shouldn't be discarded. This is critical if someone uses a tool like tmux to split the terminal horizontally. If they then print a lot of Unicode text on just one side, we have to ensure that the (for example) plain ASCII glyphs on the other half of the viewport are still retained. The cursor was drawn without a clip rect, causing the entire atlas texture to be filled with black. This just so happened to work fine in Windows Terminal but relied on a race condition. Closes #13490 * Disappearing glyphs * Start `tmux` in `wsl` * Split horizontally with `Ctrl+B`, `"` * `cat` a huge Unicode text file on the bottom * Ensure ASCII glyphs in the top half don't disappear ✅ * Black viewport after font changes * Start `OpenConsole` with `AtlasEngine` * Open Properties dialog and click "Ok" * Viewport content doesn't disappear ✅ AtlasEngine: Improve robustness against TextBuffer bugs (#13530) The current TextBuffer implementation will happily overwrite the leading/trailing half of a wide glyph with a narrow one without padding the other half with whitespace. This could crash AtlasEngine which aggressively guarded against such inconsistencies. Closes #13522 * Run .bat file linked in #13522 (Override wide glyph with a single space.) * `AtlasEngine` doesn't crash ✅ AtlasEngine: Handle IntenseIsBold (#13577) This change adds support for the `IntenseIsBold` rendering setting. Windows Terminal for instance defaults to `false` here, causing intense colors to only be bright but not bold. * Set "Intense text style" to "Bright colors" * Enable AtlasEngine * Print ``echo "`e[1mtest`e[0m"`` * "test" appears as bright without being bold ✅ AtlasEngine: Fix LRU state after scrolling (#13607) 66f4f9d had another bug: Just like how we scroll our viewport by `memmove`ing the `_r.cells` array, we also have to `memmove` the new `_r.cellGlyphMapping`. Without this fix drawing lots of glyphs while only scrolling slightly (= not invalidating the entire viewport), would erroneously call `makeNewest` on glyphs now outside of the viewport. This would cause actually visible glyphs to be recycled and overwritten by new ones. * Switch to Cascadia Code * Print some text that fills the glyph atlas * Scroll down by a few rows * Write a long "==========" ligature (this quickly fills up any remaining space in the atlas and exacerbates the issue) * Unrelated rows don't get corrupted ✅ AtlasEngine: Remove support for Windows 7 (#13608) We recently figured that we can drop support for Windows 7. Coincidentally AtlasEngine never actually supported Windows 7 properly, because it called `ResizeBuffers` with `DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT` no matter whether the swap chain was created with it enabled. The new minimally supported version is Windows 8.1. AtlasEngine: Implement remaining grid lines (#13587) This commit implements the remaining 5 of 8 grid lines: left/top/right/bottom (COMMON_LVB) borders and double underline `AtlasEngine::_resolveFontMetrics` was partially refactored to use `float`s instead of `double`s, because that's what the remaining code uses as well. It also helps the new, slightly more complex double underline calculation. * Print characters with the `COMMON_LVB_GRID_HORIZONTAL`, `GRID_LVERTICAL`, `GRID_RVERTICAL` and `UNDERSCORE` attributes via `WriteConsoleOutputW` * All 4 grid lines are visible ✅ * Grid lines correctly scale according to the `lineWidth` ✅ * Print a double underline with `printf "\033[21mtest\033[0m"` * A double underline is fully visible ✅ AtlasEngine: Scale glyphs to better fit the cell size (#13549) This commit contains 3 improvements for glyph rendering: * Scale block element and box drawing characters to fit the cell size "perfectly" without leaving pixel gaps between cells. * Use `IDWriteTextLayout::GetOverhangMetrics` to determine whether glyphs are outside the given layout box and if they are, offset their position to fit them back in. If that still fails to fit, we downscale them. * Always scale up glyphs that are more than 2 cells wide This ensures that long ligatures that mimic box drawing characters like "===" under Cascadia Code are upscaled just like regular box drawings. Unfortunately this results in ligature-heavy text (like Myanmar) to get an "uneven" appearance because some ligatures can suddenly appear too large. It's difficult to come up with a good heuristic here. Closes #12512 * Print UTF-8-demo.txt * Block characters don't leave gaps ✅ * Print a lorem-ipsum in Myanmar * Glyphs aren't cut off anymore ✅ * Print a long "===" ligature under Cascadia Code * The ligature is as wide as the number of cells used ✅ AtlasEngine: Recognize Powerline glyphs (#13650) This commit makes AtlasEngine recognize Powerline glyphs as box drawing ones. The extra pixel offsets when determining the `scale` caused weird artifacts and thus were removed. It seems like this causes no noticeable regressions. Closes #13029 * Run all values of `wchar_t` through `isInInversionList` and ensure it produces the expected value ✅ * Powerline glyphs are correctly scaled with Cascadia Code PL ✅ AtlasEngine: Fix debugGlyphGenerationPerformance (#13757) `debugGlyphGenerationPerformance` used to only test the performance of text segmentation/parsing, so I renamed it to `debugTextParsingPerformance`. The new `debugGlyphGenerationPerformance` actually clears the glyph atlas now. Additionally this fixes a bug with `debugGeneralPerformance`: If a `DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT` is requested, it needs to be used. Since `debugGeneralPerformance` is for testing without V-Sync, we need to ensure that the waitable object is properly disabled. AtlasEngine: Fix the fix for LRU state after scrolling (#13784) The absolute disgrace of a fix called 65b71ff failed to account for `std::move` being unsafe to use for overlapping ranges. While `std::move` works for trivial types (it happens to delegate to `memmove`), we need to dynamically switch between that and `std::move_backward` to be correct. Without this fix the LRU refresh is incorrect and might lead to crashes. I'm working on a new, pure D2D renderer inside AtlasEngine, which uses the iterators contained in `_r.cellGlyphMapping` to draw text. I noticed the bug, because scrolling up caused the text to be garbled and with this fix applied it works as expected. AtlasEngine: Round cell sizes to nearest instead of up (#13833) After some deliberation I noticed that rounding the glyph advance up to yield the cell width is at least just as wrong as rounding it. This is because we draw glyphs centered, meaning that (at least in theory) anti-aliased pixels might clip outside of the layout box on _both_ sides of the glyph adding not 1 but 2 extra pixels to the glyph size. Instead of just `ceilf` we would have had to use `ceilf(advanceWidth / 2) * 2` to account for that. This commit simplifies our issue by just going with what other applications do: Round all sizes (cell width and height) to the nearest pixel size. Closes #13812 * Set a breakpoint on `scaling Required == true` in `AtlasEngine::_drawGlyph` * Test an assortment of Cascadia Mono, Consolas, MS Gothic, Lucida Console at various font sizes (6, 7, 8, 10, 12, 24, ...) * Ensure breakpoint isn't hit ✅ This tells us that no glyph resizing was necessary AtlasEngine: Improve RDP performance (#13816) Direct2D is able to detect remote connections and will switch to sending draw commands across RDP instead of rendering the data on the server. This reduces the amount of data that needs to be transmitted as well as the CPU load of the server, if it has no GPU installed. This commit changes `AtlasEngine` to render with just Direct2D if a software or remote device was chosen by `D3D11CreateDevice`. Selecting the DXGI adapter the window is on explicitly in the future would allow us to be more precise here. This new rendering mode doesn't implement some of the more fancy features just yet, like inverted cursors or coloring a single wide glyph in multiple colors. It reuses most existing facilities and uses the existing tile hash map to cache DirectWrite text layouts to improve performance. Unfortunately this does incur a fairly high memory overhead of approximately 25MB for a 120x30 viewport. Additional drive-by changes include: * Treat the given font size exactly as its given without rounding Apparently we don't really need to round the font size to whole pixels * Stop updating the const buffer on every frame * Support window resizing if `debugGeneralPerformance` is enabled Closes #13079 * Tested fairly exhaustively over RDP ✅ AtlasEngine: Implement support for custom shaders (#13885) This commit implements support for custom shaders in AtlasEngine (`experimental.retroTerminalEffect` and `experimental.pixelShaderPath`). Setting these properties invalidates the device because that made it the easiest to implement this less often used feature. The retro shader was slightly rewritten so that it compiles without warnings. Additionally we noticed that AtlasEngine works well with D3D 10.0 hardware, so support for that was added bringing feature parity with DxRenderer. Closes #13853 * Default settings (Independent Flip) ✅ * ClearType (Independent Flip) ✅ * Retro Terminal Effect (Composed Flip) ✅ * Use wallpaper as background image (Composed Flip) ✅ * Running `color 40` draws everything red ✅ * With Retro Terminal Effect ✅ AtlasEngine: Add support for SetSoftwareRendering (#13886) This commit implements support for `experimental.rendering.software`. There's not much to it. It's just another 2 if conditions. * `"experimental.rendering.software": false` renders with D3D ✅ * `"experimental.rendering.software": true` triggers the new code path ✅ atlas: only enable continuous redraw if the shader needs it (#13903) We do this by detecting whether the shader is using variable 0 in constant buffer 0 (typically "time", but it can go by many names.) Closes #13901 AtlasEngine: Fix various bugs found in testing (#13906) In testing the following issues were found in AtlasEngine and fixed: 1. "Toggle terminal visual effects" action not working 2. `d2dMode` failed to work with transparent backgrounds 3. `GetSwapChainHandle()` is thread-unsafe due to it being called outside of the console lock and with single-threaded Direct2D enabled 4. 2 swap chain buffers are less performant than 3 5. Flip-Discard and `Present()` is less energy efficient than Flip-Sequential and `Present1()` 6. `d2dMode` used to copy the front to back buffer for partial rendering, but always redraw the entire dirty region anyways 7. Added support for DirectX 9 hardware 8. If custom shaders are used not all pixels would be presented Closes #13906 1. Toggling visual effects runs retro shader ✅ With a custom shader set, it toggles the shader ✅ Toggling `experimental.rendering.software` toggles the shader ✅ 2. `"backgroundImage": "desktopWallpaper"` works with D2D ✅ and D3D ✅ 3. Adding a `Sleep(3000)` in `_AttachDxgiSwapChainToXaml` doesn't break Windows 10 ✅ nor Windows 11 ✅ 4. Screen animations run at 144 FPS ✅ even while moving the window ✅ 5. No weird artefacts during cursor movement or scrolling ✅ 6. No weird artefacts during cursor movement or scrolling ✅ 7. Forcing DirectX 9.3 in `dxcpl` runs fine ✅ AtlasEngine: Fix a correctness bug (#13956) `ATLAS_POD_OPS` doesn't check for `has_unique_object_representations` and so a bug exists where `CachedCursorOptions` comparisons invoke undefined behavior.
|
🎉 Handy links: |
ghost
mentioned this pull request
DHowett
pushed a commit
that referenced
this pull request
Sep 21, 2022
AtlasEngine: Implement LRU invalidation for glyph tiles (#13458) So far AtlasEngine would only grow the backing texture atlas once it gets full, without the ability to reuse tiles once it gets full. This commit adds LRU capabilities to the glyph-to-tile hashmap, allowing us to reuse the least recently used tiles for new ones once the atlas texture is full. This commit uses a quadratic growth factor with power-of-2 textures, resulting in a backing atlas of 1x to 2x the size of the window. While AtlasEngine is still incapable of shrinking the texture, it'll now at least not grow to 128MB or result in weird glitches under most circumstances. * Print `utf8_sequence_0-0x2ffff_assigned_printable_unseparated.txt` from https://github.com/bits/UTF-8-Unicode-Test-Documents * Scroll back up to the top * PowerShell input line is still there rendering as ASCII. ✅ AtlasEngine: Improve glyph generation performance (#13477) so that we stop running out of GPU memory for complex Unicode. This however can result in our glyph generation being a performance issue in edge cases, to the point that the application may feel outright unuseable. CJK glyphs for instance can easily exceed the maximum atlas texture size (twice the window size), but take a significant amount of CPU and GPU time to rasterize and draw, which results in "jelly scrolling" down to ~1 FPS. This PR improves the situation of the latter half by directly drawing glyphs into the texture atlas without an intermediate scratchpad texture. This reduces GPU usage by 96% on my system (33% -> 2%) which improves general render performance by ~100% (15 -> 30 FPS). CPU usage remains the same however, but that's not really something we can do anything about at this time. The atlas texture is already our primary means to reduce the CPU cost after all. * Disable V-Sync for OpenConsole in NVIDIA Control Panel * Enable `debugGlyphGenerationPerformance` * Print the entire CJK block U+4E00..U+9FFF * Measure the above GPU usage and FPS improvements ✅ (Alternatively: Just scroll around and judge the "jellyness".) AtlasEngine: Fix bugs introduced in 66f4f9d and d74b66a (#13496) We only process glyphs within the dirtyRect, but glyphs outside of the dirtyRect are still in use and shouldn't be discarded. This is critical if someone uses a tool like tmux to split the terminal horizontally. If they then print a lot of Unicode text on just one side, we have to ensure that the (for example) plain ASCII glyphs on the other half of the viewport are still retained. The cursor was drawn without a clip rect, causing the entire atlas texture to be filled with black. This just so happened to work fine in Windows Terminal but relied on a race condition. Closes #13490 * Disappearing glyphs * Start `tmux` in `wsl` * Split horizontally with `Ctrl+B`, `"` * `cat` a huge Unicode text file on the bottom * Ensure ASCII glyphs in the top half don't disappear ✅ * Black viewport after font changes * Start `OpenConsole` with `AtlasEngine` * Open Properties dialog and click "Ok" * Viewport content doesn't disappear ✅ AtlasEngine: Improve robustness against TextBuffer bugs (#13530) The current TextBuffer implementation will happily overwrite the leading/trailing half of a wide glyph with a narrow one without padding the other half with whitespace. This could crash AtlasEngine which aggressively guarded against such inconsistencies. Closes #13522 * Run .bat file linked in #13522 (Override wide glyph with a single space.) * `AtlasEngine` doesn't crash ✅ AtlasEngine: Handle IntenseIsBold (#13577) This change adds support for the `IntenseIsBold` rendering setting. Windows Terminal for instance defaults to `false` here, causing intense colors to only be bright but not bold. * Set "Intense text style" to "Bright colors" * Enable AtlasEngine * Print ``echo "`e[1mtest`e[0m"`` * "test" appears as bright without being bold ✅ AtlasEngine: Fix LRU state after scrolling (#13607) 66f4f9d had another bug: Just like how we scroll our viewport by `memmove`ing the `_r.cells` array, we also have to `memmove` the new `_r.cellGlyphMapping`. Without this fix drawing lots of glyphs while only scrolling slightly (= not invalidating the entire viewport), would erroneously call `makeNewest` on glyphs now outside of the viewport. This would cause actually visible glyphs to be recycled and overwritten by new ones. * Switch to Cascadia Code * Print some text that fills the glyph atlas * Scroll down by a few rows * Write a long "==========" ligature (this quickly fills up any remaining space in the atlas and exacerbates the issue) * Unrelated rows don't get corrupted ✅ AtlasEngine: Remove support for Windows 7 (#13608) We recently figured that we can drop support for Windows 7. Coincidentally AtlasEngine never actually supported Windows 7 properly, because it called `ResizeBuffers` with `DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT` no matter whether the swap chain was created with it enabled. The new minimally supported version is Windows 8.1. AtlasEngine: Implement remaining grid lines (#13587) This commit implements the remaining 5 of 8 grid lines: left/top/right/bottom (COMMON_LVB) borders and double underline `AtlasEngine::_resolveFontMetrics` was partially refactored to use `float`s instead of `double`s, because that's what the remaining code uses as well. It also helps the new, slightly more complex double underline calculation. * Print characters with the `COMMON_LVB_GRID_HORIZONTAL`, `GRID_LVERTICAL`, `GRID_RVERTICAL` and `UNDERSCORE` attributes via `WriteConsoleOutputW` * All 4 grid lines are visible ✅ * Grid lines correctly scale according to the `lineWidth` ✅ * Print a double underline with `printf "\033[21mtest\033[0m"` * A double underline is fully visible ✅ AtlasEngine: Scale glyphs to better fit the cell size (#13549) This commit contains 3 improvements for glyph rendering: * Scale block element and box drawing characters to fit the cell size "perfectly" without leaving pixel gaps between cells. * Use `IDWriteTextLayout::GetOverhangMetrics` to determine whether glyphs are outside the given layout box and if they are, offset their position to fit them back in. If that still fails to fit, we downscale them. * Always scale up glyphs that are more than 2 cells wide This ensures that long ligatures that mimic box drawing characters like "===" under Cascadia Code are upscaled just like regular box drawings. Unfortunately this results in ligature-heavy text (like Myanmar) to get an "uneven" appearance because some ligatures can suddenly appear too large. It's difficult to come up with a good heuristic here. Closes #12512 * Print UTF-8-demo.txt * Block characters don't leave gaps ✅ * Print a lorem-ipsum in Myanmar * Glyphs aren't cut off anymore ✅ * Print a long "===" ligature under Cascadia Code * The ligature is as wide as the number of cells used ✅ AtlasEngine: Recognize Powerline glyphs (#13650) This commit makes AtlasEngine recognize Powerline glyphs as box drawing ones. The extra pixel offsets when determining the `scale` caused weird artifacts and thus were removed. It seems like this causes no noticeable regressions. Closes #13029 * Run all values of `wchar_t` through `isInInversionList` and ensure it produces the expected value ✅ * Powerline glyphs are correctly scaled with Cascadia Code PL ✅ AtlasEngine: Fix debugGlyphGenerationPerformance (#13757) `debugGlyphGenerationPerformance` used to only test the performance of text segmentation/parsing, so I renamed it to `debugTextParsingPerformance`. The new `debugGlyphGenerationPerformance` actually clears the glyph atlas now. Additionally this fixes a bug with `debugGeneralPerformance`: If a `DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT` is requested, it needs to be used. Since `debugGeneralPerformance` is for testing without V-Sync, we need to ensure that the waitable object is properly disabled. AtlasEngine: Fix the fix for LRU state after scrolling (#13784) The absolute disgrace of a fix called 65b71ff failed to account for `std::move` being unsafe to use for overlapping ranges. While `std::move` works for trivial types (it happens to delegate to `memmove`), we need to dynamically switch between that and `std::move_backward` to be correct. Without this fix the LRU refresh is incorrect and might lead to crashes. I'm working on a new, pure D2D renderer inside AtlasEngine, which uses the iterators contained in `_r.cellGlyphMapping` to draw text. I noticed the bug, because scrolling up caused the text to be garbled and with this fix applied it works as expected. AtlasEngine: Round cell sizes to nearest instead of up (#13833) After some deliberation I noticed that rounding the glyph advance up to yield the cell width is at least just as wrong as rounding it. This is because we draw glyphs centered, meaning that (at least in theory) anti-aliased pixels might clip outside of the layout box on _both_ sides of the glyph adding not 1 but 2 extra pixels to the glyph size. Instead of just `ceilf` we would have had to use `ceilf(advanceWidth / 2) * 2` to account for that. This commit simplifies our issue by just going with what other applications do: Round all sizes (cell width and height) to the nearest pixel size. Closes #13812 * Set a breakpoint on `scaling Required == true` in `AtlasEngine::_drawGlyph` * Test an assortment of Cascadia Mono, Consolas, MS Gothic, Lucida Console at various font sizes (6, 7, 8, 10, 12, 24, ...) * Ensure breakpoint isn't hit ✅ This tells us that no glyph resizing was necessary AtlasEngine: Improve RDP performance (#13816) Direct2D is able to detect remote connections and will switch to sending draw commands across RDP instead of rendering the data on the server. This reduces the amount of data that needs to be transmitted as well as the CPU load of the server, if it has no GPU installed. This commit changes `AtlasEngine` to render with just Direct2D if a software or remote device was chosen by `D3D11CreateDevice`. Selecting the DXGI adapter the window is on explicitly in the future would allow us to be more precise here. This new rendering mode doesn't implement some of the more fancy features just yet, like inverted cursors or coloring a single wide glyph in multiple colors. It reuses most existing facilities and uses the existing tile hash map to cache DirectWrite text layouts to improve performance. Unfortunately this does incur a fairly high memory overhead of approximately 25MB for a 120x30 viewport. Additional drive-by changes include: * Treat the given font size exactly as its given without rounding Apparently we don't really need to round the font size to whole pixels * Stop updating the const buffer on every frame * Support window resizing if `debugGeneralPerformance` is enabled Closes #13079 * Tested fairly exhaustively over RDP ✅ AtlasEngine: Implement support for custom shaders (#13885) This commit implements support for custom shaders in AtlasEngine (`experimental.retroTerminalEffect` and `experimental.pixelShaderPath`). Setting these properties invalidates the device because that made it the easiest to implement this less often used feature. The retro shader was slightly rewritten so that it compiles without warnings. Additionally we noticed that AtlasEngine works well with D3D 10.0 hardware, so support for that was added bringing feature parity with DxRenderer. Closes #13853 * Default settings (Independent Flip) ✅ * ClearType (Independent Flip) ✅ * Retro Terminal Effect (Composed Flip) ✅ * Use wallpaper as background image (Composed Flip) ✅ * Running `color 40` draws everything red ✅ * With Retro Terminal Effect ✅ AtlasEngine: Add support for SetSoftwareRendering (#13886) This commit implements support for `experimental.rendering.software`. There's not much to it. It's just another 2 if conditions. * `"experimental.rendering.software": false` renders with D3D ✅ * `"experimental.rendering.software": true` triggers the new code path ✅ atlas: only enable continuous redraw if the shader needs it (#13903) We do this by detecting whether the shader is using variable 0 in constant buffer 0 (typically "time", but it can go by many names.) Closes #13901 AtlasEngine: Fix various bugs found in testing (#13906) In testing the following issues were found in AtlasEngine and fixed: 1. "Toggle terminal visual effects" action not working 2. `d2dMode` failed to work with transparent backgrounds 3. `GetSwapChainHandle()` is thread-unsafe due to it being called outside of the console lock and with single-threaded Direct2D enabled 4. 2 swap chain buffers are less performant than 3 5. Flip-Discard and `Present()` is less energy efficient than Flip-Sequential and `Present1()` 6. `d2dMode` used to copy the front to back buffer for partial rendering, but always redraw the entire dirty region anyways 7. Added support for DirectX 9 hardware 8. If custom shaders are used not all pixels would be presented Closes #13906 1. Toggling visual effects runs retro shader ✅ With a custom shader set, it toggles the shader ✅ Toggling `experimental.rendering.software` toggles the shader ✅ 2. `"backgroundImage": "desktopWallpaper"` works with D2D ✅ and D3D ✅ 3. Adding a `Sleep(3000)` in `_AttachDxgiSwapChainToXaml` doesn't break Windows 10 ✅ nor Windows 11 ✅ 4. Screen animations run at 144 FPS ✅ even while moving the window ✅ 5. No weird artefacts during cursor movement or scrolling ✅ 6. No weird artefacts during cursor movement or scrolling ✅ 7. Forcing DirectX 9.3 in `dxcpl` runs fine ✅ AtlasEngine: Fix a correctness bug (#13956) `ATLAS_POD_OPS` doesn't check for `has_unique_object_representations` and so a bug exists where `CachedCursorOptions` comparisons invoke undefined behavior. Relax shader strictness in RELEASE mode (#13998) Disables strictness and warnings as errors for custom pixel shaders in RELEASE. Windows terminal is not telling the user why the shader won't compile which makes it very frustrating for the shader hacker. After trying the recent preview none of my shaders loaded anymore in Windows Terminal Preview which made me very sad. I had no idea what was wrong with them. After cloning the git repo, building it, fighting an issue that prevent DEBUG SDK from being used I finally was able to identify some issues that were blocking my shaders. > error X3556: integer modulus may be much slower, try using uints if possible. > error X4000: use of potentially uninitialized variable (rayCylinder) While the first one is a good warning I don't think it is an error and the tools I use didn't flag it so was hard to know. The second one I was staring at the code and was unable to identify what exactly was causing the issues, I fumbled with the code a few times and just felt the fun drain away. IMHO: I want it to be fun to develop shaders for windows terminal. Fighting invisible errors are not fun. I am not after building production shaders for Windows Terminal, I want some cool effects. So while I am as a .NET developer always runs with Warning as errors I don't think it's the right option here. Especially since Windows Terminal doesn't tell what is the problem. However, I understand if the shaders you ship with Windows Terminal should be free of errors and silly mistakes, so I kept the stricter setting in DEBUG mode. Loaded Windows Terminal in RELEASE and DEBUG mode and validated that RELEASE mode had reduced strictness but DEBUG retained the previous more restrictive mode. (cherry picked from commit b4b6636) Service-Card-Id: 85660397 Service-Version: 1.16 (cherry picked from commit b899d49) AtlasEngine: Properly detect shader model 4 support (#13994) Direct3D 10.0 and 10.1 only have optional support for shader model 4. This commit fixes our assumption that it's always present by checking `ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x` first. Closes #13985 * Set feature level to 10.1 via `dxcpl` * `CheckFeatureSupport` is called and doesn't throw ✅ (cherry picked from commit e2b2d9b) Service-Card-Id: 85653388 Service-Version: 1.16 (cherry picked from commit 5e9147e) AtlasEngine: Fix a crash when drawing double width rows (#13966) The `TileHashMap` refresh via `makeNewest()` in `StartPaint()` depends on us filling the entire `cellGlyphMapping` row with valid data. This commit makes sure to initialize the `cellGlyphMapping` buffer. Additionally it clears the rest of the row with whitespace until proper `LineRendition` support is added. Closes #13962 * vttest's "Test of double-sized characters" stops crashing ✅ * No weird leftover characters ✅ (cherry picked from commit 16aa79d) Service-Card-Id: 85653281 Service-Version: 1.16 (cherry picked from commit c2c5f41) AtlasEngine: Fix bugs around bitmap font rendering (#14014) This commit fixes several issues: * Some fonts set a line-gap even though they behave as if they don't want any line-gaps. Since Terminals don't really have any gaps anyways, it'll now not be taken into account anymore. * Center alignment breaks bitmap glyphs which expect left-alignment. * Automatic "opsz" axis makes Terminus TTF's italic glyphs look quite weird. I disabled this feature as we might not need it anyways. A complete fix depends on #14013 Closes #14006 * Use Terminus TTF at 13.5pt * Print UTF-8-demo.txt * No gaps between block characters ✅ (cherry picked from commit bea13bd) Service-Card-Id: 85767355 Service-Version: 1.16 (cherry picked from commit 9310db5) AtlasEngine: Fix cursor invalidation (#14038) There's a different behavior regarding cursors between conhost and Windows Terminal. In case of the latter we don't necessarily call `PaintCursor` during cursor movement, because the cursor blinker never stops "blinking". Closes #14028 * Enter text until after the line wraps * Hold backspace until the line unwraps * No leftover cursor on the second line ✅ (cherry picked from commit 08096b2) Service-Card-Id: 85767353 Service-Version: 1.16 (cherry picked from commit 9d0346c)
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This commit implements support for custom shaders in AtlasEngine
(
experimental.retroTerminalEffectandexperimental.pixelShaderPath).Setting these properties invalidates the device because that made it
the easiest to implement this less often used feature.
The retro shader was slightly rewritten so that it compiles without warnings.
Additionally we noticed that AtlasEngine works well with D3D 10.0 hardware,
so support for that was added bringing feature parity with DxRenderer.
Closes #13853
Validation Steps Performed
color 40draws everything red ✅