TAA works with Multi and Single Pass Stereo

Fair bit of hacking done, need to do a lot of cleanup.

RT arrays aren't addressed yet.

Author: robbiesri

PostProcessing/Runtime/Effects/TemporalAntialiasing.cs

@@ -42,10 +42,17 @@ enum Pass
         // Ping-pong between two history textures as we can't read & write the same target in the
         // same pass
         // TODO: We need to make left/right arrays
-        readonly RenderTexture[] m_HistoryTextures = new RenderTexture[2];
-        //readonly RenderTexture[][] m_HistoryTextures = new RenderTexture[2][];
-        //m_HistoryTextures[0][] = new RenderTexture[2];
-        int m_HistoryPingPong;
+        //readonly RenderTexture[] m_HistoryTextures = new RenderTexture[2];
+        readonly RenderTexture[][] m_HistoryTextures = new RenderTexture[2][];
+
+        //int m_HistoryPingPong;
+        int[] m_HistoryPingPong = new int [2];
+
+        public TemporalAntialiasing()
+        {
+            m_HistoryTextures[0] = new RenderTexture[2];
+            m_HistoryTextures[1] = new RenderTexture[2];
+        }
 
         public bool IsSupported()
         {
@@ -131,16 +138,18 @@ public void ConfiguredStereoJitteredProjectionMatrices(PostProcessRenderContext
 
         RenderTexture CheckHistory(int id, PostProcessRenderContext context)
         {
-            var rt = m_HistoryTextures[id];
+            //var rt = m_HistoryTextures[id];
+            var rt = m_HistoryTextures[context.activeEye][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";
+                rt.name = "Temporal Anti-aliasing History id #" + id.ToString() + " for eye " + context.activeEye.ToString();
                 rt.filterMode = FilterMode.Bilinear;
-                m_HistoryTextures[id] = rt;
+                //m_HistoryTextures[id] = rt;
+                m_HistoryTextures[context.activeEye][id] = rt;
 
                 context.command.BlitFullscreenTriangle(context.source, rt);
             }
@@ -149,15 +158,18 @@ 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";
+                //rt2.name = "Temporal Anti-aliasing History";
+                rt2.name = "Temporal Anti-aliasing History id #" + id.ToString() + " for eye " + context.activeEye.ToString();
                 rt2.filterMode = FilterMode.Bilinear;
-                m_HistoryTextures[id] = rt2;
+                //m_HistoryTextures[id] = rt2;
+                m_HistoryTextures[context.activeEye][id] = rt2;
 
                 context.command.BlitFullscreenTriangle(rt, rt2);
                 RenderTexture.ReleaseTemporary(rt);
             }
 
-            return m_HistoryTextures[id];
+            //return m_HistoryTextures[id];
+            return m_HistoryTextures[context.activeEye][id];
         }
 
         internal void Render(PostProcessRenderContext context)
@@ -167,10 +179,12 @@ internal void Render(PostProcessRenderContext context)
             var cmd = context.command;
             cmd.BeginSample("TemporalAntialiasing");
 
-            int pp = m_HistoryPingPong;
+            //int pp = m_HistoryPingPong;
+            int pp = m_HistoryPingPong[context.activeEye];
             var historyRead = CheckHistory(++pp % 2, context);
             var historyWrite = CheckHistory(++pp % 2, context);
-            m_HistoryPingPong = ++pp % 2;
+            //m_HistoryPingPong = ++pp % 2;
+            m_HistoryPingPong[context.activeEye] = ++pp % 2;
 
             const float kMotionAmplification = 100f * 60f;
             sheet.properties.SetVector(ShaderIDs.Jitter, jitter);
@@ -192,12 +206,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

@@ -256,9 +256,14 @@ void OnPreCull()
             // 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;
+            //m_Camera.nonJitteredProjectionMatrix = m_Camera.projectionMatrix;
             if (XR.XRSettings.isDeviceActive)
+            {
                 m_Camera.ResetStereoProjectionMatrices();
+                //m_Camera.nonJitteredProjectionMatrix = m_Camera.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
+            }
+            else
+                m_Camera.nonJitteredProjectionMatrix = m_Camera.projectionMatrix;
 
             context.Reset();
             context.camera = m_Camera;
@@ -381,6 +386,8 @@ void OnPreRender()
             // is switched off and the FOV or any other camera property changes.
             //m_Camera.ResetProjectionMatrix();
             //m_Camera.nonJitteredProjectionMatrix = m_Camera.projectionMatrix;
+            //m_Camera.nonJitteredProjectionMatrix = m_Camera.GetStereoNonJitteredProjectionMatrix(Camera.StereoscopicEye.Right);
+            //m_Camera.projectionMatrix = m_Camera.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
 
             context.Reset();
             context.camera = m_Camera;
@@ -496,8 +503,13 @@ void OnPostRender()
             if (m_CurrentContext.IsTemporalAntialiasingActive())
             {
                 m_Camera.ResetProjectionMatrix();
+
                 if (XR.XRSettings.isDeviceActive)
-                    m_Camera.ResetStereoProjectionMatrices();
+                {
+                    if (m_CurrentContext.xrSinglePass ||
+                        (m_Camera.stereoActiveEye == Camera.MonoOrStereoscopicEye.Right))
+                        m_Camera.ResetStereoProjectionMatrices();
+                }
             }
         }
 

PostProcessing/Runtime/PostProcessRenderContext.cs

@@ -27,13 +27,19 @@ public Camera camera
                     // we should create eye-specific params
                     // in order to support knowing the size of each eye
 
+                    if (camera.stereoActiveEye == Camera.MonoOrStereoscopicEye.Right)
+                        m_activeEye = (int)Camera.StereoscopicEye.Right;
+
                     if ((xrDesc.vrUsage == VRTextureUsage.TwoEyes) &&
                         (xrDesc.dimension != TextureDimension.Tex2DArray))
                     {
                         m_singleEyeWidth = m_width / 2;
                     }
                     else
                         m_singleEyeWidth = m_width;
+
+                    // if the intermediate texture is being used for two eyes, that's single pass
+                    m_xrSinglePass = (xrDesc.vrUsage == VRTextureUsage.TwoEyes);
                 }
                 else
                 {
@@ -96,6 +102,12 @@ public int singleEyeWidth
             get { return m_singleEyeWidth; }
         }
 
+        private bool m_xrSinglePass;
+        public bool xrSinglePass
+        {
+            get { return m_xrSinglePass; }
+        }
+
         // Are we currently rendering in the scene view?
         public bool isSceneView { get; internal set; }
 
@@ -106,12 +118,21 @@ public int singleEyeWidth
         // to do temporal reprojection (see: Depth of Field)
         public TemporalAntialiasing temporalAntialiasing { get; internal set; }
 
+        private int m_activeEye;
+        public int activeEye
+        {
+            get { return m_activeEye; }
+        }
+
         public void Reset()
         {
             m_camera = null;
             m_width = 0;
             m_height = 0;
+
             m_singleEyeWidth = 0;
+            m_activeEye = (int)Camera.StereoscopicEye.Left;
+            m_xrSinglePass = false;
 
             command = null;
             source = 0;