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

Pass{
    for(each primitive in this model){
        for(each fragment covered by this primitive){
             if(failed in depth test){
                  //如果该片元没有通过深度测试，就舍弃
             }else{
                  //如果该片元可见，就进行光照的计算
                  float4 color = Shading(materialInfo,pos,normal,lightDir,viewDir);
                  //写入帧缓存
                  writeFrameBuffer(fragment,color);
             }
        }
    }
}

Pass1{
    //延迟渲染的第一个Pass不用于计算光照，而是收集所有的深度信息，法线信息等
    //在第二个Pass中进行实际的光照计算，因而也被称为延迟渲染。
    for(each primitive in this model){
        for(each fragment covered by this primitve){
            if(failed in depth test){
                //如果没有通过深度测试，说明该片元是不可见的
                discard;
            }else{
                writeGBuffer(materialInfo,pos,normal,lightDir,viewDir);
                //如果该片元可见，就把需要的信息存储到G缓冲中去
            }
        }
    }
}
Pass2{
    for(each pixel in the screen){
        if(the pixel is valid){
            //如果该像素有效，那么就读取它对应的G缓冲中的信息
            readGBuffer(pixel,materialInfo,pos,normal,lightDir,viewDir);

            //在此处计算光照
            float4 color = Shading(materialInfo,pos,normal,lightDir,viewDir);
            writeFrameBuffer();  //更新帧缓存
        }
    }
}

Shader "Unity Shaders Book/Chapter 9/Forward Rendering"
{
    Properties
    {
        _Diffuse ("Diffuse", Color) = (1, 1, 1, 1)
        _Specular ("Specular", Color) = (1, 1, 1, 1)
        _Gloss ("Gloss", Range(8.0, 256)) = 20
    }
    SubShader
    {
        Tags { "RenderType" = "Opaque" }
        
        // BasePass
        Pass
        {
            // 环境光和第一像素光(方向光)Pass
            Tags { "LightMode" = "ForwardBase" }
            
            CGPROGRAM
            
            // 显然需要添加此声明
            #pragma multi_compile_fwdbase
            
            #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;
                float3 worldPos: TEXCOORD1;
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                fixed3 worldNormal = normalize(i.worldNormal);
                // _WorldSpaceLightPos0平行光方向
                fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);
                // 计算场景中的环境光
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;
                // _LightColor0平行光颜色和强度
                fixed3 diffuse = _LightColor0.rgb * _Diffuse.rgb * max(0, dot(worldNormal, worldLightDir));

                fixed3 viewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos.xyz);
                fixed3 halfDir = normalize(worldLightDir + viewDir);
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);
                // 平行光的衰减为1
                fixed atten = 1.0;
                
                return fixed4(ambient + (diffuse + specular) * atten, 1.0);
            }
            
            ENDCG
            
        }
        // Additional Pass
        Pass
        {
            // 其他像素光源Pass
            Tags { "LightMode" = "ForwardAdd" }
            // 开启混合模式用于叠加光照
            Blend One One
            
            CGPROGRAM
            
            // 显然需要添加此声明
            #pragma multi_compile_fwdadd
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
            
            fixed4 _Diffuse;
            fixed4 _Specular;
            float _Gloss;
            
            struct a2v
            {
                float4 vertex: POSITION;
                float3 normal: NORMAL;
            };
            
            struct v2f
            {
                float4 pos: SV_POSITION;
                float3 worldNormal: TEXCOORD0;
                float3 worldPos: TEXCOORD1;
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                fixed3 worldNormal = normalize(i.worldNormal);
                // 用于判断当前光源是否是平行光
                #ifdef USING_DIRECTIONAL_LIGHT
                    // 获取平行光的方向
                    fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);
                #else
                    // 通过点光源（或聚光灯）的位置减去世界空间下顶点位置，获得光的方向
                    fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz - i.worldPos.xyz);
                #endif
                
                fixed3 diffuse = _LightColor0.rgb * _Diffuse.rgb * max(0, dot(worldNormal, worldLightDir));
                
                fixed3 viewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos.xyz);
                fixed3 halfDir = normalize(worldLightDir + viewDir);
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);
                
                // 判断当前光源是否是平行光
                #ifdef USING_DIRECTIONAL_LIGHT
                    // 平行光衰减值为1
                    fixed atten = 1.0;
                #else
					// 如果是点光源，光的衰减值计算
                    #if defined(POINT)
                        float3 lightCoord = mul(unity_WorldToLight, float4(i.worldPos, 1)).xyz;
                        fixed atten = tex2D(_LightTexture0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL;
                    // 如果是聚光灯，光的衰减值计算
					#elif defined(SPOT)
                        float4 lightCoord = mul(unity_WorldToLight, float4(i.worldPos, 1));
                        fixed atten = (lightCoord.z > 0) * tex2D(_LightTexture0, lightCoord.xy / lightCoord.w + 0.5).w * tex2D(_LightTextureB0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL;
                    #else
                        fixed atten = 1.0;
                    #endif
                #endif

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

float3 lightCoord=mul(_LightMatrix0，float4(i.worldPosition,1)).xyz;

fixed atten = tex2D(_LightTexture0,dot(lightCoord，lightCoord).rr).UNITY_ATTEN_CHANNEL;

float distance = length(_WorldSpaceLightPos.xyz-i.worldPosition.xyz);
atten=1.0/distance;//线性衰减

Shader "Unity Shaders Book/Chapter 9/Shadow"
{
    Properties
    {
        _Diffuse ("Diffuse", Color) = (1, 1, 1, 1)
        _Specular ("Specular", Color) = (1, 1, 1, 1)
        _Gloss ("Gloss", Range(8.0, 256)) = 20
    }
    SubShader
    {
        Tags { "RenderType" = "Opaque" }
        
        Pass
        {
            // 环境光和第一像素光(方向光)Pass
            Tags { "LightMode" = "ForwardBase" }
            
            CGPROGRAM
            
            // 显然需要添加此声明
            #pragma multi_compile_fwdbase
            
            #pragma vertex vert
            #pragma fragment frag
            
            // 需要这些文件获得内置宏
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
            
            fixed4 _Diffuse;
            fixed4 _Specular;
            float _Gloss;
            
            struct a2v
            {
                float4 vertex: POSITION;
                float3 normal: NORMAL;
            };
            
            struct v2f
            {
                float4 pos: SV_POSITION;
                float3 worldNormal: TEXCOORD0;
                float3 worldPos: TEXCOORD1;
				// 这个宏用于声明一个作用于阴影纹理采样的坐标
                SHADOW_COORDS(2)
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                
                o.worldNormal = UnityObjectToWorldNormal(v.normal);

                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                
                // 这个宏用于将阴影坐标传递到像素着色器
                TRANSFER_SHADOW(o);
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                fixed3 worldNormal = normalize(i.worldNormal);
                fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);
                
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;

                fixed3 diffuse = _LightColor0.rgb * _Diffuse.rgb * max(0, dot(worldNormal, worldLightDir));

                fixed3 viewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos.xyz);
                fixed3 halfDir = normalize(worldLightDir + viewDir);
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);

                fixed atten = 1.0;
                // 使用宏坐标来采样阴影贴图
                fixed shadow = SHADOW_ATTENUATION(i);
                
                return fixed4(ambient + (diffuse + specular) * atten * shadow, 1.0);
            }
            
            ENDCG
            
        }
        
        Pass
        {
            // 其他像素光源Pass
            Tags { "LightMode" = "ForwardAdd" }
            
            Blend One One
            
            CGPROGRAM
            
            // 显然需要添加此声明
            #pragma multi_compile_fwdadd
            // 使用下面的line为点光源和聚光灯添加阴影
            //			#pragma multi_compile_fwdadd_fullshadows
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
            
            fixed4 _Diffuse;
            fixed4 _Specular;
            float _Gloss;
            
            struct a2v
            {
                float4 vertex: POSITION;
                float3 normal: NORMAL;
            };
            
            struct v2f
            {
                float4 position: SV_POSITION;
                float3 worldNormal: TEXCOORD0;
                float3 worldPos: TEXCOORD1;
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                o.position = UnityObjectToClipPos(v.vertex);
                
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                fixed3 worldNormal = normalize(i.worldNormal);
                #ifdef USING_DIRECTIONAL_LIGHT
                    fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);
                #else
                    fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz - i.worldPos.xyz);
                #endif

                fixed3 diffuse = _LightColor0.rgb * _Diffuse.rgb * max(0, dot(worldNormal, worldLightDir));

                fixed3 viewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos.xyz);
                fixed3 halfDir = normalize(worldLightDir + viewDir);
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);

                #ifdef USING_DIRECTIONAL_LIGHT
                    fixed atten = 1.0;
                #else
                    float3 lightCoord = mul(unity_WorldToLight, float4(i.worldPos, 1)).xyz;
                    fixed atten = tex2D(_LightTexture0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL;
                #endif
                
                return fixed4((diffuse + specular) * atten, 1.0);
            }
            
            ENDCG
            
        }
    }
    FallBack "Specular"
}

Shader "Unity Shaders Book/Chapter 9/Attenuation And Shadow Use Build-in Functions"
{
    Properties
    {
        _Diffuse ("Diffuse", Color) = (1, 1, 1, 1)
        _Specular ("Specular", Color) = (1, 1, 1, 1)
        _Gloss ("Gloss", Range(8.0, 256)) = 20
    }
    SubShader
    {
        Tags { "RenderType" = "Opaque" }
        
        Pass
        {
            // 环境光和第一像素光(方向光)Pass
            Tags { "LightMode" = "ForwardBase" }
            
            CGPROGRAM
            
            // 显然需要添加此声明
            #pragma multi_compile_fwdbase
            
            #pragma vertex vert
            #pragma fragment frag
            
            // 需要这些文件获得内置宏
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
            
            fixed4 _Diffuse;
            fixed4 _Specular;
            float _Gloss;
            
            struct a2v
            {
                float4 vertex: POSITION;
                float3 normal: NORMAL;
            };
            
            struct v2f
            {
                float4 pos: SV_POSITION;
                float3 worldNormal: TEXCOORD0;
                float3 worldPos: TEXCOORD1;
                // 这个宏用于声明一个作用于阴影纹理采样的坐标
                SHADOW_COORDS(2)
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                
                // 这个宏用于将阴影坐标传递到像素着色器
                TRANSFER_SHADOW(o);
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                fixed3 worldNormal = normalize(i.worldNormal);
                fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
                
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;
                
                fixed3 diffuse = _LightColor0.rgb * _Diffuse.rgb * max(0, dot(worldNormal, worldLightDir));

                fixed3 viewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
                fixed3 halfDir = normalize(worldLightDir + viewDir);
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);

                // UNITY_LIGHT_ATTENUATION)不仅可以计算衰减，还可以计算阴影信息
                UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
                
                return fixed4(ambient + (diffuse + specular) * atten, 1.0);
            }
            
            ENDCG
            
        }
        
        Pass
        {
            // 其他像素光源Pass
            Tags { "LightMode" = "ForwardAdd" }
            
            Blend One One
            
            CGPROGRAM
            
            // 显然需要添加此声明
            #pragma multi_compile_fwdadd
            // 使用下面的line为点光源和聚光灯添加阴影
            //			#pragma multi_compile_fwdadd_fullshadows
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
            
            fixed4 _Diffuse;
            fixed4 _Specular;
            float _Gloss;
            
            struct a2v
            {
                float4 vertex: POSITION;
                float3 normal: NORMAL;
            };
            
            struct v2f
            {
                float4 pos: SV_POSITION;
                float3 worldNormal: TEXCOORD0;
                float3 worldPos: TEXCOORD1;
                SHADOW_COORDS(2)
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                
                //将阴影坐标传递到像素着色器
                TRANSFER_SHADOW(o);
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                fixed3 worldNormal = normalize(i.worldNormal);
                fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
                
                fixed3 diffuse = _LightColor0.rgb * _Diffuse.rgb * max(0, dot(worldNormal, worldLightDir));

                fixed3 viewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
                fixed3 halfDir = normalize(worldLightDir + viewDir);
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);

                // UNITY_LIGHT_ATTENUATION不仅计算衰减,还有阴影信息
                UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
                
                return fixed4((diffuse + specular) * atten, 1.0);
            }
            
            ENDCG
            
        }
    }
    FallBack "Specular"
}

Shader "Unity Shaders Book/Chapter 9/Alpha Test With Shadow" {
	Properties {
		_Color ("Color Tint", Color) = (1, 1, 1, 1)
		_MainTex ("Main Tex", 2D) = "white" {}
		_Cutoff ("Alpha Cutoff", Range(0, 1)) = 0.5
	}
	SubShader {
		Tags {"Queue"="AlphaTest" "IgnoreProjector"="True" "RenderType"="TransparentCutout"}
		
		Pass {
			Tags { "LightMode"="ForwardBase" }
			
			Cull Off
			
			CGPROGRAM
			
			#pragma multi_compile_fwdbase
			
			#pragma vertex vert
			#pragma fragment frag
			
			#include "Lighting.cginc"
			#include "AutoLight.cginc"
			
			fixed4 _Color;
			sampler2D _MainTex;
			float4 _MainTex_ST;
			fixed _Cutoff;
			
			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;
				SHADOW_COORDS(3)
			};
			
			v2f vert(a2v v) {
			 	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);
			 	
			 	// 传递阴影坐标到像素着色器
			 	TRANSFER_SHADOW(o);
			 	
			 	return o;
			}
			
			fixed4 frag(v2f i) : SV_Target {
				fixed3 worldNormal = normalize(i.worldNormal);
				fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
				
				fixed4 texColor = tex2D(_MainTex, i.uv);

				clip (texColor.a - _Cutoff);
				
				fixed3 albedo = texColor.rgb * _Color.rgb;
				
				fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
				
				fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(worldNormal, worldLightDir));
							 	
			 	// UNITY_LIGHT_ATTENUATION)不仅可以计算衰减，还可以计算阴影信息
				UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
			 	
				return fixed4(ambient + diffuse * atten, 1.0);
			}
			
			ENDCG
		}
	} 
	FallBack "Transparent/Cutout/VertexLit"
}

Shader "Unity Shaders Book/Chapter 9/Alpha Blend With Shadow"
{
    Properties
    {
        _Color ("Color Tint", Color) = (1, 1, 1, 1)
        _MainTex ("Main Tex", 2D) = "white" { }
        _AlphaScale ("Alpha Scale", Range(0, 1)) = 1
    }
    SubShader
    {
        Tags { "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" }
        
        Pass
        {
            Tags { "LightMode" = "ForwardBase" }
            
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha
            
            CGPROGRAM
            
            #pragma multi_compile_fwdbase
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
            
            fixed4 _Color;
            sampler2D _MainTex;
            float4 _MainTex_ST;
            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;
                SHADOW_COORDS(3)
            };
            
            v2f vert(a2v v)
            {
                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);
                
                // 传递阴影坐标到像素着色器
                TRANSFER_SHADOW(o);
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                fixed3 worldNormal = normalize(i.worldNormal);
                fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
                
                fixed4 texColor = tex2D(_MainTex, i.uv);
                
                fixed3 albedo = texColor.rgb * _Color.rgb;
                
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
                
                fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(worldNormal, worldLightDir));

                // UNITY_LIGHT_ATTENUATION)不仅可以计算衰减，还可以计算阴影信息
                UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
                
                return fixed4(ambient + diffuse * atten, texColor.a * _AlphaScale);
            }
            
            ENDCG
            
        }
    }
    FallBack "Transparent/VertexLit"
    // 或用force应用阴影
    //	FallBack "VertexLit"
}

Shader "Unity Shaders Book/Common/Bumped Diffuse"
{
    // 逐像素漫反射的标准光照着色器
    // 思路：采用两个Pass，分别计算不同光源的渲染，主要取决于不同的渲染路径与预编译指令
    Properties
    {
        // 叠加颜色
        _Color ("Color Tint", Color) = (1, 1, 1, 1)
        // 主贴图
        _MainTex ("Main Tex", 2D) = "white" { }
        // 法线贴图
        _BumpMap ("Normal Map", 2D) = "bump" { }
    }
    SubShader
    {
        //      渲染类型 = 不透明物体     渲染队列 = 几何
        Tags { "RenderType" = "Opaque" "Queue" = "Geometry" }

        // Base Pass
        Pass
        {
            //      光照渲染路径 = 前向渲染Base    说明该Pass会计算环境光、最重要的平行光、逐顶点/SH光源和Lightmaps
            Tags { "LightMode" = "ForwardBase" }
            
            CGPROGRAM
            
            // 编译指令会保证Unity可以为相应类型的光照Pass生成所需的Shader变种
            #pragma multi_compile_fwdbase
            
            #pragma vertex vert
            #pragma fragment frag
            
            // 用于提供光照参数的文件
            #include "Lighting.cginc"
            // 用于提供计算光照衰减宏的文件
            #include "AutoLight.cginc"
            
            // 属性
            fixed4 _Color;
            sampler2D _MainTex;
            // 主纹理的缩放和平移属性
            float4 _MainTex_ST;
            sampler2D _BumpMap;
            // 法线纹理的缩放和平移属性
            float4 _BumpMap_ST;
            
            struct a2v
            {
                // 该变量名是指定的，用于后续宏计算阴影
                float4 vertex: POSITION;

                float3 normal: NORMAL;
                float4 tangent: TANGENT;
                float4 texcoord: TEXCOORD0;
            };
            
            struct v2f
            {
                // 该变量名是指定的，用于后续宏计算阴影
                float4 pos: SV_POSITION;
                
                float4 uv: TEXCOORD0;

                // 用于存储从切线空间到世界空间的变换矩阵
                float4 TtoW0: TEXCOORD1;
                float4 TtoW1: TEXCOORD2;
                float4 TtoW2: TEXCOORD3;

                // 使用宏声明一个名为_ShadowCoord的阴影纹理坐标变量
                // 由于前面已经占用了三个寄存器，所以参数是4，代表使用第四个寄存器
                SHADOW_COORDS(4)
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                // 转换顶点坐标到裁剪空间
                o.pos = UnityObjectToClipPos(v.vertex);
                
                // 计算纹理的缩放与偏移
                o.uv.xy = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                o.uv.zw = v.texcoord.xy * _BumpMap_ST.xy + _BumpMap_ST.zw;
                // 或使用内置函数
                // o.uv.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
                // o.uv.zw = TRANSFORM_TEX(v.texcoord, _BumpMap_ST);
                
                // 世界空间下坐标
                float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                // 或使用内置函数
                // float3 worldPos = UnityObjectToWorldDir(v.vertex).xyz;

                // 世界空间下法线方向
                fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);
                // 世界空间下切线方向
                fixed3 worldTangent = UnityObjectToWorldDir(v.tangent.xyz);
                // 世界空间下副法线方向 cross：叉积
                fixed3 worldBinormal = cross(worldNormal, worldTangent) * v.tangent.w;
                
                // 切线空间到世界空间的变换矩阵，按列摆放
                o.TtoW0 = float4(worldTangent.x, worldBinormal.x, worldNormal.x, worldPos.x);
                o.TtoW1 = float4(worldTangent.y, worldBinormal.y, worldNormal.y, worldPos.y);
                o.TtoW2 = float4(worldTangent.z, worldBinormal.z, worldNormal.z, worldPos.z);
                
                // 使用宏计算阴影纹理变量
                TRANSFER_SHADOW(o);
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                // 世界空间下的坐标（从前面切线空间变换到时间空间的变换矩阵分量提取而来）
                float3 worldPos = float3(i.TtoW0.w, i.TtoW1.w, i.TtoW2.w);
                // 计算世界空间下光照方向和视角方向
                fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));
                fixed3 viewDir = normalize(UnityWorldSpaceViewDir(worldPos));
                
                // 切线空间的法线方向 = 法线贴图采样
                fixed3 bump = UnpackNormal(tex2D(_BumpMap, i.uv.zw));
                // 凹凸映射 = 将切线空间的法线转换到世界空间
                bump = normalize(half3(dot(i.TtoW0.xyz, bump), dot(i.TtoW1.xyz, bump), dot(i.TtoW2.xyz, bump)));
                
                // 反射贴图 = 纹理采样 * 叠加颜色
                fixed3 albedo = tex2D(_MainTex, i.uv.xy).rgb * _Color.rgb;
                
                // 环境光 = 环境光宏 * 反射贴图
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;

                // 漫反射 =  入射光线颜色 * 反射贴图 * 取值为正数(反射方向 · 视角方向)
                // _LightColor0：该Pass处理的逐光源颜色，通过声明渲染路径后，由Unity传递给Shader的参数
                fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(bump, lightDir));
                
                // 使用宏对阴影纹理进行采样，输出到变量atten中
                UNITY_LIGHT_ATTENUATION(atten, i, worldPos);
                
                // 最终结果 = 环境光 + 漫反射 * 阴影 ， 透明度
                return fixed4(ambient + diffuse * atten, 1.0);
            }
            
            ENDCG
            
        }

        // Additional Pass
        Pass
        {
            //      光照渲染路径 = 前向渲染Add    说明该Pass会计算额外的逐像素光源，每个Pass对应一个光源
            Tags { "LightMode" = "ForwardAdd" }
            // 开启混合模式，避免该Pass的渲染结果直接覆盖之前Pass的结果
            Blend One One
            
            CGPROGRAM
            
            // 编译指令会保证Unity可以为相应类型的光照Pass生成所需的Shader变种
            // 注意该指令与之前Pass中的"multi_compile_fwdbase"有所不同
            #pragma multi_compile_fwdadd
            // 使用下面的方式可以为点光源与聚光灯光源添加阴影
            //			#pragma multi_compile_fwdadd_fullshadows
            
            #pragma vertex vert
            #pragma fragment frag
            
            // 用于提供光照参数的文件
            #include "Lighting.cginc"
            // 用于提供计算光照衰减宏的文件
            #include "AutoLight.cginc"
            
            // 属性
            fixed4 _Color;
            sampler2D _MainTex;
            // 主纹理的缩放和平移属性
            float4 _MainTex_ST;
            sampler2D _BumpMap;
            // 法线纹理的缩放和平移属性
            float4 _BumpMap_ST;
            
            struct a2v
            {
                // 该变量名是指定的，用于后续宏计算阴影
                float4 vertex: POSITION;

                float3 normal: NORMAL;
                float4 tangent: TANGENT;
                float4 texcoord: TEXCOORD0;
            };
            
            struct v2f
            {
                // 该变量名是指定的，用于后续宏计算阴影
                float4 pos: SV_POSITION;

                float4 uv: TEXCOORD0;

                // 用于存储从切线空间到世界空间的变换矩阵
                float4 TtoW0: TEXCOORD1;
                float4 TtoW1: TEXCOORD2;
                float4 TtoW2: TEXCOORD3;

                // 使用宏声明一个名为_ShadowCoord的阴影纹理坐标变量
                // 由于前面已经占用了三个寄存器，所以参数是4，代表使用第四个寄存器
                SHADOW_COORDS(4)
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                // 转换顶点坐标到裁剪空间
                o.pos = UnityObjectToClipPos(v.vertex);
                
                // 计算纹理的缩放与偏移
                o.uv.xy = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                o.uv.zw = v.texcoord.xy * _BumpMap_ST.xy + _BumpMap_ST.zw;
                // 或使用内置函数
                // o.uv.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
                // o.uv.zw = TRANSFORM_TEX(v.texcoord, _BumpMap_ST);
                
                // 世界空间下坐标
                float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                // 或使用内置函数
                // float3 worldPos = UnityObjectToWorldDir(v.vertex).xyz;

                // 世界空间下法线方向
                fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);
                // 世界空间下切线方向
                fixed3 worldTangent = UnityObjectToWorldDir(v.tangent.xyz);
                // 世界空间下副法线方向 cross：叉积
                fixed3 worldBinormal = cross(worldNormal, worldTangent) * v.tangent.w;
                
                // 切线空间到世界空间的变换矩阵，按列摆放
                o.TtoW0 = float4(worldTangent.x, worldBinormal.x, worldNormal.x, worldPos.x);
                o.TtoW1 = float4(worldTangent.y, worldBinormal.y, worldNormal.y, worldPos.y);
                o.TtoW2 = float4(worldTangent.z, worldBinormal.z, worldNormal.z, worldPos.z);
                
                // 使用宏计算阴影纹理变量
                TRANSFER_SHADOW(o);
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                // 世界空间下的坐标（从前面切线空间变换到时间空间的变换矩阵分量提取而来）
                float3 worldPos = float3(i.TtoW0.w, i.TtoW1.w, i.TtoW2.w);
                // 计算世界空间下光照方向和视角方向
                fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));
                fixed3 viewDir = normalize(UnityWorldSpaceViewDir(worldPos));
                
                // 切线空间的法线方向 = 法线贴图采样
                fixed3 bump = UnpackNormal(tex2D(_BumpMap, i.uv.zw));
                // 凹凸映射 = 将切线空间的法线转换到世界空间
                bump = normalize(half3(dot(i.TtoW0.xyz, bump), dot(i.TtoW1.xyz, bump), dot(i.TtoW2.xyz, bump)));
                
                // 反射贴图 = 纹理采样 * 叠加颜色
                fixed3 albedo = tex2D(_MainTex, i.uv.xy).rgb * _Color.rgb;
                
                // 漫反射 =  入射光线颜色 * 反射贴图 * 取值为正数(反射方向 · 视角方向)
                // _LightColor0：该Pass处理的逐光源颜色，通过声明渲染路径后，由Unity传递给Shader的参数
                fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(bump, lightDir));
                
                // 使用宏对阴影纹理进行采样，输出到变量atten中
                UNITY_LIGHT_ATTENUATION(atten, i, worldPos);
                
                // 最终结果 = 漫反射 * 阴影 ， 透明度
                return fixed4(diffuse * atten, 1.0);
            }
            
            ENDCG
            
        }
    }
    FallBack "Diffuse"
}

Shader "Unity Shaders Book/Common/Bumped Specular"
{
    // 采用了Blinn-Phong光照模型的高光反射着色器
    // 思路：采用两个Pass，分别计算不同光源的渲染，主要取决于不同的渲染路径与预编译指令
    Properties
    {
        _Color ("Color Tint", Color) = (1, 1, 1, 1)
        _MainTex ("Main Tex", 2D) = "white" { }
        _BumpMap ("Normal Map", 2D) = "bump" { }
        // 高光反射颜色
        _Specular ("Specular Color", Color) = (1, 1, 1, 1)
        // 光滑度
        _Gloss ("Gloss", Range(8.0, 256)) = 20
    }
    SubShader
    {
        Tags { "RenderType" = "Opaque" "Queue" = "Geometry" }
        
        Pass
        {
            Tags { "LightMode" = "ForwardBase" }
            
            CGPROGRAM
            
            #pragma multi_compile_fwdbase
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
            
            fixed4 _Color;
            sampler2D _MainTex;
            float4 _MainTex_ST;
            sampler2D _BumpMap;
            float4 _BumpMap_ST;
            fixed4 _Specular;
            float _Gloss;
            
            struct a2v
            {
                float4 vertex: POSITION;
                float3 normal: NORMAL;
                float4 tangent: TANGENT;
                float4 texcoord: TEXCOORD0;
            };
            
            struct v2f
            {
                float4 pos: SV_POSITION;
                float4 uv: TEXCOORD0;
                float4 TtoW0: TEXCOORD1;
                float4 TtoW1: TEXCOORD2;
                float4 TtoW2: TEXCOORD3;
                SHADOW_COORDS(4)
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                
                o.uv.xy = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                o.uv.zw = v.texcoord.xy * _BumpMap_ST.xy + _BumpMap_ST.zw;
                // o.uv.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
                // o.uv.zw = TRANSFORM_TEX(v.texcoord, _BumpMap_ST);
                
                float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                // float3 worldPos = UnityObjectToWorldDir(v.vertex).xyz;
                fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);
                fixed3 worldTangent = UnityObjectToWorldDir(v.tangent.xyz);
                fixed3 worldBinormal = cross(worldNormal, worldTangent) * v.tangent.w;
                
                o.TtoW0 = float4(worldTangent.x, worldBinormal.x, worldNormal.x, worldPos.x);
                o.TtoW1 = float4(worldTangent.y, worldBinormal.y, worldNormal.y, worldPos.y);
                o.TtoW2 = float4(worldTangent.z, worldBinormal.z, worldNormal.z, worldPos.z);
                
                TRANSFER_SHADOW(o);
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                float3 worldPos = float3(i.TtoW0.w, i.TtoW1.w, i.TtoW2.w);
                // 计算世界空间下光照方向和视角方向
                fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));
                fixed3 viewDir = normalize(UnityWorldSpaceViewDir(worldPos));
                
                // 切线空间的法线方向 = 法线贴图采样
                fixed3 bump = UnpackNormal(tex2D(_BumpMap, i.uv.zw));
                bump = normalize(half3(dot(i.TtoW0.xyz, bump), dot(i.TtoW1.xyz, bump), dot(i.TtoW2.xyz, bump)));

                fixed3 albedo = tex2D(_MainTex, i.uv.xy).rgb * _Color.rgb;
                
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
                
                fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(bump, lightDir));
                
                // 半角方向
                fixed3 halfDir = normalize(lightDir + viewDir);
                // BlinnPhong高光反射 =  入射光线颜色 * 高光反射颜色 * n次平方(取值为正数(切线空间的法线方向 · 半角方向));	pow：次平方
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(bump, halfDir)), _Gloss);
                
                UNITY_LIGHT_ATTENUATION(atten, i, worldPos);

                // 最终结果 = 环境光 + （高光反射 + 漫反射） * 阴影 ， 透明度
                return fixed4(ambient + (diffuse + specular) * atten, 1.0);
            }
            
            ENDCG
            
        }
        
        Pass
        {
            Tags { "LightMode" = "ForwardAdd" }
            
            Blend One One
            
            CGPROGRAM
            
            #pragma multi_compile_fwdadd
            // Use the line below to add shadows for point and spot lights
            //			#pragma multi_compile_fwdadd_fullshadows
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
            
            fixed4 _Color;
            sampler2D _MainTex;
            float4 _MainTex_ST;
            sampler2D _BumpMap;
            float4 _BumpMap_ST;
            float _BumpScale;
            fixed4 _Specular;
            float _Gloss;
            
            struct a2v
            {
                float4 vertex: POSITION;
                float3 normal: NORMAL;
                float4 tangent: TANGENT;
                float4 texcoord: TEXCOORD0;
            };
            
            struct v2f
            {
                float4 pos: SV_POSITION;
                float4 uv: TEXCOORD0;
                float4 TtoW0: TEXCOORD1;
                float4 TtoW1: TEXCOORD2;
                float4 TtoW2: TEXCOORD3;
                SHADOW_COORDS(4)
            };
            
            v2f vert(a2v v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                
                o.uv.xy = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                o.uv.zw = v.texcoord.xy * _BumpMap_ST.xy + _BumpMap_ST.zw;
                // o.uv.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
                // o.uv.zw = TRANSFORM_TEX(v.texcoord, _BumpMap_ST);

                float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                // float3 worldPos = UnityObjectToWorldDir(v.vertex).xyz;
                fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);
                fixed3 worldTangent = UnityObjectToWorldDir(v.tangent.xyz);
                fixed3 worldBinormal = cross(worldNormal, worldTangent) * v.tangent.w;
                
                o.TtoW0 = float4(worldTangent.x, worldBinormal.x, worldNormal.x, worldPos.x);
                o.TtoW1 = float4(worldTangent.y, worldBinormal.y, worldNormal.y, worldPos.y);
                o.TtoW2 = float4(worldTangent.z, worldBinormal.z, worldNormal.z, worldPos.z);
                
                TRANSFER_SHADOW(o);
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                float3 worldPos = float3(i.TtoW0.w, i.TtoW1.w, i.TtoW2.w);
                fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));
                fixed3 viewDir = normalize(UnityWorldSpaceViewDir(worldPos));
                
                fixed3 bump = UnpackNormal(tex2D(_BumpMap, i.uv.zw));
                bump = normalize(half3(dot(i.TtoW0.xyz, bump), dot(i.TtoW1.xyz, bump), dot(i.TtoW2.xyz, bump)));
                
                fixed3 albedo = tex2D(_MainTex, i.uv.xy).rgb * _Color.rgb;
                
                fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(bump, lightDir));
                
                // 半角方向
                fixed3 halfDir = normalize(lightDir + viewDir);
                // BlinnPhong高光反射 =  入射光线颜色 * 高光反射颜色 * n次平方(取值为正数(切线空间的法线方向 · 半角方向));	pow：次平方
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(bump, halfDir)), _Gloss);
                
                UNITY_LIGHT_ATTENUATION(atten, i, worldPos);

                // 最终结果 = （高光反射 + 漫反射） * 阴影 ， 透明度
                return fixed4((diffuse + specular) * atten, 1.0);
            }
            
            ENDCG
            
        }
    }
    FallBack "Specular"
}