Shader "Name"
{
		Properties
		{
				//开放到材质面板的属性
		}
		SubShader
		{
				//顶点-片段着色器
				//或者表面着色器
				//或者固定函数着色器
		}
		SubShader
		{
				//更加精简的版本
				//为了在旧的图形设备上运行
		}
		...
		Fallback "Name"
}

_Name (“Display Name”, type) = defaultValue [{options}]

SubShader
{
		//标签
		Tags {"TagName1" = "Value1" "TagName2" = "Value2" ...}

		//渲染状态
		Cull Back
		...

		Pass
		{
				//第一个Pass
		}
		Pass
		{
				//第二个Pass
		}
		...
}

Pass
{
	// ..设置渲染状态

	CGPROGRAM
	// 编译指令
	# pragma vertex vert
	# pragma fragment frag

	// CG代码
	
	ENDCG
}

{
	CGPROGRAM
	// ...
	# include "UnityCG.cginc"
	// ...
	ENDCG
}

//appdata基础结构体
struct appdata_base {
    float4 vertex : POSITION;
    float3 normal : NORMAL;
    float4 texcoord : TEXCOORD0;
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

//appdata切向量结构体
struct appdata_tan {
    float4 vertex : POSITION;
    float4 tangent : TANGENT;
    float3 normal : NORMAL;
    float4 texcoord : TEXCOORD0;
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

//appdata完整结构体
struct appdata_full {
    float4 vertex : POSITION;
    float4 tangent : TANGENT;
    float3 normal : NORMAL;
    float4 texcoord : TEXCOORD0;
    float4 texcoord1 : TEXCOORD1;
    float4 texcoord2 : TEXCOORD2;
    float4 texcoord3 : TEXCOORD3;
    fixed4 color : COLOR;
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

//appdata图像特效结构体
struct appdata_img
{
    float4 vertex : POSITION;
    half2 texcoord : TEXCOORD0;
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

//v2f图像特效结构体
struct v2f_img
{
    float4 pos : SV_POSITION;
    half2 uv : TEXCOORD0;
    UNITY_VERTEX_INPUT_INSTANCE_ID
    UNITY_VERTEX_OUTPUT_STEREO
};

// Transforms 2D UV by scale/bias property
#define TRANSFORM_TEX(tex,name) (tex.xy * name##_ST.xy + name##_ST.zw)

Shader "Chapter6/LambertByVertex"
{
    Properties
    {
        _MainColor ("Main Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            // 声明包含灯光变量的文件
            #include "UnityLightingCommon.cginc"

            struct v2f
            {
                float4 pos : SV_POSITION;
                fixed4 dif : COLOR0;
            };

            fixed4 _MainColor;
    
            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);

                // 法线向量
                float3 n = UnityObjectToWorldNormal(v.normal);
                n = normalize(n);

                // 灯光方向向量
                fixed3 l = normalize(_WorldSpaceLightPos0.xyz);
                
                // 按照公式计算漫反射
                o.dif = _LightColor0 * _MainColor * saturate(dot(n, l));

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                return i.dif;
            }
            ENDCG
        }
    }
}

Shader "Chapter6/Half-LambertByVertex"
{
    Properties
    {
        _MainColor ("Main Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            // 声明包含灯光变量的文件
            #include "UnityLightingCommon.cginc"

            struct v2f
            {
                float4 pos : SV_POSITION;
                fixed4 dif : COLOR0;
            };

            fixed4 _MainColor;
    
            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);

                // 法线向量
                float3 n = UnityObjectToWorldNormal(v.normal);
                n = normalize(n);

                // 灯光方向向量
                fixed3 l = normalize(_WorldSpaceLightPos0.xyz);
                
                // 按照公式计算漫反射
                o.dif = _LightColor0 * _MainColor * saturate(0.5 * dot(n, l) + 0.5);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                return i.dif;
            }
            ENDCG
        }
    }
}

Shader "Chapter6/PhongByVertex"
{
    Properties
    {
        _MainColor ("Main Color", Color) = (1,1,1,1)
        _SpecularColor ("Specular Color", Color) = (1,1,1,1)
        _Shininess ("Shininess", Range(1, 100)) = 1
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            #include "Lighting.cginc"

            struct v2f
            {
                float4 pos : SV_POSITION;
                fixed4 color : COLOR0;
            };

            fixed4 _MainColor;
            fixed4 _SpecularColor;
            half _Shininess;		

            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);

                // 计算公式中的所有变量
                float3 n = UnityObjectToWorldNormal(v.normal);
                n = normalize(n);
                fixed3 l = normalize(_WorldSpaceLightPos0.xyz);
                fixed3 view = normalize(WorldSpaceViewDir(v.vertex));

                // 漫反射部分
                fixed ndotl = saturate(dot(n, l));
                fixed4 dif = _LightColor0 * _MainColor * ndotl;

                // 镜面反射部分
                float3 ref = reflect(-l, n);
                ref = normalize(ref);
                fixed rdotv = saturate(dot(ref, view));
                fixed4 spec = _LightColor0 * _SpecularColor * pow(rdotv, _Shininess);

                // 环境光+漫反射+镜面反射
                o.color = unity_AmbientSky + dif + spec;

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                return i.color;
            }
            ENDCG
        }
    }
}

Shader "Chapter6/PhongPerPixel"
{
    Properties
    {
        _MainColor ("Main Color", Color) = (1,1,1,1)
        _SpecularColor ("Specular Color", Color) = (1,1,1,1)
        _Shininess ("Shininess", Range(1, 100)) = 1
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            #include "Lighting.cginc"

            struct v2f
            {
                float4 pos : SV_POSITION;
                float3 normal : TEXCOORD0;
                float4 vertex : TEXCOORD1;
            };

            fixed4 _MainColor;
            fixed4 _SpecularColor;
            half _Shininess;		

            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.normal = v.normal;
                o.vertex = v.vertex;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // 计算公式中的所有变量
                float3 n = UnityObjectToWorldNormal(i.normal);
                n = normalize(n);
                fixed3 l = normalize(_WorldSpaceLightPos0.xyz);
                fixed3 view = normalize(WorldSpaceViewDir(i.vertex));

                // 漫反射部分
                fixed ndotl = saturate(dot(n, l));
                fixed4 dif = _LightColor0 * _MainColor * ndotl;

                // 镜面反射部分
                float3 ref = reflect(-l, n);
                ref = normalize(ref);
                fixed rdotv = saturate(dot(ref, view));
                fixed4 spec = _LightColor0 * _SpecularColor * pow(rdotv, _Shininess);

                // 环境光+漫反射+镜面反射
                fixed4 color = unity_AmbientSky + dif + spec;
                return color;
            }
            ENDCG
        }
    }
}

Shader "Chapter6/Shadow Shader"
{
    Properties
    {
        _MainColor ("Main Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        // ---------- 基础 Pass 为主要平行光产生投影 ----------
        Pass
        {
            // 将Pass的光照模式设置为前向渲染基础Pass
            Tags { "LightMode" = "ForwardBase" }

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fwdbase   // 为在当前Pass中渲染的每个灯光编译出不同的Shader变体
            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            #include "AutoLight.cginc"

            struct v2f
            {
                float4 pos : SV_POSITION;
                float3 normal : TEXCOORD0;
                float4 vertex : TEXCOORD1;
                SHADOW_COORDS(2)            // 使用预定义宏保存阴影坐标，括号内的数字表示TEXCOORD语义后的序号，此处0和1已经被法线向量和顶点坐标占用
            };

            fixed4 _MainColor;
    
            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.normal = v.normal;
                o.vertex = v.vertex;
                TRANSFER_SHADOW(o);     // 使用预定义宏变换阴影坐标（变换阴影贴图的纹理坐标并存入结构体中），宏括号内表示要存入的结构体名称
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // 准备变量
                float3 n = UnityObjectToWorldNormal(i.normal);
                n = normalize(n);

                float3 l = WorldSpaceLightDir(i.vertex);
                l = normalize(l);

                float4 worldPos = mul(unity_ObjectToWorld, i.vertex);

                // Lambert 光照
                fixed ndotl = saturate(dot(n, l));
                fixed4 color = _LightColor0 * _MainColor * ndotl;

                // 加上4个点光源的光照
                color.rgb += Shade4PointLights(
                    unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0,
                    unity_LightColor[0].rgb, unity_LightColor[1].rgb,
                    unity_LightColor[2].rgb, unity_LightColor[3].rgb,
                    unity_4LightAtten0, worldPos.rgb, n
                ) * _MainColor;

                // 加上环境光照
                color += unity_AmbientSky;

                // 使用预定义宏计算阴影遮罩
                UNITY_LIGHT_ATTENUATION(shadowmask, i, worldPos.rgb);
                // 阴影合成
                color.rgb *= shadowmask;

                return color;
            }
            ENDCG
        }

        // ---------- 额外 Pass 为其他逐像素的灯光产生投影 ----------
        Pass
        {
            Tags { "LightMode" = "ForwardAdd" }

            // 使用相加混合，使绘制的图像与上一个Pass完全混合
            Blend One One

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fwdadd_fullshadows    // 为当前Pass中渲染的灯光编译出不同的Shader变体，并产生阴影投射
            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            #include "AutoLight.cginc"

            struct v2f
            {
                float4 pos : SV_POSITION;
                float3 normal : TEXCOORD0;
                float4 vertex : TEXCOORD1;
                SHADOW_COORDS(2)            // 使用预定义宏保存阴影坐标
            };

            fixed4 _MainColor;
    
            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.normal = v.normal;
                o.vertex = v.vertex;
                TRANSFER_SHADOW(o);     // 使用预定义宏变换阴影坐标
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // 准备变量
                float3 n = UnityObjectToWorldNormal(i.normal);
                n = normalize(n);

                float3 l = WorldSpaceLightDir(i.vertex);
                l = normalize(l);

                float4 worldPos = mul(unity_ObjectToWorld, i.vertex);

                // Lambert 光照
                fixed ndotl = saturate(dot(n, l));
                fixed4 color = _LightColor0 * _MainColor * ndotl;

                // 加上4个点光源的光照
                color.rgb += Shade4PointLights(
                    unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0,
                    unity_LightColor[0].rgb, unity_LightColor[1].rgb,
                    unity_LightColor[2].rgb, unity_LightColor[3].rgb,
                    unity_4LightAtten0, worldPos.rgb, n
                ) * _MainColor;

                // 使用预定义宏计算阴影系数
                UNITY_LIGHT_ATTENUATION(shadowmask, i, worldPos.rgb);
                // 阴影合成
                color.rgb *= shadowmask;

                return color;
            }
            ENDCG
        }
       
    }
    FallBack "Diffuse"
}

Shader "Chapter7/Blending Transparency"
{
    Properties
    {
        _MainTex ("Main Tex", 2D) = "white" {}
        _MainColor ("Main Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        // 设置渲染状态
        Tags 
        { 
            "Queue" = "Transparent"
            "RenderType"="Transparent"
            "IgnoreProjector"="True"
        }

        Pass
        {
            Tags { "LightMode" = "ForwardBase" }

            // 设置渲染状态
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

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

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 _MainColor;
    
            v2f vert (appdata_base v)
            {
                v2f o;

                o.pos = UnityObjectToClipPos(v.vertex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);

                float3 worldNormal = UnityObjectToWorldNormal(v.normal);
                o.worldNormal = worldNormal;

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 worldLight = UnityWorldSpaceLightDir(i.worldPos.xyz);
                worldLight = normalize(worldLight);

                fixed NdotL = saturate(dot(i.worldNormal, worldLight));
                fixed4 color = tex2D(_MainTex, i.texcoord);

                color.rgb *= _MainColor.rgb * NdotL * _LightColor0;
                color.rgb += unity_AmbientSky;

                // 通过_MainColor属性的a分量控制透明度
                color.a *= _MainColor.a;

                return color;
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

Shader "Chapter7/TwoSideTransparency"
{
    Properties
    {
        _MainTex ("Main Tex", 2D) = "white" {}
        _MainColor ("Main Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        // 设置渲染状态
        Tags 
        { 
            "Queue" = "Transparent"
            "RenderType"="Transparent"
            "IgnoreProjector"="True"
        }

        // 渲染背面
        Pass
        {
            Tags { "LightMode" = "ForwardBase" }

            // 设置渲染状态
            Cull Front // 开启正面剔除
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

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

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 _MainColor;
    
            v2f vert (appdata_base v)
            {
                v2f o;

                o.pos = UnityObjectToClipPos(v.vertex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);

                float3 worldNormal = UnityObjectToWorldNormal(v.normal);
                o.worldNormal = worldNormal;

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 worldLight = UnityWorldSpaceLightDir(i.worldPos.xyz);
                worldLight = normalize(worldLight);

                fixed NdotL = saturate(dot(i.worldNormal, worldLight));
                fixed4 color = tex2D(_MainTex, i.texcoord);

                color.rgb *= _MainColor.rgb * NdotL * _LightColor0;
                color.rgb += unity_AmbientSky;

                // 通过_MainColor属性的a分量控制透明度
                color.a *= _MainColor.a;

                return color;
            }
            ENDCG
        }

        // 渲染正面
        Pass
        {
            Tags { "LightMode" = "ForwardBase" }

            // 设置渲染状态
            Cull Back // 开启背面剔除
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

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

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 _MainColor;
    
            v2f vert (appdata_base v)
            {
                v2f o;

                o.pos = UnityObjectToClipPos(v.vertex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);

                float3 worldNormal = UnityObjectToWorldNormal(v.normal);
                o.worldNormal = worldNormal;

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 worldLight = UnityWorldSpaceLightDir(i.worldPos.xyz);
                worldLight = normalize(worldLight);

                fixed NdotL = saturate(dot(i.worldNormal, worldLight));
                fixed4 color = tex2D(_MainTex, i.texcoord);

                color.rgb *= _MainColor.rgb * NdotL * _LightColor0;
                color.rgb += unity_AmbientSky;

                // 通过_MainColor属性的a分量控制透明度
                color.a *= _MainColor.a;

                return color;
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

Shader "Chapter7/Alpha Test Transparent"
{
    Properties
    {
        _MainTex ("Main Tex", 2D) = "white" {}
        _AlphaTest ("Alpha Test", Range(0, 1)) = 0.5
    }
    SubShader
    {
        // 设置渲染状态
        Tags 
        { 
            "Queue" = "AlphaTest"
            "RenderType"="TransparentCutout"
            "IgnoreProjector"="True"
        }

        Pass
        {
            Tags { "LightMode" = "ForwardBase" }

            // 关闭几何体剔除
            // Cull Off
            // AlphaToMask On

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

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed _AlphaTest;
    
            v2f vert (appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);

                float3 worldNormal = UnityObjectToWorldNormal(v.normal);
                o.worldNormal = normalize(worldNormal);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 worldLight = UnityWorldSpaceLightDir(i.worldPos.xyz);
                worldLight = normalize(worldLight);

                fixed NdotL = saturate(dot(i.worldNormal, worldLight));
                fixed4 color = tex2D(_MainTex, i.texcoord);

                clip(color.a - _AlphaTest);
                // Equal to 
                //  if ((color.a - _AlphaTest) < 0.0) {
                //		discard;
                //	}

                color.rgb *= NdotL * _LightColor0;
                color.rgb += unity_AmbientSky;

                return color;
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

Stencil
{
		// 用来与缓存中已经存在的模板值进行比较的数值，被称为参照值
		// 当比较之后符合某些设定条件，这个数值可以被写进缓存
		// 数值的范围为0~255的整数，默认为0。
    Ref <ref>
		// 当读取参照值与模板值可以使用的时候，模板会指定哪些位的数值可以读取
		// 数值的范围为0~255的整数（即8位二进制11111111），默认为255
		// 如：当指定ReadMask为255，表示的是所有位都可以被读取
		ReadMask <readMask>
		// 当往缓存中写入的时候可以使用，模板会指定哪些位的数值允许写入缓存
		// 数值的范围为0~255的整数（即8位二进制11111111），默认为255
		// 如：当指定WriteMask为0，表示的是没有数值会被写入缓存
    WriteMask <writeMask>
		// 将参照值与缓存中的模板数值进行比较的方法，默认为always
    Comp <comparisonOperation>
		// 如果模板测试和深度测试都通过，缓存中的模板值如何处理，默认为keep
    Pass <passOperation>
		// 如果模板测试没有通过，缓存中的模板值如何处理，默认为keep
    Fail <failOperation>
		// 如果模板测试通过，但是深度测试没有通过，缓存中的模板值如何处理，默认为keep
    ZFail <zFailOperation>

		// 分别考虑正面和背面的像素
    CompBack <comparisonOperationBack>
    PassBack <passOperationBack>
    FailBack <failOperationBack>
    ZFailBack <zFailOperationBack>
    CompFront <comparisonOperationFront>
    PassFront <passOperationFront>
    FailFront <failOperationFront>
    ZFailFront <zFailOperationFront>
}

Shader "Chapter7/StencilTestA"
{
    SubShader
    {
        Tags { "Queue"="Geometry-1" }

        Pass
        {
            // 设置模板测试的状态
            Stencil
            {
                Ref 1
                Comp Always
                Pass Replace
            }

            // 禁止绘制任何色彩
            ColorMask 0
            ZWrite Off

            CGPROGRAM
            #pragma vertex vert
			#pragma fragment frag

            float4 vert(in float4 vertex : POSITION) : SV_POSITION
            {
				float4 pos = UnityObjectToClipPos(vertex);
				
				return pos;
			}
			
			void frag(out fixed4 color: SV_Target)
            {
				color = fixed4(0, 0, 0, 0);
			}
            ENDCG
        } 
    }
    FallBack "Diffuse"
}
Shader "Chapter7/StencilTestB"
{
    Properties
    {
		_MainColor ("Main Color", Color) = (1, 1, 1, 1)
		_MainTex ("Main Tex", 2D) = "white" {}
	}
    SubShader
    {
        Tags { "Queue"="Geometry" }

        Pass
        {
            Tags { "LightMode"="ForwardBase" }

            // 设置模板测试的状态
            Stencil
            {
                Ref 1
                Comp NotEqual
                Pass Keep
            }

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

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 _MainColor;

            v2f vert(appdata_base v)
            {
				v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);

                o.worldNormal = normalize(UnityObjectToWorldNormal(v.normal));
                o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);
                return o;
			}
			
			fixed4 frag(v2f i) : SV_Target
            {
                float3 worldLight = normalize(UnityWorldSpaceLightDir(i.worldPos.xyz));
                fixed4 color = tex2D(_MainTex, i.texcoord);

                color.rgb *= _MainColor * saturate(dot(i.worldNormal, worldLight)) * _LightColor0.rgb;
                color.rgb += unity_AmbientSky.rgb;

				return color;
			}
            ENDCG
        } 
    }
    FallBack "Diffuse"
}

Shader "Chapter10/GrabPass"
{
    Properties
    {
        _GrayScale ("Gray Scale", Range(0,1)) = 0.0
    }
    SubShader
    {
        Tags { "Queue"="Transparent" }
        GrabPass { "_ScreenTex" }

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

            struct v2f
            {
                float4 pos : SV_POSITION;
                float4 grabPos : TEXCOORD0;
            };

            v2f vert(float4 vertex : POSITION)
            {
								v2f o;
                o.pos = UnityObjectToClipPos(vertex);

                // 计算抓取图像在屏幕上的位置
                o.grabPos = ComputeGrabScreenPos(o.pos);

                return o;
						}

            fixed _GrayScale;
            sampler2D _ScreenTex;
			
						half4 frag(v2f i) : SV_Target
            {
                // 采样抓取图像
                half4 src = tex2Dproj(_ScreenTex, i.grabPos);
                // Equal to
                // half4 src = tex2D(_ScreenTex, i.grabPos.xy / i.grabPos.w);

                half grayscale = Luminance(src.rgb); // Luminance()函数将src去色，得到单通道图像grayscale
                half4 dst = half4(grayscale, grayscale, grayscale, 1);

                return lerp(src, dst, _GrayScale);
						}
            ENDCG
        } 
    }
    FallBack "Diffuse"
}

Shader "Hidden/BrightnessSaturationContrast"
{
    Properties
    {
        _MainTex ("MainTex", 2D) = "white" {}
        _Brightness ("Brightness", float) = 1
        _Saturation ("Saturation", float) = 1
        _Contrast ("Contrast", float) = 1
    }
    SubShader
    {
        Pass
        {
            Cull Off
            ZTest Always
            ZWrite Off

            CGPROGRAM
            #pragma vertex vert_img     // 使用包含文件内置的顶点着色器
            #pragma fragment frag
            #include "UnityCG.cginc"

            sampler2D _MainTex;     // 声明RenderTexture
            half _Brightness;
            half _Saturation;
            half _Contrast;

            // 将vert_img的输出结构体v2f_img输入到片段着色器
            half4 frag(v2f_img i) : SV_Target
            {
                // 使用v2f_img结构体内的纹理坐标对RenderTexture采样
                half4 renderTex = tex2D(_MainTex, i.uv);

                // 亮度
                half3 finalColor = renderTex.rgb * _Brightness;

                // 饱和度
                half luminance = Luminance(finalColor);
                finalColor = lerp(luminance, finalColor, _Saturation);

                // 对比度
                half3 grayColor = half3(0.5, 0.5, 0.5);
                finalColor = lerp(grayColor, finalColor, _Contrast);

                return half4(finalColor, 1);
            }

            ENDCG
        }
    }
    FallBack "Diffuse"
}

Shader "Samples/MatCap"
{
    Properties
    {
        [NoScaleOffset]_MatCap ("MatCap", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "Queue" = "Geometry"}

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

            struct v2f
            {
                float2 texcoord : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MatCap;

            v2f vert (appdata_base v)
            {
                v2f o;

                // 使用UNITY_MATRIX_MV的逆转置矩阵
                // 变换非统一缩放物体的法线向量
                float4 normal = mul(UNITY_MATRIX_IT_MV, float4(v.normal, 0));
                o.texcoord = normalize(normal.xyz).xy;  // 存放顶点在摄像机空间中的法线向量

                o.vertex = UnityObjectToClipPos(v.vertex);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // 范围 [-1, 1] => [0, 1]
                float2 texcoord = i.texcoord * 0.5 + 0.5;

                return tex2D(_MatCap, texcoord);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

Tags { "RenderType" = "Opaque" "Queue" = "Transparent" }

Shader "Samples/Outline"
{
    Properties
    {
        [Header(Texture Group)]
        [Space(10)]
        _Albedo ("Albedo", 2D) = "white" {}
        [NoScaleOffset]_Specular ("Specular (RGB-A)", 2D) = "black" {} // 添加[NoScaleOffset]指令以隐藏Tiling和Offset
        [NoScaleOffset]_Normal ("Normal", 2D) = "bump" {}
        [NoScaleOffset]_AO ("Ambient Occlusion", 2D) = "white" {}

        [Header(Outline Properties)]
        [Space(10)]
        _OutlineColor ("Outline Color", Color) = (1, 0, 1, 1)
        _OutlineWidth ("Outline Width", Range(0, 0.1)) = 0.01

    }

    SubShader
    {
        Tags {"RenderType" = "Opaque" "Queue" = "Transparent"}

        // --------------------- Outline Layer ---------------------
        Pass
        {
            ZWrite Off

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

            struct v2f
            {
                float4 vertex : SV_POSITION;
            };

            fixed4 _OutlineColor;
            fixed _OutlineWidth;

            v2f vert (appdata_base v)
            {
                v2f o;
                v.vertex.xyz += v.normal * _OutlineWidth;
                o.vertex = UnityObjectToClipPos(v.vertex);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                return _OutlineColor;
            }
            ENDCG
        }

        // --------------------- Regular Layer ---------------------
        CGPROGRAM
        #pragma surface surf StandardSpecular fullforwardshadows

        struct Input
        {
            float2 uv_Albedo;
        };

        sampler2D _Albedo;
        sampler2D _Specular;
        sampler2D _Normal;
        sampler2D _AO;

        void surf(Input IN, inout SurfaceOutputStandardSpecular o)
        {
            fixed4 c = tex2D(_Albedo, IN.uv_Albedo);
            o.Albedo = c.rgb;

            fixed4 specular = tex2D(_Specular, IN.uv_Albedo);
            o.Specular = specular.rgb;
            o.Smoothness = specular.a;

            o.Normal = UnpackNormal(tex2D(_Normal, IN.uv_Albedo));
            o.Occlusion = tex2D(_AO, IN.uv_Albedo);
        }

        ENDCG
    }
}

Shader "Samples/X-Ray"
{
    Properties
    {
        // 半透效果设置
        [Header(The Blocked Part)]
        [Space(10)]
        _Color ("X-Ray Color", Color) = (0,1,1,1)
        _Width ("X-Ray Width", Range(1, 2)) = 1
        _Brightness ("X-Ray Brightness",Range(0, 2)) = 1

        // 正常渲染部分
        [Header(The Normal Part)]
        [Space(10)]
        _Albedo("Albedo", 2D) = "white"{}
        [NoScaleOffset]_Specular ("Specular (RGB-A)", 2D) = "black"{}
        [NoScaleOffset]_Normal ("Nromal", 2D) = "bump"{}
        [NoScaleOffset]_AO ("AO", 2D) = "white"{}
    }

    SubShader
    {
        Tags {"RenderType" = "Opaque" "Queue" = "Geometry"}

        // --------------------- The Blocked Layer ---------------------
        Pass
        {
            ZTest Greater   // 即使被遮挡也会显示
            ZWrite Off

            Blend SrcAlpha OneMinusSrcAlpha     // 半透效果需要通过Blending实现

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

            struct v2f
            {
                float4 vertexPos : SV_POSITION;
                float3 viewDir : TEXCOORD0;
                float3 worldNor : TEXCOORD1;
            };

            fixed4 _Color;
            fixed _Width;
            half _Brightness;

            v2f vert(appdata_base v)
            {
                v2f o;
                o.vertexPos = UnityObjectToClipPos(v.vertex);
                o.viewDir = normalize(WorldSpaceViewDir(v.vertex));
                o.worldNor = UnityObjectToWorldNormal(v.normal);

                return o;
            }

            float4 frag(v2f i) : SV_Target
            {
                // Fresnel算法
                half NDotV = saturate( dot(i.worldNor, i.viewDir));
                NDotV = pow(1 - NDotV, _Width) * _Brightness;

                fixed4 color;
                color.rgb = _Color.rgb;
                color.a = NDotV;
                return color;
            }
            ENDCG
        }

        // --------------------- The Normal Layer ---------------------
        CGPROGRAM
        #pragma surface surf StandardSpecular
        #pragma target 3.0

        struct Input
        {
            float2 uv_Albedo;
        };

        sampler2D _Albedo;
        sampler2D _Specular;
        sampler2D _Normal;
        sampler2D _AO;

        void surf(Input IN, inout SurfaceOutputStandardSpecular o)
        {
            fixed4 c = tex2D(_Albedo, IN.uv_Albedo);
            o.Albedo = c.rgb;

            fixed4 specular = tex2D(_Specular, IN.uv_Albedo);
            o.Specular = specular.rgb;
            o.Smoothness = specular.a;

            o.Normal = UnpackNormal(tex2D(_Normal, IN.uv_Albedo));
            o.Occlusion = tex2D(_AO, IN.uv_Albedo);
        }

        ENDCG
    }
}

Shader "Samples/Tri-Planar Mapping"
{
    Properties
    {
        _Tiling ("Tiling", float) = 1
        [NoScaleOffset]_Albedo ("Albedo", 2D) = "white" {}
        [NoScaleOffset]_Normal ("Normal", 2D) = "bump" {}
        _Bumpiness ("Bumpiness", Range(0.01, 10)) = 1
    }
    SubShader
    {
        CGPROGRAM
        #pragma surface surf Lambert fullforwardshadows
        
        struct Input
        {
            float3 worldPos;
            float3 worldNormal;
            INTERNAL_DATA
        };

        float _Tiling;
        sampler2D _Albedo;
        sampler2D _Normal;
        half _Bumpiness;

        void surf (Input IN, inout SurfaceOutput o)
        {
            float3 texCoord = IN.worldPos * _Tiling;

            // -------------------- Mask --------------------
            float3 normal = abs(WorldNormalVector(IN, o.Normal));
            fixed maskX = saturate(dot(normal, fixed3(1, 0, 0)));
            fixed maskY = saturate(dot(normal, fixed3(0, 1, 0)));

            // -------------------- Albedo --------------------
            fixed4 colorXY = tex2D (_Albedo, texCoord.xy);
            fixed4 colorYZ = tex2D (_Albedo, texCoord.yz);
            fixed4 colorXZ = tex2D (_Albedo, texCoord.xz);

            fixed4 c;
            c = lerp(colorXY, colorYZ, maskX);
            c = lerp(c, colorXZ, maskY);

            o.Albedo = c.rgb;

            // -------------------- Normal --------------------
            fixed3 normalXY = UnpackNormal(tex2D(_Normal, texCoord.xy));
            fixed3 normalYZ = UnpackNormal(tex2D(_Normal, texCoord.yz));
            fixed3 normalXZ = UnpackNormal(tex2D(_Normal, texCoord.xz));

            fixed3 n;
            n = lerp(normalXY, normalYZ, maskX);
            n = lerp(n, normalXZ, maskY);

            o.Normal = n * half3(_Bumpiness, _Bumpiness, 1);
        }
        ENDCG
    }
    FallBack "Diffuse"
}

Shader "Samples/MatCap"
{
    Properties
    {
        [NoScaleOffset]_MatCap ("MatCap", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "Queue" = "Geometry"}

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

            struct v2f
            {
                float2 texcoord : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MatCap;

            v2f vert (appdata_base v)
            {
                v2f o;

                // 使用UNITY_MATRIX_MV的逆转置矩阵
                // 变换非统一缩放物体的法线向量
                float4 normal = mul(UNITY_MATRIX_IT_MV, float4(v.normal, 0));
                o.texcoord = normalize(normal.xyz).xy;  // 存放顶点在摄像机空间中的法线向量

                o.vertex = UnityObjectToClipPos(v.vertex);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // 范围 [-1, 1] => [0, 1]
                float2 texcoord = i.texcoord * 0.5 + 0.5;

                return tex2D(_MatCap, texcoord);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

Shader "Samples/Object Cutting"
{
    Properties
    {
        [Header(Textures)] [Space(10)]
        [NoScaleOffset] _Albedo ("Albedo", 2D) = "white" {}
        [NoScaleOffset] _Reflection ("Specular_Smoothness", 2D) = "black" {}
        [NoScaleOffset] _Normal ("Normal", 2D) = "bump" {}
        [NoScaleOffset] _Occlusion ("Ambient Occlusion", 2D) = "white" {}

        [Header(Cutting)] [Space(10)]
        [KeywordEnum(X, Y, Z)] _Direction ("Cutting Direction", Float) = 1  // KeywordEnum枚举，切割方向
        [Toggle] _Invert ("Invert Direction", Float) = 0    // Toggle开关，反转切割方向
    }
    SubShader
    {
        Tags { "RenderType"="TransparentCutout" "Queue"="AlphaTest" }
        Cull Off    // 关闭多边形剔除功能

        CGPROGRAM
        #pragma surface surf StandardSpecular addshadow fullforwardshadows
        #pragma target 3.0

        #pragma multi_compile _DIRECTION_X _DIRECTION_Y _DIRECTION_Z
        
        sampler2D _Albedo;
        sampler2D _Reflection;
        sampler2D _Normal;
        sampler2D _Occlusion;

        float3 _Position;      // 存放C#脚本传递来的切割平面坐标
        fixed _Invert;

        struct Input
        {
            float2 uv_Albedo;
            float3 worldPos;
            fixed face : VFACE;     // 保存物体表面朝向的信息，当正面朝向摄像机的时候，为正值，背面为负值
        };

        void surf (Input i, inout SurfaceOutputStandardSpecular o)
        {
            fixed4 col = tex2D(_Albedo, i.uv_Albedo);
            o.Albedo =  i.face > 0 ? col.rgb : fixed3(0,0,0);

            // 判断切割方向
            // step(a, b)，当a大于b时输出0，反之输出1
            #if _DIRECTION_X
                col.a = step(_Position.x, i.worldPos.x);
            #elif _DIRECTION_Y
                col.a = step(_Position.y, i.worldPos.y);
            #else 
                col.a = step(_Position.z, i.worldPos.z);
            #endif

            // 判断是否反转切割方向
            col.a = _Invert? 1 - col.a : col.a;

            clip(col.a - 0.001);
            
            fixed4 reflection = tex2D(_Reflection, i.uv_Albedo);
            o.Specular = i.face > 0 ? reflection.rgb : fixed3(0,0,0);
            o.Smoothness = i.face > 0 ? reflection.a : 0;

            o.Normal = UnpackNormal(tex2D(_Normal, i.uv_Albedo));

            o.Occlusion = tex2D(_Occlusion, i.uv_Albedo);
        }
        ENDCG
    }
}