Fixed motion vectors and camera relative rendering

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

         // View-projection matrix from the previous frame.
         public Matrix4x4 prevViewProjMatrix;
 
+        // We need to keep track of these when camera relative rendering is enabled so we can take
+        // camera translation into account when generating camera motion vectors
+        public Vector3 cameraPos;
+        public Vector3 prevCameraPos;
+
         // The only way to reliably keep track of a frame change right now is to compare the frame
         // count Unity gives us. We need this as a single camera could be rendered several times per
         // frame and some matrices only have to be computed once. Realistically this shouldn't
             Matrix4x4 gpuView = camera.worldToCameraMatrix;
             Matrix4x4 gpuNonJitteredProj = GL.GetGPUProjectionMatrix(nonJitteredCameraProj, true);
 
+            Vector3 pos = camera.transform.position;
+
             if (ShaderConfig.s_CameraRelativeRendering != 0)
             {
                 // Zero out the translation component.
             Matrix4x4 gpuVP = gpuNonJitteredProj * gpuView;
 
-            // A camera could be rendered multiple time per frame, only updates the previous viewproj if needed
+            // A camera could be rendered multiple times per frame, only updates the previous view proj & pos if needed
-                prevViewProjMatrix = !m_FirstFrame
-                    ? nonJitteredViewProjMatrix
-                    : gpuVP;
+                if (m_FirstFrame)
+                {
+                    prevCameraPos = pos;
+                    prevViewProjMatrix = gpuVP;
+                }
+                else
+                {
+                    prevCameraPos = cameraPos;
+                    prevViewProjMatrix = nonJitteredViewProjMatrix;
+                }
 
                 m_FirstFrame = false;
             }
             nonJitteredProjMatrix = gpuNonJitteredProj;
+            cameraPos = pos;
             screenSize = new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
 
             Plane[] planes = GeometryUtility.CalculateFrustumPlanes(viewProjMatrix);
 
                 int w = (int)hdcam.screenSize.x;
                 int h = (int)hdcam.screenSize.y;
+
+                m_CameraMotionVectorsMaterial.SetVector("_CameraPosDiff", hdcam.prevCameraPos - hdcam.cameraPos);
 
                 cmd.GetTemporaryRT(m_VelocityBuffer, w, h, 0, FilterMode.Point, Builtin.GetVelocityBufferFormat(), Builtin.GetVelocityBufferReadWrite());
                 Utilities.DrawFullScreen(cmd, m_CameraMotionVectorsMaterial, m_VelocityBufferRT, null, 0);

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/CameraMotionVectors.shader

 
         #include "../../ShaderLibrary/Common.hlsl"
         #include "../ShaderVariables.hlsl"
+        #include "../ShaderConfig.cs.hlsl"
+
+        float4 _CameraPosDiff;
 
         struct Attributes
         {
             float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
             UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
             float4 worldPos = float4(posInput.positionWS, 1.0);
+            float4 prevPos = worldPos;
-            float4 prevClipPos = mul(_PrevViewProjMatrix, worldPos);
+        #if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
+            prevPos -= _CameraPosDiff;
+        #endif
+
+            float4 prevClipPos = mul(_PrevViewProjMatrix, prevPos);
             float4 curClipPos = mul(_NonJitteredViewProjMatrix, worldPos);
             float2 prevHPos = prevClipPos.xy / prevClipPos.w;
             float2 curHPos = curClipPos.xy / curClipPos.w;
+
+        #if UNITY_UV_STARTS_AT_TOP
+            previousPositionCS.y = 1.0 - previousPositionCS.y;
+            positionCS.y = 1.0 - positionCS.y;
+        #endif
 
             return float4(positionCS - previousPositionCS, 0.0, 1.0);
         }