Implemented 2-pass CS dispatch

Packages/com.unity.postprocessing@3.2.2/PostProcessing/Runtime/Effects/Upscaling.cs

@@ -181,6 +181,7 @@ namespace UnityEngine.Rendering.PostProcessing
 				{
 					UpscalerType.FSR2 when FSR2Upscaler.IsSupported => new FSR2Upscaler(),
 					UpscalerType.FSR3 when FSR3Upscaler.IsSupported => new FSR3Upscaler(),
+					UpscalerType.SGSR2_2PassCS when SGSR2Upscaler.IsSupported => new SGSR2Upscaler_2PassCS(),
 					UpscalerType.SGSR2_3PassCS when SGSR2Upscaler.IsSupported => new SGSR2Upscaler_3PassCS(),
 					_ => new FSR2Upscaler(),	// Fallback for when the selected upscaler is not supported on the current hardware
 				};

Packages/com.unity.postprocessing@3.2.2/PostProcessing/Runtime/Effects/Upscaling/SGSR2Upscaler_2PassCS.cs

@@ -0,0 +1,83 @@
+using System.Runtime.InteropServices;
+
+namespace UnityEngine.Rendering.PostProcessing
+{
+    internal class SGSR2Upscaler_2PassCS: SGSR2Upscaler
+    {
+        public override void Render(PostProcessRenderContext context, Upscaling config)
+        {
+            var cmd = context.command;
+            cmd.BeginSample("SGSR2 2-Pass CS");
+            
+            ref var parms = ref _paramsBuffer.Value;
+            parms.renderSize = config.GetScaledRenderSize(context.camera);
+            parms.displaySize = config.UpscaleSize;
+            parms.renderSizeRcp = new Vector2(1.0f / parms.renderSize.x, 1.0f / parms.renderSize.y);
+            parms.displaySizeRcp = new Vector2(1.0f / parms.displaySize.x, 1.0f / parms.displaySize.y);
+            parms.jitterOffset = config.JitterOffset;
+            parms.clipToPrevClip = Matrix4x4.identity; // TODO: clipToPrevClip => (previous_view_proj * inv_vp)
+            parms.preExposure = config.preExposure;
+            parms.cameraFovAngleHor = Mathf.Tan(context.camera.fieldOfView * Mathf.Deg2Rad * 0.5f) * (float)parms.renderSize.x / parms.renderSize.y;
+            parms.cameraNear = context.camera.nearClipPlane;
+            parms.minLerpContribution = 0f;
+            parms.bSameCamera = 0u;
+            parms.reset = config.Reset ? 1u : 0u;
+            _paramsBuffer.UpdateBufferData(cmd);
+
+            if (_frameCount == 0 || config.Reset)
+            {
+                cmd.SetRenderTarget(_lumaHistory[0]);
+                cmd.ClearRenderTarget(false, true, Color.clear);
+                cmd.SetRenderTarget(_lumaHistory[1]);
+                cmd.ClearRenderTarget(false, true, Color.clear);
+                cmd.SetRenderTarget(_upscaleHistory[0]);
+                cmd.ClearRenderTarget(false, true, Color.clear);
+                cmd.SetRenderTarget(_upscaleHistory[1]);
+                cmd.ClearRenderTarget(false, true, Color.clear);
+            }
+
+            Convert(cmd, context, config);
+            Upscale(cmd, context);
+            
+            cmd.EndSample("SGSR2 2-Pass CS");
+            _frameCount++;
+        }
+
+        private void Convert(CommandBuffer cmd, PostProcessRenderContext context, Upscaling config)
+        {
+            var shader = context.resources.computeShaders.sgsr2Upscaler.twoPassCompute.convert;
+            int kernelIndex = shader.FindKernel("CS");
+            
+            cmd.SetComputeConstantBufferParam(shader, "Params", _paramsBuffer, 0, Marshal.SizeOf<SGSR2.Params>());
+            cmd.SetComputeTextureParam(shader, kernelIndex, "InputColor", context.source);
+            cmd.SetComputeTextureParam(shader, kernelIndex, "InputDepth", BuiltinRenderTextureType.CameraTarget, 0, RenderTextureSubElement.Depth);
+            cmd.SetComputeTextureParam(shader, kernelIndex, "InputVelocity", BuiltinRenderTextureType.MotionVectors);
+            cmd.SetComputeTextureParam(shader, kernelIndex, "MotionDepthClipAlphaBuffer", _motionDepthClipAlpha);
+            cmd.SetComputeTextureParam(shader, kernelIndex, "YCoCgColor", _colorLuma);
+            
+            const int threadGroupWorkRegionDim = 8;
+            int dispatchSrcX = (_paramsBuffer.Value.renderSize.x + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            int dispatchSrcY = (_paramsBuffer.Value.renderSize.y + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            cmd.DispatchCompute(shader, kernelIndex, dispatchSrcX, dispatchSrcY, 1);
+        }
+
+        private void Upscale(CommandBuffer cmd, PostProcessRenderContext context)
+        {
+            var shader = context.resources.computeShaders.sgsr2Upscaler.twoPassCompute.upscale;
+            int kernelIndex = shader.FindKernel("CS");
+            uint frameIndex = _frameCount % 2;
+            
+            cmd.SetComputeConstantBufferParam(shader, "Params", _paramsBuffer, 0, Marshal.SizeOf<SGSR2.Params>());
+            cmd.SetComputeTextureParam(shader, kernelIndex, "PrevHistoryOutput", _upscaleHistory[frameIndex ^ 1]);
+            cmd.SetComputeTextureParam(shader, kernelIndex, "MotionDepthClipAlphaBuffer", _motionDepthClipAlpha);
+            cmd.SetComputeTextureParam(shader, kernelIndex, "YCoCgColor", _colorLuma);
+            cmd.SetComputeTextureParam(shader, kernelIndex, "SceneColorOutput", context.destination);
+            cmd.SetComputeTextureParam(shader, kernelIndex, "HistoryOutput", _upscaleHistory[frameIndex]);
+            
+            const int threadGroupWorkRegionDim = 8;
+            int dispatchDstX = (_paramsBuffer.Value.displaySize.x + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            int dispatchDstY = (_paramsBuffer.Value.displaySize.y + (threadGroupWorkRegionDim - 1)) / threadGroupWorkRegionDim;
+            cmd.DispatchCompute(shader, kernelIndex, dispatchDstX, dispatchDstY, 1);
+        }
+    }
+}

Packages/com.unity.postprocessing@3.2.2/PostProcessing/Runtime/Effects/Upscaling/SGSR2Upscaler_2PassCS.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3d5127688822e654084c665f84c0c3e0
+timeCreated: 1734733770