Merge pull request #930 from Unity-Technologies/hdrp-xr-initial

Initial stereo rendering support in HDRP

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()
+        {
+            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 eyeIndex = 0; eyeIndex < 2; eyeIndex++)
+            {
+                var proj = projMatrixStereo[eyeIndex];
+                invProjStereo[eyeIndex] = proj.inverse;
+
+                var vp = proj * viewMatrixStereo[eyeIndex];
+                invViewProjStereo[eyeIndex] = vp.inverse;
+            }
+
+            // corresponds to UnityPerPassStereo
+            // TODO: Migrate the other stereo matrices to HDRP-managed UnityPerPassStereo?
+            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);
 
 
                     // TODO: Float HDCamera setup higher in order to pass stereo into GetCullingParameters
                     ScriptableCullingParameters cullingParams;
-                    if (!CullResults.GetCullingParameters(camera, out cullingParams))
+                    if (!CullResults.GetCullingParameters(camera, m_FrameSettings.enableStereo, out cullingParams))
                     {
                         renderContext.Submit();
                         continue;
                         DecalSystem.instance.EndCull();
                     }
 
-                    renderContext.SetupCameraProperties(camera);
+                    renderContext.SetupCameraProperties(camera, m_FrameSettings.enableStereo);
 
                     PushGlobalParams(hdCamera, cmd, diffusionProfileSettings);
 
                     }
                     ConfigureForShadowMask(enableBakeShadowMask, cmd);
 
+                    StartStereoRendering(renderContext, hdCamera.camera);
+                        
+                    // TODO: Add stereo occlusion mask
+
                     bool forcePrepassForDecals = m_DbufferManager.vsibleDecalCount > 0;
                     RenderDepthPrepass(m_CullResults, hdCamera, renderContext, cmd, forcePrepassForDecals);
 
 
                     RenderPyramidDepth(hdCamera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
 
+                    StopStereoRendering(renderContext, hdCamera.camera);
 
                     if (m_CurrentDebugDisplaySettings.IsDebugMaterialDisplayEnabled())
                     {
                     }
                     else
                     {
+                        StartStereoRendering(renderContext, hdCamera.camera);
+
                         using (new ProfilingSample(cmd, "Render SSAO", CustomSamplerId.RenderSSAO.GetSampler()))
                         {
                             // TODO: Everything here (SSAO, Shadow, Build light list, deferred shadow, material and light classification can be parallelize with Async compute)
                                 HDUtils.DrawFullScreen(cmd, hdCamera, m_CopyStencilForNoLighting, m_CameraStencilBufferCopy, m_CameraDepthStencilBuffer, null, 1);
                             }
                         }
+
+                        StopStereoRendering(renderContext, hdCamera.camera);
 
                         GPUFence buildGPULightListsCompleteFence = new GPUFence();
                         if (m_FrameSettings.enableAsyncCompute)
                         {
                             m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);
                             // TODO: check if statement below still apply
-                            renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after RenderShadows as it modify our view/proj matrix
+                            renderContext.SetupCameraProperties(camera, m_FrameSettings.enableStereo); // Need to recall SetupCameraProperties after RenderShadows as it modify our view/proj matrix
                         }
 
                         using (new ProfilingSample(cmd, "Deferred directional shadows", CustomSamplerId.RenderDeferredDirectionalShadow.GetSampler()))
 
                         RenderDeferredLighting(hdCamera, cmd);
 
+                        // Might float this higher if we enable stereo w/ deferred
+                        StartStereoRendering(renderContext, hdCamera.camera);
+
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Opaque);
                         RenderForwardError(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Opaque);
 
 
                         AccumulateDistortion(m_CullResults, hdCamera, renderContext, cmd);
                         RenderDistortion(cmd, m_Asset.renderPipelineResources, hdCamera);
+
+                        StopStereoRendering(renderContext, hdCamera.camera);
 
                         PushFullScreenDebugTexture(cmd, m_CameraColorBuffer, hdCamera, FullScreenDebugMode.NanTracker);
                         PushColorPickerDebugTexture(cmd, m_CameraColorBuffer, hdCamera);
 
+                        StartStereoRendering(renderContext, hdCamera.camera);
+
                         // Final blit
                         if (m_FrameSettings.enablePostprocess && CoreUtils.IsPostProcessingActive(postProcessLayer))
                         {
                                 HDUtils.BlitCameraTexture(cmd, hdCamera, m_CameraColorBuffer, BuiltinRenderTextureType.CameraTarget);
                             }
                         }
+
+                        StopStereoRendering(renderContext, hdCamera.camera);
+                        // Pushes to XR headset and/or display mirror
+                        if (m_FrameSettings.enableStereo)
+                            renderContext.StereoEndRender(hdCamera.camera);
                     }
 
 
                 }
                 // END TEMP
             }
+        }
+
+        void StartStereoRendering(ScriptableRenderContext renderContext, Camera cam)
+        {
+            if (m_FrameSettings.enableStereo)
+                renderContext.StartMultiEye(cam);
+        }
+
+        void StopStereoRendering(ScriptableRenderContext renderContext, Camera cam)
+        {
+            if (m_FrameSettings.enableStereo)
+                renderContext.StopMultiEye(cam);
         }
     }
 }

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/Lighting/LightLoop/LightLoopSettings.cs

             // When MSAA is enabled we disable Fptl as it become expensive compare to cluster
             // In HD, MSAA is only supported for forward only rendering, no MSAA in deferred mode (for code complexity reasons)
             aggregate.enableFptlForForwardOpaque = aggregate.enableFptlForForwardOpaque && !aggregateFrameSettings.enableMSAA;
+
+            // disable FPTL for stereo for now
+            aggregate.enableFptlForForwardOpaque = aggregate.enableFptlForForwardOpaque && !aggregateFrameSettings.enableStereo;
+
             // If Deferred, enable Fptl. If we are forward renderer only and not using Fptl for forward opaque, disable Fptl
             aggregate.isFptlEnabled = !aggregateFrameSettings.enableForwardRenderingOnly || aggregate.enableFptlForForwardOpaque;
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/FrameSettings.cs

             aggregate.enablePostprocess = camera.cameraType != CameraType.Reflection && srcFrameSettings.enablePostprocess;
 
             aggregate.enableStereo = camera.cameraType != CameraType.Reflection && srcFrameSettings.enableStereo && XRSettings.isDeviceActive && (camera.stereoTargetEye == StereoTargetEyeMask.Both) && renderPipelineSettings.supportStereo;
-            // Force forward if we request stereo. TODO: We should not enforce that, users should be able to chose deferred
-            aggregate.enableForwardRenderingOnly = aggregate.enableForwardRenderingOnly || aggregate.enableStereo;
 
             aggregate.enableAsyncCompute = srcFrameSettings.enableAsyncCompute && SystemInfo.supportsAsyncCompute;
 
             aggregate.enableMSAA = srcFrameSettings.enableMSAA && renderPipelineSettings.supportMSAA;
-            aggregate.ConfigureMSAADependentSettings();
+
+            aggregate.ConfigureMSAADependentSettings();
+            aggregate.ConfigureStereoDependentSettings();
 
             if (camera.cameraType == CameraType.Preview)
             {
                 enableSSR = false;
                 enableSubsurfaceScattering = false;
                 enableTransparentObjects = false; // waiting on depth pyramid generation
+            }
+        }
+
+        public void ConfigureStereoDependentSettings()
+        {
+            if (enableStereo)
+            {
+                // Force forward if we request stereo. TODO: We should not enforce that, users should be able to chose deferred
+                enableForwardRenderingOnly = true;
+
+                // TODO: The work will be implemented piecemeal to support all passes
+                enableMotionVectors = false;
+                enableDBuffer = false; 
+                enableDistortion = false; 
+                enablePostprocess = false;
+                enableRoughRefraction = false; 
+                enableSSAO = false;
+                enableSSR = false;
+                enableSubsurfaceScattering = false;
+                enableTransparentObjects = false;
             }
         }
 

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])
+#define UNITY_MATRIX_I_P   _InvProjMatrixStereo[unity_StereoEyeIndex]
+#define UNITY_MATRIX_VP    unity_StereoMatrixVP[unity_StereoEyeIndex]
+#define UNITY_MATRIX_I_VP  _InvViewProjMatrixStereo[unity_StereoEyeIndex]
+#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