2019-05-03 00:29:04 +02:00
|
|
|
// Copyright (c) Microsoft Corporation.
|
|
|
|
|
// Licensed under the MIT license.
|
|
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
|
|
#include "../../renderer/inc/RenderEngineBase.hpp"
|
|
|
|
|
|
2019-06-21 02:51:04 +02:00
|
|
|
#include <functional>
|
|
|
|
|
|
2019-05-03 00:29:04 +02:00
|
|
|
#include <dxgi.h>
|
|
|
|
|
#include <dxgi1_2.h>
|
|
|
|
|
|
|
|
|
|
#include <d3d11.h>
|
|
|
|
|
#include <d2d1.h>
|
|
|
|
|
#include <d2d1helper.h>
|
|
|
|
|
#include <dwrite.h>
|
|
|
|
|
#include <dwrite_1.h>
|
|
|
|
|
#include <dwrite_2.h>
|
|
|
|
|
#include <dwrite_3.h>
|
|
|
|
|
|
|
|
|
|
#include <wrl.h>
|
|
|
|
|
#include <wrl/client.h>
|
|
|
|
|
|
|
|
|
|
#include "CustomTextRenderer.h"
|
|
|
|
|
|
|
|
|
|
#include "../../types/inc/Viewport.hpp"
|
|
|
|
|
|
2020-02-21 00:13:43 +01:00
|
|
|
#include <TraceLoggingProvider.h>
|
|
|
|
|
|
|
|
|
|
TRACELOGGING_DECLARE_PROVIDER(g_hDxRenderProvider);
|
|
|
|
|
|
2019-05-03 00:29:04 +02:00
|
|
|
namespace Microsoft::Console::Render
|
|
|
|
|
{
|
|
|
|
|
class DxEngine final : public RenderEngineBase
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
DxEngine();
|
2019-09-03 23:14:07 +02:00
|
|
|
~DxEngine();
|
2019-09-03 22:45:16 +02:00
|
|
|
DxEngine(const DxEngine&) = default;
|
|
|
|
|
DxEngine(DxEngine&&) = default;
|
|
|
|
|
DxEngine& operator=(const DxEngine&) = default;
|
|
|
|
|
DxEngine& operator=(DxEngine&&) = default;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
// Used to release device resources so that another instance of
|
|
|
|
|
// conhost can render to the screen (i.e. only one DirectX
|
|
|
|
|
// application may control the screen at a time.)
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT Enable() noexcept;
|
|
|
|
|
[[nodiscard]] HRESULT Disable() noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT SetHwnd(const HWND hwnd) noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT SetWindowSize(const SIZE pixels) noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
void SetCallback(std::function<void()> pfn);
|
|
|
|
|
|
2019-12-12 14:44:01 +01:00
|
|
|
void SetRetroTerminalEffects(bool enable) noexcept;
|
|
|
|
|
|
2019-08-30 00:23:07 +02:00
|
|
|
::Microsoft::WRL::ComPtr<IDXGISwapChain1> GetSwapChain();
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
// IRenderEngine Members
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT Invalidate(const SMALL_RECT* const psrRegion) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT InvalidateCursor(const COORD* const pcoordCursor) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT InvalidateSystem(const RECT* const prcDirtyClient) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT InvalidateSelection(const std::vector<SMALL_RECT>& rectangles) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT InvalidateScroll(const COORD* const pcoordDelta) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT InvalidateAll() noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT InvalidateCircling(_Out_ bool* const pForcePaint) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT PrepareForTeardown(_Out_ bool* const pForcePaint) noexcept override;
|
|
|
|
|
|
|
|
|
|
[[nodiscard]] HRESULT StartPaint() noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT EndPaint() noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT Present() noexcept override;
|
|
|
|
|
|
|
|
|
|
[[nodiscard]] HRESULT ScrollFrame() noexcept override;
|
|
|
|
|
|
|
|
|
|
[[nodiscard]] HRESULT PaintBackground() noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT PaintBufferLine(std::basic_string_view<Cluster> const clusters,
|
|
|
|
|
COORD const coord,
|
Make Conpty emit wrapped lines as actually wrapped lines (#4415)
## Summary of the Pull Request
Changes how conpty emits text to preserve line-wrap state, and additionally adds rudimentary support to the Windows Terminal for wrapped lines.
## References
* Does _not_ fix (!) #3088, but that might be lower down in conhost. This makes wt behave like conhost, so at least there's that
* Still needs a proper deferred EOL wrap implementation in #780, which is left as a todo
* #4200 is the mega bucket with all this work
* MSFT:16485846 was the first attempt at this task, which caused the regression MSFT:18123777 so we backed it out.
* #4403 - I made sure this worked with that PR before I even sent #4403
## PR Checklist
* [x] Closes #405
* [x] Closes #3367
* [x] I work here
* [x] Tests added/passed
* [n/a] Requires documentation to be updated
## Detailed Description of the Pull Request / Additional comments
I started with the following implementation:
When conpty is about to write the last column, note that we wrapped this line here. If the next character the vt renderer is told to paint get is supposed to be at the start of the following line, then we know that the previous line had wrapped, so we _won't_ emit the usual `\r\n` here, and we'll just continue emitting text.
However, this isn't _exactly_ right - if someone fills the row _exactly_ with text, the information that's available to the vt renderer isn't enough to know for sure if this line broke or not. It is possible for the client to write a full line of text, with a `\n` at the end, to manually break the line. So, I had to also add the `lineWrapped` param to the `IRenderEngine` interface, which is about half the files in this changelist.
## Validation Steps Performed
* Ran tests
* Checked how the Windows Terminal behaves with these changes
* Made sure that conhost/inception and gnome-terminal both act as you'd expect with wrapped lines from conpty
2020-02-27 17:40:11 +01:00
|
|
|
bool const fTrimLeft,
|
|
|
|
|
const bool lineWrapped) noexcept override;
|
2019-06-11 22:27:09 +02:00
|
|
|
|
|
|
|
|
[[nodiscard]] HRESULT PaintBufferGridLines(GridLines const lines, COLORREF const color, size_t const cchLine, COORD const coordTarget) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT PaintSelection(const SMALL_RECT rect) noexcept override;
|
|
|
|
|
|
|
|
|
|
[[nodiscard]] HRESULT PaintCursor(const CursorOptions& options) noexcept override;
|
|
|
|
|
|
|
|
|
|
[[nodiscard]] HRESULT UpdateDrawingBrushes(COLORREF const colorForeground,
|
|
|
|
|
COLORREF const colorBackground,
|
|
|
|
|
const WORD legacyColorAttribute,
|
Add support for passing through extended text attributes, like… (#2917)
## Summary of the Pull Request
Adds support for Italics, Blinking, Invisible, CrossedOut text, THROUGH CONPTY. This does **NOT** add support for those styles to conhost or the terminal.
We will store these "Extended Text Attributes" in a `TextAttribute`. When we go to render a line, we'll see if the state has changed from our previous state, and if so, we'll appropriately toggle that state with VT. Boldness has been moved from a `bool` to a single bit in these flags.
Technically, now that these are stored in the buffer, we only need to make changes to the renderers to be able to support them. That's not being done as a part of this PR however.
## References
See also #2915 and #2916, which are some follow-up tasks from this fix. I thought them too risky for 20H1.
## PR Checklist
* [x] Closes #2554
* [x] I work here
* [x] Tests added/passed
* [n/a] Requires documentation to be updated
<hr>
* store text with extended attributes too
* Plumb attributes through all the renderers
* parse extended attrs, though we're not renderering them right
* Render these states correctly
* Add a very extensive test
* Cleanup for PR
* a block of PR feedback
* add 512 test cases
* Fix the build
* Fix @carlos-zamora's suggestions
* @miniksa's PR feedback
2019-10-04 22:53:54 +02:00
|
|
|
const ExtendedAttributes extendedAttrs,
|
2019-06-11 22:27:09 +02:00
|
|
|
bool const isSettingDefaultBrushes) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT UpdateFont(const FontInfoDesired& fiFontInfoDesired, FontInfo& fiFontInfo) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT UpdateDpi(int const iDpi) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT UpdateViewport(const SMALL_RECT srNewViewport) noexcept override;
|
|
|
|
|
|
|
|
|
|
[[nodiscard]] HRESULT GetProposedFont(const FontInfoDesired& fiFontInfoDesired, FontInfo& fiFontInfo, int const iDpi) noexcept override;
|
|
|
|
|
|
Move ConPTY to use til::bitmap (#5024)
## Summary of the Pull Request
Moves the ConPTY drawing mechanism (`VtRenderer`) to use the fine-grained `til::bitmap` individual-dirty-bit tracking mechanism instead of coarse-grained rectangle unions to improve drawing performance by dramatically reducing the total area redrawn.
## PR Checklist
* [x] Part of #778 and #1064
* [x] I work here
* [x] Tests added and updated.
* [x] I'm a core contributor
## Detailed Description of the Pull Request / Additional comments
- Converted `GetDirtyArea()` interface from `IRenderEngine` to use a vector of `til::rectangle` instead of the `SMALL_RECT` to banhammer inclusive rectangles.
- `VtEngine` now holds and operates on the `til::bitmap` for invalidation regions. All invalidation operation functions that used to be embedded inside `VtEngine` are deleted in favor of using the ones in `til::bitmap`.
- Updated `VtEngine` tracing to use new `til::bitmap` on trace and the new `to_string()` methods detailed below.
- Comparison operators for `til::bitmap` and complementary tests.
- Fixed an issue where the dirty rectangle shortcut in `til::bitmap` was set to 0,0,0,0 by default which means that `|=` on it with each `set()` operation was stretching the rectangle from 0,0. Now it's a `std::optional` so it has no value after just being cleared and will build from whatever the first invalidated rectangle is. Complementary tests added.
- Optional run caching for `til::bitmap` in the `runs()` method since both VT and DX renderers will likely want to generate the set of runs at the beginning of a frame and refer to them over and over through that frame. Saves the iteration and creation and caches inside `til::bitmap` where the chance of invalidation of the underlying data is known best. It is still possible to iterate manually with `begin()` and `end()` from the outside without caching, if desired. Complementary tests added.
- WEX templates added for `til::bitmap` and used in tests.
- `translate()` method for `til::bitmap` which will slide the dirty points in the direction specified by a `til::point` and optionally back-fill the uncovered area as dirty. Complementary tests added.
- Moves all string generation for `til` types `size`, `point`, `rectangle`, and `some` into a `to_string` method on each object such that it can be used in both ETW tracing scenarios AND in the TAEF templates uniformly. Adds a similar method for `bitmap`.
- Add tagging to `_bitmap_const_iterator` such that it appears as a valid **Input Iterator** to STL collections and can be used in a `std::vector` constructor as a range. Adds and cleans up operators on this iterator to match the theoretical requirements for an **Input Iterator**. Complementary tests added.
- Add loose operators to `til` which will allow some basic math operations (+, -, *, /) between `til::size` and `til::point` and vice versa. Complementary tests added. Complementary tests added.
- Adds operators to `til::rectangle` to allow scaling with basic math operations (+, -, *) versus `til::size` and translation with basic math operations (+, -) against `til::point`. Complementary tests added.
- In-place variants of some operations added to assorted `til` objects. Complementary tests added.
- Update VT tests to compare invalidation against the new map structure instead of raw rectangles where possible.
## Validation Steps Performed
- Wrote additional til Unit Tests for all additional operators and functions added to the project to support this operation
- Updated the existing VT renderer tests
- Ran perf check
2020-03-23 16:57:54 +01:00
|
|
|
[[nodiscard]] std::vector<til::rectangle> GetDirtyArea() override;
|
2019-06-11 22:27:09 +02:00
|
|
|
|
|
|
|
|
[[nodiscard]] HRESULT GetFontSize(_Out_ COORD* const pFontSize) noexcept override;
|
|
|
|
|
[[nodiscard]] HRESULT IsGlyphWideByFont(const std::wstring_view glyph, _Out_ bool* const pResult) noexcept override;
|
|
|
|
|
|
|
|
|
|
[[nodiscard]] ::Microsoft::Console::Types::Viewport GetViewportInCharacters(const ::Microsoft::Console::Types::Viewport& viewInPixels) noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
float GetScaling() const noexcept;
|
|
|
|
|
|
2019-11-13 19:17:39 +01:00
|
|
|
void SetSelectionBackground(const COLORREF color) noexcept;
|
2020-02-25 23:19:57 +01:00
|
|
|
void SetAntialiasingMode(const D2D1_TEXT_ANTIALIAS_MODE antialiasingMode) noexcept;
|
2020-04-24 19:16:34 +02:00
|
|
|
void SetDefaultTextBackgroundOpacity(const float opacity) noexcept;
|
2019-11-13 19:17:39 +01:00
|
|
|
|
2019-05-03 00:29:04 +02:00
|
|
|
protected:
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT _DoUpdateTitle(_In_ const std::wstring& newTitle) noexcept override;
|
2019-12-12 14:44:01 +01:00
|
|
|
[[nodiscard]] HRESULT _PaintTerminalEffects() noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
enum class SwapChainMode
|
|
|
|
|
{
|
|
|
|
|
ForHwnd,
|
|
|
|
|
ForComposition
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
SwapChainMode _chainMode;
|
|
|
|
|
|
|
|
|
|
HWND _hwndTarget;
|
2020-04-13 22:09:02 +02:00
|
|
|
til::size _sizeTarget;
|
2019-05-03 00:29:04 +02:00
|
|
|
int _dpi;
|
|
|
|
|
float _scale;
|
Adjusts High DPI scaling to enable differential rendering (#5345)
## Summary of the Pull Request
- Adjusts scaling practices in `DxEngine` (and related scaling practices in `TerminalControl`) for pixel-perfect row baselines and spacing at High DPI such that differential row-by-row rendering can be applied at High DPI.
## References
- #5185
## PR Checklist
* [x] Closes #5320, closes #3515, closes #1064
* [x] I work here.
* [x] Manually tested.
* [x] No doc.
* [x] Am core contributor. Also discussed with some of them already via Teams.
## Detailed Description of the Pull Request / Additional comments
**WAS:**
- We were using implicit DPI scaling on the `ID2D1RenderTarget` and running all of our processing in DIPs (Device-Independent Pixels). That's all well and good for getting things bootstrapped quickly, but it leaves the actual scaling of the draw commands up to the discretion of the rendering target.
- When we don't get to explicitly choose exactly how many pixels tall/wide and our X/Y placement perfectly, the nature of floating point multiplication and division required to do the presentation can cause us to drift off slightly out of our control depending on what the final display resolution actually is.
- Differential drawing cannot work unless we can know the exact integer pixels that need to be copied/moved/preserved/replaced between frames to give to the `IDXGISwapChain1::Present1` method. If things spill into fractional pixels or the sizes of rows/columns vary as they are rounded up and down implicitly, then we cannot do the differential rendering.
**NOW:**
- When deciding on a font, the `DxEngine` will take the scale factor into account and adjust the proposed height of the requested font. Then the remainder of the existing code that adjusts the baseline and integer-ifies each character cell will run naturally from there. That code already works correctly to align the height at normal DPI and scale out the font heights and advances to take an exact integer of pixels.
- `TermControl` has to use the scale now, in some places, and stop scaling in other places. This has to do with how the target's nature used to be implicit and is now explicit. For instance, determining where the cursor click hits must be scaled now. And determining the pixel size of the display canvas must no longer be scaled.
- `DxEngine` will no longer attempt to scale the invalid regions per my attempts in #5185 because the cell size is scaled. So it should work the same as at 96 DPI.
- The block is removed from the `DxEngine` that was causing a full invalidate on every frame at High DPI.
- A TODO was removed from `TermControl` that was invalidating everything when the DPI changed because the underlying renderer will already do that.
## Validation Steps Performed
* [x] Check at 150% DPI. Print text, scroll text down and up, do selection.
* [x] Check at 100% DPI. Print text, scroll text down and up, do selection.
* [x] Span two different DPI monitors and drag between them.
* [x] Giant pile of tests in https://github.com/microsoft/terminal/pull/5345#issuecomment-614127648
Co-authored-by: Dustin Howett <duhowett@microsoft.com>
Co-authored-by: Mike Griese <migrie@microsoft.com>
2020-04-22 23:59:51 +02:00
|
|
|
float _prevScale;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
std::function<void()> _pfn;
|
|
|
|
|
|
|
|
|
|
bool _isEnabled;
|
|
|
|
|
bool _isPainting;
|
|
|
|
|
|
2020-04-13 22:09:02 +02:00
|
|
|
til::size _displaySizePixels;
|
|
|
|
|
til::size _glyphCell;
|
Scale box drawing glyphs to fit cells for visual bliss (#5743)
## Summary of the Pull Request
Identifies and scales glyphs in the box and line drawing ranges U+2500-U+259F to fit their cells.
## PR Checklist
* [x] Closes #455
* [x] I work here.
* [x] Manual tests. This is all graphical.
* [x] Metric ton of comments
* [x] Math spreadsheet included in PR.
* [x] Double check RTL glyphs.
* [x] Why is there the extra pixel?
* [x] Scrolling the mouse wheel check is done.
* [x] Not drawing outline?
* [x] Am core contributor. Roar.
* [x] Try suppressing negative scale factors and see if that gets rid of weird shading.
## Detailed Description of the Pull Request / Additional comments
### Background
- We want the Terminal to be fast at drawing. To be fast at drawing, we perform differential drawing, or only drawing what is different from the previous frame. We use DXGI's `Present1` method to help us with this as it helps us compose only the deltas onto the previous frame at drawing time and assists us in scrolling regions from the previous frame without intervention. However, it only works on strictly integer pixel row heights.
- Most of the hit testing and size-calculation logic in both the `conhost` and the Terminal products are based on the size of an individual cell. Historically, a cell was always dictated in a `COORD` structure, or two `SHORT` values... which are integers. As such, when we specify the space for any individual glyph to be displayed inside our terminal drawing region, we want it to fall perfectly inside of an integer box to ensure all these other algorithms work correctly and continue to do so.
- Finally, we want the Terminal to have font fallback and locate glyphs that aren't in the primary selected font from any other font it can find on the system that contains the glyph, per DirectWrite's font fallback mechanisms. These glyphs won't necessarily have the same font or glyph metrics as the base font, but we need them to fit inside the same cell dimensions as if they did because the hit testing and other algorithms aren't aware of which particular font is sourcing each glyph, just the dimensions of the bounding box per cell.
### How does Terminal deal with this?
- When we select a font, we perform some calculations using the design metrics of the font and glyphs to determine how we could fit them inside a cell with integer dimensions. Our process here is that we take the requested font size (which is generally a proxy for height), find the matching glyph width for that height then round it to an integer. We back convert from that now integer width to a height value which is almost certainly now a floating point number. But because we need an integer box value, we add line padding above and below the glyphs to ensure that the height is an integer as well as the width. Finally, we don't add the padding strictly equally. We attempt to align the English baseline of the glyph box directly onto an integer pixel multiple so most characters sit crisply on a line when displayed.
- Note that fonts and their glyphs have a prescribed baseline, line gap, and advance values. We use those as guidelines to get us started, but then to meet our requirements, we pad out from those. This results in fonts that should be properly authored showing gaps. It also results in fonts that are improperly authored looking even worse than they normally would.
### Now how does block and line drawing come in?
- Block and Line drawing glyphs are generally authored so they will look fine when the font and glyph metrics are followed exactly as prescribed by the font. (For some fonts, this still isn't true and we want them to look fine anyway.)
- When we add additional padding or rounding to make glyphs fit inside of a cell, we can be adding more space than was prescribed around these glyphs. This can cause a gap to be visible.
- Additionally, when we move things like baselines to land on a perfect integer pixel, we may be drawing a glyph lower in the bounding box than was prescribed originally.
### And how do we solve it?
- We identify all glyphs in the line and block drawing ranges.
- We find the bounding boxes of both the cell and the glyph.
- We compare the height of the glyph to the height of the cell to see if we need to scale. We prescribe a scale transform if the glyph wouldn't be tall enough to fit the box. (We leave it alone otherwise as some glyphs intentionally overscan the box and scaling them can cause banding effects.)
- We inspect the overhang/underhang above and below the boxes and translate transform them (slide them) so they cover the entire cell area.
- We repeat the previous two steps but in the horizontal direction.
## Validation Steps Performed
- See these commments:
- https://github.com/microsoft/terminal/issues/455#issuecomment-620248375
- https://github.com/microsoft/terminal/issues/455#issuecomment-621533916
- https://github.com/microsoft/terminal/issues/455#issuecomment-622585453
Also see the below one with more screenshots:
- https://github.com/microsoft/terminal/pull/5743#issuecomment-624940567
2020-05-08 23:09:32 +02:00
|
|
|
::Microsoft::WRL::ComPtr<IBoxDrawingEffect> _boxDrawingEffect;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
D2D1_COLOR_F _defaultForegroundColor;
|
|
|
|
|
D2D1_COLOR_F _defaultBackgroundColor;
|
|
|
|
|
|
|
|
|
|
D2D1_COLOR_F _foregroundColor;
|
|
|
|
|
D2D1_COLOR_F _backgroundColor;
|
2019-11-13 19:17:39 +01:00
|
|
|
D2D1_COLOR_F _selectionBackground;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2020-04-13 22:09:02 +02:00
|
|
|
bool _firstFrame;
|
|
|
|
|
bool _invalidateFullRows;
|
|
|
|
|
til::bitmap _invalidMap;
|
|
|
|
|
til::point _invalidScroll;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
bool _presentReady;
|
2020-04-13 22:09:02 +02:00
|
|
|
std::vector<RECT> _presentDirty;
|
2019-05-03 00:29:04 +02:00
|
|
|
RECT _presentScroll;
|
|
|
|
|
POINT _presentOffset;
|
|
|
|
|
DXGI_PRESENT_PARAMETERS _presentParams;
|
|
|
|
|
|
2020-02-21 00:13:43 +01:00
|
|
|
static std::atomic<size_t> _tracelogCount;
|
|
|
|
|
|
2019-05-03 00:29:04 +02:00
|
|
|
static const ULONG s_ulMinCursorHeightPercent = 25;
|
|
|
|
|
static const ULONG s_ulMaxCursorHeightPercent = 100;
|
|
|
|
|
|
|
|
|
|
// Device-Independent Resources
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID2D1Factory> _d2dFactory;
|
2019-07-12 00:20:15 +02:00
|
|
|
::Microsoft::WRL::ComPtr<IDWriteFactory1> _dwriteFactory;
|
|
|
|
|
::Microsoft::WRL::ComPtr<IDWriteTextFormat> _dwriteTextFormat;
|
|
|
|
|
::Microsoft::WRL::ComPtr<IDWriteFontFace1> _dwriteFontFace;
|
2019-05-03 00:29:04 +02:00
|
|
|
::Microsoft::WRL::ComPtr<IDWriteTextAnalyzer1> _dwriteTextAnalyzer;
|
|
|
|
|
::Microsoft::WRL::ComPtr<CustomTextRenderer> _customRenderer;
|
2019-08-21 01:14:26 +02:00
|
|
|
::Microsoft::WRL::ComPtr<ID2D1StrokeStyle> _strokeStyle;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
// Device-Dependent Resources
|
|
|
|
|
bool _haveDeviceResources;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID3D11Device> _d3dDevice;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID3D11DeviceContext> _d3dDeviceContext;
|
|
|
|
|
::Microsoft::WRL::ComPtr<IDXGIFactory2> _dxgiFactory2;
|
|
|
|
|
::Microsoft::WRL::ComPtr<IDXGISurface> _dxgiSurface;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID2D1RenderTarget> _d2dRenderTarget;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID2D1SolidColorBrush> _d2dBrushForeground;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID2D1SolidColorBrush> _d2dBrushBackground;
|
|
|
|
|
::Microsoft::WRL::ComPtr<IDXGISwapChain1> _dxgiSwapChain;
|
|
|
|
|
|
2019-12-12 14:44:01 +01:00
|
|
|
// Terminal effects resources.
|
|
|
|
|
bool _retroTerminalEffects;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID3D11RenderTargetView> _renderTargetView;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID3D11VertexShader> _vertexShader;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID3D11PixelShader> _pixelShader;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID3D11InputLayout> _vertexLayout;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID3D11Buffer> _screenQuadVertexBuffer;
|
Scale retro terminal scan lines (#4716)
<!-- Enter a brief description/summary of your PR here. What does it fix/what does it change/how was it tested (even manually, if necessary)? -->
## Summary of the Pull Request
- Scale the retro terminal effects (#3468) scan lines with the screen's DPI.
- Remove artifacts from sampling wrap around.
Before & after, with my display scale set to 350%:
Before & after showing artifact removal, with my display scale set to 100%, and image enlarged to 400%:
<!-- Please review the items on the PR checklist before submitting-->
## PR Checklist
* [x] Closes #4362
* [x] CLA signed. If not, go over [here](https://cla.opensource.microsoft.com/microsoft/Terminal) and sign the CLA
* [ ] Tests added/passed
* [ ] Requires documentation to be updated
* [ ] I've discussed this with core contributors already. If not checked, I'm ready to accept this work might be rejected in favor of a different grand plan. Issue number where discussion took place: #xxx
<!-- Provide a more detailed description of the PR, other things fixed or any additional comments/features here -->
## Detailed Description of the Pull Request / Additional comments
Adds a constant buffer, which could be used for other settings for the retro terminal pixel shader.
I haven't touched C++ in over a decade before this change, and this is the first time I've played with DirectX, so please assume my code isn't exactly best practice. 🙂
<!-- Describe how you validated the behavior. Add automated tests wherever possible, but list manual validation steps taken as well -->
## Validation Steps Performed
- Changed display scale with experimental.retroTerminalEffect enabled, enjoyed scan lines on high resolution monitors.
- Enabled experimental.retroTerminalEffect, turned the setting off, changed display scale. Retro tabs still scale scan lines.
2020-02-26 01:08:45 +01:00
|
|
|
::Microsoft::WRL::ComPtr<ID3D11Buffer> _pixelShaderSettingsBuffer;
|
2019-12-12 14:44:01 +01:00
|
|
|
::Microsoft::WRL::ComPtr<ID3D11SamplerState> _samplerState;
|
|
|
|
|
::Microsoft::WRL::ComPtr<ID3D11Texture2D> _framebufferCapture;
|
|
|
|
|
|
2020-02-25 23:19:57 +01:00
|
|
|
D2D1_TEXT_ANTIALIAS_MODE _antialiasingMode;
|
|
|
|
|
|
2020-04-24 19:16:34 +02:00
|
|
|
float _defaultTextBackgroundOpacity;
|
|
|
|
|
|
Scale retro terminal scan lines (#4716)
<!-- Enter a brief description/summary of your PR here. What does it fix/what does it change/how was it tested (even manually, if necessary)? -->
## Summary of the Pull Request
- Scale the retro terminal effects (#3468) scan lines with the screen's DPI.
- Remove artifacts from sampling wrap around.
Before & after, with my display scale set to 350%:
Before & after showing artifact removal, with my display scale set to 100%, and image enlarged to 400%:
<!-- Please review the items on the PR checklist before submitting-->
## PR Checklist
* [x] Closes #4362
* [x] CLA signed. If not, go over [here](https://cla.opensource.microsoft.com/microsoft/Terminal) and sign the CLA
* [ ] Tests added/passed
* [ ] Requires documentation to be updated
* [ ] I've discussed this with core contributors already. If not checked, I'm ready to accept this work might be rejected in favor of a different grand plan. Issue number where discussion took place: #xxx
<!-- Provide a more detailed description of the PR, other things fixed or any additional comments/features here -->
## Detailed Description of the Pull Request / Additional comments
Adds a constant buffer, which could be used for other settings for the retro terminal pixel shader.
I haven't touched C++ in over a decade before this change, and this is the first time I've played with DirectX, so please assume my code isn't exactly best practice. 🙂
<!-- Describe how you validated the behavior. Add automated tests wherever possible, but list manual validation steps taken as well -->
## Validation Steps Performed
- Changed display scale with experimental.retroTerminalEffect enabled, enjoyed scan lines on high resolution monitors.
- Enabled experimental.retroTerminalEffect, turned the setting off, changed display scale. Retro tabs still scale scan lines.
2020-02-26 01:08:45 +01:00
|
|
|
// DirectX constant buffers need to be a multiple of 16; align to pad the size.
|
|
|
|
|
__declspec(align(16)) struct
|
|
|
|
|
{
|
|
|
|
|
float ScaledScanLinePeriod;
|
|
|
|
|
float ScaledGaussianSigma;
|
|
|
|
|
#pragma warning(suppress : 4324) // structure was padded due to __declspec(align())
|
|
|
|
|
} _pixelShaderSettings;
|
|
|
|
|
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT _CreateDeviceResources(const bool createSwapChain) noexcept;
|
2019-12-12 14:44:01 +01:00
|
|
|
HRESULT _SetupTerminalEffects();
|
Scale retro terminal scan lines (#4716)
<!-- Enter a brief description/summary of your PR here. What does it fix/what does it change/how was it tested (even manually, if necessary)? -->
## Summary of the Pull Request
- Scale the retro terminal effects (#3468) scan lines with the screen's DPI.
- Remove artifacts from sampling wrap around.
Before & after, with my display scale set to 350%:
Before & after showing artifact removal, with my display scale set to 100%, and image enlarged to 400%:
<!-- Please review the items on the PR checklist before submitting-->
## PR Checklist
* [x] Closes #4362
* [x] CLA signed. If not, go over [here](https://cla.opensource.microsoft.com/microsoft/Terminal) and sign the CLA
* [ ] Tests added/passed
* [ ] Requires documentation to be updated
* [ ] I've discussed this with core contributors already. If not checked, I'm ready to accept this work might be rejected in favor of a different grand plan. Issue number where discussion took place: #xxx
<!-- Provide a more detailed description of the PR, other things fixed or any additional comments/features here -->
## Detailed Description of the Pull Request / Additional comments
Adds a constant buffer, which could be used for other settings for the retro terminal pixel shader.
I haven't touched C++ in over a decade before this change, and this is the first time I've played with DirectX, so please assume my code isn't exactly best practice. 🙂
<!-- Describe how you validated the behavior. Add automated tests wherever possible, but list manual validation steps taken as well -->
## Validation Steps Performed
- Changed display scale with experimental.retroTerminalEffect enabled, enjoyed scan lines on high resolution monitors.
- Enabled experimental.retroTerminalEffect, turned the setting off, changed display scale. Retro tabs still scale scan lines.
2020-02-26 01:08:45 +01:00
|
|
|
void _ComputePixelShaderSettings() noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT _PrepareRenderTarget() noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
|
|
|
|
void _ReleaseDeviceResources() noexcept;
|
|
|
|
|
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT _CreateTextLayout(
|
2019-05-03 00:29:04 +02:00
|
|
|
_In_reads_(StringLength) PCWCHAR String,
|
|
|
|
|
_In_ size_t StringLength,
|
2019-06-11 22:27:09 +02:00
|
|
|
_Out_ IDWriteTextLayout** ppTextLayout) noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT _CopyFrontToBack() noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT _EnableDisplayAccess(const bool outputEnabled) noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-07-30 23:32:23 +02:00
|
|
|
[[nodiscard]] ::Microsoft::WRL::ComPtr<IDWriteFontFace1> _ResolveFontFaceWithFallback(std::wstring& familyName,
|
|
|
|
|
DWRITE_FONT_WEIGHT& weight,
|
|
|
|
|
DWRITE_FONT_STRETCH& stretch,
|
|
|
|
|
DWRITE_FONT_STYLE& style,
|
|
|
|
|
std::wstring& localeName) const;
|
|
|
|
|
|
|
|
|
|
[[nodiscard]] ::Microsoft::WRL::ComPtr<IDWriteFontFace1> _FindFontFace(std::wstring& familyName,
|
|
|
|
|
DWRITE_FONT_WEIGHT& weight,
|
|
|
|
|
DWRITE_FONT_STRETCH& stretch,
|
|
|
|
|
DWRITE_FONT_STYLE& style,
|
|
|
|
|
std::wstring& localeName) const;
|
|
|
|
|
|
|
|
|
|
[[nodiscard]] std::wstring _GetLocaleName() const;
|
|
|
|
|
|
2019-09-04 00:14:44 +02:00
|
|
|
[[nodiscard]] std::wstring _GetFontFamilyName(gsl::not_null<IDWriteFontFamily*> const fontFamily,
|
2019-07-30 23:32:23 +02:00
|
|
|
std::wstring& localeName) const;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] HRESULT _GetProposedFont(const FontInfoDesired& desired,
|
|
|
|
|
FontInfo& actual,
|
|
|
|
|
const int dpi,
|
2019-07-12 00:20:15 +02:00
|
|
|
::Microsoft::WRL::ComPtr<IDWriteTextFormat>& textFormat,
|
2019-06-11 22:27:09 +02:00
|
|
|
::Microsoft::WRL::ComPtr<IDWriteTextAnalyzer1>& textAnalyzer,
|
2019-07-12 00:20:15 +02:00
|
|
|
::Microsoft::WRL::ComPtr<IDWriteFontFace1>& fontFace) const noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2020-04-13 22:09:02 +02:00
|
|
|
[[nodiscard]] til::size _GetClientSize() const;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2020-04-13 22:09:02 +02:00
|
|
|
void _InvalidateRectangle(const til::rectangle& rc);
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-06-11 22:27:09 +02:00
|
|
|
[[nodiscard]] D2D1_COLOR_F _ColorFFromColorRef(const COLORREF color) noexcept;
|
2019-05-03 00:29:04 +02:00
|
|
|
|
2019-09-06 02:16:31 +02:00
|
|
|
// Routine Description:
|
|
|
|
|
// - Helps convert a Direct2D ColorF into a DXGI RGBA
|
|
|
|
|
// Arguments:
|
|
|
|
|
// - color - Direct2D Color F
|
|
|
|
|
// Return Value:
|
|
|
|
|
// - DXGI RGBA
|
|
|
|
|
[[nodiscard]] constexpr DXGI_RGBA s_RgbaFromColorF(const D2D1_COLOR_F color) noexcept
|
|
|
|
|
{
|
|
|
|
|
return { color.r, color.g, color.b, color.a };
|
|
|
|
|
}
|
2019-05-03 00:29:04 +02:00
|
|
|
};
|
|
|
|
|
}
|
