Cleanups for TAA

Couple more bits to do

* Support RT arrays
* Generalize code between OnPreCull and OnPreRender for TAA

Author: robbiesri

PostProcessing/Runtime/Effects/TemporalAntialiasing.cs

@@ -41,17 +41,16 @@ 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][];
+        const int k_NumEyes = 2;
+        const int k_NumHistoryTextures = 2;
+        readonly RenderTexture[][] m_HistoryTextures = new RenderTexture[k_NumEyes][];
 
-        //int m_HistoryPingPong;
-        int[] m_HistoryPingPong = new int [2];
+        int[] m_HistoryPingPong = new int [k_NumEyes];
 
         public TemporalAntialiasing()
         {
-            m_HistoryTextures[0] = new RenderTexture[2];
-            m_HistoryTextures[1] = new RenderTexture[2];
+            m_HistoryTextures[(int)Camera.StereoscopicEye.Left] = new RenderTexture[k_NumHistoryTextures];
+            m_HistoryTextures[(int)Camera.StereoscopicEye.Right] = new RenderTexture[k_NumHistoryTextures];
         }
 
         public bool IsSupported()
@@ -132,24 +131,28 @@ public void ConfiguredStereoJitteredProjectionMatrices(PostProcessRenderContext
                 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.singleEyeWidth, jitter.y / context.height);
             camera.useJitteredProjectionMatrixForTransparentRendering = false;
         }
 
         RenderTexture CheckHistory(int id, PostProcessRenderContext context)
         {
-            //var rt = m_HistoryTextures[id];
-            var rt = m_HistoryTextures[context.activeEye][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 id #" + id.ToString() + " for eye " + context.activeEye.ToString();
+                if (XR.XRSettings.isDeviceActive)
+                    rt.name = "Temporal Anti-aliasing History id #" + id.ToString() + " for eye " + context.xrActiveEye.ToString();
+                else
+                    rt.name = "Temporal Anti-aliasing History id #" + id.ToString();
+
                 rt.filterMode = FilterMode.Bilinear;
-                //m_HistoryTextures[id] = rt;
-                m_HistoryTextures[context.activeEye][id] = rt;
+                m_HistoryTextures[context.xrActiveEye][id] = rt;
 
                 context.command.BlitFullscreenTriangle(context.source, rt);
             }
@@ -158,18 +161,19 @@ 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 id #" + id.ToString() + " for eye " + context.activeEye.ToString();
+                if (XR.XRSettings.isDeviceActive)
+                    rt2.name = "Temporal Anti-aliasing History id #" + id.ToString() + " for eye " + context.xrActiveEye.ToString();
+                else
+                    rt2.name = "Temporal Anti-aliasing History id #" + id.ToString();
+
                 rt2.filterMode = FilterMode.Bilinear;
-                //m_HistoryTextures[id] = rt2;
-                m_HistoryTextures[context.activeEye][id] = rt2;
+                m_HistoryTextures[context.xrActiveEye][id] = rt2;
 
                 context.command.BlitFullscreenTriangle(rt, rt2);
                 RenderTexture.ReleaseTemporary(rt);
             }
 
-            //return m_HistoryTextures[id];
-            return m_HistoryTextures[context.activeEye][id];
+            return m_HistoryTextures[context.xrActiveEye][id];
         }
 
         internal void Render(PostProcessRenderContext context)
@@ -179,12 +183,10 @@ internal void Render(PostProcessRenderContext context)
             var cmd = context.command;
             cmd.BeginSample("TemporalAntialiasing");
 
-            //int pp = m_HistoryPingPong;
-            int pp = m_HistoryPingPong[context.activeEye];
+            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.activeEye] = ++pp % 2;
+            m_HistoryPingPong[context.xrActiveEye] = ++pp % 2;
 
             const float kMotionAmplification = 100f * 60f;
             sheet.properties.SetVector(ShaderIDs.Jitter, jitter);

PostProcessing/Runtime/PostProcessLayer.cs

@@ -256,14 +256,9 @@ 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;
@@ -372,28 +367,30 @@ void OnPreCull()
         void OnPreRender()
         {
             // Unused in scriptable render pipelines
-            // we only execute this for right eye
+            // Only needed for multi-pass stereo right eye
             if (RuntimeUtilities.scriptableRenderPipelineActive ||
                 (m_Camera.stereoActiveEye != Camera.MonoOrStereoscopicEye.Right))
                 return;
 
+            // Probably should re-factor everything below to share common code between OnPreCull
+            // and OnPreRender.  
+
             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;
-            //m_Camera.nonJitteredProjectionMatrix = m_Camera.GetStereoNonJitteredProjectionMatrix(Camera.StereoscopicEye.Right);
-            //m_Camera.projectionMatrix = m_Camera.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
-
             context.Reset();
             context.camera = m_Camera;
             context.sourceFormat = sourceFormat;
 
-            // TODO: I assume these are all executed for left eye before coming here
+            // I don't think I need the big hammer of clearing out the command buffers totally for the right eye.
+            // Really, I just need to clear out any effect that relies on history frames (like TAA), since each
+            // eye will have their own retained state.  The command buffers might be re-usable, assuming
+            // they start out being sourced from camera targets.
+            // Also, clearing of these buffers is dependent on their use being completed on the left eye first.
+            // Materials and render textures are what I am curious about, as far as re-use.  
+            // There is also the possibility of separating out the history-based effects into their own command
+            // buffers, and adding those per eye.  I don't think the bang-for-buck is there for that though,
+            // especially since single-pass is the path moving forward.
             m_LegacyCmdBufferBeforeReflections.Clear();
             m_LegacyCmdBufferOpaque.Clear();
             m_LegacyCmdBuffer.Clear();
@@ -421,6 +418,7 @@ void OnPreRender()
             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)

PostProcessing/Runtime/PostProcessRenderContext.cs

@@ -24,28 +24,22 @@ public Camera camera
                     RenderTextureDescriptor xrDesc = XR.XRSettings.eyeTextureDesc;
                     m_width = xrDesc.width;
                     m_height = xrDesc.height;
-                    // we should create eye-specific params
-                    // in order to support knowing the size of each eye
+
+                    m_xrSinglePass = (xrDesc.vrUsage == VRTextureUsage.TwoEyes);
 
                     if (camera.stereoActiveEye == Camera.MonoOrStereoscopicEye.Right)
-                        m_activeEye = (int)Camera.StereoscopicEye.Right;
+                        m_xrActiveEye = (int)Camera.StereoscopicEye.Right;
 
-                    if ((xrDesc.vrUsage == VRTextureUsage.TwoEyes) &&
-                        (xrDesc.dimension != TextureDimension.Tex2DArray))
-                    {
-                        m_singleEyeWidth = m_width / 2;
-                    }
+                    if (m_xrSinglePass && (xrDesc.dimension != TextureDimension.Tex2DArray))
+                        m_xrSingleEyeWidth = 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);
+                        m_xrSingleEyeWidth = m_width;
                 }
                 else
                 {
                     m_width = m_camera.pixelWidth;
                     m_height = m_camera.pixelHeight;
-                    m_singleEyeWidth = m_width;
+                    m_xrSingleEyeWidth = m_width;
                 }
             }
         }
@@ -96,18 +90,27 @@ public int height
             get { return m_height; }
         }
 
-        private int m_singleEyeWidth;
-        public int singleEyeWidth
-        {
-            get { return m_singleEyeWidth; }
-        }
-
+        // Is XR running in single-pass stereo mode?
         private bool m_xrSinglePass;
         public bool xrSinglePass
         {
             get { return m_xrSinglePass; }
         }
 
+        // Current active rendering eye (for XR)
+        private int m_xrActiveEye;
+        public int xrActiveEye
+        {
+            get { return m_xrActiveEye; }
+        }
+
+        // Current single eye width in pixels (for XR)
+        private int m_xrSingleEyeWidth;
+        public int singleEyeWidth
+        {
+            get { return m_xrSingleEyeWidth; }
+        }
+
         // Are we currently rendering in the scene view?
         public bool isSceneView { get; internal set; }
 
@@ -118,21 +121,15 @@ public bool xrSinglePass
         // 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;
+            m_xrActiveEye = (int)Camera.StereoscopicEye.Left;
+            m_xrSingleEyeWidth = 0;
 
             command = null;
             source = 0;

PostProcessing/Runtime/Utils/RuntimeUtilities.cs

@@ -192,6 +192,9 @@ public static void CopyTexture(CommandBuffer cmd, RenderTargetIdentifier source,
                 cmd.BlitFullscreenTriangle(source, destination);
         }
 
+        // TODO: Generalize the GetTemporaryRT and Blit commands in order to support
+        // RT Arrays for Stereo Instancing/MultiView
+
         #endregion
 
         #region Unity specifics