Initial

UnityProject/Assets/!ext/PostProcessing/Resources/Shaders/TAA.cginc

@@ -0,0 +1,206 @@
+#ifndef __TAA__
+#define __TAA__
+
+#pragma only_renderers ps4 xboxone d3d11 d3d9 xbox360 opengl glcore
+#pragma exclude_renderers gles
+
+#include "UnityCG.cginc"
+#include "Common.cginc"
+
+// -----------------------------------------------------------------------------
+// Solver
+
+#define TAA_USE_STABLE_BUT_GHOSTY_VARIANT 0
+
+#if !defined(TAA_DILATE_MOTION_VECTOR_SAMPLE)
+    #define TAA_DILATE_MOTION_VECTOR_SAMPLE 1
+#endif
+
+#define TAA_FRAGMENT_MOTION_HISTORY_DECAY 0.85
+
+#define TAA_FINAL_BLEND_STATIC_FACTOR _FinalBlendParameters.x
+#define TAA_FINAL_BLEND_DYNAMIC_FACTOR _FinalBlendParameters.y
+#define TAA_MOTION_AMPLIFICATION _FinalBlendParameters.z
+
+struct VaryingsSolver
+{
+    float4 vertex : SV_POSITION;
+    float4 uv : TEXCOORD0; // [xy: _MainTex.uv, zw: _HistoryTex.uv]
+};
+
+struct OutputSolver
+{
+    float4 destination : SV_Target0;
+    float4 history : SV_Target1;
+};
+
+sampler2D _HistoryTex;
+
+sampler2D _CameraMotionVectorsTexture;
+sampler2D _CameraDepthTexture;
+
+float4 _HistoryTex_TexelSize;
+float4 _CameraDepthTexture_TexelSize;
+
+float2 _Jitter;
+float4 _SharpenParameters;
+float4 _FinalBlendParameters;
+
+VaryingsSolver VertSolver(AttributesDefault input)
+{
+    VaryingsSolver output;
+
+    float4 vertex = UnityObjectToClipPos(input.vertex);
+
+    output.vertex = vertex;
+    output.uv = input.texcoord.xyxy;
+
+#if UNITY_UV_STARTS_AT_TOP
+    if (_MainTex_TexelSize.y < 0)
+        output.uv.y = 1.0 - input.texcoord.y;
+#endif
+
+    return output;
+}
+
+float2 GetClosestFragment(float2 uv)
+{
+    const float2 k = _CameraDepthTexture_TexelSize.xy;
+    const float4 neighborhood = float4(
+        SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv - k),
+        SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv + float2(k.x, -k.y)),
+        SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv + float2(-k.x, k.y)),
+        SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv + k)
+        );
+
+#if defined(UNITY_REVERSED_Z)
+    #define COMPARE_DEPTH(a, b) step(b, a)
+#else
+    #define COMPARE_DEPTH(a, b) step(a, b)
+#endif
+
+    float3 result = float3(0.0, 0.0, SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv));
+    result = lerp(result, float3(-1.0, -1.0, neighborhood.x), COMPARE_DEPTH(neighborhood.x, result.z));
+    result = lerp(result, float3( 1.0, -1.0, neighborhood.y), COMPARE_DEPTH(neighborhood.y, result.z));
+    result = lerp(result, float3(-1.0,  1.0, neighborhood.z), COMPARE_DEPTH(neighborhood.z, result.z));
+    result = lerp(result, float3( 1.0,  1.0, neighborhood.w), COMPARE_DEPTH(neighborhood.w, result.z));
+
+    return (uv + result.xy * k);
+}
+
+// Adapted from Playdead's TAA implementation
+// https://github.com/playdeadgames/temporal
+float4 ClipToAABB(float4 color, float p, float3 minimum, float3 maximum)
+{
+    // note: only clips towards aabb center (but fast!)
+    float3 center  = 0.5 * (maximum + minimum);
+    float3 extents = 0.5 * (maximum - minimum);
+
+    // This is actually `distance`, however the keyword is reserved
+    float4 offset = color - float4(center, p);
+    float3 repeat = abs(offset.xyz / extents);
+
+    repeat.x = max(repeat.x, max(repeat.y, repeat.z));
+
+    if (repeat.x > 1.0)
+    {
+        // `color` is not intersecting (nor inside) the AABB; it's clipped to the closest extent
+        return float4(center, p) + offset / repeat.x;
+    }
+    else
+    {
+        // `color` is intersecting (or inside) the AABB.
+
+        // Note: for whatever reason moving this return statement from this else into a higher
+        // scope makes the NVIDIA drivers go beyond bonkers
+        return color;
+    }
+}
+
+OutputSolver FragSolver(VaryingsSolver input)
+{
+#if TAA_DILATE_MOTION_VECTOR_SAMPLE
+    float2 motion = tex2D(_CameraMotionVectorsTexture, GetClosestFragment(input.uv.zw)).xy;
+#else
+    // Don't dilate in ortho !
+    float2 motion = tex2D(_CameraMotionVectorsTexture, input.uv.zw).xy;
+#endif
+
+    const float2 k = _MainTex_TexelSize.xy;
+    float2 uv = input.uv.xy;
+
+#if UNITY_UV_STARTS_AT_TOP
+    uv -= _MainTex_TexelSize.y < 0 ? _Jitter * float2(1.0, -1.0) : _Jitter;
+#else
+    uv -= _Jitter;
+#endif
+
+    float4 color = tex2D(_MainTex, uv);
+
+    float4 topLeft = tex2D(_MainTex, uv - k * 0.5);
+    float4 bottomRight = tex2D(_MainTex, uv + k * 0.5);
+
+    float4 corners = 4.0 * (topLeft + bottomRight) - 2.0 * color;
+
+    // Sharpen output
+    color += (color - (corners * 0.166667)) * 2.718282 * _SharpenParameters.x;
+    color = max(0.0, color);
+
+    // Tonemap color and history samples
+    float4 average = FastToneMap((corners + color) * 0.142857);
+
+    topLeft = FastToneMap(topLeft);
+    bottomRight = FastToneMap(bottomRight);
+
+    color = FastToneMap(color);
+
+    float4 history = tex2D(_HistoryTex, input.uv.zw - motion);
+
+// Only use this variant for arch viz or scenes that don't have any animated objects (camera animation is fine)
+#if TAA_USE_STABLE_BUT_GHOSTY_VARIANT
+    float4 luma = float4(Luminance(topLeft.rgb), Luminance(bottomRight.rgb), Luminance(average.rgb), Luminance(color.rgb));
+    float nudge = lerp(6.28318530718, 0.5, saturate(2.0 * history.a)) * max(abs(luma.z - luma.w), abs(luma.x - luma.y));
+
+    float4 minimum = lerp(bottomRight, topLeft, step(luma.x, luma.y)) - nudge;
+    float4 maximum = lerp(topLeft, bottomRight, step(luma.x, luma.y)) + nudge;
+#else
+    float2 luma = float2(Luminance(average.rgb), Luminance(color.rgb));
+    float nudge = 4.0 * abs(luma.x - luma.y);
+
+    float4 minimum = min(bottomRight, topLeft) - nudge;
+    float4 maximum = max(topLeft, bottomRight) + nudge;
+#endif
+
+    history = FastToneMap(history);
+
+    // Clip history samples
+    history = ClipToAABB(history, history.a, minimum.xyz, maximum.xyz);
+
+    // Store fragment motion history
+    color.a = saturate(smoothstep(0.002 * _MainTex_TexelSize.z, 0.0035 * _MainTex_TexelSize.z, length(motion)));
+
+    // Blend method
+    float weight = clamp(lerp(TAA_FINAL_BLEND_STATIC_FACTOR, TAA_FINAL_BLEND_DYNAMIC_FACTOR,
+        length(motion) * TAA_MOTION_AMPLIFICATION), TAA_FINAL_BLEND_DYNAMIC_FACTOR, TAA_FINAL_BLEND_STATIC_FACTOR);
+
+    color = FastToneUnmap(lerp(color, history, weight));
+
+    OutputSolver output;
+
+    output.destination = color;
+    color.a *= TAA_FRAGMENT_MOTION_HISTORY_DECAY;
+
+    output.history = color;
+
+    return output;
+}
+
+// -----------------------------------------------------------------------------
+// Alpha clearance
+
+float4 FragAlphaClear(VaryingsDefault input) : SV_Target
+{
+    return float4(tex2D(_MainTex, input.uv).rgb, 0.0);
+}
+
+#endif // __TAA__