WW1Series
/
UnityCACAO-HDRP17
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Rewrote the entire upscaler plugin system so that it should be hot-swappable. 

FSR2 native wrapper is still a work-in-progress but also fuck that thing.
master
Nico de Poel 2 years ago
parent
9dade33e17
commit
20f9f5efe6
3 changed files with 232 additions and 162 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. 61
      com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/RenderPass/Upscalers/FSR2WrapperUpscaler.cs
  2. 142
      com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/RenderPass/Upscalers/FSR3UpscalerPlugin.cs
  3. 177
      com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/RenderPass/Upscalers/UpscalerPlugin.cs

61
com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/RenderPass/Upscalers/FSR2WrapperUpscaler.cs
View File

@ -1,6 +1,6 @@
using System;
#if UNITY_STANDALONE_WIN
#if UNITY_STANDALONE_WIN && false
namespace UnityEngine.Rendering.HighDefinition.AMD.FSR2Wrapper
{
/// <summary>
@ -11,19 +11,40 @@ namespace UnityEngine.Rendering.HighDefinition.AMD.FSR2Wrapper
{
public override string name => "FSR 2.1";
public override bool isSupported => IsLoaded();
public override bool isSupported => UnityEngine.AMD.AMDUnityPlugin.IsLoaded();
public override bool Load() => UnityEngine.AMD.AMDUnityPlugin.Load();
public override bool Load()
{
if (!UnityEngine.AMD.AMDUnityPlugin.Load())
return false;
if (UnityEngine.AMD.GraphicsDevice.device == null)
UnityEngine.AMD.GraphicsDevice.CreateGraphicsDevice();
public override bool IsLoaded() => UnityEngine.AMD.AMDUnityPlugin.IsLoaded();
return UnityEngine.AMD.GraphicsDevice.device != null;
}
public override GraphicsDevice CreateGraphicsDevice() => new FSR2WrappedGraphicsDevice(UnityEngine.AMD.GraphicsDevice.CreateGraphicsDevice());
public override bool IsLoaded() => UnityEngine.AMD.AMDUnityPlugin.IsLoaded() && UnityEngine.AMD.GraphicsDevice.device != null;
public override void DestroyGraphicsDevice() { } // Noop, native plugin does not allow clearing the graphics device
public override UpscalerContext CreateContext(in FSR2CommandInitializationData initSettings)
{
throw new NotImplementedException();
}
public override GraphicsDevice device => new FSR2WrappedGraphicsDevice(UnityEngine.AMD.GraphicsDevice.device);
public override void DestroyContext(UpscalerContext context)
{
throw new NotImplementedException();
}
public override bool GetRenderResolutionFromQualityMode(FSR2Quality qualityMode, uint displayWidth, uint displayHeight, out uint renderWidth, out uint renderHeight)
{
return UnityEngine.AMD.GraphicsDevice.device.GetRenderResolutionFromQualityMode((UnityEngine.AMD.FSR2Quality)qualityMode, displayWidth, displayHeight, out renderWidth, out renderHeight);
}
public override uint version => UnityEngine.AMD.GraphicsDevice.version;
public override float GetUpscaleRatioFromQualityMode(FSR2Quality qualityMode)
{
return UnityEngine.AMD.GraphicsDevice.device.GetUpscaleRatioFromQualityMode((UnityEngine.AMD.FSR2Quality)qualityMode);
}
}
public class FSR2WrappedGraphicsDevice: GraphicsDevice
@ -64,22 +85,21 @@ namespace UnityEngine.Rendering.HighDefinition.AMD.FSR2Wrapper
}
}
public class FSR2WrappedContext : FSR2Context
public class FSR2WrappedContext : UpscalerContext
{
internal readonly UnityEngine.AMD.FSR2Context WrappedContext;
private readonly FSR2CommandInitializationData _initData;
private UnityEngine.AMD.FSR2Context _wrappedContext;
private FSR2CommandInitializationData _initData;
public override ref FSR2CommandInitializationData initData => ref _initData;
private FSR2CommandExecutionData _executeData;
public override ref FSR2CommandExecutionData executeData => ref _executeData;
internal FSR2WrappedContext(UnityEngine.AMD.FSR2Context wrappedContext, in FSR2CommandInitializationData initData)
internal FSR2WrappedContext(in FSR2CommandInitializationData initData)
{
WrappedContext = wrappedContext;
_initData = initData;
}
internal void Init(UnityEngine.AMD.GraphicsDevice graphicsDevice)
{
_wrappedContext = graphicsDevice.CreateFeature()
}
internal void SyncExecuteData()
{
WrappedContext.executeData.jitterOffsetX = _executeData.jitterOffsetX;
@ -97,6 +117,11 @@ namespace UnityEngine.Rendering.HighDefinition.AMD.FSR2Wrapper
WrappedContext.executeData.cameraFar = _executeData.cameraFar;
WrappedContext.executeData.cameraFovAngleVertical = _executeData.cameraFovAngleVertical;
}
public override void Execute(CommandBuffer cmd, in FSR2CommandExecutionData executeData, in FSR2TextureTable textures)
{
throw new NotImplementedException();
}
}
internal static class FSR2WrapperExtensions

142
com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/RenderPass/Upscalers/FSR3UpscalerPlugin.cs
View File

@ -9,55 +9,13 @@ namespace UnityEngine.Rendering.HighDefinition.AMD.FSR3
/// </summary>
public class FSR3UpscalerPlugin: UpscalerPlugin
{
private static FSR3GraphicsDevice sGraphicsDeviceInstance;
private Fsr3UpscalerAssets _assets;
public override string name => "FSR 3.0";
public override bool isSupported => SystemInfo.supportsComputeShaders;
public override bool Load() => true;
public override bool IsLoaded() => true;
public override GraphicsDevice CreateGraphicsDevice()
{
if (sGraphicsDeviceInstance != null)
{
sGraphicsDeviceInstance.Shutdown();
sGraphicsDeviceInstance.Initialize();
return sGraphicsDeviceInstance;
}
var graphicsDevice = new FSR3GraphicsDevice();
if (graphicsDevice.Initialize())
{
sGraphicsDeviceInstance = graphicsDevice;
return graphicsDevice;
}
Debug.LogWarning("Failed to initialize FSR3 Graphics Device");
return null;
}
public override void DestroyGraphicsDevice()
{
if (sGraphicsDeviceInstance != null)
{
sGraphicsDeviceInstance.Shutdown();
sGraphicsDeviceInstance = null;
}
}
public override GraphicsDevice device => sGraphicsDeviceInstance;
}
public class FSR3GraphicsDevice : GraphicsDevice
{
private readonly Stack<FSR3Context> _contextPool = new();
private Fsr3UpscalerAssets _assets;
internal bool Initialize()
public override bool Load()
{
if (_assets != null)
return true;
@ -66,37 +24,18 @@ namespace UnityEngine.Rendering.HighDefinition.AMD.FSR3
return _assets != null;
}
internal void Shutdown()
{
foreach (var context in _contextPool)
{
context.Reset();
}
if (_assets != null)
{
Resources.UnloadAsset(_assets);
_assets = null;
}
}
public override bool IsLoaded() => _assets != null;
public override FSR2Context CreateFeature(CommandBuffer cmd, in FSR2CommandInitializationData initSettings)
public override UpscalerContext CreateContext(in FSR2CommandInitializationData initSettings)
{
var context = _contextPool.Count != 0 ? _contextPool.Pop() : new FSR3Context();
context.Init(initSettings, _assets);
var context = new FSR3UpscalerContext(in initSettings);
context.Init(_assets);
return context;
}
public override void DestroyFeature(CommandBuffer cmd, FSR2Context fsrContext)
public override void DestroyContext(UpscalerContext context)
{
var context = (FSR3Context)fsrContext;
context.Reset();
_contextPool.Push(context);
}
public override void ExecuteFSR2(CommandBuffer cmd, FSR2Context fsrContext, in FSR2TextureTable textures)
{
((FSR3Context)fsrContext).Draw(cmd, in textures);
((FSR3UpscalerContext)context).Destroy();
}
public override bool GetRenderResolutionFromQualityMode(FSR2Quality qualityMode, uint displayWidth, uint displayHeight, out uint renderWidth, out uint renderHeight)
@ -113,50 +52,45 @@ namespace UnityEngine.Rendering.HighDefinition.AMD.FSR3
}
}
public class FSR3Context : FSR2Context
public class FSR3UpscalerContext : UpscalerContext
{
private FSR2CommandInitializationData _initData;
public override ref FSR2CommandInitializationData initData => ref _initData;
private FSR2CommandExecutionData _executeData;
public override ref FSR2CommandExecutionData executeData => ref _executeData;
private readonly Fsr3UpscalerContext _context = new();
private readonly Fsr3Upscaler.DispatchDescription _dispatchDescription = new();
private readonly FSR2CommandInitializationData _initData;
internal void Init(in FSR2CommandInitializationData initSettings, Fsr3UpscalerAssets assets)
internal FSR3UpscalerContext(in FSR2CommandInitializationData initSettings)
{
_initData = initSettings;
}
internal void Init(Fsr3UpscalerAssets assets)
{
Fsr3Upscaler.InitializationFlags flags = Fsr3Upscaler.InitializationFlags.EnableFP16Usage;
if (initSettings.GetFlag(FfxFsr2InitializationFlags.EnableHighDynamicRange)) flags |= Fsr3Upscaler.InitializationFlags.EnableHighDynamicRange;
if (initSettings.GetFlag(FfxFsr2InitializationFlags.EnableDisplayResolutionMotionVectors)) flags |= Fsr3Upscaler.InitializationFlags.EnableDisplayResolutionMotionVectors;
if (initSettings.GetFlag(FfxFsr2InitializationFlags.EnableMotionVectorsJitterCancellation)) flags |= Fsr3Upscaler.InitializationFlags.EnableMotionVectorsJitterCancellation;
if (initSettings.GetFlag(FfxFsr2InitializationFlags.DepthInverted)) flags |= Fsr3Upscaler.InitializationFlags.EnableDepthInverted;
if (initSettings.GetFlag(FfxFsr2InitializationFlags.EnableDepthInfinite)) flags |= Fsr3Upscaler.InitializationFlags.EnableDepthInfinite;
if (initSettings.GetFlag(FfxFsr2InitializationFlags.EnableAutoExposure)) flags |= Fsr3Upscaler.InitializationFlags.EnableAutoExposure;
if (initSettings.GetFlag(FfxFsr2InitializationFlags.EnableDynamicResolution)) flags |= Fsr3Upscaler.InitializationFlags.EnableDynamicResolution;
if (_initData.GetFlag(FfxFsr2InitializationFlags.EnableHighDynamicRange)) flags |= Fsr3Upscaler.InitializationFlags.EnableHighDynamicRange;
if (_initData.GetFlag(FfxFsr2InitializationFlags.EnableDisplayResolutionMotionVectors)) flags |= Fsr3Upscaler.InitializationFlags.EnableDisplayResolutionMotionVectors;
if (_initData.GetFlag(FfxFsr2InitializationFlags.EnableMotionVectorsJitterCancellation)) flags |= Fsr3Upscaler.InitializationFlags.EnableMotionVectorsJitterCancellation;
if (_initData.GetFlag(FfxFsr2InitializationFlags.DepthInverted)) flags |= Fsr3Upscaler.InitializationFlags.EnableDepthInverted;
if (_initData.GetFlag(FfxFsr2InitializationFlags.EnableDepthInfinite)) flags |= Fsr3Upscaler.InitializationFlags.EnableDepthInfinite;
if (_initData.GetFlag(FfxFsr2InitializationFlags.EnableAutoExposure)) flags |= Fsr3Upscaler.InitializationFlags.EnableAutoExposure;
if (_initData.GetFlag(FfxFsr2InitializationFlags.EnableDynamicResolution)) flags |= Fsr3Upscaler.InitializationFlags.EnableDynamicResolution;
//Debug.Log($"Initializing FSR3 with max render size: {initSettings.maxRenderSizeWidth}x{initSettings.maxRenderSizeHeight}, display size: {initSettings.displaySizeWidth}x{initSettings.displaySizeHeight}, flags: {flags}");
Debug.Log($"Initializing FSR3 with max render size: {_initData.maxRenderSizeWidth}x{_initData.maxRenderSizeHeight}, display size: {_initData.displaySizeWidth}x{_initData.displaySizeHeight}, flags: {flags}");
_context.Create(new Fsr3Upscaler.ContextDescription
{
DisplaySize = new Vector2Int((int)initSettings.displaySizeWidth, (int)initSettings.displaySizeHeight),
MaxRenderSize = new Vector2Int((int)initSettings.maxRenderSizeWidth, (int)initSettings.maxRenderSizeHeight),
DisplaySize = new Vector2Int((int)_initData.displaySizeWidth, (int)_initData.displaySizeHeight),
MaxRenderSize = new Vector2Int((int)_initData.maxRenderSizeWidth, (int)_initData.maxRenderSizeHeight),
Flags = flags,
Shaders = assets.shaders,
});
}
internal void Reset()
internal void Destroy()
{
_context.Destroy();
_initData = new FSR2CommandInitializationData();
_executeData = new FSR2CommandExecutionData();
}
internal void Draw(CommandBuffer cmd, in FSR2TextureTable textures)
public override void Execute(CommandBuffer cmd, in FSR2CommandExecutionData executeData, in FSR2TextureTable textures)
{
_dispatchDescription.Color = new ResourceView(textures.colorInput);
_dispatchDescription.Depth = new ResourceView(textures.depth);
@ -166,18 +100,18 @@ namespace UnityEngine.Rendering.HighDefinition.AMD.FSR3
_dispatchDescription.TransparencyAndComposition = new ResourceView(textures.transparencyMask);
_dispatchDescription.Output = new ResourceView(textures.colorOutput);
_dispatchDescription.JitterOffset = new Vector2(_executeData.jitterOffsetX, _executeData.jitterOffsetY);
_dispatchDescription.MotionVectorScale = new Vector2(_executeData.MVScaleX, _executeData.MVScaleY);
_dispatchDescription.RenderSize = new Vector2Int((int)_executeData.renderSizeWidth, (int)_executeData.renderSizeHeight);
_dispatchDescription.InputResourceSize = new Vector2Int((int)_executeData.renderSizeWidth, (int)_executeData.renderSizeHeight);
_dispatchDescription.EnableSharpening = _executeData.enableSharpening != 0;
_dispatchDescription.Sharpness = _executeData.sharpness;
_dispatchDescription.FrameTimeDelta = _executeData.frameTimeDelta / 1000f;
_dispatchDescription.PreExposure = _executeData.preExposure;
_dispatchDescription.Reset = _executeData.reset != 0;
_dispatchDescription.CameraNear = _executeData.cameraNear;
_dispatchDescription.CameraFar = _executeData.cameraFar;
_dispatchDescription.CameraFovAngleVertical = _executeData.cameraFovAngleVertical;
_dispatchDescription.JitterOffset = new Vector2(executeData.jitterOffsetX, executeData.jitterOffsetY);
_dispatchDescription.MotionVectorScale = new Vector2(executeData.MVScaleX, executeData.MVScaleY);
_dispatchDescription.RenderSize = new Vector2Int((int)executeData.renderSizeWidth, (int)executeData.renderSizeHeight);
_dispatchDescription.InputResourceSize = new Vector2Int((int)executeData.renderSizeWidth, (int)executeData.renderSizeHeight);
_dispatchDescription.EnableSharpening = executeData.enableSharpening != 0;
_dispatchDescription.Sharpness = executeData.sharpness;
_dispatchDescription.FrameTimeDelta = executeData.frameTimeDelta / 1000f;
_dispatchDescription.PreExposure = executeData.preExposure;
_dispatchDescription.Reset = executeData.reset != 0;
_dispatchDescription.CameraNear = executeData.cameraNear;
_dispatchDescription.CameraFar = executeData.cameraFar;
_dispatchDescription.CameraFovAngleVertical = executeData.cameraFovAngleVertical;
_dispatchDescription.ViewSpaceToMetersFactor = 1.0f; // 1 unit is 1 meter in Unity
_context.Dispatch(_dispatchDescription, cmd);

177
com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/RenderPass/Upscalers/UpscalerPlugin.cs
View File

@ -10,7 +10,7 @@ namespace UnityEngine.Rendering.HighDefinition.AMD
private static readonly List<UpscalerPlugin> AvailablePlugins = new()
{
new FSR3.FSR3UpscalerPlugin(),
#if UNITY_STANDALONE_WIN
#if UNITY_STANDALONE_WIN && false
new FSR2Wrapper.FSR2WrapperUpscaler(),
#endif
};
@ -19,7 +19,7 @@ namespace UnityEngine.Rendering.HighDefinition.AMD
public static bool Load() => ActivePlugin.Load();
public static bool IsLoaded() => ActivePlugin.IsLoaded();
public static bool IsLoaded() => ActivePlugin.IsLoaded() || ActivePlugin.isSupported;
/// <summary>
/// Get the list of available upscaler plugins, as a read-only list.
@ -72,69 +72,180 @@ namespace UnityEngine.Rendering.HighDefinition.AMD
if (newPlugin == ActivePlugin)
return true;
// If HDRP has previously created a graphics device, then it'll expect that to remain in place.
// Hence, make sure we automatically create a graphics device for the new plugin.
if (ActivePlugin != null && ActivePlugin.device != null)
{
var newDevice = newPlugin.CreateGraphicsDevice();
if (newDevice == null)
return false;
if (!newPlugin.IsLoaded() && !newPlugin.Load())
return false;
ActivePlugin.DestroyGraphicsDevice();
// TODO do we need to create a new "Feature" as well? Does HDRP cache this anywhere?
}
// Hot-swap the upscaler contexts, so HDRP can keep calling the same FSR2Contexts without knowing the underlying implementation has changed.
GraphicsDevice.device.RecreateFeatures(ActivePlugin, newPlugin);
ActivePlugin = newPlugin;
return true;
}
}
public abstract class UpscalerPlugin
public class GraphicsDevice
{
public abstract string name { get; }
private static GraphicsDevice sGraphicsDevice = null;
public abstract bool isSupported { get; }
public static GraphicsDevice device => sGraphicsDevice;
public abstract bool Load();
public static uint version => 0x00;
public abstract bool IsLoaded();
private readonly HashSet<FSR2Context> _contexts = new();
public static GraphicsDevice CreateGraphicsDevice()
{
// Lazy initialization of the plugin, because HDRP fails to call AMDUnityPlugin.Load() itself
UpscalerPlugin plugin = AMDUnityPlugin.ActivePlugin;
if (plugin != null && !plugin.IsLoaded())
{
if (!plugin.Load())
{
Debug.LogWarning("Failed to initialize upscaler plugin");
return null;
}
}
public abstract GraphicsDevice CreateGraphicsDevice();
if (sGraphicsDevice != null)
{
sGraphicsDevice.Shutdown();
sGraphicsDevice.Initialize();
return sGraphicsDevice;
}
public abstract void DestroyGraphicsDevice();
GraphicsDevice graphicsDevice = new GraphicsDevice();
if (graphicsDevice.Initialize())
{
sGraphicsDevice = graphicsDevice;
return graphicsDevice;
}
public abstract GraphicsDevice device { get; }
Debug.LogWarning("Failed to initialize upscaler GraphicsDevice");
return null;
}
public virtual uint version => 0x00;
private bool Initialize()
{
return true;
}
private void Shutdown()
{
}
internal void RecreateFeatures(UpscalerPlugin oldPlugin, UpscalerPlugin newPlugin)
{
foreach (FSR2Context context in _contexts)
{
context.Destroy(oldPlugin);
context.Create(newPlugin);
}
}
public FSR2Context CreateFeature(CommandBuffer cmd, in FSR2CommandInitializationData initSettings)
{
FSR2Context context = new FSR2Context(in initSettings);
if (!context.Create(AMDUnityPlugin.ActivePlugin))
return null;
_contexts.Add(context);
return context;
}
public void DestroyFeature(CommandBuffer cmd, FSR2Context fsrContext)
{
fsrContext.Destroy(AMDUnityPlugin.ActivePlugin);
_contexts.Remove(fsrContext);
}
public void ExecuteFSR2(CommandBuffer cmd, FSR2Context fsrContext, in FSR2TextureTable textures)
{
fsrContext.Execute(cmd, textures);
}
public bool GetRenderResolutionFromQualityMode(FSR2Quality qualityMode, uint displayWidth, uint displayHeight, out uint renderWidth, out uint renderHeight)
{
UpscalerPlugin plugin = AMDUnityPlugin.ActivePlugin;
if (plugin == null)
{
renderWidth = displayWidth;
renderHeight = displayHeight;
return false;
}
return plugin.GetRenderResolutionFromQualityMode(qualityMode, displayWidth, displayHeight, out renderWidth, out renderHeight);
}
public float GetUpscaleRatioFromQualityMode(FSR2Quality qualityMode)
{
UpscalerPlugin plugin = AMDUnityPlugin.ActivePlugin;
if (plugin == null)
{
return 1.0f;
}
return plugin.GetUpscaleRatioFromQualityMode(qualityMode);
}
}
public abstract class GraphicsDevice
public class FSR2Context
{
public static GraphicsDevice device => AMDUnityPlugin.ActivePlugin.device;
private UpscalerContext _wrappedContext;
public static uint version => AMDUnityPlugin.ActivePlugin.version;
private FSR2CommandInitializationData _initData;
public ref FSR2CommandInitializationData initData => ref _initData;
public static GraphicsDevice CreateGraphicsDevice()
private FSR2CommandExecutionData _executeData;
public ref FSR2CommandExecutionData executeData => ref _executeData;
public FSR2Context(in FSR2CommandInitializationData initSettings)
{
_initData = initSettings;
}
public bool Create(UpscalerPlugin plugin)
{
return AMDUnityPlugin.ActivePlugin.CreateGraphicsDevice();
_wrappedContext = plugin?.CreateContext(in _initData);
return _wrappedContext != null;
}
public abstract FSR2Context CreateFeature(CommandBuffer cmd, in FSR2CommandInitializationData initSettings);
public void Destroy(UpscalerPlugin plugin)
{
if (_wrappedContext == null)
return;
public abstract void DestroyFeature(CommandBuffer cmd, FSR2Context fsrContext);
plugin?.DestroyContext(_wrappedContext);
_wrappedContext = null;
}
public void Execute(CommandBuffer cmd, in FSR2TextureTable textures)
{
_wrappedContext?.Execute(cmd, in executeData, in textures);
}
}
public abstract void ExecuteFSR2(CommandBuffer cmd, FSR2Context fsrContext, in FSR2TextureTable textures);
public abstract class UpscalerPlugin
{
public abstract string name { get; }
public abstract bool isSupported { get; }
public abstract bool Load();
public abstract bool IsLoaded();
public abstract UpscalerContext CreateContext(in FSR2CommandInitializationData initSettings);
public abstract void DestroyContext(UpscalerContext context);
public abstract bool GetRenderResolutionFromQualityMode(FSR2Quality qualityMode, uint displayWidth, uint displayHeight, out uint renderWidth, out uint renderHeight);
public abstract float GetUpscaleRatioFromQualityMode(FSR2Quality qualityMode);
}
public abstract class FSR2Context
public abstract class UpscalerContext
{
public abstract ref FSR2CommandInitializationData initData { get; }
public abstract ref FSR2CommandExecutionData executeData { get; }
public abstract void Execute(CommandBuffer cmd, in FSR2CommandExecutionData executeData, in FSR2TextureTable textures);
}
public struct FSR2CommandInitializationData

Write Preview
Loading…
Cancel
Save