Unity Shader 代码模板

2022-09-03

Shader Lab

在Unity中，所有的Unity Shader都是使用ShaderLab来编写的。
Shader Lab是Unity提供编写Unity Shader的一种说明性语言，使用嵌套在花括号内部的语义来描述Unity Shader文件的结构。

基础模板1【BlingPhong+Half Lambert】

Shader "Path/Name" {

Properties{
	_Diffuse("DiffuseColor",Color)=(1,1,1,1)
	_Specular("SpecualrColor",Color)=(1,1,1,1)
	_Gloss("Gloss",Range(8.0,256))=20
}

	SubShader{
	Pass{
	Tags{"LightMode" = "ForwardBase"}//关照模式:前向渲染

	CGPROGRAM
	#pragma vertex vert
	#pragma fragment frag
	#include "Lighting.cginc"

	//定义与属性相同类型和相同名称的变量
	fixed4 _Diffuse;
	fixed4 _Specular;
	float _Gloss;

	//定义顶点着色器输入结构体
struct a2v {
	float4 vertex:POSITION;
	float3 normal:NORMAL;
};
	//定义顶点着色器输出结构体（片元着色器输入结构体）
struct v2f {
	float4 pos:SV_POSITION;
    float3 worldNormal:TEXCOORD0;
    fixed3 color : COLOR;
};

v2f vert(a2v v) {
	v2f o;
	o.pos = UnityObjectToClipPos(v.vertex);
    //世界空间的法向方向（逆矩阵）
    o.worldNormal =mul(v.normal,_World2Object);
    //世界空间下的观察方向
    o.viewDir = normalize(_WorldSpaceCameraPos.xyz-mul(unity_ObjectToWorld,v.vertex).xyz);
	return o;
}

fixed4 frag(v2f i) :SV_Target{
    //通过内置变量得到环境光部分
	fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;

	fixed3 worldNormal = normalize(i.worldNormal);
    //得到世界空间内的光线方向
	fixed3 worldLight = normalize(_WorldSpaceLightPos0);
    //半兰伯特计算
    fixed3 diffuse = _LightColor0.rgb*_Diffuse.rgb*(dot(worldNormal, worldLight)*0.5 + 0.5);  
    //Blinn-Phong计算
    fixed3 halfDir = normalize(worldLightDir+i.viewDir);//Phong：fixed3 reflectDir = normalize(reflect(-worldLightDir, worldNormal));
	//计算高光反射部分
    fixed3 specular = _LightColor0.rgb*_Specular.rgb*pow(saturate(dot(halfDir, worldNormal)), _Gloss);

	return fixed4(ambient+diffuse+specular,1.0);
}

	ENDCG
}
	
}

Fallback"Diffuse"
}

基础模板2【法线纹理】

Shader "Path/Name" {
Properties{
	_Color("Color",Color)=(1,1,1,1)
	_MainTex("MainTex",2D) ="white" {}
	_BumpTex("Noraml Tex",2D) = "bump"{} //bump为Unity自带的法线纹理，当没有提供任何法线时，"bump"就对应模型自身的法线信息
	_BumpScale("BumpScal",Float) = 1.0  //BumpScale代表凹凸程度，值为0时，表示该法线纹理不会对光照产生任何影响
	_Specular("Specular",Color) = (1,1,1,1)
	_Gloss("Gloss",Range(8.0,256)) = 20
}
	SubShader{
		Pass{
			Tags{"LightMode" = "ForwardBase"}

			CGPROGRAM

			#pragma vertex vert
			#pragma fragment frag
			#include "Lighting.cginc"

			fixed4 _Color;
			sampler2D _MainTex;
			float4 _MainTex_ST;
			sampler2D _BumpTex;
			float4 _BumpTex_ST;
			float _BumpScale;
			fixed4 _Specular;
			float _Gloss;  

			struct a2v {
				float4 vertex:POSITION;
				float3 normal:NORMAL;
				float4 tangent:TANGENT;   //tangent存储顶点的切线方向，float4类型，通过tangent.w分量决定副切线的方向性
				float4 texcoord:TEXCOORD0;
			};

			struct v2f {
				float4 pos:SV_POSITION;
				float4 uv:TEXCOORD0;
				float3 lightDir:TEXCOORD1;
				float3 viewDir:TEXCOORD2;
			};

			v2f vert(a2v v) {
				v2f o;
				o.pos = UnityObjectToClipPos(v.vertex);
				o.uv.xy = v.texcoord.xy*_MainTex_ST.xy + _MainTex_ST.zw;//(uv.xy存储主纹理坐标变换后的uv坐标)
				o.uv.zw = v.texcoord.xy*_BumpTex_ST.xy + _BumpTex_ST.zw;//(uv.zw存储法线纹理坐标变换后的uv坐标)
				//_MainTex和_BumpTex通常会使用同一组纹理坐标（法线纹理贴图由对应纹理贴图生成） 

				float3 binormal = cross(normalize(v.normal),normalize(v.tangent.xyz))*v.tangent.w;
				float3x3 rotation = float3x3(v.tangent.xyz, binormal,v.normal);
				//(按行填充，得到的矩阵实际上是模型到切线的逆矩阵的转置矩阵，也就是模型到切线的转换矩阵(正交矩阵))
				//也可以使用内建宏TANGENT_SPACE_ROTATION得到变换矩阵 

				o.lightDir = mul(rotation, ObjSpaceLightDir(v.vertex)).xyz;
				o.viewDir = mul(rotation,ObjSpaceViewDir(v.vertex)).xyz;

				return o;
			} 

			fixed4 frag(v2f i):SV_TARGET {
				fixed3  tangentLightDir = normalize(i.lightDir);
				fixed3 tangentViewDir = normalize(i.viewDir);  

				fixed4 packedNormal = tex2D(_BumpTex,i.uv.zw);  //对法线纹理进行采样
				fixed3 tangentNormal;
			    //若法线纹理类型没有被设置为bump类型，则进行手动反映射
				//tangentNormal=(packedNormal.xyz*2-1);
				//若已经设置为bump类型，可以使用内建函数
				tangentNormal = UnpackNormal(packedNormal);
				tangentNormal.xy *= _BumpScale;
				tangentNormal.z = sqrt(1.0-saturate(dot(tangentNormal.xy,tangentNormal.xy)));

				fixed3 albedo = _Color.rgb*tex2D(_MainTex,i.uv.xy);
				fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz*albedo;
				fixed3 diffuse = _LightColor0.rgb*albedo*max(0,dot(tangentNormal,tangentLightDir));
				fixed3 halfDir = normalize(tangentLightDir+tangentViewDir);
				fixed3 specular = _LightColor0.rgb*_Specular.rgb*pow(max(0,dot(tangentNormal,halfDir)),_Gloss);

				return fixed4(ambient+diffuse+specular,1.0);
			}
		ENDCG
	}
	}
		FallBack "Specular"
}

基础模板3【透明效果】

Shader "Path/Name" {
Properties{
	_Color("Color",Color)=(1,1,1,1)
	_MainTex("MainTex",2D)="white"{}
	_Cutoff("Alpha Cutoff",Range(0,1))=0.5  //在材质面板显示和调节透明度测试的控制阈值
    _AlphaScale("AlphaScale",Range(0,1))=1
}
SubShader{
    //通常，使用透明度测试的Shader都应该在SubShader中设置这三个标签
	Tags{"Queue"="AlphaTest" "IgnoreProjector"="True" "RenderType"="TransparentCutout"}
	
    //开启深度写入的Pass是为了将模型的深度信息写入深度缓冲中，从而剔除模型中被自身遮挡的片元
	Pass{
		ZWrite On
		ColorMask 0
	}
    //--------------------------------------------------------------------------------
	Pass{
		Tags{"LightMode"="ForwardBase"}

        //----AlphaBlend----
        Zwrite Off  //关闭深度写入
        Blend SrcAlpha OneMinusSrcAlpha  //设置混合因子为源的透明度
        Cull | Back | Front | Off        //开启双面渲染效果，需要两个Pass，一后一前
        //------------------

		CGPROGRAM
		#pragma vertex vert
		#pragma fragment frag
		#include "Lighting.cginc"

		fixed4 _Color;
		sampler2D _MainTex;
		float4 _MainTex_ST;
		fixed _Cutoff;
        fixed  _AlphaScale;

		struct a2v{
			float4 vertex:POSITION;
			float3 normal:NORMAL;
			float4 texcoord:TEXCOORD0;
		};

		struct v2f{
			float4 pos:SV_POSITION;
			float3 worldNormal:TEXCOORD0;
			float3 worldPos:TEXCOORD1;
			float2 uv:TEXCOORD2;
		};

		v2f vert(a2v v){
            //裁剪空间顶点、世界法线、世界顶点、UV
			v2f o;
			o.pos=UnityObjectToClipPos(v.vertex);
			o.worldNormal=UnityObjectToWorldNormal(v.normal);
			o.worldPos=mul(unity_ObjectToWorld,v.vertex).xyz;
			o.uv=TRANSFORM_TEX(v.texcoord,_MainTex);

			return o;
		}

		fixed4 frag(v2f i):SV_Target{
			fixed3 worldNormal=normalize(i.worldNormal);
			fixed3 worldLightDir=normalize(UnityWorldSpaceLightDir(i.worldPos));
            //UV采样
			fixed4 texColor=tex2D(_MainTex,i.uv);
            
            //--------Alpha Test---------
			clip(texColor.a-_Cutoff);
            //---------------------------

			fixed3 albedo=texColor.rgb*_Color;

			fixed3 ambient=UNITY_LIGHTMODEL_AMBIENT.xyz*albedo;
			fixed3 diffuse=_LightColor0.rgb*albedo*max(0,dot(worldNormal,worldLightDir));

            //--------Alpha Test---------
			return fixed4(ambient+diffuse,1.0);
            //--------AlphaBlend---------
            return fixed4(ambient+diffuse,texColor.a*_AlphaScale);

		}
		ENDCG
	}
}
FallBack "Diffuse"
}

基础模板4【剔除描边】

Shader "Path/Name" {
Properties{
	_Color("Color",Color)=(1,1,1,1)
	_EdgeColor("EdgeColor",Color)=(1,1,1,1)
	_EdgeFactor("EdgeFactor",Range(0,6))=3
	_MainTex("MainTex",2D)="white"{}
}
SubShader{

	Pass{
		Tags{"LightMode"="ForwardBase"}		
		CGPROGRAM	
		#pragma vertex vert
		#pragma fragment frag
		#include "Lighting.cginc"  

		fixed4 _Color;
		sampler2D _MainTex;
		float4 _MainTex_ST;

		struct a2v{
			float4 vertex:POSITION;
			float3 normal:NORMAL;
			float4 texcoord:TEXCOORD0;
		};
		struct v2f{
			float4 pos:SV_POSITION;
			float2 uv:TEXCOORD0;
			float3 worldNormal:TEXCOORD1;
			float4 worldPos:TEXCOORD2;
		};

		v2f vert(a2v v){
			v2f o;
			o.pos=UnityObjectToClipPos(v.vertex);
			o.uv=TRANSFORM_TEX(v.texcoord,_MainTex);
			o.worldPos=mul(unity_ObjectToWorld,v.vertex);
			o.worldNormal=UnityObjectToWorldNormal(v.normal);

			return o;
		}

		fixed4 frag(v2f i):SV_Target{
			fixed3 worldNormal=normalize(i.worldNormal);
			fixed3 worldLightDir=normalize(UnityWorldSpaceLightDir(i.pos));

			fixed3 albedo=tex2D(_MainTex,i.uv).rgb*_Color.rgb;
			fixed3 ambient=UNITY_LIGHTMODEL_AMBIENT.xyz*albedo;
			fixed3 diffuse=(_LightColor0.rgb)*albedo*max(0,dot(worldNormal,worldLightDir));

			return fixed4(ambient+diffuse,1.0);
		}
		ENDCG
	}

	Pass{
		Tags{"LightMode"="ForwardBase"}		
		Cull Front   //剔除正面

		CGPROGRAM	
		#pragma vertex vert
		#pragma fragment frag
		#include "UnityCG.cginc"  

		fixed4 _EdgeColor;
		float   _EdgeFactor;

		float4 vert(appdata_base v):SV_POSITION{
	
			float4 pos=UnityObjectToClipPos(v.vertex);
			//将法线转换到裁剪空间
			float3 clipNormal=mul((float3x3)UNITY_MATRIX_MVP,v.normal);
			//裁剪空间定点朝法线方向进行移动
			pos.xy+=_EdgeFactor*clipNormal.xy;

			return pos;
		}

		fixed4 frag():SV_Target{	
			return _EdgeColor;
		}
		ENDCG
	}
}
FallBack "Diffuse"
}

基础模板5【前向渲染】

Shader "Custom/Chapter9_ForwardRendering" {
Properties{
	_Color("Color",Color)=(1,1,1,1)
	_SpecularColor("SpecularColor",Color)=(1,1,1,1)
	_Gloss("Gloss",Range(8.0,256))=20
}
SubShader{
	Pass{
		Tags{"LightMode"="ForwardBase"}
		CGPROGRAM
			#pragma multi_compile_fwdbase
			//#pragma multi_compile_fwdbase指令保证Shader中使用光照衰减变量可以被正确赋值
			#pragma vertex vert
			#pragma fragment frag 
			
			#include "Lighting.cginc"
			
			fixed4 _Color;
			fixed4 _SpecularColor;
			float   _Gloss;

			struct a2v{
				float4 vertex:POSITION;
				float3 normal:NORMAL;
			};
			struct v2f{
				float4 pos:SV_POSITION;
				float3 worldPos:TEXCOORD0;
				float3 worldNormal:TEXCOORD1;
			};

			v2f vert(a2v v){
				v2f o;
				o.pos=UnityObjectToClipPos(v.vertex);
				o.worldPos=mul(unity_ObjectToWorld,v.vertex).xyz;
				o.worldNormal=UnityObjectToWorldNormal(v.normal);

				return o;
			}

			fixed4 frag(v2f i):SV_Target{
				fixed3 worldLightDir=normalize(UnityWorldSpaceLightDir(i.worldPos));
				fixed3 worldNormal=normalize(i.worldNormal);
				fixed3 worldViewDir=normalize(UnityWorldSpaceViewDir(i.worldPos));

				fixed3 ambient=UNITY_LIGHTMODEL_AMBIENT.xyz;
				fixed3 diffuse=_LightColor0.rgb*_Color.rgb*max(0,dot(worldNormal,worldLightDir));
				fixed3 halfDir=normalize(worldViewDir+worldLightDir);
				fixed3 specularColor=_LightColor0.rgb*_SpecularColor.rgb*pow(saturate(dot(worldNormal,halfDir)),_Gloss);
				
				fixed atten=1.0;
				//Unity选择最亮的平行光在BasePass中处理，平行光的衰减值设为1，认为没有衰减
				return fixed4(ambient+(diffuse+specularColor)*atten,1.0);
			}
		ENDCG
	}

	Pass{
		Tags{"LightMode"="ForwardAdd"}
		Blend One One
		CGPROGRAM
			#pragma multi_compile_fwdadd
			//#pragma multi_compile_fwdadd指令保证Shader中访问正确的光照变量
			#pragma vertex vert
			#pragma fragment frag 
			
			#include "Lighting.cginc"
			//需要引入改文件，才能正确的访问到_LightMatrix0光照矩阵，对坐标进行转换
			//以便对光照衰减纹理进行采样
			#include "AutoLight.cginc"
			
			fixed4 _Color;
			fixed4 _SpecularColor;
			float   _Gloss;

			struct a2v{
				float4 vertex:POSITION;
				float3 normal:NORMAL;
			};
			struct v2f{
				float4 pos:SV_POSITION;
				float3 worldPos:TEXCOORD0;
				float3 worldNormal:TEXCOORD1;
			};

			v2f vert(a2v v){
				v2f o;
				o.pos=UnityObjectToClipPos(v.vertex);
				o.worldPos=mul(unity_ObjectToWorld,v.vertex).xyz;
				o.worldNormal=UnityObjectToWorldNormal(v.normal);

				return o;
			}

			fixed4 frag(v2f i):SV_Target{
				//Additional中去掉BasePass中的环境光、自发光、逐顶点光照和SH光照部分
				//AddPass中处理的光源可能是非最亮平行光、点光源、聚光灯，因此计算光源的
				//位置、方向、颜色、强度和衰减时，需要根据光源类型分别进行计算
				#ifdef USING_DIRECTIONAL_LIGHT
					fixed3 worldLightDir=normalize(_WorldSpaceLightPos0.xyz);
				#else
					fixed3 worldLightDir=normalize(_WorldSpaceLightPos0.xyz-i.worldPos.xyz);
				#endif
				//上述过程先判断处理的光源是否为平行光，如果是平行光，渲染引擎会定义USING_DIRECTIONAL_LIGHT
				//若没有定义则说明不是平行光，光源位置通过运算得到
				fixed3 worldNormal=normalize(i.worldNormal);
				fixed3 worldViewDir=normalize(UnityWorldSpaceViewDir(i.worldPos));
				
				fixed3 diffuse=_LightColor0.rgb*_Color.rgb*max(0,dot(worldNormal,worldLightDir));
				fixed3 halfDir=normalize(worldViewDir+worldLightDir);
				fixed3 specularColor=_LightColor0.rgb*_SpecularColor.rgb*pow(saturate(dot(worldNormal,halfDir)),_Gloss);
				
				//处理衰减过程
				//针对其他光源类型，Unity使用一张纹理作为查找表，来得到片元着色器中的光照衰减值
				//先得到光源空间下的坐标，使用该坐标进行采样得到衰减值
				#ifdef USING_DIRECTIONAL_LIGHT
					fixed  atten=1.0;
				#else 
					float3 lightCoord=mul(_LightMatrix0,float4(i.worldPos,1)).xyz;
					fixed atten = tex2D(_LightTexture0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL;
				#endif		
				return fixed4((diffuse+specularColor)*atten,1.0);
			}
		ENDCG
	}
}
FallBack "Specular"
}

基础模板6【高级纹理】

Shader "Custom/Chapter10_Fresnel" {
Properties{
	_Color("Color",Color)=(1,1,1,1)
	_FresnelFactor("FresnelFactor",Range(0,1))=0.5
	_FreractionRatio("FreractionRatio",Range(0.1,1))=0.5
	_Cubemap("Cubemap",Cube)="_Skybox"{}
}
SubShader{
	Pass{
		Tags{"LightMode"="ForwardBase"}
		CGPROGRAM
		#pragma vertex vert
		#pragma fragment frag
		#pragma multi_compile_fwdbase

		#include "Lighting.cginc"
		#include "AutoLight.cginc"

		fixed4 _Color;
		float   _FresnelFactor;
		float   _FreractionRatio;
		samplerCUBE _Cubemap;

		struct a2v{
			float4 vertex:POSITION;
			float3 normal:NORMAL;
		};

		struct v2f{
			float4 pos:SV_POSITION;
			float3 worldPos	:TEXCOORD0;
			float3 worldNormal:TEXCOORD1;
			float3 worldViewDir:TEXCOORD2;
			float3 worldRefl:TEXCOORD3;
			float3 worldRefr:TEXCOORD4;
			SHADOW_COORDS(5)
		};

		v2f vert(a2v v){
			v2f o;
			o.pos=UnityObjectToClipPos(v.vertex);
			o.worldPos=mul(unity_ObjectToWorld,v.vertex).xyz;
			o.worldNormal=UnityObjectToWorldNormal(v.normal);
			o.worldViewDir=UnityWorldSpaceViewDir(o.worldPos);
			o.worldRefl=reflect(-o.worldViewDir,o.worldNormal);
			o.worldRefr=refract(-normalize(o.worldViewDir),normalize(o.worldNormal),_FreractionRatio);

			TRANSFER_SHADOW(o);
			return o;
		}

		fixed4 frag(v2f i):SV_Target{
			fixed3 worldNormal=normalize(i.worldNormal);
			fixed3 worldViewDir=normalize(i.worldViewDir);
			fixed3 worldLightDir=normalize(UnityWorldSpaceLightDir(i.worldPos));

			fixed3 ambient=UNITY_LIGHTMODEL_AMBIENT.xyz;
			fixed3 diffuse=_LightColor0.rgb*_Color.rgb*max(dot(worldNormal,worldLightDir),0);
			fixed3 reflect=texCUBE(_Cubemap,i.worldRefl).rgb;

			fixed3 refract=texCUBE(_Cubemap,i.worldRefr).rgb;

			fixed fresnel=_FresnelFactor+(1-_FresnelFactor)*pow(1-dot(worldViewDir,worldNormal),5);
			
			UNITY_LIGHT_ATTENUATION(atten,i,i.worldPos);

			//fixed3 color=ambient+lerp(diffuse,reflect,saturate(fresnel))*atten;
			fixed3 color=ambient+lerp(refract,reflect,saturate(fresnel))*atten;

			return fixed4(color,1.0);
		}
		ENDCG
	}
}
FallBack "Diffuse"
}

基础模板7【屏幕后处理】

屏幕后处理基类

[ExecuteInEditMode]
[RequireComponent(typeof(Camera)]
public class PostEffectsBase : MonoBehaviour {
protected void CheckResources() {
    bool isSupported = CheckSupport();
    if (isSupported == false) {
        NotSupport();
    }
}

protected bool CheckSupport() {
    if (SystemInfo.supportsImageEffects == false || SystemInfo.supportsRenderTextures == false) {
        return false;
    }
    return true;
}

protected void NotSupport() {
    enabled = false;
}
// Use this for initialization
void Start () {
    //检查资源和条件是否支持屏幕后处理
    CheckResources();  
}

protected Material CheckShaderAndCreateMaterial(Shader shader, Material material) {
    if (shader == null) {
        return null;
    }
    if (shader.isSupported && material && material.shader == shader) {
        return material;
    }
    if (!shader.isSupported)
    {
        return null;
    }
    else {
        material = new Material(shader);
        material.hideFlags = HideFlags.DontSave;
        if (material)
            return material;
        else
            return null;
    }
}
}

摄像机脚本

public class BrightnessSaturationAndContrast : PostEffectsBase{

public Shader briSatConShader;
private Material briSatConMaterial;

public Material material {
    get {
        briSatConMaterial = CheckShaderAndCreateMaterial(briSatConShader, briSatConMaterial);
        return briSatConMaterial;
            }
}

[Range(0.0f, 3.0f)]
public float brightness = 1.0f;
[Range(0.0f, 3.0f)]
public float saturation = 1.0f;
[Range(0.0f, 3.0f)]
public float contrast = 1.0f;


void OnRenderImage(RenderTexture src,RenderTexture dest) {
    if (material != null)
    {
        material.SetFloat("_Brightness", brightness);
        material.SetFloat("_Saturation", saturation);
        material.SetFloat("_Contrast", contrast);
        //若材质可用，将参数传递给材质，在调用Graphics.Blit进行处理
        Graphics.Blit(src, dest, material);
    }
    else {
        //否则将图像直接输出到屏幕，不做任何处理
        Graphics.Blit(src, dest);
    }
}
}

Shader Code

Shader "Custom/Chapter12_BrightnessSaturateAndContrast" {
Properties{
	_MainTex("Maintex",2D)="white"{}
	_Brightness("Brightness",Float)=1
	_Saturation("Saturation",Float)=1
	_Contrast("Contrast",Float)=1

	//Graphics.Blit(src,dest,material)会将第一个参数传递给Shader中名为_MainTex的属性
}
SubShader{
	Pass{
		ZTest Always
		Cull Off
		ZWrite Off

		CGPROGRAM
		#pragma vertex vert
		#pragma fragment frag
		#include "UnityCG.cginc"

		sampler2D _MainTex;
		float4 _MainTex_ST;
		half _Brightness;
		half _Saturation;
		half _Contrast;

		struct v2f{
			float4 pos:SV_POSITION;
			float2 uv:TEXCOORD0;
		};

		//appdata_img为Unity内置的结构体，只包含图像处理必须的顶点坐标和纹理坐标
		v2f vert(appdata_img v){
			v2f o;
			o.pos=UnityObjectToClipPos(v.vertex);
			o.uv=v.texcoord; //屏幕后处理得到的纹理和要输出的纹理坐标是相同的

			return o;
		}

		fixed4 frag(v2f i):SV_Target{
			fixed4 renderTex=tex2D(_MainTex,i.uv);  

			//应用明亮度
			fixed3 finalColor=renderTex.rgb*_Brightness;

			//应用饱和度，乘以一定系数
			fixed luminance=0.2125*renderTex.r+0.7154*renderTex.g+0.0721*renderTex.b;
			fixed3 luminanceColor=fixed3(luminance,luminance,luminance);
			finalColor=lerp(luminanceColor,finalColor,_Saturation);

			//应用对比度
			fixed3 avgColor=fixed3(0.5,0.5,0.5);
			finalColor=lerp(avgColor,finalColor,_Contrast);

			return fixed4(finalColor,renderTex.a);
		}
		ENDCG
	}
}
FallBack Off
}