C#使用Shader实现夜幕降临倒计时的效果

[RequireComponent(typeof(Camera))] 
public class NightFall : MonoBehaviour 
{ 
public Shader shader; 
public Color nightColor = new Color(0.05f, 0.05f, 0.05f, 0.5f); 
public Vector3 center = Vector3.zero; 
public float radius = 10; 
Camera mCam; 
Matrix4x4 mInverseMVP; 
Material mMat; 
/// The camera we're working with needs depth. 
void OnEnable () 
{ 
mCam = GetComponent<Camera>(); 
mCam.depthTextureMode = DepthTextureMode.Depth; 
if (shader == null) shader = Shader.Find("Image Effects/NightFall"); 
} 
/// Destroy the material when disabled. 
void OnDisable () { if (mMat) DestroyImmediate(mMat); } 
/// Automatically disable the effect if the shaders don't support it. 
void Start () 
{ 
if (!SystemInfo.supportsImageEffects || !shader || !shader.isSupported) 
{ 
enabled = false; 
} 
} 
// Called by camera to apply image effect 
void OnRenderImage (RenderTexture source, RenderTexture destination) 
{ 
print (nightColor); 
print (destination); 
// Calculate the inverse modelview-projection matrix to convert screen coordinates to world coordinates 
mInverseMVP = (mCam.projectionMatrix * mCam.worldToCameraMatrix).inverse; 
if (mMat == null) 
{ 
mMat = new Material(shader); 
mMat.hideFlags = HideFlags.HideAndDontSave; 
} 
Vector4 camPos = mCam.transform.position; 
// This accounts for Anti-aliasing on Windows flipping the depth UV coordinates. 
// Despite the official documentation, the following approach simply doesn't work: 
// http://docs.unity3d.com/Documentation/Components/SL-PlatformDifferences.html 
if (QualitySettings.antiAliasing > 0) 
{ 
RuntimePlatform pl = Application.platform; 
if (pl == RuntimePlatform.WindowsEditor || 
pl == RuntimePlatform.WindowsPlayer || 
pl == RuntimePlatform.WindowsWebPlayer) 
{ 
camPos.w = 1f; 
} 
} 
mMat.SetVector("_CamPos", camPos); 
mMat.SetMatrix("_InverseMVP", mInverseMVP); 
mMat.SetColor("_NightColor", nightColor); 
mMat.SetVector ("_Center", center); 
mMat.SetFloat ("_Radius", radius); 
Graphics.Blit(source, destination, mMat); 
} 
}

Shader "Image Effects/NightFall" 
{ 
Properties 
{ 
_NightColor ("Night Color", Color) = (0.05, 0.05, 0.05, 0.05) 
_Center ("Center", Vector) = (0,0,0,0) 
_Radius ("Radius", float) = 10 
} 
SubShader 
{ 
Pass 
{ 
ZTest Always 
Cull Off 
ZWrite Off 
Fog { Mode off } 
Blend SrcAlpha OneMinusSrcAlpha 
CGPROGRAM 
#pragma vertex vert_img 
#pragma fragment frag vertex:vert 
#pragma fragmentoption ARB_precision_hint_fastest 
#include "UnityCG.cginc" 
sampler2D _CameraDepthTexture; 
uniform float4x4 _InverseMVP; 
uniform float4 _CamPos; 
uniform half4 _NightColor; 
uniform half4 _Center; 
uniform half _Radius; 
struct Input 
{ 
float4 position : POSITION; 
float2 uv : TEXCOORD0; 
}; 
void vert (inout appdata_full v, out Input o) 
{ 
o.position = mul(UNITY_MATRIX_MVP, v.vertex); 
o.uv = v.texcoord.xy; 
} 
float3 CamToWorld (in float2 uv, in float depth) 
{ 
float4 pos = float4(uv.x, uv.y, depth, 1.0); 
pos.xyz = pos.xyz * 2.0 - 1.0; 
pos = mul(_InverseMVP, pos); 
return pos.xyz / pos.w; 
} 
fixed4 frag (Input i) : COLOR 
{ 
#if SHADER_API_D3D9 || SHADER_API_D3D11 
float2 depthUV = i.uv; 
depthUV.y = lerp(depthUV.y, 1.0 - depthUV.y, _CamPos.w); 
float depth = UNITY_SAMPLE_DEPTH(tex2D(_CameraDepthTexture, depthUV)); 
float3 pos = CamToWorld(depthUV, depth); 
#else 
float depth = UNITY_SAMPLE_DEPTH(tex2D(_CameraDepthTexture, i.uv)); 
float3 pos = CamToWorld(i.uv, depth); 
#endif 
// Limit to sea level 
if (pos.y < 0.0) 
{ 
// This is a simplified version of the ray-plane intersection formula: t = -( N.O + d ) / ( N.D ) 
float3 dir = normalize(pos - _CamPos.xyz); 
pos = _CamPos.xyz - dir * (_CamPos.y / dir.y); 
} 
half4 col; 
float dis = length(pos.xz - _Center.xz); 
if (dis < _Radius) 
{ 
col = fixed4(0,0,0,0); 
} 
else 
{ 
col = _NightColor; 
} 
return col; 
} 
ENDCG 
} 
} 
Fallback off 
}