Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
DMD3502-Cutscene-JacobTomassi/Cutscene/Assets/LowpolySimpleHouse/PostProcessing/Resources/Shaders/MotionBlur.cginc
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
420 lines (326 sloc)
11.9 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#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__ |