Added experimental.pixelShaderImagePath

Added support for loading pixes shader texture to Atlas. Loaded using DirectX ToolKit which in turn relies on WIC. Should enable new classes of pixel shader backgrounds as texture can be logos but also noise like perlin noise which is very useful in many shader scenarios.
microsoft · Oct 23, 2022 · 5ddfa17 · 5ddfa17
1 parent 1c073e5
commit 5ddfa17
Show file tree

Hide file tree

Showing 17 changed files with 124 additions and 3 deletions.
diff --git a/src/cascadia/TerminalControl/ControlCore.cpp b/src/cascadia/TerminalControl/ControlCore.cpp
@@ -330,6 +330,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
             _renderEngine->SetRetroTerminalEffect(_settings->RetroTerminalEffect());
             _renderEngine->SetPixelShaderPath(_settings->PixelShaderPath());
+            _renderEngine->SetPixelShaderImagePath(_settings->PixelShaderImagePath());
             _renderEngine->SetForceFullRepaintRendering(_settings->ForceFullRepaintRendering());
             _renderEngine->SetSoftwareRendering(_settings->SoftwareRendering());
 
@@ -769,6 +770,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             _renderEngine->SetSelectionBackground(til::color{ newAppearance->SelectionBackground() });
             _renderEngine->SetRetroTerminalEffect(newAppearance->RetroTerminalEffect());
             _renderEngine->SetPixelShaderPath(newAppearance->PixelShaderPath());
+            _renderEngine->SetPixelShaderImagePath(newAppearance->PixelShaderImagePath());
             _renderer->TriggerRedrawAll();
         }
     }

diff --git a/src/cascadia/TerminalControl/IControlAppearance.idl b/src/cascadia/TerminalControl/IControlAppearance.idl
@@ -17,5 +17,6 @@ namespace Microsoft.Terminal.Control
         // Experimental settings
         Boolean RetroTerminalEffect { get; };
         String PixelShaderPath { get; };
+        String PixelShaderImagePath { get; };
     };
 }
diff --git a/src/cascadia/TerminalCore/Terminal.cpp b/src/cascadia/TerminalCore/Terminal.cpp
@@ -1716,7 +1716,7 @@ til::point Terminal::GetViewportRelativeCursorPosition() const noexcept
 // These functions are used by TerminalInput, which must build in conhost
 // against OneCore compatible signatures. See the definitions in
 // VtApiRedirection.hpp (which we cannot include cross-project.)
-// Since we do nto run on OneCore, we can dispense with the compatibility
+// Since we don't run on OneCore, we can dispense with the compatibility
 // shims.
 extern "C" UINT OneCoreSafeMapVirtualKeyW(_In_ UINT uCode, _In_ UINT uMapType)
 {

diff --git a/src/cascadia/TerminalSettingsModel/IAppearanceConfig.idl b/src/cascadia/TerminalSettingsModel/IAppearanceConfig.idl
@@ -50,6 +50,7 @@ namespace Microsoft.Terminal.Settings.Model
 
         INHERITABLE_APPEARANCE_SETTING(Boolean, RetroTerminalEffect);
         INHERITABLE_APPEARANCE_SETTING(String, PixelShaderPath);
+        INHERITABLE_APPEARANCE_SETTING(String, PixelShaderImagePath);
         INHERITABLE_APPEARANCE_SETTING(IntenseStyle, IntenseTextStyle);
         INHERITABLE_APPEARANCE_SETTING(Microsoft.Terminal.Core.AdjustTextMode, AdjustIndistinguishableColors);
         INHERITABLE_APPEARANCE_SETTING(Double, Opacity);

diff --git a/src/cascadia/TerminalSettingsModel/MTSMSettings.h b/src/cascadia/TerminalSettingsModel/MTSMSettings.h
@@ -108,6 +108,7 @@ Author(s):
     X(winrt::Windows::UI::Xaml::Media::Stretch, BackgroundImageStretchMode, "backgroundImageStretchMode", winrt::Windows::UI::Xaml::Media::Stretch::UniformToFill) \
     X(bool, RetroTerminalEffect, "experimental.retroTerminalEffect", false)                                                                                        \
     X(hstring, PixelShaderPath, "experimental.pixelShaderPath")                                                                                                    \
+    X(hstring, PixelShaderImagePath, "experimental.pixelShaderImagePath")                                                                                          \
     X(ConvergedAlignment, BackgroundImageAlignment, "backgroundImageAlignment", ConvergedAlignment::Horizontal_Center | ConvergedAlignment::Vertical_Center)       \
     X(hstring, ColorSchemeName, "colorScheme", L"Campbell")                                                                                                        \
     X(hstring, BackgroundImagePath, "backgroundImage")                                                                                                             \

diff --git a/src/cascadia/TerminalSettingsModel/TerminalSettings.cpp b/src/cascadia/TerminalSettingsModel/TerminalSettings.cpp
@@ -221,6 +221,7 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
 
         _RetroTerminalEffect = appearance.RetroTerminalEffect();
         _PixelShaderPath = winrt::hstring{ wil::ExpandEnvironmentStringsW<std::wstring>(appearance.PixelShaderPath().c_str()) };
+        _PixelShaderImagePath = winrt::hstring{ wil::ExpandEnvironmentStringsW<std::wstring>(appearance.PixelShaderImagePath().c_str()) };
 
         _IntenseIsBold = WI_IsFlagSet(appearance.IntenseTextStyle(), Microsoft::Terminal::Settings::Model::IntenseStyle::Bold);
         _IntenseIsBright = WI_IsFlagSet(appearance.IntenseTextStyle(), Microsoft::Terminal::Settings::Model::IntenseStyle::Bright);

diff --git a/src/cascadia/TerminalSettingsModel/TerminalSettings.h b/src/cascadia/TerminalSettingsModel/TerminalSettings.h
@@ -155,6 +155,7 @@ namespace winrt::Microsoft::Terminal::Settings::Model::implementation
         INHERITABLE_SETTING(Model::TerminalSettings, bool, ForceVTInput, false);
 
         INHERITABLE_SETTING(Model::TerminalSettings, hstring, PixelShaderPath);
+        INHERITABLE_SETTING(Model::TerminalSettings, hstring, PixelShaderImagePath);
 
         INHERITABLE_SETTING(Model::TerminalSettings, bool, Elevate, false);
 

diff --git a/src/cascadia/inc/ControlProperties.h b/src/cascadia/inc/ControlProperties.h
@@ -26,7 +26,8 @@
     X(winrt::Windows::UI::Xaml::HorizontalAlignment, BackgroundImageHorizontalAlignment, winrt::Windows::UI::Xaml::HorizontalAlignment::Center) \
     X(winrt::Windows::UI::Xaml::VerticalAlignment, BackgroundImageVerticalAlignment, winrt::Windows::UI::Xaml::VerticalAlignment::Center)       \
     X(bool, RetroTerminalEffect, false)                                                                                                         \
-    X(winrt::hstring, PixelShaderPath)
+    X(winrt::hstring, PixelShaderPath)                                                                                                          \
+    X(winrt::hstring, PixelShaderImagePath)
 
 // --------------------------- Core Settings ---------------------------
 //  All of these settings are defined in ICoreSettings.

diff --git a/src/renderer/atlas/AtlasEngine.api.cpp b/src/renderer/atlas/AtlasEngine.api.cpp
@@ -296,6 +296,11 @@ HRESULT AtlasEngine::Enable() noexcept
     return _api.customPixelShaderPath;
 }
 
+[[nodiscard]] std::wstring_view AtlasEngine::GetPixelShaderImagePath() noexcept
+{
+    return _api.customPixelShaderImagePath;
+}
+
 [[nodiscard]] bool AtlasEngine::GetRetroTerminalEffect() const noexcept
 {
     return _api.useRetroTerminalEffect;
@@ -370,6 +375,16 @@ void AtlasEngine::SetPixelShaderPath(std::wstring_view value) noexcept
     }
 }
 
+void AtlasEngine::SetPixelShaderImagePath(std::wstring_view value) noexcept
+{
+    if (_api.customPixelShaderImagePath != value)
+    {
+        _api.customPixelShaderImagePath = value;
+        _resolveTransparencySettings();
+        WI_SetFlag(_api.invalidations, ApiInvalidations::Device);
+    }
+}
+
 void AtlasEngine::SetRetroTerminalEffect(bool enable) noexcept
 {
     if (_api.useRetroTerminalEffect != enable)

diff --git a/src/renderer/atlas/AtlasEngine.cpp b/src/renderer/atlas/AtlasEngine.cpp
@@ -8,6 +8,7 @@
 #include <custom_shader_vs.h>
 #include <shader_ps.h>
 #include <shader_vs.h>
+#include <wincodec.h>
 
 #include "../../interactivity/win32/CustomWindowMessages.h"
 
@@ -676,6 +677,13 @@ void AtlasEngine::_createResources()
             THROW_IF_FAILED(_r.device->CreateBuffer(&desc, nullptr, _r.constantBuffer.put()));
         }
 
+        if (!_api.customPixelShaderImagePath.empty())
+        {
+            _r.customShaderTexture = LoadShaderTextureFromFile(
+                _r.device.get(),
+                _api.customPixelShaderImagePath);
+        }
+
         THROW_IF_FAILED(_r.device->CreateVertexShader(&shader_vs[0], sizeof(shader_vs), nullptr, _r.vertexShader.put()));
         THROW_IF_FAILED(_r.device->CreatePixelShader(&shader_ps[0], sizeof(shader_ps), nullptr, _r.pixelShader.put()));
 

diff --git a/src/renderer/atlas/AtlasEngine.h b/src/renderer/atlas/AtlasEngine.h
@@ -10,6 +10,8 @@
 #include "../../renderer/inc/IRenderEngine.hpp"
 #include "DWriteTextAnalysis.h"
 
+#include "TextureLoader.h"
+
 namespace Microsoft::Console::Render
 {
     struct TextAnalysisSinkResult;
@@ -61,6 +63,7 @@ namespace Microsoft::Console::Render
         // DxRenderer - getter
         HRESULT Enable() noexcept override;
         [[nodiscard]] std::wstring_view GetPixelShaderPath() noexcept override;
+        [[nodiscard]] std::wstring_view GetPixelShaderImagePath() noexcept override;
         [[nodiscard]] bool GetRetroTerminalEffect() const noexcept override;
         [[nodiscard]] float GetScaling() const noexcept override;
         [[nodiscard]] Types::Viewport GetViewportInCharacters(const Types::Viewport& viewInPixels) const noexcept override;
@@ -72,6 +75,7 @@ namespace Microsoft::Console::Render
         void SetForceFullRepaintRendering(bool enable) noexcept override;
         [[nodiscard]] HRESULT SetHwnd(HWND hwnd) noexcept override;
         void SetPixelShaderPath(std::wstring_view value) noexcept override;
+        void SetPixelShaderImagePath(std::wstring_view value) noexcept override;
         void SetRetroTerminalEffect(bool enable) noexcept override;
         void SetSelectionBackground(COLORREF color, float alpha = 0.5f) noexcept override;
         void SetSoftwareRendering(bool enable) noexcept override;
@@ -1004,6 +1008,7 @@ namespace Microsoft::Console::Render
             wil::com_ptr<ID3D11PixelShader> customPixelShader;
             wil::com_ptr<ID3D11Buffer> customShaderConstantBuffer;
             wil::com_ptr<ID3D11SamplerState> customShaderSamplerState;
+            ShaderTexture customShaderTexture;
             std::chrono::steady_clock::time_point customShaderStartTime;
 
             // D2D resources
@@ -1105,6 +1110,7 @@ namespace Microsoft::Console::Render
             bool enableTransparentBackground = false;
 
             std::wstring customPixelShaderPath; // changes are flagged as ApiInvalidations::Device
+            std::wstring customPixelShaderImagePath;
             bool useRetroTerminalEffect = false; // changes are flagged as ApiInvalidations::Device
             bool useSoftwareRendering = false; // changes are flagged as ApiInvalidations::Device
 

diff --git a/src/renderer/atlas/AtlasEngine.r.cpp b/src/renderer/atlas/AtlasEngine.r.cpp
@@ -243,7 +243,15 @@ void AtlasEngine::_renderWithCustomShader() const
         // PS: Pixel Shader
         _r.deviceContext->PSSetShader(_r.customPixelShader.get(), nullptr, 0);
         _r.deviceContext->PSSetConstantBuffers(0, 1, _r.customShaderConstantBuffer.addressof());
-        _r.deviceContext->PSSetShaderResources(0, 1, _r.customOffscreenTextureView.addressof());
+
+        ID3D11ShaderResourceView* const resourceViews[]{
+            _r.customOffscreenTextureView.get(),
+            _r.customShaderTexture.TextureView.get(),
+        };
+        // Checking if customer shader texture is set
+        const UINT numViews = resourceViews[1] ? 2 : 1;
+        _r.deviceContext->PSSetShaderResources(0, numViews, &resourceViews[0]);
+
         _r.deviceContext->PSSetSamplers(0, 1, _r.customShaderSamplerState.addressof());
 
         _r.deviceContext->Draw(4, 0);

diff --git a/src/renderer/atlas/TextureLoader.cpp b/src/renderer/atlas/TextureLoader.cpp
@@ -0,0 +1,40 @@
+#include "pch.h"
+
+#include "TextureLoader.h"
+
+#include "WICTextureLoader.h"
+
+namespace Microsoft::Console::Render
+{
+    Microsoft::Console::Render::ShaderTexture LoadShaderTextureFromFile(
+        ID3D11Device* d3dDevice,
+        const std::wstring& fileName)
+    {
+        Microsoft::Console::Render::ShaderTexture result;
+
+        const auto hr = DirectX::CreateWICTextureFromFileEx(
+            d3dDevice,
+            fileName.c_str(),
+            0,
+            D3D11_USAGE_DEFAULT,
+            D3D11_BIND_SHADER_RESOURCE,
+            0,
+            0,
+            DirectX::WIC_LOADER_DEFAULT
+                // TODO: Should we ignore SRGB conversion?
+                //  If we use the default settings the texture is converted
+                //  from SRGB into linear RGB which do make a lot of sense but
+                //  can also be a somewhat surprising to devs not used to it.
+                | DirectX::WIC_LOADER_IGNORE_SRGB,
+            result.Texture.addressof(),
+            result.TextureView.addressof());
+
+        if (FAILED(hr))
+        {
+            LOG_HR(hr);
+            return Microsoft::Console::Render::ShaderTexture();
+        }
+
+        return result;
+    }
+}
diff --git a/src/renderer/atlas/TextureLoader.h b/src/renderer/atlas/TextureLoader.h
@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#pragma once
+
+namespace Microsoft::Console::Render
+{
+    struct ShaderTexture
+    {
+        wil::com_ptr<ID3D11Resource> Texture;
+        wil::com_ptr<ID3D11ShaderResourceView> TextureView;
+    };
+
+    Microsoft::Console::Render::ShaderTexture LoadShaderTextureFromFile(
+        ID3D11Device* d3dDevice,
+        const std::wstring& fileName);
+}
diff --git a/src/renderer/dx/DxRenderer.cpp b/src/renderer/dx/DxRenderer.cpp
@@ -1017,6 +1017,14 @@ std::wstring_view DxEngine::GetPixelShaderPath() noexcept
     return _pixelShaderPath;
 }
 
+std::wstring_view DxEngine::GetPixelShaderImagePath() noexcept
+{
+    // NOP implementation as DxEngine is to be replaced by Atlas
+    //  so recommended to not backport this function
+    static std::wstring empty;
+    return empty;
+}
+
 void DxEngine::SetPixelShaderPath(std::wstring_view value) noexcept
 try
 {
@@ -1031,6 +1039,12 @@ try
 }
 CATCH_LOG()
 
+void DxEngine::SetPixelShaderImagePath(std::wstring_view) noexcept
+{
+    // NOP implementation as DxEngine is to be replaced by Atlas
+    //  so recommended to not backport this function
+}
+
 void DxEngine::SetForceFullRepaintRendering(bool enable) noexcept
 try
 {

diff --git a/src/renderer/dx/DxRenderer.hpp b/src/renderer/dx/DxRenderer.hpp
@@ -66,6 +66,9 @@ namespace Microsoft::Console::Render
         std::wstring_view GetPixelShaderPath() noexcept override;
         void SetPixelShaderPath(std::wstring_view value) noexcept override;
 
+        std::wstring_view GetPixelShaderImagePath() noexcept override;
+        void SetPixelShaderImagePath(std::wstring_view value) noexcept override;
+
         void SetForceFullRepaintRendering(bool enable) noexcept override;
 
         void SetSoftwareRendering(bool enable) noexcept override;

diff --git a/src/renderer/inc/IRenderEngine.hpp b/src/renderer/inc/IRenderEngine.hpp
@@ -93,6 +93,7 @@ namespace Microsoft::Console::Render
         // DxRenderer - getter
         virtual HRESULT Enable() noexcept { return S_OK; }
         virtual [[nodiscard]] std::wstring_view GetPixelShaderPath() noexcept { return {}; }
+        virtual [[nodiscard]] std::wstring_view GetPixelShaderImagePath() noexcept { return {}; }
         virtual [[nodiscard]] bool GetRetroTerminalEffect() const noexcept { return false; }
         virtual [[nodiscard]] float GetScaling() const noexcept { return 1; }
         virtual [[nodiscard]] Types::Viewport GetViewportInCharacters(const Types::Viewport& viewInPixels) const noexcept { return Types::Viewport::Empty(); }
@@ -104,6 +105,7 @@ namespace Microsoft::Console::Render
         virtual void SetForceFullRepaintRendering(bool enable) noexcept {}
         virtual [[nodiscard]] HRESULT SetHwnd(const HWND hwnd) noexcept { return E_NOTIMPL; }
         virtual void SetPixelShaderPath(std::wstring_view value) noexcept {}
+        virtual void SetPixelShaderImagePath(std::wstring_view value) noexcept {}
         virtual void SetRetroTerminalEffect(bool enable) noexcept {}
         virtual void SetSelectionBackground(const COLORREF color, const float alpha = 0.5f) noexcept {}
         virtual void SetSoftwareRendering(bool enable) noexcept {}