Moved FSR3 classes into their own sub-namespace. This is more future-proof with an eye on porting over more FidelityFX technologies.

- Using texture arrays is now a boolean flag that can be set on dispatch, removing the need for HDRP-specific checks inside the FSR3 code and shaders.
- Debug view shader is no longer conditionally included.
- Reduced the number of multi-compile variants by removing unused keywords for each shader.
- Optimized temporary RT use; two resources can reuse the same generic intermediate temp RT.
- Reorganized some of the shader code to work nicer with the rest of the FidelityFX SDK sources.

Assets/Fsr3UpscalerAssets.asset

@@ -0,0 +1,26 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: db26e15a33db6ab42a38daab0ba2712f, type: 3}
+  m_Name: Fsr3UpscalerAssets
+  m_EditorClassIdentifier: 
+  shaders:
+    prepareInputsPass: {fileID: 7200000, guid: 4f59e5b9179d74844ae06a30ae1e0629, type: 3}
+    lumaPyramidPass: {fileID: 7200000, guid: d253be05abcdc80428503d3e4cce3a36, type: 3}
+    shadingChangePyramidPass: {fileID: 7200000, guid: 251e663738905fa4d8817001682d802f, type: 3}
+    shadingChangePass: {fileID: 7200000, guid: 9a2bff2f97619ed4989d9b0577ba0641, type: 3}
+    prepareReactivityPass: {fileID: 7200000, guid: 20e44016ed34b0d4b8de499d1b566c69, type: 3}
+    lumaInstabilityPass: {fileID: 7200000, guid: a135306e6d1857e43a86ef20db2a47fe, type: 3}
+    accumulatePass: {fileID: 7200000, guid: c9b45f0ae7673694ba57a4aadfe212e9, type: 3}
+    sharpenPass: {fileID: 7200000, guid: 7aaf5cfff022de2499e9b0412f947f6c, type: 3}
+    autoGenReactivePass: {fileID: 7200000, guid: 5716b91fdaa4e9e439df6b96a796fe6e, type: 3}
+    tcrAutoGenPass: {fileID: 7200000, guid: 75cdc6ef23f08ed498d4da511923fcea, type: 3}
+    debugViewPass: {fileID: 7200000, guid: cb24a71d54164c54eb5e86839acd48c5, type: 3}

Assets/Fsr3UpscalerAssets.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4151befafd86e8740ab09463b4f1bdbb
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Resources/FSR2/ffx_fsr2_autogen_reactive_pass.compute

@@ -1,32 +0,0 @@
-// Copyright (c) 2023 Nico de Poel
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#pragma kernel CS
-
-#pragma multi_compile_local __ FFX_HALF
-#pragma multi_compile_local __ FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_JITTERED_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_INVERTED_DEPTH
-
-#pragma multi_compile_local __ UNITY_FSR2_HDRP
-
-#include "ffx_fsr2_unity_common.cginc"
-
-#include "shaders/ffx_fsr2_autogen_reactive_pass.hlsl"

Assets/Resources/FSR2/ffx_fsr2_lock_pass.compute.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 3c96d72b39a840c428c901628dab92c0
-ComputeShaderImporter:
-  externalObjects: {}
-  preprocessorOverride: 0
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/ffx_fsr2_rcas_pass.compute.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 5a82801f160ff6a4eb47db567216e592
-ComputeShaderImporter:
-  externalObjects: {}
-  preprocessorOverride: 0
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/ffx_fsr2_reconstruct_previous_depth_pass.compute

@@ -1,33 +0,0 @@
-// Copyright (c) 2023 Nico de Poel
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#pragma kernel CS
-
-#pragma multi_compile_local __ FFX_HALF
-#pragma multi_compile_local __ FFX_FSR2_OPTION_HDR_COLOR_INPUT
-#pragma multi_compile_local __ FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_JITTERED_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_INVERTED_DEPTH
-
-#pragma multi_compile_local __ UNITY_FSR2_HDRP
-
-#include "ffx_fsr2_unity_common.cginc"
-
-#include "shaders/ffx_fsr2_reconstruct_previous_depth_pass.hlsl"

Assets/Resources/FSR2/ffx_fsr2_reconstruct_previous_depth_pass.compute.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 6ef1b4c25874e334dad5ba3ac6345e32
-ComputeShaderImporter:
-  externalObjects: {}
-  preprocessorOverride: 0
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/ffx_fsr2_tcr_autogen_pass.compute.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: b478fba0a6a87b44b8be7c35deb5f0dc
-ComputeShaderImporter:
-  externalObjects: {}
-  preprocessorOverride: 0
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/ffx_fsr2_unity_common.cginc.meta

@@ -1,27 +0,0 @@
-fileFormatVersion: 2
-guid: bb2d4d4671c448698877526c29f2fc99
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      Any: 
-    second:
-      enabled: 1
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_core_cpu.h

@@ -1,332 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-/// A define for a true value in a boolean expression.
-///
-/// @ingroup CPU
-#define FFX_TRUE (1)
-
-/// A define for a false value in a boolean expression.
-///
-/// @ingroup CPU
-#define FFX_FALSE (0)
- 
-#if !defined(FFX_STATIC)
-/// A define to abstract declaration of static variables and functions.
-///
-/// @ingroup CPU
-#define FFX_STATIC static
-#endif // #if !defined(FFX_STATIC)
-
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wunused-variable"
-#endif
-
-/// Interpret the bit layout of an IEEE-754 floating point value as an unsigned integer.
-///
-/// @param [in] x               A 32bit floating value.
-///
-/// @returns
-/// An unsigned 32bit integer value containing the bit pattern of <c><i>x</i></c>.
-/// 
-/// @ingroup CPU
-FFX_STATIC FfxUInt32 ffxAsUInt32(FfxFloat32 x)
-{
-    union
-    {
-        FfxFloat32 f;
-        FfxUInt32  u;
-    } bits;
-
-    bits.f = x;
-    return bits.u;
-}
-
-FFX_STATIC FfxFloat32 ffxDot2(FfxFloat32x2 a, FfxFloat32x2 b)
-{
-    return a[0] * b[0] + a[1] * b[1];
-}
-
-FFX_STATIC FfxFloat32 ffxDot3(FfxFloat32x3 a, FfxFloat32x3 b)
-{
-    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-}
-
-FFX_STATIC FfxFloat32 ffxDot4(FfxFloat32x4 a, FfxFloat32x4 b)
-{
-    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
-}
-
-/// Compute the linear interopation between two values.
-///
-/// Implemented by calling the GLSL <c><i>mix</i></c> instrinsic function. Implements the
-/// following math:
-///
-///     (1 - t) * x + t * y
-///
-/// @param [in] x               The first value to lerp between.
-/// @param [in] y               The second value to lerp between.
-/// @param [in] t               The value to determine how much of <c><i>x</i></c> and how much of <c><i>y</i></c>.
-///
-/// @returns
-/// A linearly interpolated value between <c><i>x</i></c> and <c><i>y</i></c> according to <c><i>t</i></c>.
-///
-/// @ingroup CPU
-FFX_STATIC FfxFloat32 ffxLerp(FfxFloat32 x, FfxFloat32 y, FfxFloat32 t)
-{
-    return y * t + (-x * t + x);
-}
-
-/// Compute the reciprocal of a value.
-///
-/// @param [in] x               The value to compute the reciprocal for.
-///
-/// @returns
-/// The reciprocal value of <c><i>x</i></c>.
-///
-/// @ingroup CPU
-FFX_STATIC FfxFloat32 ffxReciprocal(FfxFloat32 a)
-{
-    return 1.0f / a;
-}
-
-/// Compute the square root of a value.
-///
-/// @param [in] x                   The first value to compute the min of.
-///
-/// @returns
-/// The the square root of <c><i>x</i></c>.
-///
-/// @ingroup CPU
-FFX_STATIC FfxFloat32 ffxSqrt(FfxFloat32 x)
-{
-    return sqrt(x);
-}
-
-FFX_STATIC FfxUInt32 AShrSU1(FfxUInt32 a, FfxUInt32 b)
-{
-    return FfxUInt32(FfxInt32(a) >> FfxInt32(b));
-}
-
-/// Compute the factional part of a decimal value.
-///
-/// This function calculates <c><i>x - floor(x)</i></c>. 
-///
-/// @param [in] x               The value to compute the fractional part from.
-///
-/// @returns
-/// The fractional part of <c><i>x</i></c>.
-///
-/// @ingroup CPU
-FFX_STATIC FfxFloat32 ffxFract(FfxFloat32 a)
-{
-    return a - floor(a);
-}
-
-/// Compute the reciprocal square root of a value.
-///
-/// @param [in] x               The value to compute the reciprocal for.
-///
-/// @returns
-/// The reciprocal square root value of <c><i>x</i></c>.
-///
-/// @ingroup CPU
-FFX_STATIC FfxFloat32 rsqrt(FfxFloat32 a)
-{
-    return ffxReciprocal(ffxSqrt(a));
-}
-
-FFX_STATIC FfxFloat32 ffxMin(FfxFloat32 x, FfxFloat32 y)
-{
-    return x < y ? x : y;
-}
-
-FFX_STATIC FfxUInt32 ffxMin(FfxUInt32 x, FfxUInt32 y)
-{
-    return x < y ? x : y;
-}
-
-FFX_STATIC FfxFloat32 ffxMax(FfxFloat32 x, FfxFloat32 y)
-{
-    return x > y ? x : y;
-}
-
-FFX_STATIC FfxUInt32 ffxMax(FfxUInt32 x, FfxUInt32 y)
-{
-    return x > y ? x : y;
-}
-
-/// Clamp a value to a [0..1] range.
-///
-/// @param [in] x               The value to clamp to [0..1] range.
-///
-/// @returns
-/// The clamped version of <c><i>x</i></c>.
-///
-/// @ingroup CPU
-FFX_STATIC FfxFloat32 ffxSaturate(FfxFloat32 a)
-{
-    return ffxMin(1.0f, ffxMax(0.0f, a));
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-FFX_STATIC void opAAddOneF3(FfxFloat32x3 d, FfxFloat32x3 a, FfxFloat32 b)
-{
-    d[0] = a[0] + b;
-    d[1] = a[1] + b;
-    d[2] = a[2] + b;
-    return;
-}
-
-FFX_STATIC void opACpyF3(FfxFloat32x3 d, FfxFloat32x3 a)
-{
-    d[0] = a[0];
-    d[1] = a[1];
-    d[2] = a[2];
-    return;
-}
-
-FFX_STATIC void opAMulF3(FfxFloat32x3 d, FfxFloat32x3 a, FfxFloat32x3 b)
-{
-    d[0] = a[0] * b[0];
-    d[1] = a[1] * b[1];
-    d[2] = a[2] * b[2];
-    return;
-}
-
-FFX_STATIC void opAMulOneF3(FfxFloat32x3 d, FfxFloat32x3 a, FfxFloat32 b)
-{
-    d[0] = a[0] * b;
-    d[1] = a[1] * b;
-    d[2] = a[2] * b;
-    return;
-}
-
-FFX_STATIC void opARcpF3(FfxFloat32x3 d, FfxFloat32x3 a)
-{
-    d[0] = ffxReciprocal(a[0]);
-    d[1] = ffxReciprocal(a[1]);
-    d[2] = ffxReciprocal(a[2]);
-    return;
-}
-
-/// Convert FfxFloat32 to half (in lower 16-bits of output).
-/// 
-/// This function implements the same fast technique that is documented here: ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf
-/// 
-/// The function supports denormals.
-/// 
-/// Some conversion rules are to make computations possibly "safer" on the GPU,
-///  -INF & -NaN -> -65504
-///  +INF & +NaN -> +65504
-///
-/// @param [in] f               The 32bit floating point value to convert.
-/// 
-/// @returns
-/// The closest 16bit floating point value to <c><i>f</i></c>.
-/// 
-/// @ingroup CPU
-FFX_STATIC FfxUInt32 f32tof16(FfxFloat32 f)
-{
-    static FfxUInt16 base[512] = {
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
-        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 0x0200, 0x0400,
-        0x0800, 0x0c00, 0x1000, 0x1400, 0x1800, 0x1c00, 0x2000, 0x2400, 0x2800, 0x2c00, 0x3000, 0x3400, 0x3800, 0x3c00, 0x4000, 0x4400, 0x4800, 0x4c00, 0x5000,
-        0x5400, 0x5800, 0x5c00, 0x6000, 0x6400, 0x6800, 0x6c00, 0x7000, 0x7400, 0x7800, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff,
-        0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x7bff, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
-        0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8002,
-        0x8004, 0x8008, 0x8010, 0x8020, 0x8040, 0x8080, 0x8100, 0x8200, 0x8400, 0x8800, 0x8c00, 0x9000, 0x9400, 0x9800, 0x9c00, 0xa000, 0xa400, 0xa800, 0xac00,
-        0xb000, 0xb400, 0xb800, 0xbc00, 0xc000, 0xc400, 0xc800, 0xcc00, 0xd000, 0xd400, 0xd800, 0xdc00, 0xe000, 0xe400, 0xe800, 0xec00, 0xf000, 0xf400, 0xf800,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff,
-        0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff, 0xfbff
-    };
-    
-    static FfxUInt8 shift[512] = {
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-        0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
-        0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
-        0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18
-    };
-
-    union
-    {
-        FfxFloat32      f;
-        FfxUInt32 u;
-    } bits;
-
-    bits.f       = f;
-    FfxUInt32 u = bits.u;
-    FfxUInt32 i = u >> 23;
-    return (FfxUInt32)(base[i]) + ((u & 0x7fffff) >> shift[i]);
-}
-
-/// Pack 2x32-bit floating point values in a single 32bit value.
-///
-/// This function first converts each component of <c><i>value</i></c> into their nearest 16-bit floating
-/// point representation, and then stores the X and Y components in the lower and upper 16 bits of the
-/// 32bit unsigned integer respectively.
-///
-/// @param [in] value               A 2-dimensional floating point value to convert and pack.
-///
-/// @returns
-/// A packed 32bit value containing 2 16bit floating point values.
-///
-/// @ingroup CPU
-FFX_STATIC FfxUInt32 packHalf2x16(FfxFloat32x2 a)
-{
-    return f32tof16(a[0]) + (f32tof16(a[1]) << 16);
-}

Assets/Resources/FSR2/shaders/ffx_fsr2_accumulate.h

@@ -1,295 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef FFX_FSR2_ACCUMULATE_H
-#define FFX_FSR2_ACCUMULATE_H
-
-FfxFloat32 GetPxHrVelocity(FfxFloat32x2 fMotionVector)
-{
-    return length(fMotionVector * DisplaySize());
-}
-#if FFX_HALF
-FFX_MIN16_F GetPxHrVelocity(FFX_MIN16_F2 fMotionVector)
-{
-    return length(fMotionVector * FFX_MIN16_F2(DisplaySize()));
-}
-#endif
-
-void Accumulate(const AccumulationPassCommonParams params, FFX_PARAMETER_INOUT FfxFloat32x3 fHistoryColor, FfxFloat32x3 fAccumulation, FFX_PARAMETER_IN FfxFloat32x4 fUpsampledColorAndWeight)
-{
-    // Aviod invalid values when accumulation and upsampled weight is 0
-    fAccumulation = ffxMax(FSR2_EPSILON.xxx, fAccumulation + fUpsampledColorAndWeight.www);
-
-#if FFX_FSR2_OPTION_HDR_COLOR_INPUT
-    //YCoCg -> RGB -> Tonemap -> YCoCg (Use RGB tonemapper to avoid color desaturation)
-    fUpsampledColorAndWeight.xyz = RGBToYCoCg(Tonemap(YCoCgToRGB(fUpsampledColorAndWeight.xyz)));
-    fHistoryColor = RGBToYCoCg(Tonemap(YCoCgToRGB(fHistoryColor)));
-#endif
-
-    const FfxFloat32x3 fAlpha = fUpsampledColorAndWeight.www / fAccumulation;
-    fHistoryColor = ffxLerp(fHistoryColor, fUpsampledColorAndWeight.xyz, fAlpha);
-
-    fHistoryColor = YCoCgToRGB(fHistoryColor);
-
-#if FFX_FSR2_OPTION_HDR_COLOR_INPUT
-    fHistoryColor = InverseTonemap(fHistoryColor);
-#endif
-}
-
-void RectifyHistory(
-    const AccumulationPassCommonParams params,
-    RectificationBox clippingBox,
-    FFX_PARAMETER_INOUT FfxFloat32x3 fHistoryColor,
-    FFX_PARAMETER_INOUT FfxFloat32x3 fAccumulation,
-    FfxFloat32 fLockContributionThisFrame,
-    FfxFloat32 fTemporalReactiveFactor,
-    FfxFloat32 fLumaInstabilityFactor)
-{
-    FfxFloat32 fScaleFactorInfluence = ffxMin(20.0f, ffxPow(FfxFloat32(1.0f / length(DownscaleFactor().x * DownscaleFactor().y)), 3.0f));
-
-    const FfxFloat32 fVecolityFactor = ffxSaturate(params.fHrVelocity / 20.0f);
-    const FfxFloat32 fBoxScaleT = ffxMax(params.fDepthClipFactor, ffxMax(params.fAccumulationMask, fVecolityFactor));
-    FfxFloat32 fBoxScale = ffxLerp(fScaleFactorInfluence, 1.0f, fBoxScaleT);
-
-    FfxFloat32x3 fScaledBoxVec = clippingBox.boxVec * fBoxScale;
-    FfxFloat32x3 boxMin = clippingBox.boxCenter - fScaledBoxVec;
-    FfxFloat32x3 boxMax = clippingBox.boxCenter + fScaledBoxVec;
-    FfxFloat32x3 boxCenter = clippingBox.boxCenter;
-    FfxFloat32 boxVecSize = length(clippingBox.boxVec);
-
-    boxMin = ffxMax(clippingBox.aabbMin, boxMin);
-    boxMax = ffxMin(clippingBox.aabbMax, boxMax);
-
-    if (any(FFX_GREATER_THAN(boxMin, fHistoryColor)) || any(FFX_GREATER_THAN(fHistoryColor, boxMax))) {
-
-        const FfxFloat32x3 fClampedHistoryColor = clamp(fHistoryColor, boxMin, boxMax);
-
-        FfxFloat32x3 fHistoryContribution = ffxMax(fLumaInstabilityFactor, fLockContributionThisFrame).xxx;
-        
-        const FfxFloat32 fReactiveFactor = params.fDilatedReactiveFactor;
-        const FfxFloat32 fReactiveContribution = 1.0f - ffxPow(fReactiveFactor, 1.0f / 2.0f);
-        fHistoryContribution *= fReactiveContribution;
-
-        // Scale history color using rectification info, also using accumulation mask to avoid potential invalid color protection
-        fHistoryColor = ffxLerp(fClampedHistoryColor, fHistoryColor, ffxSaturate(fHistoryContribution));
-
-        // Scale accumulation using rectification info
-        const FfxFloat32x3 fAccumulationMin = ffxMin(fAccumulation, FFX_BROADCAST_FLOAT32X3(0.1f));
-        fAccumulation = ffxLerp(fAccumulationMin, fAccumulation, ffxSaturate(fHistoryContribution));
-    }
-}
-
-void WriteUpscaledOutput(FfxInt32x2 iPxHrPos, FfxFloat32x3 fUpscaledColor)
-{
-    StoreUpscaledOutput(iPxHrPos, fUpscaledColor);
-}
-
-void FinalizeLockStatus(const AccumulationPassCommonParams params, FfxFloat32x2 fLockStatus, FfxFloat32 fUpsampledWeight)
-{
-    // we expect similar motion for next frame
-    // kill lock if that location is outside screen, avoid locks to be clamped to screen borders
-    FfxFloat32x2 fEstimatedUvNextFrame = params.fHrUv - params.fMotionVector;
-    if (IsUvInside(fEstimatedUvNextFrame) == false) {
-        KillLock(fLockStatus);
-    }
-    else {
-        // Decrease lock lifetime
-        const FfxFloat32 fLifetimeDecreaseLanczosMax = FfxFloat32(JitterSequenceLength()) * FfxFloat32(fAverageLanczosWeightPerFrame);
-        const FfxFloat32 fLifetimeDecrease = FfxFloat32(fUpsampledWeight / fLifetimeDecreaseLanczosMax);
-        fLockStatus[LOCK_LIFETIME_REMAINING] = ffxMax(FfxFloat32(0), fLockStatus[LOCK_LIFETIME_REMAINING] - fLifetimeDecrease);
-    }
-
-    StoreLockStatus(params.iPxHrPos, fLockStatus);
-}
-
-
-FfxFloat32x3 ComputeBaseAccumulationWeight(const AccumulationPassCommonParams params, FfxFloat32 fThisFrameReactiveFactor, FfxBoolean bInMotionLastFrame, FfxFloat32 fUpsampledWeight, LockState lockState)
-{
-    // Always assume max accumulation was reached
-    FfxFloat32 fBaseAccumulation = fMaxAccumulationLanczosWeight * FfxFloat32(params.bIsExistingSample) * (1.0f - fThisFrameReactiveFactor) * (1.0f - params.fDepthClipFactor);
-
-    fBaseAccumulation = ffxMin(fBaseAccumulation, ffxLerp(fBaseAccumulation, fUpsampledWeight * 10.0f, ffxMax(FfxFloat32(bInMotionLastFrame), ffxSaturate(params.fHrVelocity * FfxFloat32(10)))));
-
-    fBaseAccumulation = ffxMin(fBaseAccumulation, ffxLerp(fBaseAccumulation, fUpsampledWeight, ffxSaturate(params.fHrVelocity / FfxFloat32(20))));
-
-    return fBaseAccumulation.xxx;
-}
-
-FfxFloat32 ComputeLumaInstabilityFactor(const AccumulationPassCommonParams params, RectificationBox clippingBox, FfxFloat32 fThisFrameReactiveFactor, FfxFloat32 fLuminanceDiff)
-{
-    const FfxFloat32 fUnormThreshold = 1.0f / 255.0f;
-    const FfxInt32 N_MINUS_1 = 0;
-    const FfxInt32 N_MINUS_2 = 1;
-    const FfxInt32 N_MINUS_3 = 2;
-    const FfxInt32 N_MINUS_4 = 3;
-
-    FfxFloat32 fCurrentFrameLuma = clippingBox.boxCenter.x;
-
-#if FFX_FSR2_OPTION_HDR_COLOR_INPUT
-    fCurrentFrameLuma = fCurrentFrameLuma / (1.0f + ffxMax(0.0f, fCurrentFrameLuma));
-#endif
-
-    fCurrentFrameLuma = round(fCurrentFrameLuma * 255.0f) / 255.0f;
-
-    const FfxBoolean bSampleLumaHistory = (ffxMax(ffxMax(params.fDepthClipFactor, params.fAccumulationMask), fLuminanceDiff) < 0.1f) && (params.bIsNewSample == false);
-    FfxFloat32x4 fCurrentFrameLumaHistory = bSampleLumaHistory ? SampleLumaHistory(params.fReprojectedHrUv) : FFX_BROADCAST_FLOAT32X4(0.0f);
-
-    FfxFloat32 fLumaInstability = 0.0f;
-    FfxFloat32 fDiffs0 = (fCurrentFrameLuma - fCurrentFrameLumaHistory[N_MINUS_1]);
-
-    FfxFloat32 fMin = abs(fDiffs0);
-
-    if (fMin >= fUnormThreshold)
-    {
-        for (int i = N_MINUS_2; i <= N_MINUS_4; i++) {
-            FfxFloat32 fDiffs1 = (fCurrentFrameLuma - fCurrentFrameLumaHistory[i]);
-
-            if (sign(fDiffs0) == sign(fDiffs1)) {
-                
-                // Scale difference to protect historically similar values
-                const FfxFloat32 fMinBias = 1.0f;
-                fMin = ffxMin(fMin, abs(fDiffs1) * fMinBias);
-            }
-        }
-
-        const FfxFloat32 fBoxSize = clippingBox.boxVec.x;
-        const FfxFloat32 fBoxSizeFactor = ffxPow(ffxSaturate(fBoxSize / 0.1f), 6.0f);
-
-        fLumaInstability = FfxFloat32(fMin != abs(fDiffs0)) * fBoxSizeFactor;
-        fLumaInstability = FfxFloat32(fLumaInstability > fUnormThreshold);
-
-        fLumaInstability *= 1.0f - ffxMax(params.fAccumulationMask, ffxPow(fThisFrameReactiveFactor, 1.0f / 6.0f));
-    }
-
-    //shift history
-    fCurrentFrameLumaHistory[N_MINUS_4] = fCurrentFrameLumaHistory[N_MINUS_3];
-    fCurrentFrameLumaHistory[N_MINUS_3] = fCurrentFrameLumaHistory[N_MINUS_2];
-    fCurrentFrameLumaHistory[N_MINUS_2] = fCurrentFrameLumaHistory[N_MINUS_1];
-    fCurrentFrameLumaHistory[N_MINUS_1] = fCurrentFrameLuma;
-
-    StoreLumaHistory(params.iPxHrPos, fCurrentFrameLumaHistory);
-
-    return fLumaInstability * FfxFloat32(fCurrentFrameLumaHistory[N_MINUS_4] != 0);
-}
-
-FfxFloat32 ComputeTemporalReactiveFactor(const AccumulationPassCommonParams params, FfxFloat32 fTemporalReactiveFactor)
-{
-    FfxFloat32 fNewFactor = ffxMin(0.99f, fTemporalReactiveFactor);
-
-    fNewFactor = ffxMax(fNewFactor, ffxLerp(fNewFactor, 0.4f, ffxSaturate(params.fHrVelocity)));
-
-    fNewFactor = ffxMax(fNewFactor * fNewFactor, ffxMax(params.fDepthClipFactor * 0.1f, params.fDilatedReactiveFactor));
-
-    // Force reactive factor for new samples
-    fNewFactor = params.bIsNewSample ? 1.0f : fNewFactor;
-
-    if (ffxSaturate(params.fHrVelocity * 10.0f) >= 1.0f) {
-        fNewFactor = ffxMax(FSR2_EPSILON, fNewFactor) * -1.0f;
-    }
-    
-    return fNewFactor;
-}
-
-AccumulationPassCommonParams InitParams(FfxInt32x2 iPxHrPos)
-{
-    AccumulationPassCommonParams params;
-
-    params.iPxHrPos = iPxHrPos;
-    const FfxFloat32x2 fHrUv = (iPxHrPos + 0.5f) / DisplaySize();
-    params.fHrUv = fHrUv;
-    
-    const FfxFloat32x2 fLrUvJittered = fHrUv + Jitter() / RenderSize();
-    params.fLrUv_HwSampler = ClampUv(fLrUvJittered, RenderSize(), MaxRenderSize());
-
-    params.fMotionVector = GetMotionVector(iPxHrPos, fHrUv);
-    params.fHrVelocity = GetPxHrVelocity(params.fMotionVector);
-
-    ComputeReprojectedUVs(params, params.fReprojectedHrUv, params.bIsExistingSample);
-
-    params.fDepthClipFactor = ffxSaturate(SampleDepthClip(params.fLrUv_HwSampler));
-    
-    const FfxFloat32x2 fDilatedReactiveMasks = SampleDilatedReactiveMasks(params.fLrUv_HwSampler);
-    params.fDilatedReactiveFactor = fDilatedReactiveMasks.x;
-    params.fAccumulationMask = fDilatedReactiveMasks.y;
-    params.bIsResetFrame = (0 == FrameIndex());
-
-    params.bIsNewSample = (params.bIsExistingSample == false || params.bIsResetFrame);
-
-    return params;
-}
-
-void Accumulate(FfxInt32x2 iPxHrPos)
-{
-    const AccumulationPassCommonParams params = InitParams(iPxHrPos);
-
-    FfxFloat32x3 fHistoryColor = FfxFloat32x3(0, 0, 0);
-    FfxFloat32x2 fLockStatus;
-    InitializeNewLockSample(fLockStatus);
-
-    FfxFloat32 fTemporalReactiveFactor = 0.0f;
-    FfxBoolean bInMotionLastFrame = FFX_FALSE;
-    LockState lockState = { FFX_FALSE , FFX_FALSE };
-    if (params.bIsExistingSample && !params.bIsResetFrame) {
-        ReprojectHistoryColor(params, fHistoryColor, fTemporalReactiveFactor, bInMotionLastFrame);
-        lockState = ReprojectHistoryLockStatus(params, fLockStatus);
-    }
-
-    FfxFloat32 fThisFrameReactiveFactor = ffxMax(params.fDilatedReactiveFactor, fTemporalReactiveFactor);
-
-    FfxFloat32 fLuminanceDiff = 0.0f;
-    FfxFloat32 fLockContributionThisFrame = 0.0f;
-    UpdateLockStatus(params, fThisFrameReactiveFactor, lockState, fLockStatus, fLockContributionThisFrame, fLuminanceDiff);
-
-    // Load upsampled input color
-    RectificationBox clippingBox;
-    FfxFloat32x4 fUpsampledColorAndWeight = ComputeUpsampledColorAndWeight(params, clippingBox, fThisFrameReactiveFactor);
-    
-    const FfxFloat32 fLumaInstabilityFactor = ComputeLumaInstabilityFactor(params, clippingBox, fThisFrameReactiveFactor, fLuminanceDiff);
-
-
-    FfxFloat32x3 fAccumulation = ComputeBaseAccumulationWeight(params, fThisFrameReactiveFactor, bInMotionLastFrame, fUpsampledColorAndWeight.w, lockState);
-
-    if (params.bIsNewSample) {
-        fHistoryColor = YCoCgToRGB(fUpsampledColorAndWeight.xyz);
-    }
-    else {
-        RectifyHistory(params, clippingBox, fHistoryColor, fAccumulation, fLockContributionThisFrame, fThisFrameReactiveFactor, fLumaInstabilityFactor);
-
-        Accumulate(params, fHistoryColor, fAccumulation, fUpsampledColorAndWeight);
-    }
-
-    fHistoryColor = UnprepareRgb(fHistoryColor, Exposure());
-
-    FinalizeLockStatus(params, fLockStatus, fUpsampledColorAndWeight.w);
-
-    // Get new temporal reactive factor
-    fTemporalReactiveFactor = ComputeTemporalReactiveFactor(params, fThisFrameReactiveFactor);
-
-    StoreInternalColorAndWeight(iPxHrPos, FfxFloat32x4(fHistoryColor, fTemporalReactiveFactor));
-
-    // Output final color when RCAS is disabled
-#if FFX_FSR2_OPTION_APPLY_SHARPENING == 0
-    WriteUpscaledOutput(iPxHrPos, fHistoryColor);
-#endif
-    StoreNewLocks(iPxHrPos, 0);
-}
-
-#endif // FFX_FSR2_ACCUMULATE_H

Assets/Resources/FSR2/shaders/ffx_fsr2_accumulate.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: a04cb2522aaff1045869a272ed129964
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_accumulate_pass.hlsl

@@ -1,78 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#define FSR2_BIND_SRV_INPUT_EXPOSURE                         0
-#define FSR2_BIND_SRV_DILATED_REACTIVE_MASKS                 1
-#if FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-#define FSR2_BIND_SRV_DILATED_MOTION_VECTORS                 2
-#else
-#define FSR2_BIND_SRV_INPUT_MOTION_VECTORS                   2
-#endif
-#define FSR2_BIND_SRV_INTERNAL_UPSCALED                      3
-#define FSR2_BIND_SRV_LOCK_STATUS                            4
-#define FSR2_BIND_SRV_PREPARED_INPUT_COLOR                   5
-#define FSR2_BIND_SRV_LANCZOS_LUT                            6
-#define FSR2_BIND_SRV_UPSCALE_MAXIMUM_BIAS_LUT               7
-#define FSR2_BIND_SRV_SCENE_LUMINANCE_MIPS                   8
-#define FSR2_BIND_SRV_AUTO_EXPOSURE                          9
-#define FSR2_BIND_SRV_LUMA_HISTORY                           10
-
-#define FSR2_BIND_UAV_INTERNAL_UPSCALED                      0
-#define FSR2_BIND_UAV_LOCK_STATUS                            1
-#define FSR2_BIND_UAV_UPSCALED_OUTPUT                        2
-#define FSR2_BIND_UAV_NEW_LOCKS                              3
-#define FSR2_BIND_UAV_LUMA_HISTORY                           4
-
-#define FSR2_BIND_CB_FSR2                                    0
-
-#include "ffx_fsr2_callbacks_hlsl.h"
-#include "ffx_fsr2_common.h"
-#include "ffx_fsr2_sample.h"
-#include "ffx_fsr2_upsample.h"
-#include "ffx_fsr2_postprocess_lock_status.h"
-#include "ffx_fsr2_reproject.h"
-#include "ffx_fsr2_accumulate.h"
-
-#ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#define FFX_FSR2_THREAD_GROUP_WIDTH 8
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#define FFX_FSR2_THREAD_GROUP_HEIGHT 8
-#endif // FFX_FSR2_THREAD_GROUP_HEIGHT
-#ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#define FFX_FSR2_THREAD_GROUP_DEPTH 1
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#ifndef FFX_FSR2_NUM_THREADS
-#define FFX_FSR2_NUM_THREADS [numthreads(FFX_FSR2_THREAD_GROUP_WIDTH, FFX_FSR2_THREAD_GROUP_HEIGHT, FFX_FSR2_THREAD_GROUP_DEPTH)]
-#endif // #ifndef FFX_FSR2_NUM_THREADS
-
-FFX_FSR2_PREFER_WAVE64
-FFX_FSR2_NUM_THREADS
-FFX_FSR2_EMBED_ROOTSIG_CONTENT
-void CS(uint2 uGroupId : SV_GroupID, uint2 uGroupThreadId : SV_GroupThreadID)
-{
-    const uint GroupRows = (uint(DisplaySize().y) + FFX_FSR2_THREAD_GROUP_HEIGHT - 1) / FFX_FSR2_THREAD_GROUP_HEIGHT;
-    uGroupId.y = GroupRows - uGroupId.y - 1;
-
-    uint2 uDispatchThreadId = uGroupId * uint2(FFX_FSR2_THREAD_GROUP_WIDTH, FFX_FSR2_THREAD_GROUP_HEIGHT) + uGroupThreadId;
-
-    Accumulate(uDispatchThreadId);
-}

Assets/Resources/FSR2/shaders/ffx_fsr2_autogen_reactive_pass.hlsl

@@ -1,85 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#define FSR2_BIND_SRV_INPUT_OPAQUE_ONLY                     0
-#define FSR2_BIND_SRV_INPUT_COLOR                           1
-#define FSR2_BIND_UAV_AUTOREACTIVE                          0
-
-#define FSR2_BIND_CB_FSR2                                   0
-#define FSR2_BIND_CB_REACTIVE                               1
-
-#include "ffx_fsr2_callbacks_hlsl.h"
-#include "ffx_fsr2_common.h"
-
-#ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#define FFX_FSR2_THREAD_GROUP_WIDTH 8
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#define FFX_FSR2_THREAD_GROUP_HEIGHT 8
-#endif // FFX_FSR2_THREAD_GROUP_HEIGHT
-#ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#define FFX_FSR2_THREAD_GROUP_DEPTH 1
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#ifndef FFX_FSR2_NUM_THREADS
-#define FFX_FSR2_NUM_THREADS [numthreads(FFX_FSR2_THREAD_GROUP_WIDTH, FFX_FSR2_THREAD_GROUP_HEIGHT, FFX_FSR2_THREAD_GROUP_DEPTH)]
-#endif // #ifndef FFX_FSR2_NUM_THREADS
-
-#if defined(FSR2_BIND_CB_REACTIVE)
-cbuffer cbGenerateReactive : FFX_FSR2_DECLARE_CB(FSR2_BIND_CB_REACTIVE)
-{
-    float   scale;
-    float   threshold;
-    float   binaryValue;
-    uint    flags;
-};
-#endif
-
-FFX_FSR2_NUM_THREADS
-FFX_FSR2_EMBED_ROOTSIG_CONTENT
-void CS(uint2 uGroupId : SV_GroupID, uint2 uGroupThreadId : SV_GroupThreadID)
-{
-    uint2 uDispatchThreadId = uGroupId * uint2(FFX_FSR2_THREAD_GROUP_WIDTH, FFX_FSR2_THREAD_GROUP_HEIGHT) + uGroupThreadId;
-
-    float3 ColorPreAlpha    = LoadOpaqueOnly( FFX_MIN16_I2(uDispatchThreadId) ).rgb;
-    float3 ColorPostAlpha   = LoadInputColor(uDispatchThreadId).rgb;
-    
-    if (flags & FFX_FSR2_AUTOREACTIVEFLAGS_APPLY_TONEMAP)
-    {
-        ColorPreAlpha = Tonemap(ColorPreAlpha);
-        ColorPostAlpha = Tonemap(ColorPostAlpha);
-    }
-
-    if (flags & FFX_FSR2_AUTOREACTIVEFLAGS_APPLY_INVERSETONEMAP)
-    {
-        ColorPreAlpha = InverseTonemap(ColorPreAlpha);
-        ColorPostAlpha = InverseTonemap(ColorPostAlpha);
-    }
-
-    float out_reactive_value = 0.f;
-    float3 delta = abs(ColorPostAlpha - ColorPreAlpha);
-    
-    out_reactive_value = (flags & FFX_FSR2_AUTOREACTIVEFLAGS_USE_COMPONENTS_MAX) ? max(delta.x, max(delta.y, delta.z)) : length(delta);
-    out_reactive_value *= scale;
-
-    out_reactive_value = (flags & FFX_FSR2_AUTOREACTIVEFLAGS_APPLY_THRESHOLD) ? (out_reactive_value < threshold ? 0 : binaryValue) : out_reactive_value;
-
-    rw_output_autoreactive[uDispatchThreadId] = out_reactive_value;
-}

Assets/Resources/FSR2/shaders/ffx_fsr2_callbacks_hlsl.h

@@ -1,817 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "ffx_fsr2_resources.h"
-
-#if defined(FFX_GPU)
-#ifdef __hlsl_dx_compiler
-#pragma dxc diagnostic push
-#pragma dxc diagnostic ignored "-Wambig-lit-shift"
-#endif //__hlsl_dx_compiler
-#include "ffx_core.h"
-#ifdef __hlsl_dx_compiler
-#pragma dxc diagnostic pop
-#endif //__hlsl_dx_compiler
-#endif // #if defined(FFX_GPU)
-
-#if defined(FFX_GPU)
-#ifndef FFX_FSR2_PREFER_WAVE64
-#define FFX_FSR2_PREFER_WAVE64
-#endif // #if defined(FFX_GPU)
-
-#if defined(FFX_GPU)
-#pragma warning(disable: 3205)  // conversion from larger type to smaller
-#endif // #if defined(FFX_GPU)
-
-#define DECLARE_SRV_REGISTER(regIndex)  t##regIndex
-#define DECLARE_UAV_REGISTER(regIndex)  u##regIndex
-#define DECLARE_CB_REGISTER(regIndex)   b##regIndex
-#define FFX_FSR2_DECLARE_SRV(regIndex)  register(DECLARE_SRV_REGISTER(regIndex))
-#define FFX_FSR2_DECLARE_UAV(regIndex)  register(DECLARE_UAV_REGISTER(regIndex))
-#define FFX_FSR2_DECLARE_CB(regIndex)   register(DECLARE_CB_REGISTER(regIndex))
-
-#if defined(FSR2_BIND_CB_FSR2) || defined(FFX_INTERNAL)
-    cbuffer cbFSR2 : FFX_FSR2_DECLARE_CB(FSR2_BIND_CB_FSR2)
-    {
-        FfxInt32x2    iRenderSize;
-        FfxInt32x2    iMaxRenderSize;
-        FfxInt32x2    iDisplaySize;
-        FfxInt32x2    iInputColorResourceDimensions;
-        FfxInt32x2    iLumaMipDimensions;
-        FfxInt32      iLumaMipLevelToUse;
-        FfxInt32      iFrameIndex;
-
-        FfxFloat32x4  fDeviceToViewDepth;
-        FfxFloat32x2  fJitter;
-        FfxFloat32x2  fMotionVectorScale;
-        FfxFloat32x2  fDownscaleFactor;
-        FfxFloat32x2  fMotionVectorJitterCancellation;
-        FfxFloat32    fPreExposure;
-        FfxFloat32    fPreviousFramePreExposure;
-        FfxFloat32    fTanHalfFOV;
-        FfxFloat32    fJitterSequenceLength;
-        FfxFloat32    fDeltaTime;
-        FfxFloat32    fDynamicResChangeFactor;
-        FfxFloat32    fViewSpaceToMetersFactor;
-
-        FfxInt32      iDummy;
-    };
-
-#define FFX_FSR2_CONSTANT_BUFFER_1_SIZE (sizeof(cbFSR2) / 4)  // Number of 32-bit values. This must be kept in sync with the cbFSR2 size.
-#endif
-
-#if defined(FFX_GPU)
-#define FFX_FSR2_ROOTSIG_STRINGIFY(p) FFX_FSR2_ROOTSIG_STR(p)
-#define FFX_FSR2_ROOTSIG_STR(p) #p
-#define FFX_FSR2_ROOTSIG [RootSignature( "DescriptorTable(UAV(u0, numDescriptors = " FFX_FSR2_ROOTSIG_STRINGIFY(FFX_FSR2_RESOURCE_IDENTIFIER_COUNT) ")), " \
-                                    "DescriptorTable(SRV(t0, numDescriptors = " FFX_FSR2_ROOTSIG_STRINGIFY(FFX_FSR2_RESOURCE_IDENTIFIER_COUNT) ")), " \
-                                    "RootConstants(num32BitConstants=" FFX_FSR2_ROOTSIG_STRINGIFY(FFX_FSR2_CONSTANT_BUFFER_1_SIZE) ", b0), " \
-                                    "StaticSampler(s0, filter = FILTER_MIN_MAG_MIP_POINT, " \
-                                                      "addressU = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "addressV = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "addressW = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "comparisonFunc = COMPARISON_NEVER, " \
-                                                      "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK), " \
-                                    "StaticSampler(s1, filter = FILTER_MIN_MAG_MIP_LINEAR, " \
-                                                      "addressU = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "addressV = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "addressW = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "comparisonFunc = COMPARISON_NEVER, " \
-                                                      "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK)" )]
-
-#define FFX_FSR2_CONSTANT_BUFFER_2_SIZE 6  // Number of 32-bit values. This must be kept in sync with max( cbRCAS , cbSPD) size.
-
-#define FFX_FSR2_CB2_ROOTSIG [RootSignature( "DescriptorTable(UAV(u0, numDescriptors = " FFX_FSR2_ROOTSIG_STRINGIFY(FFX_FSR2_RESOURCE_IDENTIFIER_COUNT) ")), " \
-                                    "DescriptorTable(SRV(t0, numDescriptors = " FFX_FSR2_ROOTSIG_STRINGIFY(FFX_FSR2_RESOURCE_IDENTIFIER_COUNT) ")), " \
-                                    "RootConstants(num32BitConstants=" FFX_FSR2_ROOTSIG_STRINGIFY(FFX_FSR2_CONSTANT_BUFFER_1_SIZE) ", b0), " \
-                                    "RootConstants(num32BitConstants=" FFX_FSR2_ROOTSIG_STRINGIFY(FFX_FSR2_CONSTANT_BUFFER_2_SIZE) ", b1), " \
-                                    "StaticSampler(s0, filter = FILTER_MIN_MAG_MIP_POINT, " \
-                                                      "addressU = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "addressV = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "addressW = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "comparisonFunc = COMPARISON_NEVER, " \
-                                                      "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK), " \
-                                    "StaticSampler(s1, filter = FILTER_MIN_MAG_MIP_LINEAR, " \
-                                                      "addressU = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "addressV = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "addressW = TEXTURE_ADDRESS_CLAMP, " \
-                                                      "comparisonFunc = COMPARISON_NEVER, " \
-                                                      "borderColor = STATIC_BORDER_COLOR_TRANSPARENT_BLACK)" )]
-#if defined(FFX_FSR2_EMBED_ROOTSIG)
-#define FFX_FSR2_EMBED_ROOTSIG_CONTENT FFX_FSR2_ROOTSIG
-#define FFX_FSR2_EMBED_CB2_ROOTSIG_CONTENT FFX_FSR2_CB2_ROOTSIG
-#else
-#define FFX_FSR2_EMBED_ROOTSIG_CONTENT
-#define FFX_FSR2_EMBED_CB2_ROOTSIG_CONTENT
-#endif // #if FFX_FSR2_EMBED_ROOTSIG
-#endif // #if defined(FFX_GPU)
-
-// Declare and sample camera buffers as regular textures, unless overridden
-#if !defined(UNITY_FSR2_TEX2D)
-#define UNITY_FSR2_TEX2D(type)      Texture2D<type>
-#endif
-#if !defined(UNITY_FSR2_POS)
-#define UNITY_FSR2_POS(pxPos)       (pxPos)
-#endif
-#if !defined(UNITY_FSR2_UV)
-#define UNITY_FSR2_UV(uv)           (uv)
-#endif
-
-/* Define getter functions in the order they are defined in the CB! */
-FfxInt32x2 RenderSize()
-{
-    return iRenderSize;
-}
-
-FfxInt32x2 MaxRenderSize()
-{
-    return iMaxRenderSize;
-}
-
-FfxInt32x2 DisplaySize()
-{
-    return iDisplaySize;
-}
-
-FfxInt32x2 InputColorResourceDimensions()
-{
-    return iInputColorResourceDimensions;
-}
-
-FfxInt32x2 LumaMipDimensions()
-{
-    return iLumaMipDimensions;
-}
-
-FfxInt32  LumaMipLevelToUse()
-{
-    return iLumaMipLevelToUse;
-}
-
-FfxInt32 FrameIndex()
-{
-    return iFrameIndex;
-}
-
-FfxFloat32x2 Jitter()
-{
-    return fJitter;
-}
-
-FfxFloat32x4 DeviceToViewSpaceTransformFactors()
-{
-    return fDeviceToViewDepth;
-}
-
-FfxFloat32x2 MotionVectorScale()
-{
-    return fMotionVectorScale;
-}
-
-FfxFloat32x2 DownscaleFactor()
-{
-    return fDownscaleFactor;
-}
-
-FfxFloat32x2 MotionVectorJitterCancellation()
-{
-    return fMotionVectorJitterCancellation;
-}
-
-FfxFloat32 PreExposure()
-{
-    return fPreExposure;
-}
-
-FfxFloat32 PreviousFramePreExposure()
-{
-    return fPreviousFramePreExposure;
-}
-
-FfxFloat32 TanHalfFoV()
-{
-    return fTanHalfFOV;
-}
-
-FfxFloat32 JitterSequenceLength()
-{
-    return fJitterSequenceLength;
-}
-
-FfxFloat32 DeltaTime()
-{
-    return fDeltaTime;
-}
-
-FfxFloat32 DynamicResChangeFactor()
-{
-    return fDynamicResChangeFactor;
-}
-
-FfxFloat32 ViewSpaceToMetersFactor()
-{
-    return fViewSpaceToMetersFactor;
-}
-
-
-SamplerState s_PointClamp : register(s0);
-SamplerState s_LinearClamp : register(s1);
-
-// SRVs
-#if defined(FFX_INTERNAL)
-    UNITY_FSR2_TEX2D(FfxFloat32x4)                r_input_opaque_only                       : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY);
-    UNITY_FSR2_TEX2D(FfxFloat32x4)                r_input_color_jittered                    : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_COLOR);
-    UNITY_FSR2_TEX2D(FfxFloat32x4)                r_input_motion_vectors                    : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_MOTION_VECTORS);
-    UNITY_FSR2_TEX2D(FfxFloat32)                  r_input_depth                             : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_DEPTH);
-    Texture2D<FfxFloat32x2>                       r_input_exposure                          : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_EXPOSURE);
-    Texture2D<FfxFloat32x2>                       r_auto_exposure                           : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_AUTO_EXPOSURE);
-    Texture2D<FfxFloat32>                         r_reactive_mask                           : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK);
-    Texture2D<FfxFloat32>                         r_transparency_and_composition_mask       : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK);
-    Texture2D<FfxUInt32>                          r_reconstructed_previous_nearest_depth    : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH);
-    Texture2D<FfxFloat32x2>                       r_dilated_motion_vectors                  : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS);
-    Texture2D<FfxFloat32x2>                       r_previous_dilated_motion_vectors         : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_PREVIOUS_DILATED_MOTION_VECTORS);
-    Texture2D<FfxFloat32>                         r_dilatedDepth                            : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_DEPTH);
-    Texture2D<FfxFloat32x4>                       r_internal_upscaled_color                 : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR);
-    Texture2D<unorm FfxFloat32x2>                 r_lock_status                             : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS);
-    Texture2D<FfxFloat32>                         r_lock_input_luma                         : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_INPUT_LUMA);
-    Texture2D<unorm FfxFloat32>                   r_new_locks                               : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_NEW_LOCKS);
-    Texture2D<FfxFloat32x4>                       r_prepared_input_color                    : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_PREPARED_INPUT_COLOR);
-    Texture2D<FfxFloat32x4>                       r_luma_history                            : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY);
-    Texture2D<FfxFloat32x4>                       r_rcas_input                              : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_RCAS_INPUT);
-    Texture2D<FfxFloat32>                         r_lanczos_lut                             : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_LANCZOS_LUT);
-    Texture2D<FfxFloat32>                         r_imgMips                                 : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE);
-    Texture2D<FfxFloat32>                         r_upsample_maximum_bias_lut               : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTITIER_UPSAMPLE_MAXIMUM_BIAS_LUT);
-    Texture2D<unorm FfxFloat32x2>                 r_dilated_reactive_masks                  : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS);
-    Texture2D<float3>                             r_input_prev_color_pre_alpha              : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR);
-    Texture2D<float3>                             r_input_prev_color_post_alpha             : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR);
-
-    Texture2D<FfxFloat32x4>                       r_debug_out                               : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_DEBUG_OUTPUT);
-
-    // UAV declarations
-    RWTexture2D<FfxUInt32>                        rw_reconstructed_previous_nearest_depth   : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH);
-    RWTexture2D<FfxFloat32x2>                     rw_dilated_motion_vectors                 : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS);
-    RWTexture2D<FfxFloat32>                       rw_dilatedDepth                           : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_DEPTH);
-    RWTexture2D<FfxFloat32x4>                     rw_internal_upscaled_color                : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR);
-    RWTexture2D<unorm FfxFloat32x2>               rw_lock_status                            : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS);
-    RWTexture2D<FfxFloat32>                       rw_lock_input_luma                        : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_INPUT_LUMA);
-    RWTexture2D<unorm FfxFloat32>                 rw_new_locks                              : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_NEW_LOCKS);
-    RWTexture2D<FfxFloat32x4>                     rw_prepared_input_color                   : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_PREPARED_INPUT_COLOR);
-    RWTexture2D<FfxFloat32x4>                     rw_luma_history                           : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY);
-    RWTexture2D<FfxFloat32x4>                     rw_upscaled_output                        : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT);
-
-    globallycoherent RWTexture2D<FfxFloat32>      rw_img_mip_shading_change                 : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_SHADING_CHANGE);
-    globallycoherent RWTexture2D<FfxFloat32>      rw_img_mip_5                              : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_5);
-    RWTexture2D<unorm FfxFloat32x2>               rw_dilated_reactive_masks                 : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS);
-    RWTexture2D<FfxFloat32x2>                     rw_auto_exposure                          : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_AUTO_EXPOSURE);
-    globallycoherent RWTexture2D<FfxUInt32>       rw_spd_global_atomic                      : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_SPD_ATOMIC_COUNT);
-    RWTexture2D<FfxFloat32x4>                     rw_debug_out                              : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_DEBUG_OUTPUT);
-    
-    RWTexture2D<float>                            rw_output_autoreactive                    : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_AUTOREACTIVE);
-    RWTexture2D<float>                            rw_output_autocomposition                 : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_AUTOCOMPOSITION);
-    RWTexture2D<float3>                           rw_output_prev_color_pre_alpha            : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR);
-    RWTexture2D<float3>                           rw_output_prev_color_post_alpha           : FFX_FSR2_DECLARE_UAV(FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR);  
-
-#else // #if defined(FFX_INTERNAL)
-    #if defined FSR2_BIND_SRV_INPUT_COLOR
-        UNITY_FSR2_TEX2D(FfxFloat32x4)            r_input_color_jittered                    : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_INPUT_COLOR);
-    #endif
-    #if defined FSR2_BIND_SRV_INPUT_OPAQUE_ONLY
-        UNITY_FSR2_TEX2D(FfxFloat32x4)            r_input_opaque_only                       : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_INPUT_OPAQUE_ONLY);
-    #endif
-    #if defined FSR2_BIND_SRV_INPUT_MOTION_VECTORS
-        UNITY_FSR2_TEX2D(FfxFloat32x4)            r_input_motion_vectors                    : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_INPUT_MOTION_VECTORS);
-    #endif
-    #if defined FSR2_BIND_SRV_INPUT_DEPTH
-        UNITY_FSR2_TEX2D(FfxFloat32)              r_input_depth                             : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_INPUT_DEPTH);
-    #endif 
-    #if defined FSR2_BIND_SRV_INPUT_EXPOSURE
-        Texture2D<FfxFloat32x2>                   r_input_exposure                          : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_INPUT_EXPOSURE);
-    #endif
-    #if defined FSR2_BIND_SRV_AUTO_EXPOSURE
-        Texture2D<FfxFloat32x2>                   r_auto_exposure                           : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_AUTO_EXPOSURE);
-    #endif
-    #if defined FSR2_BIND_SRV_REACTIVE_MASK
-        Texture2D<FfxFloat32>                     r_reactive_mask                           : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_REACTIVE_MASK);
-    #endif 
-    #if defined FSR2_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK
-        Texture2D<FfxFloat32>                     r_transparency_and_composition_mask       : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK);
-    #endif
-    #if defined FSR2_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH
-        Texture2D<FfxUInt32>                      r_reconstructed_previous_nearest_depth    : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH);
-    #endif 
-    #if defined FSR2_BIND_SRV_DILATED_MOTION_VECTORS
-       Texture2D<FfxFloat32x2>                    r_dilated_motion_vectors                  : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_DILATED_MOTION_VECTORS);
-    #endif
-    #if defined FSR2_BIND_SRV_PREVIOUS_DILATED_MOTION_VECTORS
-           Texture2D<FfxFloat32x2>                r_previous_dilated_motion_vectors         : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_PREVIOUS_DILATED_MOTION_VECTORS);
-    #endif
-    #if defined FSR2_BIND_SRV_DILATED_DEPTH
-        Texture2D<FfxFloat32>                     r_dilatedDepth                            : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_DILATED_DEPTH);
-    #endif
-    #if defined FSR2_BIND_SRV_INTERNAL_UPSCALED
-        Texture2D<FfxFloat32x4>                   r_internal_upscaled_color                 : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_INTERNAL_UPSCALED);
-    #endif
-    #if defined FSR2_BIND_SRV_LOCK_STATUS
-        Texture2D<unorm FfxFloat32x2>             r_lock_status                             : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_LOCK_STATUS);
-    #endif
-    #if defined FSR2_BIND_SRV_LOCK_INPUT_LUMA
-        Texture2D<FfxFloat32>                     r_lock_input_luma                         : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_LOCK_INPUT_LUMA);
-    #endif
-    #if defined FSR2_BIND_SRV_NEW_LOCKS
-        Texture2D<unorm FfxFloat32>               r_new_locks                               : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_NEW_LOCKS);
-    #endif
-    #if defined FSR2_BIND_SRV_PREPARED_INPUT_COLOR
-        Texture2D<FfxFloat32x4>                  r_prepared_input_color                    : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_PREPARED_INPUT_COLOR);
-    #endif
-    #if defined FSR2_BIND_SRV_LUMA_HISTORY
-        Texture2D<unorm FfxFloat32x4>             r_luma_history                            : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_LUMA_HISTORY);
-    #endif
-    #if defined FSR2_BIND_SRV_RCAS_INPUT
-        Texture2D<FfxFloat32x4>                   r_rcas_input                              : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_RCAS_INPUT);
-    #endif
-    #if defined FSR2_BIND_SRV_LANCZOS_LUT
-        Texture2D<FfxFloat32>                     r_lanczos_lut                             : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_LANCZOS_LUT);
-    #endif
-    #if defined FSR2_BIND_SRV_SCENE_LUMINANCE_MIPS
-        Texture2D<FfxFloat32>                     r_imgMips                                 : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_SCENE_LUMINANCE_MIPS);
-    #endif
-    #if defined FSR2_BIND_SRV_UPSCALE_MAXIMUM_BIAS_LUT
-        Texture2D<FfxFloat32>                     r_upsample_maximum_bias_lut               : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_UPSCALE_MAXIMUM_BIAS_LUT);
-    #endif
-    #if defined FSR2_BIND_SRV_DILATED_REACTIVE_MASKS
-        Texture2D<unorm FfxFloat32x2>             r_dilated_reactive_masks                  : FFX_FSR2_DECLARE_SRV(FSR2_BIND_SRV_DILATED_REACTIVE_MASKS);
-    #endif
-
-    #if defined FSR2_BIND_SRV_PREV_PRE_ALPHA_COLOR
-        Texture2D<float3>                         r_input_prev_color_pre_alpha              : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR);
-    #endif
-    #if defined FSR2_BIND_SRV_PREV_POST_ALPHA_COLOR
-        Texture2D<float3>                         r_input_prev_color_post_alpha             : FFX_FSR2_DECLARE_SRV(FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR);
-    #endif
-   
-    // UAV declarations
-    #if defined FSR2_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH
-        RWTexture2D<FfxUInt32>                    rw_reconstructed_previous_nearest_depth   : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH);
-    #endif
-    #if defined FSR2_BIND_UAV_DILATED_MOTION_VECTORS
-        RWTexture2D<FfxFloat32x2>                 rw_dilated_motion_vectors                 : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_DILATED_MOTION_VECTORS);
-    #endif
-    #if defined FSR2_BIND_UAV_DILATED_DEPTH
-        RWTexture2D<FfxFloat32>                   rw_dilatedDepth                           : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_DILATED_DEPTH);
-    #endif
-    #if defined FSR2_BIND_UAV_INTERNAL_UPSCALED
-        RWTexture2D<FfxFloat32x4>                 rw_internal_upscaled_color                : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_INTERNAL_UPSCALED);
-    #endif
-    #if defined FSR2_BIND_UAV_LOCK_STATUS
-        RWTexture2D<unorm FfxFloat32x2>           rw_lock_status                            : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_LOCK_STATUS);
-    #endif
-    #if defined FSR2_BIND_UAV_LOCK_INPUT_LUMA
-        RWTexture2D<FfxFloat32>                   rw_lock_input_luma                        : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_LOCK_INPUT_LUMA);
-    #endif
-    #if defined FSR2_BIND_UAV_NEW_LOCKS
-        RWTexture2D<unorm FfxFloat32>             rw_new_locks                              : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_NEW_LOCKS);
-    #endif
-    #if defined FSR2_BIND_UAV_PREPARED_INPUT_COLOR
-        RWTexture2D<FfxFloat32x4>                 rw_prepared_input_color                   : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_PREPARED_INPUT_COLOR);
-    #endif
-    #if defined FSR2_BIND_UAV_LUMA_HISTORY
-        RWTexture2D<FfxFloat32x4>                 rw_luma_history                           : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_LUMA_HISTORY);
-    #endif
-    #if defined FSR2_BIND_UAV_UPSCALED_OUTPUT
-        RWTexture2D<FfxFloat32x4>                 rw_upscaled_output                        : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_UPSCALED_OUTPUT);
-    #endif
-    #if defined FSR2_BIND_UAV_EXPOSURE_MIP_LUMA_CHANGE
-        globallycoherent RWTexture2D<FfxFloat32>  rw_img_mip_shading_change                 : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_EXPOSURE_MIP_LUMA_CHANGE);
-    #endif
-    #if defined FSR2_BIND_UAV_EXPOSURE_MIP_5
-        globallycoherent RWTexture2D<FfxFloat32>  rw_img_mip_5                              : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_EXPOSURE_MIP_5);
-    #endif
-    #if defined FSR2_BIND_UAV_DILATED_REACTIVE_MASKS
-        RWTexture2D<unorm FfxFloat32x2>           rw_dilated_reactive_masks                 : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_DILATED_REACTIVE_MASKS);
-    #endif
-    #if defined FSR2_BIND_UAV_EXPOSURE
-        RWTexture2D<FfxFloat32x2>                 rw_exposure                               : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_EXPOSURE);
-    #endif
-    #if defined FSR2_BIND_UAV_AUTO_EXPOSURE
-        RWTexture2D<FfxFloat32x2>                 rw_auto_exposure                          : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_AUTO_EXPOSURE);
-    #endif
-    #if defined FSR2_BIND_UAV_SPD_GLOBAL_ATOMIC
-        globallycoherent RWTexture2D<FfxUInt32>   rw_spd_global_atomic                      : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_SPD_GLOBAL_ATOMIC);
-    #endif
-
-    #if defined FSR2_BIND_UAV_AUTOREACTIVE
-        RWTexture2D<float>                        rw_output_autoreactive                    : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_AUTOREACTIVE);
-    #endif
-    #if defined FSR2_BIND_UAV_AUTOCOMPOSITION
-        RWTexture2D<float>                        rw_output_autocomposition                 : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_AUTOCOMPOSITION);
-    #endif
-    #if defined FSR2_BIND_UAV_PREV_PRE_ALPHA_COLOR
-        RWTexture2D<float3>                       rw_output_prev_color_pre_alpha            : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_PREV_PRE_ALPHA_COLOR);
-    #endif
-    #if defined FSR2_BIND_UAV_PREV_POST_ALPHA_COLOR
-        RWTexture2D<float3>                       rw_output_prev_color_post_alpha           : FFX_FSR2_DECLARE_UAV(FSR2_BIND_UAV_PREV_POST_ALPHA_COLOR);
-    #endif
-#endif // #if defined(FFX_INTERNAL)
-
-#if defined(FSR2_BIND_SRV_SCENE_LUMINANCE_MIPS) || defined(FFX_INTERNAL)
-FfxFloat32 LoadMipLuma(FfxUInt32x2 iPxPos, FfxUInt32 mipLevel)
-{
-    return r_imgMips.mips[mipLevel][iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_SCENE_LUMINANCE_MIPS) || defined(FFX_INTERNAL)
-FfxFloat32 SampleMipLuma(FfxFloat32x2 fUV, FfxUInt32 mipLevel)
-{
-    return r_imgMips.SampleLevel(s_LinearClamp, fUV, mipLevel);
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_INPUT_DEPTH) || defined(FFX_INTERNAL)
-FfxFloat32 LoadInputDepth(FfxUInt32x2 iPxPos)
-{
-    return r_input_depth[UNITY_FSR2_POS(iPxPos)];
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_INPUT_DEPTH) || defined(FFX_INTERNAL)
-FfxFloat32 SampleInputDepth(FfxFloat32x2 fUV)
-{
-    return r_input_depth.SampleLevel(s_LinearClamp, UNITY_FSR2_UV(fUV), 0).x;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_REACTIVE_MASK) || defined(FFX_INTERNAL)
-FfxFloat32 LoadReactiveMask(FfxUInt32x2 iPxPos)
-{
-    return r_reactive_mask[iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK) || defined(FFX_INTERNAL)
-FfxFloat32 LoadTransparencyAndCompositionMask(FfxUInt32x2 iPxPos)
-{
-    return r_transparency_and_composition_mask[iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_INPUT_COLOR) || defined(FFX_INTERNAL)
-FfxFloat32x3 LoadInputColor(FfxUInt32x2 iPxPos)
-{
-    return r_input_color_jittered[UNITY_FSR2_POS(iPxPos)].rgb;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_INPUT_COLOR) || defined(FFX_INTERNAL)
-FfxFloat32x3 SampleInputColor(FfxFloat32x2 fUV)
-{
-    return r_input_color_jittered.SampleLevel(s_LinearClamp, UNITY_FSR2_UV(fUV), 0).rgb;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_PREPARED_INPUT_COLOR) || defined(FFX_INTERNAL)
-FfxFloat32x3 LoadPreparedInputColor(FfxUInt32x2 iPxPos)
-{
-    return r_prepared_input_color[iPxPos].xyz;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_INPUT_MOTION_VECTORS) || defined(FFX_INTERNAL)
-FfxFloat32x2 LoadInputMotionVector(FfxUInt32x2 iPxDilatedMotionVectorPos)
-{
-    FfxFloat32x2 fSrcMotionVector = r_input_motion_vectors[UNITY_FSR2_POS(iPxDilatedMotionVectorPos)].xy;
-
-    FfxFloat32x2 fUvMotionVector = fSrcMotionVector * MotionVectorScale();
-
-#if FFX_FSR2_OPTION_JITTERED_MOTION_VECTORS
-    fUvMotionVector -= MotionVectorJitterCancellation();
-#endif
-
-    return fUvMotionVector;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_INTERNAL_UPSCALED) || defined(FFX_INTERNAL)
-FfxFloat32x4 LoadHistory(FfxUInt32x2 iPxHistory)
-{
-    return r_internal_upscaled_color[iPxHistory];
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_LUMA_HISTORY) || defined(FFX_INTERNAL)
-void StoreLumaHistory(FfxUInt32x2 iPxPos, FfxFloat32x4 fLumaHistory)
-{
-    rw_luma_history[iPxPos] = fLumaHistory;
-}
-
-FfxFloat32x4 LoadRwLumaHistory(FFX_MIN16_I2 iPxPos)
-{
-    return rw_luma_history[iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_LUMA_HISTORY) || defined(FFX_INTERNAL)
-FfxFloat32x4 SampleLumaHistory(FfxFloat32x2 fUV)
-{
-    return r_luma_history.SampleLevel(s_LinearClamp, fUV, 0);
-}
-#endif
-
-#if defined(FFX_INTERNAL)
-FfxFloat32x4 SampleDebug(FfxFloat32x2 fUV)
-{
-    return r_debug_out.SampleLevel(s_LinearClamp, fUV, 0).w;
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_INTERNAL_UPSCALED) || defined(FFX_INTERNAL)
-void StoreReprojectedHistory(FfxUInt32x2 iPxHistory, FfxFloat32x4 fHistory)
-{
-    rw_internal_upscaled_color[iPxHistory] = fHistory;
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_INTERNAL_UPSCALED) || defined(FFX_INTERNAL)
-void StoreInternalColorAndWeight(FfxUInt32x2 iPxPos, FfxFloat32x4 fColorAndWeight)
-{
-    rw_internal_upscaled_color[iPxPos] = fColorAndWeight;
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_UPSCALED_OUTPUT) || defined(FFX_INTERNAL)
-void StoreUpscaledOutput(FfxUInt32x2 iPxPos, FfxFloat32x3 fColor)
-{
-    rw_upscaled_output[iPxPos] = FfxFloat32x4(fColor, 1.f);
-}
-#endif
-
-//LOCK_LIFETIME_REMAINING == 0
-//Should make LockInitialLifetime() return a const 1.0f later
-#if defined(FSR2_BIND_SRV_LOCK_STATUS) || defined(FFX_INTERNAL)
-FfxFloat32x2 LoadLockStatus(FfxUInt32x2 iPxPos)
-{
-    return r_lock_status[iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_LOCK_STATUS) || defined(FFX_INTERNAL)
-void StoreLockStatus(FfxUInt32x2 iPxPos, FfxFloat32x2 fLockStatus)
-{
-    rw_lock_status[iPxPos] = fLockStatus;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_LOCK_INPUT_LUMA) || defined(FFX_INTERNAL)
-FfxFloat32 LoadLockInputLuma(FfxUInt32x2 iPxPos)
-{
-    return r_lock_input_luma[iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_LOCK_INPUT_LUMA) || defined(FFX_INTERNAL)
-void StoreLockInputLuma(FfxUInt32x2 iPxPos, FfxFloat32 fLuma)
-{
-    rw_lock_input_luma[iPxPos] = fLuma;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_NEW_LOCKS) || defined(FFX_INTERNAL)
-FfxFloat32 LoadNewLocks(FfxUInt32x2 iPxPos)
-{
-    return r_new_locks[iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_NEW_LOCKS) || defined(FFX_INTERNAL)
-FfxFloat32 LoadRwNewLocks(FfxUInt32x2 iPxPos)
-{
-    return rw_new_locks[iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_NEW_LOCKS) || defined(FFX_INTERNAL)
-void StoreNewLocks(FfxUInt32x2 iPxPos, FfxFloat32 newLock)
-{
-    rw_new_locks[iPxPos] = newLock;
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_PREPARED_INPUT_COLOR) || defined(FFX_INTERNAL)
-void StorePreparedInputColor(FFX_PARAMETER_IN FfxUInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x4 fTonemapped)
-{
-    rw_prepared_input_color[iPxPos] = fTonemapped;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_PREPARED_INPUT_COLOR) || defined(FFX_INTERNAL)
-FfxFloat32 SampleDepthClip(FfxFloat32x2 fUV)
-{
-    return r_prepared_input_color.SampleLevel(s_LinearClamp, fUV, 0).w;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_LOCK_STATUS) || defined(FFX_INTERNAL)
-FfxFloat32x2 SampleLockStatus(FfxFloat32x2 fUV)
-{
-    FfxFloat32x2 fLockStatus = r_lock_status.SampleLevel(s_LinearClamp, fUV, 0);
-    return fLockStatus;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH) || defined(FFX_INTERNAL)
-FfxFloat32 LoadReconstructedPrevDepth(FfxUInt32x2 iPxPos)
-{
-    return asfloat(r_reconstructed_previous_nearest_depth[iPxPos]);
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH) || defined(FFX_INTERNAL)
-void StoreReconstructedDepth(FfxUInt32x2 iPxSample, FfxFloat32 fDepth)
-{
-    FfxUInt32 uDepth = asuint(fDepth);
-
-    #if FFX_FSR2_OPTION_INVERTED_DEPTH
-        InterlockedMax(rw_reconstructed_previous_nearest_depth[iPxSample], uDepth);
-    #else
-        InterlockedMin(rw_reconstructed_previous_nearest_depth[iPxSample], uDepth); // min for standard, max for inverted depth
-    #endif
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH) || defined(FFX_INTERNAL)
-void SetReconstructedDepth(FfxUInt32x2 iPxSample, const FfxUInt32 uValue)
-{
-    rw_reconstructed_previous_nearest_depth[iPxSample] = uValue;
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_DILATED_DEPTH) || defined(FFX_INTERNAL)
-void StoreDilatedDepth(FFX_PARAMETER_IN FfxUInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32 fDepth)
-{
-    rw_dilatedDepth[iPxPos] = fDepth;
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_DILATED_MOTION_VECTORS) || defined(FFX_INTERNAL)
-void StoreDilatedMotionVector(FFX_PARAMETER_IN FfxUInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 fMotionVector)
-{
-    rw_dilated_motion_vectors[iPxPos] = fMotionVector;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_DILATED_MOTION_VECTORS) || defined(FFX_INTERNAL)
-FfxFloat32x2 LoadDilatedMotionVector(FfxUInt32x2 iPxInput)
-{
-    return r_dilated_motion_vectors[iPxInput].xy;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_PREVIOUS_DILATED_MOTION_VECTORS) || defined(FFX_INTERNAL)
-FfxFloat32x2 LoadPreviousDilatedMotionVector(FfxUInt32x2 iPxInput)
-{
-    return r_previous_dilated_motion_vectors[iPxInput].xy;
-}
-
-FfxFloat32x2 SamplePreviousDilatedMotionVector(FfxFloat32x2 uv)
-{
-    return r_previous_dilated_motion_vectors.SampleLevel(s_LinearClamp, uv, 0).xy;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_DILATED_DEPTH) || defined(FFX_INTERNAL)
-FfxFloat32 LoadDilatedDepth(FfxUInt32x2 iPxInput)
-{
-    return r_dilatedDepth[iPxInput];
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_INPUT_EXPOSURE) || defined(FFX_INTERNAL)
-FfxFloat32 Exposure()
-{
-    FfxFloat32 exposure = r_input_exposure[FfxUInt32x2(0, 0)].x;
-
-    if (exposure == 0.0f) {
-        exposure = 1.0f;
-    }
-
-    return exposure;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_AUTO_EXPOSURE) || defined(FFX_INTERNAL)
-FfxFloat32 AutoExposure()
-{
-    FfxFloat32 exposure = r_auto_exposure[FfxUInt32x2(0, 0)].x;
-
-    if (exposure == 0.0f) {
-        exposure = 1.0f;
-    }
-
-    return exposure;
-}
-#endif
-
-FfxFloat32 SampleLanczos2Weight(FfxFloat32 x)
-{
-#if defined(FSR2_BIND_SRV_LANCZOS_LUT) || defined(FFX_INTERNAL)
-    return r_lanczos_lut.SampleLevel(s_LinearClamp, FfxFloat32x2(x / 2, 0.5f), 0);
-#else
-    return 0.f;
-#endif
-}
-
-#if defined(FSR2_BIND_SRV_UPSCALE_MAXIMUM_BIAS_LUT) || defined(FFX_INTERNAL)
-FfxFloat32 SampleUpsampleMaximumBias(FfxFloat32x2 uv)
-{
-    // Stored as a SNORM, so make sure to multiply by 2 to retrieve the actual expected range.
-    return FfxFloat32(2.0) * r_upsample_maximum_bias_lut.SampleLevel(s_LinearClamp, abs(uv) * 2.0, 0);
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_DILATED_REACTIVE_MASKS) || defined(FFX_INTERNAL)
-FfxFloat32x2 SampleDilatedReactiveMasks(FfxFloat32x2 fUV)
-{
-	return r_dilated_reactive_masks.SampleLevel(s_LinearClamp, fUV, 0);
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_DILATED_REACTIVE_MASKS) || defined(FFX_INTERNAL)
-FfxFloat32x2 LoadDilatedReactiveMasks(FFX_PARAMETER_IN FfxUInt32x2 iPxPos)
-{
-    return r_dilated_reactive_masks[iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_DILATED_REACTIVE_MASKS) || defined(FFX_INTERNAL)
-void StoreDilatedReactiveMasks(FFX_PARAMETER_IN FfxUInt32x2 iPxPos, FFX_PARAMETER_IN FfxFloat32x2 fDilatedReactiveMasks)
-{
-    rw_dilated_reactive_masks[iPxPos] = fDilatedReactiveMasks;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_INPUT_OPAQUE_ONLY) || defined(FFX_INTERNAL)
-FfxFloat32x3 LoadOpaqueOnly(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos)
-{
-    return r_input_opaque_only[UNITY_FSR2_POS(iPxPos)].xyz;
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_PREV_PRE_ALPHA_COLOR) || defined(FFX_INTERNAL)
-FfxFloat32x3 LoadPrevPreAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos)
-{
-    return r_input_prev_color_pre_alpha[iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_SRV_PREV_POST_ALPHA_COLOR) || defined(FFX_INTERNAL)
-FfxFloat32x3 LoadPrevPostAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos)
-{
-    return r_input_prev_color_post_alpha[iPxPos];
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_AUTOREACTIVE) || defined(FFX_INTERNAL)
-#if defined(FSR2_BIND_UAV_AUTOCOMPOSITION) || defined(FFX_INTERNAL)
-void StoreAutoReactive(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F2 fReactive)
-{
-    rw_output_autoreactive[iPxPos] = fReactive.x;
-
-    rw_output_autocomposition[iPxPos] = fReactive.y;
-}
-#endif
-#endif
-
-#if defined(FSR2_BIND_UAV_PREV_PRE_ALPHA_COLOR) || defined(FFX_INTERNAL)
-void StorePrevPreAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F3 color)
-{
-    rw_output_prev_color_pre_alpha[iPxPos] = color;
-
-}
-#endif
-
-#if defined(FSR2_BIND_UAV_PREV_POST_ALPHA_COLOR) || defined(FFX_INTERNAL)
-void StorePrevPostAlpha(FFX_PARAMETER_IN FFX_MIN16_I2 iPxPos, FFX_PARAMETER_IN FFX_MIN16_F3 color)
-{
-    rw_output_prev_color_post_alpha[iPxPos] = color;
-}
-#endif
-
-#endif // #if defined(FFX_GPU)

Assets/Resources/FSR2/shaders/ffx_fsr2_callbacks_hlsl.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: eb121968296f9ba44b35d7e18d2b79df
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_common.h

@@ -1,565 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#if !defined(FFX_FSR2_COMMON_H)
-#define FFX_FSR2_COMMON_H
-
-#if defined(FFX_CPU) || defined(FFX_GPU)
-//Locks
-#define LOCK_LIFETIME_REMAINING 0
-#define LOCK_TEMPORAL_LUMA 1
-#endif // #if defined(FFX_CPU) || defined(FFX_GPU)
-
-#if defined(FFX_GPU)
-FFX_STATIC const FfxFloat32 FSR2_FP16_MIN = 6.10e-05f;
-FFX_STATIC const FfxFloat32 FSR2_FP16_MAX = 65504.0f;
-FFX_STATIC const FfxFloat32 FSR2_EPSILON = 1e-03f;
-FFX_STATIC const FfxFloat32 FSR2_TONEMAP_EPSILON = 1.0f / FSR2_FP16_MAX;
-FFX_STATIC const FfxFloat32 FSR2_FLT_MAX = 3.402823466e+38f;
-FFX_STATIC const FfxFloat32 FSR2_FLT_MIN = 1.175494351e-38f;
-
-// treat vector truncation warnings as errors
-#pragma warning(error: 3206)
-
-// suppress warnings
-#pragma warning(disable: 3205)  // conversion from larger type to smaller
-#pragma warning(disable: 3571)  // in ffxPow(f, e), f could be negative
-
-// Reconstructed depth usage
-FFX_STATIC const FfxFloat32 fReconstructedDepthBilinearWeightThreshold = 0.01f;
-
-// Accumulation
-FFX_STATIC const FfxFloat32 fUpsampleLanczosWeightScale = 1.0f / 12.0f;
-FFX_STATIC const FfxFloat32 fMaxAccumulationLanczosWeight = 1.0f;
-FFX_STATIC const FfxFloat32 fAverageLanczosWeightPerFrame = 0.74f * fUpsampleLanczosWeightScale; // Average lanczos weight for jitter accumulated samples
-FFX_STATIC const FfxFloat32 fAccumulationMaxOnMotion = 3.0f * fUpsampleLanczosWeightScale;
-
-// Auto exposure
-FFX_STATIC const FfxFloat32 resetAutoExposureAverageSmoothing = 1e8f;
-
-struct AccumulationPassCommonParams
-{
-    FfxInt32x2 iPxHrPos;
-    FfxFloat32x2 fHrUv;
-    FfxFloat32x2 fLrUv_HwSampler;
-    FfxFloat32x2 fMotionVector;
-    FfxFloat32x2 fReprojectedHrUv;
-    FfxFloat32 fHrVelocity;
-    FfxFloat32 fDepthClipFactor;
-    FfxFloat32 fDilatedReactiveFactor;
-    FfxFloat32 fAccumulationMask;
-
-    FfxBoolean bIsResetFrame;
-    FfxBoolean bIsExistingSample;
-    FfxBoolean bIsNewSample;
-};
-
-struct LockState
-{
-    FfxBoolean NewLock; //Set for both unique new and re-locked new
-    FfxBoolean WasLockedPrevFrame; //Set to identify if the pixel was already locked (relock)
-};
-
-void InitializeNewLockSample(FFX_PARAMETER_OUT FfxFloat32x2 fLockStatus)
-{
-    fLockStatus = FfxFloat32x2(0, 0);
-}
-
-#if FFX_HALF
-void InitializeNewLockSample(FFX_PARAMETER_OUT FFX_MIN16_F2 fLockStatus)
-{
-    fLockStatus = FFX_MIN16_F2(0, 0);
-}
-#endif
-
-
-void KillLock(FFX_PARAMETER_INOUT FfxFloat32x2 fLockStatus)
-{
-    fLockStatus[LOCK_LIFETIME_REMAINING] = 0;
-}
-
-#if FFX_HALF
-void KillLock(FFX_PARAMETER_INOUT FFX_MIN16_F2 fLockStatus)
-{
-    fLockStatus[LOCK_LIFETIME_REMAINING] = FFX_MIN16_F(0);
-}
-#endif
-
-struct RectificationBox
-{
-    FfxFloat32x3 boxCenter;
-    FfxFloat32x3 boxVec;
-    FfxFloat32x3 aabbMin;
-    FfxFloat32x3 aabbMax;
-    FfxFloat32 fBoxCenterWeight;
-};
-#if FFX_HALF
-struct RectificationBoxMin16
-{
-    FFX_MIN16_F3 boxCenter;
-    FFX_MIN16_F3 boxVec;
-    FFX_MIN16_F3 aabbMin;
-    FFX_MIN16_F3 aabbMax;
-    FFX_MIN16_F fBoxCenterWeight;
-};
-#endif
-
-void RectificationBoxReset(FFX_PARAMETER_INOUT RectificationBox rectificationBox)
-{
-    rectificationBox.fBoxCenterWeight = FfxFloat32(0);
-
-    rectificationBox.boxCenter = FfxFloat32x3(0, 0, 0);
-    rectificationBox.boxVec = FfxFloat32x3(0, 0, 0);
-    rectificationBox.aabbMin = FfxFloat32x3(FSR2_FLT_MAX, FSR2_FLT_MAX, FSR2_FLT_MAX);
-    rectificationBox.aabbMax = -FfxFloat32x3(FSR2_FLT_MAX, FSR2_FLT_MAX, FSR2_FLT_MAX);
-}
-#if FFX_HALF
-void RectificationBoxReset(FFX_PARAMETER_INOUT RectificationBoxMin16 rectificationBox)
-{
-    rectificationBox.fBoxCenterWeight = FFX_MIN16_F(0);
-
-    rectificationBox.boxCenter = FFX_MIN16_F3(0, 0, 0);
-    rectificationBox.boxVec = FFX_MIN16_F3(0, 0, 0);
-    rectificationBox.aabbMin = FFX_MIN16_F3(FSR2_FP16_MAX, FSR2_FP16_MAX, FSR2_FP16_MAX);
-    rectificationBox.aabbMax = -FFX_MIN16_F3(FSR2_FP16_MAX, FSR2_FP16_MAX, FSR2_FP16_MAX);
-}
-#endif
-
-void RectificationBoxAddInitialSample(FFX_PARAMETER_INOUT RectificationBox rectificationBox, const FfxFloat32x3 colorSample, const FfxFloat32 fSampleWeight)
-{
-    rectificationBox.aabbMin = colorSample;
-    rectificationBox.aabbMax = colorSample;
-
-    FfxFloat32x3 weightedSample = colorSample * fSampleWeight;
-    rectificationBox.boxCenter = weightedSample;
-    rectificationBox.boxVec = colorSample * weightedSample;
-    rectificationBox.fBoxCenterWeight = fSampleWeight;
-}
-
-void RectificationBoxAddSample(FfxBoolean bInitialSample, FFX_PARAMETER_INOUT RectificationBox rectificationBox, const FfxFloat32x3 colorSample, const FfxFloat32 fSampleWeight)
-{
-    if (bInitialSample) {
-        RectificationBoxAddInitialSample(rectificationBox, colorSample, fSampleWeight);
-    } else {
-        rectificationBox.aabbMin = ffxMin(rectificationBox.aabbMin, colorSample);
-        rectificationBox.aabbMax = ffxMax(rectificationBox.aabbMax, colorSample);
-
-        FfxFloat32x3 weightedSample = colorSample * fSampleWeight;
-        rectificationBox.boxCenter += weightedSample;
-        rectificationBox.boxVec += colorSample * weightedSample;
-        rectificationBox.fBoxCenterWeight += fSampleWeight;
-    }
-}
-#if FFX_HALF
-void RectificationBoxAddInitialSample(FFX_PARAMETER_INOUT RectificationBoxMin16 rectificationBox, const FFX_MIN16_F3 colorSample, const FFX_MIN16_F fSampleWeight)
-{
-    rectificationBox.aabbMin = colorSample;
-    rectificationBox.aabbMax = colorSample;
-
-    FFX_MIN16_F3 weightedSample = colorSample * fSampleWeight;
-    rectificationBox.boxCenter = weightedSample;
-    rectificationBox.boxVec = colorSample * weightedSample;
-    rectificationBox.fBoxCenterWeight = fSampleWeight;
-}
-
-void RectificationBoxAddSample(FfxBoolean bInitialSample, FFX_PARAMETER_INOUT RectificationBoxMin16 rectificationBox, const FFX_MIN16_F3 colorSample, const FFX_MIN16_F fSampleWeight)
-{
-    if (bInitialSample) {
-        RectificationBoxAddInitialSample(rectificationBox, colorSample, fSampleWeight);
-    } else {
-        rectificationBox.aabbMin = ffxMin(rectificationBox.aabbMin, colorSample);
-        rectificationBox.aabbMax = ffxMax(rectificationBox.aabbMax, colorSample);
-
-        FFX_MIN16_F3 weightedSample = colorSample * fSampleWeight;
-        rectificationBox.boxCenter += weightedSample;
-        rectificationBox.boxVec += colorSample * weightedSample;
-        rectificationBox.fBoxCenterWeight += fSampleWeight;
-    }
-}
-#endif
-
-void RectificationBoxComputeVarianceBoxData(FFX_PARAMETER_INOUT RectificationBox rectificationBox)
-{
-    rectificationBox.fBoxCenterWeight = (abs(rectificationBox.fBoxCenterWeight) > FfxFloat32(FSR2_EPSILON) ? rectificationBox.fBoxCenterWeight : FfxFloat32(1.f));
-    rectificationBox.boxCenter /= rectificationBox.fBoxCenterWeight;
-    rectificationBox.boxVec /= rectificationBox.fBoxCenterWeight;
-    FfxFloat32x3 stdDev = sqrt(abs(rectificationBox.boxVec - rectificationBox.boxCenter * rectificationBox.boxCenter));
-    rectificationBox.boxVec = stdDev;
-}
-#if FFX_HALF
-void RectificationBoxComputeVarianceBoxData(FFX_PARAMETER_INOUT RectificationBoxMin16 rectificationBox)
-{
-    rectificationBox.fBoxCenterWeight = (abs(rectificationBox.fBoxCenterWeight) > FFX_MIN16_F(FSR2_EPSILON) ? rectificationBox.fBoxCenterWeight : FFX_MIN16_F(1.f));
-    rectificationBox.boxCenter /= rectificationBox.fBoxCenterWeight;
-    rectificationBox.boxVec /= rectificationBox.fBoxCenterWeight;
-    FFX_MIN16_F3 stdDev = sqrt(abs(rectificationBox.boxVec - rectificationBox.boxCenter * rectificationBox.boxCenter));
-    rectificationBox.boxVec = stdDev;
-}
-#endif
-
-FfxFloat32x3 SafeRcp3(FfxFloat32x3 v)
-{
-    return (all(FFX_NOT_EQUAL(v, FfxFloat32x3(0, 0, 0)))) ? (FfxFloat32x3(1, 1, 1) / v) : FfxFloat32x3(0, 0, 0);
-}
-#if FFX_HALF
-FFX_MIN16_F3 SafeRcp3(FFX_MIN16_F3 v)
-{
-    return (all(FFX_NOT_EQUAL(v, FFX_MIN16_F3(0, 0, 0)))) ? (FFX_MIN16_F3(1, 1, 1) / v) : FFX_MIN16_F3(0, 0, 0);
-}
-#endif
-
-FfxFloat32 MinDividedByMax(const FfxFloat32 v0, const FfxFloat32 v1)
-{
-    const FfxFloat32 m = ffxMax(v0, v1);
-    return m != 0 ? ffxMin(v0, v1) / m : 0;
-}
-
-#if FFX_HALF
-FFX_MIN16_F MinDividedByMax(const FFX_MIN16_F v0, const FFX_MIN16_F v1)
-{
-    const FFX_MIN16_F m = ffxMax(v0, v1);
-    return m != FFX_MIN16_F(0) ? ffxMin(v0, v1) / m : FFX_MIN16_F(0);
-}
-#endif
-
-FfxFloat32x3 YCoCgToRGB(FfxFloat32x3 fYCoCg)
-{
-    FfxFloat32x3 fRgb;
-
-    fRgb = FfxFloat32x3(
-        fYCoCg.x + fYCoCg.y - fYCoCg.z,
-        fYCoCg.x + fYCoCg.z,
-        fYCoCg.x - fYCoCg.y - fYCoCg.z);
-
-    return fRgb;
-}
-#if FFX_HALF
-FFX_MIN16_F3 YCoCgToRGB(FFX_MIN16_F3 fYCoCg)
-{
-    FFX_MIN16_F3 fRgb;
-
-    fRgb = FFX_MIN16_F3(
-        fYCoCg.x + fYCoCg.y - fYCoCg.z,
-        fYCoCg.x + fYCoCg.z,
-        fYCoCg.x - fYCoCg.y - fYCoCg.z);
-
-    return fRgb;
-}
-#endif
-
-FfxFloat32x3 RGBToYCoCg(FfxFloat32x3 fRgb)
-{
-    FfxFloat32x3 fYCoCg;
-
-    fYCoCg = FfxFloat32x3(
-        0.25f * fRgb.r + 0.5f * fRgb.g + 0.25f * fRgb.b,
-        0.5f * fRgb.r - 0.5f * fRgb.b,
-        -0.25f * fRgb.r + 0.5f * fRgb.g - 0.25f * fRgb.b);
-
-    return fYCoCg;
-}
-#if FFX_HALF
-FFX_MIN16_F3 RGBToYCoCg(FFX_MIN16_F3 fRgb)
-{
-    FFX_MIN16_F3 fYCoCg;
-
-    fYCoCg = FFX_MIN16_F3(
-        0.25 * fRgb.r + 0.5 * fRgb.g + 0.25 * fRgb.b,
-        0.5 * fRgb.r - 0.5 * fRgb.b,
-        -0.25 * fRgb.r + 0.5 * fRgb.g - 0.25 * fRgb.b);
-
-    return fYCoCg;
-}
-#endif
-
-FfxFloat32 RGBToLuma(FfxFloat32x3 fLinearRgb)
-{
-    return dot(fLinearRgb, FfxFloat32x3(0.2126f, 0.7152f, 0.0722f));
-}
-#if FFX_HALF
-FFX_MIN16_F RGBToLuma(FFX_MIN16_F3 fLinearRgb)
-{
-    return dot(fLinearRgb, FFX_MIN16_F3(0.2126f, 0.7152f, 0.0722f));
-}
-#endif
-
-FfxFloat32 RGBToPerceivedLuma(FfxFloat32x3 fLinearRgb)
-{
-    FfxFloat32 fLuminance = RGBToLuma(fLinearRgb);
-
-    FfxFloat32 fPercievedLuminance = 0;
-    if (fLuminance <= 216.0f / 24389.0f) {
-        fPercievedLuminance = fLuminance * (24389.0f / 27.0f);
-    }
-    else {
-        fPercievedLuminance = ffxPow(fLuminance, 1.0f / 3.0f) * 116.0f - 16.0f;
-    }
-
-    return fPercievedLuminance * 0.01f;
-}
-#if FFX_HALF
-FFX_MIN16_F RGBToPerceivedLuma(FFX_MIN16_F3 fLinearRgb)
-{
-    FFX_MIN16_F fLuminance = RGBToLuma(fLinearRgb);
-
-    FFX_MIN16_F fPercievedLuminance = FFX_MIN16_F(0);
-    if (fLuminance <= FFX_MIN16_F(216.0f / 24389.0f)) {
-        fPercievedLuminance = fLuminance * FFX_MIN16_F(24389.0f / 27.0f);
-    }
-    else {
-        fPercievedLuminance = ffxPow(fLuminance, FFX_MIN16_F(1.0f / 3.0f)) * FFX_MIN16_F(116.0f) - FFX_MIN16_F(16.0f);
-    }
-
-    return fPercievedLuminance * FFX_MIN16_F(0.01f);
-}
-#endif
-
-FfxFloat32x3 Tonemap(FfxFloat32x3 fRgb)
-{
-    return fRgb / (ffxMax(ffxMax(0.f, fRgb.r), ffxMax(fRgb.g, fRgb.b)) + 1.f).xxx;
-}
-
-FfxFloat32x3 InverseTonemap(FfxFloat32x3 fRgb)
-{
-    return fRgb / ffxMax(FSR2_TONEMAP_EPSILON, 1.f - ffxMax(fRgb.r, ffxMax(fRgb.g, fRgb.b))).xxx;
-}
-
-#if FFX_HALF
-FFX_MIN16_F3 Tonemap(FFX_MIN16_F3 fRgb)
-{
-    return fRgb / (ffxMax(ffxMax(FFX_MIN16_F(0.f), fRgb.r), ffxMax(fRgb.g, fRgb.b)) + FFX_MIN16_F(1.f)).xxx;
-}
-
-FFX_MIN16_F3 InverseTonemap(FFX_MIN16_F3 fRgb)
-{
-    return fRgb / ffxMax(FFX_MIN16_F(FSR2_TONEMAP_EPSILON), FFX_MIN16_F(1.f) - ffxMax(fRgb.r, ffxMax(fRgb.g, fRgb.b))).xxx;
-}
-#endif
-
-FfxInt32x2 ClampLoad(FfxInt32x2 iPxSample, FfxInt32x2 iPxOffset, FfxInt32x2 iTextureSize)
-{
-    FfxInt32x2 result = iPxSample + iPxOffset;
-    result.x = (iPxOffset.x < 0) ? ffxMax(result.x, 0) : result.x;
-    result.x = (iPxOffset.x > 0) ? ffxMin(result.x, iTextureSize.x - 1) : result.x;
-    result.y = (iPxOffset.y < 0) ? ffxMax(result.y, 0) : result.y;
-    result.y = (iPxOffset.y > 0) ? ffxMin(result.y, iTextureSize.y - 1) : result.y;
-    return result;
-
-    // return ffxMed3(iPxSample + iPxOffset, FfxInt32x2(0, 0), iTextureSize - FfxInt32x2(1, 1));
-}
-#if FFX_HALF
-FFX_MIN16_I2 ClampLoad(FFX_MIN16_I2 iPxSample, FFX_MIN16_I2 iPxOffset, FFX_MIN16_I2 iTextureSize)
-{
-    FFX_MIN16_I2 result = iPxSample + iPxOffset;
-    result.x = (iPxOffset.x < 0) ? ffxMax(result.x, FFX_MIN16_I(0)) : result.x;
-    result.x = (iPxOffset.x > 0) ? ffxMin(result.x, iTextureSize.x - FFX_MIN16_I(1)) : result.x;
-    result.y = (iPxOffset.y < 0) ? ffxMax(result.y, FFX_MIN16_I(0)) : result.y;
-    result.y = (iPxOffset.y > 0) ? ffxMin(result.y, iTextureSize.y - FFX_MIN16_I(1)) : result.y;
-    return result;
-
-    // return ffxMed3Half(iPxSample + iPxOffset, FFX_MIN16_I2(0, 0), iTextureSize - FFX_MIN16_I2(1, 1));
-}
-#endif
-
-FfxFloat32x2 ClampUv(FfxFloat32x2 fUv, FfxInt32x2 iTextureSize, FfxInt32x2 iResourceSize)
-{
-    const FfxFloat32x2 fSampleLocation = fUv * iTextureSize;
-    const FfxFloat32x2 fClampedLocation = ffxMax(FfxFloat32x2(0.5f, 0.5f), ffxMin(fSampleLocation, FfxFloat32x2(iTextureSize) - FfxFloat32x2(0.5f, 0.5f)));
-    const FfxFloat32x2 fClampedUv = fClampedLocation / FfxFloat32x2(iResourceSize);
-
-    return fClampedUv;
-}
-
-FfxBoolean IsOnScreen(FfxInt32x2 pos, FfxInt32x2 size)
-{
-    return all(FFX_LESS_THAN(FfxUInt32x2(pos), FfxUInt32x2(size)));
-}
-#if FFX_HALF
-FfxBoolean IsOnScreen(FFX_MIN16_I2 pos, FFX_MIN16_I2 size)
-{
-    return all(FFX_LESS_THAN(FFX_MIN16_U2(pos), FFX_MIN16_U2(size)));
-}
-#endif
-
-FfxFloat32 ComputeAutoExposureFromLavg(FfxFloat32 Lavg)
-{
-    Lavg = exp(Lavg);
-
-    const FfxFloat32 S = 100.0f; //ISO arithmetic speed
-    const FfxFloat32 K = 12.5f;
-    FfxFloat32 ExposureISO100 = log2((Lavg * S) / K);
-
-    const FfxFloat32 q = 0.65f;
-    FfxFloat32 Lmax = (78.0f / (q * S)) * ffxPow(2.0f, ExposureISO100);
-
-    return 1 / Lmax;
-}
-#if FFX_HALF
-FFX_MIN16_F ComputeAutoExposureFromLavg(FFX_MIN16_F Lavg)
-{
-    Lavg = exp(Lavg);
-
-    const FFX_MIN16_F S = FFX_MIN16_F(100.0f); //ISO arithmetic speed
-    const FFX_MIN16_F K = FFX_MIN16_F(12.5f);
-    const FFX_MIN16_F ExposureISO100 = log2((Lavg * S) / K);
-
-    const FFX_MIN16_F q = FFX_MIN16_F(0.65f);
-    const FFX_MIN16_F Lmax = (FFX_MIN16_F(78.0f) / (q * S)) * ffxPow(FFX_MIN16_F(2.0f), ExposureISO100);
-
-    return FFX_MIN16_F(1) / Lmax;
-}
-#endif
-
-FfxInt32x2 ComputeHrPosFromLrPos(FfxInt32x2 iPxLrPos)
-{
-    FfxFloat32x2 fSrcJitteredPos = FfxFloat32x2(iPxLrPos) + 0.5f - Jitter();
-    FfxFloat32x2 fLrPosInHr = (fSrcJitteredPos / RenderSize()) * DisplaySize();
-    FfxInt32x2 iPxHrPos = FfxInt32x2(floor(fLrPosInHr));
-    return iPxHrPos;
-}
-#if FFX_HALF
-FFX_MIN16_I2 ComputeHrPosFromLrPos(FFX_MIN16_I2 iPxLrPos)
-{
-    FFX_MIN16_F2 fSrcJitteredPos = FFX_MIN16_F2(iPxLrPos) + FFX_MIN16_F(0.5f) - FFX_MIN16_F2(Jitter());
-    FFX_MIN16_F2 fLrPosInHr = (fSrcJitteredPos / FFX_MIN16_F2(RenderSize())) * FFX_MIN16_F2(DisplaySize());
-    FFX_MIN16_I2 iPxHrPos = FFX_MIN16_I2(floor(fLrPosInHr));
-    return iPxHrPos;
-}
-#endif
-
-FfxFloat32x2 ComputeNdc(FfxFloat32x2 fPxPos, FfxInt32x2 iSize)
-{
-    return fPxPos / FfxFloat32x2(iSize) * FfxFloat32x2(2.0f, -2.0f) + FfxFloat32x2(-1.0f, 1.0f);
-}
-
-FfxFloat32 GetViewSpaceDepth(FfxFloat32 fDeviceDepth)
-{
-    const FfxFloat32x4 fDeviceToViewDepth = DeviceToViewSpaceTransformFactors();
-
-    // fDeviceToViewDepth details found in ffx_fsr2.cpp
-    return (fDeviceToViewDepth[1] / (fDeviceDepth - fDeviceToViewDepth[0]));
-}
-
-FfxFloat32 GetViewSpaceDepthInMeters(FfxFloat32 fDeviceDepth)
-{
-    return GetViewSpaceDepth(fDeviceDepth) * ViewSpaceToMetersFactor();
-}
-
-FfxFloat32x3 GetViewSpacePosition(FfxInt32x2 iViewportPos, FfxInt32x2 iViewportSize, FfxFloat32 fDeviceDepth)
-{
-    const FfxFloat32x4 fDeviceToViewDepth = DeviceToViewSpaceTransformFactors();
-
-    const FfxFloat32 Z = GetViewSpaceDepth(fDeviceDepth);
-
-    const FfxFloat32x2 fNdcPos = ComputeNdc(iViewportPos, iViewportSize);
-    const FfxFloat32 X = fDeviceToViewDepth[2] * fNdcPos.x * Z;
-    const FfxFloat32 Y = fDeviceToViewDepth[3] * fNdcPos.y * Z;
-
-    return FfxFloat32x3(X, Y, Z);
-}
-
-FfxFloat32x3 GetViewSpacePositionInMeters(FfxInt32x2 iViewportPos, FfxInt32x2 iViewportSize, FfxFloat32 fDeviceDepth)
-{
-    return GetViewSpacePosition(iViewportPos, iViewportSize, fDeviceDepth) * ViewSpaceToMetersFactor();
-}
-
-FfxFloat32 GetMaxDistanceInMeters()
-{
-#if FFX_FSR2_OPTION_INVERTED_DEPTH
-    return GetViewSpaceDepth(0.0f) * ViewSpaceToMetersFactor();
-#else
-    return GetViewSpaceDepth(1.0f) * ViewSpaceToMetersFactor();
-#endif
-}
-
-FfxFloat32x3 PrepareRgb(FfxFloat32x3 fRgb, FfxFloat32 fExposure, FfxFloat32 fPreExposure)
-{
-    fRgb /= fPreExposure;
-    fRgb *= fExposure;
-
-    fRgb = clamp(fRgb, 0.0f, FSR2_FP16_MAX);
-
-    return fRgb;
-}
-
-FfxFloat32x3 UnprepareRgb(FfxFloat32x3 fRgb, FfxFloat32 fExposure)
-{
-    fRgb /= fExposure;
-    fRgb *= PreExposure();
-
-    return fRgb;
-}
-
-
-struct BilinearSamplingData
-{
-    FfxInt32x2 iOffsets[4];
-    FfxFloat32 fWeights[4];
-    FfxInt32x2 iBasePos;
-};
-
-BilinearSamplingData GetBilinearSamplingData(FfxFloat32x2 fUv, FfxInt32x2 iSize)
-{
-    BilinearSamplingData data;
-
-    FfxFloat32x2 fPxSample = (fUv * iSize) - FfxFloat32x2(0.5f, 0.5f);
-    data.iBasePos = FfxInt32x2(floor(fPxSample));
-    FfxFloat32x2 fPxFrac = ffxFract(fPxSample);
-
-    data.iOffsets[0] = FfxInt32x2(0, 0);
-    data.iOffsets[1] = FfxInt32x2(1, 0);
-    data.iOffsets[2] = FfxInt32x2(0, 1);
-    data.iOffsets[3] = FfxInt32x2(1, 1);
-
-    data.fWeights[0] = (1 - fPxFrac.x) * (1 - fPxFrac.y);
-    data.fWeights[1] = (fPxFrac.x) * (1 - fPxFrac.y);
-    data.fWeights[2] = (1 - fPxFrac.x) * (fPxFrac.y);
-    data.fWeights[3] = (fPxFrac.x) * (fPxFrac.y);
-
-    return data;
-}
-
-struct PlaneData
-{
-    FfxFloat32x3 fNormal;
-    FfxFloat32 fDistanceFromOrigin;
-};
-
-PlaneData GetPlaneFromPoints(FfxFloat32x3 fP0, FfxFloat32x3 fP1, FfxFloat32x3 fP2)
-{
-    PlaneData plane;
-
-    FfxFloat32x3 v0 = fP0 - fP1;
-    FfxFloat32x3 v1 = fP0 - fP2;
-    plane.fNormal = normalize(cross(v0, v1));
-    plane.fDistanceFromOrigin = -dot(fP0, plane.fNormal);
-
-    return plane;
-}
-
-FfxFloat32 PointToPlaneDistance(PlaneData plane, FfxFloat32x3 fPoint)
-{
-    return abs(dot(plane.fNormal, fPoint) + plane.fDistanceFromOrigin);
-}
-
-#endif // #if defined(FFX_GPU)
-
-#endif //!defined(FFX_FSR2_COMMON_H)

Assets/Resources/FSR2/shaders/ffx_fsr2_common.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: 2176dca22b6e9604da8329c79abae68d
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_compute_luminance_pyramid.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: dbcdb6dfb36311a49aa7b05bc5054280
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_compute_luminance_pyramid_pass.hlsl

@@ -1,131 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#define FSR2_BIND_SRV_INPUT_COLOR                     0
-#define FSR2_BIND_UAV_SPD_GLOBAL_ATOMIC               0
-#define FSR2_BIND_UAV_EXPOSURE_MIP_LUMA_CHANGE        1
-#define FSR2_BIND_UAV_EXPOSURE_MIP_5                  2
-#define FSR2_BIND_UAV_AUTO_EXPOSURE                   3
-#define FSR2_BIND_CB_FSR2                             0
-#define FSR2_BIND_CB_SPD                              1
-
-#include "ffx_fsr2_callbacks_hlsl.h"
-#include "ffx_fsr2_common.h"
-
-#if defined(FSR2_BIND_CB_SPD)
-    cbuffer cbSPD : FFX_FSR2_DECLARE_CB(FSR2_BIND_CB_SPD) {
-
-        FfxUInt32   mips;
-        FfxUInt32   numWorkGroups;
-        FfxUInt32x2 workGroupOffset;
-        FfxUInt32x2 renderSize;
-    };
-
-    FfxUInt32 MipCount()
-    {
-        return mips;
-    }
-
-    FfxUInt32 NumWorkGroups()
-    {
-        return numWorkGroups;
-    }
-
-    FfxUInt32x2 WorkGroupOffset()
-    {
-        return workGroupOffset;
-    }
-
-    FfxUInt32x2 SPD_RenderSize()
-    {
-        return renderSize;
-    }
-#endif
-
-
-FfxFloat32x2 SPD_LoadExposureBuffer()
-{
-    return rw_auto_exposure[FfxInt32x2(0,0)];
-}
-
-void SPD_SetExposureBuffer(FfxFloat32x2 value)
-{
-    rw_auto_exposure[FfxInt32x2(0,0)] = value;
-}
-
-FfxFloat32x4 SPD_LoadMipmap5(FfxInt32x2 iPxPos)
-{
-    return FfxFloat32x4(rw_img_mip_5[iPxPos], 0, 0, 0);
-}
-
-void SPD_SetMipmap(FfxInt32x2 iPxPos, FfxInt32 slice, FfxFloat32 value)
-{
-    switch (slice)
-    {
-    case FFX_FSR2_SHADING_CHANGE_MIP_LEVEL:
-        rw_img_mip_shading_change[iPxPos] = value;
-        break;
-    case 5:
-        rw_img_mip_5[iPxPos] = value;
-        break;
-    default:
-
-        // avoid flattened side effect
-#if defined(FSR2_BIND_UAV_EXPOSURE_MIP_LUMA_CHANGE) || defined(FFX_INTERNAL)
-        rw_img_mip_shading_change[iPxPos] = rw_img_mip_shading_change[iPxPos];
-#elif defined(FSR2_BIND_UAV_EXPOSURE_MIP_5) || defined(FFX_INTERNAL)
-        rw_img_mip_5[iPxPos] = rw_img_mip_5[iPxPos];
-#endif
-        break;
-    }
-}
-
-void SPD_IncreaseAtomicCounter(inout FfxUInt32 spdCounter)
-{
-   InterlockedAdd(rw_spd_global_atomic[FfxInt32x2(0,0)], 1, spdCounter);
-}
-
-void SPD_ResetAtomicCounter()
-{
-    rw_spd_global_atomic[FfxInt32x2(0,0)] = 0;
-}
-
-#include "ffx_fsr2_compute_luminance_pyramid.h"
-
-#ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#define FFX_FSR2_THREAD_GROUP_WIDTH 256
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#define FFX_FSR2_THREAD_GROUP_HEIGHT 1
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#define FFX_FSR2_THREAD_GROUP_DEPTH 1
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#ifndef FFX_FSR2_NUM_THREADS
-#define FFX_FSR2_NUM_THREADS [numthreads(FFX_FSR2_THREAD_GROUP_WIDTH, FFX_FSR2_THREAD_GROUP_HEIGHT, FFX_FSR2_THREAD_GROUP_DEPTH)]
-#endif // #ifndef FFX_FSR2_NUM_THREADS
-
-FFX_FSR2_NUM_THREADS
-FFX_FSR2_EMBED_CB2_ROOTSIG_CONTENT
-void CS(uint3 WorkGroupId : SV_GroupID, uint LocalThreadIndex : SV_GroupIndex)
-{
-    ComputeAutoExposure(WorkGroupId, LocalThreadIndex);
-}

Assets/Resources/FSR2/shaders/ffx_fsr2_depth_clip.h

@@ -1,258 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef FFX_FSR2_DEPTH_CLIP_H
-#define FFX_FSR2_DEPTH_CLIP_H
-
-FFX_STATIC const FfxFloat32 DepthClipBaseScale = 4.0f;
-
-FfxFloat32 ComputeDepthClip(FfxFloat32x2 fUvSample, FfxFloat32 fCurrentDepthSample)
-{
-    FfxFloat32 fCurrentDepthViewSpace = GetViewSpaceDepth(fCurrentDepthSample);
-    BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fUvSample, RenderSize());
-
-    FfxFloat32 fDilatedSum = 0.0f;
-    FfxFloat32 fDepth = 0.0f;
-    FfxFloat32 fWeightSum = 0.0f;
-    for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) {
-
-        const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex];
-        const FfxInt32x2 iSamplePos = bilinearInfo.iBasePos + iOffset;
-
-        if (IsOnScreen(iSamplePos, RenderSize())) {
-            const FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex];
-            if (fWeight > fReconstructedDepthBilinearWeightThreshold) {
-
-                const FfxFloat32 fPrevDepthSample = LoadReconstructedPrevDepth(iSamplePos);
-                const FfxFloat32 fPrevNearestDepthViewSpace = GetViewSpaceDepth(fPrevDepthSample);
-
-                const FfxFloat32 fDepthDiff = fCurrentDepthViewSpace - fPrevNearestDepthViewSpace;
-
-                if (fDepthDiff > 0.0f) {
-
-#if FFX_FSR2_OPTION_INVERTED_DEPTH
-                    const FfxFloat32 fPlaneDepth = ffxMin(fPrevDepthSample, fCurrentDepthSample);
-#else
-                    const FfxFloat32 fPlaneDepth = ffxMax(fPrevDepthSample, fCurrentDepthSample);
-#endif
-                    
-                    const FfxFloat32x3 fCenter = GetViewSpacePosition(FfxInt32x2(RenderSize() * 0.5f), RenderSize(), fPlaneDepth);
-                    const FfxFloat32x3 fCorner = GetViewSpacePosition(FfxInt32x2(0, 0), RenderSize(), fPlaneDepth);
-
-                    const FfxFloat32 fHalfViewportWidth = length(FfxFloat32x2(RenderSize()));
-                    const FfxFloat32 fDepthThreshold = ffxMax(fCurrentDepthViewSpace, fPrevNearestDepthViewSpace);
-
-                    const FfxFloat32 Ksep = 1.37e-05f;
-                    const FfxFloat32 Kfov = length(fCorner) / length(fCenter);
-                    const FfxFloat32 fRequiredDepthSeparation = Ksep * Kfov * fHalfViewportWidth * fDepthThreshold;
-
-                    const FfxFloat32 fResolutionFactor = ffxSaturate(length(FfxFloat32x2(RenderSize())) / length(FfxFloat32x2(1920.0f, 1080.0f)));
-                    const FfxFloat32 fPower = ffxLerp(1.0f, 3.0f, fResolutionFactor);
-                    fDepth += ffxPow(ffxSaturate(FfxFloat32(fRequiredDepthSeparation / fDepthDiff)), fPower) * fWeight;
-                    fWeightSum += fWeight;
-                }
-            }
-        }
-    }
-
-    return (fWeightSum > 0) ? ffxSaturate(1.0f - fDepth / fWeightSum) : 0.0f;
-}
-
-FfxFloat32 ComputeMotionDivergence(FfxInt32x2 iPxPos, FfxInt32x2 iPxInputMotionVectorSize)
-{
-    FfxFloat32 minconvergence = 1.0f;
-
-    FfxFloat32x2 fMotionVectorNucleus = LoadInputMotionVector(iPxPos);
-    FfxFloat32 fNucleusVelocityLr = length(fMotionVectorNucleus * RenderSize());
-    FfxFloat32 fMaxVelocityUv = length(fMotionVectorNucleus);
-
-    const FfxFloat32 MotionVectorVelocityEpsilon = 1e-02f;
-
-    if (fNucleusVelocityLr > MotionVectorVelocityEpsilon) {
-        for (FfxInt32 y = -1; y <= 1; ++y) {
-            for (FfxInt32 x = -1; x <= 1; ++x) {
-
-                FfxInt32x2 sp = ClampLoad(iPxPos, FfxInt32x2(x, y), iPxInputMotionVectorSize);
-
-                FfxFloat32x2 fMotionVector = LoadInputMotionVector(sp);
-                FfxFloat32 fVelocityUv = length(fMotionVector);
-
-                fMaxVelocityUv = ffxMax(fVelocityUv, fMaxVelocityUv);
-                fVelocityUv = ffxMax(fVelocityUv, fMaxVelocityUv);
-                minconvergence = ffxMin(minconvergence, dot(fMotionVector / fVelocityUv, fMotionVectorNucleus / fVelocityUv));
-            }
-        }
-    }
-
-    return ffxSaturate(1.0f - minconvergence) * ffxSaturate(fMaxVelocityUv / 0.01f);
-}
-
-FfxFloat32 ComputeDepthDivergence(FfxInt32x2 iPxPos)
-{
-    const FfxFloat32 fMaxDistInMeters = GetMaxDistanceInMeters();
-    FfxFloat32 fDepthMax = 0.0f;
-    FfxFloat32 fDepthMin = fMaxDistInMeters;
-
-    FfxInt32 iMaxDistFound = 0;
-
-    for (FfxInt32 y = -1; y < 2; y++) {
-        for (FfxInt32 x = -1; x < 2; x++) {
-
-            const FfxInt32x2 iOffset = FfxInt32x2(x, y);
-            const FfxInt32x2 iSamplePos = iPxPos + iOffset;
-
-            const FfxFloat32 fOnScreenFactor = IsOnScreen(iSamplePos, RenderSize()) ? 1.0f : 0.0f;
-            FfxFloat32 fDepth = GetViewSpaceDepthInMeters(LoadDilatedDepth(iSamplePos)) * fOnScreenFactor;
-
-            iMaxDistFound |= FfxInt32(fMaxDistInMeters == fDepth);
-
-            fDepthMin = ffxMin(fDepthMin, fDepth);
-            fDepthMax = ffxMax(fDepthMax, fDepth);
-        }
-    }
-
-    return (1.0f - fDepthMin / fDepthMax) * (FfxBoolean(iMaxDistFound) ? 0.0f : 1.0f);
-}
-
-FfxFloat32 ComputeTemporalMotionDivergence(FfxInt32x2 iPxPos)
-{
-    const FfxFloat32x2 fUv = FfxFloat32x2(iPxPos + 0.5f) / RenderSize();
-
-    FfxFloat32x2 fMotionVector = LoadDilatedMotionVector(iPxPos);
-    FfxFloat32x2 fReprojectedUv = fUv + fMotionVector;
-    fReprojectedUv = ClampUv(fReprojectedUv, RenderSize(), MaxRenderSize());
-    FfxFloat32x2 fPrevMotionVector = SamplePreviousDilatedMotionVector(fReprojectedUv);
-
-    float fPxDistance = length(fMotionVector * DisplaySize());
-    return fPxDistance > 1.0f ? ffxLerp(0.0f, 1.0f - ffxSaturate(length(fPrevMotionVector) / length(fMotionVector)), ffxSaturate(ffxPow(fPxDistance / 20.0f, 3.0f))) : 0;
-}
-
-void PreProcessReactiveMasks(FfxInt32x2 iPxLrPos, FfxFloat32 fMotionDivergence)
-{
-    // Compensate for bilinear sampling in accumulation pass
-
-    FfxFloat32x3 fReferenceColor = LoadInputColor(iPxLrPos).xyz;
-    FfxFloat32x2 fReactiveFactor = FfxFloat32x2(0.0f, fMotionDivergence);
-
-    float fMasksSum = 0.0f;
-
-    FfxFloat32x3 fColorSamples[9];
-    FfxFloat32 fReactiveSamples[9];
-    FfxFloat32 fTransparencyAndCompositionSamples[9];
-
-    FFX_UNROLL
-    for (FfxInt32 y = -1; y < 2; y++) {
-        FFX_UNROLL
-        for (FfxInt32 x = -1; x < 2; x++) {
-
-            const FfxInt32x2 sampleCoord = ClampLoad(iPxLrPos, FfxInt32x2(x, y), FfxInt32x2(RenderSize()));
-
-            FfxInt32 sampleIdx = (y + 1) * 3 + x + 1;
-
-            FfxFloat32x3 fColorSample = LoadInputColor(sampleCoord).xyz;
-            FfxFloat32 fReactiveSample = LoadReactiveMask(sampleCoord);
-            FfxFloat32 fTransparencyAndCompositionSample = LoadTransparencyAndCompositionMask(sampleCoord);
-
-            fColorSamples[sampleIdx] = fColorSample;
-            fReactiveSamples[sampleIdx] = fReactiveSample;
-            fTransparencyAndCompositionSamples[sampleIdx] = fTransparencyAndCompositionSample;
-
-            fMasksSum += (fReactiveSample + fTransparencyAndCompositionSample);
-        }
-    }
-
-    if (fMasksSum > 0)
-    {
-        for (FfxInt32 sampleIdx = 0; sampleIdx < 9; sampleIdx++)
-        {
-            FfxFloat32x3 fColorSample = fColorSamples[sampleIdx];
-            FfxFloat32 fReactiveSample = fReactiveSamples[sampleIdx];
-            FfxFloat32 fTransparencyAndCompositionSample = fTransparencyAndCompositionSamples[sampleIdx];
-
-            const FfxFloat32 fMaxLenSq = ffxMax(dot(fReferenceColor, fReferenceColor), dot(fColorSample, fColorSample));
-            const FfxFloat32 fSimilarity = dot(fReferenceColor, fColorSample) / fMaxLenSq;
-
-            // Increase power for non-similar samples
-            const FfxFloat32 fPowerBiasMax = 6.0f;
-            const FfxFloat32 fSimilarityPower = 1.0f + (fPowerBiasMax - fSimilarity * fPowerBiasMax);
-            const FfxFloat32 fWeightedReactiveSample = ffxPow(fReactiveSample, fSimilarityPower);
-            const FfxFloat32 fWeightedTransparencyAndCompositionSample = ffxPow(fTransparencyAndCompositionSample, fSimilarityPower);
-
-            fReactiveFactor = ffxMax(fReactiveFactor, FfxFloat32x2(fWeightedReactiveSample, fWeightedTransparencyAndCompositionSample));
-        }
-    }
-
-    StoreDilatedReactiveMasks(iPxLrPos, fReactiveFactor);
-}
-
-FfxFloat32x3 ComputePreparedInputColor(FfxInt32x2 iPxLrPos)
-{
-    //We assume linear data. if non-linear input (sRGB, ...),
-    //then we should convert to linear first and back to sRGB on output.
-    FfxFloat32x3 fRgb = ffxMax(FfxFloat32x3(0, 0, 0), LoadInputColor(iPxLrPos));
-
-    fRgb = PrepareRgb(fRgb, Exposure(), PreExposure());
-
-    const FfxFloat32x3 fPreparedYCoCg = RGBToYCoCg(fRgb);
-
-    return fPreparedYCoCg;
-}
-
-FfxFloat32 EvaluateSurface(FfxInt32x2 iPxPos, FfxFloat32x2 fMotionVector)
-{
-    FfxFloat32 d0 = GetViewSpaceDepth(LoadReconstructedPrevDepth(iPxPos + FfxInt32x2(0, -1)));
-    FfxFloat32 d1 = GetViewSpaceDepth(LoadReconstructedPrevDepth(iPxPos + FfxInt32x2(0, 0)));
-    FfxFloat32 d2 = GetViewSpaceDepth(LoadReconstructedPrevDepth(iPxPos + FfxInt32x2(0, 1)));
-
-    return 1.0f - FfxFloat32(((d0 - d1) > (d1 * 0.01f)) && ((d1 - d2) > (d2 * 0.01f)));
-}
-
-void DepthClip(FfxInt32x2 iPxPos)
-{
-    FfxFloat32x2 fDepthUv = (iPxPos + 0.5f) / RenderSize();
-    FfxFloat32x2 fMotionVector = LoadDilatedMotionVector(iPxPos);
-
-    // Discard tiny mvs
-    fMotionVector *= FfxFloat32(length(fMotionVector * DisplaySize()) > 0.01f);
-
-    const FfxFloat32x2 fDilatedUv = fDepthUv + fMotionVector;
-    const FfxFloat32 fDilatedDepth = LoadDilatedDepth(iPxPos);
-    const FfxFloat32 fCurrentDepthViewSpace = GetViewSpaceDepth(LoadInputDepth(iPxPos));
-
-    // Compute prepared input color and depth clip
-    FfxFloat32 fDepthClip = ComputeDepthClip(fDilatedUv, fDilatedDepth) * EvaluateSurface(iPxPos, fMotionVector);
-    FfxFloat32x3 fPreparedYCoCg = ComputePreparedInputColor(iPxPos);
-    StorePreparedInputColor(iPxPos, FfxFloat32x4(fPreparedYCoCg, fDepthClip));
-
-    // Compute dilated reactive mask
-#if FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-    FfxInt32x2 iSamplePos = iPxPos;
-#else
-    FfxInt32x2 iSamplePos = ComputeHrPosFromLrPos(iPxPos);
-#endif
-
-    FfxFloat32 fMotionDivergence = ComputeMotionDivergence(iSamplePos, RenderSize());
-    FfxFloat32 fTemporalMotionDifference = ffxSaturate(ComputeTemporalMotionDivergence(iPxPos) - ComputeDepthDivergence(iPxPos));
-
-    PreProcessReactiveMasks(iPxPos, ffxMax(fTemporalMotionDifference, fMotionDivergence));
-}
-
-#endif //!defined( FFX_FSR2_DEPTH_CLIPH )

Assets/Resources/FSR2/shaders/ffx_fsr2_depth_clip.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: f7c16477aeb3a9b4f94f4ef818d10d9b
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_depth_clip_pass.hlsl

@@ -1,66 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#define FSR2_BIND_SRV_RECONSTRUCTED_PREV_NEAREST_DEPTH      0
-#define FSR2_BIND_SRV_DILATED_MOTION_VECTORS                1
-#define FSR2_BIND_SRV_DILATED_DEPTH                         2
-#define FSR2_BIND_SRV_REACTIVE_MASK                         3
-#define FSR2_BIND_SRV_TRANSPARENCY_AND_COMPOSITION_MASK     4
-#define FSR2_BIND_SRV_PREVIOUS_DILATED_MOTION_VECTORS       5
-#define FSR2_BIND_SRV_INPUT_MOTION_VECTORS                  6
-#define FSR2_BIND_SRV_INPUT_COLOR                           7
-#define FSR2_BIND_SRV_INPUT_DEPTH                           8
-#define FSR2_BIND_SRV_INPUT_EXPOSURE                        9
-
-#define FSR2_BIND_UAV_DILATED_REACTIVE_MASKS                0
-#define FSR2_BIND_UAV_PREPARED_INPUT_COLOR                  1
-
-#define FSR2_BIND_CB_FSR2                                   0
-
-#include "ffx_fsr2_callbacks_hlsl.h"
-#include "ffx_fsr2_common.h"
-#include "ffx_fsr2_sample.h"
-#include "ffx_fsr2_depth_clip.h"
-
-#ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#define FFX_FSR2_THREAD_GROUP_WIDTH 8
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#define FFX_FSR2_THREAD_GROUP_HEIGHT 8
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#define FFX_FSR2_THREAD_GROUP_DEPTH 1
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#ifndef FFX_FSR2_NUM_THREADS
-#define FFX_FSR2_NUM_THREADS [numthreads(FFX_FSR2_THREAD_GROUP_WIDTH, FFX_FSR2_THREAD_GROUP_HEIGHT, FFX_FSR2_THREAD_GROUP_DEPTH)]
-#endif // #ifndef FFX_FSR2_NUM_THREADS
-
-FFX_FSR2_PREFER_WAVE64
-FFX_FSR2_NUM_THREADS
-FFX_FSR2_EMBED_ROOTSIG_CONTENT
-void CS(
-    int2 iGroupId : SV_GroupID,
-    int2 iDispatchThreadId : SV_DispatchThreadID,
-    int2 iGroupThreadId : SV_GroupThreadID,
-    int iGroupIndex : SV_GroupIndex)
-{
-    DepthClip(iDispatchThreadId);
-}

Assets/Resources/FSR2/shaders/ffx_fsr2_lock.h

@@ -1,115 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef FFX_FSR2_LOCK_H
-#define FFX_FSR2_LOCK_H
-
-void ClearResourcesForNextFrame(in FfxInt32x2 iPxHrPos)
-{
-    if (all(FFX_LESS_THAN(iPxHrPos, FfxInt32x2(RenderSize()))))
-    {
-#if FFX_FSR2_OPTION_INVERTED_DEPTH
-        const FfxUInt32 farZ = 0x0;
-#else
-        const FfxUInt32 farZ = 0x3f800000;
-#endif
-        SetReconstructedDepth(iPxHrPos, farZ);
-    }
-}
-
-FfxBoolean ComputeThinFeatureConfidence(FfxInt32x2 pos)
-{
-    const FfxInt32 RADIUS = 1;
-
-    FfxFloat32 fNucleus = LoadLockInputLuma(pos);
-
-    FfxFloat32 similar_threshold = 1.05f;
-    FfxFloat32 dissimilarLumaMin = FSR2_FLT_MAX;
-    FfxFloat32 dissimilarLumaMax = 0;
-
-    /*
-     0 1 2
-     3 4 5
-     6 7 8
-    */
-
-    #define SETBIT(x) (1U << x)
-
-    FfxUInt32 mask = SETBIT(4); //flag fNucleus as similar
-
-    const FfxUInt32 uNumRejectionMasks = 4;
-    const FfxUInt32 uRejectionMasks[uNumRejectionMasks] = {
-        SETBIT(0) | SETBIT(1) | SETBIT(3) | SETBIT(4), //Upper left
-        SETBIT(1) | SETBIT(2) | SETBIT(4) | SETBIT(5), //Upper right
-        SETBIT(3) | SETBIT(4) | SETBIT(6) | SETBIT(7), //Lower left
-        SETBIT(4) | SETBIT(5) | SETBIT(7) | SETBIT(8), //Lower right
-    };
-
-    FfxInt32 idx = 0;
-    FFX_UNROLL
-    for (FfxInt32 y = -RADIUS; y <= RADIUS; y++) {
-        FFX_UNROLL
-        for (FfxInt32 x = -RADIUS; x <= RADIUS; x++, idx++) {
-            if (x == 0 && y == 0) continue;
-
-            FfxInt32x2 samplePos = ClampLoad(pos, FfxInt32x2(x, y), FfxInt32x2(RenderSize()));
-
-            FfxFloat32 sampleLuma = LoadLockInputLuma(samplePos);
-            FfxFloat32 difference = ffxMax(sampleLuma, fNucleus) / ffxMin(sampleLuma, fNucleus);
-
-            if (difference > 0 && (difference < similar_threshold)) {
-                mask |= SETBIT(idx);
-            } else {
-                dissimilarLumaMin = ffxMin(dissimilarLumaMin, sampleLuma);
-                dissimilarLumaMax = ffxMax(dissimilarLumaMax, sampleLuma);
-            }
-        }
-    }
-
-    FfxBoolean isRidge = fNucleus > dissimilarLumaMax || fNucleus < dissimilarLumaMin;
-
-    if (FFX_FALSE == isRidge) {
-
-        return false;
-    }
-
-    FFX_UNROLL
-    for (FfxInt32 i = 0; i < 4; i++) {
-
-        if ((mask & uRejectionMasks[i]) == uRejectionMasks[i]) {
-            return false;
-        }
-    }
-    
-    return true;
-}
-
-void ComputeLock(FfxInt32x2 iPxLrPos)
-{
-    if (ComputeThinFeatureConfidence(iPxLrPos))
-    {
-        StoreNewLocks(ComputeHrPosFromLrPos(iPxLrPos), 1.f);
-    }
-
-    ClearResourcesForNextFrame(iPxLrPos);
-}
-
-#endif // FFX_FSR2_LOCK_H

Assets/Resources/FSR2/shaders/ffx_fsr2_lock.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: 9b4cdc5f81194ac4fa946c31b86234ed
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_lock_pass.hlsl

@@ -1,53 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#define FSR2_BIND_SRV_LOCK_INPUT_LUMA                       0
-#define FSR2_BIND_UAV_NEW_LOCKS                             0
-#define FSR2_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH      1
-#define FSR2_BIND_CB_FSR2                                   0
-
-#include "ffx_fsr2_callbacks_hlsl.h"
-#include "ffx_fsr2_common.h"
-#include "ffx_fsr2_sample.h"
-#include "ffx_fsr2_lock.h"
-
-#ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#define FFX_FSR2_THREAD_GROUP_WIDTH 8
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#define FFX_FSR2_THREAD_GROUP_HEIGHT 8
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#define FFX_FSR2_THREAD_GROUP_DEPTH 1
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#ifndef FFX_FSR2_NUM_THREADS
-#define FFX_FSR2_NUM_THREADS [numthreads(FFX_FSR2_THREAD_GROUP_WIDTH, FFX_FSR2_THREAD_GROUP_HEIGHT, FFX_FSR2_THREAD_GROUP_DEPTH)]
-#endif // #ifndef FFX_FSR2_NUM_THREADS
-
-FFX_FSR2_PREFER_WAVE64
-FFX_FSR2_NUM_THREADS
-FFX_FSR2_EMBED_ROOTSIG_CONTENT
-void CS(uint2 uGroupId : SV_GroupID, uint2 uGroupThreadId : SV_GroupThreadID)
-{
-    uint2 uDispatchThreadId = uGroupId * uint2(FFX_FSR2_THREAD_GROUP_WIDTH, FFX_FSR2_THREAD_GROUP_HEIGHT) + uGroupThreadId;
-
-    ComputeLock(uDispatchThreadId);
-}

Assets/Resources/FSR2/shaders/ffx_fsr2_lock_pass.hlsl.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 471a3f7a033c72f4fa737d4f8238a9bd
-ShaderIncludeImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_postprocess_lock_status.h

@@ -1,106 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef FFX_FSR2_POSTPROCESS_LOCK_STATUS_H
-#define FFX_FSR2_POSTPROCESS_LOCK_STATUS_H
-
-FfxFloat32x4 WrapShadingChangeLuma(FfxInt32x2 iPxSample)
-{
-    return FfxFloat32x4(LoadMipLuma(iPxSample, LumaMipLevelToUse()), 0, 0, 0);
-}
-
-#if FFX_HALF
-FFX_MIN16_F4 WrapShadingChangeLuma(FFX_MIN16_I2 iPxSample)
-{
-    return FFX_MIN16_F4(LoadMipLuma(iPxSample, LumaMipLevelToUse()), 0, 0, 0);
-}
-#endif
-
-#if FFX_FSR2_OPTION_POSTPROCESSLOCKSTATUS_SAMPLERS_USE_DATA_HALF && FFX_HALF
-DeclareCustomFetchBilinearSamplesMin16(FetchShadingChangeLumaSamples, WrapShadingChangeLuma)
-#else
-DeclareCustomFetchBicubicSamples(FetchShadingChangeLumaSamples, WrapShadingChangeLuma)
-#endif
-DeclareCustomTextureSample(ShadingChangeLumaSample, Lanczos2, FetchShadingChangeLumaSamples)
-
-FfxFloat32 GetShadingChangeLuma(FfxInt32x2 iPxHrPos, FfxFloat32x2 fUvCoord)
-{
-    FfxFloat32 fShadingChangeLuma = 0;
-
-#if 0
-    fShadingChangeLuma = Exposure() * exp(ShadingChangeLumaSample(fUvCoord, LumaMipDimensions()).x);
-#else
-
-    const FfxFloat32 fDiv = FfxFloat32(2 << LumaMipLevelToUse());
-    FfxInt32x2 iMipRenderSize = FfxInt32x2(RenderSize() / fDiv);
-
-    fUvCoord = ClampUv(fUvCoord, iMipRenderSize, LumaMipDimensions());
-    fShadingChangeLuma = Exposure() * exp(FfxFloat32(SampleMipLuma(fUvCoord, LumaMipLevelToUse())));
-#endif
-
-    fShadingChangeLuma = ffxPow(fShadingChangeLuma, 1.0f / 6.0f);
-
-    return fShadingChangeLuma;
-}
-
-void UpdateLockStatus(AccumulationPassCommonParams params,
-    FFX_PARAMETER_INOUT FfxFloat32 fReactiveFactor, LockState state,
-    FFX_PARAMETER_INOUT FfxFloat32x2 fLockStatus,
-    FFX_PARAMETER_OUT FfxFloat32 fLockContributionThisFrame,
-    FFX_PARAMETER_OUT FfxFloat32 fLuminanceDiff) {
-
-    const FfxFloat32 fShadingChangeLuma = GetShadingChangeLuma(params.iPxHrPos, params.fHrUv);
-
-    //init temporal shading change factor, init to -1 or so in reproject to know if "true new"?
-    fLockStatus[LOCK_TEMPORAL_LUMA] = (fLockStatus[LOCK_TEMPORAL_LUMA] == FfxFloat32(0.0f)) ? fShadingChangeLuma : fLockStatus[LOCK_TEMPORAL_LUMA];
-
-    FfxFloat32 fPreviousShadingChangeLuma = fLockStatus[LOCK_TEMPORAL_LUMA];
-
-    fLuminanceDiff = 1.0f - MinDividedByMax(fPreviousShadingChangeLuma, fShadingChangeLuma);
-
-    if (state.NewLock) {
-        fLockStatus[LOCK_TEMPORAL_LUMA] = fShadingChangeLuma;
-
-        fLockStatus[LOCK_LIFETIME_REMAINING] = (fLockStatus[LOCK_LIFETIME_REMAINING] != 0.0f) ? 2.0f : 1.0f;
-    }
-    else if(fLockStatus[LOCK_LIFETIME_REMAINING] <= 1.0f) {
-        fLockStatus[LOCK_TEMPORAL_LUMA] = ffxLerp(fLockStatus[LOCK_TEMPORAL_LUMA], FfxFloat32(fShadingChangeLuma), 0.5f);
-    }
-    else {
-        if (fLuminanceDiff > 0.1f) {
-            KillLock(fLockStatus);
-        }
-    }
-
-    fReactiveFactor = ffxMax(fReactiveFactor, ffxSaturate((fLuminanceDiff - 0.1f) * 10.0f));
-    fLockStatus[LOCK_LIFETIME_REMAINING] *= (1.0f - fReactiveFactor);
-
-    fLockStatus[LOCK_LIFETIME_REMAINING] *= ffxSaturate(1.0f - params.fAccumulationMask);
-    fLockStatus[LOCK_LIFETIME_REMAINING] *= FfxFloat32(params.fDepthClipFactor < 0.1f);
-
-    // Compute this frame lock contribution
-    const FfxFloat32 fLifetimeContribution = ffxSaturate(fLockStatus[LOCK_LIFETIME_REMAINING] - 1.0f);
-    const FfxFloat32 fShadingChangeContribution = ffxSaturate(MinDividedByMax(fLockStatus[LOCK_TEMPORAL_LUMA], fShadingChangeLuma));
-
-    fLockContributionThisFrame = ffxSaturate(ffxSaturate(fLifetimeContribution * 4.0f) * fShadingChangeContribution);
-}
-
-#endif //!defined( FFX_FSR2_POSTPROCESS_LOCK_STATUS_H )

Assets/Resources/FSR2/shaders/ffx_fsr2_postprocess_lock_status.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: 3945c3cfd2cc1a64cb0513864d88d8ca
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_rcas.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: 7bd7d4eb34c626342966cb9b3fe00363
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_rcas_pass.hlsl

@@ -1,75 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#define FSR2_BIND_SRV_INPUT_EXPOSURE        0
-#define FSR2_BIND_SRV_RCAS_INPUT            1
-#define FSR2_BIND_UAV_UPSCALED_OUTPUT       0
-#define FSR2_BIND_CB_FSR2                   0
-#define FSR2_BIND_CB_RCAS                   1
-
-#include "ffx_fsr2_callbacks_hlsl.h"
-#include "ffx_fsr2_common.h"
-
-//Move to prototype shader!
-#if defined(FSR2_BIND_CB_RCAS)
-    cbuffer cbRCAS : FFX_FSR2_DECLARE_CB(FSR2_BIND_CB_RCAS)
-    {
-        uint4 rcasConfig;
-    };
-
-    uint4 RCASConfig()
-    {
-        return rcasConfig;
-    }
-#else
-    uint4 RCASConfig()
-    {
-        return 0;
-    }
-#endif
-
-
-float4 LoadRCAS_Input(FfxInt32x2 iPxPos)
-{
-    return r_rcas_input[iPxPos];
-}
-
-#include "ffx_fsr2_rcas.h"
-
-#ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#define FFX_FSR2_THREAD_GROUP_WIDTH 64
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#define FFX_FSR2_THREAD_GROUP_HEIGHT 1
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#define FFX_FSR2_THREAD_GROUP_DEPTH 1
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#ifndef FFX_FSR2_NUM_THREADS
-#define FFX_FSR2_NUM_THREADS [numthreads(FFX_FSR2_THREAD_GROUP_WIDTH, FFX_FSR2_THREAD_GROUP_HEIGHT, FFX_FSR2_THREAD_GROUP_DEPTH)]
-#endif // #ifndef FFX_FSR2_NUM_THREADS
-
-FFX_FSR2_NUM_THREADS
-FFX_FSR2_EMBED_CB2_ROOTSIG_CONTENT
-void CS(uint3 LocalThreadId : SV_GroupThreadID, uint3 WorkGroupId : SV_GroupID, uint3 Dtid : SV_DispatchThreadID)
-{
-    RCAS(LocalThreadId, WorkGroupId, Dtid);
-}

Assets/Resources/FSR2/shaders/ffx_fsr2_rcas_pass.hlsl.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 871ca1938c701d64f94ef8ec00ef06f4
-ShaderIncludeImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_reconstruct_dilated_velocity_and_previous_depth.h

@@ -1,145 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef FFX_FSR2_RECONSTRUCT_DILATED_VELOCITY_AND_PREVIOUS_DEPTH_H
-#define FFX_FSR2_RECONSTRUCT_DILATED_VELOCITY_AND_PREVIOUS_DEPTH_H
-
-void ReconstructPrevDepth(FfxInt32x2 iPxPos, FfxFloat32 fDepth, FfxFloat32x2 fMotionVector, FfxInt32x2 iPxDepthSize)
-{
-    fMotionVector *= FfxFloat32(length(fMotionVector * DisplaySize()) > 0.1f);
-
-    FfxFloat32x2 fUv = (iPxPos + FfxFloat32(0.5)) / iPxDepthSize;
-    FfxFloat32x2 fReprojectedUv = fUv + fMotionVector;
- 
-    BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fReprojectedUv, RenderSize());
-
-    // Project current depth into previous frame locations.
-    // Push to all pixels having some contribution if reprojection is using bilinear logic.
-    for (FfxInt32 iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++) {
-        
-        const FfxInt32x2 iOffset = bilinearInfo.iOffsets[iSampleIndex];
-        FfxFloat32 fWeight = bilinearInfo.fWeights[iSampleIndex];
-
-        if (fWeight > fReconstructedDepthBilinearWeightThreshold) {
-
-            FfxInt32x2 iStorePos = bilinearInfo.iBasePos + iOffset;
-            if (IsOnScreen(iStorePos, iPxDepthSize)) {
-                StoreReconstructedDepth(iStorePos, fDepth);
-            }
-        }
-    }
-}
-
-void FindNearestDepth(FFX_PARAMETER_IN FfxInt32x2 iPxPos, FFX_PARAMETER_IN FfxInt32x2 iPxSize, FFX_PARAMETER_OUT FfxFloat32 fNearestDepth, FFX_PARAMETER_OUT FfxInt32x2 fNearestDepthCoord)
-{
-    const FfxInt32 iSampleCount = 9;
-    const FfxInt32x2 iSampleOffsets[iSampleCount] = {
-        FfxInt32x2(+0, +0),
-        FfxInt32x2(+1, +0),
-        FfxInt32x2(+0, +1),
-        FfxInt32x2(+0, -1),
-        FfxInt32x2(-1, +0),
-        FfxInt32x2(-1, +1),
-        FfxInt32x2(+1, +1),
-        FfxInt32x2(-1, -1),
-        FfxInt32x2(+1, -1),
-    };
-
-    // pull out the depth loads to allow SC to batch them
-    FfxFloat32 depth[9];
-    FfxInt32 iSampleIndex = 0;
-    FFX_UNROLL
-    for (iSampleIndex = 0; iSampleIndex < iSampleCount; ++iSampleIndex) {
-
-        FfxInt32x2 iPos = iPxPos + iSampleOffsets[iSampleIndex];
-        depth[iSampleIndex] = LoadInputDepth(iPos);
-    }
-
-    // find closest depth
-    fNearestDepthCoord = iPxPos;
-    fNearestDepth = depth[0];
-    FFX_UNROLL
-    for (iSampleIndex = 1; iSampleIndex < iSampleCount; ++iSampleIndex) {
-
-        FfxInt32x2 iPos = iPxPos + iSampleOffsets[iSampleIndex];
-        if (IsOnScreen(iPos, iPxSize)) {
-
-            FfxFloat32 fNdDepth = depth[iSampleIndex];
-#if FFX_FSR2_OPTION_INVERTED_DEPTH
-            if (fNdDepth > fNearestDepth) {
-#else
-            if (fNdDepth < fNearestDepth) {
-#endif
-                fNearestDepthCoord = iPos;
-                fNearestDepth = fNdDepth;
-            }
-        }
-    }
-}
-
-FfxFloat32 ComputeLockInputLuma(FfxInt32x2 iPxLrPos)
-{
-    //We assume linear data. if non-linear input (sRGB, ...),
-    //then we should convert to linear first and back to sRGB on output.
-    FfxFloat32x3 fRgb = ffxMax(FfxFloat32x3(0, 0, 0), LoadInputColor(iPxLrPos));
-
-    // Use internal auto exposure for locking logic
-    fRgb /= PreExposure();
-    fRgb *= Exposure();
-
-#if FFX_FSR2_OPTION_HDR_COLOR_INPUT
-    fRgb = Tonemap(fRgb);
-#endif
-
-    //compute luma used to lock pixels, if used elsewhere the ffxPow must be moved!
-    const FfxFloat32 fLockInputLuma = ffxPow(RGBToPerceivedLuma(fRgb), FfxFloat32(1.0 / 6.0));
-
-    return fLockInputLuma;
-}
-
-void ReconstructAndDilate(FfxInt32x2 iPxLrPos)
-{
-    FfxFloat32 fDilatedDepth;
-    FfxInt32x2 iNearestDepthCoord;
-
-    FindNearestDepth(iPxLrPos, RenderSize(), fDilatedDepth, iNearestDepthCoord);
-
-#if FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-    FfxInt32x2 iSamplePos = iPxLrPos;
-    FfxInt32x2 iMotionVectorPos = iNearestDepthCoord;
-#else
-    FfxInt32x2 iSamplePos = ComputeHrPosFromLrPos(iPxLrPos);
-    FfxInt32x2 iMotionVectorPos = ComputeHrPosFromLrPos(iNearestDepthCoord);
-#endif
-
-    FfxFloat32x2 fDilatedMotionVector = LoadInputMotionVector(iMotionVectorPos);
-
-    StoreDilatedDepth(iPxLrPos, fDilatedDepth);
-    StoreDilatedMotionVector(iPxLrPos, fDilatedMotionVector);
-
-    ReconstructPrevDepth(iPxLrPos, fDilatedDepth, fDilatedMotionVector, RenderSize());
-
-    FfxFloat32 fLockInputLuma = ComputeLockInputLuma(iPxLrPos);
-    StoreLockInputLuma(iPxLrPos, fLockInputLuma);
-}
-
-
-#endif //!defined( FFX_FSR2_RECONSTRUCT_DILATED_VELOCITY_AND_PREVIOUS_DEPTH_H )

Assets/Resources/FSR2/shaders/ffx_fsr2_reconstruct_dilated_velocity_and_previous_depth.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: 13cd33c3d34a317409049dfd939e64ef
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_reconstruct_previous_depth_pass.hlsl

@@ -1,63 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#define FSR2_BIND_SRV_INPUT_MOTION_VECTORS                  0
-#define FSR2_BIND_SRV_INPUT_DEPTH                           1
-#define FSR2_BIND_SRV_INPUT_COLOR                           2
-#define FSR2_BIND_SRV_INPUT_EXPOSURE                        3
-
-#define FSR2_BIND_UAV_RECONSTRUCTED_PREV_NEAREST_DEPTH      0
-#define FSR2_BIND_UAV_DILATED_MOTION_VECTORS                1
-#define FSR2_BIND_UAV_DILATED_DEPTH                         2
-#define FSR2_BIND_UAV_LOCK_INPUT_LUMA                       3
-
-#define FSR2_BIND_CB_FSR2                                   0
-
-#include "ffx_fsr2_callbacks_hlsl.h"
-#include "ffx_fsr2_common.h"
-#include "ffx_fsr2_sample.h"
-#include "ffx_fsr2_reconstruct_dilated_velocity_and_previous_depth.h"
-
-#ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#define FFX_FSR2_THREAD_GROUP_WIDTH 8
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_WIDTH
-#ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#define FFX_FSR2_THREAD_GROUP_HEIGHT 8
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_HEIGHT
-#ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#define FFX_FSR2_THREAD_GROUP_DEPTH 1
-#endif // #ifndef FFX_FSR2_THREAD_GROUP_DEPTH
-#ifndef FFX_FSR2_NUM_THREADS
-#define FFX_FSR2_NUM_THREADS [numthreads(FFX_FSR2_THREAD_GROUP_WIDTH, FFX_FSR2_THREAD_GROUP_HEIGHT, FFX_FSR2_THREAD_GROUP_DEPTH)]
-#endif // #ifndef FFX_FSR2_NUM_THREADS
-
-FFX_FSR2_PREFER_WAVE64
-FFX_FSR2_NUM_THREADS
-FFX_FSR2_EMBED_ROOTSIG_CONTENT
-void CS(
-    int2 iGroupId : SV_GroupID,
-    int2 iDispatchThreadId : SV_DispatchThreadID,
-    int2 iGroupThreadId : SV_GroupThreadID,
-    int iGroupIndex : SV_GroupIndex
-)
-{
-    ReconstructAndDilate(iDispatchThreadId);
-}

Assets/Resources/FSR2/shaders/ffx_fsr2_reconstruct_previous_depth_pass.hlsl.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 9355c255c8505ae48ae89af286943747
-ShaderIncludeImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_reproject.h

@@ -1,136 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef FFX_FSR2_REPROJECT_H
-#define FFX_FSR2_REPROJECT_H
-
-#ifndef FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE
-#define FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE 0 // Reference
-#endif
-
-FfxFloat32x4 WrapHistory(FfxInt32x2 iPxSample)
-{
-    return LoadHistory(iPxSample);
-}
-
-#if FFX_HALF
-FFX_MIN16_F4 WrapHistory(FFX_MIN16_I2 iPxSample)
-{
-    return FFX_MIN16_F4(LoadHistory(iPxSample));
-}
-#endif
-
-
-#if FFX_FSR2_OPTION_REPROJECT_SAMPLERS_USE_DATA_HALF && FFX_HALF
-DeclareCustomFetchBicubicSamplesMin16(FetchHistorySamples, WrapHistory)
-DeclareCustomTextureSampleMin16(HistorySample, FFX_FSR2_GET_LANCZOS_SAMPLER1D(FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE), FetchHistorySamples)
-#else
-DeclareCustomFetchBicubicSamples(FetchHistorySamples, WrapHistory)
-DeclareCustomTextureSample(HistorySample, FFX_FSR2_GET_LANCZOS_SAMPLER1D(FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE), FetchHistorySamples)
-#endif
-
-FfxFloat32x4 WrapLockStatus(FfxInt32x2 iPxSample)
-{
-    FfxFloat32x4 fSample = FfxFloat32x4(LoadLockStatus(iPxSample), 0.0f, 0.0f);
-    return fSample;
-}
-
-#if FFX_HALF
-FFX_MIN16_F4 WrapLockStatus(FFX_MIN16_I2 iPxSample)
-{
-    FFX_MIN16_F4 fSample = FFX_MIN16_F4(LoadLockStatus(iPxSample), 0.0, 0.0);
-
-    return fSample;
-}
-#endif
-
-#if 1
-#if FFX_FSR2_OPTION_REPROJECT_SAMPLERS_USE_DATA_HALF && FFX_HALF
-DeclareCustomFetchBilinearSamplesMin16(FetchLockStatusSamples, WrapLockStatus)
-DeclareCustomTextureSampleMin16(LockStatusSample, Bilinear, FetchLockStatusSamples)
-#else
-DeclareCustomFetchBilinearSamples(FetchLockStatusSamples, WrapLockStatus)
-DeclareCustomTextureSample(LockStatusSample, Bilinear, FetchLockStatusSamples)
-#endif
-#else
-#if FFX_FSR2_OPTION_REPROJECT_SAMPLERS_USE_DATA_HALF && FFX_HALF
-DeclareCustomFetchBicubicSamplesMin16(FetchLockStatusSamples, WrapLockStatus)
-DeclareCustomTextureSampleMin16(LockStatusSample, FFX_FSR2_GET_LANCZOS_SAMPLER1D(FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE), FetchLockStatusSamples)
-#else
-DeclareCustomFetchBicubicSamples(FetchLockStatusSamples, WrapLockStatus)
-DeclareCustomTextureSample(LockStatusSample, FFX_FSR2_GET_LANCZOS_SAMPLER1D(FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE), FetchLockStatusSamples)
-#endif
-#endif
-
-FfxFloat32x2 GetMotionVector(FfxInt32x2 iPxHrPos, FfxFloat32x2 fHrUv)
-{
-#if FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-    FfxFloat32x2 fDilatedMotionVector = LoadDilatedMotionVector(FFX_MIN16_I2(fHrUv * RenderSize()));
-#else
-    FfxFloat32x2 fDilatedMotionVector = LoadInputMotionVector(iPxHrPos);
-#endif
-
-    return fDilatedMotionVector;
-}
-
-FfxBoolean IsUvInside(FfxFloat32x2 fUv)
-{
-    return (fUv.x >= 0.0f && fUv.x <= 1.0f) && (fUv.y >= 0.0f && fUv.y <= 1.0f);
-}
-
-void ComputeReprojectedUVs(const AccumulationPassCommonParams params, FFX_PARAMETER_OUT FfxFloat32x2 fReprojectedHrUv, FFX_PARAMETER_OUT FfxBoolean bIsExistingSample)
-{
-    fReprojectedHrUv = params.fHrUv + params.fMotionVector;
-
-    bIsExistingSample = IsUvInside(fReprojectedHrUv);
-}
-
-void ReprojectHistoryColor(const AccumulationPassCommonParams params, FFX_PARAMETER_OUT FfxFloat32x3 fHistoryColor, FFX_PARAMETER_OUT FfxFloat32 fTemporalReactiveFactor, FFX_PARAMETER_OUT FfxBoolean bInMotionLastFrame)
-{
-    FfxFloat32x4 fHistory = HistorySample(params.fReprojectedHrUv, DisplaySize());
-
-    fHistoryColor = PrepareRgb(fHistory.rgb, Exposure(), PreviousFramePreExposure());
-
-    fHistoryColor = RGBToYCoCg(fHistoryColor);
-
-    //Compute temporal reactivity info
-    fTemporalReactiveFactor = ffxSaturate(abs(fHistory.w));
-    bInMotionLastFrame = (fHistory.w < 0.0f);
-}
-
-LockState ReprojectHistoryLockStatus(const AccumulationPassCommonParams params, FFX_PARAMETER_OUT FfxFloat32x2 fReprojectedLockStatus)
-{
-    LockState state = { FFX_FALSE, FFX_FALSE };
-    const FfxFloat32 fNewLockIntensity = LoadRwNewLocks(params.iPxHrPos);
-    state.NewLock = fNewLockIntensity > (127.0f / 255.0f);
-
-    FfxFloat32 fInPlaceLockLifetime = state.NewLock ? fNewLockIntensity : 0;
-
-    fReprojectedLockStatus = SampleLockStatus(params.fReprojectedHrUv);
-
-    if (fReprojectedLockStatus[LOCK_LIFETIME_REMAINING] != FfxFloat32(0.0f)) {
-        state.WasLockedPrevFrame = true;
-    }
-
-    return state;
-}
-
-#endif //!defined( FFX_FSR2_REPROJECT_H )

Assets/Resources/FSR2/shaders/ffx_fsr2_reproject.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: 63fc917ca6895cb4aac237ea35edb838
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_resources.h

@@ -1,105 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef FFX_FSR2_RESOURCES_H
-#define FFX_FSR2_RESOURCES_H
-
-#if defined(FFX_CPU) || defined(FFX_GPU)
-#define FFX_FSR2_RESOURCE_IDENTIFIER_NULL                                           0
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_OPAQUE_ONLY                              1
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_COLOR                                    2
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_MOTION_VECTORS                           3
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_DEPTH                                    4
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_EXPOSURE                                 5
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_REACTIVE_MASK                            6
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INPUT_TRANSPARENCY_AND_COMPOSITION_MASK        7
-#define FFX_FSR2_RESOURCE_IDENTIFIER_RECONSTRUCTED_PREVIOUS_NEAREST_DEPTH           8
-#define FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_MOTION_VECTORS                         9
-#define FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_DEPTH                                  10
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR                        11
-#define FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS                                    12
-#define FFX_FSR2_RESOURCE_IDENTIFIER_NEW_LOCKS                                      13
-#define FFX_FSR2_RESOURCE_IDENTIFIER_PREPARED_INPUT_COLOR                           14
-#define FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY                                   15
-#define FFX_FSR2_RESOURCE_IDENTIFIER_DEBUG_OUTPUT                                   16
-#define FFX_FSR2_RESOURCE_IDENTIFIER_LANCZOS_LUT                                    17
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SPD_ATOMIC_COUNT                               18
-#define FFX_FSR2_RESOURCE_IDENTIFIER_UPSCALED_OUTPUT                                19
-#define FFX_FSR2_RESOURCE_IDENTIFIER_RCAS_INPUT                                     20
-#define FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS_1                                  21
-#define FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_STATUS_2                                  22
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_1                      23
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_UPSCALED_COLOR_2                      24
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_REACTIVITY                    25
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_TRANSPARENCY_AND_COMPOSITION  26
-#define FFX_FSR2_RESOURCE_IDENTITIER_UPSAMPLE_MAXIMUM_BIAS_LUT                      27
-#define FFX_FSR2_RESOURCE_IDENTIFIER_DILATED_REACTIVE_MASKS                         28
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE                                29 // same as FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_0
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_0                       29
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_1                       30
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_2                       31
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_3                       32
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_4                       33
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_5                       34
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_6                       35
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_7                       36
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_8                       37
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_9                       38
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_10                      39
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_11                      40
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_12                      41
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DEFAULT_EXPOSURE                      42
-#define FFX_FSR2_RESOURCE_IDENTIFIER_AUTO_EXPOSURE                                  43
-#define FFX_FSR2_RESOURCE_IDENTIFIER_AUTOREACTIVE                                   44
-#define FFX_FSR2_RESOURCE_IDENTIFIER_AUTOCOMPOSITION                                45
-
-#define FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR                           46
-#define FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR                          47
-#define FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR_1                         48
-#define FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR_1                        49
-#define FFX_FSR2_RESOURCE_IDENTIFIER_PREV_PRE_ALPHA_COLOR_2                         50
-#define FFX_FSR2_RESOURCE_IDENTIFIER_PREV_POST_ALPHA_COLOR_2                        51
-#define FFX_FSR2_RESOURCE_IDENTIFIER_PREVIOUS_DILATED_MOTION_VECTORS                52
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DILATED_MOTION_VECTORS_1              53
-#define FFX_FSR2_RESOURCE_IDENTIFIER_INTERNAL_DILATED_MOTION_VECTORS_2              54
-#define FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY_1                                 55
-#define FFX_FSR2_RESOURCE_IDENTIFIER_LUMA_HISTORY_2                                 56
-#define FFX_FSR2_RESOURCE_IDENTIFIER_LOCK_INPUT_LUMA                                57
-
-// Shading change detection mip level setting, value must be in the range [FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_0, FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_12]
-#define FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_SHADING_CHANGE          FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_4
-#define FFX_FSR2_SHADING_CHANGE_MIP_LEVEL                                           (FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE_MIPMAP_SHADING_CHANGE - FFX_FSR2_RESOURCE_IDENTIFIER_SCENE_LUMINANCE)
-
-#define FFX_FSR2_RESOURCE_IDENTIFIER_COUNT                                          58
-
-#define FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_FSR2                                     0
-#define FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_SPD                                      1
-#define FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_RCAS                                     2
-#define FFX_FSR2_CONSTANTBUFFER_IDENTIFIER_GENREACTIVE                              3
-
-#define FFX_FSR2_AUTOREACTIVEFLAGS_APPLY_TONEMAP                                    1
-#define FFX_FSR2_AUTOREACTIVEFLAGS_APPLY_INVERSETONEMAP                             2
-#define FFX_FSR2_AUTOREACTIVEFLAGS_APPLY_THRESHOLD                                  4
-#define FFX_FSR2_AUTOREACTIVEFLAGS_USE_COMPONENTS_MAX                               8
-
-#endif // #if defined(FFX_CPU) || defined(FFX_GPU)
-
-#endif //!defined( FFX_FSR2_RESOURCES_H )

Assets/Resources/FSR2/shaders/ffx_fsr2_resources.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: fd5bed2bf4ba07444ae815390168a15d
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_sample.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: ba3ee190167b6c240aaeb1f8f4dbcb67
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_tcr_autogen.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: 18b8590c99b171a4e9af68dfd2c3ff02
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_tcr_autogen_pass.hlsl.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 9feb1fa4d6cff5a4799298dc69b12a8e
-ShaderIncludeImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Resources/FSR2/shaders/ffx_fsr2_upsample.h

@@ -1,194 +0,0 @@
-// This file is part of the FidelityFX SDK.
-//
-// Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef FFX_FSR2_UPSAMPLE_H
-#define FFX_FSR2_UPSAMPLE_H
-
-FFX_STATIC const FfxUInt32 iLanczos2SampleCount = 16;
-
-void Deringing(RectificationBox clippingBox, FFX_PARAMETER_INOUT FfxFloat32x3 fColor)
-{
-    fColor = clamp(fColor, clippingBox.aabbMin, clippingBox.aabbMax);
-}
-#if FFX_HALF
-void Deringing(RectificationBoxMin16 clippingBox, FFX_PARAMETER_INOUT FFX_MIN16_F3 fColor)
-{
-    fColor = clamp(fColor, clippingBox.aabbMin, clippingBox.aabbMax);
-}
-#endif
-
-#ifndef FFX_FSR2_OPTION_UPSAMPLE_USE_LANCZOS_TYPE
-#define FFX_FSR2_OPTION_UPSAMPLE_USE_LANCZOS_TYPE 2 // Approximate
-#endif
-
-FfxFloat32 GetUpsampleLanczosWeight(FfxFloat32x2 fSrcSampleOffset, FfxFloat32 fKernelWeight)
-{
-    FfxFloat32x2 fSrcSampleOffsetBiased = fSrcSampleOffset * fKernelWeight.xx;
-#if FFX_FSR2_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 0 // LANCZOS_TYPE_REFERENCE
-    FfxFloat32 fSampleWeight = Lanczos2(length(fSrcSampleOffsetBiased));
-#elif FFX_FSR2_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 1 // LANCZOS_TYPE_LUT
-    FfxFloat32 fSampleWeight = Lanczos2_UseLUT(length(fSrcSampleOffsetBiased));
-#elif FFX_FSR2_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2 // LANCZOS_TYPE_APPROXIMATE
-    FfxFloat32 fSampleWeight = Lanczos2ApproxSq(dot(fSrcSampleOffsetBiased, fSrcSampleOffsetBiased));
-#else
-#error "Invalid Lanczos type"
-#endif
-    return fSampleWeight;
-}
-
-#if FFX_HALF
-FFX_MIN16_F GetUpsampleLanczosWeight(FFX_MIN16_F2 fSrcSampleOffset, FFX_MIN16_F fKernelWeight)
-{
-    FFX_MIN16_F2 fSrcSampleOffsetBiased = fSrcSampleOffset * fKernelWeight.xx;
-#if FFX_FSR2_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 0 // LANCZOS_TYPE_REFERENCE
-    FFX_MIN16_F fSampleWeight = Lanczos2(length(fSrcSampleOffsetBiased));
-#elif FFX_FSR2_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 1 // LANCZOS_TYPE_LUT
-    FFX_MIN16_F fSampleWeight = Lanczos2_UseLUT(length(fSrcSampleOffsetBiased));
-#elif FFX_FSR2_OPTION_UPSAMPLE_USE_LANCZOS_TYPE == 2 // LANCZOS_TYPE_APPROXIMATE
-    FFX_MIN16_F fSampleWeight = Lanczos2ApproxSq(dot(fSrcSampleOffsetBiased, fSrcSampleOffsetBiased));
-
-    // To Test: Save reciproqual sqrt compute
-    // FfxFloat32 fSampleWeight = Lanczos2Sq_UseLUT(dot(fSrcSampleOffsetBiased, fSrcSampleOffsetBiased));
-#else
-#error "Invalid Lanczos type"
-#endif
-    return fSampleWeight;
-}
-#endif
-
-FfxFloat32 ComputeMaxKernelWeight() {
-    const FfxFloat32 fKernelSizeBias = 1.0f;
-
-    FfxFloat32 fKernelWeight = FfxFloat32(1) + (FfxFloat32(1.0f) / FfxFloat32x2(DownscaleFactor()) - FfxFloat32(1)).x * FfxFloat32(fKernelSizeBias);
-
-    return ffxMin(FfxFloat32(1.99f), fKernelWeight);
-}
-
-FfxFloat32x4 ComputeUpsampledColorAndWeight(const AccumulationPassCommonParams params,
-    FFX_PARAMETER_INOUT RectificationBox clippingBox, FfxFloat32 fReactiveFactor)
-{
-    #if FFX_FSR2_OPTION_UPSAMPLE_SAMPLERS_USE_DATA_HALF && FFX_HALF
-    #include "ffx_fsr2_force16_begin.h"
-    #endif
-    // We compute a sliced lanczos filter with 2 lobes (other slices are accumulated temporaly)
-    FfxFloat32x2 fDstOutputPos = FfxFloat32x2(params.iPxHrPos) + FFX_BROADCAST_FLOAT32X2(0.5f);      // Destination resolution output pixel center position
-    FfxFloat32x2 fSrcOutputPos = fDstOutputPos * DownscaleFactor();                   // Source resolution output pixel center position
-    FfxInt32x2 iSrcInputPos = FfxInt32x2(floor(fSrcOutputPos));                     // TODO: what about weird upscale factors...
-
-    #if FFX_FSR2_OPTION_UPSAMPLE_SAMPLERS_USE_DATA_HALF && FFX_HALF
-    #include "ffx_fsr2_force16_end.h"
-    #endif
-
-    FfxFloat32x3 fSamples[iLanczos2SampleCount];
-
-    FfxFloat32x2 fSrcUnjitteredPos = (FfxFloat32x2(iSrcInputPos) + FfxFloat32x2(0.5f, 0.5f)) - Jitter(); // This is the un-jittered position of the sample at offset 0,0
-
-    FfxInt32x2 offsetTL;
-    offsetTL.x = (fSrcUnjitteredPos.x > fSrcOutputPos.x) ? FfxInt32(-2) : FfxInt32(-1);
-    offsetTL.y = (fSrcUnjitteredPos.y > fSrcOutputPos.y) ? FfxInt32(-2) : FfxInt32(-1);
-
-    //Load samples
-    // If fSrcUnjitteredPos.y > fSrcOutputPos.y, indicates offsetTL.y = -2, sample offset Y will be [-2, 1], clipbox will be rows [1, 3].
-    // Flip row# for sampling offset in this case, so first 0~2 rows in the sampled array can always be used for computing the clipbox.
-    // This reduces branch or cmove on sampled colors, but moving this overhead to sample position / weight calculation time which apply to less values.
-    const FfxBoolean bFlipRow = fSrcUnjitteredPos.y > fSrcOutputPos.y;
-    const FfxBoolean bFlipCol = fSrcUnjitteredPos.x > fSrcOutputPos.x;
-
-    FfxFloat32x2 fOffsetTL = FfxFloat32x2(offsetTL);
-
-    FFX_UNROLL
-    for (FfxInt32 row = 0; row < 3; row++) {
-
-        FFX_UNROLL
-            for (FfxInt32 col = 0; col < 3; col++) {
-                FfxInt32 iSampleIndex = col + (row << 2);
-
-                FfxInt32x2 sampleColRow = FfxInt32x2(bFlipCol ? (3 - col) : col, bFlipRow ? (3 - row) : row);
-                FfxInt32x2 iSrcSamplePos = FfxInt32x2(iSrcInputPos) + offsetTL + sampleColRow;
-
-                const FfxInt32x2 sampleCoord = ClampLoad(iSrcSamplePos, FfxInt32x2(0, 0), FfxInt32x2(RenderSize()));
-
-                fSamples[iSampleIndex] = LoadPreparedInputColor(FfxInt32x2(sampleCoord));
-            }
-    }
-
-    FfxFloat32x4 fColorAndWeight = FfxFloat32x4(0.0f, 0.0f, 0.0f, 0.0f);
-
-    FfxFloat32x2 fBaseSampleOffset = FfxFloat32x2(fSrcUnjitteredPos - fSrcOutputPos);
-
-    // Identify how much of each upsampled color to be used for this frame
-    const FfxFloat32 fKernelReactiveFactor = ffxMax(fReactiveFactor, FfxFloat32(params.bIsNewSample));
-    const FfxFloat32 fKernelBiasMax = ComputeMaxKernelWeight() * (1.0f - fKernelReactiveFactor);
-
-    const FfxFloat32 fKernelBiasMin = ffxMax(1.0f, ((1.0f + fKernelBiasMax) * 0.3f));
-    const FfxFloat32 fKernelBiasFactor = ffxMax(0.0f, ffxMax(0.25f * params.fDepthClipFactor, fKernelReactiveFactor));
-    const FfxFloat32 fKernelBias = ffxLerp(fKernelBiasMax, fKernelBiasMin, fKernelBiasFactor);
-
-    const FfxFloat32 fRectificationCurveBias = ffxLerp(-2.0f, -3.0f, ffxSaturate(params.fHrVelocity / 50.0f));
-
-    FFX_UNROLL
-    for (FfxInt32 row = 0; row < 3; row++) {
-        FFX_UNROLL
-        for (FfxInt32 col = 0; col < 3; col++) {
-            FfxInt32 iSampleIndex = col + (row << 2);
-
-            const FfxInt32x2 sampleColRow = FfxInt32x2(bFlipCol ? (3 - col) : col, bFlipRow ? (3 - row) : row);
-            const FfxFloat32x2 fOffset = fOffsetTL + FfxFloat32x2(sampleColRow);
-            FfxFloat32x2 fSrcSampleOffset = fBaseSampleOffset + fOffset;
-
-            FfxInt32x2 iSrcSamplePos = FfxInt32x2(iSrcInputPos) + FfxInt32x2(offsetTL) + sampleColRow;
-
-            const FfxFloat32 fOnScreenFactor = FfxFloat32(IsOnScreen(FfxInt32x2(iSrcSamplePos), FfxInt32x2(RenderSize())));
-            FfxFloat32 fSampleWeight = fOnScreenFactor * FfxFloat32(GetUpsampleLanczosWeight(fSrcSampleOffset, fKernelBias));
-
-            fColorAndWeight += FfxFloat32x4(fSamples[iSampleIndex] * fSampleWeight, fSampleWeight);
-
-            // Update rectification box
-            {
-                const FfxFloat32 fSrcSampleOffsetSq = dot(fSrcSampleOffset, fSrcSampleOffset);
-                const FfxFloat32 fBoxSampleWeight = exp(fRectificationCurveBias * fSrcSampleOffsetSq);
-
-                const FfxBoolean bInitialSample = (row == 0) && (col == 0);
-                RectificationBoxAddSample(bInitialSample, clippingBox, fSamples[iSampleIndex], fBoxSampleWeight);
-            }
-        }
-    }
-
-    RectificationBoxComputeVarianceBoxData(clippingBox);
-
-    fColorAndWeight.w *= FfxFloat32(fColorAndWeight.w > FSR2_EPSILON);
-
-    if (fColorAndWeight.w > FSR2_EPSILON) {
-        // Normalize for deringing (we need to compare colors)
-        fColorAndWeight.xyz = fColorAndWeight.xyz / fColorAndWeight.w;
-        fColorAndWeight.w *= fUpsampleLanczosWeightScale;
-
-        Deringing(clippingBox, fColorAndWeight.xyz);
-    }
-
-    #if FFX_FSR2_OPTION_UPSAMPLE_SAMPLERS_USE_DATA_HALF && FFX_HALF
-    #include "ffx_fsr2_force16_end.h"
-    #endif
-
-    return fColorAndWeight;
-}
-
-#endif //!defined( FFX_FSR2_UPSAMPLE_H )

Assets/Resources/FSR2/shaders/ffx_fsr2_upsample.h.meta

@@ -1,60 +0,0 @@
-fileFormatVersion: 2
-guid: 1ff3a385cfe07db4387e4d7b457238f8
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      : Any
-    second:
-      enabled: 0
-      settings:
-        Exclude Editor: 1
-        Exclude GameCoreScarlett: 1
-        Exclude GameCoreXboxOne: 1
-        Exclude Linux64: 1
-        Exclude OSXUniversal: 1
-        Exclude PS4: 1
-        Exclude PS5: 1
-        Exclude WebGL: 1
-        Exclude Win: 1
-        Exclude Win64: 1
-  - first:
-      Any: 
-    second:
-      enabled: 0
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Standalone: Linux64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  - first:
-      Standalone: Win64
-    second:
-      enabled: 0
-      settings:
-        CPU: None
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scenes/SampleScene.unity

@@ -337,7 +337,7 @@ MonoBehaviour:
     autoTcScale: 1
     autoReactiveScale: 5
     autoReactiveMax: 0.9
-  outputMotionVectors: {fileID: 0}
+  assets: {fileID: 11400000, guid: 4151befafd86e8740ab09463b4f1bdbb, type: 2}
 --- !u!114 &963194230
 MonoBehaviour:
   m_ObjectHideFlags: 0

Assets/Resources/FSR2.meta → Assets/Scenes/SampleSceneTwoCamera_Profiles.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: cad7d53fa2166a0449bec7a9b4f17d69
+guid: eb14106c650eeca49808390291b2f028
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Assets/Scripts/Core/Fsr2Pass.cs

@@ -1,396 +0,0 @@
-// Copyright (c) 2023 Nico de Poel
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-using System;
-using System.Runtime.InteropServices;
-using UnityEngine;
-using UnityEngine.Rendering;
-
-namespace FidelityFX
-{
-    /// <summary>
-    /// Base class for all of the compute passes that make up the FSR2 process.
-    /// This loosely matches the FfxPipelineState struct from the original FSR2 codebase, wrapped in an object-oriented blanket.
-    /// These classes are responsible for loading compute shaders, managing temporary resources, binding resources to shader kernels and dispatching said shaders.
-    /// </summary>
-    internal abstract class Fsr2Pass: IDisposable
-    {
-        internal const int ShadingChangeMipLevel = 4;   // This matches the FFX_FSR2_SHADING_CHANGE_MIP_LEVEL define
-
-        protected readonly Fsr2.ContextDescription ContextDescription;
-        protected readonly Fsr2Resources Resources;
-        protected readonly ComputeBuffer Constants;
-        
-        protected ComputeShader ComputeShader;
-        protected int KernelIndex;
-        
-        protected virtual bool AllowFP16 => true;
-
-        protected Fsr2Pass(Fsr2.ContextDescription contextDescription, Fsr2Resources resources, ComputeBuffer constants)
-        {
-            ContextDescription = contextDescription;
-            Resources = resources;
-            Constants = constants;
-        }
-
-        public virtual void Dispose()
-        {
-            UnloadComputeShader();
-        }
-
-        public abstract void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY);
-
-        protected void LoadComputeShader(string name)
-        {
-            LoadComputeShader(name, ContextDescription.Flags, ref ComputeShader, out KernelIndex);
-        }
-        
-        private void LoadComputeShader(string name, Fsr2.InitializationFlags flags, ref ComputeShader shaderRef, out int kernelIndex)
-        {
-            if (shaderRef == null)
-            {
-                shaderRef = ContextDescription.Callbacks.LoadComputeShader(name);
-                if (shaderRef == null)
-                    throw new MissingReferenceException($"Shader '{name}' could not be loaded! Please ensure it is included in the project correctly.");
-            }
-
-            kernelIndex = shaderRef.FindKernel("CS");
-
-            bool useLut = false;
-#if UNITY_2022_1_OR_NEWER   // This will also work in 2020.3.43+ and 2021.3.14+ 
-            if (SystemInfo.computeSubGroupSize == 64)
-            {
-                useLut = true;
-            }
-#endif
-            
-            // Allow 16-bit floating point as a configuration option, except on passes that explicitly disable it
-            bool supportedFP16 = ((flags & Fsr2.InitializationFlags.EnableFP16Usage) != 0 && AllowFP16);
-
-            // This matches the permutation rules from the CreatePipeline* functions
-            if ((flags & Fsr2.InitializationFlags.EnableHighDynamicRange) != 0) shaderRef.EnableKeyword("FFX_FSR2_OPTION_HDR_COLOR_INPUT");
-            if ((flags & Fsr2.InitializationFlags.EnableDisplayResolutionMotionVectors) == 0) shaderRef.EnableKeyword("FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS");
-            if ((flags & Fsr2.InitializationFlags.EnableMotionVectorsJitterCancellation) != 0) shaderRef.EnableKeyword("FFX_FSR2_OPTION_JITTERED_MOTION_VECTORS");
-            if ((flags & Fsr2.InitializationFlags.EnableDepthInverted) != 0) shaderRef.EnableKeyword("FFX_FSR2_OPTION_INVERTED_DEPTH");
-            if (useLut) shaderRef.EnableKeyword("FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE");
-            if (supportedFP16) shaderRef.EnableKeyword("FFX_HALF");
-
-            // Inform the shader which render pipeline we're currently using
-            var pipeline = GraphicsSettings.currentRenderPipeline;
-            if (pipeline != null && pipeline.GetType().Name.Contains("HDRenderPipeline"))
-            {
-                shaderRef.EnableKeyword("UNITY_FSR2_HDRP");
-            }
-        }
-
-        private void UnloadComputeShader()
-        {
-            UnloadComputeShader(ref ComputeShader);
-        }
-        
-        private void UnloadComputeShader(ref ComputeShader shaderRef)
-        {
-            if (shaderRef == null)
-                return;
-
-            ContextDescription.Callbacks.UnloadComputeShader(shaderRef);
-            shaderRef = null;
-        }
-    }
-
-    internal class Fsr2ComputeLuminancePyramidPass : Fsr2Pass
-    {
-        private readonly ComputeBuffer _spdConstants;
-        
-        public Fsr2ComputeLuminancePyramidPass(Fsr2.ContextDescription contextDescription, Fsr2Resources resources, ComputeBuffer constants, ComputeBuffer spdConstants)
-            : base(contextDescription, resources, constants)
-        {
-            _spdConstants = spdConstants;
-            
-            LoadComputeShader("FSR2/ffx_fsr2_compute_luminance_pyramid_pass");
-        }
-
-        public override void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
-        {
-            ref var color = ref dispatchParams.Color;
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputColor, color.RenderTarget, color.MipLevel, color.SubElement);
-
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavSpdAtomicCount, Resources.SpdAtomicCounter);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavExposureMipLumaChange, Resources.SceneLuminance, ShadingChangeMipLevel);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavExposureMip5, Resources.SceneLuminance, 5);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavAutoExposure, Resources.AutoExposure);
-
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbFsr2, Constants, 0, Marshal.SizeOf<Fsr2.Fsr2Constants>());
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbSpd, _spdConstants, 0, Marshal.SizeOf<Fsr2.SpdConstants>());
-            
-            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
-        }
-    }
-
-    internal class Fsr2ReconstructPreviousDepthPass : Fsr2Pass
-    {
-        public Fsr2ReconstructPreviousDepthPass(Fsr2.ContextDescription contextDescription, Fsr2Resources resources, ComputeBuffer constants)
-            : base(contextDescription, resources, constants)
-        {
-            LoadComputeShader("FSR2/ffx_fsr2_reconstruct_previous_depth_pass");
-        }
-
-        public override void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
-        {
-            ref var color = ref dispatchParams.Color;
-            ref var depth = ref dispatchParams.Depth;
-            ref var motionVectors = ref dispatchParams.MotionVectors;
-            ref var exposure = ref dispatchParams.Exposure;
-            
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputColor, color.RenderTarget, color.MipLevel, color.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputDepth, depth.RenderTarget, depth.MipLevel, depth.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputMotionVectors, motionVectors.RenderTarget, motionVectors.MipLevel, motionVectors.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputExposure, exposure.RenderTarget, exposure.MipLevel, exposure.SubElement);
-
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavDilatedMotionVectors, Resources.DilatedMotionVectors[frameIndex]);
-            
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbFsr2, Constants, 0, Marshal.SizeOf<Fsr2.Fsr2Constants>());
-            
-            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
-        }
-    }
-    
-    internal class Fsr2DepthClipPass : Fsr2Pass
-    {
-        public Fsr2DepthClipPass(Fsr2.ContextDescription contextDescription, Fsr2Resources resources, ComputeBuffer constants)
-            : base(contextDescription, resources, constants)
-        {
-            LoadComputeShader("FSR2/ffx_fsr2_depth_clip_pass");
-        }
-
-        public override void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
-        {
-            ref var color = ref dispatchParams.Color;
-            ref var depth = ref dispatchParams.Depth;
-            ref var motionVectors = ref dispatchParams.MotionVectors;
-            ref var exposure = ref dispatchParams.Exposure;
-            ref var reactive = ref dispatchParams.Reactive;
-            ref var tac = ref dispatchParams.TransparencyAndComposition;
-            
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputColor, color.RenderTarget, color.MipLevel, color.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputDepth, depth.RenderTarget, depth.MipLevel, depth.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputMotionVectors, motionVectors.RenderTarget, motionVectors.MipLevel, motionVectors.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputExposure, exposure.RenderTarget, exposure.MipLevel, exposure.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvReactiveMask, reactive.RenderTarget, reactive.MipLevel, reactive.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvTransparencyAndCompositionMask, tac.RenderTarget, tac.MipLevel, tac.SubElement);
-
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvReconstructedPrevNearestDepth, Fsr2ShaderIDs.UavReconstructedPrevNearestDepth);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvDilatedMotionVectors, Resources.DilatedMotionVectors[frameIndex]);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvDilatedDepth, Fsr2ShaderIDs.UavDilatedDepth);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvPrevDilatedMotionVectors, Resources.DilatedMotionVectors[frameIndex ^ 1]);
-
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbFsr2, Constants, 0, Marshal.SizeOf<Fsr2.Fsr2Constants>());
-            
-            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
-        }
-    }
-
-    internal class Fsr2LockPass : Fsr2Pass
-    {
-        public Fsr2LockPass(Fsr2.ContextDescription contextDescription, Fsr2Resources resources, ComputeBuffer constants)
-            : base(contextDescription, resources, constants)
-        {
-            LoadComputeShader("FSR2/ffx_fsr2_lock_pass");
-        }
-
-        public override void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
-        {
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvLockInputLuma, Fsr2ShaderIDs.UavLockInputLuma);
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbFsr2, Constants, 0, Marshal.SizeOf<Fsr2.Fsr2Constants>());
-            
-            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
-        }
-    }
-    
-    internal class Fsr2AccumulatePass : Fsr2Pass
-    {
-        private const string SharpeningKeyword = "FFX_FSR2_OPTION_APPLY_SHARPENING";
-        
-        // Workaround: Disable FP16 path for the accumulate pass on NVIDIA due to reduced occupancy and high VRAM throughput.
-        protected override bool AllowFP16 => SystemInfo.graphicsDeviceVendorID != 0x10DE;
-    
-#if UNITY_2021_2_OR_NEWER
-        private readonly LocalKeyword _sharpeningKeyword;
-#endif
-        
-        public Fsr2AccumulatePass(Fsr2.ContextDescription contextDescription, Fsr2Resources resources, ComputeBuffer constants)
-            : base(contextDescription, resources, constants)
-        {
-            LoadComputeShader("FSR2/ffx_fsr2_accumulate_pass");
-#if UNITY_2021_2_OR_NEWER
-            _sharpeningKeyword = new LocalKeyword(ComputeShader, SharpeningKeyword);
-#endif
-        }
-
-        public override void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
-        {
-#if UNITY_2021_2_OR_NEWER
-            if (dispatchParams.EnableSharpening)
-                commandBuffer.EnableKeyword(ComputeShader, _sharpeningKeyword);
-            else
-                commandBuffer.DisableKeyword(ComputeShader, _sharpeningKeyword);
-#else
-            if (dispatchParams.EnableSharpening)
-                commandBuffer.EnableShaderKeyword(SharpeningKeyword);
-            else
-                commandBuffer.DisableShaderKeyword(SharpeningKeyword);
-#endif
-            
-            if ((ContextDescription.Flags & Fsr2.InitializationFlags.EnableDisplayResolutionMotionVectors) == 0)
-            {
-                commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvDilatedMotionVectors, Resources.DilatedMotionVectors[frameIndex]);
-            }
-            else
-            {
-                ref var motionVectors = ref dispatchParams.MotionVectors;
-                commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputMotionVectors, motionVectors.RenderTarget, motionVectors.MipLevel, motionVectors.SubElement);
-            }
-
-            ref var exposure = ref dispatchParams.Exposure;
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputExposure, exposure.RenderTarget, exposure.MipLevel, exposure.SubElement);
-
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvDilatedReactiveMasks, Fsr2ShaderIDs.UavDilatedReactiveMasks);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInternalUpscaled, Resources.InternalUpscaled[frameIndex ^ 1]);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvLockStatus, Resources.LockStatus[frameIndex ^ 1]);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvPreparedInputColor, Fsr2ShaderIDs.UavPreparedInputColor);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvLanczosLut, Resources.LanczosLut);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvUpscaleMaximumBiasLut, Resources.MaximumBiasLut);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvSceneLuminanceMips, Resources.SceneLuminance);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvAutoExposure, Resources.AutoExposure);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvLumaHistory, Resources.LumaHistory[frameIndex ^ 1]);
-
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavInternalUpscaled, Resources.InternalUpscaled[frameIndex]);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavLockStatus, Resources.LockStatus[frameIndex]);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavLumaHistory, Resources.LumaHistory[frameIndex]);
-            
-            ref var output = ref dispatchParams.Output;
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavUpscaledOutput, output.RenderTarget, output.MipLevel, output.SubElement);
-
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbFsr2, Constants, 0, Marshal.SizeOf<Fsr2.Fsr2Constants>());
-            
-            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
-        }
-    }
-
-    internal class Fsr2RcasPass : Fsr2Pass
-    {
-        private readonly ComputeBuffer _rcasConstants;
-
-        public Fsr2RcasPass(Fsr2.ContextDescription contextDescription, Fsr2Resources resources, ComputeBuffer constants, ComputeBuffer rcasConstants)
-            : base(contextDescription, resources, constants)
-        {
-            _rcasConstants = rcasConstants;
-            
-            LoadComputeShader("FSR2/ffx_fsr2_rcas_pass");
-        }
-
-        public override void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
-        {
-            ref var exposure = ref dispatchParams.Exposure;
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputExposure, exposure.RenderTarget, exposure.MipLevel, exposure.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvRcasInput, Resources.InternalUpscaled[frameIndex]);
-            
-            ref var output = ref dispatchParams.Output;
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavUpscaledOutput, output.RenderTarget, output.MipLevel, output.SubElement);
-
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbFsr2, Constants, 0, Marshal.SizeOf<Fsr2.Fsr2Constants>());
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbRcas, _rcasConstants, 0, Marshal.SizeOf<Fsr2.RcasConstants>());
-
-            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
-        }
-    }
-
-    internal class Fsr2GenerateReactivePass : Fsr2Pass
-    {
-        private readonly ComputeBuffer _generateReactiveConstants;
-
-        public Fsr2GenerateReactivePass(Fsr2.ContextDescription contextDescription, Fsr2Resources resources, ComputeBuffer generateReactiveConstants)
-            : base(contextDescription, resources, null)
-        {
-            _generateReactiveConstants = generateReactiveConstants;
-            
-            LoadComputeShader("FSR2/ffx_fsr2_autogen_reactive_pass");
-        }
-
-        public override void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
-        {
-        }
-
-        public void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.GenerateReactiveDescription dispatchParams, int dispatchX, int dispatchY)
-        {
-            ref var opaqueOnly = ref dispatchParams.ColorOpaqueOnly;
-            ref var color = ref dispatchParams.ColorPreUpscale;
-            ref var reactive = ref dispatchParams.OutReactive;
-            
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvOpaqueOnly, opaqueOnly.RenderTarget, opaqueOnly.MipLevel, opaqueOnly.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputColor, color.RenderTarget, color.MipLevel, color.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavAutoReactive, reactive.RenderTarget, reactive.MipLevel, reactive.SubElement);
-            
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbGenReactive, _generateReactiveConstants, 0, Marshal.SizeOf<Fsr2.GenerateReactiveConstants>());
-            
-            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
-        }
-    }
-
-    internal class Fsr2TcrAutogeneratePass : Fsr2Pass
-    {
-        private readonly ComputeBuffer _tcrAutogenerateConstants;
-
-        public Fsr2TcrAutogeneratePass(Fsr2.ContextDescription contextDescription, Fsr2Resources resources, ComputeBuffer constants, ComputeBuffer tcrAutogenerateConstants)
-            : base(contextDescription, resources, constants)
-        {
-            _tcrAutogenerateConstants = tcrAutogenerateConstants;
-            
-            LoadComputeShader("FSR2/ffx_fsr2_tcr_autogen_pass");
-        }
-
-        public override void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
-        {
-            ref var color = ref dispatchParams.Color;
-            ref var motionVectors = ref dispatchParams.MotionVectors;
-            ref var opaqueOnly = ref dispatchParams.ColorOpaqueOnly;
-            ref var reactive = ref dispatchParams.Reactive;
-            ref var tac = ref dispatchParams.TransparencyAndComposition;
-            
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvOpaqueOnly, opaqueOnly.RenderTarget, opaqueOnly.MipLevel, opaqueOnly.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputColor, color.RenderTarget, color.MipLevel, color.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvInputMotionVectors, motionVectors.RenderTarget, motionVectors.MipLevel, motionVectors.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvPrevColorPreAlpha, Resources.PrevPreAlpha[frameIndex ^ 1]);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvPrevColorPostAlpha, Resources.PrevPostAlpha[frameIndex ^ 1]);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvReactiveMask, reactive.RenderTarget, reactive.MipLevel, reactive.SubElement);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.SrvTransparencyAndCompositionMask, tac.RenderTarget, tac.MipLevel, tac.SubElement);
-
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavAutoReactive, Resources.AutoReactive);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavAutoComposition, Resources.AutoComposition);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavPrevColorPreAlpha, Resources.PrevPreAlpha[frameIndex]);
-            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr2ShaderIDs.UavPrevColorPostAlpha, Resources.PrevPostAlpha[frameIndex]);
-            
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbFsr2, Constants, 0, Marshal.SizeOf<Fsr2.Fsr2Constants>());
-            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr2ShaderIDs.CbGenReactive, _tcrAutogenerateConstants, 0, Marshal.SizeOf<Fsr2.GenerateReactiveConstants2>());
-            
-            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
-        }
-    }
-}

Assets/Scripts/Core/Fsr2Resources.cs

@@ -1,251 +0,0 @@
-// Copyright (c) 2023 Nico de Poel
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-using System;
-using UnityEngine;
-using UnityEngine.Experimental.Rendering;
-using UnityEngine.Rendering;
-
-namespace FidelityFX
-{
-    /// <summary>
-    /// Helper class for bundling and managing persistent resources required by the FSR2 process.
-    /// This includes lookup tables, default fallback resources and double-buffered resources that get swapped between frames.
-    /// </summary>
-    internal class Fsr2Resources
-    {
-        public Texture2D DefaultExposure;
-        public Texture2D DefaultReactive;
-        public Texture2D LanczosLut;
-        public Texture2D MaximumBiasLut;
-        public RenderTexture SpdAtomicCounter;
-        public RenderTexture AutoExposure;
-        public RenderTexture SceneLuminance;
-        public RenderTexture AutoReactive;
-        public RenderTexture AutoComposition;
-        public readonly RenderTexture[] DilatedMotionVectors = new RenderTexture[2];
-        public readonly RenderTexture[] LockStatus = new RenderTexture[2];
-        public readonly RenderTexture[] InternalUpscaled = new RenderTexture[2];
-        public readonly RenderTexture[] LumaHistory = new RenderTexture[2];
-        public readonly RenderTexture[] PrevPreAlpha = new RenderTexture[2];
-        public readonly RenderTexture[] PrevPostAlpha = new RenderTexture[2];
-
-        public void Create(Fsr2.ContextDescription contextDescription)
-        {
-            // Generate the data for the LUT
-            const int lanczos2LutWidth = 128;
-            float[] lanczos2Weights = new float[lanczos2LutWidth];
-            for (int currentLanczosWidthIndex = 0; currentLanczosWidthIndex < lanczos2LutWidth; ++currentLanczosWidthIndex)
-            {
-                float x = 2.0f * currentLanczosWidthIndex / (lanczos2LutWidth - 1);
-                float y = Fsr2.Lanczos2(x);
-                lanczos2Weights[currentLanczosWidthIndex] = y;
-            }
-
-            float[] maximumBias = new float[MaximumBiasTextureWidth * MaximumBiasTextureHeight];
-            for (int i = 0; i < maximumBias.Length; ++i)
-            {
-                maximumBias[i] = MaximumBias[i] / 2.0f;
-            }
-
-            // Resource FSR2_LanczosLutData: FFX_RESOURCE_USAGE_READ_ONLY, FFX_SURFACE_FORMAT_R16_SNORM, FFX_RESOURCE_FLAGS_NONE
-            // R16_SNorm textures are not supported by Unity on most platforms, strangely enough. So instead we use R32_SFloat and upload pre-normalized float data.
-            LanczosLut = new Texture2D(lanczos2LutWidth, 1, GraphicsFormat.R32_SFloat, TextureCreationFlags.None) { name = "FSR2_LanczosLutData" };
-            LanczosLut.SetPixelData(lanczos2Weights, 0);
-            LanczosLut.Apply();
-            
-            // Resource FSR2_MaximumUpsampleBias: FFX_RESOURCE_USAGE_READ_ONLY, FFX_SURFACE_FORMAT_R16_SNORM, FFX_RESOURCE_FLAGS_NONE
-            MaximumBiasLut = new Texture2D(MaximumBiasTextureWidth, MaximumBiasTextureHeight, GraphicsFormat.R32_SFloat, TextureCreationFlags.None) { name = "FSR2_MaximumUpsampleBias" };
-            MaximumBiasLut.SetPixelData(maximumBias, 0);
-            MaximumBiasLut.Apply();
-            
-            // Resource FSR2_DefaultExposure: FFX_RESOURCE_USAGE_READ_ONLY, FFX_SURFACE_FORMAT_R32G32_FLOAT, FFX_RESOURCE_FLAGS_NONE
-            DefaultExposure = new Texture2D(1, 1, GraphicsFormat.R32G32_SFloat, TextureCreationFlags.None) { name = "FSR2_DefaultExposure" };
-            DefaultExposure.SetPixel(0, 0, Color.clear);
-            DefaultExposure.Apply();
-
-            // Resource FSR2_DefaultReactivityMask: FFX_RESOURCE_USAGE_READ_ONLY, FFX_SURFACE_FORMAT_R8_UNORM, FFX_RESOURCE_FLAGS_NONE
-            DefaultReactive = new Texture2D(1, 1, GraphicsFormat.R8_UNorm, TextureCreationFlags.None) { name = "FSR2_DefaultReactivityMask" };
-            DefaultReactive.SetPixel(0, 0, Color.clear);
-            DefaultReactive.Apply();
-            
-            // Resource FSR2_SpdAtomicCounter: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R32_UINT, FFX_RESOURCE_FLAGS_ALIASABLE
-            // Despite what the original FSR2 codebase says, this resource really isn't aliasable. Resetting this counter to 0 every frame breaks auto-exposure on MacOS Metal.
-            SpdAtomicCounter = new RenderTexture(1, 1, 0, GraphicsFormat.R32_UInt) { name = "FSR2_SpdAtomicCounter", enableRandomWrite = true };
-            SpdAtomicCounter.Create();
-
-            // Resource FSR2_AutoExposure: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R32G32_FLOAT, FFX_RESOURCE_FLAGS_NONE
-            AutoExposure = new RenderTexture(1, 1, 0, GraphicsFormat.R32G32_SFloat) { name = "FSR2_AutoExposure", enableRandomWrite = true };
-            AutoExposure.Create();
-            
-            // Resource FSR2_ExposureMips: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16_FLOAT, FFX_RESOURCE_FLAGS_ALIASABLE
-            // This is a rather special case: it's an aliasable resource, but because we require a mipmap chain and bind specific mip levels per shader, we can't easily use temporary RTs for this.
-            int w = contextDescription.MaxRenderSize.x / 2, h = contextDescription.MaxRenderSize.y / 2;
-            int mipCount = 1 + Mathf.FloorToInt(Mathf.Log(Math.Max(w, h), 2.0f));
-            SceneLuminance = new RenderTexture(w, h, 0, GraphicsFormat.R16_SFloat, mipCount) { name = "FSR2_ExposureMips", enableRandomWrite = true, useMipMap = true, autoGenerateMips = false };
-            SceneLuminance.Create();
-            
-            // Resources FSR2_InternalDilatedVelocity1/2: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16G16_FLOAT, FFX_RESOURCE_FLAGS_NONE
-            CreateDoubleBufferedResource(DilatedMotionVectors, "FSR2_InternalDilatedVelocity", contextDescription.MaxRenderSize, GraphicsFormat.R16G16_SFloat);
-            
-            // Resources FSR2_LockStatus1/2: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16G16_FLOAT, FFX_RESOURCE_FLAGS_NONE
-            CreateDoubleBufferedResource(LockStatus, "FSR2_LockStatus", contextDescription.DisplaySize, GraphicsFormat.R16G16_SFloat);
-            
-            // Resources FSR2_InternalUpscaled1/2: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, FFX_RESOURCE_FLAGS_NONE
-            CreateDoubleBufferedResource(InternalUpscaled, "FSR2_InternalUpscaled", contextDescription.DisplaySize, GraphicsFormat.R16G16B16A16_SFloat);
-            
-            // Resources FSR2_LumaHistory1/2: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8G8B8A8_UNORM, FFX_RESOURCE_FLAGS_NONE
-            CreateDoubleBufferedResource(LumaHistory, "FSR2_LumaHistory", contextDescription.DisplaySize, GraphicsFormat.R8G8B8A8_UNorm);
-        }
-
-        public void CreateTcrAutogenResources(Fsr2.ContextDescription contextDescription)
-        {
-            // Resource FSR2_AutoReactive: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8_UNORM, FFX_RESOURCE_FLAGS_NONE
-            AutoReactive = new RenderTexture(contextDescription.MaxRenderSize.x, contextDescription.MaxRenderSize.y, 0, GraphicsFormat.R8_UNorm) { name = "FSR2_AutoReactive", enableRandomWrite = true };
-            AutoReactive.Create();
-
-            // Resource FSR2_AutoComposition: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8_UNORM, FFX_RESOURCE_FLAGS_NONE
-            AutoComposition = new RenderTexture(contextDescription.MaxRenderSize.x, contextDescription.MaxRenderSize.y, 0, GraphicsFormat.R8_UNorm) { name = "FSR2_AutoComposition", enableRandomWrite = true };
-            AutoComposition.Create();
-
-            // Resources FSR2_PrevPreAlpha0/1: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R11G11B10_FLOAT, FFX_RESOURCE_FLAGS_NONE
-            CreateDoubleBufferedResource(PrevPreAlpha, "FSR2_PrevPreAlpha", contextDescription.MaxRenderSize, GraphicsFormat.B10G11R11_UFloatPack32);
-
-            // Resources FSR2_PrevPostAlpha0/1: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R11G11B10_FLOAT, FFX_RESOURCE_FLAGS_NONE
-            CreateDoubleBufferedResource(PrevPostAlpha, "FSR2_PrevPostAlpha", contextDescription.MaxRenderSize, GraphicsFormat.B10G11R11_UFloatPack32);
-        }
-        
-        // Set up shared aliasable resources, i.e. temporary render textures
-        // These do not need to persist between frames, but they do need to be available between passes
-        public static void CreateAliasableResources(CommandBuffer commandBuffer, Fsr2.ContextDescription contextDescription, Fsr2.DispatchDescription dispatchParams)
-        {
-            Vector2Int displaySize = contextDescription.DisplaySize;
-            Vector2Int maxRenderSize = contextDescription.MaxRenderSize;
-
-            // FSR2_ReconstructedPrevNearestDepth: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R32_UINT, FFX_RESOURCE_FLAGS_ALIASABLE
-            commandBuffer.GetTemporaryRT(Fsr2ShaderIDs.UavReconstructedPrevNearestDepth, maxRenderSize.x, maxRenderSize.y, 0, default, GraphicsFormat.R32_UInt, 1, true);
-
-            // FSR2_DilatedDepth: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R32_FLOAT, FFX_RESOURCE_FLAGS_ALIASABLE
-            commandBuffer.GetTemporaryRT(Fsr2ShaderIDs.UavDilatedDepth, maxRenderSize.x, maxRenderSize.y, 0, default, GraphicsFormat.R32_SFloat, 1, true);
-
-            // FSR2_LockInputLuma: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16_FLOAT, FFX_RESOURCE_FLAGS_ALIASABLE
-            commandBuffer.GetTemporaryRT(Fsr2ShaderIDs.UavLockInputLuma, maxRenderSize.x, maxRenderSize.y, 0, default, GraphicsFormat.R16_SFloat, 1, true);
-            
-            // FSR2_DilatedReactiveMasks: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8G8_UNORM, FFX_RESOURCE_FLAGS_ALIASABLE
-            commandBuffer.GetTemporaryRT(Fsr2ShaderIDs.UavDilatedReactiveMasks, maxRenderSize.x, maxRenderSize.y, 0, default, GraphicsFormat.R8G8_UNorm, 1, true);
-            
-            // FSR2_PreparedInputColor: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, FFX_RESOURCE_FLAGS_ALIASABLE
-            commandBuffer.GetTemporaryRT(Fsr2ShaderIDs.UavPreparedInputColor, maxRenderSize.x, maxRenderSize.y, 0, default, GraphicsFormat.R16G16B16A16_SFloat, 1, true);
-            
-            // FSR2_NewLocks: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8_UNORM, FFX_RESOURCE_FLAGS_ALIASABLE
-            commandBuffer.GetTemporaryRT(Fsr2ShaderIDs.UavNewLocks, displaySize.x, displaySize.y, 0, default, GraphicsFormat.R8_UNorm, 1, true);
-        }
-
-        public static void DestroyAliasableResources(CommandBuffer commandBuffer)
-        {
-            // Release all of the aliasable resources used this frame
-            commandBuffer.ReleaseTemporaryRT(Fsr2ShaderIDs.UavReconstructedPrevNearestDepth);
-            commandBuffer.ReleaseTemporaryRT(Fsr2ShaderIDs.UavDilatedDepth);
-            commandBuffer.ReleaseTemporaryRT(Fsr2ShaderIDs.UavLockInputLuma);
-            commandBuffer.ReleaseTemporaryRT(Fsr2ShaderIDs.UavDilatedReactiveMasks);
-            commandBuffer.ReleaseTemporaryRT(Fsr2ShaderIDs.UavPreparedInputColor);
-            commandBuffer.ReleaseTemporaryRT(Fsr2ShaderIDs.UavNewLocks);
-        }
-
-        private static void CreateDoubleBufferedResource(RenderTexture[] resource, string name, Vector2Int size, GraphicsFormat format)
-        {
-            for (int i = 0; i < 2; ++i)
-            {
-                resource[i] = new RenderTexture(size.x, size.y, 0, format) { name = name + (i + 1), enableRandomWrite = true };
-                resource[i].Create();
-            }
-        }
-
-        public void Destroy()
-        {
-            DestroyTcrAutogenResources();
-            
-            DestroyResource(LumaHistory);
-            DestroyResource(InternalUpscaled);
-            DestroyResource(LockStatus);
-            DestroyResource(DilatedMotionVectors);
-            DestroyResource(ref SceneLuminance);
-            DestroyResource(ref AutoExposure);
-            DestroyResource(ref DefaultReactive);
-            DestroyResource(ref DefaultExposure);
-            DestroyResource(ref MaximumBiasLut);
-            DestroyResource(ref LanczosLut);
-        }
-
-        public void DestroyTcrAutogenResources()
-        {
-            DestroyResource(PrevPostAlpha);
-            DestroyResource(PrevPreAlpha);
-            DestroyResource(ref AutoComposition);
-            DestroyResource(ref AutoReactive);
-        }
-        
-        private static void DestroyResource(ref Texture2D resource)
-        {
-            if (resource == null)
-                return;
-            
-            UnityEngine.Object.Destroy(resource);
-            resource = null;
-        }
-
-        private static void DestroyResource(ref RenderTexture resource)
-        {
-            if (resource == null)
-                return;
-            
-            resource.Release();
-            resource = null;
-        }
-
-        private static void DestroyResource(RenderTexture[] resource)
-        {
-            for (int i = 0; i < resource.Length; ++i)
-                DestroyResource(ref resource[i]);
-        }
-
-        private const int MaximumBiasTextureWidth = 16;
-        private const int MaximumBiasTextureHeight = 16;
-        private static readonly float[] MaximumBias =  
-        {
-            2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	1.876f,	1.809f,	1.772f,	1.753f,	1.748f,
-            2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	1.869f,	1.801f,	1.764f,	1.745f,	1.739f,
-            2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	1.976f,	1.841f,	1.774f,	1.737f,	1.716f,	1.71f,
-            2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	1.914f,	1.784f,	1.716f,	1.673f,	1.649f,	1.641f,
-            2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	1.793f,	1.676f,	1.604f,	1.562f,	1.54f,	1.533f,
-            2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	1.802f,	1.619f,	1.536f,	1.492f,	1.467f,	1.454f,	1.449f,
-            2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	1.812f,	1.575f,	1.496f,	1.456f,	1.432f,	1.416f,	1.408f,	1.405f,
-            2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	1.555f,	1.479f,	1.438f,	1.413f,	1.398f,	1.387f,	1.381f,	1.379f,
-            2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	1.812f,	1.555f,	1.474f,	1.43f,	1.404f,	1.387f,	1.376f,	1.368f,	1.363f,	1.362f,
-            2.0f,	2.0f,	2.0f,	2.0f,	2.0f,	1.802f,	1.575f,	1.479f,	1.43f,	1.401f,	1.382f,	1.369f,	1.36f,	1.354f,	1.351f,	1.35f,
-            2.0f,	2.0f,	1.976f,	1.914f,	1.793f,	1.619f,	1.496f,	1.438f,	1.404f,	1.382f,	1.367f,	1.357f,	1.349f,	1.344f,	1.341f,	1.34f,
-            1.876f,	1.869f,	1.841f,	1.784f,	1.676f,	1.536f,	1.456f,	1.413f,	1.387f,	1.369f,	1.357f,	1.347f,	1.341f,	1.336f,	1.333f,	1.332f,
-            1.809f,	1.801f,	1.774f,	1.716f,	1.604f,	1.492f,	1.432f,	1.398f,	1.376f,	1.36f,	1.349f,	1.341f,	1.335f,	1.33f,	1.328f,	1.327f,
-            1.772f,	1.764f,	1.737f,	1.673f,	1.562f,	1.467f,	1.416f,	1.387f,	1.368f,	1.354f,	1.344f,	1.336f,	1.33f,	1.326f,	1.323f,	1.323f,
-            1.753f,	1.745f,	1.716f,	1.649f,	1.54f,	1.454f,	1.408f,	1.381f,	1.363f,	1.351f,	1.341f,	1.333f,	1.328f,	1.323f,	1.321f,	1.32f,
-            1.748f,	1.739f,	1.71f,	1.641f,	1.533f,	1.449f,	1.405f,	1.379f,	1.362f,	1.35f,	1.34f,	1.332f,	1.327f,	1.323f,	1.32f,	1.319f,
-        };
-    }
-}

Assets/Scripts/Core/Fsr2ShaderIDs.cs

@@ -1,80 +0,0 @@
-// Copyright (c) 2023 Nico de Poel
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-using UnityEngine;
-
-namespace FidelityFX
-{
-    internal static class Fsr2ShaderIDs
-    {
-        // Shader resource views, i.e. read-only bindings
-        internal static readonly int SrvInputColor = Shader.PropertyToID("r_input_color_jittered");
-        internal static readonly int SrvOpaqueOnly = Shader.PropertyToID("r_input_opaque_only");
-        internal static readonly int SrvInputMotionVectors = Shader.PropertyToID("r_input_motion_vectors");
-        internal static readonly int SrvInputDepth = Shader.PropertyToID("r_input_depth");
-        internal static readonly int SrvInputExposure = Shader.PropertyToID("r_input_exposure");
-        internal static readonly int SrvAutoExposure = Shader.PropertyToID("r_auto_exposure");
-        internal static readonly int SrvReactiveMask = Shader.PropertyToID("r_reactive_mask");
-        internal static readonly int SrvTransparencyAndCompositionMask = Shader.PropertyToID("r_transparency_and_composition_mask");
-        internal static readonly int SrvReconstructedPrevNearestDepth = Shader.PropertyToID("r_reconstructed_previous_nearest_depth");
-        internal static readonly int SrvDilatedMotionVectors = Shader.PropertyToID("r_dilated_motion_vectors");
-        internal static readonly int SrvPrevDilatedMotionVectors = Shader.PropertyToID("r_previous_dilated_motion_vectors");
-        internal static readonly int SrvDilatedDepth = Shader.PropertyToID("r_dilatedDepth");
-        internal static readonly int SrvInternalUpscaled = Shader.PropertyToID("r_internal_upscaled_color");
-        internal static readonly int SrvLockStatus = Shader.PropertyToID("r_lock_status");
-        internal static readonly int SrvLockInputLuma = Shader.PropertyToID("r_lock_input_luma");
-        internal static readonly int SrvPreparedInputColor = Shader.PropertyToID("r_prepared_input_color");
-        internal static readonly int SrvLumaHistory = Shader.PropertyToID("r_luma_history");
-        internal static readonly int SrvRcasInput = Shader.PropertyToID("r_rcas_input");
-        internal static readonly int SrvLanczosLut = Shader.PropertyToID("r_lanczos_lut");
-        internal static readonly int SrvSceneLuminanceMips = Shader.PropertyToID("r_imgMips");
-        internal static readonly int SrvUpscaleMaximumBiasLut = Shader.PropertyToID("r_upsample_maximum_bias_lut");
-        internal static readonly int SrvDilatedReactiveMasks = Shader.PropertyToID("r_dilated_reactive_masks");
-        internal static readonly int SrvPrevColorPreAlpha = Shader.PropertyToID("r_input_prev_color_pre_alpha");
-        internal static readonly int SrvPrevColorPostAlpha = Shader.PropertyToID("r_input_prev_color_post_alpha");
-
-        // Unordered access views, i.e. random read/write bindings
-        internal static readonly int UavReconstructedPrevNearestDepth = Shader.PropertyToID("rw_reconstructed_previous_nearest_depth");
-        internal static readonly int UavDilatedMotionVectors = Shader.PropertyToID("rw_dilated_motion_vectors");
-        internal static readonly int UavDilatedDepth = Shader.PropertyToID("rw_dilatedDepth");
-        internal static readonly int UavInternalUpscaled = Shader.PropertyToID("rw_internal_upscaled_color");
-        internal static readonly int UavLockStatus = Shader.PropertyToID("rw_lock_status");
-        internal static readonly int UavLockInputLuma = Shader.PropertyToID("rw_lock_input_luma");
-        internal static readonly int UavNewLocks = Shader.PropertyToID("rw_new_locks");
-        internal static readonly int UavPreparedInputColor = Shader.PropertyToID("rw_prepared_input_color");
-        internal static readonly int UavLumaHistory = Shader.PropertyToID("rw_luma_history");
-        internal static readonly int UavUpscaledOutput = Shader.PropertyToID("rw_upscaled_output");
-        internal static readonly int UavExposureMipLumaChange = Shader.PropertyToID("rw_img_mip_shading_change");
-        internal static readonly int UavExposureMip5 = Shader.PropertyToID("rw_img_mip_5");
-        internal static readonly int UavDilatedReactiveMasks = Shader.PropertyToID("rw_dilated_reactive_masks");
-        internal static readonly int UavAutoExposure = Shader.PropertyToID("rw_auto_exposure");
-        internal static readonly int UavSpdAtomicCount = Shader.PropertyToID("rw_spd_global_atomic");
-        internal static readonly int UavAutoReactive = Shader.PropertyToID("rw_output_autoreactive");
-        internal static readonly int UavAutoComposition = Shader.PropertyToID("rw_output_autocomposition");
-        internal static readonly int UavPrevColorPreAlpha = Shader.PropertyToID("rw_output_prev_color_pre_alpha");
-        internal static readonly int UavPrevColorPostAlpha = Shader.PropertyToID("rw_output_prev_color_post_alpha");
-
-        // Constant buffer bindings
-        internal static readonly int CbFsr2 = Shader.PropertyToID("cbFSR2");
-        internal static readonly int CbSpd = Shader.PropertyToID("cbSPD");
-        internal static readonly int CbRcas = Shader.PropertyToID("cbRCAS");
-        internal static readonly int CbGenReactive = Shader.PropertyToID("cbGenerateReactive");
-    }
-}

Assets/Scripts/Core/Fsr3ShaderIDs.cs

@@ -0,0 +1,91 @@
+// Copyright (c) 2024 Nico de Poel
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using UnityEngine;
+
+namespace FidelityFX.FSR3
+{
+    public static class Fsr3ShaderIDs
+    {
+        // Shader resource views, i.e. read-only bindings
+        public static readonly int SrvInputColor = Shader.PropertyToID("r_input_color_jittered");
+        public static readonly int SrvOpaqueOnly = Shader.PropertyToID("r_input_opaque_only");
+        public static readonly int SrvInputMotionVectors = Shader.PropertyToID("r_input_motion_vectors");
+        public static readonly int SrvInputDepth = Shader.PropertyToID("r_input_depth");
+        public static readonly int SrvInputExposure = Shader.PropertyToID("r_input_exposure");
+        public static readonly int SrvFrameInfo = Shader.PropertyToID("r_frame_info"); 
+        public static readonly int SrvReactiveMask = Shader.PropertyToID("r_reactive_mask");
+        public static readonly int SrvTransparencyAndCompositionMask = Shader.PropertyToID("r_transparency_and_composition_mask");
+        public static readonly int SrvReconstructedPrevNearestDepth = Shader.PropertyToID("r_reconstructed_previous_nearest_depth");
+        public static readonly int SrvDilatedMotionVectors = Shader.PropertyToID("r_dilated_motion_vectors");
+        public static readonly int SrvDilatedDepth = Shader.PropertyToID("r_dilated_depth");
+        public static readonly int SrvInternalUpscaled = Shader.PropertyToID("r_internal_upscaled_color");
+        public static readonly int SrvAccumulation = Shader.PropertyToID("r_accumulation");
+        public static readonly int SrvLumaHistory = Shader.PropertyToID("r_luma_history");
+        public static readonly int SrvRcasInput = Shader.PropertyToID("r_rcas_input");
+        public static readonly int SrvLanczosLut = Shader.PropertyToID("r_lanczos_lut");
+        public static readonly int SrvSpdMips = Shader.PropertyToID("r_spd_mips");
+        public static readonly int SrvDilatedReactiveMasks = Shader.PropertyToID("r_dilated_reactive_masks");
+        public static readonly int SrvNewLocks = Shader.PropertyToID("r_new_locks");
+        public static readonly int SrvFarthestDepth = Shader.PropertyToID("r_farthest_depth");
+        public static readonly int SrvFarthestDepthMip1 = Shader.PropertyToID("r_farthest_depth_mip1");
+        public static readonly int SrvShadingChange = Shader.PropertyToID("r_shading_change");
+        public static readonly int SrvCurrentLuma = Shader.PropertyToID("r_current_luma");
+        public static readonly int SrvPreviousLuma = Shader.PropertyToID("r_previous_luma");
+        public static readonly int SrvLumaInstability = Shader.PropertyToID("r_luma_instability");
+        public static readonly int SrvPrevColorPreAlpha = Shader.PropertyToID("r_input_prev_color_pre_alpha");
+        public static readonly int SrvPrevColorPostAlpha = Shader.PropertyToID("r_input_prev_color_post_alpha");
+
+        // Unordered access views, i.e. random read/write bindings
+        public static readonly int UavReconstructedPrevNearestDepth = Shader.PropertyToID("rw_reconstructed_previous_nearest_depth");
+        public static readonly int UavDilatedMotionVectors = Shader.PropertyToID("rw_dilated_motion_vectors");
+        public static readonly int UavDilatedDepth = Shader.PropertyToID("rw_dilated_depth");
+        public static readonly int UavInternalUpscaled = Shader.PropertyToID("rw_internal_upscaled_color");
+        public static readonly int UavAccumulation = Shader.PropertyToID("rw_accumulation");
+        public static readonly int UavLumaHistory = Shader.PropertyToID("rw_luma_history");
+        public static readonly int UavUpscaledOutput = Shader.PropertyToID("rw_upscaled_output");
+        public static readonly int UavDilatedReactiveMasks = Shader.PropertyToID("rw_dilated_reactive_masks");
+        public static readonly int UavFrameInfo = Shader.PropertyToID("rw_frame_info");
+        public static readonly int UavSpdAtomicCount = Shader.PropertyToID("rw_spd_global_atomic");
+        public static readonly int UavNewLocks = Shader.PropertyToID("rw_new_locks");
+        public static readonly int UavAutoReactive = Shader.PropertyToID("rw_output_autoreactive");
+        public static readonly int UavShadingChange = Shader.PropertyToID("rw_shading_change");
+        public static readonly int UavFarthestDepth = Shader.PropertyToID("rw_farthest_depth");
+        public static readonly int UavFarthestDepthMip1 = Shader.PropertyToID("rw_farthest_depth_mip1");
+        public static readonly int UavCurrentLuma = Shader.PropertyToID("rw_current_luma");
+        public static readonly int UavLumaInstability = Shader.PropertyToID("rw_luma_instability");
+        public static readonly int UavIntermediate = Shader.PropertyToID("rw_intermediate_fp16x1");
+        public static readonly int UavSpdMip0 = Shader.PropertyToID("rw_spd_mip0");
+        public static readonly int UavSpdMip1 = Shader.PropertyToID("rw_spd_mip1");
+        public static readonly int UavSpdMip2 = Shader.PropertyToID("rw_spd_mip2");
+        public static readonly int UavSpdMip3 = Shader.PropertyToID("rw_spd_mip3");
+        public static readonly int UavSpdMip4 = Shader.PropertyToID("rw_spd_mip4");
+        public static readonly int UavSpdMip5 = Shader.PropertyToID("rw_spd_mip5");
+        public static readonly int UavAutoComposition = Shader.PropertyToID("rw_output_autocomposition");
+        public static readonly int UavPrevColorPreAlpha = Shader.PropertyToID("rw_output_prev_color_pre_alpha");
+        public static readonly int UavPrevColorPostAlpha = Shader.PropertyToID("rw_output_prev_color_post_alpha");
+
+        // Constant buffer bindings
+        public static readonly int CbFsr3Upscaler = Shader.PropertyToID("cbFSR3Upscaler");
+        public static readonly int CbSpd = Shader.PropertyToID("cbSPD");
+        public static readonly int CbRcas = Shader.PropertyToID("cbRCAS");
+        public static readonly int CbGenReactive = Shader.PropertyToID("cbGenerateReactive");
+    }
+}

Assets/Scripts/Core/Fsr2.cs → Assets/Scripts/Core/Fsr3Upscaler.cs

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Nico de Poel
+// Copyright (c) 2024 Nico de Poel
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -23,17 +23,17 @@ using System.Runtime.InteropServices;
 using UnityEngine;
 using UnityEngine.Rendering;
 
-namespace FidelityFX
+namespace FidelityFX.FSR3
 {
     /// <summary>
-    /// A collection of helper functions and data structures required by the FSR2 process.
+    /// A collection of helper functions and data structures required by the FSR3 Upscaler process.
     /// </summary>
-    public static class Fsr2
+    public static class Fsr3Upscaler
     {
         /// <summary>
-        /// Creates a new FSR2 context with standard parameters that are appropriate for the current platform. 
+        /// Creates a new FSR3 Upscaler context with standard parameters that are appropriate for the current platform. 
         /// </summary>
-        public static Fsr2Context CreateContext(Vector2Int displaySize, Vector2Int maxRenderSize, IFsr2Callbacks callbacks, InitializationFlags flags = 0)
+        public static Fsr3UpscalerContext CreateContext(Vector2Int displaySize, Vector2Int maxRenderSize, Fsr3UpscalerShaders shaders, InitializationFlags flags = 0)
         {
             if (SystemInfo.usesReversedZBuffer)
                 flags |= InitializationFlags.EnableDepthInverted;
@@ -44,17 +44,17 @@ namespace FidelityFX
             flags |= InitializationFlags.EnableDebugChecking;
 #endif
             
-            Debug.Log($"Setting up FSR2 with render size: {maxRenderSize.x}x{maxRenderSize.y}, display size: {displaySize.x}x{displaySize.y}, flags: {flags}");
+            Debug.Log($"Setting up FSR3 Upscaler with render size: {maxRenderSize.x}x{maxRenderSize.y}, display size: {displaySize.x}x{displaySize.y}, flags: {flags}");
             
             var contextDescription = new ContextDescription
             {
                 Flags = flags,
-                DisplaySize = displaySize,
+                MaxUpscaleSize = displaySize,
                 MaxRenderSize = maxRenderSize,
-                Callbacks = callbacks,
+                Shaders = shaders,
             };
             
-            var context = new Fsr2Context();
+            var context = new Fsr3UpscalerContext();
             context.Create(contextDescription);
             return context;
         }
@@ -63,6 +63,8 @@ namespace FidelityFX
         {
             switch (qualityMode)
             {
+                case QualityMode.NativeAA:
+                    return 1.0f;
                 case QualityMode.UltraQuality:
                     return 1.2f;
                 case QualityMode.Quality:
@@ -134,11 +136,12 @@ namespace FidelityFX
         
         public enum QualityMode
         {
-            UltraQuality = 0,
-            Quality = 1,
-            Balanced = 2,
-            Performance = 3,
-            UltraPerformance = 4,
+            NativeAA = 0,
+            UltraQuality = 1,
+            Quality = 2,
+            Balanced = 3,
+            Performance = 4,
+            UltraPerformance = 5,
         }
 
         [Flags]
@@ -155,47 +158,25 @@ namespace FidelityFX
             EnableDebugChecking = 1 << 8,
         }
 
-        public struct ContextDescription
+        [Flags]
+        public enum DispatchFlags
         {
-            public InitializationFlags Flags;
-            public Vector2Int MaxRenderSize;
-            public Vector2Int DisplaySize;
-            public IFsr2Callbacks Callbacks;
+            DrawDebugView = 1 << 0,
         }
 
         /// <summary>
-        /// An immutable structure wrapping all of the necessary information to bind a specific buffer or attachment of a render target to a compute shader.
+        /// A structure encapsulating the parameters required to initialize FidelityFX Super Resolution 3 upscaling.
         /// </summary>
-        public readonly struct ResourceView
+        public struct ContextDescription
         {
-            /// <summary>
-            /// This value is the equivalent of not setting any value at all; all struct fields will have their default values.
-            /// It does not refer to a valid texture, therefore any variable set to this value should be checked for IsValid and reassigned before being bound to a shader.
-            /// </summary>
-            public static readonly ResourceView Unassigned = new ResourceView(default);
-            
-            /// <summary>
-            /// This value contains a valid texture reference that can be bound to a shader, however it is just an empty placeholder texture.
-            /// Binding this to a shader can be seen as setting the texture variable inside the shader to null.
-            /// </summary>
-            public static readonly ResourceView None = new ResourceView(BuiltinRenderTextureType.None);
-            
-            public ResourceView(in RenderTargetIdentifier renderTarget, RenderTextureSubElement subElement = RenderTextureSubElement.Default, int mipLevel = 0)
-            {
-                RenderTarget = renderTarget;
-                SubElement = subElement;
-                MipLevel = mipLevel;
-            }
-            
-            public bool IsValid => !RenderTarget.Equals(default);
-            
-            public readonly RenderTargetIdentifier RenderTarget;
-            public readonly RenderTextureSubElement SubElement;
-            public readonly int MipLevel;
+            public InitializationFlags Flags;
+            public Vector2Int MaxRenderSize;
+            public Vector2Int MaxUpscaleSize;
+            public Fsr3UpscalerShaders Shaders;
         }
 
         /// <summary>
-        /// A structure encapsulating the parameters for dispatching the various passes of FidelityFX Super Resolution 2.
+        /// A structure encapsulating the parameters for dispatching the various passes of FidelityFX Super Resolution 3.
         /// </summary>
         public class DispatchDescription
         {
@@ -209,7 +190,7 @@ namespace FidelityFX
             public Vector2 JitterOffset;
             public Vector2 MotionVectorScale;
             public Vector2Int RenderSize;
-            public Vector2Int InputResourceSize;
+            public Vector2Int UpscaleSize;
             public bool EnableSharpening;
             public float Sharpness;
             public float FrameTimeDelta;    // in seconds
@@ -219,6 +200,8 @@ namespace FidelityFX
             public float CameraFar;
             public float CameraFovAngleVertical;
             public float ViewSpaceToMetersFactor;
+            public DispatchFlags Flags;
+            public bool UseTextureArrays;   // Enable texture array bindings, primarily used for HDRP and XR
             
             // EXPERIMENTAL reactive mask generation parameters
             public bool EnableAutoReactive;
@@ -231,7 +214,7 @@ namespace FidelityFX
 
         /// <summary>
         /// A structure encapsulating the parameters for automatic generation of a reactive mask.
-        /// The default values for Scale, CutoffThreshold, BinaryValue and Flags were taken from the FSR2 demo project.
+        /// The default values for Scale, CutoffThreshold, BinaryValue and Flags were taken from the FSR3 demo project.
         /// </summary>
         public class GenerateReactiveDescription
         {
@@ -255,30 +238,33 @@ namespace FidelityFX
         }
         
         [Serializable, StructLayout(LayoutKind.Sequential)]
-        internal struct Fsr2Constants
+        internal struct UpscalerConstants
         {
             public Vector2Int renderSize;
+            public Vector2Int previousFrameRenderSize;
+
+            public Vector2Int upscaleSize;
+            public Vector2Int previousFrameUpscaleSize;
+            
             public Vector2Int maxRenderSize;
-            public Vector2Int displaySize;
-            public Vector2Int inputColorResourceDimensions;
-            public Vector2Int lumaMipDimensions;
-            public int lumaMipLevelToUse;
-            public int frameIndex;
+            public Vector2Int maxUpscaleSize;
             
             public Vector4 deviceToViewDepth;
+            
             public Vector2 jitterOffset;
+            public Vector2 previousFrameJitterOffset;
+            
             public Vector2 motionVectorScale;
             public Vector2 downscaleFactor;
+            
             public Vector2 motionVectorJitterCancellation;
-            public float preExposure;
-            public float previousFramePreExposure;
             public float tanHalfFOV;
             public float jitterPhaseCount;
+            
             public float deltaTime;
-            public float dynamicResChangeFactor;
+            public float deltaPreExposure;
             public float viewSpaceToMetersFactor;
-
-            public int dummy;
+            public float frameIndex;
         }
         
         [Serializable, StructLayout(LayoutKind.Sequential)]

Assets/Scripts/Core/Fsr3UpscalerAssets.cs

@@ -0,0 +1,177 @@
+// Copyright (c) 2024 Nico de Poel
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace FidelityFX.FSR3
+{
+    /// <summary>
+    /// Scriptable object containing all shader resources required by FidelityFX Super Resolution 3 (FSR3) Upscaler.
+    /// These can be stored in an asset file and referenced from a scene or prefab, avoiding the need to load the shaders from a Resources folder.
+    /// </summary>
+    [CreateAssetMenu(fileName = "FSR3 Upscaler Assets", menuName = "FidelityFX/FSR3 Upscaler Assets", order = 1103)]
+    public class Fsr3UpscalerAssets : ScriptableObject
+    {
+        public Fsr3UpscalerShaders shaders;
+        
+#if UNITY_EDITOR
+        private void Reset()
+        {
+            shaders = new Fsr3UpscalerShaders
+            {
+                prepareInputsPass = FindComputeShader("ffx_fsr3upscaler_prepare_inputs_pass"),
+                lumaPyramidPass = FindComputeShader("ffx_fsr3upscaler_luma_pyramid_pass"),
+                shadingChangePyramidPass = FindComputeShader("ffx_fsr3upscaler_shading_change_pyramid_pass"),
+                shadingChangePass = FindComputeShader("ffx_fsr3upscaler_shading_change_pass"),
+                prepareReactivityPass = FindComputeShader("ffx_fsr3upscaler_prepare_reactivity_pass"),
+                lumaInstabilityPass = FindComputeShader("ffx_fsr3upscaler_luma_instability_pass"),
+                accumulatePass = FindComputeShader("ffx_fsr3upscaler_accumulate_pass"),
+                sharpenPass = FindComputeShader("ffx_fsr3upscaler_rcas_pass"),
+                autoGenReactivePass = FindComputeShader("ffx_fsr3upscaler_autogen_reactive_pass"),
+                tcrAutoGenPass = FindComputeShader("ffx_fsr3upscaler_tcr_autogen_pass"),
+                debugViewPass = FindComputeShader("ffx_fsr3upscaler_debug_view_pass"),
+            };
+        }
+
+        private static ComputeShader FindComputeShader(string name)
+        {
+            string[] assetGuids = UnityEditor.AssetDatabase.FindAssets($"t:ComputeShader {name}");
+            if (assetGuids == null || assetGuids.Length == 0)
+                return null;
+
+            string assetPath = UnityEditor.AssetDatabase.GUIDToAssetPath(assetGuids[0]);
+            return UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(assetPath);
+        }
+#endif
+    }
+    
+    /// <summary>
+    /// All the compute shaders used by the FSR3 Upscaler.
+    /// </summary>
+    [System.Serializable]
+    public class Fsr3UpscalerShaders
+    {
+        /// <summary>
+        /// The compute shader used by the prepare inputs pass.
+        /// </summary>
+        public ComputeShader prepareInputsPass;
+        
+        /// <summary>
+        /// The compute shader used by the luminance pyramid computation pass.
+        /// </summary>
+        public ComputeShader lumaPyramidPass;
+
+        /// <summary>
+        /// The compute shader used by the shading change pyramid pass.
+        /// </summary>
+        public ComputeShader shadingChangePyramidPass;
+
+        /// <summary>
+        /// The compute shader used by the shading change pass.
+        /// </summary>
+        public ComputeShader shadingChangePass;
+
+        /// <summary>
+        /// The compute shader used by the prepare reactivity pass.
+        /// </summary>
+        public ComputeShader prepareReactivityPass;
+        
+        /// <summary>
+        /// The compute shader used by the luma instability pass.
+        /// </summary>
+        public ComputeShader lumaInstabilityPass;
+
+        /// <summary>
+        /// The compute shader used by the accumulation pass.
+        /// </summary>
+        public ComputeShader accumulatePass;
+
+        /// <summary>
+        /// The compute shader used by the RCAS sharpening pass.
+        /// </summary>
+        public ComputeShader sharpenPass;
+
+        /// <summary>
+        /// The compute shader used to auto-generate a reactive mask.
+        /// </summary>
+        public ComputeShader autoGenReactivePass;
+
+        /// <summary>
+        /// The compute shader used to auto-generate a transparency & composition mask.
+        /// </summary>
+        public ComputeShader tcrAutoGenPass;
+
+        /// <summary>
+        /// The compute shader used to display a debug view.
+        /// </summary>
+        public ComputeShader debugViewPass;
+        
+        /// <summary>
+        /// Returns a copy of this class and its contents.
+        /// </summary>
+        public Fsr3UpscalerShaders Clone()
+        {
+            return (Fsr3UpscalerShaders)MemberwiseClone();
+        }
+
+        /// <summary>
+        /// Returns a copy of this class with clones of all its shaders.
+        /// This can be useful if you're running multiple FSR3 Upscaler instances with different shader configurations.
+        /// Be sure to clean up these clones through Dispose once you're done with them.
+        /// </summary>
+        public Fsr3UpscalerShaders DeepCopy()
+        {
+            return new Fsr3UpscalerShaders
+            {
+                prepareInputsPass = Object.Instantiate(prepareInputsPass),
+                lumaPyramidPass = Object.Instantiate(lumaPyramidPass),
+                shadingChangePyramidPass = Object.Instantiate(shadingChangePyramidPass),
+                shadingChangePass = Object.Instantiate(shadingChangePass),
+                prepareReactivityPass = Object.Instantiate(prepareReactivityPass),
+                lumaInstabilityPass = Object.Instantiate(lumaInstabilityPass),
+                accumulatePass = Object.Instantiate(accumulatePass),
+                sharpenPass = Object.Instantiate(sharpenPass),
+                autoGenReactivePass = Object.Instantiate(autoGenReactivePass),
+                tcrAutoGenPass = Object.Instantiate(tcrAutoGenPass),
+                debugViewPass = Object.Instantiate(debugViewPass),
+            };
+        }
+
+        /// <summary>
+        /// Destroy all the shaders within this instance.
+        /// Use this only on clones created through DeepCopy.
+        /// </summary>
+        public void Dispose()
+        {
+            Object.Destroy(prepareInputsPass);
+            Object.Destroy(lumaPyramidPass);
+            Object.Destroy(shadingChangePyramidPass);
+            Object.Destroy(shadingChangePass);
+            Object.Destroy(prepareReactivityPass);
+            Object.Destroy(lumaInstabilityPass);
+            Object.Destroy(accumulatePass);
+            Object.Destroy(sharpenPass);
+            Object.Destroy(autoGenReactivePass);
+            Object.Destroy(tcrAutoGenPass);
+            Object.Destroy(debugViewPass);
+        }
+    }
+}

Assets/Scripts/Core/Fsr3UpscalerAssets.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: db26e15a33db6ab42a38daab0ba2712f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Core/Fsr2Callbacks.cs → Assets/Scripts/Core/Fsr3UpscalerCallbacks.cs

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Nico de Poel
+// Copyright (c) 2024 Nico de Poel
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -20,19 +20,14 @@
 
 using UnityEngine;
 
-namespace FidelityFX
+namespace FidelityFX.FSR3
 {
     /// <summary>
-    /// A collection of callbacks required by the FSR2 process.
-    /// This allows some customization by the game dev on how to integrate FSR2 into their own game setup.
+    /// A collection of callbacks required by the FSR3 Upscaler process.
+    /// This allows some customization by the game dev on how to integrate FSR3 upscaling into their own game setup.
     /// </summary>
-    public interface IFsr2Callbacks
+    public interface IFsr3UpscalerCallbacks
     {
-        Shader LoadShader(string name);
-        void UnloadShader(Shader shader);
-        ComputeShader LoadComputeShader(string name);
-        void UnloadComputeShader(ComputeShader shader);
-        
         /// <summary>
         /// Apply a mipmap bias to in-game textures to prevent them from becoming blurry as the internal rendering resolution lowers.
         /// This will need to be customized on a per-game basis, as there is no clear universal way to determine what are "in-game" textures.
@@ -47,33 +42,13 @@ namespace FidelityFX
     }
     
     /// <summary>
-    /// Default implementation of IFsr2Callbacks using simple Resources calls.
+    /// Default implementation of IFsr3UpscalerCallbacks.
     /// These are fine for testing but a proper game will want to extend and override these methods.
     /// </summary>
-    public class Fsr2CallbacksBase: IFsr2Callbacks
+    public class Fsr3UpscalerCallbacksBase: IFsr3UpscalerCallbacks
     {
         protected float CurrentBiasOffset = 0;
 
-        public virtual Shader LoadShader(string name)
-        {
-            return Resources.Load<Shader>(name);
-        }
-
-        public virtual void UnloadShader(Shader shader)
-        {
-            Resources.UnloadAsset(shader);
-        }
-
-        public virtual ComputeShader LoadComputeShader(string name)
-        {
-            return Resources.Load<ComputeShader>(name);
-        }
-
-        public virtual void UnloadComputeShader(ComputeShader shader)
-        {
-            Resources.UnloadAsset(shader);
-        }
-
         public virtual void ApplyMipmapBias(float biasOffset)
         {
             if (float.IsNaN(biasOffset) || float.IsInfinity(biasOffset))

Assets/Scripts/Core/Fsr2Context.cs → Assets/Scripts/Core/Fsr3UpscalerContext.cs

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Nico de Poel
+// Copyright (c) 2024 Nico de Poel
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -19,77 +19,83 @@
 // THE SOFTWARE.
 
 using System;
-using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using UnityEngine;
 using UnityEngine.Rendering;
 
-namespace FidelityFX
+namespace FidelityFX.FSR3
 {
     /// <summary>
-    /// This class loosely matches the FfxFsr2Context struct from the original FSR2 codebase.
-    /// It manages the various resources and compute passes required by the FSR2 process.
+    /// This class loosely matches the FfxFsr3UpscalerContext struct from the original FSR3 codebase.
+    /// It manages the various resources and compute passes required by the FSR3 Upscaler process.
     /// Note that this class does not know anything about Unity render pipelines; all it knows is CommandBuffers and RenderTargetIdentifiers.
     /// This should make it suitable for integration with any of the available Unity render pipelines.
     /// </summary>
-    public class Fsr2Context
+    public class Fsr3UpscalerContext
     {
         private const int MaxQueuedFrames = 16;
         
-        private Fsr2.ContextDescription _contextDescription;
+        private Fsr3Upscaler.ContextDescription _contextDescription;
         private CommandBuffer _commandBuffer;
         
-        private Fsr2Pass _depthClipPass;
-        private Fsr2Pass _reconstructPreviousDepthPass;
-        private Fsr2Pass _lockPass;
-        private Fsr2Pass _accumulatePass;
-        private Fsr2Pass _rcasPass;
-        private Fsr2Pass _computeLuminancePyramidPass;
-        private Fsr2Pass _generateReactivePass;
-        private Fsr2Pass _tcrAutogeneratePass;
-
-        private readonly Fsr2Resources _resources = new Fsr2Resources();
-
-        private ComputeBuffer _fsr2ConstantsBuffer;
-        private readonly Fsr2.Fsr2Constants[] _fsr2ConstantsArray = { new Fsr2.Fsr2Constants() };
-        private ref Fsr2.Fsr2Constants Constants => ref _fsr2ConstantsArray[0];
+        private Fsr3UpscalerPass _prepareInputsPass;
+        private Fsr3UpscalerPass _lumaPyramidPass;
+        private Fsr3UpscalerPass _shadingChangePyramidPass;
+        private Fsr3UpscalerPass _shadingChangePass;
+        private Fsr3UpscalerPass _prepareReactivityPass;
+        private Fsr3UpscalerPass _lumaInstabilityPass;
+        private Fsr3UpscalerPass _accumulatePass;
+        private Fsr3UpscalerPass _sharpenPass;
+        private Fsr3UpscalerPass _generateReactivePass;
+        private Fsr3UpscalerPass _tcrAutogeneratePass;
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+        private Fsr3UpscalerPass _debugViewPass;
+#endif
+
+        private readonly Fsr3UpscalerResources _resources = new Fsr3UpscalerResources();
+
+        private ComputeBuffer _upscalerConstantsBuffer;
+        private readonly Fsr3Upscaler.UpscalerConstants[] _upscalerConstantsArray = { new Fsr3Upscaler.UpscalerConstants() };
+        private ref Fsr3Upscaler.UpscalerConstants UpscalerConsts => ref _upscalerConstantsArray[0];
 
         private ComputeBuffer _spdConstantsBuffer;
-        private readonly Fsr2.SpdConstants[] _spdConstantsArray = { new Fsr2.SpdConstants() };
-        private ref Fsr2.SpdConstants SpdConsts => ref _spdConstantsArray[0];
+        private readonly Fsr3Upscaler.SpdConstants[] _spdConstantsArray = { new Fsr3Upscaler.SpdConstants() };
+        private ref Fsr3Upscaler.SpdConstants SpdConsts => ref _spdConstantsArray[0];
     
         private ComputeBuffer _rcasConstantsBuffer;
-        private readonly Fsr2.RcasConstants[] _rcasConstantsArray = new Fsr2.RcasConstants[1];
-        private ref Fsr2.RcasConstants RcasConsts => ref _rcasConstantsArray[0];
+        private readonly Fsr3Upscaler.RcasConstants[] _rcasConstantsArray = new Fsr3Upscaler.RcasConstants[1];
+        private ref Fsr3Upscaler.RcasConstants RcasConsts => ref _rcasConstantsArray[0];
 
         private ComputeBuffer _generateReactiveConstantsBuffer;
-        private readonly Fsr2.GenerateReactiveConstants[] _generateReactiveConstantsArray = { new Fsr2.GenerateReactiveConstants() };
-        private ref Fsr2.GenerateReactiveConstants GenReactiveConsts => ref _generateReactiveConstantsArray[0];
+        private readonly Fsr3Upscaler.GenerateReactiveConstants[] _generateReactiveConstantsArray = { new Fsr3Upscaler.GenerateReactiveConstants() };
+        private ref Fsr3Upscaler.GenerateReactiveConstants GenReactiveConsts => ref _generateReactiveConstantsArray[0];
 
         private ComputeBuffer _tcrAutogenerateConstantsBuffer;
-        private readonly Fsr2.GenerateReactiveConstants2[] _tcrAutogenerateConstantsArray = { new Fsr2.GenerateReactiveConstants2() };
-        private ref Fsr2.GenerateReactiveConstants2 TcrAutoGenConsts => ref _tcrAutogenerateConstantsArray[0];
+        private readonly Fsr3Upscaler.GenerateReactiveConstants2[] _tcrAutogenerateConstantsArray = { new Fsr3Upscaler.GenerateReactiveConstants2() };
+        private ref Fsr3Upscaler.GenerateReactiveConstants2 TcrAutoGenConsts => ref _tcrAutogenerateConstantsArray[0];
 
         private bool _firstExecution;
-        private Vector2 _previousJitterOffset;
         private int _resourceFrameIndex;
+        private Vector2 _previousJitterOffset;
+        private float _preExposure;
+        private float _previousFramePreExposure;
 
-        public void Create(Fsr2.ContextDescription contextDescription)
+        public void Create(Fsr3Upscaler.ContextDescription contextDescription)
         {
             _contextDescription = contextDescription;
-            _commandBuffer = new CommandBuffer { name = "FSR2" };
+            _commandBuffer = new CommandBuffer { name = "FSR3 Upscaler" };
             
-            _fsr2ConstantsBuffer = CreateConstantBuffer<Fsr2.Fsr2Constants>();
-            _spdConstantsBuffer = CreateConstantBuffer<Fsr2.SpdConstants>();
-            _rcasConstantsBuffer = CreateConstantBuffer<Fsr2.RcasConstants>();
-            _generateReactiveConstantsBuffer = CreateConstantBuffer<Fsr2.GenerateReactiveConstants>();
-            _tcrAutogenerateConstantsBuffer = CreateConstantBuffer<Fsr2.GenerateReactiveConstants2>();
+            _upscalerConstantsBuffer = CreateConstantBuffer<Fsr3Upscaler.UpscalerConstants>();
+            _spdConstantsBuffer = CreateConstantBuffer<Fsr3Upscaler.SpdConstants>();
+            _rcasConstantsBuffer = CreateConstantBuffer<Fsr3Upscaler.RcasConstants>();
+            _generateReactiveConstantsBuffer = CreateConstantBuffer<Fsr3Upscaler.GenerateReactiveConstants>();
+            _tcrAutogenerateConstantsBuffer = CreateConstantBuffer<Fsr3Upscaler.GenerateReactiveConstants2>();
 
             // Set defaults
             _firstExecution = true;
             _resourceFrameIndex = 0;
             
-            Constants.displaySize = _contextDescription.DisplaySize;
+            UpscalerConsts.maxUpscaleSize = _contextDescription.MaxUpscaleSize;
             
             _resources.Create(_contextDescription);
             CreatePasses();
@@ -97,26 +103,36 @@ namespace FidelityFX
 
         private void CreatePasses()
         {
-            _computeLuminancePyramidPass = new Fsr2ComputeLuminancePyramidPass(_contextDescription, _resources, _fsr2ConstantsBuffer, _spdConstantsBuffer);
-            _reconstructPreviousDepthPass = new Fsr2ReconstructPreviousDepthPass(_contextDescription, _resources, _fsr2ConstantsBuffer);
-            _depthClipPass = new Fsr2DepthClipPass(_contextDescription, _resources, _fsr2ConstantsBuffer);
-            _lockPass = new Fsr2LockPass(_contextDescription, _resources, _fsr2ConstantsBuffer);
-            _accumulatePass = new Fsr2AccumulatePass(_contextDescription, _resources, _fsr2ConstantsBuffer);
-            _rcasPass = new Fsr2RcasPass(_contextDescription, _resources, _fsr2ConstantsBuffer, _rcasConstantsBuffer);
-            _generateReactivePass = new Fsr2GenerateReactivePass(_contextDescription, _resources, _generateReactiveConstantsBuffer);
-            _tcrAutogeneratePass = new Fsr2TcrAutogeneratePass(_contextDescription, _resources, _fsr2ConstantsBuffer, _tcrAutogenerateConstantsBuffer);
+            _prepareInputsPass = new Fsr3UpscalerPrepareInputsPass(_contextDescription, _resources, _upscalerConstantsBuffer);
+            _lumaPyramidPass = new Fsr3UpscalerLumaPyramidPass(_contextDescription, _resources, _upscalerConstantsBuffer, _spdConstantsBuffer);
+            _shadingChangePyramidPass = new Fsr3UpscalerShadingChangePyramidPass(_contextDescription, _resources, _upscalerConstantsBuffer, _spdConstantsBuffer);
+            _shadingChangePass = new Fsr3UpscalerShadingChangePass(_contextDescription, _resources, _upscalerConstantsBuffer);
+            _prepareReactivityPass = new Fsr3UpscalerPrepareReactivityPass(_contextDescription, _resources, _upscalerConstantsBuffer);
+            _lumaInstabilityPass = new Fsr3UpscalerLumaInstabilityPass(_contextDescription, _resources, _upscalerConstantsBuffer);
+            _accumulatePass = new Fsr3UpscalerAccumulatePass(_contextDescription, _resources, _upscalerConstantsBuffer);
+            _sharpenPass = new Fsr3UpscalerSharpenPass(_contextDescription, _resources, _upscalerConstantsBuffer, _rcasConstantsBuffer);
+            _generateReactivePass = new Fsr3UpscalerGenerateReactivePass(_contextDescription, _resources, _generateReactiveConstantsBuffer);
+            _tcrAutogeneratePass = new Fsr3UpscalerTcrAutogeneratePass(_contextDescription, _resources, _upscalerConstantsBuffer, _tcrAutogenerateConstantsBuffer);
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+            _debugViewPass = new Fsr3UpscalerDebugViewPass(_contextDescription, _resources, _upscalerConstantsBuffer);
+#endif
         }
         
         public void Destroy()
         {
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+            DestroyPass(ref _debugViewPass);
+#endif
             DestroyPass(ref _tcrAutogeneratePass);
             DestroyPass(ref _generateReactivePass);
-            DestroyPass(ref _computeLuminancePyramidPass);
-            DestroyPass(ref _rcasPass);
+            DestroyPass(ref _lumaPyramidPass);
+            DestroyPass(ref _sharpenPass);
             DestroyPass(ref _accumulatePass);
-            DestroyPass(ref _lockPass);
-            DestroyPass(ref _reconstructPreviousDepthPass);
-            DestroyPass(ref _depthClipPass);
+            DestroyPass(ref _prepareReactivityPass);
+            DestroyPass(ref _shadingChangePass);
+            DestroyPass(ref _shadingChangePyramidPass);
+            DestroyPass(ref _lumaInstabilityPass);
+            DestroyPass(ref _prepareInputsPass);
             
             _resources.Destroy();
             
@@ -124,31 +140,41 @@ namespace FidelityFX
             DestroyConstantBuffer(ref _generateReactiveConstantsBuffer);
             DestroyConstantBuffer(ref _rcasConstantsBuffer);
             DestroyConstantBuffer(ref _spdConstantsBuffer);
-            DestroyConstantBuffer(ref _fsr2ConstantsBuffer);
+            DestroyConstantBuffer(ref _upscalerConstantsBuffer);
 
-            _commandBuffer.Dispose();
-            _commandBuffer = null;
+            if (_commandBuffer != null)
+            {
+                _commandBuffer.Dispose();
+                _commandBuffer = null;
+            }
         }
 
-        public void Dispatch(Fsr2.DispatchDescription dispatchParams)
+        public void Dispatch(Fsr3Upscaler.DispatchDescription dispatchParams)
         {
             _commandBuffer.Clear();
             Dispatch(dispatchParams, _commandBuffer);
             Graphics.ExecuteCommandBuffer(_commandBuffer);
         }
         
-        public void Dispatch(Fsr2.DispatchDescription dispatchParams, CommandBuffer commandBuffer)
+        public void Dispatch(Fsr3Upscaler.DispatchDescription dispatchParams, CommandBuffer commandBuffer)
         {
-            if ((_contextDescription.Flags & Fsr2.InitializationFlags.EnableDebugChecking) != 0)
+            if ((_contextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableDebugChecking) != 0)
             {
                 DebugCheckDispatch(dispatchParams);
             }
 
+            if (dispatchParams.UseTextureArrays)
+                commandBuffer.EnableShaderKeyword("UNITY_FSR_TEXTURE2D_X_ARRAY");
+            
             if (_firstExecution)
             {
-                commandBuffer.SetRenderTarget(_resources.LockStatus[0]);
+                commandBuffer.SetRenderTarget(_resources.Accumulation[0]);
+                commandBuffer.ClearRenderTarget(false, true, Color.clear);
+                commandBuffer.SetRenderTarget(_resources.Accumulation[1]);
+                commandBuffer.ClearRenderTarget(false, true, Color.clear);
+                commandBuffer.SetRenderTarget(_resources.Luma[0]);
                 commandBuffer.ClearRenderTarget(false, true, Color.clear);
-                commandBuffer.SetRenderTarget(_resources.LockStatus[1]);
+                commandBuffer.SetRenderTarget(_resources.Luma[1]);
                 commandBuffer.ClearRenderTarget(false, true, Color.clear);
             }
             
@@ -157,10 +183,10 @@ namespace FidelityFX
             _firstExecution = false;
 
             // If auto exposure is enabled use the auto exposure SRV, otherwise what the app sends
-            if ((_contextDescription.Flags & Fsr2.InitializationFlags.EnableAutoExposure) != 0)
-                dispatchParams.Exposure = new Fsr2.ResourceView(_resources.AutoExposure);
+            if ((_contextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableAutoExposure) != 0)
+                dispatchParams.Exposure = new ResourceView(_resources.FrameInfo);
             else if (!dispatchParams.Exposure.IsValid) 
-                dispatchParams.Exposure = new Fsr2.ResourceView(_resources.DefaultExposure);
+                dispatchParams.Exposure = new ResourceView(_resources.DefaultExposure);
 
             if (dispatchParams.EnableAutoReactive)
             {
@@ -170,7 +196,7 @@ namespace FidelityFX
 
                 if (resetAccumulation)
                 {
-                    RenderTargetIdentifier opaqueOnly = dispatchParams.ColorOpaqueOnly.IsValid ? dispatchParams.ColorOpaqueOnly.RenderTarget : Fsr2ShaderIDs.SrvOpaqueOnly;
+                    RenderTargetIdentifier opaqueOnly = dispatchParams.ColorOpaqueOnly.IsValid ? dispatchParams.ColorOpaqueOnly.RenderTarget : Fsr3ShaderIDs.SrvOpaqueOnly;
                     commandBuffer.Blit(_resources.PrevPreAlpha[frameIndex ^ 1], opaqueOnly);
                 }
             }
@@ -180,33 +206,32 @@ namespace FidelityFX
                 _resources.DestroyTcrAutogenResources();
             }
             
-            if (!dispatchParams.Reactive.IsValid) dispatchParams.Reactive = new Fsr2.ResourceView(_resources.DefaultReactive);
-            if (!dispatchParams.TransparencyAndComposition.IsValid) dispatchParams.TransparencyAndComposition = new Fsr2.ResourceView(_resources.DefaultReactive);
-            Fsr2Resources.CreateAliasableResources(commandBuffer, _contextDescription, dispatchParams);
+            if (!dispatchParams.Reactive.IsValid) dispatchParams.Reactive = new ResourceView(_resources.DefaultReactive);
+            if (!dispatchParams.TransparencyAndComposition.IsValid) dispatchParams.TransparencyAndComposition = new ResourceView(_resources.DefaultReactive);
+            Fsr3UpscalerResources.CreateAliasableResources(commandBuffer, _contextDescription, dispatchParams);
             
             SetupConstants(dispatchParams, resetAccumulation);
             
             // Reactive mask bias
             const int threadGroupWorkRegionDim = 8;
-            int dispatchSrcX = (Constants.renderSize.x + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
-            int dispatchSrcY = (Constants.renderSize.y + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
-            int dispatchDstX = (_contextDescription.DisplaySize.x + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
-            int dispatchDstY = (_contextDescription.DisplaySize.y + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            int dispatchSrcX = (UpscalerConsts.renderSize.x + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            int dispatchSrcY = (UpscalerConsts.renderSize.y + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            int dispatchDstX = (UpscalerConsts.upscaleSize.x + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            int dispatchDstY = (UpscalerConsts.upscaleSize.y + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            int dispatchShadingChangePassX = ((UpscalerConsts.renderSize.x / 2) + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            int dispatchShadingChangePassY = ((UpscalerConsts.renderSize.y / 2) + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
 
             // Clear reconstructed depth for max depth store
             if (resetAccumulation)
             {
-                commandBuffer.SetRenderTarget(_resources.LockStatus[frameIndex ^ 1]);
-                commandBuffer.ClearRenderTarget(false, true, Color.clear);
-                
-                commandBuffer.SetRenderTarget(_resources.InternalUpscaled[frameIndex ^ 1]);
+                commandBuffer.SetRenderTarget(_resources.Accumulation[frameIndex ^ 1]);
                 commandBuffer.ClearRenderTarget(false, true, Color.clear);
                 
-                commandBuffer.SetRenderTarget(_resources.SceneLuminance);
+                commandBuffer.SetRenderTarget(_resources.SpdMips);
                 commandBuffer.ClearRenderTarget(false, true, Color.clear);
                 
                 // Auto exposure always used to track luma changes in locking logic
-                commandBuffer.SetRenderTarget(_resources.AutoExposure);
+                commandBuffer.SetRenderTarget(_resources.FrameInfo);
                 commandBuffer.ClearRenderTarget(false, true, new Color(0f, 1e8f, 0f, 0f));
 
                 // Reset atomic counter to 0
@@ -214,34 +239,33 @@ namespace FidelityFX
                 commandBuffer.ClearRenderTarget(false, true, Color.clear);
             }
             
+            // FSR3: need to clear here since we need the content of this surface for frame interpolation, so clearing in the lock pass is not an option
+            bool depthInverted = (_contextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableDepthInverted) == Fsr3Upscaler.InitializationFlags.EnableDepthInverted;
+            commandBuffer.SetRenderTarget(_resources.ReconstructedPrevNearestDepth);
+            commandBuffer.ClearRenderTarget(false, true, depthInverted ? Color.clear : Color.white);
+            
             // Auto exposure
             SetupSpdConstants(dispatchParams, out var dispatchThreadGroupCount);
             
             // Initialize constant buffers data
-            commandBuffer.SetBufferData(_fsr2ConstantsBuffer, _fsr2ConstantsArray);
+            commandBuffer.SetBufferData(_upscalerConstantsBuffer, _upscalerConstantsArray);
             commandBuffer.SetBufferData(_spdConstantsBuffer, _spdConstantsArray);
 
             // Auto reactive
             if (dispatchParams.EnableAutoReactive)
             {
                 GenerateTransparencyCompositionReactive(dispatchParams, commandBuffer, frameIndex);
-                dispatchParams.Reactive = new Fsr2.ResourceView(_resources.AutoReactive);
-                dispatchParams.TransparencyAndComposition = new Fsr2.ResourceView(_resources.AutoComposition);
+                dispatchParams.Reactive = new ResourceView(_resources.AutoReactive);
+                dispatchParams.TransparencyAndComposition = new ResourceView(_resources.AutoComposition);
             }
             
-            // Compute luminance pyramid
-            _computeLuminancePyramidPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchThreadGroupCount.x, dispatchThreadGroupCount.y);
-
-            // Reconstruct previous depth
-            _reconstructPreviousDepthPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchSrcX, dispatchSrcY);
-
-            // Depth clip
-            _depthClipPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchSrcX, dispatchSrcY);
+            _prepareInputsPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchSrcX, dispatchSrcY);
+            _lumaPyramidPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchThreadGroupCount.x, dispatchThreadGroupCount.y);
+            _shadingChangePyramidPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchThreadGroupCount.x, dispatchThreadGroupCount.y);
+            _shadingChangePass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchShadingChangePassX, dispatchShadingChangePassY);
+            _prepareReactivityPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchSrcX, dispatchSrcY);
+            _lumaInstabilityPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchSrcX, dispatchSrcY);
             
-            // Create locks
-            _lockPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchSrcX, dispatchSrcY);
-
-            // Accumulate
             _accumulatePass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchDstX, dispatchDstY);
 
             if (dispatchParams.EnableSharpening)
@@ -252,24 +276,33 @@ namespace FidelityFX
                 
                 // Dispatch RCAS
                 const int threadGroupWorkRegionDimRcas = 16;
-                int threadGroupsX = (Screen.width + threadGroupWorkRegionDimRcas - 1) / threadGroupWorkRegionDimRcas;
-                int threadGroupsY = (Screen.height + threadGroupWorkRegionDimRcas - 1) / threadGroupWorkRegionDimRcas;
-                _rcasPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, threadGroupsX, threadGroupsY);
+                int threadGroupsX = (UpscalerConsts.upscaleSize.x + threadGroupWorkRegionDimRcas - 1) / threadGroupWorkRegionDimRcas;
+                int threadGroupsY = (UpscalerConsts.upscaleSize.y + threadGroupWorkRegionDimRcas - 1) / threadGroupWorkRegionDimRcas;
+                _sharpenPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, threadGroupsX, threadGroupsY);
+            }
+            
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+            if ((dispatchParams.Flags & Fsr3Upscaler.DispatchFlags.DrawDebugView) != 0)
+            {
+                _debugViewPass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchDstX, dispatchDstY);
             }
+#endif
 
             _resourceFrameIndex = (_resourceFrameIndex + 1) % MaxQueuedFrames;
 
-            Fsr2Resources.DestroyAliasableResources(commandBuffer);
+            Fsr3UpscalerResources.DestroyAliasableResources(commandBuffer);
+            
+            commandBuffer.DisableShaderKeyword("UNITY_FSR_TEXTURE2D_X_ARRAY");
         }
 
-        public void GenerateReactiveMask(Fsr2.GenerateReactiveDescription dispatchParams)
+        public void GenerateReactiveMask(Fsr3Upscaler.GenerateReactiveDescription dispatchParams)
         {
             _commandBuffer.Clear();
             GenerateReactiveMask(dispatchParams, _commandBuffer);
             Graphics.ExecuteCommandBuffer(_commandBuffer);
         }
 
-        public void GenerateReactiveMask(Fsr2.GenerateReactiveDescription dispatchParams, CommandBuffer commandBuffer)
+        public void GenerateReactiveMask(Fsr3Upscaler.GenerateReactiveDescription dispatchParams, CommandBuffer commandBuffer)
         {
             const int threadGroupWorkRegionDim = 8;
             int dispatchSrcX = (dispatchParams.RenderSize.x + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
@@ -281,10 +314,10 @@ namespace FidelityFX
             GenReactiveConsts.flags = (uint)dispatchParams.Flags;
             commandBuffer.SetBufferData(_generateReactiveConstantsBuffer, _generateReactiveConstantsArray);
             
-            ((Fsr2GenerateReactivePass)_generateReactivePass).ScheduleDispatch(commandBuffer, dispatchParams, dispatchSrcX, dispatchSrcY);
+            ((Fsr3UpscalerGenerateReactivePass)_generateReactivePass).ScheduleDispatch(commandBuffer, dispatchParams, dispatchSrcX, dispatchSrcY);
         }
 
-        private void GenerateTransparencyCompositionReactive(Fsr2.DispatchDescription dispatchParams, CommandBuffer commandBuffer, int frameIndex)
+        private void GenerateTransparencyCompositionReactive(Fsr3Upscaler.DispatchDescription dispatchParams, CommandBuffer commandBuffer, int frameIndex)
         {
             const int threadGroupWorkRegionDim = 8;
             int dispatchSrcX = (dispatchParams.RenderSize.x + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
@@ -299,14 +332,16 @@ namespace FidelityFX
             _tcrAutogeneratePass.ScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchSrcX, dispatchSrcY);
         }
 
-        private void SetupConstants(Fsr2.DispatchDescription dispatchParams, bool resetAccumulation)
+        private void SetupConstants(Fsr3Upscaler.DispatchDescription dispatchParams, bool resetAccumulation)
         {
-            ref Fsr2.Fsr2Constants constants = ref Constants;
+            ref Fsr3Upscaler.UpscalerConstants constants = ref UpscalerConsts;
 
+            constants.previousFrameJitterOffset = constants.jitterOffset;
             constants.jitterOffset = dispatchParams.JitterOffset;
+
+            constants.previousFrameRenderSize = constants.renderSize;
             constants.renderSize = dispatchParams.RenderSize;
             constants.maxRenderSize = _contextDescription.MaxRenderSize;
-            constants.inputColorResourceDimensions = dispatchParams.InputResourceSize;
 
             // Compute the horizontal FOV for the shader from the vertical one
             float aspectRatio = (float)dispatchParams.RenderSize.x / dispatchParams.RenderSize.y;
@@ -317,23 +352,41 @@ namespace FidelityFX
             // Compute params to enable device depth to view space depth computation in shader
             constants.deviceToViewDepth = SetupDeviceDepthToViewSpaceDepthParams(dispatchParams);
 
+            constants.previousFrameUpscaleSize = constants.upscaleSize;
+            if (dispatchParams.UpscaleSize.x == 0 && dispatchParams.UpscaleSize.y == 0)
+            {
+                constants.upscaleSize = _contextDescription.MaxUpscaleSize;
+            }
+            else
+            {
+                constants.upscaleSize = dispatchParams.UpscaleSize;
+            }
+            
             // To be updated if resource is larger than the actual image size
-            constants.downscaleFactor = new Vector2((float)constants.renderSize.x / _contextDescription.DisplaySize.x, (float)constants.renderSize.y / _contextDescription.DisplaySize.y);
-            constants.previousFramePreExposure = constants.preExposure;
-            constants.preExposure = (dispatchParams.PreExposure != 0) ? dispatchParams.PreExposure : 1.0f;
+            constants.downscaleFactor = new Vector2((float)constants.renderSize.x / constants.upscaleSize.x, (float)constants.renderSize.y / constants.upscaleSize.y);
+            
+            // Calculate pre-exposure relevant factors
+            constants.deltaPreExposure = 1.0f;
+            _previousFramePreExposure = _preExposure;
+            _preExposure = dispatchParams.PreExposure != 0.0f ? dispatchParams.PreExposure : 1.0f;
+
+            if (_previousFramePreExposure > 0.0f)
+            {
+                constants.deltaPreExposure = _preExposure / _previousFramePreExposure;
+            }
             
             // Motion vector data
-            Vector2Int motionVectorsTargetSize = (_contextDescription.Flags & Fsr2.InitializationFlags.EnableDisplayResolutionMotionVectors) != 0 ? constants.displaySize : constants.renderSize;
+            Vector2Int motionVectorsTargetSize = (_contextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableDisplayResolutionMotionVectors) != 0 ? constants.upscaleSize : constants.renderSize;
             constants.motionVectorScale = dispatchParams.MotionVectorScale / motionVectorsTargetSize;
             
             // Compute jitter cancellation
-            if ((_contextDescription.Flags & Fsr2.InitializationFlags.EnableMotionVectorsJitterCancellation) != 0)
+            if ((_contextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableMotionVectorsJitterCancellation) != 0)
             {
                 constants.motionVectorJitterCancellation = (_previousJitterOffset - constants.jitterOffset) / motionVectorsTargetSize;
                 _previousJitterOffset = constants.jitterOffset;
             }
 
-            int jitterPhaseCount = Fsr2.GetJitterPhaseCount(dispatchParams.RenderSize.x, _contextDescription.DisplaySize.x);
+            int jitterPhaseCount = Fsr3Upscaler.GetJitterPhaseCount(dispatchParams.RenderSize.x, _contextDescription.MaxUpscaleSize.x);
             if (resetAccumulation || constants.jitterPhaseCount == 0)
             {
                 constants.jitterPhaseCount = jitterPhaseCount;
@@ -353,20 +406,13 @@ namespace FidelityFX
             if (resetAccumulation)
                 constants.frameIndex = 0;
             else
-                constants.frameIndex++;
-
-            // Shading change usage of the SPD mip levels
-            constants.lumaMipLevelToUse = Fsr2Pass.ShadingChangeMipLevel;
-
-            float mipDiv = 2 << constants.lumaMipLevelToUse;
-            constants.lumaMipDimensions.x = (int)(constants.maxRenderSize.x / mipDiv);
-            constants.lumaMipDimensions.y = (int)(constants.maxRenderSize.y / mipDiv);
+                constants.frameIndex += 1.0f;
         }
         
-        private Vector4 SetupDeviceDepthToViewSpaceDepthParams(Fsr2.DispatchDescription dispatchParams)
+        private Vector4 SetupDeviceDepthToViewSpaceDepthParams(Fsr3Upscaler.DispatchDescription dispatchParams)
         {
-            bool inverted = (_contextDescription.Flags & Fsr2.InitializationFlags.EnableDepthInverted) != 0;
-            bool infinite = (_contextDescription.Flags & Fsr2.InitializationFlags.EnableDepthInfinite) != 0;
+            bool inverted = (_contextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableDepthInverted) != 0;
+            bool infinite = (_contextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableDepthInfinite) != 0;
 
             // make sure it has no impact if near and far plane values are swapped in dispatch params
             // the flags "inverted" and "infinite" will decide what transform to use
@@ -396,19 +442,19 @@ namespace FidelityFX
                 1.0f / cotHalfFovY);
         }
 
-        private void SetupRcasConstants(Fsr2.DispatchDescription dispatchParams)
+        private void SetupRcasConstants(Fsr3Upscaler.DispatchDescription dispatchParams)
         {
             int sharpnessIndex = Mathf.RoundToInt(Mathf.Clamp01(dispatchParams.Sharpness) * (RcasConfigs.Length - 1));
             RcasConsts = RcasConfigs[sharpnessIndex];
         }
 
-        private void SetupSpdConstants(Fsr2.DispatchDescription dispatchParams, out Vector2Int dispatchThreadGroupCount)
+        private void SetupSpdConstants(Fsr3Upscaler.DispatchDescription dispatchParams, out Vector2Int dispatchThreadGroupCount)
         {
             RectInt rectInfo = new RectInt(0, 0, dispatchParams.RenderSize.x, dispatchParams.RenderSize.y);
             SpdSetup(rectInfo, out dispatchThreadGroupCount, out var workGroupOffset, out var numWorkGroupsAndMips);
             
             // Downsample
-            ref Fsr2.SpdConstants spdConstants = ref SpdConsts;
+            ref Fsr3Upscaler.SpdConstants spdConstants = ref SpdConsts;
             spdConstants.numWorkGroups = (uint)numWorkGroupsAndMips.x;
             spdConstants.mips = (uint)numWorkGroupsAndMips.y;
             spdConstants.workGroupOffsetX = (uint)workGroupOffset.x;
@@ -434,7 +480,7 @@ namespace FidelityFX
             }
         }
 
-        private void DebugCheckDispatch(Fsr2.DispatchDescription dispatchParams)
+        private void DebugCheckDispatch(Fsr3Upscaler.DispatchDescription dispatchParams)
         {
             if (!dispatchParams.Color.IsValid)
             {
@@ -451,14 +497,14 @@ namespace FidelityFX
                 Debug.LogError("MotionVectors resource is null");
             }
             
-            if (!dispatchParams.Output.IsValid)
+            if (dispatchParams.Exposure.IsValid && (_contextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableAutoExposure) != 0)
             {
-                Debug.LogError("Output resource is null");
+                Debug.LogWarning("Exposure resource provided, however auto exposure flag is present");
             }
             
-            if (dispatchParams.Exposure.IsValid && (_contextDescription.Flags & Fsr2.InitializationFlags.EnableAutoExposure) != 0)
+            if (!dispatchParams.Output.IsValid)
             {
-                Debug.LogWarning("Exposure resource provided, however auto exposure flag is present");
+                Debug.LogError("Output resource is null");
             }
 
             if (Mathf.Abs(dispatchParams.JitterOffset.x) > 1.0f || Mathf.Abs(dispatchParams.JitterOffset.y) > 1.0f)
@@ -486,6 +532,11 @@ namespace FidelityFX
                 Debug.LogWarning("RenderSize contains zero dimension");
             }
 
+            if (dispatchParams.Sharpness < 0.0f || dispatchParams.Sharpness > 1.0f)
+            {
+                Debug.LogWarning("Sharpness contains value outside of expected range [0.0, 1.0]");
+            }
+
             if (dispatchParams.FrameTimeDelta > 1.0f)
             {
                 Debug.LogWarning("FrameTimeDelta is greater than 1.0f - this value should be seconds (~0.0166 for 60fps)");
@@ -496,8 +547,8 @@ namespace FidelityFX
                 Debug.LogError("PreExposure provided as 0.0f which is invalid");
             }
 
-            bool infiniteDepth = (_contextDescription.Flags & Fsr2.InitializationFlags.EnableDepthInfinite) != 0;
-            bool inverseDepth = (_contextDescription.Flags & Fsr2.InitializationFlags.EnableDepthInverted) != 0;
+            bool infiniteDepth = (_contextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableDepthInfinite) != 0;
+            bool inverseDepth = (_contextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableDepthInverted) != 0;
 
             if (inverseDepth)
             {
@@ -552,32 +603,32 @@ namespace FidelityFX
         }
 
         /// <summary>
-        /// The FSR2 C++ codebase uses floats bitwise converted to ints to pass sharpness parameters to the RCAS shader.
+        /// The FSR3 C++ codebase uses floats bitwise converted to ints to pass sharpness parameters to the RCAS shader.
         /// This is not possible in C# without enabling unsafe code compilation, so to avoid that we instead use a table of precomputed values.
         /// </summary>
-        private static readonly Fsr2.RcasConstants[] RcasConfigs = new []
+        private static readonly Fsr3Upscaler.RcasConstants[] RcasConfigs = new []
         {
-            new Fsr2.RcasConstants(1048576000u, 872428544u),
-            new Fsr2.RcasConstants(1049178080u, 877212745u),
-            new Fsr2.RcasConstants(1049823372u, 882390168u),
-            new Fsr2.RcasConstants(1050514979u, 887895276u),
-            new Fsr2.RcasConstants(1051256227u, 893859143u),
-            new Fsr2.RcasConstants(1052050675u, 900216232u),
-            new Fsr2.RcasConstants(1052902144u, 907032080u),
-            new Fsr2.RcasConstants(1053814727u, 914306687u),
-            new Fsr2.RcasConstants(1054792807u, 922105590u),
-            new Fsr2.RcasConstants(1055841087u, 930494326u),
-            new Fsr2.RcasConstants(1056964608u, 939538432u),
-            new Fsr2.RcasConstants(1057566688u, 944322633u),
-            new Fsr2.RcasConstants(1058211980u, 949500056u),
-            new Fsr2.RcasConstants(1058903587u, 955005164u),
-            new Fsr2.RcasConstants(1059644835u, 960969031u),
-            new Fsr2.RcasConstants(1060439283u, 967326120u),
-            new Fsr2.RcasConstants(1061290752u, 974141968u),
-            new Fsr2.RcasConstants(1062203335u, 981416575u),
-            new Fsr2.RcasConstants(1063181415u, 989215478u),
-            new Fsr2.RcasConstants(1064229695u, 997604214u),
-            new Fsr2.RcasConstants(1065353216u, 1006648320),
+            new Fsr3Upscaler.RcasConstants(1048576000u, 872428544u),
+            new Fsr3Upscaler.RcasConstants(1049178080u, 877212745u),
+            new Fsr3Upscaler.RcasConstants(1049823372u, 882390168u),
+            new Fsr3Upscaler.RcasConstants(1050514979u, 887895276u),
+            new Fsr3Upscaler.RcasConstants(1051256227u, 893859143u),
+            new Fsr3Upscaler.RcasConstants(1052050675u, 900216232u),
+            new Fsr3Upscaler.RcasConstants(1052902144u, 907032080u),
+            new Fsr3Upscaler.RcasConstants(1053814727u, 914306687u),
+            new Fsr3Upscaler.RcasConstants(1054792807u, 922105590u),
+            new Fsr3Upscaler.RcasConstants(1055841087u, 930494326u),
+            new Fsr3Upscaler.RcasConstants(1056964608u, 939538432u),
+            new Fsr3Upscaler.RcasConstants(1057566688u, 944322633u),
+            new Fsr3Upscaler.RcasConstants(1058211980u, 949500056u),
+            new Fsr3Upscaler.RcasConstants(1058903587u, 955005164u),
+            new Fsr3Upscaler.RcasConstants(1059644835u, 960969031u),
+            new Fsr3Upscaler.RcasConstants(1060439283u, 967326120u),
+            new Fsr3Upscaler.RcasConstants(1061290752u, 974141968u),
+            new Fsr3Upscaler.RcasConstants(1062203335u, 981416575u),
+            new Fsr3Upscaler.RcasConstants(1063181415u, 989215478u),
+            new Fsr3Upscaler.RcasConstants(1064229695u, 997604214u),
+            new Fsr3Upscaler.RcasConstants(1065353216u, 1006648320),
         };
         
         private static ComputeBuffer CreateConstantBuffer<TConstants>() where TConstants: struct
@@ -594,7 +645,7 @@ namespace FidelityFX
             bufferRef = null;
         }
 
-        private static void DestroyPass(ref Fsr2Pass pass)
+        private static void DestroyPass(ref Fsr3UpscalerPass pass)
         {
             if (pass == null)
                 return;

Assets/Scripts/Core/Fsr3UpscalerPass.cs

@@ -0,0 +1,472 @@
+// Copyright (c) 2024 Nico de Poel
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Runtime.InteropServices;
+using UnityEngine;
+using UnityEngine.Profiling;
+using UnityEngine.Rendering;
+
+namespace FidelityFX.FSR3
+{
+    /// <summary>
+    /// Base class for all of the compute passes that make up the FSR3 Upscaler process.
+    /// This loosely matches the FfxPipelineState struct from the original FSR3 codebase, wrapped in an object-oriented blanket.
+    /// These classes are responsible for loading compute shaders, managing temporary resources, binding resources to shader kernels and dispatching said shaders.
+    /// </summary>
+    internal abstract class Fsr3UpscalerPass: IDisposable
+    {
+        protected readonly Fsr3Upscaler.ContextDescription ContextDescription;
+        protected readonly Fsr3UpscalerResources Resources;
+        protected readonly ComputeBuffer Constants;
+        
+        protected ComputeShader ComputeShader;
+        protected int KernelIndex;
+
+        protected CustomSampler Sampler;
+        
+        protected Fsr3UpscalerPass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants)
+        {
+            ContextDescription = contextDescription;
+            Resources = resources;
+            Constants = constants;
+        }
+
+        public virtual void Dispose()
+        {
+        }
+
+        public void ScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+            commandBuffer.BeginSample(Sampler);
+            DoScheduleDispatch(commandBuffer, dispatchParams, frameIndex, dispatchX, dispatchY);
+            commandBuffer.EndSample(Sampler);
+        }
+
+        protected abstract void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY);
+        
+        protected void InitComputeShader(string passName, ComputeShader shader)
+        {
+            InitComputeShader(passName, shader, ContextDescription.Flags);
+        }
+        
+        private void InitComputeShader(string passName, ComputeShader shader, Fsr3Upscaler.InitializationFlags flags)
+        {
+            if (shader == null)
+            {
+                throw new MissingReferenceException($"Shader for FSR3 Upscaler pass '{passName}' could not be loaded! Please ensure it is included in the project correctly.");
+            }
+
+            ComputeShader = shader;
+            KernelIndex = ComputeShader.FindKernel("CS");
+            Sampler = CustomSampler.Create(passName);
+
+            bool useLut = false;
+#if UNITY_2022_1_OR_NEWER   // This will also work in 2020.3.43+ and 2021.3.14+ 
+            if (SystemInfo.computeSubGroupSize == 64)
+            {
+                useLut = true;
+            }
+#endif
+            
+            // This matches the permutation rules from the CreatePipeline* functions
+            if ((flags & Fsr3Upscaler.InitializationFlags.EnableHighDynamicRange) != 0) ComputeShader.EnableKeyword("FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT");
+            if ((flags & Fsr3Upscaler.InitializationFlags.EnableDisplayResolutionMotionVectors) == 0) ComputeShader.EnableKeyword("FFX_FSR3UPSCALER_OPTION_LOW_RESOLUTION_MOTION_VECTORS");
+            if ((flags & Fsr3Upscaler.InitializationFlags.EnableMotionVectorsJitterCancellation) != 0) ComputeShader.EnableKeyword("FFX_FSR3UPSCALER_OPTION_JITTERED_MOTION_VECTORS");
+            if ((flags & Fsr3Upscaler.InitializationFlags.EnableDepthInverted) != 0) ComputeShader.EnableKeyword("FFX_FSR3UPSCALER_OPTION_INVERTED_DEPTH");
+            if (useLut) ComputeShader.EnableKeyword("FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE");
+            if ((flags & Fsr3Upscaler.InitializationFlags.EnableFP16Usage) != 0) ComputeShader.EnableKeyword("FFX_HALF");
+        }
+    }
+    
+    internal class Fsr3UpscalerPrepareInputsPass : Fsr3UpscalerPass
+    {
+        public Fsr3UpscalerPrepareInputsPass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants)
+            : base(contextDescription, resources, constants)
+        {
+            InitComputeShader("Prepare Inputs", contextDescription.Shaders.prepareInputsPass);
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+            ref var color = ref dispatchParams.Color;
+            ref var depth = ref dispatchParams.Depth;
+            ref var motionVectors = ref dispatchParams.MotionVectors;
+            
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputColor, color.RenderTarget, color.MipLevel, color.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputDepth, depth.RenderTarget, depth.MipLevel, depth.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputMotionVectors, motionVectors.RenderTarget, motionVectors.MipLevel, motionVectors.SubElement);
+            
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavDilatedMotionVectors, Resources.DilatedVelocity);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavDilatedDepth, Resources.DilatedDepth);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavReconstructedPrevNearestDepth, Resources.ReconstructedPrevNearestDepth);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavFarthestDepth, Fsr3ShaderIDs.UavIntermediate);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavCurrentLuma, Resources.Luma[frameIndex]);
+            
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbFsr3Upscaler, Constants, 0, Marshal.SizeOf<Fsr3Upscaler.UpscalerConstants>());
+            
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+        }
+    }
+
+    internal class Fsr3UpscalerLumaPyramidPass : Fsr3UpscalerPass
+    {
+        private readonly ComputeBuffer _spdConstants;
+        
+        public Fsr3UpscalerLumaPyramidPass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants, ComputeBuffer spdConstants)
+            : base(contextDescription, resources, constants)
+        {
+            _spdConstants = spdConstants;
+            
+            InitComputeShader("Compute Luminance Pyramid", contextDescription.Shaders.lumaPyramidPass);
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvCurrentLuma, Resources.Luma[frameIndex]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvFarthestDepth, Fsr3ShaderIDs.UavIntermediate);
+
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdAtomicCount, Resources.SpdAtomicCounter);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavFrameInfo, Resources.FrameInfo);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip0, Resources.SpdMips, 0);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip1, Resources.SpdMips, 1);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip2, Resources.SpdMips, 2);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip3, Resources.SpdMips, 3);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip4, Resources.SpdMips, 4);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip5, Resources.SpdMips, 5);
+
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbFsr3Upscaler, Constants, 0, Marshal.SizeOf<Fsr3Upscaler.UpscalerConstants>());
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbSpd, _spdConstants, 0, Marshal.SizeOf<Fsr3Upscaler.SpdConstants>());
+            
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+        }
+    }
+
+    internal class Fsr3UpscalerShadingChangePyramidPass : Fsr3UpscalerPass
+    {
+        private readonly ComputeBuffer _spdConstants;
+        
+        public Fsr3UpscalerShadingChangePyramidPass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants, ComputeBuffer spdConstants)
+            : base(contextDescription, resources, constants)
+        {
+            _spdConstants = spdConstants;
+            
+            InitComputeShader("Compute Shading Change Pyramid", contextDescription.Shaders.shadingChangePyramidPass);
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+            ref var exposure = ref dispatchParams.Exposure;
+            
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvCurrentLuma, Resources.Luma[frameIndex]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvPreviousLuma, Resources.Luma[frameIndex ^ 1]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvDilatedMotionVectors, Resources.DilatedVelocity);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputExposure, exposure.RenderTarget, exposure.MipLevel, exposure.SubElement);
+            
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdAtomicCount, Resources.SpdAtomicCounter);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip0, Resources.SpdMips, 0);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip1, Resources.SpdMips, 1);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip2, Resources.SpdMips, 2);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip3, Resources.SpdMips, 3);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip4, Resources.SpdMips, 4);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavSpdMip5, Resources.SpdMips, 5);
+            
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbFsr3Upscaler, Constants, 0, Marshal.SizeOf<Fsr3Upscaler.UpscalerConstants>());
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbSpd, _spdConstants, 0, Marshal.SizeOf<Fsr3Upscaler.SpdConstants>());
+            
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+        }
+    }
+    
+    internal class Fsr3UpscalerShadingChangePass : Fsr3UpscalerPass
+    {
+        public Fsr3UpscalerShadingChangePass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants)
+            : base(contextDescription, resources, constants)
+        {
+            InitComputeShader("Compute Shading Change", contextDescription.Shaders.shadingChangePass);
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvSpdMips, Resources.SpdMips);
+            
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbFsr3Upscaler, Constants, 0, Marshal.SizeOf<Fsr3Upscaler.UpscalerConstants>());
+            
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+        }
+    }
+
+    internal class Fsr3UpscalerPrepareReactivityPass : Fsr3UpscalerPass
+    {
+        public Fsr3UpscalerPrepareReactivityPass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants)
+            : base(contextDescription, resources, constants)
+        {
+            InitComputeShader("Prepare Reactivity", contextDescription.Shaders.prepareReactivityPass);
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+            ref var exposure = ref dispatchParams.Exposure;
+            ref var reactive = ref dispatchParams.Reactive;
+            ref var tac = ref dispatchParams.TransparencyAndComposition;
+
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvReconstructedPrevNearestDepth, Resources.ReconstructedPrevNearestDepth);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvDilatedMotionVectors, Resources.DilatedVelocity);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvDilatedDepth, Resources.DilatedDepth);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvReactiveMask, reactive.RenderTarget, reactive.MipLevel, reactive.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvTransparencyAndCompositionMask, tac.RenderTarget, tac.MipLevel, tac.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvAccumulation, Resources.Accumulation[frameIndex ^ 1]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvShadingChange, Fsr3ShaderIDs.UavShadingChange);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvCurrentLuma, Resources.Luma[frameIndex]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputExposure, exposure.RenderTarget, exposure.MipLevel, exposure.SubElement);
+
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavAccumulation, Resources.Accumulation[frameIndex]); 
+
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbFsr3Upscaler, Constants, 0, Marshal.SizeOf<Fsr3Upscaler.UpscalerConstants>());
+            
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+        }
+    }
+
+    internal class Fsr3UpscalerLumaInstabilityPass : Fsr3UpscalerPass
+    {
+        public Fsr3UpscalerLumaInstabilityPass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants)
+            : base(contextDescription, resources, constants)
+        {
+            InitComputeShader("Compute Luminance Instability", contextDescription.Shaders.lumaInstabilityPass);
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+            ref var exposure = ref dispatchParams.Exposure;
+            
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputExposure, exposure.RenderTarget, exposure.MipLevel, exposure.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvDilatedReactiveMasks, Fsr3ShaderIDs.UavDilatedReactiveMasks);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvDilatedMotionVectors, Resources.DilatedVelocity);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvFrameInfo, Resources.FrameInfo);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvLumaHistory, Resources.LumaHistory[frameIndex ^ 1]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvFarthestDepthMip1, Fsr3ShaderIDs.UavFarthestDepthMip1);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvCurrentLuma, Resources.Luma[frameIndex]);
+
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavLumaHistory, Resources.LumaHistory[frameIndex]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavLumaInstability, Fsr3ShaderIDs.UavIntermediate);
+            
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbFsr3Upscaler, Constants, 0, Marshal.SizeOf<Fsr3Upscaler.UpscalerConstants>());
+            
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+        }
+    }
+    
+    internal class Fsr3UpscalerAccumulatePass : Fsr3UpscalerPass
+    {
+        private const string SharpeningKeyword = "FFX_FSR3UPSCALER_OPTION_APPLY_SHARPENING";
+    
+#if UNITY_2021_2_OR_NEWER
+        private readonly LocalKeyword _sharpeningKeyword;
+#endif
+        
+        public Fsr3UpscalerAccumulatePass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants)
+            : base(contextDescription, resources, constants)
+        {
+            InitComputeShader("Accumulate", contextDescription.Shaders.accumulatePass);
+#if UNITY_2021_2_OR_NEWER
+            _sharpeningKeyword = new LocalKeyword(ComputeShader, SharpeningKeyword);
+#endif
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+#if UNITY_2021_2_OR_NEWER
+            if (dispatchParams.EnableSharpening)
+                commandBuffer.EnableKeyword(ComputeShader, _sharpeningKeyword);
+            else
+                commandBuffer.DisableKeyword(ComputeShader, _sharpeningKeyword);
+#else
+            if (dispatchParams.EnableSharpening)
+                commandBuffer.EnableShaderKeyword(SharpeningKeyword);
+            else
+                commandBuffer.DisableShaderKeyword(SharpeningKeyword);
+#endif
+            
+            ref var color = ref dispatchParams.Color;
+            ref var exposure = ref dispatchParams.Exposure;
+            ref var output = ref dispatchParams.Output;
+            
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputExposure, exposure.RenderTarget, exposure.MipLevel, exposure.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvDilatedReactiveMasks, Fsr3ShaderIDs.UavDilatedReactiveMasks);
+            
+            if ((ContextDescription.Flags & Fsr3Upscaler.InitializationFlags.EnableDisplayResolutionMotionVectors) == 0)
+            {
+                commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvDilatedMotionVectors, Resources.DilatedVelocity);
+            }
+            else
+            {
+                ref var motionVectors = ref dispatchParams.MotionVectors;
+                commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputMotionVectors, motionVectors.RenderTarget, motionVectors.MipLevel, motionVectors.SubElement);
+            }
+
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInternalUpscaled, Resources.InternalUpscaled[frameIndex ^ 1]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvLanczosLut, Resources.LanczosLut);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvFarthestDepthMip1, Fsr3ShaderIDs.UavFarthestDepthMip1);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvCurrentLuma, Resources.Luma[frameIndex]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvLumaInstability, Fsr3ShaderIDs.UavIntermediate);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputColor, color.RenderTarget, color.MipLevel, color.SubElement);
+            
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavInternalUpscaled, Resources.InternalUpscaled[frameIndex]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavUpscaledOutput, output.RenderTarget, output.MipLevel, output.SubElement);
+
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbFsr3Upscaler, Constants, 0, Marshal.SizeOf<Fsr3Upscaler.UpscalerConstants>());
+            
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+        }
+    }
+
+    internal class Fsr3UpscalerSharpenPass : Fsr3UpscalerPass
+    {
+        private readonly ComputeBuffer _rcasConstants;
+
+        public Fsr3UpscalerSharpenPass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants, ComputeBuffer rcasConstants)
+            : base(contextDescription, resources, constants)
+        {
+            _rcasConstants = rcasConstants;
+            
+            InitComputeShader("RCAS Sharpening", contextDescription.Shaders.sharpenPass);
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+            ref var exposure = ref dispatchParams.Exposure;
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputExposure, exposure.RenderTarget, exposure.MipLevel, exposure.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvRcasInput, Resources.InternalUpscaled[frameIndex]);
+            
+            ref var output = ref dispatchParams.Output;
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavUpscaledOutput, output.RenderTarget, output.MipLevel, output.SubElement);
+
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbFsr3Upscaler, Constants, 0, Marshal.SizeOf<Fsr3Upscaler.UpscalerConstants>());
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbRcas, _rcasConstants, 0, Marshal.SizeOf<Fsr3Upscaler.RcasConstants>());
+
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+        }
+    }
+
+    internal class Fsr3UpscalerGenerateReactivePass : Fsr3UpscalerPass
+    {
+        private readonly ComputeBuffer _generateReactiveConstants;
+
+        public Fsr3UpscalerGenerateReactivePass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer generateReactiveConstants)
+            : base(contextDescription, resources, null)
+        {
+            _generateReactiveConstants = generateReactiveConstants;
+            
+            InitComputeShader("Auto-Generate Reactive Mask", contextDescription.Shaders.autoGenReactivePass);
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+        }
+
+        public void ScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.GenerateReactiveDescription dispatchParams, int dispatchX, int dispatchY)
+        {
+            commandBuffer.BeginSample(Sampler);
+            
+            ref var opaqueOnly = ref dispatchParams.ColorOpaqueOnly;
+            ref var color = ref dispatchParams.ColorPreUpscale;
+            ref var reactive = ref dispatchParams.OutReactive;
+            
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvOpaqueOnly, opaqueOnly.RenderTarget, opaqueOnly.MipLevel, opaqueOnly.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputColor, color.RenderTarget, color.MipLevel, color.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavAutoReactive, reactive.RenderTarget, reactive.MipLevel, reactive.SubElement);
+            
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbGenReactive, _generateReactiveConstants, 0, Marshal.SizeOf<Fsr3Upscaler.GenerateReactiveConstants>());
+            
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+            
+            commandBuffer.EndSample(Sampler);
+        }
+    }
+
+    internal class Fsr3UpscalerTcrAutogeneratePass : Fsr3UpscalerPass
+    {
+        private readonly ComputeBuffer _tcrAutogenerateConstants;
+
+        public Fsr3UpscalerTcrAutogeneratePass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants, ComputeBuffer tcrAutogenerateConstants)
+            : base(contextDescription, resources, constants)
+        {
+            _tcrAutogenerateConstants = tcrAutogenerateConstants;
+            
+            InitComputeShader("Auto-Generate Transparency & Composition Mask", contextDescription.Shaders.tcrAutoGenPass);
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+            ref var color = ref dispatchParams.Color;
+            ref var motionVectors = ref dispatchParams.MotionVectors;
+            ref var opaqueOnly = ref dispatchParams.ColorOpaqueOnly;
+            ref var reactive = ref dispatchParams.Reactive;
+            ref var tac = ref dispatchParams.TransparencyAndComposition;
+            
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvOpaqueOnly, opaqueOnly.RenderTarget, opaqueOnly.MipLevel, opaqueOnly.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputColor, color.RenderTarget, color.MipLevel, color.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputMotionVectors, motionVectors.RenderTarget, motionVectors.MipLevel, motionVectors.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvPrevColorPreAlpha, Resources.PrevPreAlpha[frameIndex ^ 1]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvPrevColorPostAlpha, Resources.PrevPostAlpha[frameIndex ^ 1]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvReactiveMask, reactive.RenderTarget, reactive.MipLevel, reactive.SubElement);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvTransparencyAndCompositionMask, tac.RenderTarget, tac.MipLevel, tac.SubElement);
+
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavAutoReactive, Resources.AutoReactive);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavAutoComposition, Resources.AutoComposition);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavPrevColorPreAlpha, Resources.PrevPreAlpha[frameIndex]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavPrevColorPostAlpha, Resources.PrevPostAlpha[frameIndex]);
+            
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbFsr3Upscaler, Constants, 0, Marshal.SizeOf<Fsr3Upscaler.UpscalerConstants>());
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbGenReactive, _tcrAutogenerateConstants, 0, Marshal.SizeOf<Fsr3Upscaler.GenerateReactiveConstants2>());
+            
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+        }
+    }
+
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+    internal class Fsr3UpscalerDebugViewPass : Fsr3UpscalerPass
+    {
+        public Fsr3UpscalerDebugViewPass(Fsr3Upscaler.ContextDescription contextDescription, Fsr3UpscalerResources resources, ComputeBuffer constants)
+            : base(contextDescription, resources, constants)
+        {
+            InitComputeShader("Debug View", contextDescription.Shaders.debugViewPass);
+        }
+
+        protected override void DoScheduleDispatch(CommandBuffer commandBuffer, Fsr3Upscaler.DispatchDescription dispatchParams, int frameIndex, int dispatchX, int dispatchY)
+        {
+            ref var exposure = ref dispatchParams.Exposure;
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvDilatedReactiveMasks, Fsr3ShaderIDs.UavDilatedReactiveMasks);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvDilatedMotionVectors, Resources.DilatedVelocity);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvDilatedDepth, Resources.DilatedDepth);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInternalUpscaled, Resources.InternalUpscaled[frameIndex]);
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.SrvInputExposure, exposure.RenderTarget, exposure.MipLevel, exposure.SubElement);
+            
+            ref var output = ref dispatchParams.Output;
+            commandBuffer.SetComputeTextureParam(ComputeShader, KernelIndex, Fsr3ShaderIDs.UavUpscaledOutput, output.RenderTarget, output.MipLevel, output.SubElement);
+            
+            commandBuffer.SetComputeConstantBufferParam(ComputeShader, Fsr3ShaderIDs.CbFsr3Upscaler, Constants, 0, Marshal.SizeOf<Fsr3Upscaler.UpscalerConstants>());
+            
+            commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
+        }
+    }
+#endif
+}

Assets/Scripts/Core/Fsr3UpscalerResources.cs

@@ -0,0 +1,245 @@
+// Copyright (c) 2024 Nico de Poel
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Rendering;
+
+namespace FidelityFX.FSR3
+{
+    /// <summary>
+    /// Helper class for bundling and managing persistent resources required by the FSR3 Upscaler process.
+    /// This includes lookup tables, default fallback resources and double-buffered resources that get swapped between frames.
+    /// </summary>
+    internal class Fsr3UpscalerResources
+    {
+        public Texture2D LanczosLut;
+        public Texture2D DefaultExposure;
+        public Texture2D DefaultReactive;
+        
+        public RenderTexture SpdAtomicCounter;
+        public RenderTexture SpdMips;
+        public RenderTexture DilatedVelocity;
+        public RenderTexture DilatedDepth;
+        public RenderTexture ReconstructedPrevNearestDepth;
+        public RenderTexture FrameInfo;
+        public RenderTexture AutoReactive;
+        public RenderTexture AutoComposition;
+        
+        public readonly RenderTexture[] Accumulation = new RenderTexture[2];
+        public readonly RenderTexture[] Luma = new RenderTexture[2];
+        public readonly RenderTexture[] InternalUpscaled = new RenderTexture[2];
+        public readonly RenderTexture[] LumaHistory = new RenderTexture[2];
+        public readonly RenderTexture[] PrevPreAlpha = new RenderTexture[2];
+        public readonly RenderTexture[] PrevPostAlpha = new RenderTexture[2];
+
+        public void Create(Fsr3Upscaler.ContextDescription contextDescription)
+        {
+            // Generate the data for the LUT
+            const int lanczos2LutWidth = 128;
+            float[] lanczos2Weights = new float[lanczos2LutWidth];
+            for (int currentLanczosWidthIndex = 0; currentLanczosWidthIndex < lanczos2LutWidth; ++currentLanczosWidthIndex)
+            {
+                float x = 2.0f * currentLanczosWidthIndex / (lanczos2LutWidth - 1);
+                float y = Fsr3Upscaler.Lanczos2(x);
+                lanczos2Weights[currentLanczosWidthIndex] = y;
+            }
+
+            Vector2Int maxRenderSize = contextDescription.MaxRenderSize;
+            Vector2Int maxRenderSizeDiv2 = maxRenderSize / 2;
+            
+            // Resource FSR3UPSCALER_LanczosLutData: FFX_RESOURCE_USAGE_READ_ONLY, FFX_SURFACE_FORMAT_R16_SNORM, FFX_RESOURCE_FLAGS_NONE
+            // R16_SNorm textures are not supported by Unity on most platforms, strangely enough. So instead we use R32_SFloat and upload pre-normalized float data.
+            LanczosLut = new Texture2D(lanczos2LutWidth, 1, GraphicsFormat.R32_SFloat, TextureCreationFlags.None) { name = "FSR3UPSCALER_LanczosLutData" };
+            LanczosLut.SetPixelData(lanczos2Weights, 0);
+            LanczosLut.Apply();
+            
+            // Resource FSR3UPSCALER_DefaultReactivityMask: FFX_RESOURCE_USAGE_READ_ONLY, FFX_SURFACE_FORMAT_R8_UNORM, FFX_RESOURCE_FLAGS_NONE
+            DefaultReactive = new Texture2D(1, 1, GraphicsFormat.R8_UNorm, TextureCreationFlags.None) { name = "FSR3UPSCALER_DefaultReactivityMask" };
+            DefaultReactive.SetPixel(0, 0, Color.clear);
+            DefaultReactive.Apply();
+            
+            // Resource FSR3UPSCALER_DefaultExposure: FFX_RESOURCE_USAGE_READ_ONLY, FFX_SURFACE_FORMAT_R32G32_FLOAT, FFX_RESOURCE_FLAGS_NONE
+            DefaultExposure = new Texture2D(1, 1, GraphicsFormat.R32G32_SFloat, TextureCreationFlags.None) { name = "FSR3UPSCALER_DefaultExposure" };
+            DefaultExposure.SetPixel(0, 0, Color.clear);
+            DefaultExposure.Apply();
+            
+            // Resource FSR3UPSCALER_SpdAtomicCounter: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R32_UINT, FFX_RESOURCE_FLAGS_ALIASABLE
+            // Despite what the original FSR3 codebase says, this resource really isn't aliasable. Resetting this counter to 0 every frame breaks auto-exposure on MacOS Metal.
+            SpdAtomicCounter = new RenderTexture(1, 1, 0, GraphicsFormat.R32_UInt) { name = "FSR3UPSCALER_SpdAtomicCounter", enableRandomWrite = true };
+            SpdAtomicCounter.Create();
+            
+            // Resource FSR3UPSCALER_SpdMips: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16G16_FLOAT, FFX_RESOURCE_FLAGS_ALIASABLE
+            // This is a rather special case: it's an aliasable resource, but because we require a mipmap chain and bind specific mip levels per shader, we can't easily use temporary RTs for this.
+            int mipCount = 1 + Mathf.FloorToInt(Mathf.Log(Math.Max(maxRenderSizeDiv2.x, maxRenderSizeDiv2.y), 2.0f));
+            SpdMips = new RenderTexture(maxRenderSizeDiv2.x, maxRenderSizeDiv2.y, 0, GraphicsFormat.R16G16_SFloat, mipCount) { name = "FSR3UPSCALER_SpdMips", enableRandomWrite = true, useMipMap = true, autoGenerateMips = false };
+            SpdMips.Create();
+            
+            // Resource FSR3UPSCALER_DilatedVelocity: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16G16_FLOAT, FFX_RESOURCE_FLAGS_NONE
+            DilatedVelocity = new RenderTexture(maxRenderSize.x, maxRenderSize.y, 0, GraphicsFormat.R16G16_SFloat) { name = "FSR3UPSCALER_DilatedVelocity", enableRandomWrite = true };
+            DilatedVelocity.Create();
+            
+            // Resource FSR3UPSCALER_DilatedDepth: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R32_FLOAT, FFX_RESOURCE_FLAGS_NONE
+            DilatedDepth = new RenderTexture(maxRenderSize.x, maxRenderSize.y, 0, GraphicsFormat.R32_SFloat) { name = "FSR3UPSCALER_DilatedDepth", enableRandomWrite = true };
+            DilatedDepth.Create();
+            
+            // Resource FSR3UPSCALER_ReconstructedPrevNearestDepth: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R32_UINT, FFX_RESOURCE_FLAGS_NONE
+            ReconstructedPrevNearestDepth = new RenderTexture(maxRenderSize.x, maxRenderSize.y, 0, GraphicsFormat.R32_UInt) { name = "FSR3UPSCALER_ReconstructedPrevNearestDepth", enableRandomWrite = true };
+            ReconstructedPrevNearestDepth.Create();
+            
+            // Resource FSR3UPSCALER_FrameInfo: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R32G32B32A32_FLOAT, FFX_RESOURCE_FLAGS_NONE
+            FrameInfo = new RenderTexture(1, 1, 0, GraphicsFormat.R32G32B32A32_SFloat) { name = "FSR3UPSCALER_FrameInfo", enableRandomWrite = true };
+            FrameInfo.Create();
+
+            // Resources FSR3UPSCALER_Accumulation1/2: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8_UNORM, FFX_RESOURCE_FLAGS_NONE
+            CreateDoubleBufferedResource(Accumulation, "FSR3UPSCALER_Accumulation", maxRenderSize, GraphicsFormat.R8_UNorm);
+            
+            // Resources FSR3UPSCALER_Luma1/2: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16_FLOAT, FFX_RESOURCE_FLAGS_NONE
+            CreateDoubleBufferedResource(Luma, "FSR3UPSCALER_Luma", maxRenderSize, GraphicsFormat.R16_SFloat);
+            
+            // Resources FSR3UPSCALER_InternalUpscaled1/2: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, FFX_RESOURCE_FLAGS_NONE
+            CreateDoubleBufferedResource(InternalUpscaled, "FSR3UPSCALER_InternalUpscaled", contextDescription.MaxUpscaleSize, GraphicsFormat.R16G16B16A16_SFloat);
+            
+            // Resources FSR3UPSCALER_LumaHistory1/2: FFX_RESOURCE_USAGE_RENDERTARGET | FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16G16B16A16_FLOAT, FFX_RESOURCE_FLAGS_NONE
+            CreateDoubleBufferedResource(LumaHistory, "FSR3UPSCALER_LumaHistory", maxRenderSize, GraphicsFormat.R16G16B16A16_SFloat);
+        }
+
+        public void CreateTcrAutogenResources(Fsr3Upscaler.ContextDescription contextDescription)
+        {
+            // Resource FSR3UPSCALER_AutoReactive: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8_UNORM, FFX_RESOURCE_FLAGS_NONE
+            AutoReactive = new RenderTexture(contextDescription.MaxRenderSize.x, contextDescription.MaxRenderSize.y, 0, GraphicsFormat.R8_UNorm) { name = "FSR3UPSCALER_AutoReactive", enableRandomWrite = true };
+            AutoReactive.Create();
+
+            // Resource FSR3UPSCALER_AutoComposition: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8_UNORM, FFX_RESOURCE_FLAGS_NONE
+            AutoComposition = new RenderTexture(contextDescription.MaxRenderSize.x, contextDescription.MaxRenderSize.y, 0, GraphicsFormat.R8_UNorm) { name = "FSR3UPSCALER_AutoComposition", enableRandomWrite = true };
+            AutoComposition.Create();
+
+            // Resources FSR3UPSCALER_PrevPreAlpha0/1: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R11G11B10_FLOAT, FFX_RESOURCE_FLAGS_NONE
+            CreateDoubleBufferedResource(PrevPreAlpha, "FSR3UPSCALER_PrevPreAlpha", contextDescription.MaxRenderSize, GraphicsFormat.B10G11R11_UFloatPack32);
+
+            // Resources FSR3UPSCALER_PrevPostAlpha0/1: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R11G11B10_FLOAT, FFX_RESOURCE_FLAGS_NONE
+            CreateDoubleBufferedResource(PrevPostAlpha, "FSR3UPSCALER_PrevPostAlpha", contextDescription.MaxRenderSize, GraphicsFormat.B10G11R11_UFloatPack32);
+        }
+        
+        // Set up shared aliasable resources, i.e. temporary render textures
+        // These do not need to persist between frames, but they do need to be available between passes
+        public static void CreateAliasableResources(CommandBuffer commandBuffer, Fsr3Upscaler.ContextDescription contextDescription, Fsr3Upscaler.DispatchDescription dispatchParams)
+        {
+            Vector2Int maxUpscaleSize = contextDescription.MaxUpscaleSize;
+            Vector2Int maxRenderSize = contextDescription.MaxRenderSize;
+            Vector2Int maxRenderSizeDiv2 = maxRenderSize / 2;
+            
+            // FSR3UPSCALER_IntermediateFp16x1: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16_FLOAT, FFX_RESOURCE_FLAGS_ALIASABLE
+            commandBuffer.GetTemporaryRT(Fsr3ShaderIDs.UavIntermediate, maxRenderSize.x, maxRenderSize.y, 0, default, GraphicsFormat.R16_SFloat, 1, true);
+            
+            // FSR3UPSCALER_ShadingChange: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8_UNORM, FFX_RESOURCE_FLAGS_ALIASABLE
+            commandBuffer.GetTemporaryRT(Fsr3ShaderIDs.UavShadingChange, maxRenderSizeDiv2.x, maxRenderSizeDiv2.y, 0, default, GraphicsFormat.R8_UNorm, 1, true);
+            
+            // FSR3UPSCALER_NewLocks: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8_UNORM, FFX_RESOURCE_FLAGS_ALIASABLE
+            commandBuffer.GetTemporaryRT(Fsr3ShaderIDs.UavNewLocks, maxUpscaleSize.x, maxUpscaleSize.y, 0, default, GraphicsFormat.R8_UNorm, 1, true);
+            
+            // FSR3UPSCALER_FarthestDepthMip1: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R16_FLOAT, FFX_RESOURCE_FLAGS_ALIASABLE
+            commandBuffer.GetTemporaryRT(Fsr3ShaderIDs.UavFarthestDepthMip1, maxRenderSizeDiv2.x, maxRenderSizeDiv2.y, 0, default, GraphicsFormat.R16_SFloat, 1, true);
+            
+            // FSR3UPSCALER_DilatedReactiveMasks: FFX_RESOURCE_USAGE_UAV, FFX_SURFACE_FORMAT_R8G8B8A8_UNORM, FFX_RESOURCE_FLAGS_ALIASABLE
+            commandBuffer.GetTemporaryRT(Fsr3ShaderIDs.UavDilatedReactiveMasks, maxRenderSize.x, maxRenderSize.y, 0, default, GraphicsFormat.R8G8B8A8_UNorm, 1, true);
+        }
+
+        public static void DestroyAliasableResources(CommandBuffer commandBuffer)
+        {
+            // Release all of the aliasable resources used this frame
+            commandBuffer.ReleaseTemporaryRT(Fsr3ShaderIDs.UavDilatedReactiveMasks);
+            commandBuffer.ReleaseTemporaryRT(Fsr3ShaderIDs.UavFarthestDepthMip1);
+            commandBuffer.ReleaseTemporaryRT(Fsr3ShaderIDs.UavNewLocks);
+            commandBuffer.ReleaseTemporaryRT(Fsr3ShaderIDs.UavShadingChange);
+            commandBuffer.ReleaseTemporaryRT(Fsr3ShaderIDs.UavIntermediate);
+        }
+
+        private static void CreateDoubleBufferedResource(RenderTexture[] resource, string name, Vector2Int size, GraphicsFormat format)
+        {
+            for (int i = 0; i < 2; ++i)
+            {
+                resource[i] = new RenderTexture(size.x, size.y, 0, format) { name = name + (i + 1), enableRandomWrite = true };
+                resource[i].Create();
+            }
+        }
+
+        public void Destroy()
+        {
+            DestroyTcrAutogenResources();
+            
+            DestroyResource(LumaHistory);
+            DestroyResource(InternalUpscaled);
+            DestroyResource(Luma);
+            DestroyResource(Accumulation);
+            
+            DestroyResource(ref FrameInfo);
+            DestroyResource(ref ReconstructedPrevNearestDepth);
+            DestroyResource(ref DilatedDepth);
+            DestroyResource(ref DilatedVelocity);
+            DestroyResource(ref SpdMips);
+            DestroyResource(ref SpdAtomicCounter);
+            
+            DestroyResource(ref DefaultReactive);
+            DestroyResource(ref DefaultExposure);
+            DestroyResource(ref LanczosLut);
+        }
+
+        public void DestroyTcrAutogenResources()
+        {
+            DestroyResource(PrevPostAlpha);
+            DestroyResource(PrevPreAlpha);
+            DestroyResource(ref AutoComposition);
+            DestroyResource(ref AutoReactive);
+        }
+        
+        private static void DestroyResource(ref Texture2D resource)
+        {
+            if (resource == null)
+                return;
+            
+#if UNITY_EDITOR
+            if (Application.isPlaying && !UnityEditor.EditorApplication.isPaused)
+                UnityEngine.Object.Destroy(resource);
+            else
+                UnityEngine.Object.DestroyImmediate(resource);
+#else
+            UnityEngine.Object.Destroy(resource);
+#endif
+            resource = null;
+        }
+
+        private static void DestroyResource(ref RenderTexture resource)
+        {
+            if (resource == null)
+                return;
+            
+            resource.Release();
+            resource = null;
+        }
+
+        private static void DestroyResource(RenderTexture[] resource)
+        {
+            for (int i = 0; i < resource.Length; ++i)
+                DestroyResource(ref resource[i]);
+        }
+    }
+}

Assets/Scripts/Core/ResourceView.cs

@@ -0,0 +1,55 @@
+// Copyright (c) 2024 Nico de Poel
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using UnityEngine.Rendering;
+
+namespace FidelityFX
+{
+    /// <summary>
+    /// An immutable structure wrapping all of the necessary information to bind a specific buffer or attachment of a render target to a compute shader.
+    /// </summary>
+    public readonly struct ResourceView
+    {
+        /// <summary>
+        /// This value is the equivalent of not setting any value at all; all struct fields will have their default values.
+        /// It does not refer to a valid texture, therefore any variable set to this value should be checked for IsValid and reassigned before being bound to a shader.
+        /// </summary>
+        public static readonly ResourceView Unassigned = new ResourceView(default);
+            
+        /// <summary>
+        /// This value contains a valid texture reference that can be bound to a shader, however it is just an empty placeholder texture.
+        /// Binding this to a shader can be seen as setting the texture variable inside the shader to null.
+        /// </summary>
+        public static readonly ResourceView None = new ResourceView(BuiltinRenderTextureType.None);
+            
+        public ResourceView(in RenderTargetIdentifier renderTarget, RenderTextureSubElement subElement = RenderTextureSubElement.Default, int mipLevel = 0)
+        {
+            RenderTarget = renderTarget;
+            SubElement = subElement;
+            MipLevel = mipLevel;
+        }
+            
+        public bool IsValid => !RenderTarget.Equals(default);
+            
+        public readonly RenderTargetIdentifier RenderTarget;
+        public readonly RenderTextureSubElement SubElement;
+        public readonly int MipLevel;
+    }
+}

Assets/Scripts/Core/ResourceView.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eb9fdfac33a070740b66520d88f43ab7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Debug/DebugDumper.cs

@@ -24,12 +24,13 @@ using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 using System.Text;
-using FidelityFX;
 using UnityEngine;
+using FidelityFX;
+using FidelityFX.FSR3;
 
 public class DebugDumper : MonoBehaviour
 {
-    private Fsr2ImageEffect _fsr;
+    private Fsr3UpscalerImageEffect _fsr;
 
     private float _scaleFactor = 1.0f;
     private float _lastScaleTime = 0f;
@@ -44,7 +45,7 @@ public class DebugDumper : MonoBehaviour
         
         Debug.Log(sb);
 
-        _fsr = GetComponent<Fsr2ImageEffect>();
+        _fsr = GetComponent<Fsr3UpscalerImageEffect>();
     }
 
     void OnEnable()
@@ -77,8 +78,8 @@ public class DebugDumper : MonoBehaviour
         if (Input.GetButtonDown("Fire2"))
         {
             int quality = (int)_fsr.qualityMode;
-            quality = (quality + 1) % Enum.GetValues(typeof(Fsr2.QualityMode)).Length;
-            _fsr.qualityMode = (Fsr2.QualityMode)quality;
+            quality = (quality + 1) % Enum.GetValues(typeof(Fsr3Upscaler.QualityMode)).Length;
+            _fsr.qualityMode = (Fsr3Upscaler.QualityMode)quality;
         }
 
         if (Input.GetButtonDown("Fire3"))
@@ -113,7 +114,7 @@ public class DebugDumper : MonoBehaviour
             GUI.matrix = Matrix4x4.Scale(new Vector3(scale, scale, scale));
         }
         
-        GUILayout.Label($"FSR2: {(_fsr.enabled ? "Enabled" : "Disabled")}");
+        GUILayout.Label($"FSR3 Upscaler: {(_fsr.enabled ? "Enabled" : "Disabled")}");
         GUILayout.Label($"Quality: {_fsr.qualityMode}");
         GUILayout.Label($"Auto-exposure: {(_fsr.enableAutoExposure ? "Enabled" : "Disabled")}");
         GUILayout.Label($"Scale: {_scaleFactor:0.00}");

Assets/Scripts/Fsr2CameraHelper.cs → Assets/Scripts/Fsr3UpscalerCameraHelper.cs

@@ -23,6 +23,7 @@ using System.Collections;
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Rendering;
+using FidelityFX.FSR3;
 
 namespace FidelityFX
 {
@@ -30,10 +31,10 @@ namespace FidelityFX
     /// 
     /// </summary>
     [RequireComponent(typeof(Camera))]
-    public class Fsr2CameraHelper : MonoBehaviour
+    public class Fsr3UpscalerCameraHelper : MonoBehaviour
     {
         [Tooltip("Standard scaling ratio presets.")]
-        public Fsr2.QualityMode qualityMode = Fsr2.QualityMode.Quality;
+        public Fsr3Upscaler.QualityMode qualityMode = Fsr3Upscaler.QualityMode.Quality;
 
         private Vector2Int _maxRenderSize;
         private Vector2Int _displaySize;
@@ -44,7 +45,7 @@ namespace FidelityFX
 
         private void OnEnable()
         {
-            // Set up the original camera to output all of the required FSR2 input resources at the desired resolution
+            // Set up the original camera to output all of the required FSR3 Upscaler input resources at the desired resolution
             _renderCamera = GetComponent<Camera>();
             _originalDepthTextureMode = _renderCamera.depthTextureMode;
             _renderCamera.depthTextureMode = _originalDepthTextureMode | DepthTextureMode.Depth | DepthTextureMode.MotionVectors;
@@ -60,12 +61,12 @@ namespace FidelityFX
         {
             // Determine the desired rendering and display resolutions
             _displaySize = GetDisplaySize();
-            Fsr2.GetRenderResolutionFromQualityMode(out var maxRenderWidth, out var maxRenderHeight, _displaySize.x, _displaySize.y, qualityMode);
+            Fsr3Upscaler.GetRenderResolutionFromQualityMode(out var maxRenderWidth, out var maxRenderHeight, _displaySize.x, _displaySize.y, qualityMode);
             _maxRenderSize = new Vector2Int(maxRenderWidth, maxRenderHeight);
 
             if (_maxRenderSize.x == 0 || _maxRenderSize.y == 0)
             {
-                Debug.LogError($"FSR2 render size is invalid: {_maxRenderSize.x}x{_maxRenderSize.y}. Please check your screen resolution and camera viewport parameters.");
+                Debug.LogError($"FSR3 Upscaler render size is invalid: {_maxRenderSize.x}x{_maxRenderSize.y}. Please check your screen resolution and camera viewport parameters.");
                 enabled = false;
             }
             
@@ -86,9 +87,9 @@ namespace FidelityFX
         {
             var scaledRenderSize = GetScaledRenderSize();
             
-            // Perform custom jittering of the camera's projection matrix according to FSR2's recipe
-            int jitterPhaseCount = Fsr2.GetJitterPhaseCount(scaledRenderSize.x, _displaySize.x);
-            Fsr2.GetJitterOffset(out float jitterX, out float jitterY, Time.frameCount, jitterPhaseCount);
+            // Perform custom jittering of the camera's projection matrix according to FSR3's recipe
+            int jitterPhaseCount = Fsr3Upscaler.GetJitterPhaseCount(scaledRenderSize.x, _displaySize.x);
+            Fsr3Upscaler.GetJitterOffset(out float jitterX, out float jitterY, Time.frameCount, jitterPhaseCount);
 
             jitterX = 2.0f * jitterX / scaledRenderSize.x;
             jitterY = 2.0f * jitterY / scaledRenderSize.y;

Assets/Scripts/Fsr2ImageEffect.cs → Assets/Scripts/Fsr3UpscalerImageEffect.cs

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Nico de Poel
+// Copyright (c) 2024 Nico de Poel
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -19,25 +19,25 @@
 // THE SOFTWARE.
 
 using System;
-using System.Collections;
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Rendering;
+using FidelityFX.FSR3;
 
 namespace FidelityFX
 {
     /// <summary>
-    /// This class is responsible for hooking into various Unity events and translating them to the FSR2 subsystem.
-    /// This includes creation and destruction of the FSR2 context, as well as dispatching commands at the right time.
-    /// This component also exposes various FSR2 parameters to the Unity inspector.
+    /// This class is responsible for hooking into various Unity events and translating them to the FSR3 Upscaler subsystem.
+    /// This includes creation and destruction of the FSR3 Upscaler context, as well as dispatching commands at the right time.
+    /// This component also exposes various FSR3 Upscaler parameters to the Unity inspector.
     /// </summary>
     [RequireComponent(typeof(Camera))]
-    public class Fsr2ImageEffect : MonoBehaviour
+    public class Fsr3UpscalerImageEffect : MonoBehaviour
     {
-        public IFsr2Callbacks Callbacks { get; set; } = new Fsr2CallbacksBase();
+        public IFsr3UpscalerCallbacks Callbacks { get; set; } = new Fsr3UpscalerCallbacksBase();
         
         [Tooltip("Standard scaling ratio presets.")]
-        public Fsr2.QualityMode qualityMode = Fsr2.QualityMode.Quality;
+        public Fsr3Upscaler.QualityMode qualityMode = Fsr3Upscaler.QualityMode.Quality;
 
         [Tooltip("Apply RCAS sharpening to the image after upscaling.")]
         public bool performSharpenPass = true;
@@ -55,6 +55,10 @@ namespace FidelityFX
         [Tooltip("Optional 1x1 texture containing the exposure value for the current frame.")]
         public Texture exposure = null;
 
+        [Header("Debug")]
+        [Tooltip("Enable a debug view to analyze the upscaling process.")]
+        public bool enableDebugView = false;
+
         [Header("Reactivity, Transparency & Composition")] 
         [Tooltip("Optional texture to control the influence of the current frame on the reconstructed output. If unset, either an auto-generated or a default cleared reactive mask will be used.")]
         public Texture reactiveMask = null;
@@ -76,7 +80,7 @@ namespace FidelityFX
             [Tooltip("A value to set for the binary reactive mask")]
             [Range(0, 1)] public float binaryValue = 0.9f;
             [Tooltip("Flags to determine how to generate the reactive mask")]
-            public Fsr2.GenerateReactiveFlags flags = Fsr2.GenerateReactiveFlags.ApplyTonemap | Fsr2.GenerateReactiveFlags.ApplyThreshold | Fsr2.GenerateReactiveFlags.UseComponentsMax;
+            public Fsr3Upscaler.GenerateReactiveFlags flags = Fsr3Upscaler.GenerateReactiveFlags.ApplyTonemap | Fsr3Upscaler.GenerateReactiveFlags.ApplyThreshold | Fsr3Upscaler.GenerateReactiveFlags.UseComponentsMax;
         }
 
         [Tooltip("(Experimental) Automatically generate and use Reactive mask and Transparency & composition mask internally.")]
@@ -98,25 +102,25 @@ namespace FidelityFX
             [Range(0, 1)] public float autoReactiveMax = 0.9f;
         }
 
-        [Header("Slave cameras")] 
-        public Fsr2CameraHelper[] cameraStack;
+        [SerializeField]
+        private Fsr3UpscalerAssets assets;
 
-        private Fsr2Context _context;
+        private Fsr3UpscalerContext _context;
         private Vector2Int _maxRenderSize;
         private Vector2Int _displaySize;
         private bool _resetHistory;
         
-        private readonly Fsr2.DispatchDescription _dispatchDescription = new Fsr2.DispatchDescription();
-        private readonly Fsr2.GenerateReactiveDescription _genReactiveDescription = new Fsr2.GenerateReactiveDescription();
+        private readonly Fsr3Upscaler.DispatchDescription _dispatchDescription = new Fsr3Upscaler.DispatchDescription();
+        private readonly Fsr3Upscaler.GenerateReactiveDescription _genReactiveDescription = new Fsr3Upscaler.GenerateReactiveDescription();
 
-        private Fsr2ImageEffectHelper _helper;
+        private Fsr3UpscalerImageEffectHelper _helper;
         
         private Camera _renderCamera;
         private RenderTexture _originalRenderTarget;
         private DepthTextureMode _originalDepthTextureMode;
         private Rect _originalRect;
 
-        private Fsr2.QualityMode _prevQualityMode;
+        private Fsr3Upscaler.QualityMode _prevQualityMode;
         private Vector2Int _prevDisplaySize;
         private bool _prevAutoExposure;
 
@@ -128,7 +132,7 @@ namespace FidelityFX
 
         private void OnEnable()
         {
-            // Set up the original camera to output all of the required FSR2 input resources at the desired resolution
+            // Set up the original camera to output all of the required FSR3 input resources at the desired resolution
             _renderCamera = GetComponent<Camera>();
             _originalRenderTarget = _renderCamera.targetTexture;
             _originalDepthTextureMode = _renderCamera.depthTextureMode;
@@ -137,48 +141,39 @@ namespace FidelityFX
             
             // Determine the desired rendering and display resolutions
             _displaySize = GetDisplaySize();
-            Fsr2.GetRenderResolutionFromQualityMode(out var maxRenderWidth, out var maxRenderHeight, _displaySize.x, _displaySize.y, qualityMode);
+            Fsr3Upscaler.GetRenderResolutionFromQualityMode(out var maxRenderWidth, out var maxRenderHeight, _displaySize.x, _displaySize.y, qualityMode);
             _maxRenderSize = new Vector2Int(maxRenderWidth, maxRenderHeight);
 
             if (!SystemInfo.supportsComputeShaders)
             {
-                Debug.LogError("FSR2 requires compute shader support!");
+                Debug.LogError("FSR3 Upscaler requires compute shader support!");
+                enabled = false;
+                return;
+            }
+            
+            if (assets == null)
+            {
+                Debug.LogError($"FSR3 Upscaler assets are not assigned! Please ensure an {nameof(Fsr3UpscalerAssets)} asset is assigned to the Assets property of this component.");
                 enabled = false;
                 return;
             }
 
             if (_maxRenderSize.x == 0 || _maxRenderSize.y == 0)
             {
-                Debug.LogError($"FSR2 render size is invalid: {_maxRenderSize.x}x{_maxRenderSize.y}. Please check your screen resolution and camera viewport parameters.");
+                Debug.LogError($"FSR3 Upscaler render size is invalid: {_maxRenderSize.x}x{_maxRenderSize.y}. Please check your screen resolution and camera viewport parameters.");
                 enabled = false;
                 return;
             }
             
-            _helper = GetComponent<Fsr2ImageEffectHelper>();
+            _helper = GetComponent<Fsr3UpscalerImageEffectHelper>();
             _copyWithDepthMaterial = new Material(Shader.Find("Hidden/BlitCopyWithDepth"));
             
             CreateFsrContext();
             CreateCommandBuffers();
-
-            if (cameraStack != null)
-            {
-                foreach (var cameraHelper in cameraStack)
-                {
-                    cameraHelper.enabled = true;
-                }
-            }
         }
 
         private void OnDisable()
         {
-            if (cameraStack != null)
-            {
-                foreach (var cameraHelper in cameraStack)
-                {
-                    cameraHelper.enabled = false;
-                }
-            }
-            
             DestroyCommandBuffers();
             DestroyFsrContext();
 
@@ -195,14 +190,14 @@ namespace FidelityFX
 
         private void CreateFsrContext()
         {
-            // Initialize FSR2 context
-            Fsr2.InitializationFlags flags = 0;
-            if (_renderCamera.allowHDR) flags |= Fsr2.InitializationFlags.EnableHighDynamicRange;
-            if (enableFP16) flags |= Fsr2.InitializationFlags.EnableFP16Usage;
-            if (enableAutoExposure) flags |= Fsr2.InitializationFlags.EnableAutoExposure;
-            if (UsingDynamicResolution()) flags |= Fsr2.InitializationFlags.EnableDynamicResolution;
+            // Initialize FSR3 Upscaler context
+            Fsr3Upscaler.InitializationFlags flags = 0;
+            if (_renderCamera.allowHDR) flags |= Fsr3Upscaler.InitializationFlags.EnableHighDynamicRange;
+            if (enableFP16) flags |= Fsr3Upscaler.InitializationFlags.EnableFP16Usage;
+            if (enableAutoExposure) flags |= Fsr3Upscaler.InitializationFlags.EnableAutoExposure;
+            if (UsingDynamicResolution()) flags |= Fsr3Upscaler.InitializationFlags.EnableDynamicResolution;
 
-            _context = Fsr2.CreateContext(_displaySize, _maxRenderSize, Callbacks, flags);
+            _context = Fsr3Upscaler.CreateContext(_displaySize, _maxRenderSize, assets.shaders, flags);
 
             _prevDisplaySize = _displaySize;
             _prevQualityMode = qualityMode;
@@ -224,8 +219,8 @@ namespace FidelityFX
 
         private void CreateCommandBuffers()
         {
-            _dispatchCommandBuffer = new CommandBuffer { name = "FSR2 Dispatch" };
-            _opaqueInputCommandBuffer = new CommandBuffer { name = "FSR2 Opaque Input" };
+            _dispatchCommandBuffer = new CommandBuffer { name = "FSR3 Upscaler Dispatch" };
+            _opaqueInputCommandBuffer = new CommandBuffer { name = "FSR3 Upscaler Opaque Input" };
             _renderCamera.AddCommandBuffer(CameraEvent.BeforeForwardAlpha, _opaqueInputCommandBuffer);
         }
 
@@ -248,7 +243,7 @@ namespace FidelityFX
         private void ApplyMipmapBias()
         {
             // Apply a mipmap bias so that textures retain their sharpness
-            float biasOffset = Fsr2.GetMipmapBiasOffset(_maxRenderSize.x, _displaySize.x);
+            float biasOffset = Fsr3Upscaler.GetMipmapBiasOffset(_maxRenderSize.x, _displaySize.x);
             if (!float.IsNaN(biasOffset) && !float.IsInfinity(biasOffset))
             {
                 Callbacks.ApplyMipmapBias(biasOffset);
@@ -263,7 +258,7 @@ namespace FidelityFX
 
         private void Update()
         {
-            // Monitor for any changes in parameters that require a reset of the FSR2 context
+            // Monitor for any changes in parameters that require a reset of the FSR3 Upscaler context
             var displaySize = GetDisplaySize();
             if (displaySize.x != _prevDisplaySize.x || displaySize.y != _prevDisplaySize.y || qualityMode != _prevQualityMode || enableAutoExposure != _prevAutoExposure)
             {
@@ -271,15 +266,6 @@ namespace FidelityFX
                 OnDisable();
                 OnEnable();
             }
-            
-            if (cameraStack != null)
-            {
-                int numCams = cameraStack.Length;
-                for (int i = 0; i < numCams; ++i)
-                {
-                    cameraStack[i].qualityMode = qualityMode;
-                }
-            }
         }
 
         public void ResetHistory()
@@ -324,40 +310,42 @@ namespace FidelityFX
 
         private void SetupDispatchDescription()
         {
-            // Set up the main FSR2 dispatch parameters
-            _dispatchDescription.Color = new Fsr2.ResourceView(BuiltinRenderTextureType.CameraTarget, RenderTextureSubElement.Color);
-            _dispatchDescription.Depth = new Fsr2.ResourceView(BuiltinRenderTextureType.CameraTarget, RenderTextureSubElement.Depth);
-            _dispatchDescription.MotionVectors = new Fsr2.ResourceView(BuiltinRenderTextureType.MotionVectors);
-            _dispatchDescription.Exposure = Fsr2.ResourceView.Unassigned;
-            _dispatchDescription.Reactive = Fsr2.ResourceView.Unassigned;
-            _dispatchDescription.TransparencyAndComposition = Fsr2.ResourceView.Unassigned;
-            
-            if (!enableAutoExposure && exposure != null) _dispatchDescription.Exposure = new Fsr2.ResourceView(exposure);
-            if (reactiveMask != null) _dispatchDescription.Reactive = new Fsr2.ResourceView(reactiveMask);
-            if (transparencyAndCompositionMask != null) _dispatchDescription.TransparencyAndComposition = new Fsr2.ResourceView(transparencyAndCompositionMask);
+            // Set up the main FSR3 Upscaler dispatch parameters
+            _dispatchDescription.Color = new ResourceView(BuiltinRenderTextureType.CameraTarget, RenderTextureSubElement.Color);
+            _dispatchDescription.Depth = new ResourceView(BuiltinRenderTextureType.CameraTarget, RenderTextureSubElement.Depth);
+            _dispatchDescription.MotionVectors = new ResourceView(BuiltinRenderTextureType.MotionVectors);
+            _dispatchDescription.Exposure = ResourceView.Unassigned;
+            _dispatchDescription.Reactive = ResourceView.Unassigned;
+            _dispatchDescription.TransparencyAndComposition = ResourceView.Unassigned;
+            
+            if (!enableAutoExposure && exposure != null) _dispatchDescription.Exposure = new ResourceView(exposure);
+            if (reactiveMask != null) _dispatchDescription.Reactive = new ResourceView(reactiveMask);
+            if (transparencyAndCompositionMask != null) _dispatchDescription.TransparencyAndComposition = new ResourceView(transparencyAndCompositionMask);
 
             var scaledRenderSize = GetScaledRenderSize();
             
-            _dispatchDescription.Output = new Fsr2.ResourceView(Fsr2ShaderIDs.UavUpscaledOutput);
+            _dispatchDescription.Output = new ResourceView(Fsr3ShaderIDs.UavUpscaledOutput);
             _dispatchDescription.PreExposure = preExposure;
             _dispatchDescription.EnableSharpening = performSharpenPass;
             _dispatchDescription.Sharpness = sharpness;
             _dispatchDescription.MotionVectorScale.x = -scaledRenderSize.x;
             _dispatchDescription.MotionVectorScale.y = -scaledRenderSize.y;
             _dispatchDescription.RenderSize = scaledRenderSize;
+            _dispatchDescription.UpscaleSize = _displaySize;
             _dispatchDescription.FrameTimeDelta = Time.unscaledDeltaTime;
             _dispatchDescription.CameraNear = _renderCamera.nearClipPlane;
             _dispatchDescription.CameraFar = _renderCamera.farClipPlane;
             _dispatchDescription.CameraFovAngleVertical = _renderCamera.fieldOfView * Mathf.Deg2Rad;
             _dispatchDescription.ViewSpaceToMetersFactor = 1.0f; // 1 unit is 1 meter in Unity
             _dispatchDescription.Reset = _resetHistory;
+            _dispatchDescription.Flags = enableDebugView ? Fsr3Upscaler.DispatchFlags.DrawDebugView : 0;
             _resetHistory = false;
 
             // Set up the parameters for the optional experimental auto-TCR feature
             _dispatchDescription.EnableAutoReactive = autoGenerateTransparencyAndComposition;
             if (autoGenerateTransparencyAndComposition)
             {
-                _dispatchDescription.ColorOpaqueOnly = new Fsr2.ResourceView(_colorOpaqueOnly);
+                _dispatchDescription.ColorOpaqueOnly = new ResourceView(_colorOpaqueOnly);
                 _dispatchDescription.AutoTcThreshold = generateTransparencyAndCompositionParameters.autoTcThreshold;
                 _dispatchDescription.AutoTcScale = generateTransparencyAndCompositionParameters.autoTcScale;
                 _dispatchDescription.AutoReactiveScale = generateTransparencyAndCompositionParameters.autoReactiveScale;
@@ -366,7 +354,7 @@ namespace FidelityFX
 
             if (SystemInfo.usesReversedZBuffer)
             {
-                // Swap the near and far clip plane distances as FSR2 expects this when using inverted depth
+                // Swap the near and far clip plane distances as FSR3 expects this when using inverted depth
                 (_dispatchDescription.CameraNear, _dispatchDescription.CameraFar) = (_dispatchDescription.CameraFar, _dispatchDescription.CameraNear);
             }
         }
@@ -374,9 +362,9 @@ namespace FidelityFX
         private void SetupAutoReactiveDescription()
         {
             // Set up the parameters to auto-generate a reactive mask
-            _genReactiveDescription.ColorOpaqueOnly = new Fsr2.ResourceView(_colorOpaqueOnly);
-            _genReactiveDescription.ColorPreUpscale = new Fsr2.ResourceView(BuiltinRenderTextureType.CameraTarget, RenderTextureSubElement.Color);
-            _genReactiveDescription.OutReactive = new Fsr2.ResourceView(Fsr2ShaderIDs.UavAutoReactive);
+            _genReactiveDescription.ColorOpaqueOnly = new ResourceView(_colorOpaqueOnly);
+            _genReactiveDescription.ColorPreUpscale = new ResourceView(BuiltinRenderTextureType.CameraTarget, RenderTextureSubElement.Color);
+            _genReactiveDescription.OutReactive = new ResourceView(Fsr3ShaderIDs.UavAutoReactive);
             _genReactiveDescription.RenderSize = GetScaledRenderSize();
             _genReactiveDescription.Scale = generateReactiveParameters.scale;
             _genReactiveDescription.CutoffThreshold = generateReactiveParameters.cutoffThreshold;
@@ -388,9 +376,9 @@ namespace FidelityFX
         {
             var scaledRenderSize = GetScaledRenderSize();
             
-            // Perform custom jittering of the camera's projection matrix according to FSR2's recipe
-            int jitterPhaseCount = Fsr2.GetJitterPhaseCount(scaledRenderSize.x, _displaySize.x);
-            Fsr2.GetJitterOffset(out float jitterX, out float jitterY, Time.frameCount, jitterPhaseCount);
+            // Perform custom jittering of the camera's projection matrix according to FSR3's recipe
+            int jitterPhaseCount = Fsr3Upscaler.GetJitterPhaseCount(scaledRenderSize.x, _displaySize.x);
+            Fsr3Upscaler.GetJitterOffset(out float jitterX, out float jitterY, Time.frameCount, jitterPhaseCount);
 
             _dispatchDescription.JitterOffset = new Vector2(jitterX, jitterY);
 
@@ -409,40 +397,37 @@ namespace FidelityFX
             _renderCamera.rect = _originalRect;
             _renderCamera.ResetProjectionMatrix();
 
-            // Update the input resource descriptions
-            _dispatchDescription.InputResourceSize = new Vector2Int(src.width, src.height);
-
             _dispatchCommandBuffer.Clear();
 
             if (autoGenerateReactiveMask)
             {
-                // The auto-reactive mask pass is executed separately from the main FSR2 passes
+                // The auto-reactive mask pass is executed separately from the main FSR3 Upscaler passes
                 var scaledRenderSize = GetScaledRenderSize();
-                _dispatchCommandBuffer.GetTemporaryRT(Fsr2ShaderIDs.UavAutoReactive, scaledRenderSize.x, scaledRenderSize.y, 0, default, GraphicsFormat.R8_UNorm, 1, true);
+                _dispatchCommandBuffer.GetTemporaryRT(Fsr3ShaderIDs.UavAutoReactive, scaledRenderSize.x, scaledRenderSize.y, 0, default, GraphicsFormat.R8_UNorm, 1, true);
                 _context.GenerateReactiveMask(_genReactiveDescription, _dispatchCommandBuffer);
-                _dispatchDescription.Reactive = new Fsr2.ResourceView(Fsr2ShaderIDs.UavAutoReactive);
+                _dispatchDescription.Reactive = new ResourceView(Fsr3ShaderIDs.UavAutoReactive);
             }
 
-            // The backbuffer is not set up to allow random-write access, so we need a temporary render texture for FSR2 to output to
-            _dispatchCommandBuffer.GetTemporaryRT(Fsr2ShaderIDs.UavUpscaledOutput, _displaySize.x, _displaySize.y, 0, default, GetDefaultFormat(), default, 1, true);
+            // The backbuffer is not set up to allow random-write access, so we need a temporary render texture for FSR3 to output to
+            _dispatchCommandBuffer.GetTemporaryRT(Fsr3ShaderIDs.UavUpscaledOutput, _displaySize.x, _displaySize.y, 0, default, GetDefaultFormat(), default, 1, true);
 
             _context.Dispatch(_dispatchDescription, _dispatchCommandBuffer);
 
             // Output the upscaled image
             if (_originalRenderTarget != null)
             {
-                // Output to the camera target texture, passing through depth and motion vectors
+                // Output to the camera target texture, passing through depth as well
                 _dispatchCommandBuffer.SetGlobalTexture("_DepthTex", BuiltinRenderTextureType.CameraTarget, RenderTextureSubElement.Depth);
-                _dispatchCommandBuffer.Blit(Fsr2ShaderIDs.UavUpscaledOutput, _originalRenderTarget, _copyWithDepthMaterial);
+                _dispatchCommandBuffer.Blit(Fsr3ShaderIDs.UavUpscaledOutput, _originalRenderTarget, _copyWithDepthMaterial);
             }
             else
             {
                 // Output directly to the backbuffer
-                _dispatchCommandBuffer.Blit(Fsr2ShaderIDs.UavUpscaledOutput, dest);
+                _dispatchCommandBuffer.Blit(Fsr3ShaderIDs.UavUpscaledOutput, dest);
             }
             
-            _dispatchCommandBuffer.ReleaseTemporaryRT(Fsr2ShaderIDs.UavUpscaledOutput);
-            _dispatchCommandBuffer.ReleaseTemporaryRT(Fsr2ShaderIDs.UavAutoReactive);
+            _dispatchCommandBuffer.ReleaseTemporaryRT(Fsr3ShaderIDs.UavUpscaledOutput);
+            _dispatchCommandBuffer.ReleaseTemporaryRT(Fsr3ShaderIDs.UavAutoReactive);
 
             Graphics.ExecuteCommandBuffer(_dispatchCommandBuffer);
 
@@ -484,5 +469,20 @@ namespace FidelityFX
             
             return _maxRenderSize;
         }
+        
+        #if UNITY_EDITOR
+        private void Reset()
+        {
+            if (assets != null)
+                return;
+
+            string[] assetGuids = UnityEditor.AssetDatabase.FindAssets($"t:{nameof(Fsr3UpscalerAssets)}");
+            if (assetGuids == null || assetGuids.Length == 0)
+                return;
+
+            string assetPath = UnityEditor.AssetDatabase.GUIDToAssetPath(assetGuids[0]);
+            assets = UnityEditor.AssetDatabase.LoadAssetAtPath<Fsr3UpscalerAssets>(assetPath);
+        }
+        #endif
     }
 }

Assets/Scripts/Fsr2ImageEffectHelper.cs → Assets/Scripts/Fsr3UpscalerImageEffectHelper.cs

@@ -20,27 +20,28 @@
 
 using System.Collections;
 using UnityEngine;
+using FidelityFX.FSR3;
 
 namespace FidelityFX
 {
     /// <summary>
-    /// Small helper script to be used in conjunction with the Fsr2ImageEffect script.
-    /// The FSR2 image effect needs to be the last effect in the post-processing chain but for render scaling to work properly, it also needs to be the first to execute OnPreCull.
+    /// Small helper script to be used in conjunction with the Fsr3UpscalerImageEffect script.
+    /// The FSR3 Upscaler image effect needs to be the last effect in the post-processing chain but for render scaling to work properly, it also needs to be the first to execute OnPreCull.
     /// Unfortunately altering the script execution order does not affect the order in which OnPreCull is executed. Only the order of scripts on the same game object matters. 
     /// 
-    /// When combining FSR2 upscaling with other post-processing effects (most notably Unity's Post-Processing Stack V2),
+    /// When combining FSR3 upscaling with other post-processing effects (most notably Unity's Post-Processing Stack V2),
     /// this script should be added to the same camera and moved up above any other scripts that have an OnPreCull method. 
     /// </summary>
-    [RequireComponent(typeof(Camera), typeof(Fsr2ImageEffect))]
-    public class Fsr2ImageEffectHelper : MonoBehaviour
+    [RequireComponent(typeof(Camera), typeof(Fsr3UpscalerImageEffect))]
+    public class Fsr3UpscalerImageEffectHelper : MonoBehaviour
     {
         private Camera _renderCamera;
-        private Fsr2ImageEffect _imageEffect;
+        private Fsr3UpscalerImageEffect _imageEffect;
 
         private void OnEnable()
         {
             _renderCamera = GetComponent<Camera>();
-            _imageEffect = GetComponent<Fsr2ImageEffect>();
+            _imageEffect = GetComponent<Fsr3UpscalerImageEffect>();
         }
 
         private void OnPreCull()
@@ -49,10 +50,10 @@ namespace FidelityFX
                 return;
             
             var originalRect = _renderCamera.rect;
-            float upscaleRatio = Fsr2.GetUpscaleRatioFromQualityMode(_imageEffect.qualityMode);
+            float upscaleRatio = Fsr3Upscaler.GetUpscaleRatioFromQualityMode(_imageEffect.qualityMode);
 
             // Render to a smaller portion of the screen by manipulating the camera's viewport rect
-            _renderCamera.aspect = (_renderCamera.pixelWidth * originalRect.width) / (_renderCamera.pixelHeight * originalRect.height);
+            _renderCamera.aspect = (float)_renderCamera.pixelWidth / _renderCamera.pixelHeight;
             _renderCamera.rect = new Rect(0, 0, originalRect.width / upscaleRatio, originalRect.height / upscaleRatio);
         }
     }

Assets/Resources/Shaders.meta → Assets/Shaders/FSR3.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 99529786e04ad7e468cdde9e81ce2dba
+guid: 661ffc6dbd7389b4da99fb9f749745de
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Assets/Resources/FSR2/ffx_fsr2_accumulate_pass.compute → Assets/Shaders/FSR3/ffx_fsr3upscaler_accumulate_pass.compute

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Nico de Poel
+// Copyright (c) 2024 Nico de Poel
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -21,21 +21,19 @@
 #pragma kernel CS
 
 #pragma multi_compile_local __ FFX_HALF
-#pragma multi_compile_local __ FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE
-#pragma multi_compile_local __ FFX_FSR2_OPTION_HDR_COLOR_INPUT
-#pragma multi_compile_local __ FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_JITTERED_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_INVERTED_DEPTH
-#pragma multi_compile_local __ FFX_FSR2_OPTION_APPLY_SHARPENING
+#pragma multi_compile_local __ FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE
+#pragma multi_compile_local __ FFX_FSR3UPSCALER_OPTION_HDR_COLOR_INPUT
+#pragma multi_compile_local __ FFX_FSR3UPSCALER_OPTION_LOW_RESOLUTION_MOTION_VECTORS
+#pragma multi_compile_local __ FFX_FSR3UPSCALER_OPTION_APPLY_SHARPENING
 
-#pragma multi_compile_local __ UNITY_FSR2_HDRP
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
 
-#include "ffx_fsr2_unity_common.cginc"
+#include "ffx_fsr_unity_common.cginc"
 
 // Ensure the correct value is defined for this keyword, as it is used to select one of multiple sampler functions
-#ifdef FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE
-#undef FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE
-#define FFX_FSR2_OPTION_REPROJECT_USE_LANCZOS_TYPE 1
+#ifdef FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE
+#undef FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE
+#define FFX_FSR3UPSCALER_OPTION_REPROJECT_USE_LANCZOS_TYPE 1
 #endif
 
-#include "shaders/ffx_fsr2_accumulate_pass.hlsl"
+#include "shaders/ffx_fsr3upscaler_accumulate_pass.hlsl"

Assets/Resources/FSR2/ffx_fsr2_compute_luminance_pyramid_pass.compute.meta → Assets/Shaders/FSR3/ffx_fsr3upscaler_accumulate_pass.compute.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 0894ebeefb6aa7d4680c71dffbda3fee
+guid: c9b45f0ae7673694ba57a4aadfe212e9
 ComputeShaderImporter:
   externalObjects: {}
   preprocessorOverride: 0

Assets/Resources/FSR2/ffx_fsr2_lock_pass.compute → Assets/Shaders/FSR3/ffx_fsr3upscaler_autogen_reactive_pass.compute

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Nico de Poel
+// Copyright (c) 2024 Nico de Poel
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -21,10 +21,9 @@
 #pragma kernel CS
 
 #pragma multi_compile_local __ FFX_HALF
-#pragma multi_compile_local __ FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_JITTERED_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_INVERTED_DEPTH
 
-#include "ffx_fsr2_unity_common.cginc"
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
 
-#include "shaders/ffx_fsr2_lock_pass.hlsl"
+#include "ffx_fsr_unity_common.cginc"
+
+#include "shaders/ffx_fsr3upscaler_autogen_reactive_pass.hlsl"

Assets/Resources/FSR2/ffx_fsr2_depth_clip_pass.compute.meta → Assets/Shaders/FSR3/ffx_fsr3upscaler_autogen_reactive_pass.compute.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 8026d9d8542eab6499c32d5d46beb2b6
+guid: 5716b91fdaa4e9e439df6b96a796fe6e
 ComputeShaderImporter:
   externalObjects: {}
   preprocessorOverride: 0

Assets/Resources/FSR2/ffx_fsr2_rcas_pass.compute → Assets/Shaders/FSR3/ffx_fsr3upscaler_debug_view_pass.compute

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Nico de Poel
+// Copyright (c) 2024 Nico de Poel
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -20,10 +20,10 @@
 
 #pragma kernel CS
 
-#pragma multi_compile_local __ FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_JITTERED_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_INVERTED_DEPTH
+#pragma multi_compile_local __ FFX_HALF
 
-#include "ffx_fsr2_unity_common.cginc"
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
 
-#include "shaders/ffx_fsr2_rcas_pass.hlsl"
+#include "ffx_fsr_unity_common.cginc"
+
+#include "shaders/ffx_fsr3upscaler_debug_view_pass.hlsl"

Assets/Resources/FSR2/ffx_fsr2_autogen_reactive_pass.compute.meta → Assets/Shaders/FSR3/ffx_fsr3upscaler_debug_view_pass.compute.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: d18fb8811ca4753469c439784546104e
+guid: cb24a71d54164c54eb5e86839acd48c5
 ComputeShaderImporter:
   externalObjects: {}
   preprocessorOverride: 0

Assets/Resources/FSR2/ffx_fsr2_depth_clip_pass.compute → Assets/Shaders/FSR3/ffx_fsr3upscaler_luma_instability_pass.compute

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Nico de Poel
+// Copyright (c) 2024 Nico de Poel
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -21,12 +21,9 @@
 #pragma kernel CS
 
 #pragma multi_compile_local __ FFX_HALF
-#pragma multi_compile_local __ FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_JITTERED_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_INVERTED_DEPTH
 
-#pragma multi_compile_local __ UNITY_FSR2_HDRP
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
 
-#include "ffx_fsr2_unity_common.cginc"
+#include "ffx_fsr_unity_common.cginc"
 
-#include "shaders/ffx_fsr2_depth_clip_pass.hlsl"
+#include "shaders/ffx_fsr3upscaler_luma_instability_pass.hlsl"

Assets/Resources/FSR2/ffx_fsr2_accumulate_pass.compute.meta → Assets/Shaders/FSR3/ffx_fsr3upscaler_luma_instability_pass.compute.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 702560780e923c84394c9b22ba460a9c
+guid: a135306e6d1857e43a86ef20db2a47fe
 ComputeShaderImporter:
   externalObjects: {}
   preprocessorOverride: 0

Assets/Resources/FSR2/ffx_fsr2_compute_luminance_pyramid_pass.compute → Assets/Shaders/FSR3/ffx_fsr3upscaler_luma_pyramid_pass.compute

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Nico de Poel
+// Copyright (c) 2024 Nico de Poel
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -20,14 +20,11 @@
 
 #pragma kernel CS
 
-//#pragma multi_compile_local __ FFX_HALF  // causes a hard-coded error message from the shader include ¯\_(ツ)_/¯
-#pragma multi_compile_local __ FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_JITTERED_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_INVERTED_DEPTH
+#pragma multi_compile_local __ FFX_HALF
 
-#pragma multi_compile_local __ UNITY_FSR2_HDRP
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
 
-#include "ffx_fsr2_unity_common.cginc"
+#include "ffx_fsr_unity_common.cginc"
 
 // Wave operations require shader model 6.0; this can only be enabled when using DXC on D3D12
 // These pragmas are commented out by default as Unity will sometimes ignore the #if's and try to enable these features anyway.
@@ -36,7 +33,7 @@
 //#pragma require WaveBasic   // Required for WaveGetLaneIndex
 //#pragma require WaveBallot  // Required for WaveReadLaneAt
 //#else
-#define SPD_NO_WAVE_OPERATIONS
+#define FFX_SPD_NO_WAVE_OPERATIONS
 //#endif
 
-#include "shaders/ffx_fsr2_compute_luminance_pyramid_pass.hlsl"
+#include "shaders/ffx_fsr3upscaler_luma_pyramid_pass.hlsl"

Assets/Shaders/FSR3/ffx_fsr3upscaler_luma_pyramid_pass.compute.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d253be05abcdc80428503d3e4cce3a36
+ComputeShaderImporter:
+  externalObjects: {}
+  preprocessorOverride: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Resources/FSR2/ffx_fsr2_tcr_autogen_pass.compute → Assets/Shaders/FSR3/ffx_fsr3upscaler_prepare_inputs_pass.compute

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Nico de Poel
+// Copyright (c) 2024 Nico de Poel
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -21,12 +21,11 @@
 #pragma kernel CS
 
 #pragma multi_compile_local __ FFX_HALF
-#pragma multi_compile_local __ FFX_FSR2_OPTION_LOW_RESOLUTION_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_JITTERED_MOTION_VECTORS
-#pragma multi_compile_local __ FFX_FSR2_OPTION_INVERTED_DEPTH
+#pragma multi_compile_local __ FFX_FSR3UPSCALER_OPTION_LOW_RESOLUTION_MOTION_VECTORS
+#pragma multi_compile_local __ FFX_FSR3UPSCALER_OPTION_INVERTED_DEPTH
 
-#pragma multi_compile_local __ UNITY_FSR2_HDRP
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
 
-#include "ffx_fsr2_unity_common.cginc"
+#include "ffx_fsr_unity_common.cginc"
 
-#include "shaders/ffx_fsr2_tcr_autogen_pass.hlsl"
+#include "shaders/ffx_fsr3upscaler_prepare_inputs_pass.hlsl"

Assets/Shaders/FSR3/ffx_fsr3upscaler_prepare_inputs_pass.compute.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4f59e5b9179d74844ae06a30ae1e0629
+ComputeShaderImporter:
+  externalObjects: {}
+  preprocessorOverride: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Shaders/FSR3/ffx_fsr3upscaler_prepare_reactivity_pass.compute

@@ -0,0 +1,29 @@
+// Copyright (c) 2024 Nico de Poel
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#pragma kernel CS
+
+#pragma multi_compile_local __ FFX_HALF
+
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
+
+#include "ffx_fsr_unity_common.cginc"
+
+#include "shaders/ffx_fsr3upscaler_prepare_reactivity_pass.hlsl"

Assets/Shaders/FSR3/ffx_fsr3upscaler_prepare_reactivity_pass.compute.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 20e44016ed34b0d4b8de499d1b566c69
+ComputeShaderImporter:
+  externalObjects: {}
+  preprocessorOverride: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Shaders/FSR3/ffx_fsr3upscaler_rcas_pass.compute

@@ -0,0 +1,27 @@
+// Copyright (c) 2024 Nico de Poel
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#pragma kernel CS
+
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
+
+#include "ffx_fsr_unity_common.cginc"
+
+#include "shaders/ffx_fsr3upscaler_rcas_pass.hlsl"

Assets/Shaders/FSR3/ffx_fsr3upscaler_rcas_pass.compute.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7aaf5cfff022de2499e9b0412f947f6c
+ComputeShaderImporter:
+  externalObjects: {}
+  preprocessorOverride: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Shaders/FSR3/ffx_fsr3upscaler_shading_change_pass.compute

@@ -0,0 +1,29 @@
+// Copyright (c) 2024 Nico de Poel
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#pragma kernel CS
+
+#pragma multi_compile_local __ FFX_HALF
+
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
+
+#include "ffx_fsr_unity_common.cginc"
+
+#include "shaders/ffx_fsr3upscaler_shading_change_pass.hlsl"

Assets/Shaders/FSR3/ffx_fsr3upscaler_shading_change_pass.compute.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9a2bff2f97619ed4989d9b0577ba0641
+ComputeShaderImporter:
+  externalObjects: {}
+  preprocessorOverride: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Shaders/FSR3/ffx_fsr3upscaler_shading_change_pyramid_pass.compute

@@ -0,0 +1,32 @@
+// Copyright (c) 2024 Nico de Poel
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#pragma kernel CS
+
+#pragma multi_compile_local __ FFX_HALF
+
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
+
+#include "ffx_fsr_unity_common.cginc"
+
+// Wave operations require shader model 6.0; this can only be enabled when using DXC on D3D12
+#define FFX_SPD_NO_WAVE_OPERATIONS
+
+#include "shaders/ffx_fsr3upscaler_shading_change_pyramid_pass.hlsl"

Assets/Shaders/FSR3/ffx_fsr3upscaler_shading_change_pyramid_pass.compute.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 251e663738905fa4d8817001682d802f
+ComputeShaderImporter:
+  externalObjects: {}
+  preprocessorOverride: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Shaders/FSR3/ffx_fsr3upscaler_tcr_autogen_pass.compute

@@ -0,0 +1,30 @@
+// Copyright (c) 2024 Nico de Poel
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#pragma kernel CS
+
+#pragma multi_compile_local __ FFX_HALF
+#pragma multi_compile_local __ FFX_FSR3UPSCALER_OPTION_JITTERED_MOTION_VECTORS
+
+#pragma multi_compile __ UNITY_FSR_TEXTURE2D_X_ARRAY
+
+#include "ffx_fsr_unity_common.cginc"
+
+#include "shaders/ffx_fsr3upscaler_tcr_autogen_pass.hlsl"