【Aladdin Unity3D Shader编程】之二 光照模型(一)

光照模型

光照模型就是一个公式，使用这个公式来计算在某个点的光照效果。

在标准光照模型里面，我们把进入摄像机的光分为下面四个部分：

  • 自发光

    类似生活中的萤火虫等自己能够发光

  • 高光反射

    类似生活中的镜子，近似认为百分百反射出去

  • 漫反射

    类似生活中的光照射到墙壁上、桌子上的反光不会百分百反射出去，各个方向都会反射。

  • 环境光

    类似生活中的光照照射在某个物体上，物体漫反射然后反射到其他物体上这些过程的光是环境光。

以上都是模拟生活中的光照效果，并不等同于实际生活中的光照计算，实际生活中的光照会更加复杂。

光照模型中关于漫反射的计算

漫反射计算放在顶点函数里面就是逐顶点光照

Disffuse = 直射光颜色*max(0,cosθ) (θ是法线跟光照的夹角) 如果夹角小于0的话就是背光面就直接取黑色

理论知识:

  • 向量点乘(结果值)
a*b=|a||b|cosθ
  • 向量叉乘(结果是向量)
a*b=c  c的一个向量，值是|a||b|sinθ

编写漫反射Shader

在Pass块里添加Tags{“LightMode”=”ForwardBase”}和#include “Lighting.cginc” //引用一些写好的程序块 会包含一些获取光照的信息

只有定义了正确的LightMode才能得到一些Unity的内置光照变量。

  • normalize() 将一个向量单位化
  • max()用来取得函数中最大的一个
  • dot()用来取得两个向量的点积
  • _WorldSpaceLightPos0取得平行光的位置
  • _LightColor0取得平行光的颜色

UNITY_MATRIX_MVP 这个矩阵是将模型空间转换到剪裁空间

  • _World2Object这个矩阵用来将一个方向从时间空间转换到模型空间
  • UNITY_LIGHTMODEL_AMBIENT 用来获取环境光
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

Shader "AladdinShader/04 Diffuse Tertex Shader"

{

    Properties

    {



    }



    SubShader {

        Pass 

        {

            Tags{"LightMode"="ForwardBase"}



        CGPROGRAM

#include "Lighting.cginc" //引用一些写好的程序块 会包含一些获取光照的信息  

//_LightColor0 取得第一个直射光的颜色

//_WorldSpaceLightPos0 

#pragma vertex vert

#pragma fragment frag 

        struct a2v 

        {

            float4 vertex:POSITION;

            float3 normal:NORMAL; //模型空间下法线

        };

        struct v2f

        {

            float4 position:SV_POSITION;

            fixed3 color:COLOR;

        };

        v2f vert(a2v v)

        {

            v2f f;

            f.position = mul(UNITY_MATRIX_MVP, v.vertex);

            //获得世界空间的单位法线向量

            fixed3 normalDir = normalize(mul(v.normal, (float3x3)unity_WorldToObject)); //从模型空间转到世界空间 float3x3 将一个4*4的矩阵强转成3*3的矩阵

            //世界空间下的光照位置

            fixed3  lightDir = _WorldSpaceLightPos0.xyz; //对于每一个点来说每一个光的位置就是光的方向（针对平行光）

            //取得漫反射的颜色

            fixed3 diffuse = _LightColor0.rgb * max(0, dot(normalDir, lightDir));//取得第一个直射光的颜色

            f.color = diffuse;

            return f;

        }

        fixed4 frag(v2f f):SV_Target

        {

            return fixed4(f.color,1);

        }

        ENDCG

        }

    }

    FallBack  "VertexLit"

}

效果：

没有写反射光照之前的效果，红色是均匀的

这里写图片描述

写了光照效果之后，会看到正对光照地方很亮，背对光照的地方就很暗甚至黑色。

这里写图片描述

现在是逐顶点光照，顶点的数量是有限的，如果将计算放在片元函数里面计算效果会更好，但计算量也会更大，那就叫逐片元光照。

给物体自身添加颜色和环境光共同控制

上面物体的颜色只是受环境光的颜色影响，但实际生活中我们看到的物体的颜色是环境光和自身颜色混合的效果。我们在上面的例子的基础上，添加上物体本身的颜色：

给物体添加颜色属性然后*环境光

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

Shader "AladdinShader/04 Diffuse Tertex Shader"

{

    Properties

    {

        _Diffuse("Diffuse",Color)=(1,1,1,1) //添加自身的颜色

    }

    SubShader {

        Pass 

        {

            Tags{"LightMode"="ForwardBase"}

        CGPROGRAM

#include "Lighting.cginc" //引用一些写好的程序块 会包含一些获取光照的信息  

//_LightColor0 取得第一个直射光的颜色

//_WorldSpaceLightPos0 

#pragma vertex vert

#pragma fragment frag 

        fixed4 _Diffuse;

        struct a2v 

        {

            float4 vertex:POSITION;

            float3 normal:NORMAL; //模型空间下法线

        };

        struct v2f

        {

            float4 position:SV_POSITION;

            fixed3 color:COLOR;

        };

        v2f vert(a2v v)

        {

            v2f f;

            f.position = mul(UNITY_MATRIX_MVP, v.vertex);

            fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.rgb;//获得系统内置的环境光

            //获得世界空间的单位法线向量

            fixed3 normalDir = normalize(mul(v.normal, (float3x3)unity_WorldToObject)); //从模型空间转到世界空间 float3x3 将一个4*4的矩阵强转成3*3的矩阵

            //世界空间下的光照位置

            fixed3  lightDir = _WorldSpaceLightPos0.xyz; //对于每一个点来说每一个光的位置就是光的方向（针对平行光）

            //取得漫反射的颜色

            fixed3 diffuse = _LightColor0.rgb * max(0, dot(normalDir, lightDir)) * _Diffuse.rgb;//取得第一个直射光的颜色 颜色融合

            f.color = diffuse + ambient;  //颜色增加 增强

            return f;

        }

        fixed4 frag(v2f f):SV_Target

        {

            return fixed4(f.color,1);

        }

        ENDCG

        }

    }

    FallBack  "VertexLit"

}

效果：

这里写图片描述

这样直射光设置成白色，颜色本身设置成绿色，并且在面板中调整颜色，物体就显示成这种颜色。颜色融合一般是颜色的改变，颜色相加是强度增强。

环境光设置:Window->Lighting->Ambient Source->Color 一般不建议很强的环境光

逐像素光照

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

Shader "AladdinShader/05 Diffuse fragment Shader"

{

    Properties

    {

        _Diffuse("Diffuse",Color)=(1,1,1,1) //添加自身的颜色

    }

    SubShader {

        Pass 

        {

            Tags{"LightMode"="ForwardBase"}

        CGPROGRAM

#include "Lighting.cginc" //引用一些写好的程序块 会包含一些获取光照的信息  

//_LightColor0 取得第一个直射光的颜色

//_WorldSpaceLightPos0 

#pragma vertex vert

#pragma fragment frag 

        fixed4 _Diffuse;

        struct a2v 

        {

            float4 vertex:POSITION;

            float3 normal:NORMAL; //模型空间下法线

        };

        struct v2f

        {

            float4 position:SV_POSITION;

            fixed3 worldNormalDir:COLOR0;

        };

        v2f vert(a2v v)

        {

            v2f f;

            f.position = mul(UNITY_MATRIX_MVP, v.vertex);

            f.worldNormalDir = mul(v.normal, (float3x3)unity_WorldToObject);

            return f;

        }

        fixed4 frag(v2f f):SV_Target

        {

            fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.rgb;//获得系统内置的环境光

            //获得世界空间的单位法线向量

            fixed3 normalDir = normalize(f.worldNormalDir); //从模型空间转到世界空间 float3x3 将一个4*4的矩阵强转成3*3的矩阵

            //世界空间下的光照位置

            fixed3  lightDir = _WorldSpaceLightPos0.xyz; //对于每一个点来说每一个光的位置就是光的方向（针对平行光）

            //取得漫反射的颜色

            fixed3 diffuse = _LightColor0.rgb * max(0, dot(normalDir, lightDir)) * _Diffuse.rgb;//取得第一个直射光的颜色 颜色融合

            fixed3 tempColor = diffuse + ambient;  //颜色增加 增强

            return fixed4(tempColor,1);

        }

        ENDCG

        }

    }

    FallBack  "VertexLit"

}

效果图：

这里写图片描述

一个是逐顶点光照，一个是逐像素光照，自己看还是能看出区别的。逐像素光照会更消耗性能一些，如果不需要很高的精度的话就可以用逐顶点光照代替。

半兰伯特光照模型

模型表面的明亮度直接取决于光线向量（light vector）和表面法线（normal）两个向量将夹角的余弦值。

如果漫反射光强设置为Diffuse，入射光光强为I，光方向和法线夹角为θ，那么兰伯特光照模型可以用下面的公式表示：Diffuse = I * cosθ。

兰伯特光照模型 模型背面全都是黑色都看不清楚

这里写图片描述

为了解决这个问题，改造一些兰伯特光照模型的公式，让背光部分也随着光照强度改变而改变。

半兰伯特光照模型：

为了解决兰伯特模型背光面全都是黑的看不清楚的问题。

Diffuse=直射光颜色 (cosθ 0.5 + 0.5)

这里写图片描述

Shader修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

Shader "AladdinShader/06 Diffuse fragment Half Lanbote Shader"

{

    Properties

    {

        _Diffuse("Diffuse",Color)=(1,1,1,1) //添加自身的颜色

    }

    SubShader {

        Pass 

        {

            Tags{"LightMode"="ForwardBase"}

        CGPROGRAM

#include "Lighting.cginc" //引用一些写好的程序块 会包含一些获取光照的信息  

//_LightColor0 取得第一个直射光的颜色

//_WorldSpaceLightPos0 

#pragma vertex vert

#pragma fragment frag 

        fixed4 _Diffuse;

        struct a2v 

        {

            float4 vertex:POSITION;

            float3 normal:NORMAL; //模型空间下法线

        };

        struct v2f

        {

            float4 position:SV_POSITION;

            fixed3 worldNormalDir:COLOR0;

        };

        v2f vert(a2v v)

        {

            v2f f;

            f.position = mul(UNITY_MATRIX_MVP, v.vertex);

            f.worldNormalDir = mul(v.normal, (float3x3)unity_WorldToObject);

            return f;

        }

        fixed4 frag(v2f f):SV_Target

        {

            fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.rgb;//获得系统内置的环境光

            //获得世界空间的单位法线向量

            fixed3 normalDir = normalize(f.worldNormalDir); //从模型空间转到世界空间 float3x3 将一个4*4的矩阵强转成3*3的矩阵

            //世界空间下的光照位置

            fixed3  lightDir = _WorldSpaceLightPos0.xyz; //对于每一个点来说每一个光的位置就是光的方向（针对平行光）

            float halfLambert = dot(normalDir, lightDir) * 0.5 + 0.5; //半兰伯特光照模型

            //取得漫反射的颜色

            fixed3 diffuse = _LightColor0.rgb * halfLambert * _Diffuse.rgb;//取得第一个直射光的颜色 颜色融合

            fixed3 tempColor = diffuse + ambient;  //颜色增加 增强

            return fixed4(tempColor,1);

        }

        ENDCG

        }

    }

    FallBack  "VertexLit"

}

这里写图片描述

会明显的感觉模型亮度变亮了，而且背面也不会纯黑了也会渐变，而且正面颜色也会鲜明一些，这样整体效果会更好一些。

高光反射模型

Specular=直射光*pow(max(cosθ,0),高光的参数) θ:是反射光和视野方向的夹角

pow:余弦值的X次方

编写高光反射Shader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

Shader "AladdinShader/07 Specular Vertex Shader"

{

    Properties

    {

        _Diffuse("Diffuse",Color)=(1,1,1,1) //添加自身的颜色

    }

    SubShader {

        Pass 

        {

            Tags{"LightMode"="ForwardBase"}



        CGPROGRAM



#include "Lighting.cginc" //引用一些写好的程序块 会包含一些获取光照的信息  



//_LightColor0 取得第一个直射光的颜色

//_WorldSpaceLightPos0 

#pragma vertex vert

#pragma fragment frag 

        fixed4 _Diffuse;

        struct a2v 

        {

            float4 vertex:POSITION;

            float3 normal:NORMAL; //模型空间下法线

        };

        struct v2f

        {

            float4 position:SV_POSITION;

            fixed3 color:COLOR;

        };



        v2f vert(a2v v)

        {

            v2f f;

            f.position = mul(UNITY_MATRIX_MVP, v.vertex);

            fixed3 adbient = UNITY_LIGHTMODEL_AMBIENT.rgb;

            fixed3 normalDir = normalize(mul(v.normal,(float3x3)unity_WorldToObject));

            fixed3 lightDir = normalize(_WorldSpaceLightPos0.xyz);//对于每个顶点来说 光的位置就是光的方向 因为是平行光

            fixed3 diffuse = _LightColor0.rgb * max(dot(normalDir,lightDir), 0) * _Diffuse.rgb;//取得漫反射的颜色

            //反射光方向

            fixed3 reflectDir = normalize(reflect(-lightDir,normalDir));

            //视野方向

            //相机是在世界空间下              

            fixed3 viewDir = normalize(_WorldSpaceCameraPos.xyz - mul(v.vertex,unity_WorldToObject).xyz);

            //高光反射

            fixed3 specular = _LightColor0.rgb * pow(max(dot(reflectDir,viewDir),0),10);

            f.color = diffuse + adbient + specular;

            return f;

        }

        fixed4 frag(v2f f):SV_Target

        {

            return fixed4(f.color, 1);

        }

        ENDCG

        }

    }

    FallBack  "VertexLit"

}

效果图:

添加_Gloss和SpecularColor控制高光大小和高光颜色

添加一个Range属性，将X次幂的值改成Range属性，做如下修改：

1
2
3
4
5
6

_Gloss("Gloss",Range(8,200)) = 10

//高光反射

fixed3 specular = _LightColor0.rgb * pow(max(dot(reflectDir,viewDir),0),_Gloss);

就会看到高光光圈随着_Gloss改变而改变

想要改变高光部分的颜色控制，我们添加一个颜色变量然后将高光颜色与我们设置的颜色属性进行融合计算就会得到新的高光部分的颜色

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

Shader "AladdinShader/07 Specular Vertex Shader"

{

    Properties

    {

        _Diffuse("Diffuse",Color)=(1,1,1,1) //添加自身的颜色

        _Specular("Specular",Color)=(1,1,1,1)

        _Gloss("Gloss",Range(8,200)) = 10

    }

    SubShader {

        Pass 

        {

            Tags{"LightMode"="ForwardBase"}

        CGPROGRAM

#include "Lighting.cginc" //引用一些写好的程序块 会包含一些获取光照的信息  

//_LightColor0 取得第一个直射光的颜色

//_WorldSpaceLightPos0 

#pragma vertex vert

#pragma fragment frag 

        fixed4 _Diffuse;

        fixed4 _Specular;

        half _Gloss;

        struct a2v 

        {

            float4 vertex:POSITION;

            float3 normal:NORMAL; //模型空间下法线

        };

        struct v2f

        {

            float4 position:SV_POSITION;

            fixed3 color:COLOR;

        };



        v2f vert(a2v v)

        {

            v2f f;

            f.position = mul(UNITY_MATRIX_MVP, v.vertex);

            fixed3 adbient = UNITY_LIGHTMODEL_AMBIENT.rgb;

            fixed3 normalDir = normalize(mul(v.normal,(float3x3)unity_WorldToObject));

            fixed3 lightDir = normalize(_WorldSpaceLightPos0.xyz);//对于每个顶点来说 光的位置就是光的方向 因为是平行光

            fixed3 diffuse = _LightColor0.rgb * max(dot(normalDir,lightDir), 0) * _Diffuse.rgb;//取得漫反射的颜色

            //反射光方向

            fixed3 reflectDir = normalize(reflect(-lightDir,normalDir));

            //视野方向

            //相机是在世界空间下              

            fixed3 viewDir = normalize(_WorldSpaceCameraPos.xyz - mul(v.vertex,unity_WorldToObject).xyz);

            //高光反射

            fixed3 specular = _LightColor0.rgb * pow(max(dot(reflectDir,viewDir),0),_Gloss) * _Specular.rgb;

            f.color = diffuse + adbient + specular;

            return f;

        }

        fixed4 frag(v2f f):SV_Target

        {

            return fixed4(f.color, 1);

        }

        ENDCG

        }

    }

    FallBack  "VertexLit"

}

效果图:

逐像素高光反射

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128



Shader "AladdinShader/08 Specular Fragment Shader"

{

    Properties

    {

        _Diffuse("Diffuse",Color)=(1,1,1,1) //添加自身的颜色

        _Specular("Specular",Color)=(1,1,1,1)

        _Gloss("Gloss",Range(8,200)) = 10

    }

    SubShader {

        Pass 

        {

            Tags{"LightMode"="ForwardBase"}

        CGPROGRAM



#include "Lighting.cginc" //引用一些写好的程序块 会包含一些获取光照的信息  

//_LightColor0 取得第一个直射光的颜色

//_WorldSpaceLightPos0 

#pragma vertex vert

#pragma fragment frag 

        fixed4 _Diffuse;

        fixed4 _Specular;

        half _Gloss;

        struct a2v 

        {

            float4 vertex:POSITION;

            float3 normal:NORMAL; //模型空间下法线

        };

        struct v2f

        {

            float4 position:SV_POSITION;

            float3 worldNormal:TEXCOORD0;//世界空间下的法线方向 

            float3 worldVertext:TEXCOORD1;//时间空间下的顶点坐标

        };

        v2f vert(a2v v)

        {

            v2f f;

            f.position = mul(UNITY_MATRIX_MVP, v.vertex);

            f.worldNormal = mul(v.normal, (float3x3)unity_WorldToObject);

            f.worldVertext = mul(v.vertex , unity_WorldToObject).xyz;

            return f;

        }



        fixed4 frag(v2f f):SV_Target

        {

            fixed3 adbient = UNITY_LIGHTMODEL_AMBIENT.rgb;

            fixed3 normalDir = normalize(f.worldNormal);

            fixed3 lightDir = normalize(_WorldSpaceLightPos0.xyz);//对于每个顶点来说 光的位置就是光的方向 因为是平行光

            fixed3 diffuse = _LightColor0.rgb * max(dot(normalDir,lightDir), 0) * _Diffuse.rgb;//取得漫反射的颜色

            //反射光方向

            fixed3 reflectDir = normalize(reflect(-lightDir,normalDir));

            //视野方向

            //相机是在世界空间下              

            fixed3 viewDir = normalize(_WorldSpaceCameraPos.xyz - f.worldVertext);

            //高光反射

            fixed3 specular = _LightColor0.rgb * pow(max(dot(reflectDir,viewDir),0),_Gloss) * _Specular.rgb;

            fixed3 tempColor = diffuse + adbient + specular;

            return fixed4(tempColor, 1);

        }

        ENDCG

        }

    }

    FallBack  "VertexLit"

}

效果图:

会比逐顶点高光效果更好一些，背光面可以考虑之前说的半兰伯特来处理，这样就不会显示全黑效果不好的情况。

赏

努力赚奶粉钱

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一名<br>爱写代码的<br>码农