[SpaceWarp] URP Commit to support Unity 2021.2

Full Commit with all of our Oculus App SpaceWarp URP changes, which were previously only on the 2020.3/oculus-app-spacewarp branch, but now on this branch which is on top of Unity's 2021.2/staging branch.

Author: neelbedekar

com.unity.render-pipelines.core/ShaderLibrary/SpaceTransforms.hlsl

@@ -39,6 +39,11 @@ float4x4 GetWorldToHClipMatrix()
     return UNITY_MATRIX_VP;
 }
 
+float4x4 GetPrevWorldToHClipMatrix()
+{
+    return UNITY_MATRIX_PREV_VP;
+}
+
 // Transform to homogenous clip space
 float4x4 GetViewToHClipMatrix()
 {
@@ -80,6 +85,13 @@ float3 TransformObjectToWorld(float3 positionOS)
     #endif
 }
 
+float3 TransformPreviousObjectToWorld(float3 positionOS)
+{
+#if !defined(SHADER_STAGE_RAY_TRACING)
+    return mul(GetPrevObjectToWorldMatrix(), float4(positionOS, 1.0)).xyz;
+#endif
+}
+
 float3 TransformWorldToObject(float3 positionWS)
 {
     #if defined(SHADER_STAGE_RAY_TRACING)
@@ -107,6 +119,11 @@ float4 TransformWorldToHClip(float3 positionWS)
     return mul(GetWorldToHClipMatrix(), float4(positionWS, 1.0));
 }
 
+float4 TransformWorldToPrevHClip(float3 positionWS)
+{
+    return mul(GetPrevWorldToHClipMatrix(), float4(positionWS, 1.0));
+}
+
 // Tranforms position from view space to homogenous space
 float4 TransformWViewToHClip(float3 positionVS)
 {

com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/OculusMotionVectors.hlsl

@@ -0,0 +1,25 @@
+#ifndef SG_MOTION_VECTORS_INCLUDED
+#define SG_MOTION_VECTORS_INCLUDED
+
+PackedVaryings vert(Attributes input)
+{
+    Varyings output = (Varyings)0;
+    output = BuildVaryings(input);
+    PackedVaryings packedOutput = (PackedVaryings)0;
+    packedOutput = PackVaryings(output);
+    return packedOutput;
+}
+
+half4 frag(PackedVaryings packedInput) : SV_TARGET
+{
+    Varyings unpacked = UnpackVaryings(packedInput);
+    UNITY_SETUP_INSTANCE_ID(unpacked);
+
+    float3 screenPos = unpacked.curPositionCS.xyz / unpacked.curPositionCS.w;
+    float3 screenPosPrev = unpacked.prevPositionCS.xyz / unpacked.prevPositionCS.w;
+    half4 color = (1);
+    color.xyz = screenPos - screenPosPrev;
+
+    return color;
+}
+#endif

com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/OculusMotionVectors.hlsl.meta

@@ -23,4 +23,5 @@
 #define SHADERPASS_DECAL_GBUFFER_PROJECTOR (19)
 #define SHADERPASS_DECAL_GBUFFER_MESH (20)
 #define SHADERPASS_DEPTHNORMALS (21)
+#define SHADERPASS_MOTIONVECTORS (22)
 #endif

com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl

@@ -10,6 +10,15 @@
     float3 _LightPosition;
 #endif
 
+#ifdef VARYINGS_NEED_PREVIOUS_POSITION_CS
+    bool IsSmoothRotation(float3 prevAxis1, float3 prevAxis2, float3 currAxis1, float3 currAxis2)
+    {
+        float angleThreshold = 0.984f; // cos(10 degrees)
+        float2 angleDot = float2(dot(normalize(prevAxis1), normalize(currAxis1)), dot(normalize(prevAxis2), normalize(currAxis2)));
+        return all(angleDot > angleThreshold);
+    }
+#endif
+
 #if defined(FEATURES_GRAPH_VERTEX)
 #if defined(HAVE_VFX_MODIFICATION)
 VertexDescription BuildVertexDescription(Attributes input, AttributesElement element)
@@ -189,6 +198,35 @@ Varyings BuildVaryings(Attributes input)
     output.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
 #endif
 
+#ifdef VARYINGS_NEED_CURRENT_POSITION_CS
+    float3 curWS = TransformObjectToWorld(input.positionOS.xyz);
+    output.curPositionCS = TransformWorldToHClip(curWS);
+#endif
+
+#ifdef VARYINGS_NEED_PREVIOUS_POSITION_CS
+    if (unity_MotionVectorsParams.y == 0.0)
+    {
+        output.prevPositionCS = float4(0.0, 0.0, 0.0, 1.0);
+    }
+    else
+    {
+        bool hasDeformation = unity_MotionVectorsParams.x > 0.0;
+        float3 effectivePositionOS = (hasDeformation ? input.uv4.xyz : input.positionOS.xyz);
+        float3 previousWS = TransformPreviousObjectToWorld(effectivePositionOS);
+
+        float4x4 previousOTW = GetPrevObjectToWorldMatrix();
+        float4x4 currentOTW = GetObjectToWorldMatrix();
+        if (!IsSmoothRotation(previousOTW._11_21_31, previousOTW._12_22_32, currentOTW._11_21_31, currentOTW._12_22_32))
+        {
+            output.prevPositionCS = output.curPositionCS;
+        }
+        else
+        {
+            output.prevPositionCS = TransformWorldToPrevHClip(previousWS);
+        }
+    }
+#endif
+
 #if defined(VARYINGS_NEED_SHADOW_COORD) && defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
     output.shadowCoord = GetShadowCoord(vertexInput);
 #endif

com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Varyings.hlsl

@@ -315,6 +315,7 @@ public static SubShaderDescriptor LitComputeDotsSubShader(UniversalTarget target
                 result.passes.Add(PassVariant(CorePasses.ScenePicking(target), CorePragmas.DOTSDefault));
 
                 result.passes.Add(PassVariant(LitPasses._2D(target), CorePragmas.DOTSDefault));
+                result.passes.Add(CorePasses.MotionVectors(target));
 
                 return result;
             }

com.unity.render-pipelines.universal/Editor/ShaderGraph/Targets/UniversalLitSubTarget.cs

@@ -877,6 +877,38 @@ public static PassDescriptor ShadowCaster(UniversalTarget target)
             return result;
         }
 
+        public static PassDescriptor MotionVectors(UniversalTarget target)
+        {
+            var result = new PassDescriptor()
+            {
+                // Definition
+                displayName = "MotionVectors",
+                referenceName = "SHADERPASS_MOTIONVECTORS",
+                lightMode = "MotionVectors",
+
+                // Template
+                passTemplatePath = GenerationUtils.GetDefaultTemplatePath("PassMesh.template"),
+                sharedTemplateDirectories = GenerationUtils.GetDefaultSharedTemplateDirectories(),
+
+                // Port Mask
+                validVertexBlocks = CoreBlockMasks.Vertex,
+
+                // Fields
+                structs = CoreStructCollections.Default,
+                requiredFields = CoreRequiredFields.MotionVectors,
+                fieldDependencies = CoreFieldDependencies.Default,
+
+                // Conditional State
+                renderStates = CoreRenderStates.Default,
+                pragmas = CorePragmas.DOTSInstanced,
+                includes = CoreIncludes.MotionVectors,
+            };
+
+            AddAlphaClipControlToPass(ref result, target);
+
+            return result;
+        }
+
         public static PassDescriptor SceneSelection(UniversalTarget target)
         {
             var result = new PassDescriptor()
@@ -1092,6 +1124,13 @@ static class CoreRequiredFields
             StructFields.Varyings.normalWS,
             StructFields.Varyings.tangentWS,                        // needed for vertex lighting
         };
+
+        public static readonly FieldCollection MotionVectors = new FieldCollection()
+        {
+            StructFields.Attributes.uv4,                   // needed for previousPositionOS
+            UniversalStructFields.Varyings.curPositionCS,
+            UniversalStructFields.Varyings.prevPositionCS,
+        };
     }
     #endregion
 
@@ -1383,6 +1422,7 @@ static class CoreIncludes
         const string kTextureStack = "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl";
         const string kDBuffer = "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DBuffer.hlsl";
         const string kSelectionPickingPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/SelectionPickingPass.hlsl";
+        const string kMotionVectors = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/OculusMotionVectors.hlsl";
 
         public static readonly IncludeCollection CorePregraph = new IncludeCollection
         {
@@ -1463,6 +1503,17 @@ static class CoreIncludes
             { CorePostgraph },
             { kSelectionPickingPass, IncludeLocation.Postgraph },
         };
+
+        public static readonly IncludeCollection MotionVectors = new IncludeCollection
+        {
+            // Pre-graph
+            { CoreIncludes.CorePregraph },
+            { CoreIncludes.ShaderGraphPregraph },
+
+            // Post-graph
+            { CoreIncludes.CorePostgraph },
+            { kMotionVectors, IncludeLocation.Postgraph },
+        };
     }
     #endregion
 

com.unity.render-pipelines.universal/Editor/ShaderGraph/Targets/UniversalTarget.cs

@@ -161,6 +161,7 @@ public static SubShaderDescriptor Unlit(UniversalTarget target, string renderTyp
                 result.passes.Add(CorePasses.ScenePicking(target));
 
                 result.passes.Add(UnlitPasses.DepthNormalOnly(target));
+                result.passes.Add(CorePasses.MotionVectors(target));
 
                 return result;
             }

com.unity.render-pipelines.universal/Editor/ShaderGraph/Targets/UniversalUnlitSubTarget.cs

@@ -21,6 +21,10 @@ public struct Varyings
                 "SV_RenderTargetArrayIndex", "(defined(UNITY_STEREO_INSTANCING_ENABLED))", StructFieldOptions.Generated);
             public static FieldDescriptor stereoTargetEyeIndexAsBlendIdx0 = new FieldDescriptor(Varyings.name, "stereoTargetEyeIndexAsBlendIdx0", "", ShaderValueType.Uint,
                 "BLENDINDICES0", "(defined(UNITY_STEREO_MULTIVIEW_ENABLED)) || (defined(UNITY_STEREO_INSTANCING_ENABLED) && (defined(SHADER_API_GLES3) || defined(SHADER_API_GLCORE)))");
+            public static FieldDescriptor curPositionCS = new FieldDescriptor(Varyings.name, "curPositionCS", "VARYINGS_NEED_CURRENT_POSITION_CS", ShaderValueType.Float4,
+                subscriptOptions: StructFieldOptions.Optional);
+            public static FieldDescriptor prevPositionCS = new FieldDescriptor(Varyings.name, "prevPositionCS", "VARYINGS_NEED_PREVIOUS_POSITION_CS", ShaderValueType.Float4,
+                subscriptOptions: StructFieldOptions.Optional);
         }
     }
 }

com.unity.render-pipelines.universal/Editor/ShaderGraph/UniversalStructFields.cs

@@ -27,6 +27,8 @@ static class UniversalStructs
                 UniversalStructFields.Varyings.sh,
                 UniversalStructFields.Varyings.fogFactorAndVertexLight,
                 UniversalStructFields.Varyings.shadowCoord,
+                UniversalStructFields.Varyings.curPositionCS,
+                UniversalStructFields.Varyings.prevPositionCS,
                 StructFields.Varyings.instanceID,
                 UniversalStructFields.Varyings.stereoTargetEyeIndexAsBlendIdx0,
                 UniversalStructFields.Varyings.stereoTargetEyeIndexAsRTArrayIdx,

com.unity.render-pipelines.universal/Editor/ShaderGraph/UniversalStructs.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Profiling;
+
+namespace UnityEngine.Rendering.Universal.Internal
+{
+    /// <summary>
+    /// Draw  motion vectors into the given color and depth target. Both come from the Oculus runtime.
+    ///
+    /// This will render objects that have a material and/or shader with the pass name "MotionVectors".
+    /// </summary>
+    public class OculusMotionVectorPass : ScriptableRenderPass
+    {
+        FilteringSettings m_FilteringSettings;
+        ProfilingSampler m_ProfilingSampler;
+
+        RenderTargetIdentifier motionVectorColorIdentifier;
+        RenderTargetIdentifier motionVectorDepthIdentifier;
+
+        public OculusMotionVectorPass(string profilerTag, bool opaque, RenderPassEvent evt, RenderQueueRange renderQueueRange, LayerMask layerMask, StencilState stencilState, int stencilReference)
+        {
+            base.profilingSampler = new ProfilingSampler(nameof(OculusMotionVectorPass));
+            m_ProfilingSampler = new ProfilingSampler(profilerTag);
+            renderPassEvent = evt;
+            m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
+        }
+
+        internal OculusMotionVectorPass(URPProfileId profileId, bool opaque, RenderPassEvent evt, RenderQueueRange renderQueueRange, LayerMask layerMask, StencilState stencilState, int stencilReference)
+            : this(profileId.GetType().Name, opaque, evt, renderQueueRange, layerMask, stencilState, stencilReference)
+        {
+            m_ProfilingSampler = ProfilingSampler.Get(profileId);
+        }
+
+        public void Setup(
+            RenderTargetIdentifier motionVecColorIdentifier,
+            RenderTargetIdentifier motionVecDepthIdentifier)
+        {
+            this.motionVectorColorIdentifier = motionVecColorIdentifier;
+            this.motionVectorDepthIdentifier = motionVecDepthIdentifier;
+        }
+
+        public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
+        {
+            ConfigureTarget(motionVectorColorIdentifier, motionVectorDepthIdentifier);
+            ConfigureClear(ClearFlag.All, Color.black);
+        }
+
+        /// <inheritdoc/>
+        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
+        {
+            // NOTE: Do NOT mix ProfilingScope with named CommandBuffers i.e. CommandBufferPool.Get("name").
+            // Currently there's an issue which results in mismatched markers.
+            CommandBuffer cmd = CommandBufferPool.Get();
+            using (new ProfilingScope(cmd, m_ProfilingSampler))
+            {
+                context.ExecuteCommandBuffer(cmd);
+                cmd.Clear();
+
+                Camera camera = renderingData.cameraData.camera;
+                var filterSettings = m_FilteringSettings;
+
+                var drawSettings = CreateDrawingSettings(new ShaderTagId("MotionVectors"), ref renderingData, renderingData.cameraData.defaultOpaqueSortFlags);
+                drawSettings.perObjectData = PerObjectData.MotionVectors;
+                context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filterSettings);
+            }
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
+        }
+    }
+}

com.unity.render-pipelines.universal/Runtime/Passes/OculusMotionVectorPass.cs

@@ -145,6 +145,7 @@ public static void SetViewAndProjectionMatrices(CommandBuffer cmd, Matrix4x4 vie
         internal static readonly int UNITY_STEREO_MATRIX_P = Shader.PropertyToID("unity_StereoMatrixP");
         internal static readonly int UNITY_STEREO_MATRIX_IP = Shader.PropertyToID("unity_StereoMatrixInvP");
         internal static readonly int UNITY_STEREO_MATRIX_VP = Shader.PropertyToID("unity_StereoMatrixVP");
+        internal static readonly int UNITY_STEREO_MATRIX_PREV_VP = Shader.PropertyToID("unity_StereoMatrixPrevVP");
         internal static readonly int UNITY_STEREO_MATRIX_IVP = Shader.PropertyToID("unity_StereoMatrixInvVP");
         internal static readonly int UNITY_STEREO_CAMERA_PROJECTION = Shader.PropertyToID("unity_StereoCameraProjection");
         internal static readonly int UNITY_STEREO_CAMERA_INV_PROJECTION = Shader.PropertyToID("unity_StereoCameraInvProjection");
@@ -154,6 +155,8 @@ public static void SetViewAndProjectionMatrices(CommandBuffer cmd, Matrix4x4 vie
         internal class StereoConstants
         {
             public Matrix4x4[] viewProjMatrix = new Matrix4x4[2];
+            public Matrix4x4[] mvViewProjMatrix = new Matrix4x4[2];
+            public Matrix4x4[] prevMVViewProjMatrix = new Matrix4x4[2];
             public Matrix4x4[] invViewMatrix = new Matrix4x4[2];
             public Matrix4x4[] invProjMatrix = new Matrix4x4[2];
             public Matrix4x4[] invViewProjMatrix = new Matrix4x4[2];
@@ -174,11 +177,18 @@ internal class StereoConstants
         /// <param name="cameraProjectionMatrix">Camera projection matrix to be set.Array size is 2. Does not include platform specific transformations such as depth-reverse, depth range in post-projective space and y-flip. </param>
         /// <param name="setInverseMatrices">Set this to true if you also need to set inverse camera matrices.</param>
         /// <returns>Void</c></returns>
-        internal static void SetStereoViewAndProjectionMatrices(CommandBuffer cmd, Matrix4x4[] viewMatrix, Matrix4x4[] projMatrix, Matrix4x4[] cameraProjMatrix, bool setInverseMatrices)
+        internal static void SetStereoViewAndProjectionMatrices(CommandBuffer cmd, Matrix4x4[] viewMatrix, Matrix4x4[] projMatrix, Matrix4x4[] cameraProjMatrix, bool setInverseMatrices, bool prevViewValid, Matrix4x4[] prevViewMatrix, bool isOculusMotionVec = false)
         {
+            if (isOculusMotionVec)
+                stereoConstants.mvViewProjMatrix.CopyTo(stereoConstants.prevMVViewProjMatrix, 0);
+
             for (int i = 0; i < 2; i++)
             {
                 stereoConstants.viewProjMatrix[i] = projMatrix[i] * viewMatrix[i];
+                if (prevViewValid)
+                    stereoConstants.prevMVViewProjMatrix[i] = projMatrix[i] * prevViewMatrix[i];
+                if (isOculusMotionVec)
+                    stereoConstants.mvViewProjMatrix[i] = projMatrix[i] * viewMatrix[i];
                 stereoConstants.invViewMatrix[i] = Matrix4x4.Inverse(viewMatrix[i]);
                 stereoConstants.invProjMatrix[i] = Matrix4x4.Inverse(projMatrix[i]);
                 stereoConstants.invViewProjMatrix[i] = Matrix4x4.Inverse(stereoConstants.viewProjMatrix[i]);
@@ -189,6 +199,8 @@ internal static void SetStereoViewAndProjectionMatrices(CommandBuffer cmd, Matri
             cmd.SetGlobalMatrixArray(UNITY_STEREO_MATRIX_V, viewMatrix);
             cmd.SetGlobalMatrixArray(UNITY_STEREO_MATRIX_P, projMatrix);
             cmd.SetGlobalMatrixArray(UNITY_STEREO_MATRIX_VP, stereoConstants.viewProjMatrix);
+            if (isOculusMotionVec)
+                cmd.SetGlobalMatrixArray(UNITY_STEREO_MATRIX_PREV_VP, stereoConstants.prevMVViewProjMatrix);
 
             cmd.SetGlobalMatrixArray(UNITY_STEREO_CAMERA_PROJECTION, cameraProjMatrix);
 

com.unity.render-pipelines.universal/Runtime/Passes/OculusMotionVectorPass.cs.meta

@@ -1204,10 +1204,12 @@ void SetRenderPassAttachments(CommandBuffer cmd, ScriptableRenderPass renderPass
 #if ENABLE_VR && ENABLE_XR_MODULE
                         if (cameraData.xr.enabled)
                         {
+                            bool isOculusMotionVec = renderPass is Internal.OculusMotionVectorPass;
                             // SetRenderTarget might alter the internal device state(winding order).
                             // Non-stereo buffer is already updated internally when switching render target. We update stereo buffers here to keep the consistency.
-                            bool isRenderToBackBufferTarget = (passColorAttachment == cameraData.xr.renderTarget) && !cameraData.xr.renderTargetIsRenderTexture;
-                            cameraData.xr.UpdateGPUViewAndProjectionMatrices(cmd, ref cameraData, !isRenderToBackBufferTarget);
+                            bool isRenderToBackBufferTarget = ((passColorAttachment == cameraData.xr.renderTarget) && !cameraData.xr.renderTargetIsRenderTexture) ||
+                                ((passColorAttachment == cameraData.xr.motionVectorRenderTarget) && !cameraData.xr.motionVectorRenderTargetIsRenderTexture);
+                            cameraData.xr.UpdateGPUViewAndProjectionMatrices(cmd, ref cameraData, !isRenderToBackBufferTarget, isOculusMotionVec);
                         }
 #endif
                     }

com.unity.render-pipelines.universal/Runtime/RenderingUtils.cs

@@ -880,6 +880,7 @@ internal enum URPProfileId
         // DrawObjectsPass
         DrawOpaqueObjects,
         DrawTransparentObjects,
+        DrawMVOpaqueObjects,
 
         // RenderObjectsPass
         //RenderObjects,