[Quest] URP XR Application Space Warp Support

Jira: https://jira.unity3d.com/browse/GFXFOUND-485
TDD: https://docs.google.com/document/d/1dcKIeihKJ4WfPnA3h1_5fhhouyfFGTlkRAzN8wLLI-4/edit#heading=h.e2arxtl9wukf

- Users can enable App SpaceWarp for URP projects, in order to reduce the application’s rendering rate and increase the total frametime budget.
***Note***: ASW feature is only added to URP RenderGraph code path, Vulkan Graphics API
- AppSW can be enabled when using the OpenXR plugin, and targeting the Vulkan graphics API when running URP RenderGraph.
- Following shaders are modified to provide compatibility with AppSW
  - Lit
  - Unlit
  - SimpleLit
  - ComplexLit
  - ObjectMotionVectorFallback

Author: thomas-zeng

Packages/com.unity.render-pipelines.core/Runtime/XR/XRGraphicsAutomatedTests.cs

@@ -74,7 +74,7 @@ internal static void OverrideLayout(XRLayout layout, Camera camera)
                                 viewMatrix *= Matrix4x4.Translate(new Vector3(.34f, 0.25f, -0.08f));
                             }
 
-                            XRView xrView = new XRView(projMatrix, viewMatrix, xrPass.GetViewport(viewId), null, xrPass.GetTextureArraySlice(viewId));
+                            XRView xrView = new XRView(projMatrix, viewMatrix, Matrix4x4.identity, false, xrPass.GetViewport(viewId), null, xrPass.GetTextureArraySlice(viewId));
                             xrPass.AssignView(viewId, xrView);
                         }
                     }

Packages/com.unity.render-pipelines.core/Runtime/XR/XRPass.cs

@@ -12,13 +12,16 @@ public struct XRPassCreateInfo
     {
         internal RenderTargetIdentifier renderTarget;
         internal RenderTextureDescriptor renderTargetDesc;
+        internal RenderTargetIdentifier motionVectorRenderTarget;
+        internal RenderTextureDescriptor motionVectorRenderTargetDesc;
         internal ScriptableCullingParameters cullingParameters;
         internal Material occlusionMeshMaterial;
         internal float occlusionMeshScale;
         internal IntPtr foveatedRenderingInfo;
         internal int multipassId;
         internal int cullingPassId;
         internal bool copyDepth;
+        internal bool hasMotionVectorPass;
 
 #if ENABLE_VR && ENABLE_XR_MODULE
         internal UnityEngine.XR.XRDisplaySubsystem.XRRenderPass xrSdkRenderPass;
@@ -95,6 +98,11 @@ public bool supportsFoveatedRendering
         /// </summary>
         public bool copyDepth { get; private set; }
 
+        /// <summary>
+        ///  If true, the render pipeline is expected to generate motion data and output to the motionVectorRenderTarget.
+        /// </summary>
+        public bool hasMotionVectorPass { get; private set; }
+
         /// <summary>
         /// If true, is the first pass of a xr camera
         /// </summary>
@@ -125,6 +133,16 @@ public bool supportsFoveatedRendering
         /// </summary>
         public RenderTextureDescriptor renderTargetDesc { get; private set; }
 
+        /// <summary>
+        ///  Destination render target for motion vectors
+        /// </summary>
+        public RenderTargetIdentifier motionVectorRenderTarget { get; private set; }
+
+        /// <summary>
+        /// Destination render target descriptor for motion vectors.
+        /// </summary>
+        public RenderTextureDescriptor motionVectorRenderTargetDesc { get; private set; }
+
         /// <summary>
         /// Parameters used for culling.
         /// </summary>
@@ -211,6 +229,26 @@ public Matrix4x4 GetViewMatrix(int viewIndex = 0)
             return m_Views[viewIndex].viewMatrix;
         }
 
+        /// <summary>
+        /// Returns true if the previous frame view matrix for a given view is valid.
+        /// </summary>
+        /// <param name="viewIndex"> Index of XRView to retrieve the data from. </param>
+        /// <returns> Boolean describing if previous frame view matrix for a given view is valid. </returns>
+        public bool GetPrevViewValid(int viewIndex = 0)
+        {
+            return m_Views[viewIndex].isPrevViewMatrixValid;
+        }
+
+        /// <summary>
+        /// Returns the previous frame view matrix for a given view.
+        /// </summary>
+        /// <param name="viewIndex"> Index of XRView to retrieve the data from. </param>
+        /// <returns> Previous frame XR view matrix for the specified XRView. </returns>
+        public Matrix4x4 GetPrevViewMatrix(int viewIndex = 0)
+        {
+            return m_Views[viewIndex].prevViewMatrix;
+        }
+
         /// <summary>
         /// Returns the viewport for a given view.
         /// </summary>
@@ -422,6 +460,9 @@ public void InitBase(XRPassCreateInfo createInfo)
             AssignCullingParams(createInfo.cullingPassId, createInfo.cullingParameters);
             renderTarget = new RenderTargetIdentifier(createInfo.renderTarget, 0, CubemapFace.Unknown, -1);
             renderTargetDesc = createInfo.renderTargetDesc;
+            motionVectorRenderTarget = new RenderTargetIdentifier(createInfo.motionVectorRenderTarget, 0, CubemapFace.Unknown, -1);
+            motionVectorRenderTargetDesc = createInfo.motionVectorRenderTargetDesc;
+            hasMotionVectorPass = createInfo.hasMotionVectorPass;
             m_OcclusionMesh.SetMaterial(createInfo.occlusionMeshMaterial);
             occlusionMeshScale = createInfo.occlusionMeshScale;
             foveatedRenderingInfo = createInfo.foveatedRenderingInfo;

Packages/com.unity.render-pipelines.core/Runtime/XR/XRSystem.cs

@@ -454,24 +454,30 @@ static XRView BuildView(XRDisplaySubsystem.XRRenderPass renderPass, XRDisplaySub
             // XRTODO : remove this line and use XRSettings.useOcclusionMesh instead when it's fixed
             Mesh occlusionMesh = XRGraphicsAutomatedTests.running ? null : renderParameter.occlusionMesh;
 
-            return new XRView(renderParameter.projection, renderParameter.view, viewport, occlusionMesh, renderParameter.textureArraySlice);
+            return new XRView(renderParameter.projection, renderParameter.view, renderParameter.previousView, renderParameter.isPreviousViewValid, viewport, occlusionMesh, renderParameter.textureArraySlice);
         }
 
-        static XRPassCreateInfo BuildPass(XRDisplaySubsystem.XRRenderPass xrRenderPass, ScriptableCullingParameters cullingParameters, XRLayout layout)
+        private static RenderTextureDescriptor XrRenderTextureDescToUnityRenderTextureDesc(RenderTextureDescriptor xrDesc)
         {
             // We can't use descriptor directly because y-flip is forced
             // XRTODO : fix root problem
-            RenderTextureDescriptor xrDesc = xrRenderPass.renderTargetDesc;
             RenderTextureDescriptor rtDesc = new RenderTextureDescriptor(xrDesc.width, xrDesc.height, xrDesc.colorFormat, xrDesc.depthBufferBits, xrDesc.mipCount);
-            rtDesc.dimension    = xrRenderPass.renderTargetDesc.dimension;
-            rtDesc.volumeDepth  = xrRenderPass.renderTargetDesc.volumeDepth;
-            rtDesc.vrUsage      = xrRenderPass.renderTargetDesc.vrUsage;
-            rtDesc.sRGB         = xrRenderPass.renderTargetDesc.sRGB;
-            
+            rtDesc.dimension    = xrDesc.dimension;
+            rtDesc.volumeDepth  = xrDesc.volumeDepth;
+            rtDesc.vrUsage      = xrDesc.vrUsage;
+            rtDesc.sRGB         = xrDesc.sRGB;
+            return rtDesc;
+        }
+
+        static XRPassCreateInfo BuildPass(XRDisplaySubsystem.XRRenderPass xrRenderPass, ScriptableCullingParameters cullingParameters, XRLayout layout)
+        {    
             XRPassCreateInfo passInfo = new XRPassCreateInfo
             {
                 renderTarget            = xrRenderPass.renderTarget,
-                renderTargetDesc        = rtDesc,
+                renderTargetDesc        = XrRenderTextureDescToUnityRenderTextureDesc(xrRenderPass.renderTargetDesc),
+                hasMotionVectorPass     = xrRenderPass.hasMotionVectorPass,
+                motionVectorRenderTarget = xrRenderPass.motionVectorRenderTarget,
+                motionVectorRenderTargetDesc = XrRenderTextureDescToUnityRenderTextureDesc(xrRenderPass.motionVectorRenderTargetDesc),
                 cullingParameters       = cullingParameters,
                 occlusionMeshMaterial   = s_OcclusionMeshMaterial,
                 occlusionMeshScale      = GetOcclusionMeshScale(),

Packages/com.unity.render-pipelines.core/Runtime/XR/XRView.cs

@@ -6,18 +6,22 @@ internal readonly struct XRView
     {
         internal readonly Matrix4x4 projMatrix;
         internal readonly Matrix4x4 viewMatrix;
+        internal readonly Matrix4x4 prevViewMatrix;
         internal readonly Rect viewport;
         internal readonly Mesh occlusionMesh;
         internal readonly int textureArraySlice;
         internal readonly Vector2 eyeCenterUV;
+        internal readonly bool isPrevViewMatrixValid;
 
-        internal XRView(Matrix4x4 projMatrix, Matrix4x4 viewMatrix, Rect viewport, Mesh occlusionMesh, int textureArraySlice)
+        internal XRView(Matrix4x4 projMatrix, Matrix4x4 viewMatrix, Matrix4x4 prevViewMatrix, bool isPrevViewMatrixValid, Rect viewport, Mesh occlusionMesh, int textureArraySlice)
         {
             this.projMatrix = projMatrix;
             this.viewMatrix = viewMatrix;
+            this.prevViewMatrix = prevViewMatrix;
             this.viewport = viewport;
             this.occlusionMesh = occlusionMesh;
             this.textureArraySlice = textureArraySlice;
+            this.isPrevViewMatrixValid = isPrevViewMatrixValid;
             eyeCenterUV = ComputeEyeCenterUV(projMatrix);
         }
 

Packages/com.unity.render-pipelines.universal/Editor/ShaderScriptableStripper.cs

@@ -114,12 +114,14 @@ public bool PassHasKeyword(LocalKeyword keyword)
         Shader m_ScreenSpaceLensFlareShader = Shader.Find("Hidden/Universal Render Pipeline/LensFlareScreenSpace");
         Shader m_XROcclusionMeshShader = Shader.Find("Hidden/Universal Render Pipeline/XR/XROcclusionMesh");
         Shader m_XRMirrorViewShader = Shader.Find("Hidden/Universal Render Pipeline/XR/XRMirrorView");
+        Shader m_XRMotionVectorShader = Shader.Find("Hidden/Universal Render Pipeline/XR/XRMotionVector");
 
         // Pass names
         public static readonly string kPassNameUniversal2D = "Universal2D";
         public static readonly string kPassNameGBuffer = "GBuffer";
         public static readonly string kPassNameForwardLit = "ForwardLit";
         public static readonly string kPassNameDepthNormals = "DepthNormals";
+        public static readonly string kPassNameXRMotionVectors = "XRMotionVectors";
 
         // Keywords
         LocalKeyword m_MainLightShadows;
@@ -719,6 +721,15 @@ internal bool StripUnusedFeatures_XROcclusionMesh(ref IShaderScriptableStripping
             return strippingData.stripUnusedXRVariants;
         }
 
+        internal bool StripUnusedFeatures_XRMotionVector(ref IShaderScriptableStrippingData strippingData)
+        {
+            if (strippingData.shader != m_XRMotionVectorShader)
+                return false;
+
+            return strippingData.stripUnusedXRVariants;
+        }
+        
+
         internal bool StripUnusedFeatures(ref IShaderScriptableStrippingData strippingData)
         {
             if (StripUnusedFeatures_DebugDisplay(ref strippingData))
@@ -817,6 +828,9 @@ internal bool StripUnusedFeatures(ref IShaderScriptableStrippingData strippingDa
             if (StripUnusedFeatures_XROcclusionMesh(ref strippingData))
                 return true;
 
+            if (StripUnusedFeatures_XRMotionVector(ref strippingData))
+                return true;
+
             return false;
         }
 
@@ -991,6 +1005,14 @@ internal bool StripUnusedPass_Decals(ref IShaderScriptableStrippingData strippin
             return false;
         }
 
+        internal bool StripUnusedPass_XRMotionVectors(ref IShaderScriptableStrippingData strippingData)
+        {
+            // Strip XR MotionVector Passes if there is no XR
+            if (strippingData.passName == kPassNameXRMotionVectors && strippingData.stripUnusedXRVariants)
+                return true;
+            return false;
+        }        
+
         internal bool StripUnusedPass(ref IShaderScriptableStrippingData strippingData)
         {
             if (StripUnusedPass_2D(ref strippingData))
@@ -1005,6 +1027,9 @@ internal bool StripUnusedPass(ref IShaderScriptableStrippingData strippingData)
             if (StripUnusedPass_Decals(ref strippingData))
                 return true;
 
+            if (StripUnusedPass_XRMotionVectors(ref strippingData))
+                return true;
+
             return false;
         }