ndepoel
/
FSRTestBuiltin
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Reorganized context and dispatch code: 

- Resource binding and shader dispatch is now done in separate Pipeline classes per stage, mirroring the design of the original FSR2 code.
- Moved some classes and structs around to make them available outside of the Fsr2Context class.
mac-autoexp
Nico de Poel 3 years ago
parent
70dc9e29d4
commit
08e034584c
4 changed files with 284 additions and 193 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 176
      Assets/Scripts/Fsr2.cs
  2. 217
      Assets/Scripts/Fsr2Context.cs
  3. 81
      Assets/Scripts/Fsr2Pipeline.cs
  4. 3
      Assets/Scripts/Fsr2Pipeline.cs.meta

176
Assets/Scripts/Fsr2.cs
View File

@ -1,4 +1,5 @@
using System;
using System.Runtime.InteropServices;
using UnityEngine;
using UnityEngine.Rendering;
@ -8,64 +9,6 @@ namespace FidelityFX
{
// Allow overriding of certain Unity resource management behaviors by the programmer
public static Fsr2Callbacks GlobalCallbacks { get; set; } = new Fsr2Callbacks();
public enum QualityMode
{
Quality = 1,
Balanced = 2,
Performance = 3,
UltraPerformance = 4,
}
[Flags]
public enum InitializationFlags
{
EnableHighDynamicRange = 1 << 0,
EnableDisplayResolutionMotionVectors = 1 << 1,
EnableMotionVectorsJitterCancellation = 1 << 2,
EnableDepthInverted = 1 << 3,
EnableDepthInfinite = 1 << 4,
EnableAutoExposure = 1 << 5,
EnableDynamicResolution = 1 << 6,
EnableTexture1DUsage = 1 << 7,
EnableDebugChecking = 1 << 8,
}
public enum MessageType
{
Error = 0,
Warning = 1,
}
public struct ContextDescription
{
public InitializationFlags Flags;
public Vector2Int MaxRenderSize;
public Vector2Int DisplaySize;
public Fsr2Callbacks Callbacks;
}
public class DispatchDescription
{
// Texture2D Color, Depth, MotionVectors; // Will be passed using ComputeShader.SetTextureFromGlobal
public Texture2D Exposure;
public Texture2D Reactive;
public Texture2D TransparencyAndComposition;
public RenderTexture Input;
public RenderTexture Output;
public Vector2 JitterOffset;
public Vector2 MotionVectorScale;
public Vector2Int RenderSize;
public bool EnableSharpening;
public float Sharpness;
public float FrameTimeDelta;
public float PreExposure;
public bool Reset;
public float CameraNear;
public float CameraFar;
public float CameraFovAngleVertical;
public float ViewSpaceToMetersFactor;
}
/// <summary>
/// Creates a new FSR2 context with standard parameters that are appropriate for the current platform.
@ -148,5 +91,122 @@ namespace FidelityFX
return Mathf.Abs(value) < Mathf.Epsilon ? 1.0f :
Mathf.Sin(Mathf.PI * value) / (Mathf.PI * value) * (Mathf.Sin(0.5f * Mathf.PI * value) / (0.5f * Mathf.PI * value));
}
public enum QualityMode
{
Quality = 1,
Balanced = 2,
Performance = 3,
UltraPerformance = 4,
}
[Flags]
public enum InitializationFlags
{
EnableHighDynamicRange = 1 << 0,
EnableDisplayResolutionMotionVectors = 1 << 1,
EnableMotionVectorsJitterCancellation = 1 << 2,
EnableDepthInverted = 1 << 3,
EnableDepthInfinite = 1 << 4,
EnableAutoExposure = 1 << 5,
EnableDynamicResolution = 1 << 6,
EnableTexture1DUsage = 1 << 7,
EnableDebugChecking = 1 << 8,
}
public enum MessageType
{
Error = 0,
Warning = 1,
}
public struct ContextDescription
{
public InitializationFlags Flags;
public Vector2Int MaxRenderSize;
public Vector2Int DisplaySize;
public Fsr2Callbacks Callbacks;
}
public class DispatchDescription
{
// Texture2D Color, Depth, MotionVectors; // Will be passed using ComputeShader.SetTextureFromGlobal
public Texture2D Exposure;
public Texture2D Reactive;
public Texture2D TransparencyAndComposition;
public RenderTexture Input;
public RenderTexture Output;
public Vector2 JitterOffset;
public Vector2 MotionVectorScale;
public Vector2Int RenderSize;
public bool EnableSharpening;
public float Sharpness;
public float FrameTimeDelta;
public float PreExposure;
public bool Reset;
public float CameraNear;
public float CameraFar;
public float CameraFovAngleVertical;
public float ViewSpaceToMetersFactor;
}
[Serializable, StructLayout(LayoutKind.Sequential)]
internal struct Fsr2Constants
{
public Vector2Int renderSize;
public Vector2Int maxRenderSize;
public Vector2Int displaySize;
public Vector2Int inputColorResourceDimensions;
public Vector2Int lumaMipDimensions;
public int lumaMipLevelToUse;
public int frameIndex;
public Vector4 deviceToViewDepth;
public Vector2 jitterOffset;
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 viewSpaceToMetersFactor;
}
[Serializable, StructLayout(LayoutKind.Sequential)]
internal struct SpdConstants
{
public uint mips;
public uint numWorkGroups;
public uint workGroupOffsetX, workGroupOffsetY;
public uint renderSizeX, renderSizeY;
}
[Serializable, StructLayout(LayoutKind.Sequential)]
internal struct GenerateReactiveConstants
{
public float scale;
public float threshold;
public float binaryValue;
public uint flags;
}
[Serializable, StructLayout(LayoutKind.Sequential)]
internal struct RcasConstants
{
public RcasConstants(uint sharpness, uint halfSharp)
{
this.sharpness = sharpness;
this.halfSharp = halfSharp;
dummy0 = dummy1 = 0;
}
public readonly uint sharpness;
public readonly uint halfSharp;
public readonly uint dummy0;
public readonly uint dummy1;
}
}
}

217
Assets/Scripts/Fsr2Context.cs
View File

@ -12,32 +12,32 @@ namespace FidelityFX
private Fsr2.ContextDescription _contextDescription;
private CommandBuffer _commandBuffer;
private ComputeShader _prepareInputColorShader;
private ComputeShader _depthClipShader;
private ComputeShader _reconstructPreviousDepthShader;
private ComputeShader _lockShader;
private ComputeShader _accumulateShader;
private ComputeShader _generateReactiveShader;
private ComputeShader _rcasShader;
private ComputeShader _computeLuminancePyramidShader;
private ComputeShader _tcrAutogenShader;
private Fsr2Pipeline _depthClipPipeline;
private Fsr2Pipeline _reconstructPreviousDepthPipeline;
private Fsr2Pipeline _lockPipeline;
private Fsr2Pipeline _accumulatePipeline;
private Fsr2Pipeline _accumulateSharpenPipeline;
private Fsr2Pipeline _rcasPipeline;
private Fsr2Pipeline _computeLuminancePyramidPipeline;
private Fsr2Pipeline _generateReactivePipeline;
private Fsr2Pipeline _tcrAutogeneratePipeline;
private ComputeBuffer _fsr2ConstantsBuffer;
private readonly Fsr2Constants[] _fsr2ConstantsArray = { new Fsr2Constants() };
private ref Fsr2Constants Constants => ref _fsr2ConstantsArray[0];
private readonly Fsr2.Fsr2Constants[] _fsr2ConstantsArray = { new Fsr2.Fsr2Constants() };
private ref Fsr2.Fsr2Constants Constants => ref _fsr2ConstantsArray[0];
private ComputeBuffer _spdConstantsBuffer;
private readonly SpdConstants[] _spdConstantsArray = { new SpdConstants() };
private ref SpdConstants SpdConsts => ref _spdConstantsArray[0];
private readonly Fsr2.SpdConstants[] _spdConstantsArray = { new Fsr2.SpdConstants() };
private ref Fsr2.SpdConstants SpdConsts => ref _spdConstantsArray[0];
private ComputeBuffer _rcasConstantsBuffer;
private readonly RcasConstants[] _rcasConstantsArray = new RcasConstants[1];
private ref RcasConstants RcasConsts => ref _rcasConstantsArray[0];
private readonly Fsr2.RcasConstants[] _rcasConstantsArray = new Fsr2.RcasConstants[1];
private ref Fsr2.RcasConstants RcasConsts => ref _rcasConstantsArray[0];
private ComputeBuffer _generateReactiveConstantsBuffer;
private readonly GenerateReactiveConstants[] _generateReactiveConstantsArray = { new GenerateReactiveConstants() };
private ref GenerateReactiveConstants GenReactiveConsts => ref _generateReactiveConstantsArray[0];
private readonly Fsr2.GenerateReactiveConstants[] _generateReactiveConstantsArray = { new Fsr2.GenerateReactiveConstants() };
private ref Fsr2.GenerateReactiveConstants GenReactiveConsts => ref _generateReactiveConstantsArray[0];
private bool _firstExecution;
private Vector2 _previousJitterOffset;
@ -48,9 +48,9 @@ namespace FidelityFX
_contextDescription = contextDescription;
_commandBuffer = new CommandBuffer { name = "FSR2" };
_fsr2ConstantsBuffer = CreateConstantBuffer<Fsr2Constants>();
_spdConstantsBuffer = CreateConstantBuffer<SpdConstants>();
_rcasConstantsBuffer = CreateConstantBuffer<RcasConstants>();
_fsr2ConstantsBuffer = CreateConstantBuffer<Fsr2.Fsr2Constants>();
_spdConstantsBuffer = CreateConstantBuffer<Fsr2.SpdConstants>();
_rcasConstantsBuffer = CreateConstantBuffer<Fsr2.RcasConstants>();
// Set defaults
_firstExecution = true;
@ -67,7 +67,7 @@ namespace FidelityFX
lanczos2Weights[currentLanczosWidthIndex] = (short)Mathf.Round(y * 32767.0f);
}
InitShaders();
InitPipelines();
// TODO: create resources, i.e. render textures used for intermediate results.
// Note that "aliasable" resources should be equivalent to GetTemporary render textures
@ -76,17 +76,22 @@ namespace FidelityFX
// Unity doesn't do 1D textures so just default to Texture2D
}
private void InitShaders()
// private void InitShaders()
// {
// LoadComputeShader("FSR2/ffx_fsr2_compute_luminance_pyramid_pass", ref _computeLuminancePyramidShader, out _computeLuminancePyramidKernel);
// LoadComputeShader("FSR2/ffx_fsr2_rcas_pass", ref _rcasShader, out _rcasKernel);
// LoadComputeShader("FSR2/ffx_fsr2_prepare_input_color_pass", ref _prepareInputColorShader, out _prepareInputColorKernel);
// LoadComputeShader("FSR2/ffx_fsr2_depth_clip_pass", ref _depthClipShader, out _depthClipKernel);
// LoadComputeShader("FSR2/ffx_fsr2_reconstruct_previous_depth_pass", ref _reconstructPreviousDepthShader, out _reconstructPreviousDepthKernel);
// LoadComputeShader("FSR2/ffx_fsr2_lock_pass", ref _lockShader, out _lockKernel);
// LoadComputeShader("FSR2/ffx_fsr2_accumulate_pass", ref _accumulateShader, out _accumulateKernel);
// LoadComputeShader("FSR2/ffx_fsr2_autogen_reactive_pass", ref _generateReactiveShader, out _generateReactiveKernel);
// LoadComputeShader("FSR2/ffx_fsr2_tcr_autogen_pass", ref _tcrAutogenShader, out _tcrAutogenKernel);
// }
private void InitPipelines()
{
LoadComputeShader("FSR2/ffx_fsr2_compute_luminance_pyramid_pass", ref _computeLuminancePyramidShader);
LoadComputeShader("FSR2/ffx_fsr2_rcas_pass", ref _rcasShader);
LoadComputeShader("FSR2/ffx_fsr2_prepare_input_color_pass", ref _prepareInputColorShader);
LoadComputeShader("FSR2/ffx_fsr2_depth_clip_pass", ref _depthClipShader);
LoadComputeShader("FSR2/ffx_fsr2_reconstruct_previous_depth_pass", ref _reconstructPreviousDepthShader);
LoadComputeShader("FSR2/ffx_fsr2_lock_pass", ref _lockShader);
LoadComputeShader("FSR2/ffx_fsr2_accumulate_pass", ref _accumulateShader);
LoadComputeShader("FSR2/ffx_fsr2_autogen_reactive_pass", ref _generateReactiveShader);
LoadComputeShader("FSR2/ffx_fsr2_tcr_autogen_pass", ref _tcrAutogenShader);
_rcasPipeline = new Fsr2RcasPipeline(_contextDescription.Callbacks, _fsr2ConstantsBuffer, _rcasConstantsBuffer);
}
public void Dispatch(Fsr2.DispatchDescription dispatchParams)
@ -125,25 +130,38 @@ namespace FidelityFX
}
// Auto exposure
SetupSpdConstants(dispatchParams);
SetupSpdConstants(dispatchParams, out var dispatchThreadGroupCount);
// Initialize constant buffers data
_fsr2ConstantsBuffer.SetData(_fsr2ConstantsArray);
_spdConstantsBuffer.SetData(_spdConstantsArray);
// // Compute luminance pyramid
// _commandBuffer.DispatchCompute(_computeLuminancePyramidShader, _computeLuminancePyramidKernel, dispatchThreadGroupCount.x, dispatchThreadGroupCount.y, 1);
//
// // Reconstruct previous depth
// _commandBuffer.DispatchCompute(_reconstructPreviousDepthShader, _reconstructPreviousDepthKernel, dispatchSrcX, dispatchSrcY, 1);
//
// // Depth clip
// _commandBuffer.DispatchCompute(_depthClipShader, _depthClipKernel, dispatchSrcX, dispatchSrcY, 1);
//
// // Lock
// _commandBuffer.DispatchCompute(_lockShader, _lockKernel, dispatchSrcX, dispatchSrcY, 1);
//
// // Accumulate
// _commandBuffer.DispatchCompute(_accumulateShader, _accumulateKernel, dispatchDstX, dispatchDstY, 1); // TODO: accumulate + sharpen
if (dispatchParams.EnableSharpening)
{
// Compute the constants
SetupRcasConstants(dispatchParams);
// Run the RCAS sharpening filter on the upscaled image
int rcasKernel = _rcasShader.FindKernel("CS");
_rcasShader.SetTexture(rcasKernel, "r_input_exposure", dispatchParams.Exposure);
_rcasShader.SetTexture(rcasKernel, "r_rcas_input", dispatchParams.Input);
_rcasShader.SetTexture(rcasKernel, "rw_upscaled_output", dispatchParams.Output);
_rcasShader.SetConstantBuffer("cbFSR2", _fsr2ConstantsBuffer, 0, Marshal.SizeOf<Fsr2Constants>());
_rcasShader.SetConstantBuffer("cbRCAS", _rcasConstantsBuffer, 0, Marshal.SizeOf<RcasConstants>());
_rcasConstantsBuffer.SetData(_rcasConstantsArray);
// Dispatch RCAS
const int threadGroupWorkRegionDimRcas = 16;
int threadGroupsX = (Screen.width + threadGroupWorkRegionDimRcas - 1) / threadGroupWorkRegionDimRcas;
int threadGroupsY = (Screen.height + threadGroupWorkRegionDimRcas - 1) / threadGroupWorkRegionDimRcas;
_commandBuffer.DispatchCompute(_rcasShader, rcasKernel, threadGroupsX, threadGroupsY, 1);
_rcasPipeline.ScheduleDispatch(_commandBuffer, dispatchParams, threadGroupsX, threadGroupsY);
}
else
{
@ -159,7 +177,7 @@ namespace FidelityFX
private void SetupConstants(Fsr2.DispatchDescription dispatchParams, bool resetAccumulation)
{
ref Fsr2Constants constants = ref Constants;
ref Fsr2.Fsr2Constants constants = ref Constants;
constants.jitterOffset = dispatchParams.JitterOffset;
constants.renderSize = new Vector2Int(
@ -229,8 +247,6 @@ namespace FidelityFX
float mipDiv = 2 << constants.lumaMipLevelToUse;
constants.lumaMipDimensions.x = (int)(constants.maxRenderSize.x / mipDiv);
constants.lumaMipDimensions.y = (int)(constants.maxRenderSize.y / mipDiv);
_fsr2ConstantsBuffer.SetData(_fsr2ConstantsArray);
}
private Vector4 SetupDeviceDepthToViewSpaceDepthParams(Fsr2.DispatchDescription dispatchParams)
@ -271,25 +287,21 @@ namespace FidelityFX
{
int sharpnessIndex = Mathf.RoundToInt(Mathf.Clamp01(dispatchParams.Sharpness) * (RcasConfigs.Count - 1));
RcasConsts = RcasConfigs[sharpnessIndex];
_rcasConstantsBuffer.SetData(_rcasConstantsArray);
}
private void SetupSpdConstants(Fsr2.DispatchDescription dispatchParams)
private void SetupSpdConstants(Fsr2.DispatchDescription dispatchParams, out Vector2Int dispatchThreadGroupCount)
{
RectInt rectInfo = new RectInt(0, 0, dispatchParams.RenderSize.x, dispatchParams.RenderSize.y);
SpdSetup(rectInfo, out var dispatchThreadGroupCount, out var workGroupOffset, out var numWorkGroupsAndMips);
SpdSetup(rectInfo, out dispatchThreadGroupCount, out var workGroupOffset, out var numWorkGroupsAndMips);
// Downsample
ref SpdConstants spdConstants = ref SpdConsts;
ref Fsr2.SpdConstants spdConstants = ref SpdConsts;
spdConstants.numWorkGroups = (uint)numWorkGroupsAndMips.x;
spdConstants.mips = (uint)numWorkGroupsAndMips.y;
spdConstants.workGroupOffsetX = (uint)workGroupOffset.x;
spdConstants.workGroupOffsetY = (uint)workGroupOffset.y;
spdConstants.renderSizeX = (uint)dispatchParams.RenderSize.x;
spdConstants.renderSizeY = (uint)dispatchParams.RenderSize.y;
_spdConstantsBuffer.SetData(_spdConstantsArray);
}
private static void SpdSetup(RectInt rectInfo,
@ -312,88 +324,29 @@ namespace FidelityFX
public void Destroy()
{
DisposePipeline(ref _tcrAutogeneratePipeline);
DisposePipeline(ref _generateReactivePipeline);
DisposePipeline(ref _computeLuminancePyramidPipeline);
DisposePipeline(ref _rcasPipeline);
DisposePipeline(ref _accumulateSharpenPipeline);
DisposePipeline(ref _accumulatePipeline);
DisposePipeline(ref _lockPipeline);
DisposePipeline(ref _reconstructPreviousDepthPipeline);
DisposePipeline(ref _depthClipPipeline);
DestroyConstantBuffer(ref _rcasConstantsBuffer);
DestroyConstantBuffer(ref _spdConstantsBuffer);
DestroyConstantBuffer(ref _fsr2ConstantsBuffer);
DestroyComputeShader(ref _tcrAutogenShader);
DestroyComputeShader(ref _generateReactiveShader);
DestroyComputeShader(ref _accumulateShader);
DestroyComputeShader(ref _lockShader);
DestroyComputeShader(ref _reconstructPreviousDepthShader);
DestroyComputeShader(ref _depthClipShader);
DestroyComputeShader(ref _prepareInputColorShader);
DestroyComputeShader(ref _rcasShader);
DestroyComputeShader(ref _computeLuminancePyramidShader);
_commandBuffer.Dispose();
_commandBuffer = null;
}
[Serializable, StructLayout(LayoutKind.Sequential)]
private struct Fsr2Constants
{
public Vector2Int renderSize;
public Vector2Int maxRenderSize;
public Vector2Int displaySize;
public Vector2Int inputColorResourceDimensions;
public Vector2Int lumaMipDimensions;
public int lumaMipLevelToUse;
public int frameIndex;
public Vector4 deviceToViewDepth;
public Vector2 jitterOffset;
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 viewSpaceToMetersFactor;
}
[Serializable, StructLayout(LayoutKind.Sequential)]
private struct SpdConstants
{
public uint mips;
public uint numWorkGroups;
public uint workGroupOffsetX, workGroupOffsetY;
public uint renderSizeX, renderSizeY;
}
[Serializable, StructLayout(LayoutKind.Sequential)]
private struct GenerateReactiveConstants
{
public float scale;
public float threshold;
public float binaryValue;
public uint flags;
}
[Serializable, StructLayout(LayoutKind.Sequential)]
private struct RcasConstants
{
public RcasConstants(uint sharpness, uint halfSharp)
{
this.sharpness = sharpness;
this.halfSharp = halfSharp;
dummy0 = dummy1 = 0;
}
public readonly uint sharpness;
public readonly uint halfSharp;
public readonly uint dummy0;
public readonly uint dummy1;
}
/// <summary>
/// The FSR2 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 List<RcasConstants> RcasConfigs = new()
private static readonly List<Fsr2.RcasConstants> RcasConfigs = new()
{
new(1048576000u, 872428544u),
new(1049178080u, 877212745u),
@ -423,12 +376,6 @@ namespace FidelityFX
return new ComputeBuffer(1, Marshal.SizeOf<TConstants>(), ComputeBufferType.Constant);
}
private void LoadComputeShader(string name, ref ComputeShader shaderRef)
{
if (shaderRef == null)
shaderRef = _contextDescription.Callbacks.LoadComputeShader(name);
}
private static void DestroyConstantBuffer(ref ComputeBuffer bufferRef)
{
if (bufferRef == null)
@ -438,13 +385,13 @@ namespace FidelityFX
bufferRef = null;
}
private void DestroyComputeShader(ref ComputeShader shaderRef)
private static void DisposePipeline(ref Fsr2Pipeline pipeline)
{
if (shaderRef == null)
if (pipeline == null)
return;
_contextDescription.Callbacks.UnloadComputeShader(shaderRef);
shaderRef = null;
pipeline.Dispose();
pipeline = null;
}
}
}

81
Assets/Scripts/Fsr2Pipeline.cs
View File

@ -0,0 +1,81 @@
using System;
using System.Runtime.InteropServices;
using UnityEngine;
using UnityEngine.Rendering;
namespace FidelityFX
{
internal abstract class Fsr2Pipeline: IDisposable
{
protected ComputeShader ComputeShader;
protected int KernelIndex;
private readonly Fsr2Callbacks _callbacks;
protected Fsr2Pipeline(Fsr2Callbacks callbacks)
{
_callbacks = callbacks;
}
public virtual void Dispose()
{
UnloadComputeShader();
}
public abstract void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int dispatchX, int dispatchY);
protected void LoadComputeShader(string name)
{
LoadComputeShader(name, ref ComputeShader, out KernelIndex);
}
protected void LoadComputeShader(string name, ref ComputeShader shaderRef, out int kernelIndex)
{
if (shaderRef == null)
shaderRef = _callbacks.LoadComputeShader(name);
kernelIndex = shaderRef.FindKernel("CS");
}
protected void UnloadComputeShader()
{
UnloadComputeShader(ref ComputeShader);
}
protected void UnloadComputeShader(ref ComputeShader shaderRef)
{
if (shaderRef == null)
return;
_callbacks.UnloadComputeShader(shaderRef);
shaderRef = null;
}
}
internal class Fsr2RcasPipeline : Fsr2Pipeline
{
private readonly ComputeBuffer _fsr2Constants;
private readonly ComputeBuffer _rcasConstants;
public Fsr2RcasPipeline(Fsr2Callbacks callbacks, ComputeBuffer fsr2Constants, ComputeBuffer rcasConstants)
: base(callbacks)
{
_fsr2Constants = fsr2Constants;
_rcasConstants = rcasConstants;
LoadComputeShader("FSR2/ffx_fsr2_rcas_pass");
}
public override void ScheduleDispatch(CommandBuffer commandBuffer, Fsr2.DispatchDescription dispatchParams, int dispatchX, int dispatchY)
{
// Run the RCAS sharpening filter on the upscaled image
ComputeShader.SetTexture(KernelIndex, "r_input_exposure", dispatchParams.Exposure);
ComputeShader.SetTexture(KernelIndex, "r_rcas_input", dispatchParams.Input);
ComputeShader.SetTexture(KernelIndex, "rw_upscaled_output", dispatchParams.Output);
ComputeShader.SetConstantBuffer("cbFSR2", _fsr2Constants, 0, Marshal.SizeOf<Fsr2.Fsr2Constants>());
ComputeShader.SetConstantBuffer("cbRCAS", _rcasConstants, 0, Marshal.SizeOf<Fsr2.RcasConstants>());
commandBuffer.DispatchCompute(ComputeShader, KernelIndex, dispatchX, dispatchY, 1);
}
}
}

3
Assets/Scripts/Fsr2Pipeline.cs.meta
View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 14234aed75ce454183019d2e20a44d24
timeCreated: 1676885169
Write Preview
Loading…
Cancel
Save