Plug-in stereo matrices plus bind new stereo matrices

Won't really take effect until stereo SRP APIs are activated

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

         public Vector4 viewParam;
         public PostProcessRenderContext postprocessRenderContext;
 
+        public Matrix4x4[] viewMatrixStereo;
+        public Matrix4x4[] projMatrixStereo;
+
         // Non oblique projection matrix (RHS)
         public Matrix4x4 nonObliqueProjMatrix
         {
         public Matrix4x4 nonJitteredViewProjMatrix
         {
             get { return nonJitteredProjMatrix * viewMatrix; }
+        }
+
+        public Matrix4x4 GetViewProjMatrixStereo(uint eyeIndex)
+        {
+            return (projMatrixStereo[eyeIndex] * viewMatrixStereo[eyeIndex]);
         }
 
         // Always true for cameras that just got added to the pool - needed for previous matrices to
             camera = cam;
             frustumPlanes = new Plane[6];
             frustumPlaneEquations = new Vector4[6];
+
+            viewMatrixStereo = new Matrix4x4[2];
+            projMatrixStereo = new Matrix4x4[2];
+
             postprocessRenderContext = new PostProcessRenderContext();
             m_AdditionalCameraData = cam.GetComponent<HDAdditionalCameraData>();
             Reset();
                 var xrDesc = XRSettings.eyeTextureDesc;
                 m_ActualWidth = xrDesc.width;
                 m_ActualHeight = xrDesc.height;
+
+                ConfigureStereoMatrices();
             }
 
             // Unfortunately sometime (like in the HDCameraEditor) HDUtils.hdrpSettings can be null because of scripts that change the current pipeline...
             screenSize = new Vector4(screenWidth, screenHeight, 1.0f / screenWidth, 1.0f / screenHeight);
         }
 
+        void ConfigureStereoMatrices()
+        {
+            // will the matrices work?
+            for (uint eyeIndex = 0; eyeIndex < 2; eyeIndex++)
+            {
+                viewMatrixStereo[eyeIndex] = camera.GetStereoViewMatrix((Camera.StereoscopicEye)eyeIndex);
+
+                projMatrixStereo[eyeIndex] = camera.GetStereoProjectionMatrix((Camera.StereoscopicEye)eyeIndex);
+                projMatrixStereo[eyeIndex] = GL.GetGPUProjectionMatrix(projMatrixStereo[eyeIndex], true);
+            }
+
+            // TODO: Fetch the single cull matrix stuff
+        }
+
         // Warning: different views can use the same camera!
         public long GetViewID()
         {
             cmd.SetGlobalVectorArray(HDShaderIDs._FrustumPlanes, frustumPlaneEquations);
             cmd.SetGlobalInt(HDShaderIDs._TaaFrameIndex, (int)taaFrameIndex);
             cmd.SetGlobalVector(HDShaderIDs._TaaFrameRotation, taaFrameRotation);
+        }
+
+        public void SetupGlobalStereoParams(CommandBuffer cmd)
+        {
+            var invProjStereo = new Matrix4x4[2];
+            var invViewProjStereo = new Matrix4x4[2];
+
+            for (uint ei = 0; ei < 2; ei++)
+            {
+                var proj = projMatrixStereo[ei];
+                invProjStereo[ei] = proj.inverse;
+
+                var view = viewMatrixStereo[ei];
+                var vp = proj * view;
+                invViewProjStereo[ei] = vp.inverse;
+            }
+
+            cmd.SetGlobalMatrixArray(HDShaderIDs._InvProjMatrixStereo, invProjStereo);
+            cmd.SetGlobalMatrixArray(HDShaderIDs._InvViewProjMatrixStereo, invViewProjStereo);
         }
 
         // TODO: We should set all the value below globally and not let it under the control of Unity,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

             using (new ProfilingSample(cmd, "Push Global Parameters", CustomSamplerId.PushGlobalParameters.GetSampler()))
             {
                 hdCamera.SetupGlobalParams(cmd);
+                if (m_FrameSettings.enableStereo)
+                    hdCamera.SetupGlobalStereoParams(cmd);
 
                 m_SSSBufferManager.PushGlobalParams(cmd, sssParameters, m_FrameSettings);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _TaaFrameIndex    = Shader.PropertyToID("_TaaFrameIndex");
         public static readonly int _TaaFrameRotation = Shader.PropertyToID("_TaaFrameRotation");
 
+        public static readonly int _InvProjMatrixStereo = Shader.PropertyToID("_InvProjMatrixStereo");
+        public static readonly int _InvViewProjMatrixStereo = Shader.PropertyToID("_InvViewProjMatrixStereo");
+
         public static readonly int _DepthTexture                   = Shader.PropertyToID("_DepthTexture");
         public static readonly int _CameraColorTexture             = Shader.PropertyToID("_CameraColorTexture");
         public static readonly int _CameraSssDiffuseLightingBuffer = Shader.PropertyToID("_CameraSssDiffuseLightingTexture");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariables.hlsl

 float4   _FrustumPlanes[6]; // {(a, b, c) = N, d = -dot(N, P)} [L, R, T, B, N, F]
 CBUFFER_END
 
+// Custom generated by HDRP, not from Unity Engine (passed in via HDCamera)
+#if defined(USING_STEREO_MATRICES)
+
+CBUFFER_START(UnityPerPassStereo)
+float4x4 _InvProjMatrixStereo[2];
+float4x4 _InvViewProjMatrixStereo[2];
+CBUFFER_END
+
+#endif // USING_STEREO_MATRICES
+
 float4x4 OptimizeProjectionMatrix(float4x4 M)
 {
     // Matrix format (x = non-constant value).

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariablesMatrixDefsHDCamera.hlsl

 #ifndef UNITY_SHADER_VARIABLES_MATRIX_DEFS_HDCAMERA_INCLUDED
 #define UNITY_SHADER_VARIABLES_MATRIX_DEFS_HDCAMERA_INCLUDED
 
+#if defined(USING_STEREO_MATRICES)
+
+#define UNITY_MATRIX_M     unity_ObjectToWorld
+#define UNITY_MATRIX_I_M   unity_WorldToObject
+#define UNITY_MATRIX_V     unity_StereoMatrixV[unity_StereoEyeIndex]
+#define UNITY_MATRIX_I_V   unity_StereoMatrixInvV[unity_StereoEyeIndex]
+#define UNITY_MATRIX_P     OptimizeProjectionMatrix(unity_StereoMatrixP[unity_StereoEyeIndex])
+// TEMP, use _InvProjMatrixStereo once bound
+#define UNITY_MATRIX_I_P   unity_StereoCameraInvProjection[unity_StereoEyeIndex]
+#define UNITY_MATRIX_VP    unity_StereoMatrixVP[unity_StereoEyeIndex]
+// TEMP - MUST FIX, use _InvViewProjMatrixStereo once bound
+#define UNITY_MATRIX_I_VP  mul(UNITY_MATRIX_I_V, UNITY_MATRIX_I_P)
+#define UNITY_MATRIX_MV    mul(UNITY_MATRIX_V, UNITY_MATRIX_M)
+#define UNITY_MATRIX_T_MV  transpose(UNITY_MATRIX_MV)
+#define UNITY_MATRIX_IT_MV transpose(mul(UNITY_MATRIX_I_M, UNITY_MATRIX_I_V))
+#define UNITY_MATRIX_MVP   mul(UNITY_MATRIX_VP, UNITY_MATRIX_M)
+
+#else
+
 #define UNITY_MATRIX_M     unity_ObjectToWorld
 #define UNITY_MATRIX_I_M   unity_WorldToObject
 #define UNITY_MATRIX_V     _ViewMatrix
 #define UNITY_MATRIX_T_MV  transpose(UNITY_MATRIX_MV)
 #define UNITY_MATRIX_IT_MV transpose(mul(UNITY_MATRIX_I_M, UNITY_MATRIX_I_V))
 #define UNITY_MATRIX_MVP   mul(UNITY_MATRIX_VP, UNITY_MATRIX_M)
+
+#endif // USING_STEREO_MATRICES
 
 #endif // UNITY_SHADER_VARIABLES_MATRIX_DEFS_HDCAMERA_INCLUDED