UnityCACAO-HDRP17/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/RenderPass/Upscalers/FSR2WrapperUpscaler.cs

using System;

#if UNITY_STANDALONE_WIN
namespace UnityEngine.Rendering.HighDefinition.AMD.FSR2Wrapper
{
    /// <summary>
    /// Wrapper plugin that simply forwards calls to the original Unity native plugin implementation of FSR2.
    /// Use this to verify other plugins against Unity's reference implementation.
    /// </summary>
    public class FSR2WrapperUpscaler: UpscalerPlugin
    {
        public override string name => "FSR 2.1 (Unity)";

        public override bool isSupported => UnityEngine.AMD.AMDUnityPlugin.IsLoaded();

        public override bool Load()
        {
            if (!UnityEngine.AMD.AMDUnityPlugin.Load())
                return false;

            if (UnityEngine.AMD.GraphicsDevice.device == null)
                UnityEngine.AMD.GraphicsDevice.CreateGraphicsDevice();

            return UnityEngine.AMD.GraphicsDevice.device != null;
        }

        public override bool IsLoaded() => UnityEngine.AMD.AMDUnityPlugin.IsLoaded() && UnityEngine.AMD.GraphicsDevice.device != null;
        
        public override UpscalerContext CreateContext(in FSR2CommandInitializationData initSettings)
        {
            var context = new FSR2WrappedContext(in initSettings);
            context.Init();
            return context;
        }

        public override void DestroyContext(UpscalerContext context)
        {
            ((FSR2WrappedContext)context).Destroy();
        }

        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 float GetUpscaleRatioFromQualityMode(FSR2Quality qualityMode)
        {
            return UnityEngine.AMD.GraphicsDevice.device.GetUpscaleRatioFromQualityMode((UnityEngine.AMD.FSR2Quality)qualityMode);
        }
    }

    public class FSR2WrappedContext : UpscalerContext
    {
        private readonly FSR2CommandInitializationData _initData;
        
        private UnityEngine.AMD.FSR2Context _wrappedContext;
        
        private CommandBuffer _tempCmd;
        
        internal FSR2WrappedContext(in FSR2CommandInitializationData initData)
        {
            _initData = initData;
        }

        internal void Init()
        {
            _tempCmd ??= new CommandBuffer { name = "FSR2Wrapper" };
            
            _tempCmd.Clear();
            var initSettings = _initData.ToWrapped();
            _wrappedContext = UnityEngine.AMD.GraphicsDevice.device.CreateFeature(_tempCmd, in initSettings);
            Graphics.ExecuteCommandBuffer(_tempCmd);
        }

        internal void Destroy()
        {
            if (_wrappedContext == null)
                return;
            
            _tempCmd.Clear();
            UnityEngine.AMD.GraphicsDevice.device.DestroyFeature(_tempCmd, _wrappedContext);
            Graphics.ExecuteCommandBuffer(_tempCmd);
            
            _wrappedContext = null;
            _tempCmd.Release();
            _tempCmd = null;
        }
        
        public override void Execute(CommandBuffer cmd, in FSR2CommandExecutionData executeData, in FSR2TextureTable textures)
        {
            SyncExecuteData(in executeData);
            var tex = textures.ToWrapped();
            UnityEngine.AMD.GraphicsDevice.device.ExecuteFSR2(cmd, _wrappedContext, in tex);
        }

        private void SyncExecuteData(in FSR2CommandExecutionData executeData)
        {
            _wrappedContext.executeData.jitterOffsetX = executeData.jitterOffsetX;
            _wrappedContext.executeData.jitterOffsetY = executeData.jitterOffsetY;
            _wrappedContext.executeData.MVScaleX = executeData.MVScaleX;
            _wrappedContext.executeData.MVScaleY = executeData.MVScaleY;
            _wrappedContext.executeData.renderSizeWidth = executeData.renderSizeWidth;
            _wrappedContext.executeData.renderSizeHeight = executeData.renderSizeHeight;
            _wrappedContext.executeData.enableSharpening = executeData.enableSharpening;
            _wrappedContext.executeData.sharpness = executeData.sharpness;
            _wrappedContext.executeData.frameTimeDelta = executeData.frameTimeDelta;
            _wrappedContext.executeData.preExposure = executeData.preExposure;
            _wrappedContext.executeData.reset = executeData.reset;
            _wrappedContext.executeData.cameraNear = executeData.cameraNear;
            _wrappedContext.executeData.cameraFar = executeData.cameraFar;
            _wrappedContext.executeData.cameraFovAngleVertical = executeData.cameraFovAngleVertical;
        }
    }

    internal static class FSR2WrapperExtensions
    {
        public static UnityEngine.AMD.FSR2CommandInitializationData ToWrapped(this FSR2CommandInitializationData data)
        {
            return new UnityEngine.AMD.FSR2CommandInitializationData
            {
                displaySizeHeight = data.displaySizeHeight,
                displaySizeWidth = data.displaySizeWidth,
                ffxFsrFlags = (UnityEngine.AMD.FfxFsr2InitializationFlags)data.ffxFsrFlags,
                maxRenderSizeHeight = data.maxRenderSizeHeight,
                maxRenderSizeWidth = data.maxRenderSizeWidth,
            };
        }
        
        public static UnityEngine.AMD.FSR2TextureTable ToWrapped(this FSR2TextureTable table)
        {
            return new UnityEngine.AMD.FSR2TextureTable
            {
                biasColorMask = table.biasColorMask,
                colorInput = table.colorInput,
                colorOutput = table.colorOutput,
                depth = table.depth,
                exposureTexture = table.exposureTexture,
                motionVectors = table.motionVectors,
                reactiveMask = table.reactiveMask,
                transparencyMask = table.transparencyMask,
            };
        }
    }
}
#endif  // UNITY_STANDALONE_WIN