DLSSPass.cs

using System.Collections.Generic;
using UnityEngine.Experimental.Rendering;

namespace UnityEngine.Rendering.HighDefinition
{
    internal class DLSSPass
    {

        #region public members, general engine code
        public struct Parameters
        {
            public bool resetHistory;
            public float preExposure;
            public HDCamera hdCamera;
            public GlobalDynamicResolutionSettings drsSettings;
        }

        public static bool SetupFeature()
        {
#if ENABLE_NVIDIA && ENABLE_NVIDIA_MODULE
            if (!NVIDIA.NVUnityPlugin.IsLoaded())
                return false;

            if (s_ExpectedDeviceVersion != NVIDIA.GraphicsDevice.version)
            {
                Debug.LogWarning("Cannot instantiate NVIDIA device because the version HDRP expects does not match the backend version.");
                return false;
            }

            if (!SystemInfo.graphicsDeviceVendor.ToLowerInvariant().Contains("nvidia"))
                return false;

            var device = NVIDIA.GraphicsDevice.CreateGraphicsDevice();
            return device != null && device.IsFeatureAvailable(NVIDIA.GraphicsDeviceFeature.DLSS);
#else
            return false;
#endif
        }

        public static DLSSPass Create()
        {
            DLSSPass dlssPass = null;

#if ENABLE_NVIDIA && ENABLE_NVIDIA_MODULE
            if (!SetupFeature())
                return null;

            dlssPass = new DLSSPass(NVIDIA.GraphicsDevice.device);
#endif
            return dlssPass;
        }

        public void BeginFrame(HDCamera hdCamera)
        {
#if ENABLE_NVIDIA && ENABLE_NVIDIA_MODULE
            InternalNVIDIABeginFrame(hdCamera);
#endif
        }

        public void SetupDRSScaling(bool enableAutomaticSettings, Camera camera, in HDAdditionalCameraData hdCam,  XRPass xrPass, ref GlobalDynamicResolutionSettings dynamicResolutionSettings)
        {
#if ENABLE_NVIDIA && ENABLE_NVIDIA_MODULE
            InternalNVIDIASetupDRSScaling(enableAutomaticSettings, camera, hdCam, xrPass, ref dynamicResolutionSettings);
#endif
        }

        public void Render(
            DLSSPass.Parameters parameters,
            UpscalerResources.CameraResources resources,
            CommandBuffer cmdBuffer)
        {
#if ENABLE_NVIDIA && ENABLE_NVIDIA_MODULE
            InternalNVIDIARender(parameters, resources, cmdBuffer);
#endif
        }

        #endregion

        #region private members, nvidia specific code
#if ENABLE_NVIDIA && ENABLE_NVIDIA_MODULE
        private static uint s_ExpectedDeviceVersion = 0x06;

        private UpscalerCameras m_CameraStates = new UpscalerCameras();

        private CommandBuffer m_CommandBuffer = new CommandBuffer();

        private NVIDIA.GraphicsDevice m_Device = null;

        private DLSSPass(NVIDIA.GraphicsDevice device)
        {
            m_Device = device;
        }

        private struct DlssViewData
        {
            public NVIDIA.DLSSQuality  perfQuality;
            public UpscalerResolution inputRes;
            public UpscalerResolution outputRes;
            public float sharpness;
            public float jitterX;
            public float jitterY;
            public bool reset;
            public uint presetQuality;
            public uint presetBalanced;
            public uint presetPerformance;
            public uint presetUltraPerformance;
            public uint presetDLAA;
            public bool CanFitInput(in UpscalerResolution inputRect)
            {
                return inputRes.width >= inputRect.width && inputRes.height > inputRect.height;
            }
        }

        private struct OptimalSettingsRequest
        {
            public NVIDIA.DLSSQuality quality;
            public Rect viewport;
            public NVIDIA.OptimalDLSSSettingsData optimalSettings;
            public bool CanFit(UpscalerResolution rect)
            {
                return rect.width >= optimalSettings.minWidth && rect.height >= optimalSettings.minHeight
                    && rect.width <= optimalSettings.maxWidth && rect.height <= optimalSettings.maxHeight;
            }
        }

        private static bool IsOptimalSettingsValid(in NVIDIA.OptimalDLSSSettingsData optimalSettings)
        {
            return optimalSettings.maxHeight >= optimalSettings.minHeight
                && optimalSettings.maxWidth  >= optimalSettings.minWidth
                && optimalSettings.maxWidth  != 0
                && optimalSettings.maxHeight != 0
                && optimalSettings.minWidth  != 0
                && optimalSettings.minHeight != 0;
        }

        private class ViewState
        {
            private NVIDIA.DLSSContext m_DlssContext = null;
            private NVIDIA.GraphicsDevice m_Device;
            private DlssViewData m_Data = new DlssViewData();
            private bool m_UsingOptimalSettings = false;
            private bool m_UseAutomaticSettings = false;
            private UpscalerResolution m_BackbufferRes;
            private OptimalSettingsRequest m_OptimalSettingsRequest = new OptimalSettingsRequest();

            public NVIDIA.DLSSContext DLSSContext { get { return m_DlssContext; } }
            public bool useAutomaticSettings { get { return m_UseAutomaticSettings; } }
            public OptimalSettingsRequest OptimalSettingsRequestData { get { return m_OptimalSettingsRequest; } }

            public ViewState()
            {
            }

            public void Init(NVIDIA.GraphicsDevice device)
            {
                m_Device = device;
                m_DlssContext = null;
            }

            public void RequestUseAutomaticSettings(bool useAutomaticSettings, NVIDIA.DLSSQuality quality, Rect viewport, in NVIDIA.OptimalDLSSSettingsData optimalSettings)
            {
                m_UseAutomaticSettings = useAutomaticSettings;
                m_OptimalSettingsRequest.quality = quality;
                m_OptimalSettingsRequest.viewport = viewport;
                m_OptimalSettingsRequest.optimalSettings = optimalSettings;
            }

            public void ClearAutomaticSettings()
            {
                m_UseAutomaticSettings = false;
            }

            private bool ShouldUseAutomaticSettings()
            {
                if (!m_UseAutomaticSettings || m_DlssContext == null)
                    return false;

                return m_DlssContext.initData.quality == m_OptimalSettingsRequest.quality
                    && m_DlssContext.initData.outputRTHeight == (uint)m_OptimalSettingsRequest.viewport.height
                    && m_DlssContext.initData.outputRTWidth  == (uint)m_OptimalSettingsRequest.viewport.width
                    && IsOptimalSettingsValid(m_OptimalSettingsRequest.optimalSettings);
            }

            static NVIDIA.DLSSPreset Uint2Preset(uint preset)
            {
                if (preset >= (uint)NVIDIA.DLSSPreset.Preset_Default && preset <= (uint)NVIDIA.DLSSPreset.Preset_M)
                    return (NVIDIA.DLSSPreset)preset;
                Debug.LogWarningFormat("Unknown DLSS Preset value {0}, using default value.", preset);
                return NVIDIA.DLSSPreset.Preset_Default;
            }
            static bool PresetChanged(in DlssViewData prev, in DlssViewData curr)
            {
                return  prev.presetQuality != curr.presetQuality ||
                        prev.presetBalanced != curr.presetBalanced ||
                        prev.presetPerformance != curr.presetPerformance ||
                        prev.presetUltraPerformance != curr.presetUltraPerformance ||
                        prev.presetDLAA != curr.presetDLAA;
            }

            public void UpdateViewState(
                in DlssViewData viewData,
                CommandBuffer cmdBuffer)
            {
                if(m_Device == null)
                    return;

                bool shouldUseOptimalSettings = ShouldUseAutomaticSettings();
                bool isNew = false;
                if (viewData.outputRes != m_Data.outputRes ||
                    (viewData.inputRes.width > m_BackbufferRes.width || viewData.inputRes.height > m_BackbufferRes.height) ||
                    (viewData.inputRes != m_BackbufferRes && !m_OptimalSettingsRequest.CanFit(viewData.inputRes)) ||
                    viewData.perfQuality != m_Data.perfQuality ||
                    m_DlssContext == null ||
                    shouldUseOptimalSettings != m_UsingOptimalSettings ||
                    PresetChanged(viewData, m_Data)
                )
                {
                    isNew = true;
                    m_BackbufferRes = viewData.inputRes;

                    if (m_DlssContext != null)
                    {
                        m_Device.DestroyFeature(cmdBuffer, m_DlssContext);
                        m_DlssContext = null;
                    }

                    var settings = new NVIDIA.DLSSCommandInitializationData();
                    settings.SetFlag(NVIDIA.DLSSFeatureFlags.IsHDR, true);
                    settings.SetFlag(NVIDIA.DLSSFeatureFlags.MVLowRes, true);
                    settings.SetFlag(NVIDIA.DLSSFeatureFlags.DepthInverted, true);
                    settings.inputRTWidth   = m_BackbufferRes.width;
                    settings.inputRTHeight  = m_BackbufferRes.height;
                    settings.outputRTWidth  = viewData.outputRes.width;
                    settings.outputRTHeight = viewData.outputRes.height;
                    settings.quality = viewData.perfQuality;

                    settings.presetQualityMode = Uint2Preset(viewData.presetQuality);
                    settings.presetBalancedMode = Uint2Preset(viewData.presetBalanced);
                    settings.presetPerformanceMode = Uint2Preset(viewData.presetPerformance);
                    settings.presetUltraPerformanceMode = Uint2Preset(viewData.presetUltraPerformance);
                    settings.presetDlaaMode = Uint2Preset(viewData.presetDLAA);

                    m_UsingOptimalSettings = shouldUseOptimalSettings;
                    m_DlssContext = m_Device.CreateFeature(cmdBuffer, settings);
                }

                m_Data = viewData;
                m_Data.reset = isNew || viewData.reset;
            }

            public void SubmitDlssCommands(
                Texture source,
                Texture depth,
                Texture motionVectors,
                Texture biasColorMask,
                Texture output,
                float preExposure,
                CommandBuffer cmdBuffer)
            {
                if (m_DlssContext == null)
                    return;

                m_DlssContext.executeData.sharpness = m_UsingOptimalSettings ? m_OptimalSettingsRequest.optimalSettings.sharpness : m_Data.sharpness;
                m_DlssContext.executeData.mvScaleX = -((float)m_Data.inputRes.width);
                m_DlssContext.executeData.mvScaleY = -((float)m_Data.inputRes.height);
                m_DlssContext.executeData.subrectOffsetX = 0;
                m_DlssContext.executeData.subrectOffsetY = 0;
                m_DlssContext.executeData.subrectWidth = m_Data.inputRes.width;
                m_DlssContext.executeData.subrectHeight = m_Data.inputRes.height;
                m_DlssContext.executeData.jitterOffsetX = m_Data.jitterX;
                m_DlssContext.executeData.jitterOffsetY = m_Data.jitterY;
                m_DlssContext.executeData.preExposure = preExposure;
                m_DlssContext.executeData.invertYAxis = 1u;
                m_DlssContext.executeData.invertXAxis = 0u;
                m_DlssContext.executeData.reset = m_Data.reset ? 1 : 0;

                var textureTable = new NVIDIA.DLSSTextureTable()
                {
                    colorInput = source,
                    colorOutput = output,
                    depth = depth,
                    motionVectors = motionVectors,
                    biasColorMask = biasColorMask
                };

                m_Device.ExecuteDLSS(cmdBuffer, m_DlssContext, textureTable);
            }

            public void Cleanup(CommandBuffer cmdBuffer)
            {
                if (m_DlssContext != null)
                {
                    m_Device.DestroyFeature(cmdBuffer, m_DlssContext);
                    m_DlssContext = null;
                }

                m_Device = null;
                m_Data = new DlssViewData();
                m_UsingOptimalSettings = false;
                m_UseAutomaticSettings = false;
                m_BackbufferRes = new UpscalerResolution();
                m_OptimalSettingsRequest = new OptimalSettingsRequest();
            }
        }

        private class DLSSCamera
        {
            List<ViewState> m_Views = null;
            NVIDIA.GraphicsDevice m_Device = null;
            PerformDynamicRes m_ScaleDelegate = null;
            public PerformDynamicRes ScaleDelegate { get { return m_ScaleDelegate; } }
            public List<ViewState> ViewStates { get { return m_Views; } }

            public DLSSCamera()
            {
                m_ScaleDelegate = ScaleFn;
            }

            public void Init(NVIDIA.GraphicsDevice device)
            {
                m_Device = device;
            }

            public void ClearAutomaticSettings()
            {
                if (m_Views == null)
                    return;
                foreach (var v in m_Views)
                    v.ClearAutomaticSettings();
            }

            private float ScaleFn()
            {
                if (m_Views == null  || m_Views.Count == 0)
                    return 100.0f;

                var viewState = m_Views[0];
                if (!viewState.useAutomaticSettings)
                    return 100.0f;

                var optimalSettings = viewState.OptimalSettingsRequestData.optimalSettings;
                var targetViewport = viewState.OptimalSettingsRequestData.viewport;
                float suggestedPercentageX = (float)optimalSettings.outRenderWidth / targetViewport.width;
                float suggestedPercentageY = (float)optimalSettings.outRenderHeight / targetViewport.height;
                return Mathf.Min(suggestedPercentageX, suggestedPercentageY) * 100.0f;
            }

            public void SubmitCommands(
                HDCamera camera,
                float preExposure,
                in DlssViewData viewData,
                in UpscalerResources.CameraResources camResources,
                CommandBuffer cmdBuffer)
            {
                int cameraViewCount = 1;
                int activeViewId = 0;
                if (camera.xr.enabled)
                {
                    cameraViewCount = camera.xr.singlePassEnabled ? camera.xr.viewCount : 2;
                    activeViewId = camera.xr.multipassId;
                }

                if (m_Views == null || m_Views.Count != cameraViewCount)
                {
                    if (m_Views != null)
                        Cleanup(cmdBuffer);

                    m_Views = ListPool<ViewState>.Get();
                    for (int viewId = 0; viewId < cameraViewCount; ++viewId)
                    {
                        var newView = GenericPool<ViewState>.Get();
                        newView.Init(m_Device);
                        m_Views.Add(newView);
                    }
                }

                void RunPass(ViewState viewState, CommandBuffer cmdBuffer, in DlssViewData viewData, in UpscalerResources.ViewResources viewResources)
                {
                    viewState.UpdateViewState(viewData, cmdBuffer);
                    viewState.SubmitDlssCommands(
                        viewResources.source,
                        viewResources.depth,
                        viewResources.motionVectors,
                        viewResources.biasColorMask,
                        viewResources.output, preExposure, cmdBuffer);
                }

                if (camResources.copyToViews)
                {
                    Assertions.Assert.IsTrue(camera.xr.enabled && camera.xr.singlePassEnabled, "XR must be enabled for tmp copying to views to occur");

                    //copy to tmp views first, to maximize pipelining
                    for (int viewId = 0; viewId < m_Views.Count; ++viewId)
                    {
                        ViewState viewState = m_Views[viewId];
                        UpscalerResources.ViewResources tmpResources = viewId == 0 ? camResources.tmpView0 : camResources.tmpView1;

                        cmdBuffer.CopyTexture(camResources.resources.source, viewId, tmpResources.source, 0);
                        cmdBuffer.CopyTexture(camResources.resources.depth, viewId, tmpResources.depth, 0);
                        cmdBuffer.CopyTexture(camResources.resources.motionVectors, viewId, tmpResources.motionVectors, 0);

                        if (camResources.resources.biasColorMask != null)
                            cmdBuffer.CopyTexture(camResources.resources.biasColorMask, viewId, tmpResources.biasColorMask, 0);
                    }

                    for (int viewId = 0; viewId < m_Views.Count; ++viewId)
                    {
                        ViewState viewState = m_Views[viewId];
                        UpscalerResources.ViewResources tmpResources = viewId == 0 ? camResources.tmpView0 : camResources.tmpView1;
                        RunPass(viewState, cmdBuffer, viewData, tmpResources);
                        cmdBuffer.CopyTexture(tmpResources.output, 0, camResources.resources.output, viewId);
                    }
                }
                else
                {
                    RunPass(m_Views[activeViewId], cmdBuffer, viewData, camResources.resources);
                }
            }

            public void Cleanup(CommandBuffer cmdBuffer)
            {
                if (m_Views == null)
                    return;

                foreach (var v in m_Views)
                {
                    v.Cleanup(cmdBuffer);
                    GenericPool<ViewState>.Release(v);
                }

                ListPool<ViewState>.Release(m_Views);
                m_Views = null;
                m_Device = null;
            }
        }

        private void CleanupCameraStates()
        {
            Dictionary<EntityId, UpscalerCameras.State> cameras = m_CameraStates.cameras;
            m_CommandBuffer.Clear();
            foreach (var kv in cameras)
            {
                var cameraState = kv.Value;
                if (!m_CameraStates.HasCameraStateExpired(cameraState) || cameraState.data == null)
                    continue;

                var dlssCamera = cameraState.data as DLSSCamera;
                dlssCamera.Cleanup(m_CommandBuffer);
                GenericPool<DLSSCamera>.Release(dlssCamera);
                cameraState.data = null;
            }
            Graphics.ExecuteCommandBuffer(m_CommandBuffer);
            m_CameraStates.CleanupCameraStates();
        }

        private void InternalNVIDIASetupDRSScaling(bool enableAutomaticSettings, Camera camera, in HDAdditionalCameraData hdCam, XRPass xrPass, ref GlobalDynamicResolutionSettings dynamicResolutionSettings)
        {
            if (m_Device == null)
                return;

            UpscalerCameras.State cameraState = m_CameraStates.GetState(camera);
            if (cameraState == null)
                return;

            var dlssCamera = cameraState.data as DLSSCamera;
            if (dlssCamera.ViewStates == null || dlssCamera.ViewStates.Count == 0)
                return;

            if (dlssCamera.ViewStates[0].DLSSContext == null)
                return;

            var usedQuality = dlssCamera.ViewStates[0].DLSSContext.initData.quality;
            Rect finalViewport = xrPass != null && xrPass.enabled ? xrPass.GetViewport() : new Rect(camera.pixelRect.x, camera.pixelRect.y, camera.pixelWidth, camera.pixelHeight);
            NVIDIA.OptimalDLSSSettingsData optimalSettings = new NVIDIA.OptimalDLSSSettingsData();
            m_Device.GetOptimalSettings((uint)finalViewport.width, (uint)finalViewport.height, usedQuality, out optimalSettings);

            foreach (var view in dlssCamera.ViewStates)
            {
                if (view == null)
                    continue;

                view.RequestUseAutomaticSettings(enableAutomaticSettings, usedQuality, finalViewport, optimalSettings);
            }

            if (enableAutomaticSettings)
            {
                if (IsOptimalSettingsValid(optimalSettings) && enableAutomaticSettings)
                {
                    dynamicResolutionSettings.maxPercentage = Mathf.Min((float)optimalSettings.maxWidth / finalViewport.width, (float)optimalSettings.maxHeight / finalViewport.height) * 100.0f;
                    dynamicResolutionSettings.minPercentage = Mathf.Max((float)optimalSettings.minWidth / finalViewport.width, (float)optimalSettings.minHeight / finalViewport.height) * 100.0f;
                    DynamicResolutionHandler.SetSystemDynamicResScaler(dlssCamera.ScaleDelegate, DynamicResScalePolicyType.ReturnsPercentage);
                    DynamicResolutionHandler.SetActiveDynamicScalerSlot(DynamicResScalerSlot.System);
                }
            }
            else
            {
                dlssCamera.ClearAutomaticSettings();
            }
        }

        private void InternalNVIDIABeginFrame(HDCamera hdCamera)
        {
            if (m_Device == null)
                return;

            m_CameraStates.ProcessExpiredCameras();

            UpscalerCameras.State cameraState = m_CameraStates.GetState(hdCamera.camera);
            var dlssCamera = cameraState != null ? cameraState.data as DLSSCamera : (DLSSCamera)null;

            bool dlssActive = hdCamera.IsDLSSEnabled();

            if (cameraState == null && dlssActive)
            {
                dlssCamera = GenericPool<DLSSCamera>.Get();
                dlssCamera.Init(m_Device);
                cameraState = m_CameraStates.CreateState(hdCamera.camera);
                cameraState.data = dlssCamera;
            }
            else if (cameraState != null && !dlssActive)
            {
                m_CameraStates.InvalidateState(cameraState);
            }

            if (cameraState != null)
                m_CameraStates.TagUsed(cameraState);

            CleanupCameraStates();
            m_CameraStates.NextFrame();
        }

        private void InternalNVIDIARender(in DLSSPass.Parameters parameters, UpscalerResources.CameraResources resources, CommandBuffer cmdBuffer)
        {
            if (m_Device == null || m_CameraStates.cameras.Count == 0)
                return;

            UpscalerCameras.State cameraState = m_CameraStates.GetState(parameters.hdCamera.camera);
            if (cameraState == null)
                return;

            DLSSCamera dlssCamera = cameraState.data as DLSSCamera;
            var dlssViewData = new DlssViewData();

            dlssViewData.perfQuality =
                (NVIDIA.DLSSQuality)(
                    parameters.hdCamera.deepLearningSuperSamplingUseCustomQualitySettings
                    ? parameters.hdCamera.deepLearningSuperSamplingQuality
                    : parameters.drsSettings.DLSSPerfQualitySetting);

            // presets are per-project, not per camera.
            dlssViewData.presetQuality          = parameters.drsSettings.DLSSRenderPresetForQuality;
            dlssViewData.presetBalanced         = parameters.drsSettings.DLSSRenderPresetForBalanced;
            dlssViewData.presetPerformance      = parameters.drsSettings.DLSSRenderPresetForPerformance;
            dlssViewData.presetUltraPerformance = parameters.drsSettings.DLSSRenderPresetForUltraPerformance;
            dlssViewData.presetDLAA             = parameters.drsSettings.DLSSRenderPresetForDLAA;

            dlssViewData.inputRes  = new UpscalerResolution() { width = (uint)parameters.hdCamera.actualWidth, height = (uint)parameters.hdCamera.actualHeight };
            dlssViewData.outputRes = new UpscalerResolution() {
                width  = (uint)parameters.hdCamera.finalViewport.width,
                height = (uint)parameters.hdCamera.finalViewport.height
            };
            
            dlssViewData.jitterX = -parameters.hdCamera.taaJitter.x;
            dlssViewData.jitterY = -parameters.hdCamera.taaJitter.y;
            dlssViewData.reset = parameters.resetHistory;
            dlssCamera.SubmitCommands(parameters.hdCamera, parameters.preExposure, dlssViewData, resources, cmdBuffer);
        }

#endif
        #endregion
    }
}