FiE-Game/Assets/PostProcessing/Resources/Shaders/MotionBlur.cginc

#ifndef __MOTION_BLUR__
#define __MOTION_BLUR__

#include "UnityCG.cginc"
#include "Common.cginc"

// Camera depth texture
sampler2D_float _CameraDepthTexture;

// Camera motion vectors texture
sampler2D_half _CameraMotionVectorsTexture;
float4 _CameraMotionVectorsTexture_TexelSize;

// Packed velocity texture (2/10/10/10)
sampler2D_half _VelocityTex;
float2 _VelocityTex_TexelSize;

// NeighborMax texture
sampler2D_half _NeighborMaxTex;
float2 _NeighborMaxTex_TexelSize;

// Velocity scale factor
float _VelocityScale;

// TileMax filter parameters
int _TileMaxLoop;
float2 _TileMaxOffs;

// Maximum blur radius (in pixels)
half _MaxBlurRadius;
float _RcpMaxBlurRadius;

// Filter parameters/coefficients
half _LoopCount;

// History buffer for frame blending
sampler2D _History1LumaTex;
sampler2D _History2LumaTex;
sampler2D _History3LumaTex;
sampler2D _History4LumaTex;

sampler2D _History1ChromaTex;
sampler2D _History2ChromaTex;
sampler2D _History3ChromaTex;
sampler2D _History4ChromaTex;

half _History1Weight;
half _History2Weight;
half _History3Weight;
half _History4Weight;

struct VaryingsMultitex
{
    float4 pos : SV_POSITION;
    float2 uv0 : TEXCOORD0;
    float2 uv1 : TEXCOORD1;
};

VaryingsMultitex VertMultitex(AttributesDefault v)
{
    VaryingsMultitex o;
    o.pos = UnityObjectToClipPos(v.vertex);
    o.uv0 = v.texcoord.xy;
    o.uv1 = v.texcoord.xy;

#if UNITY_UV_STARTS_AT_TOP
    if (_MainTex_TexelSize.y < 0.0)
        o.uv1.y = 1.0 - v.texcoord.y;
#endif

    return o;
}

// -----------------------------------------------------------------------------
// Prefilter

// Velocity texture setup
half4 FragVelocitySetup(VaryingsDefault i) : SV_Target
{
    // Sample the motion vector.
    float2 v = tex2D(_CameraMotionVectorsTexture, i.uv).rg;

    // Apply the exposure time and convert to the pixel space.
    v *= (_VelocityScale * 0.5) * _CameraMotionVectorsTexture_TexelSize.zw;

    // Clamp the vector with the maximum blur radius.
    v /= max(1.0, length(v) * _RcpMaxBlurRadius);

    // Sample the depth of the pixel.
    half d = LinearizeDepth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv));

    // Pack into 10/10/10/2 format.
    return half4((v * _RcpMaxBlurRadius + 1.0) * 0.5, d, 0.0);
}

// TileMax filter (2 pixel width with normalization)
half4 FragTileMax1(VaryingsDefault i) : SV_Target
{
    float4 d = _MainTex_TexelSize.xyxy * float4(-0.5, -0.5, 0.5, 0.5);

    half2 v1 = tex2D(_MainTex, i.uv + d.xy).rg;
    half2 v2 = tex2D(_MainTex, i.uv + d.zy).rg;
    half2 v3 = tex2D(_MainTex, i.uv + d.xw).rg;
    half2 v4 = tex2D(_MainTex, i.uv + d.zw).rg;

    v1 = (v1 * 2.0 - 1.0) * _MaxBlurRadius;
    v2 = (v2 * 2.0 - 1.0) * _MaxBlurRadius;
    v3 = (v3 * 2.0 - 1.0) * _MaxBlurRadius;
    v4 = (v4 * 2.0 - 1.0) * _MaxBlurRadius;

    return half4(MaxV(MaxV(MaxV(v1, v2), v3), v4), 0.0, 0.0);
}

// TileMax filter (2 pixel width)
half4 FragTileMax2(VaryingsDefault i) : SV_Target
{
    float4 d = _MainTex_TexelSize.xyxy * float4(-0.5, -0.5, 0.5, 0.5);

    half2 v1 = tex2D(_MainTex, i.uv + d.xy).rg;
    half2 v2 = tex2D(_MainTex, i.uv + d.zy).rg;
    half2 v3 = tex2D(_MainTex, i.uv + d.xw).rg;
    half2 v4 = tex2D(_MainTex, i.uv + d.zw).rg;

    return half4(MaxV(MaxV(MaxV(v1, v2), v3), v4), 0.0, 0.0);
}

// TileMax filter (variable width)
half4 FragTileMaxV(VaryingsDefault i) : SV_Target
{
    float2 uv0 = i.uv + _MainTex_TexelSize.xy * _TileMaxOffs.xy;

    float2 du = float2(_MainTex_TexelSize.x, 0.0);
    float2 dv = float2(0, _MainTex_TexelSize.y);

    half2 vo = 0;

    UNITY_LOOP
    for (int ix = 0; ix < _TileMaxLoop; ix++)
    {
        UNITY_LOOP
        for (int iy = 0; iy < _TileMaxLoop; iy++)
        {
            float2 uv = uv0 + du * ix + dv * iy;
            vo = MaxV(vo, tex2D(_MainTex, uv).rg);
        }
    }

    return half4(vo, 0.0, 0.0);
}

// NeighborMax filter
half4 FragNeighborMax(VaryingsDefault i) : SV_Target
{
    const half cw = 1.01; // Center weight tweak

    float4 d = _MainTex_TexelSize.xyxy * float4(1.0, 1.0, -1.0, 0.0);

    half2 v1 = tex2D(_MainTex, i.uv - d.xy).rg;
    half2 v2 = tex2D(_MainTex, i.uv - d.wy).rg;
    half2 v3 = tex2D(_MainTex, i.uv - d.zy).rg;

    half2 v4 = tex2D(_MainTex, i.uv - d.xw).rg;
    half2 v5 = tex2D(_MainTex, i.uv).rg * cw;
    half2 v6 = tex2D(_MainTex, i.uv + d.xw).rg;

    half2 v7 = tex2D(_MainTex, i.uv + d.zy).rg;
    half2 v8 = tex2D(_MainTex, i.uv + d.wy).rg;
    half2 v9 = tex2D(_MainTex, i.uv + d.xy).rg;

    half2 va = MaxV(v1, MaxV(v2, v3));
    half2 vb = MaxV(v4, MaxV(v5, v6));
    half2 vc = MaxV(v7, MaxV(v8, v9));

    return half4(MaxV(va, MaxV(vb, vc)) * (1.0 / cw), 0.0, 0.0);
}

// -----------------------------------------------------------------------------
// Reconstruction

// Returns true or false with a given interval.
bool Interval(half phase, half interval)
{
    return frac(phase / interval) > 0.499;
}

// Jitter function for tile lookup
float2 JitterTile(float2 uv)
{
    float rx, ry;
    sincos(GradientNoise(uv + float2(2.0, 0.0)) * UNITY_PI_2, ry, rx);
    return float2(rx, ry) * _NeighborMaxTex_TexelSize.xy * 0.25;
}

// Velocity sampling function
half3 SampleVelocity(float2 uv)
{
    half3 v = tex2Dlod(_VelocityTex, float4(uv, 0.0, 0.0)).xyz;
    return half3((v.xy * 2.0 - 1.0) * _MaxBlurRadius, v.z);
}

// Reconstruction filter
half4 FragReconstruction(VaryingsMultitex i) : SV_Target
{
    // Color sample at the center point
    const half4 c_p = tex2D(_MainTex, i.uv0);

    // Velocity/Depth sample at the center point
    const half3 vd_p = SampleVelocity(i.uv1);
    const half l_v_p = max(length(vd_p.xy), 0.5);
    const half rcp_d_p = 1.0 / vd_p.z;

    // NeighborMax vector sample at the center point
    const half2 v_max = tex2D(_NeighborMaxTex, i.uv1 + JitterTile(i.uv1)).xy;
    const half l_v_max = length(v_max);
    const half rcp_l_v_max = 1.0 / l_v_max;

    // Escape early if the NeighborMax vector is small enough.
    if (l_v_max < 2.0) return c_p;

    // Use V_p as a secondary sampling direction except when it's too small
    // compared to V_max. This vector is rescaled to be the length of V_max.
    const half2 v_alt = (l_v_p * 2.0 > l_v_max) ? vd_p.xy * (l_v_max / l_v_p) : v_max;

    // Determine the sample count.
    const half sc = floor(min(_LoopCount, l_v_max * 0.5));

    // Loop variables (starts from the outermost sample)
    const half dt = 1.0 / sc;
    const half t_offs = (GradientNoise(i.uv0) - 0.5) * dt;
    half t = 1.0 - dt * 0.5;
    half count = 0.0;

    // Background velocity
    // This is used for tracking the maximum velocity in the background layer.
    half l_v_bg = max(l_v_p, 1.0);

    // Color accumlation
    half4 acc = 0.0;

    UNITY_LOOP while (t > dt * 0.25)
    {
        // Sampling direction (switched per every two samples)
        const half2 v_s = Interval(count, 4.0) ? v_alt : v_max;

        // Sample position (inverted per every sample)
        const half t_s = (Interval(count, 2.0) ? -t : t) + t_offs;

        // Distance to the sample position
        const half l_t = l_v_max * abs(t_s);

        // UVs for the sample position
        const float2 uv0 = i.uv0 + v_s * t_s * _MainTex_TexelSize.xy;
        const float2 uv1 = i.uv1 + v_s * t_s * _VelocityTex_TexelSize.xy;

        // Color sample
        const half3 c = tex2Dlod(_MainTex, float4(uv0, 0.0, 0.0)).rgb;

        // Velocity/Depth sample
        const half3 vd = SampleVelocity(uv1);

        // Background/Foreground separation
        const half fg = saturate((vd_p.z - vd.z) * 20.0 * rcp_d_p);

        // Length of the velocity vector
        const half l_v = lerp(l_v_bg, length(vd.xy), fg);

        // Sample weight
        // (Distance test) * (Spreading out by motion) * (Triangular window)
        const half w = saturate(l_v - l_t) / l_v * (1.2 - t);

        // Color accumulation
        acc += half4(c, 1.0) * w;

        // Update the background velocity.
        l_v_bg = max(l_v_bg, l_v);

        // Advance to the next sample.
        t = Interval(count, 2.0) ? t - dt : t;
        count += 1.0;
    }

    // Add the center sample.
    acc += half4(c_p.rgb, 1.0) * (1.2 / (l_v_bg * sc * 2.0));

    return half4(acc.rgb / acc.a, c_p.a);
}

// -----------------------------------------------------------------------------
// Frame blending

VaryingsDefault VertFrameCompress(AttributesDefault v)
{
    VaryingsDefault o;
    o.pos = v.vertex;
    o.uvSPR = 0;
#if UNITY_UV_STARTS_AT_TOP
    o.uv = v.texcoord * float2(1.0, -1.0) + float2(0.0, 1.0);
#else
    o.uv = v.texcoord;
#endif
    return o;
}

#if !SHADER_API_GLES

// MRT output struct for the compressor
struct CompressorOutput
{
    half4 luma   : SV_Target0;
    half4 chroma : SV_Target1;
};

// Frame compression fragment shader
CompressorOutput FragFrameCompress(VaryingsDefault i)
{
    float sw = _ScreenParams.x;     // Screen width
    float pw = _ScreenParams.z - 1; // Pixel width

    // RGB to YCbCr convertion matrix
    const half3 kY  = half3( 0.299   ,  0.587   ,  0.114   );
    const half3 kCB = half3(-0.168736, -0.331264,  0.5     );
    const half3 kCR = half3( 0.5     , -0.418688, -0.081312);

    // 0: even column, 1: odd column
    half odd = frac(i.uv.x * sw * 0.5) > 0.5;

    // Calculate UV for chroma componetns.
    // It's between the even and odd columns.
    float2 uv_c = i.uv.xy;
    uv_c.x = (floor(uv_c.x * sw * 0.5) * 2.0 + 1.0) * pw;

    // Sample the source texture.
    half3 rgb_y = tex2D(_MainTex, i.uv).rgb;
    half3 rgb_c = tex2D(_MainTex, uv_c).rgb;

    #if !UNITY_COLORSPACE_GAMMA
    rgb_y = LinearToGammaSpace(rgb_y);
    rgb_c = LinearToGammaSpace(rgb_c);
    #endif

    // Convertion and subsampling
    CompressorOutput o;
    o.luma = dot(kY, rgb_y);
    o.chroma = dot(lerp(kCB, kCR, odd), rgb_c) + 0.5;
    return o;
}

#else

// MRT might not be supported. Replace it with a null shader.
half4 FragFrameCompress(VaryingsDefault i) : SV_Target
{
    return 0;
}

#endif

// Sample luma-chroma textures and convert to RGB
half3 DecodeHistory(float2 uvLuma, float2 uvCb, float2 uvCr, sampler2D lumaTex, sampler2D chromaTex)
{
    half y = tex2D(lumaTex, uvLuma).r;
    half cb = tex2D(chromaTex, uvCb).r - 0.5;
    half cr = tex2D(chromaTex, uvCr).r - 0.5;
    return y + half3(1.402 * cr, -0.34414 * cb - 0.71414 * cr, 1.772 * cb);
}

// Frame blending fragment shader
half4 FragFrameBlending(VaryingsMultitex i) : SV_Target
{
    float sw = _MainTex_TexelSize.z; // Texture width
    float pw = _MainTex_TexelSize.x; // Texel width

    // UV for luma
    float2 uvLuma = i.uv1;

    // UV for Cb (even columns)
    float2 uvCb = i.uv1;
    uvCb.x = (floor(uvCb.x * sw * 0.5) * 2.0 + 0.5) * pw;

    // UV for Cr (even columns)
    float2 uvCr = uvCb;
    uvCr.x += pw;

    // Sample from the source image
    half4 src = tex2D(_MainTex, i.uv0);

    // Sampling and blending
    #if UNITY_COLORSPACE_GAMMA
    half3 acc = src.rgb;
    #else
    half3 acc = LinearToGammaSpace(src.rgb);
    #endif

    acc += DecodeHistory(uvLuma, uvCb, uvCr, _History1LumaTex, _History1ChromaTex) * _History1Weight;
    acc += DecodeHistory(uvLuma, uvCb, uvCr, _History2LumaTex, _History2ChromaTex) * _History2Weight;
    acc += DecodeHistory(uvLuma, uvCb, uvCr, _History3LumaTex, _History3ChromaTex) * _History3Weight;
    acc += DecodeHistory(uvLuma, uvCb, uvCr, _History4LumaTex, _History4ChromaTex) * _History4Weight;
    acc /= 1.0 + _History1Weight + _History2Weight +_History3Weight +_History4Weight;

    #if !UNITY_COLORSPACE_GAMMA
    acc = GammaToLinearSpace(acc);
    #endif

    return half4(acc, src.a);
}

// Frame blending fragment shader (without chroma subsampling)
half4 FragFrameBlendingRaw(VaryingsMultitex i) : SV_Target
{
    half4 src = tex2D(_MainTex, i.uv0);
    half3 acc = src.rgb;
    acc += tex2D(_History1LumaTex, i.uv0) * _History1Weight;
    acc += tex2D(_History2LumaTex, i.uv0) * _History2Weight;
    acc += tex2D(_History3LumaTex, i.uv0) * _History3Weight;
    acc += tex2D(_History4LumaTex, i.uv0) * _History4Weight;
    acc /= 1.0 + _History1Weight + _History2Weight +_History3Weight +_History4Weight;
    return half4(acc, src.a);
}

#endif // __MOTION_BLUR__