1
Shader "Unlit/Chapter10-Reflection"
2
{
3
    Properties
4
    {
5
        _Color ("Color Tint",Color) = (1,1,1,1)
6
        _ReflectColor ("Reflection Color",Color) = (1,1,1,1)
7
        _ReflectAmount ("Reflection Amount",Range(0,1)) = 1
8
        _Cubemap ("Reflection Cubemap",Cube) = "_Skybox" {}//Cubemap资源，事先使用脚本生成
9
    }
10
    SubShader
11
    {
12

13
        Pass
14
        {
15
            CGPROGRAM
16
            #pragma vertex vert
17
            #pragma fragment frag
18

19
            #include "Lighting.cginc"
20
            #include "AutoLight.cginc"
21

22
            fixed3 _Color;
23
            fixed3 _ReflectColor;
24
            fixed _ReflectAmount;
25
            samplerCUBE _Cubemap;
26

27
            struct a2v
28
            {
29
                float4 vertex : POSITION;
30
                float3 normal:NORMAL;
31
            };
32

33
            struct v2f
34
            {
35
                float4 pos : SV_POSITION;
36
                float3 worldNormal:TEXCOORD0;
37
                float3 worldPos:TEXCOORD1;
38
                float3 worldViewDir:TEXCOORD2;
39
                float3 worldRefl:TEXCOORD3;
40
                SHADOW_COORDS(4)
41
            };
42

43
            v2f vert (a2v v)
44
            {
45
                v2f o;
46
                o.pos = UnityObjectToClipPos(v.vertex);
47
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
48
                o.worldPos = mul(unity_ObjectToWorld,v.vertex).xyz;
49
                o.worldViewDir = UnityWorldSpaceViewDir(o.worldPos);
50
                o.worldRefl = reflect(-o.worldViewDir,o.worldNormal);
51
                TRANSFER_SHADOW(o);
52
                return o;
53
            }
54

55
            fixed4 frag (v2f i) : SV_Target
56
            {
57
                float3 worldNormal = normalize(i.worldNormal);
58
                float3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
59
                float3 worldViewDir = normalize(i.worldViewDir);
60

61
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;
62
                fixed3 diffuse = _LightColor0.rgb*_Color.rgb*saturate(dot(worldLightDir,worldNormal));
63
                fixed3 reflect = texCUBE(_Cubemap,i.worldRefl).rgb*_ReflectColor.rgb;
64

65
                UNITY_LIGHT_ATTENUATION(atten,i,i.worldPos);
66

67
                fixed3 color = ambient+lerp(diffuse,reflect,_ReflectAmount)*atten;
68
                return fixed4(color,1.0);
69
            }
70
            ENDCG
71
        }
72
    }
73
}

1
Shader "Unlit/Chapter10-Refraction"
2
{
3
    Properties
4
    {
5
        _Color ("Color Tint",Color) = (1,1,1,1)
6
        _RefractColor ("Refraction Color",Color) = (1,1,1,1)
7
        _RefractAmount ("Refraction Amount",Range(0,1)) = 1
8
        _RefractRatio ("Refraction Ratio",Range(0.1,1)) = 0.5
9
        _Cubemap ("Refraction Cubemap",Cube) = "_Skybox"{}
10
    }
11
    SubShader
12
    {
13
        Pass
14
        {
15
            CGPROGRAM
16
            #pragma vertex vert
17
            #pragma fragment frag
18

19
            #include "Lighting.cginc"
20
            #include "AutoLight.cginc"
21

22
            fixed3 _Color;
23
            fixed3 _RefractColor;
24
            fixed _RefractAmount;
25
            fixed _RefractRatio;
26
            samplerCUBE _Cubemap;
27

28
            struct a2v
29
            {
30
                float4 vertex : POSITION;
31
                float3 normal : NORMAL;
32
            };
33

34
            struct v2f
35
            {
36
                float4 pos : SV_POSITION;
37
                float3 worldPos : TEXCOORD0;
38
                float3 worldNormal : TEXCOORD1;
39
                float3 worldViewDir : TEXCOORD2;
40
                float3 worldRefr : TEXCOORD3;
41
                SHADOW_COORDS(4)
42
            };
43

44
            v2f vert (a2v v)
45
            {
46
                v2f o;
47
                o.pos = UnityObjectToClipPos(v.vertex);
48
                o.worldPos = mul(unity_ObjectToWorld,v.vertex).xyz;
49
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
50
                o.worldViewDir = UnityWorldSpaceViewDir(o.worldPos);//从相机指向物体
51
                o.worldRefr = refract(normalize(-o.worldViewDir),normalize(o.worldNormal),_RefractRatio);//refract函数需要的视线方向是从物体指向相机
52
                TRANSFER_SHADOW(o);
53
                return o;
54
            }
55

56
            fixed4 frag (v2f i) : SV_Target
57
            {
58
                float3 worldNormal = normalize(i.worldNormal);
59
                float3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
60

61
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;
62
                fixed3 diffuse = _LightColor0.rgb*_Color.rgb*saturate(dot(worldNormal,worldLightDir));
63
                fixed3 refraction = texCUBE(_Cubemap,i.worldRefr).rgb*_RefractColor.rgb;
64
                UNITY_LIGHT_ATTENUATION(atten,i,i.worldPos);
65
                fixed3 color = ambient+lerp(diffuse,refraction,_RefractAmount)*atten;
66
                return fixed4(color,1.0);
67
            }
68
            ENDCG
69
        }
70
    }
71
}

1
Shader "Unlit/Chapter10-Fresnel"
2
{
3
    Properties
4
    {
5
        _Color ("Color Tint",Color) = (1,1,1,1)
6
        _FresnelScale ("Fresnel Scale",Range(0,1)) = 0.5
7
        _Cubemap ("Reflection Cubemap",Cube) = "_Skybox"{}
8
    }
9
    SubShader
10
    {
11

12
        Pass
13
        {
14
            CGPROGRAM
15
            #pragma vertex vert
16
            #pragma fragment frag
17

18
            #include "Lighting.cginc"
19
            #include "AutoLight.cginc"
20
            fixed3 _Color;
21
            fixed _FresnelScale;
22
            samplerCUBE _Cubemap;
23

24
            struct a2v
25
            {
26
                float4 vertex : POSITION;
27
                float3 normal : NORMAL;
28
            };
29

30
            struct v2f
31
            {
32
                float4 pos : SV_POSITION;
33
                float3 worldPos : TEXCOORD0;
34
                float3 worldNormal : TEXCOORD1;
35
                float3 worldViewDir : TEXCOORD2;
36
                float3 worldRefl : TEXCOORD3;
37
                SHADOW_COORDS(4)
38
            };
39

40
            v2f vert (a2v v)
41
            {
42
                v2f o;
43
                o.pos = UnityObjectToClipPos(v.vertex);
44
                o.worldPos = mul(unity_ObjectToWorld,v.vertex).xyz;
45
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
46
                o.worldViewDir = UnityWorldSpaceViewDir(o.worldPos);
47
                o.worldRefl = reflect(-o.worldViewDir,o.worldNormal);
48
                TRANSFER_SHADOW(o);
49
                return o;
50
            }
51

52
            fixed4 frag (v2f i) : SV_Target
53
            {
54
                float3 worldNormal = normalize(i.worldNormal);
55
                float3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
56
                float3 worldViewDir = normalize(i.worldViewDir);
57

58
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;
59
                fixed3 diffuse = _LightColor0.rgb*_Color.rgb*saturate(dot(worldNormal,worldLightDir));
60
                fixed3 reflection = texCUBE(_Cubemap,i.worldRefl).rgb;
61
                fixed fresnel = _FresnelScale+(1-_FresnelScale)*pow(1-dot(worldViewDir,worldNormal),5);
62
                UNITY_LIGHT_ATTENUATION(atten,i,i.worldPos);
63
                fixed3 color = ambient+lerp(diffuse,reflection,saturate(fresnel))*atten;
64
                return fixed4(color,1.0);
65
            }
66
            ENDCG
67
        }
68
    }
69
}

1
Shader "Unlit/Chapter10-Mirro"
2
{
3
    Properties
4
    {
5
        _MainTex ("Texture", 2D) = "white" {}
6
    }
7
    SubShader
8
    {
9

10
        Pass
11
        {
12
            CGPROGRAM
13
            #pragma vertex vert
14
            #pragma fragment frag
15

16
            #include "Lighting.cginc"
17

18
            struct a2v
19
            {
20
                float4 vertex : POSITION;
21
                float2 texcoord : TEXCOORD0;
22
            };
23

24
            struct v2f
25
            {
26
                float2 uv : TEXCOORD0;
27
                float4 pos : SV_POSITION;
28
            };
29

30
            sampler2D _MainTex;
31
            float4 _MainTex_ST;
32

33
            v2f vert (a2v v)
34
            {
35
                v2f o;
36
                o.pos = UnityObjectToClipPos(v.vertex);
37
                o.uv = v.texcoord;
38
                o.uv.x = 1-o.uv.x;
39
                return o;
40
            }
41

42
            fixed4 frag (v2f i) : SV_Target
43
            {
44
                return tex2D(_MainTex,i.uv);
45
            }
46
            ENDCG
47
        }
48
    }
49
}

1
Shader "Unlit/Chapter11-ImageSequenceAnimation"
2
{
3
    Properties
4
    {
5
    _Color ("Color Tint",Color) = (1,1,1,1)
6
    _MainTex ("Image Sequence", 2D) = "white" {}
7
    _HorizontalAmount ("Horizontal Amount",Float) = 4//每行有几帧小图
8
    _VerticalAmount ("Vertical Amount",Float) = 4//每列有几帧小图
9
    _Speed ("Speed",Range(1,100)) = 30
10
    }
11
    SubShader
12
    {
13
        Tags { "RenderType"="Transparent" "Queue" = "Transparent" "IgnoreProjector" = "True" }//关键帧图像_MainTex通常是透明纹理，因此被当作一个半透明对象
14

15
        Pass
16
        {
17
            Tags {"LightMode" = "ForwardBase"}//为什么需要声明渲染模式
18
            ZWrite Off
19
            Blend SrcAlpha OneMinusSrcAlpha//关闭深度写入和声明混合模式都是渲染透明度混合物体的标配
20
            CGPROGRAM
21
            #pragma vertex vert
22
            #pragma fragment frag
23

24
            #include "Lighting.cginc"
25

26
            struct a2v
27
            {
28
                float4 vertex : POSITION;
29
                float2 texcoord : TEXCOORD0;
30
            };
31

32
            struct v2f
33
            {
34
                float2 uv : TEXCOORD0;
35
                float4 pos : SV_POSITION;
36
            };
37

38
            fixed3 _Color;
39
            sampler2D _MainTex;
40
            float4 _MainTex_ST;
41
            float _HorizontalAmount;
42
            float _VerticalAmount;
43
            float _Speed;
44

45
            v2f vert (a2v v)
46
            {
47
                v2f o;
48
                o.pos = UnityObjectToClipPos(v.vertex);
49
                o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
50
                return o;
51
            }
52

53
            fixed4 frag (v2f i) : SV_Target
54
            {
55
                float offset = floor(_Time.y*_Speed);//_Speed是每秒多少帧，_Time.y是游戏运行时间，二者相乘得到当前应该播放第几帧
56
                //计算当前帧在序列帧图像的第几行、第几列
57
                float row = floor(offset/_HorizontalAmount);//总帧数/一行有多少帧=行数
58
                float column = offset - row*_HorizontalAmount;//总帧数%一行有多少帧=列数<=>总帧数-行数*每行的帧数=剩余的这一行的帧数=这一行的列数
59

60
                half2 uv = float2(i.uv.x / _HorizontalAmount,i.uv.y / _VerticalAmount);//计算第一帧开始时的UV坐标（整张序列帧的UV范围是0-1，但每次只需移动其中一个小图，所以先把UV缩放到左上角第一个小图的起始处）
61
                uv.x += column / _HorizontalAmount;//从第一个小图开始偏移row行、column列
62
                uv.y -= row / _VerticalAmount;//往下偏移row行，因为Unity中纹理坐标原点在左下角，从下往上增大；序列帧纹理（美术）原点在左上角，从上往下增大。现在是往序列帧纹理的下方偏移，所以对uv来说是减小
63
                //half2 uv = i.uv + half2(column,-row);//这种写法是把uv的+-操作统一起来表示
64
                //uv.x /= _HorizontalAmount;
65
                //uv.y /= _VerticalAmount;
66

67
                fixed4 c = tex2D(_MainTex,uv);//使用偏移后的uv采样_MainTex
68
                c.rgb*=_Color;//需要乘上物体本来的颜色
69
                return c;
70
            }
71
            ENDCG
72
        }
73
    }
74
    Fallback "Transparent/VertexLit"//半透明物体的Fallback
75
}

1
Shader "Unlit/Chapter11-ScrollingBackground"
2
{
3
    Properties
4
    {
5
        _MainTex ("Base Layer(RGB)",2D) = "white"{}//第一层（较远）纹理
6
        _DetailTex ("2nd Layer(RGB)",2D) = "white"{}//第二层（较近）纹理
7
        _ScrollX("Base layer Scroll Speed",Float) = 1.0//第一层纹理的水平滚动速度
8
        _Scroll2X("2nd layer Scroll Speed",Float) = 1.0//第二层纹理的水平滚动速度
9
        _Multiplier("Layer Multiplier",Float) = 1//纹理的整体亮度 美术需要、整体曝光
10
    }
11
    SubShader
12
    {
13

14
        Pass
15
        {
16
            CGPROGRAM
17
            #pragma vertex vert
18
            #pragma fragment frag
19

20
            #include "Lighting.cginc"
21

22
            sampler2D _MainTex;
23
            float4 _MainTex_ST;
24
            sampler2D _DetailTex;
25
            float4 _DetailTex_ST;
26
            float _ScrollX;
27
            float _Scroll2X;
28
            float _Multiplier;
29

30
            struct a2v
31
            {
32
                float4 vertex : POSITION;
33
                float4 texcoord : TEXCOORD0;
34
            };
35

36
            struct v2f
37
            {
38
                float4 uv : TEXCOORD0;
39
                float4 pos : SV_POSITION;
40
            };
41

42
            v2f vert (a2v v)
43
            {
44
                v2f o;
45
                o.pos = UnityObjectToClipPos(v.vertex);
46
                o.uv.xy = TRANSFORM_TEX(v.texcoord, _MainTex)+frac(float2(_ScrollX,0.0)*_Time.y);//TRANSFORM_TEX获得的是贴图固有的采样坐标（加了贴图缩放和偏移的影响）；_ScrollX*_Time.y是计算到目前为止，水平方向走了多少帧，这个值会随着_Time.y的增大而无限增大。又因为uv是二维坐标，所以需要将这个值转为二维向量，因为只是水平移动，所以y分量直接为0.且由于uv坐标是0-1，所以需要使用frac只取这个值的小数部分，将其限制在0-1之间，且无限循环滚动
47
                o.uv.zw = TRANSFORM_TEX(v.texcoord, _DetailTex)+frac(float2(_Scroll2X,0.0)*_Time.y);
48
                return o;
49
            }
50

51
            fixed4 frag (v2f i) : SV_Target
52
            {
53
                fixed4 firstLayer = tex2D(_MainTex,i.uv.xy);
54
                fixed4 secondLayer = tex2D(_DetailTex,i.uv.zw);
55
                fixed4 color = lerp(firstLayer,secondLayer,secondLayer.a);//近景是叠加在远景之上，近景中透明部分能够透出背景
56
                color.rgb*=_Multiplier;
57
                return color;
58
            }
59
            ENDCG
60
        }
61
    }
62
    Fallback "VertexLit"
63
}