初步移植FSR

EffectCommon/EffectCommon.vcxproj

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
  <ProjectConfiguration Include="Debug|Win32">

EffectCommon/EffectCommon.vcxproj.filters

@@ -42,6 +42,9 @@
  <Filter>着色器</Filter>
  </None>
  <None Include="packages.config" />
+ <None Include="ffx_a.hlsli">
+ <Filter>着色器</Filter>
+ </None>
  </ItemGroup>
  <ItemGroup>
  <FxCompile Include="RGB2YUVShader.hlsl">

EffectCommon/common.hlsli

@@ -98,9 +98,17 @@ static float2 maxCoord7;
 #define SampleInputCur(index) (SampleInput(index, Coord(index).xy))
 #define SampleInputOff(index, pos) (SampleInput(index, Coord(index).xy + (pos) * Coord(index).zw))
 
-// 在循环中使用
+// LOD
 #define SampleInputLod(index, pos) (InputTexture##index.SampleLevel(InputSampler##index, (pos), 0))
 
+// Gather
+#define GatherInputRed(index, pos) (InputTexture##index.GatherRed(InputSampler##index, (pos), 0))
+#define GatherInputGreen(index, pos) (InputTexture##index.GatherGreen(InputSampler##index, (pos), 0))
+#define GatherInputBlue(index, pos) (InputTexture##index.GatherBlue(InputSampler##index, (pos), 0))
+
+// Load
+#define LoadInput(index, pos) (InputTexture##index.Load(pos))
+
 #ifndef MAGPIE_NO_CHECK
 #define GetCheckedPos(index, pos) (clamp((pos), 0, maxCoord##index))
 #define GetCheckedOffPos(index, pos) (GetCheckedPos(index, Coord(index).xy + (pos) * Coord(index).zw))
@@ -110,6 +118,8 @@ static float2 maxCoord7;
 #endif
 
 
+#define MAGPIE_ENTRY(name) D2D_PS_ENTRY(name)
+
 // 需要 main 函数的开头调用
 
 void InitMagpieSampleInput() {

MODULE_Common/DllMain.cpp

@@ -7,6 +7,7 @@
 #include "MitchellNetravaliScaleEffect.h"
 #include "PixelScaleEffect.h"
 #include "ContrastAdaptiveSharpenEffect.h"
+#include "FSREffect.h"
 
 #pragma comment(lib, "dxguid.lib")
 
@@ -357,6 +358,56 @@ API_DECLSPEC HRESULT CreateContrastAdaptiveSharpenEffect(
  return S_OK;
 }
 
+API_DECLSPEC HRESULT CreateFSREffect(
+ ID2D1Factory1* d2dFactory,
+ ID2D1DeviceContext* d2dDC,
+ const nlohmann::json& props,
+ float fillScale,
+ std::pair<float, float>& scale,
+ ComPtr<ID2D1Effect>& effect
+) {
+ bool isRegistered;
+ HRESULT hr = EffectUtils::IsEffectRegistered(d2dFactory, CLSID_MAGPIE_FSR_EFFECT, isRegistered);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ if (!isRegistered) {
+ hr = FSREffect::Register(d2dFactory);
+ if (FAILED(hr)) {
+ return hr;
+ }
+ }
+
+ ComPtr<ID2D1Effect> result;
+ hr = d2dDC->CreateEffect(CLSID_MAGPIE_FSR_EFFECT, &result);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ std::pair<float, float> scaleResult(1.0f, 1.0f);
+ // scale 属性
+ auto it = props.find("scale");
+ if (it != props.end()) {
+ hr = EffectUtils::ReadScaleProp(*it, fillScale, scale, scaleResult);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ hr = result->SetValue(
+ FSREffect::PROP_SCALE,
+ D2D1_VECTOR_2F{ scaleResult.first, scaleResult.second }
+ );
+ if (FAILED(hr)) {
+ return hr;
+ }
+ }
+
+ effect = std::move(result);
+ scale.first *= scaleResult.first;
+ scale.second *= scaleResult.second;
+ return S_OK;
+}
 
 API_DECLSPEC HRESULT CreateEffect(
  ID2D1Factory1* d2dFactory,
@@ -380,7 +431,9 @@ API_DECLSPEC HRESULT CreateEffect(
  return CreateMitchellEffect(d2dFactory, d2dDC, props, fillScale, scale, effect);
  } else if (e == "pixelScale") {
  return CreatePixelScaleEffect(d2dFactory, d2dDC, props, effect, scale);
- } else {
+ } else if (e == "FSR") {
+ return CreateFSREffect(d2dFactory, d2dDC, props, fillScale, scale, effect);
+ } else {
  return E_INVALIDARG;
  }
 }

MODULE_Common/EffectDefines.h

@@ -31,6 +31,13 @@ DEFINE_GUID(GUID_MAGPIE_PIXEL_SCALE_SHADER,
 DEFINE_GUID(GUID_MAGPIE_CONTRAST_ADAPTIVE_SHARPEN_SHADER,
  0x3e7f23c3, 0x185f, 0x4ac6, 0xb6, 0xb8, 0xd5, 0x18, 0x7e, 0x69, 0xca, 0x4f);
 
+// {6B5C18BA-B415-4EDC-9A1C-7D4876E94633}
+DEFINE_GUID(GUID_MAGPIE_FFX_EASU_SHADER,
+ 0x6b5c18ba, 0xb415, 0x4edc, 0x9a, 0x1c, 0x7d, 0x48, 0x76, 0xe9, 0x46, 0x33);
+// {16C7F163-CBCC-4764-8AF8-07FC113747FA}
+DEFINE_GUID(GUID_MAGPIE_FFX_RCAS_SHADER,
+ 0x16c7f163, 0xcbcc, 0x4764, 0x8a, 0xf8, 0x7, 0xfc, 0x11, 0x37, 0x47, 0xfa);
+
 
 
 // {FF65D2D6-4359-429D-B30A-F3F65B5AF20D}
@@ -58,6 +65,9 @@ DEFINE_GUID(CLSID_MAGPIE_LANCZOS_SCALE_EFFECT,
 DEFINE_GUID(CLSID_MAGPIE_PIXEL_SCALE_EFFECT,
  0xed9318d, 0xd624, 0x4582, 0x9c, 0xe2, 0x39, 0x9b, 0x79, 0x42, 0x8a, 0xb4);
 
+// {0C748324-87A8-4A9E-AF73-38309CF9CF2C}
+DEFINE_GUID(CLSID_MAGPIE_FSR_EFFECT,
+ 0xc748324, 0x87a8, 0x4a9e, 0xaf, 0x73, 0x38, 0x30, 0x9c, 0xf9, 0xcf, 0x2c);
 
 
 constexpr auto MAGPIE_ADAPTIVE_SHARPEN_PASS1_SHADER = L"shaders/AdaptiveSharpenPass1Shader.cso";
@@ -68,3 +78,6 @@ constexpr auto MAGPIE_LANCZOS6_SCALE_SHADER = L"shaders/Lanczos6ScaleShader.cso"
 constexpr auto MAGPIE_JINC2_SCALE_SHADER = L"shaders/Jinc2ScaleShader.cso";
 constexpr auto MAGPIE_MITCHELL_NETRAVALI_SCALE_SHADER = L"shaders/MitchellNetravaliScaleShader.cso";
 constexpr auto MAGPIE_PIXEL_SCALE_SHADER = L"shaders/PixelScaleShader.cso";
+
+constexpr auto MAGPIE_FFX_EASU_SHADER = L"shaders/FfxEasuShader.cso";
+constexpr auto MAGPIE_FFX_RCAS_SHADER = L"shaders/FfxRcasShader.cso";

MODULE_Common/FSREffect.h

@@ -0,0 +1,109 @@
+#pragma once
+#include "pch.h"
+#include <EffectBase.h>
+#include "EffectDefines.h"
+#include "FfxEasuTransform.h"
+#include "FfxRcasTransform.h"
+
+
+class FSREffect : public EffectBase {
+public:
+ IFACEMETHODIMP Initialize(
+ _In_ ID2D1EffectContext* pEffectContext,
+ _In_ ID2D1TransformGraph* pTransformGraph
+ ) {
+ HRESULT hr = FfxEasuTransform::Create(pEffectContext, &_easuTransform);
+ if (FAILED(hr)) {
+ return hr;
+ }
+ hr = FfxRcasTransform::Create(pEffectContext, &_rcasTransform);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ hr = pTransformGraph->AddNode(_easuTransform.Get());
+ if (FAILED(hr)) {
+ return hr;
+ }
+ hr = pTransformGraph->AddNode(_rcasTransform.Get());
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ hr = pTransformGraph->ConnectToEffectInput(0, _easuTransform.Get(), 0);
+ if (FAILED(hr)) {
+ return hr;
+ }
+ hr = pTransformGraph->ConnectNode(_easuTransform.Get(), _rcasTransform.Get(), 0);
+ if (FAILED(hr)) {
+ return hr;
+ }
+ hr = pTransformGraph->SetOutputNode(_rcasTransform.Get());
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ return S_OK;
+ }
+
+ HRESULT SetScale(D2D_VECTOR_2F value) {
+ if (value.x <= 0 || value.y <= 0) {
+ return E_INVALIDARG;
+ }
+
+ _easuTransform->SetScale(value);
+ return S_OK;
+ }
+
+ D2D_VECTOR_2F GetScale() const {
+ return _easuTransform->GetScale();
+ }
+
+ enum PROPS {
+ PROP_SCALE = 0,
+ };
+
+ static HRESULT Register(_In_ ID2D1Factory1* pFactory) {
+ const D2D1_PROPERTY_BINDING bindings[] =
+ {
+ D2D1_VALUE_TYPE_BINDING(L"Scale", &SetScale, &GetScale)
+ };
+
+ HRESULT hr = pFactory->RegisterEffectFromString(CLSID_MAGPIE_FSR_EFFECT, XML(
+ <?xml version='1.0'?>
+ <Effect>
+ <!--System Properties-->
+ <Property name='DisplayName' type='string' value='FSR'/>
+ <Property name='Author' type='string' value='Blinue'/>
+ <Property name='Category' type='string' value='FFX'/>
+ <Property name='Description' type='string' value='FSR'/>
+ <Inputs>
+ <Input name='Source'/>
+ </Inputs>
+ <Property name='Scale' type='vector2'>
+ <Property name='DisplayName' type='string' value='Scale'/>
+ <Property name='Default' type='vector2' value='(1,1)'/>
+ </Property>
+
+ </Effect>
+ ), bindings, ARRAYSIZE(bindings), CreateEffect);
+
+ return hr;
+ }
+
+ static HRESULT CALLBACK CreateEffect(_Outptr_ IUnknown** ppEffectImpl) {
+ *ppEffectImpl = static_cast<ID2D1EffectImpl*>(new FSREffect());
+
+ if (*ppEffectImpl == nullptr) {
+ return E_OUTOFMEMORY;
+ }
+
+ return S_OK;
+ }
+
+private:
+ FSREffect() {}
+
+ ComPtr<FfxEasuTransform> _easuTransform = nullptr;
+ ComPtr<FfxRcasTransform> _rcasTransform = nullptr;
+};

MODULE_Common/FfxEasuShader.hlsl

@@ -0,0 +1,45 @@
+cbuffer constants : register(b0) {
+ int2 srcSize : packoffset(c0.x);
+ int2 destSize : packoffset(c0.z);
+};
+
+#define MAGPIE_INPUT_COUNT 1
+#include "common.hlsli"
+
+
+#define A_GPU 1
+#define A_HLSL 1
+#include "ffx_a.hlsli"
+#define FSR_EASU_F 1
+
+AF4 FsrEasuRF(AF2 p) {
+ return GatherInputRed(0, p * srcSize * Coord(0).zw);
+}
+AF4 FsrEasuGF(AF2 p) {
+ return GatherInputGreen(0, p * srcSize * Coord(0).zw);
+}
+AF4 FsrEasuBF(AF2 p) {
+ return GatherInputBlue(0, p * srcSize * Coord(0).zw);
+}
+
+
+#include "ffx_fsr1.hlsli"
+
+
+MAGPIE_ENTRY(main) {
+ float2 rcpSrc = rcp(srcSize);
+ float2 rcpDest = rcp(destSize);
+ float2 scale = srcSize * rcpDest;
+
+ float3 c;
+ FsrEasuF(
+ c,
+ Coord(0).xy / Coord(0).zw,
+ asuint(float4(scale, 0.5 * scale - 0.5)),
+ asuint(float4(rcpSrc.xy, rcpSrc.x, -rcpSrc.y)),
+ asuint(float4(-rcpSrc.x, 2 * rcpSrc.y, rcpSrc.x, 2 * rcpSrc.y)),
+ asuint(float4(0, 4 * rcpSrc.y, 0, 0))
+ );
+
+ return float4(c, 1.0f);
+}

MODULE_Common/FfxEasuTransform.h

@@ -0,0 +1,41 @@
+#pragma once
+#include "pch.h"
+#include <SimpleScaleTransform.h>
+#include "EffectDefines.h"
+
+
+class FfxEasuTransform : public SimpleScaleTransform {
+private:
+ FfxEasuTransform() : SimpleScaleTransform(GUID_MAGPIE_FFX_EASU_SHADER) {}
+public:
+ static HRESULT Create(_In_ ID2D1EffectContext* d2dEC, _Outptr_ FfxEasuTransform** ppOutput) {
+ if (!ppOutput) {
+ return E_INVALIDARG;
+ }
+
+ HRESULT hr = LoadShader(d2dEC, MAGPIE_FFX_EASU_SHADER, GUID_MAGPIE_FFX_EASU_SHADER);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ *ppOutput = new FfxEasuTransform();
+ return hr;
+ }
+
+protected:
+ void _SetShaderContantBuffer(const SIZE& srcSize, const SIZE& destSize) override {
+ struct {
+ INT32 srcWidth;
+ INT32 srcHeight;
+ INT32 destWidth;
+ INT32 destHeight;
+ } shaderConstants{
+ srcSize.cx,
+ srcSize.cy,
+ destSize.cx,
+ destSize.cy
+ };
+
+ _drawInfo->SetPixelShaderConstantBuffer((BYTE*)&shaderConstants, sizeof(shaderConstants));
+ }
+};

MODULE_Common/FfxRcasShader.hlsl

@@ -0,0 +1,31 @@
+cbuffer constants : register(b0) {
+ uint2 srcSize : packoffset(c0.x);
+ float sharpness : packoffset(c0.z);
+};
+
+#define MAGPIE_INPUT_COUNT 1
+#define MAGPIE_NO_CHECK
+#include "common.hlsli"
+
+
+#define A_GPU
+#define A_HLSL
+#include "ffx_a.hlsli"
+#define FSR_RCAS_F
+
+AF4 FsrRcasLoadF(ASU2 p) { return LoadInput(0, int3(ASU2(p), 0)); }
+void FsrRcasInputF(inout AF1 r, inout AF1 g, inout AF1 b) {}
+
+
+#include "ffx_fsr1.hlsli"
+
+
+MAGPIE_ENTRY(main) {
+ float s = AExp2F1(-sharpness);
+ varAF2(hSharp) = initAF2(s, s);
+
+ float3 c;
+ FsrRcasF(c.r, c.g, c.b, Coord(0).xy / Coord(0).zw, float4(AU1_AF1(s), AU1_AH2_AF2(hSharp), 0, 0));
+
+ return float4(c, 1.0f);
+}