Shader "Hidden/Post FX/Builtin Debug Views"
|
{
|
CGINCLUDE
|
|
#include "UnityCG.cginc"
|
#include "Common.cginc"
|
|
#pragma exclude_renderers d3d11_9x
|
|
sampler2D_float _CameraDepthTexture;
|
sampler2D_float _CameraDepthNormalsTexture;
|
sampler2D_float _CameraMotionVectorsTexture;
|
|
float4 _CameraDepthTexture_ST;
|
float4 _CameraDepthNormalsTexture_ST;
|
float4 _CameraMotionVectorsTexture_ST;
|
|
#if SOURCE_GBUFFER
|
sampler2D _CameraGBufferTexture2;
|
float4 _CameraGBufferTexture2_ST;
|
#endif
|
|
// -----------------------------------------------------------------------------
|
// Depth
|
|
float _DepthScale;
|
|
float4 FragDepth(VaryingsDefault i) : SV_Target
|
{
|
float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, UnityStereoScreenSpaceUVAdjust(i.uv, _CameraDepthTexture_ST));
|
depth = Linear01Depth(depth) * _DepthScale;
|
float3 d = depth.xxx;
|
|
#if !UNITY_COLORSPACE_GAMMA
|
d = GammaToLinearSpace(d);
|
#endif
|
|
return float4(d, 1.0);
|
}
|
|
// -----------------------------------------------------------------------------
|
// Normals
|
|
float3 SampleNormal(float2 uv)
|
{
|
#if SOURCE_GBUFFER
|
float3 norm = tex2D(_CameraGBufferTexture2, uv).xyz * 2.0 - 1.0;
|
return mul((float3x3)unity_WorldToCamera, norm);
|
#else
|
float4 cdn = tex2D(_CameraDepthNormalsTexture, uv);
|
return DecodeViewNormalStereo(cdn) * float3(1.0, 1.0, -1.0);
|
#endif
|
}
|
|
float4 FragNormals(VaryingsDefault i) : SV_Target
|
{
|
float3 n = SampleNormal(UnityStereoScreenSpaceUVAdjust(i.uv, _CameraDepthNormalsTexture_ST));
|
|
#if UNITY_COLORSPACE_GAMMA
|
n = LinearToGammaSpace(n);
|
#endif
|
|
return float4(n, 1.0);
|
}
|
|
// -----------------------------------------------------------------------------
|
// Motion vectors
|
|
float _Opacity;
|
float _Amplitude;
|
float4 _Scale;
|
|
float4 FragMovecsOpacity(VaryingsDefault i) : SV_Target
|
{
|
float4 src = tex2D(_MainTex, i.uv);
|
return float4(src.rgb * _Opacity, src.a);
|
}
|
|
// Convert a motion vector into RGBA color.
|
float4 VectorToColor(float2 mv)
|
{
|
float phi = atan2(mv.x, mv.y);
|
float hue = (phi / UNITY_PI + 1.0) * 0.5;
|
|
float r = abs(hue * 6.0 - 3.0) - 1.0;
|
float g = 2.0 - abs(hue * 6.0 - 2.0);
|
float b = 2.0 - abs(hue * 6.0 - 4.0);
|
float a = length(mv);
|
|
return saturate(float4(r, g, b, a));
|
}
|
|
float4 FragMovecsImaging(VaryingsDefault i) : SV_Target
|
{
|
float4 src = tex2D(_MainTex, i.uv);
|
|
float2 mv = tex2D(_CameraMotionVectorsTexture, i.uv).rg * _Amplitude;
|
|
#if UNITY_UV_STARTS_AT_TOP
|
mv.y *= -1.0;
|
#endif
|
|
float4 mc = VectorToColor(mv);
|
|
float3 rgb = src.rgb;
|
|
#if !UNITY_COLORSPACE_GAMMA
|
rgb = LinearToGammaSpace(rgb);
|
#endif
|
|
rgb = lerp(rgb, mc.rgb, mc.a * _Opacity);
|
|
#if !UNITY_COLORSPACE_GAMMA
|
rgb = GammaToLinearSpace(rgb);
|
#endif
|
|
return float4(rgb, src.a);
|
}
|
|
struct VaryingsArrows
|
{
|
float4 vertex : SV_POSITION;
|
float2 scoord : TEXCOORD;
|
float4 color : COLOR;
|
};
|
|
VaryingsArrows VertArrows(AttributesDefault v)
|
{
|
// Retrieve the motion vector.
|
float4 uv = float4(v.texcoord.xy, 0.0, 0.0);
|
|
#if UNITY_UV_STARTS_AT_TOP
|
uv.y = 1.0 - uv.y;
|
#endif
|
|
float2 mv = tex2Dlod(_CameraMotionVectorsTexture, uv).rg * _Amplitude;
|
|
#if UNITY_UV_STARTS_AT_TOP
|
mv.y *= -1.0;
|
#endif
|
|
// Arrow color
|
float4 color = VectorToColor(mv);
|
|
// Make a rotation matrix based on the motion vector.
|
float2x2 rot = float2x2(mv.y, mv.x, -mv.x, mv.y);
|
|
// Rotate and scale the body of the arrow.
|
float2 pos = mul(rot, v.vertex.zy) * _Scale.xy;
|
|
// Normalized variant of the motion vector and the rotation matrix.
|
float2 mv_n = normalize(mv);
|
float2x2 rot_n = float2x2(mv_n.y, mv_n.x, -mv_n.x, mv_n.y);
|
|
// Rotate and scale the head of the arrow.
|
float2 head = float2(v.vertex.x, -abs(v.vertex.x)) * 0.3;
|
head *= saturate(color.a);
|
pos += mul(rot_n, head) * _Scale.xy;
|
|
// Offset the arrow position.
|
pos += v.texcoord.xy * 2.0 - 1.0;
|
|
// Convert to the screen coordinates.
|
float2 scoord = (pos + 1.0) * 0.5 * _ScreenParams.xy;
|
|
// Snap to a pixel-perfect position.
|
scoord = round(scoord);
|
|
// Bring back to the normalized screen space.
|
pos = (scoord + 0.5) * (_ScreenParams.zw - 1.0) * 2.0 - 1.0;
|
|
// Color tweaks
|
color.rgb = GammaToLinearSpace(lerp(color.rgb, 1.0, 0.5));
|
color.a *= _Opacity;
|
|
// Output
|
VaryingsArrows o;
|
o.vertex = float4(pos, 0.0, 1.0);
|
o.scoord = scoord;
|
o.color = saturate(color);
|
return o;
|
}
|
|
float4 FragMovecsArrows(VaryingsArrows i) : SV_Target
|
{
|
// Pseudo anti-aliasing.
|
float aa = length(frac(i.scoord) - 0.5) / 0.707;
|
aa *= (aa * (aa * 0.305306011 + 0.682171111) + 0.012522878); // gamma
|
return float4(i.color.rgb, i.color.a * aa);
|
}
|
|
ENDCG
|
|
SubShader
|
{
|
Cull Off ZWrite Off ZTest Always
|
|
// (0) - Depth
|
Pass
|
{
|
CGPROGRAM
|
|
#pragma vertex VertDefault
|
#pragma fragment FragDepth
|
|
ENDCG
|
}
|
|
// (1) - Normals
|
Pass
|
{
|
CGPROGRAM
|
|
#pragma vertex VertDefault
|
#pragma fragment FragNormals
|
#pragma multi_compile __ SOURCE_GBUFFER
|
|
ENDCG
|
}
|
|
// (2) - Motion vectors - Opacity
|
Pass
|
{
|
CGPROGRAM
|
|
#pragma vertex VertDefault
|
#pragma fragment FragMovecsOpacity
|
|
ENDCG
|
}
|
|
// (3) - Motion vectors - Imaging
|
Pass
|
{
|
CGPROGRAM
|
|
#pragma vertex VertDefault
|
#pragma fragment FragMovecsImaging
|
#pragma multi_compile __ UNITY_COLORSPACE_GAMMA
|
|
ENDCG
|
}
|
|
// (4) - Motion vectors - Arrows
|
Pass
|
{
|
Blend SrcAlpha OneMinusSrcAlpha
|
|
CGPROGRAM
|
|
#pragma vertex VertArrows
|
#pragma fragment FragMovecsArrows
|
|
ENDCG
|
}
|
}
|
}
|
