Merge pull request #259 from Unity-Technologies/xr_taa

XR Support for TAA

Author: Chman

PostProcessing/Editor/PostProcessLayerEditor.cs

@@ -176,7 +176,7 @@ void DoAntialiasing()
                 if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.TemporalAntialiasing)
                 {
                     if (RuntimeUtilities.isSinglePassStereoEnabled)
-                        EditorGUILayout.HelpBox("TAA doesn't work with Single-pass stereo rendering.", MessageType.Warning);
+                        EditorGUILayout.HelpBox("TAA requires Unity 2017.3+ for Single-pass stereo rendering support.", MessageType.Warning);
 
                     EditorGUILayout.PropertyField(m_TaaJitterSpread);
                     EditorGUILayout.PropertyField(m_TaaStationaryBlending);

PostProcessing/Runtime/Effects/TemporalAntialiasing.cs

@@ -41,15 +41,26 @@ enum Pass
 
         // Ping-pong between two history textures as we can't read & write the same target in the
         // same pass
-        readonly RenderTexture[] m_HistoryTextures = new RenderTexture[2];
-        int m_HistoryPingPong;
+        const int k_NumEyes = 2;
+        const int k_NumHistoryTextures = 2;
+        readonly RenderTexture[][] m_HistoryTextures = new RenderTexture[k_NumEyes][];
+
+        int[] m_HistoryPingPong = new int [k_NumEyes];
+
+        public TemporalAntialiasing()
+        {
+            m_HistoryTextures[(int)Camera.StereoscopicEye.Left] = new RenderTexture[k_NumHistoryTextures];
+            m_HistoryTextures[(int)Camera.StereoscopicEye.Right] = new RenderTexture[k_NumHistoryTextures];
+        }
 
         public bool IsSupported()
         {
             return SystemInfo.supportedRenderTargetCount >= 2
                 && SystemInfo.supportsMotionVectors
-                && SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2
-                && !RuntimeUtilities.isSinglePassStereoEnabled;
+#if !UNITY_2017_3_OR_NEWER
+                && !RuntimeUtilities.isVREnabled
+#endif
+                && SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
         }
 
         internal DepthTextureMode GetCameraFlags()
@@ -96,18 +107,70 @@ public Matrix4x4 GetJitteredProjectionMatrix(Camera camera)
             return cameraProj;
         }
 
+        public void ConfigureJitteredProjectionMatrix(PostProcessRenderContext context)
+        {
+            var camera = context.camera;
+            camera.nonJitteredProjectionMatrix = camera.projectionMatrix;
+            camera.projectionMatrix = GetJitteredProjectionMatrix(camera);
+            camera.useJitteredProjectionMatrixForTransparentRendering = false;
+        }
+
+        // TODO: We'll probably need to isolate most of this for SRPs
+        public void ConfigureStereoJitteredProjectionMatrices(PostProcessRenderContext context)
+        {
+#if  UNITY_2017_3_OR_NEWER
+            var camera = context.camera;
+            jitter = GenerateRandomOffset();
+            jitter *= jitterSpread;
+
+            for (var eye = Camera.StereoscopicEye.Left; eye <= Camera.StereoscopicEye.Right; eye++)
+            {
+                // This saves off the device generated projection matrices as non-jittered
+                context.camera.CopyStereoDeviceProjectionMatrixToNonJittered(eye);
+                var originalProj = context.camera.GetStereoNonJitteredProjectionMatrix(eye);
+
+                // Currently no support for custom jitter func, as VR devices would need to provide
+                // original projection matrix as input along with jitter 
+                var jitteredMatrix = RuntimeUtilities.GenerateJitteredProjectionMatrixFromOriginal(context, originalProj, jitter);
+                context.camera.SetStereoProjectionMatrix(eye, jitteredMatrix);
+            }
+
+            // jitter has to be scaled for the actual eye texture size, not just the intermediate texture size
+            // which could be double-wide in certain stereo rendering scenarios
+            jitter = new Vector2(jitter.x / context.xrSingleEyeWidth, jitter.y / context.height);
+            camera.useJitteredProjectionMatrixForTransparentRendering = false;
+#endif
+        }
+
+        void GenerateHistoryName(RenderTexture rt, int id, PostProcessRenderContext context)
+        {
+            rt.name = "Temporal Anti-aliasing History id #" + id;
+
+            bool vrDeviceActive = false;
+
+#if UNITY_2017_2_OR_NEWER
+            vrDeviceActive = XR.XRSettings.isDeviceActive;
+#else
+            vrDeviceActive = VR.VRSettings.isDeviceActive;
+#endif
+
+            if (vrDeviceActive)
+                rt.name += " for eye " + context.xrActiveEye;
+        }
+
         RenderTexture CheckHistory(int id, PostProcessRenderContext context)
         {
-            var rt = m_HistoryTextures[id];
+            var rt = m_HistoryTextures[context.xrActiveEye][id];
 
             if (m_ResetHistory || rt == null || !rt.IsCreated())
             {
                 RenderTexture.ReleaseTemporary(rt);
 
                 rt = RenderTexture.GetTemporary(context.width, context.height, 0, context.sourceFormat);
-                rt.name = "Temporal Anti-aliasing History";
+                GenerateHistoryName(rt, id, context);
+
                 rt.filterMode = FilterMode.Bilinear;
-                m_HistoryTextures[id] = rt;
+                m_HistoryTextures[context.xrActiveEye][id] = rt;
 
                 context.command.BlitFullscreenTriangle(context.source, rt);
             }
@@ -116,15 +179,16 @@ RenderTexture CheckHistory(int id, PostProcessRenderContext context)
                 // On size change, simply copy the old history to the new one. This looks better
                 // than completely discarding the history and seeing a few aliased frames.
                 var rt2 = RenderTexture.GetTemporary(context.width, context.height, 0, context.sourceFormat);
-                rt2.name = "Temporal Anti-aliasing History";
+                GenerateHistoryName(rt2, id, context);
+
                 rt2.filterMode = FilterMode.Bilinear;
-                m_HistoryTextures[id] = rt2;
+                m_HistoryTextures[context.xrActiveEye][id] = rt2;
 
                 context.command.BlitFullscreenTriangle(rt, rt2);
                 RenderTexture.ReleaseTemporary(rt);
             }
 
-            return m_HistoryTextures[id];
+            return m_HistoryTextures[context.xrActiveEye][id];
         }
 
         internal void Render(PostProcessRenderContext context)
@@ -134,10 +198,10 @@ internal void Render(PostProcessRenderContext context)
             var cmd = context.command;
             cmd.BeginSample("TemporalAntialiasing");
 
-            int pp = m_HistoryPingPong;
+            int pp = m_HistoryPingPong[context.xrActiveEye];
             var historyRead = CheckHistory(++pp % 2, context);
             var historyWrite = CheckHistory(++pp % 2, context);
-            m_HistoryPingPong = ++pp % 2;
+            m_HistoryPingPong[context.xrActiveEye] = ++pp % 2;
 
             const float kMotionAmplification = 100f * 60f;
             sheet.properties.SetVector(ShaderIDs.Jitter, jitter);
@@ -159,12 +223,17 @@ internal void Release()
         {
             for (int i = 0; i < m_HistoryTextures.Length; i++)
             {
-                RenderTexture.ReleaseTemporary(m_HistoryTextures[i]);
+                for (int j = 0; j < m_HistoryTextures[i].Length; j++)
+                {
+                    RenderTexture.ReleaseTemporary(m_HistoryTextures[i][j]);
+                    m_HistoryTextures[i][j] = null;
+                }
                 m_HistoryTextures[i] = null;
             }
 
             m_SampleIndex = 0;
-            m_HistoryPingPong = 0;
+            m_HistoryPingPong[0] = 0;
+            m_HistoryPingPong[1] = 0;
 
             ResetHistory();
         }

PostProcessing/Runtime/PostProcessLayer.cs

@@ -5,6 +5,12 @@
 
 namespace UnityEngine.Rendering.PostProcessing
 {
+#if UNITY_2017_2_OR_NEWER
+    using XRSettings = UnityEngine.XR.XRSettings;
+#elif UNITY_5_6_OR_NEWER
+    using XRSettings = UnityEngine.VR.VRSettings;
+#endif
+
     // TODO: XMLDoc everything (?)
     [DisallowMultipleComponent, ExecuteInEditMode, ImageEffectAllowedInSceneView]
     [AddComponentMenu("Rendering/Post-process Layer", -1)]
@@ -256,20 +262,40 @@ void OnPreCull()
             if (RuntimeUtilities.scriptableRenderPipelineActive)
                 return;
 
-            var context = m_CurrentContext;
-            var sourceFormat = m_Camera.allowHDR ? RenderTextureFormat.DefaultHDR : RenderTextureFormat.Default;
-
             // Resets the projection matrix from previous frame in case TAA was enabled.
             // We also need to force reset the non-jittered projection matrix here as it's not done
             // when ResetProjectionMatrix() is called and will break transparent rendering if TAA
             // is switched off and the FOV or any other camera property changes.
             m_Camera.ResetProjectionMatrix();
             m_Camera.nonJitteredProjectionMatrix = m_Camera.projectionMatrix;
 
+            if (XRSettings.isDeviceActive)
+                m_Camera.ResetStereoProjectionMatrices();
+
+            BuildCommandBuffers();
+        }
+
+        void OnPreRender()
+        {
+            // Unused in scriptable render pipelines
+            // Only needed for multi-pass stereo right eye
+            if (RuntimeUtilities.scriptableRenderPipelineActive ||
+                (m_Camera.stereoActiveEye != Camera.MonoOrStereoscopicEye.Right))
+                return;
+
+            BuildCommandBuffers();
+        }
+
+        void BuildCommandBuffers()
+        {
+            var context = m_CurrentContext;
+            var sourceFormat = m_Camera.allowHDR ? RenderTextureFormat.DefaultHDR : RenderTextureFormat.Default;
+
             context.Reset();
             context.camera = m_Camera;
             context.sourceFormat = sourceFormat;
 
+            // TODO: Investigate retaining command buffers on XR multi-pass right eye
             m_LegacyCmdBufferBeforeReflections.Clear();
             m_LegacyCmdBufferBeforeLighting.Clear();
             m_LegacyCmdBufferOpaque.Clear();
@@ -321,6 +347,7 @@ void OnPreCull()
             opaqueOnlyEffects += isFogActive ? 1 : 0;
             opaqueOnlyEffects += hasCustomOpaqueOnlyEffects ? 1 : 0;
 
+            // This works on right eye because it is resolved/populated at runtime
             var cameraTarget = new RenderTargetIdentifier(BuiltinRenderTextureType.CameraTarget);
 
             if (opaqueOnlyEffects > 0)
@@ -394,7 +421,15 @@ void OnPostRender()
                 return;
 
             if (m_CurrentContext.IsTemporalAntialiasingActive())
+            {
                 m_Camera.ResetProjectionMatrix();
+
+                if (XRSettings.isDeviceActive)
+                {
+                    if (RuntimeUtilities.isSinglePassStereoEnabled || m_Camera.stereoActiveEye == Camera.MonoOrStereoscopicEye.Right)
+                        m_Camera.ResetStereoProjectionMatrices();
+                }
+            }
         }
 
         PostProcessBundle GetBundle<T>()
@@ -573,10 +608,16 @@ public void Render(PostProcessRenderContext context)
             {
                 if (!RuntimeUtilities.scriptableRenderPipelineActive)
                 {
-                    var camera = context.camera;
-                    camera.nonJitteredProjectionMatrix = camera.projectionMatrix;
-                    camera.projectionMatrix = temporalAntialiasing.GetJitteredProjectionMatrix(camera);
-                    camera.useJitteredProjectionMatrixForTransparentRendering = false;
+                    if (XRSettings.isDeviceActive)
+                    {
+                        // We only need to configure all of this once for stereo, during OnPreCull
+                        if (context.camera.stereoActiveEye != Camera.MonoOrStereoscopicEye.Right)
+                            temporalAntialiasing.ConfigureStereoJitteredProjectionMatrices(context);
+                    }
+                    else
+                    {
+                        temporalAntialiasing.ConfigureJitteredProjectionMatrix(context);
+                    }
                 }
 
                 var taaTarget = m_TargetPool.Get();

PostProcessing/Runtime/PostProcessRenderContext.cs

@@ -1,13 +1,52 @@
 namespace UnityEngine.Rendering.PostProcessing
 {
+#if UNITY_2017_2_OR_NEWER
+    using XRSettings = UnityEngine.XR.XRSettings;
+#elif UNITY_5_6_OR_NEWER
+    using XRSettings = UnityEngine.VR.VRSettings;
+#endif
+
     // Context object passed around all post-fx in a frame
     public sealed class PostProcessRenderContext
     {
         // -----------------------------------------------------------------------------------------
         // The following should be filled by the render pipeline
 
         // Camera currently rendering
-        public Camera camera { get; set; }
+        Camera m_Camera;
+        public Camera camera
+        {
+            get { return m_Camera; }
+            set
+            {
+                m_Camera = value;
+
+                if (XRSettings.isDeviceActive)
+                {
+#if UNITY_2017_2_OR_NEWER
+                    RenderTextureDescriptor xrDesc = XRSettings.eyeTextureDesc;
+                    width = xrDesc.width;
+                    height = xrDesc.height;
+#else
+                    width = XRSettings.eyeTextureWidth; // double this for single-pass when we can't query eyeTextureDesc
+                    height = XRSettings.eyeTextureHeight;
+#endif
+
+                    if (camera.stereoActiveEye == Camera.MonoOrStereoscopicEye.Right)
+                        xrActiveEye = (int)Camera.StereoscopicEye.Right;
+
+                    xrSingleEyeWidth = XRSettings.eyeTextureWidth;
+                    xrSingleEyeHeight = XRSettings.eyeTextureHeight;
+                }
+                else
+                {
+                    width = m_Camera.pixelWidth;
+                    height = m_Camera.pixelHeight;
+                    xrSingleEyeWidth = width;
+                }
+            }
+        }
+
 
         // The command buffer to fill in
         public CommandBuffer command { get; set; }
@@ -45,16 +84,19 @@ public sealed class PostProcessRenderContext
         public PostProcessDebugLayer debugLayer { get; internal set; }
 
         // Current camera width in pixels
-        public int width
-        {
-            get { return camera.pixelWidth; }
-        }
+        public int width { get; private set; }
 
         // Current camera height in pixels
-        public int height
-        {
-            get { return camera.pixelHeight; }
-        }
+        public int height { get; private set; }
+
+        // Current active rendering eye (for XR)
+        public int xrActiveEye { get; private set; }
+
+        // Current single eye width in pixels (for XR)
+        public int xrSingleEyeWidth { get; private set; }
+
+        // Current single eye height in pixels (for XR)
+        public int xrSingleEyeHeight { get; private set; }
 
         // Are we currently rendering in the scene view?
         public bool isSceneView { get; internal set; }
@@ -68,7 +110,14 @@ public int height
 
         public void Reset()
         {
-            camera = null;
+            m_Camera = null;
+            width = 0;
+            height = 0;
+
+            xrActiveEye = (int)Camera.StereoscopicEye.Left;
+            xrSingleEyeWidth = 0;
+            xrSingleEyeHeight = 0;
+
             command = null;
             source = 0;
             destination = 0;