New temporal filter for DoF

This commit includes major improvements to the temporal filter for DoF. See the
following document for details on the improvements.

https://goo.gl/3Rpxcz

This commit also includes changes to the other components.

**Changes to the TAA component**

- Added `jitterVector` property to share the current jitter vector with DoF.

**Changes to the Uber shader**

- Changed to use a full-resolution CoC buffer to blend DoF results in the Uber
  pass. This is needed to eliminate seams and aliasing caused by integration
  with TAA. This also improves the quality even when TAA is disabled.

**Changes to Common.cginc**

- Added `SEPARATE_TEXTURE_SAMPLER` macro that controls how MainTex is to be
  declared (sampler2D or separate texture/sampler).

The following is a brief list of the changes on the DoF component.

- Implemented a temporal reprojection filter for the CoC history buffer. It's a
  simplified variant of the TAA filter and tailored to have nearly-identical
  characteristics with a less cost.

- Changed to use R8 render textures for storing CoC values instead of RHalf.
  This is needed to compensate performance loss due to increase of the memory
  and bandwidth usage.

- Optimized with using the texture gather functions on Shader Model 5.

- Optimized the post blur filter. The sample count was reduced from 9 to 4
  without losing quality.

Author: keijiro

PostProcessing/Resources/Shaders/Common.cginc

@@ -16,7 +16,12 @@
 // -----------------------------------------------------------------------------
 // Uniforms
 
+#if defined(SEPARATE_TEXTURE_SAMPLER)
+Texture2D _MainTex;
+SamplerState sampler_MainTex;
+#else
 sampler2D _MainTex;
+#endif
 float4 _MainTex_TexelSize;
 float4 _MainTex_ST;
 

PostProcessing/Resources/Shaders/DepthOfField.cginc

@@ -1,22 +1,30 @@
 #ifndef __DEPTH_OF_FIELD__
 #define __DEPTH_OF_FIELD__
 
-#include "UnityCG.cginc"
+#if SHADER_TARGET >= 50
+    // Use separate texture/sampler objects on Shader Model 5.0
+    #define SEPARATE_TEXTURE_SAMPLER
+    #define DOF_DECL_TEX2D(tex) Texture2D tex; SamplerState sampler##tex
+    #define DOF_TEX2D(tex, coord) tex.Sample(sampler##tex, coord)
+#else
+    #define DOF_DECL_TEX2D(tex) sampler2D tex
+    #define DOF_TEX2D(tex, coord) tex2D(tex, coord)
+#endif
+
 #include "Common.cginc"
 #include "DiskKernels.cginc"
 
-#define PREFILTER_LUMA_WEIGHT 1
-
-sampler2D_float _CameraDepthTexture;
-sampler2D_float _HistoryCoC;
-float _HistoryWeight;
+DOF_DECL_TEX2D(_CameraDepthTexture);
+DOF_DECL_TEX2D(_CameraMotionVectorsTexture);
+DOF_DECL_TEX2D(_CoCTex);
 
 // Camera parameters
 float _Distance;
 float _LensCoeff;  // f^2 / (N * (S1 - f) * film_width * 2)
 float _MaxCoC;
 float _RcpMaxCoC;
 float _RcpAspect;
+half3 _TaaParams; // Jitter.x, Jitter.y, Blending
 
 struct VaryingsDOF
 {
@@ -47,75 +55,114 @@ VaryingsDOF VertDOF(AttributesDefault v)
     return o;
 }
 
-// Prefilter: CoC calculation, downsampling and premultiplying.
-
-#if defined(PREFILTER_TAA)
+// CoC calculation
+half4 FragCoC(VaryingsDOF i) : SV_Target
+{
+    float depth = LinearEyeDepth(DOF_TEX2D(_CameraDepthTexture, i.uv));
+    half coc = (depth - _Distance) * _LensCoeff / max(depth, 1e-5);
+    return saturate(coc * 0.5 * _RcpMaxCoC + 0.5);
+}
 
-// TAA enabled: use MRT to update the history buffer in the same pass.
-struct PrefilterOutput
+// Temporal filter
+half4 FragTempFilter(VaryingsDOF i) : SV_Target
 {
-    half4 base : SV_Target0;
-    half4 history : SV_Target1;
-};
-#define PrefilterSemantics
+    float3 uvOffs = _MainTex_TexelSize.xyy * float3(1, 1, 0);
+
+#if defined(SEPARATE_TEXTURE_SAMPLER)
+
+    half4 cocTL = _CoCTex.GatherRed(sampler_CoCTex, i.uv - uvOffs.xy * 0.5); // top-left
+    half4 cocBR = _CoCTex.GatherRed(sampler_CoCTex, i.uv + uvOffs.xy * 0.5); // bottom-right
+    half coc1 = cocTL.x; // top
+    half coc2 = cocTL.z; // left
+    half coc3 = cocBR.x; // bottom
+    half coc4 = cocBR.z; // right
 
 #else
 
-// No TAA
-#define PrefilterOutput half4
-#define PrefilterSemantics :SV_Target
+    half coc1 = DOF_TEX2D(_CoCTex, i.uv - uvOffs.xz).r; // top
+    half coc2 = DOF_TEX2D(_CoCTex, i.uv - uvOffs.zy).r; // left
+    half coc3 = DOF_TEX2D(_CoCTex, i.uv + uvOffs.zy).r; // bottom
+    half coc4 = DOF_TEX2D(_CoCTex, i.uv + uvOffs.xz).r; // right
 
 #endif
 
-PrefilterOutput FragPrefilter(VaryingsDOF i) PrefilterSemantics
+    // Dejittered center sample.
+    half coc0 = DOF_TEX2D(_CoCTex, i.uv - _TaaParams.xy).r;
+
+    // CoC dilation: determine the closest point in the four neighbors.
+    float3 closest = float3(0, 0, coc0);
+    closest = coc1 < closest.z ? float3(-uvOffs.xz, coc1) : closest;
+    closest = coc2 < closest.z ? float3(-uvOffs.zy, coc2) : closest;
+    closest = coc3 < closest.z ? float3(+uvOffs.zy, coc3) : closest;
+    closest = coc4 < closest.z ? float3(+uvOffs.xz, coc4) : closest;
+
+    // Sample the history buffer with the motion vector at the closest point.
+    float2 motion = DOF_TEX2D(_CameraMotionVectorsTexture, i.uv + closest.xy).xy;
+    half cocHis = DOF_TEX2D(_MainTex, i.uv - motion).r;
+
+    // Neighborhood clamping.
+    half cocMin = closest.z;
+    half cocMax = max(max(max(max(coc0, coc1), coc2), coc3), coc4);
+    cocHis = clamp(cocHis, cocMin, cocMax);
+
+    // Blend with the history.
+    return lerp(coc0, cocHis, _TaaParams.z);
+}
+
+// Prefilter: downsampling and premultiplying.
+half4 FragPrefilter(VaryingsDOF i) : SV_Target
 {
+#if defined(SEPARATE_TEXTURE_SAMPLER)
+
+    // Sample source colors.
+    half4 c_r = _MainTex.GatherRed  (sampler_MainTex, i.uv);
+    half4 c_g = _MainTex.GatherGreen(sampler_MainTex, i.uv);
+    half4 c_b = _MainTex.GatherBlue (sampler_MainTex, i.uv);
+
+    half3 c0 = half3(c_r.x, c_g.x, c_b.x);
+    half3 c1 = half3(c_r.y, c_g.y, c_b.y);
+    half3 c2 = half3(c_r.z, c_g.z, c_b.z);
+    half3 c3 = half3(c_r.w, c_g.w, c_b.w);
+
+    // Sample CoCs.
+    half4 cocs = _CoCTex.Gather(sampler_CoCTex, i.uvAlt) * 2.0 - 1.0;
+    half coc0 = cocs.x;
+    half coc1 = cocs.y;
+    half coc2 = cocs.z;
+    half coc3 = cocs.w;
+
+#else
+
     float3 duv = _MainTex_TexelSize.xyx * float3(0.5, 0.5, -0.5);
 
     // Sample source colors.
-    half3 c0 = tex2D(_MainTex, i.uv - duv.xy).rgb;
-    half3 c1 = tex2D(_MainTex, i.uv - duv.zy).rgb;
-    half3 c2 = tex2D(_MainTex, i.uv + duv.zy).rgb;
-    half3 c3 = tex2D(_MainTex, i.uv + duv.xy).rgb;
-
-    // Sample linear depths.
-    float d0 = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uvAlt - duv.xy));
-    float d1 = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uvAlt - duv.zy));
-    float d2 = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uvAlt + duv.zy));
-    float d3 = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uvAlt + duv.xy));
-    float4 depths = float4(d0, d1, d2, d3);
-
-    // Calculate the radiuses of CoCs at these sample points.
-    float4 cocs = (depths - _Distance) * _LensCoeff / depths;
-    cocs = clamp(cocs, -_MaxCoC, _MaxCoC);
-
-#if defined(PREFILTER_TAA)
-    // Get the average with the history to avoid temporal aliasing.
-    half hcoc = tex2D(_HistoryCoC, i.uv).r;
-    cocs = lerp(cocs, hcoc, _HistoryWeight);
-#endif
+    half3 c0 = DOF_TEX2D(_MainTex, i.uv - duv.xy).rgb;
+    half3 c1 = DOF_TEX2D(_MainTex, i.uv - duv.zy).rgb;
+    half3 c2 = DOF_TEX2D(_MainTex, i.uv + duv.zy).rgb;
+    half3 c3 = DOF_TEX2D(_MainTex, i.uv + duv.xy).rgb;
+
+    // Sample CoCs.
+    half coc0 = DOF_TEX2D(_CoCTex, i.uvAlt - duv.xy).r * 2.0 - 1.0;
+    half coc1 = DOF_TEX2D(_CoCTex, i.uvAlt - duv.zy).r * 2.0 - 1.0;
+    half coc2 = DOF_TEX2D(_CoCTex, i.uvAlt + duv.zy).r * 2.0 - 1.0;
+    half coc3 = DOF_TEX2D(_CoCTex, i.uvAlt + duv.xy).r * 2.0 - 1.0;
 
-    // Premultiply CoC to reduce background bleeding.
-    float4 weights = saturate(abs(cocs) * _RcpMaxCoC);
-
-#if defined(PREFILTER_LUMA_WEIGHT)
-    // Apply luma weights to reduce flickering.
-    // References:
-    //   http://gpuopen.com/optimized-reversible-tonemapper-for-resolve/
-    //   http://graphicrants.blogspot.fr/2013/12/tone-mapping.html
-    weights.x *= 1.0 / (Max3(c0) + 1.0);
-    weights.y *= 1.0 / (Max3(c1) + 1.0);
-    weights.z *= 1.0 / (Max3(c2) + 1.0);
-    weights.w *= 1.0 / (Max3(c3) + 1.0);
 #endif
 
+    // Apply CoC and luma weights to reduce bleeding and flickering.
+    float w0 = abs(coc0) / (Max3(c0) + 1.0);
+    float w1 = abs(coc1) / (Max3(c1) + 1.0);
+    float w2 = abs(coc2) / (Max3(c2) + 1.0);
+    float w3 = abs(coc3) / (Max3(c3) + 1.0);
+
     // Weighted average of the color samples
-    half3 avg = c0 * weights.x + c1 * weights.y + c2 * weights.z + c3 * weights.w;
-    avg /= dot(weights, 1.0);
+    half3 avg = c0 * w0 + c1 * w1 + c2 * w2 + c3 * w3;
+    avg /= max(w0 + w1 + w2 + w3, 1e-5);
 
-    // Output CoC = average of CoCs
-    half cocmin = Min4(cocs);
-    half cocmax = Max4(cocs);
-    half coc = -cocmin > cocmax ? cocmin : cocmax;
+    // Select the largest CoC value.
+    half coc_min = Min4(coc0, coc1, coc2, coc3);
+    half coc_max = Max4(coc0, coc1, coc2, coc3);
+    half coc = (-coc_min > coc_max ? coc_min : coc_max) * _MaxCoC;
 
     // Premultiply CoC again.
     avg *= smoothstep(0, _MainTex_TexelSize.y * 2, abs(coc));
@@ -124,20 +171,13 @@ PrefilterOutput FragPrefilter(VaryingsDOF i) PrefilterSemantics
     avg = GammaToLinearSpace(avg);
 #endif
 
-#if defined(PREFILTER_TAA)
-    PrefilterOutput output;
-    output.base = half4(avg, coc);
-    output.history = coc.xxxx;
-    return output;
-#else
     return half4(avg, coc);
-#endif
 }
 
 // Bokeh filter with disk-shaped kernels
 half4 FragBlur(VaryingsDOF i) : SV_Target
 {
-    half4 samp0 = tex2D(_MainTex, i.uv);
+    half4 samp0 = DOF_TEX2D(_MainTex, i.uv);
 
     half4 bgAcc = 0.0; // Background: far field bokeh
     half4 fgAcc = 0.0; // Foreground: near field bokeh
@@ -148,7 +188,7 @@ half4 FragBlur(VaryingsDOF i) : SV_Target
         float dist = length(disp);
 
         float2 duv = float2(disp.x * _RcpAspect, disp.y);
-        half4 samp = tex2D(_MainTex, i.uv + duv);
+        half4 samp = DOF_TEX2D(_MainTex, i.uv + duv);
 
         // BG: Compare CoC of the current sample and the center sample
         // and select smaller one.
@@ -181,50 +221,23 @@ half4 FragBlur(VaryingsDOF i) : SV_Target
     fgAcc.a *= UNITY_PI / kSampleCount;
 
     // Alpha premultiplying
-    half3 rgb = 0.0;
-    rgb = lerp(rgb, bgAcc.rgb, saturate(bgAcc.a));
-    rgb = lerp(rgb, fgAcc.rgb, saturate(fgAcc.a));
-
-    // Combined alpha value
-    half alpha = (1.0 - saturate(bgAcc.a)) * (1.0 - saturate(fgAcc.a));
+    half alpha = saturate(fgAcc.a);
+    half3 rgb = lerp(bgAcc.rgb, fgAcc.rgb, alpha);
 
     return half4(rgb, alpha);
 }
 
 // Postfilter blur
 half4 FragPostBlur(VaryingsDOF i) : SV_Target
 {
-    // 9-tap tent filter
-    float4 duv = _MainTex_TexelSize.xyxy * float4(1, 1, -1, 0);
-
-    half4 c0 = tex2D(_MainTex, i.uv - duv.xy);
-    half4 c1 = tex2D(_MainTex, i.uv - duv.wy);
-    half4 c2 = tex2D(_MainTex, i.uv - duv.zy);
-
-    half4 c3 = tex2D(_MainTex, i.uv + duv.zw);
-    half4 c4 = tex2D(_MainTex, i.uv         );
-    half4 c5 = tex2D(_MainTex, i.uv + duv.xw);
-
-    half4 c6 = tex2D(_MainTex, i.uv + duv.zy);
-    half4 c7 = tex2D(_MainTex, i.uv + duv.wy);
-    half4 c8 = tex2D(_MainTex, i.uv + duv.xy);
-
-    half4 acc = c0 * 1 + c1 * 2 + c2 * 1 +
-                c3 * 2 + c4 * 4 + c5 * 2 +
-                c6 * 1 + c7 * 2 + c8 * 1;
-
-    half aa =
-        c0.a * c0.a * 1 + c1.a * c1.a * 2 + c2.a * c2.a * 1 +
-        c3.a * c3.a * 2 + c4.a * c4.a * 4 + c5.a * c5.a * 2 +
-        c6.a * c6.a * 1 + c7.a * c7.a * 2 + c8.a * c8.a * 1;
-
-    half wb = 1.2;
-    half a = (wb * acc.a - aa) / (wb * 16 - acc.a);
-
-    acc /= 16;
-
-    half3 rgb = acc.rgb * (1 + saturate(acc.a - a));
-    return half4(rgb, a);
+    // 9 tap tent filter with 4 bilinear samples
+    const float4 duv = _MainTex_TexelSize.xyxy * float4(0.5, 0.5, -0.5, 0);
+    half4 acc;
+    acc  = DOF_TEX2D(_MainTex, i.uv - duv.xy);
+    acc += DOF_TEX2D(_MainTex, i.uv - duv.zy);
+    acc += DOF_TEX2D(_MainTex, i.uv + duv.zy);
+    acc += DOF_TEX2D(_MainTex, i.uv + duv.xy);
+    return acc / 4.0;
 }
 
 #endif // __DEPTH_OF_FIELD__