Unity Shader-边缘光(RimLight)效果

http://blog.csdn.net/puppet_master/article/details/53548134

简介

写了两篇简单光照模型的shader的文章，虽然Unity自带的shader就有diffuse和specular，效果还比自己写的好，然而要想学好shader，基础还是很重要的。不然到网上到处找shader，扔到项目里，能用就好，完全不看性能的话，迟早会出事的。今天不看光照模型了，物理渲染还没搞懂，所以只好先来个简单的shader玩一玩。正好最近在和某基友玩黑魂，这货一出来总是自带一个特效-边缘光。于是本人强迫症发作，决定研究一下这个怎么实现。

RimLight--边缘发光效果，是一个比较常用的效果，实现简单，在普通的光照计算后只需要两步操作，就可以实现边缘光效果。看下面一幅图，简单介绍一下RimLight的原理：

所谓RimLight边缘发光，也就是说对应我们当前视角方向，物体上位于边缘的地方额外加一个光的效果。那么，怎么判断一个点是否在物体的边缘呢？就是通过法线方向和视线方向的夹角来判断。当视线方向V与法线方向N垂直时，这个法线对应的面就与视线方向平行，说明当前这个点对于当前视角来说，就处在边缘；而视线方向与法线方向一致时，这个法线对应的面就垂直于视线方向，说明当前是直视这个面。所以，我们就可以根据dot（N,V）来获得视线方向与法线方向的余弦值，通过这个值来区分该像素是否处在边缘，进而判断是否需要增加以及增加边缘光的强弱。

边缘光效果Unity下的实现

上面已经说完了边缘光效果的实现原理，下面附上完整的边缘光效果shader，基于之前介绍过的 兰伯特光照模型，增加了边缘光效果：

[csharp]  view plain  copy

1. //边缘发光Shader  
2. //by：puppet_master  
3. //2016.12.11  
4.   
5. Shader "ApcShader/RimLight"  
6. {  
7.     //属性  
8.     Properties{  
9.         _Diffuse("Diffuse", Color) = (1,1,1,1)  
10.         _RimColor("RimColor", Color) = (1,1,1,1)  
11.         _RimPower("RimPower", Range(0.000001, 3.0)) = 0.1  
12.         _MainTex("Base 2D", 2D) = "white"{}  
13.     }  
14.   
15.     //子着色器    
16.     SubShader  
17.     {  
18.         Pass  
19.         {  
20.             //定义Tags  
21.             Tags{ "RenderType" = "Opaque" }  
22.   
23.             CGPROGRAM  
24.             //引入头文件  
25.             #include "Lighting.cginc"  
26.             //定义Properties中的变量  
27.             fixed4 _Diffuse;  
28.             sampler2D _MainTex;  
29.             //使用了TRANSFROM_TEX宏就需要定义XXX_ST  
30.             float4 _MainTex_ST;  
31.             fixed4 _RimColor;  
32.             float _RimPower;  
33.   
34.             //定义结构体：vertex shader阶段输出的内容  
35.             struct v2f  
36.             {  
37.                 float4 pos : SV_POSITION;  
38.                 float3 worldNormal : TEXCOORD0;  
39.                 float2 uv : TEXCOORD1;  
40.                 //在vertex shader中计算观察方向传递给fragment shader  
41.                 float3 worldViewDir : TEXCOORD2;  
42.             };  
43.   
44.             //定义顶点shader,参数直接使用appdata_base（包含position, noramal, texcoord）  
45.             v2f vert(appdata_base v)  
46.             {  
47.                 v2f o;  
48.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
49.                 //通过TRANSFORM_TEX宏转化纹理坐标，主要处理了Offset和Tiling的改变,默认时等同于o.uv = v.texcoord.xy;  
50.                 o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);  
51.                 o.worldNormal = mul(v.normal, (float3x3)_World2Object);  
52.                 //顶点转化到世界空间  
53.                 float3 worldPos = mul(_Object2World, v.vertex).xyz;  
54.                 //可以把计算计算ViewDir的操作放在vertex shader阶段，毕竟逐顶点计算比较省  
55.                 o.worldViewDir = _WorldSpaceCameraPos.xyz - worldPos;  
56.                 return o;  
57.             }  
58.   
59.             //定义片元shader  
60.             fixed4 frag(v2f i) : SV_Target  
61.             {  
62.                 //unity自身的diffuse也是带了环境光，这里我们也增加一下环境光  
63.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * _Diffuse.xyz;  
64.                 //归一化法线，即使在vert归一化也不行，从vert到frag阶段有差值处理，传入的法线方向并不是vertex shader直接传出的  
65.                 fixed3 worldNormal = normalize(i.worldNormal);  
66.                 //把光照方向归一化  
67.                 fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);  
68.                 //根据半兰伯特模型计算像素的光照信息  
69.                 fixed3 lambert = 0.5 * dot(worldNormal, worldLightDir) + 0.5;  
70.                 //最终输出颜色为lambert光强*材质diffuse颜色*光颜色  
71.                 fixed3 diffuse = lambert * _Diffuse.xyz * _LightColor0.xyz + ambient;  
72.                 //进行纹理采样  
73.                 fixed4 color = tex2D(_MainTex, i.uv);  
74.                   
75.                 //以下为本篇主题：计算RimLight  
76.                 //把视线方向归一化  
77.                 float3 worldViewDir = normalize(i.worldViewDir);  
78.                 //计算视线方向与法线方向的夹角，夹角越大，dot值越接近0，说明视线方向越偏离该点，也就是平视，该点越接近边缘  
79.                 float rim = 1 - max(0, dot(worldViewDir, worldNormal));  
80.                 //计算rimLight  
81.                 fixed3 rimColor = _RimColor * pow(rim, 1 / _RimPower);  
82.                 //输出颜色+边缘光颜色  
83.                 color.rgb = color.rgb* diffuse + rimColor;  
84.                   
85.                 return fixed4(color);  
86.             }  
87.   
88.             //使用vert函数和frag函数  
89.             #pragma vertex vert  
90.             #pragma fragment frag     
91.   
92.             ENDCG  
93.         }  
94.     }  
95.     //前面的Shader失效的话，使用默认的Diffuse  
96.     FallBack "Diffuse"  
97. }  

下面看一下加了边缘光后的效果，普通diffuse shader：

白色边缘光效果：

黄色边缘光效果：

增加 景深效果和 Bloom效果，Bloom可以把亮的部分处理得更亮，有一种光线溢出的效果，而景深效果可以突出我们要表现的重点。唉，最近发现自己身陷后处理不能自拔啊....

通过Mask图控制边缘光

我们把边缘光效果加大到一定程度，就快成了自发光效果，但是上面的shader有个问题，就是全身都会自发光。如下图所示：

如果只希望盔甲部分有自发光效果，而其他部分没有自发光，我们就需要用Mask图来控制了，我们用一张Alpha8的灰度图来控制是否开启边缘光效果，将上面的shader简单修改一下，增加Mask图的通道：

[csharp]  view plain  copy

1. //边缘发光Shader  
2. //by：puppet_master  
3. //2016.12.11  
4.   
5. Shader "ApcShader/RimLight"  
6. {  
7.     //属性  
8.     Properties{  
9.         _Diffuse("Diffuse", Color) = (1,1,1,1)  
10.         _RimColor("RimColor", Color) = (1,1,1,1)  
11.         _RimPower("RimPower", Range(0.000001, 20.0)) = 0.1  
12.         _RimMask("RimMask", 2D) = "white"{}  
13.         _MainTex("Base 2D", 2D) = "white"{}  
14.     }  
15.   
16.     //子着色器    
17.     SubShader  
18.     {  
19.         Pass  
20.         {  
21.             //定义Tags  
22.             Tags{ "RenderType" = "Opaque" }  
23.   
24.             CGPROGRAM  
25.             //引入头文件  
26.             #include "Lighting.cginc"  
27.             //定义Properties中的变量  
28.             fixed4 _Diffuse;  
29.             sampler2D _MainTex;  
30.             //使用了TRANSFROM_TEX宏就需要定义XXX_ST  
31.             float4 _MainTex_ST;  
32.             sampler2D _RimMask;  
33.             fixed4 _RimColor;  
34.             float _RimPower;  
35.   
36.             //定义结构体：vertex shader阶段输出的内容  
37.             struct v2f  
38.             {  
39.                 float4 pos : SV_POSITION;  
40.                 float3 worldNormal : TEXCOORD0;  
41.                 float2 uv : TEXCOORD1;  
42.                 //在vertex shader中计算观察方向传递给fragment shader  
43.                 float3 worldViewDir : TEXCOORD2;  
44.             };  
45.   
46.             //定义顶点shader,参数直接使用appdata_base（包含position, noramal, texcoord）  
47.             v2f vert(appdata_base v)  
48.             {  
49.                 v2f o;  
50.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
51.                 //通过TRANSFORM_TEX宏转化纹理坐标，主要处理了Offset和Tiling的改变,默认时等同于o.uv = v.texcoord.xy;  
52.                 o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);  
53.                 o.worldNormal = mul(v.normal, (float3x3)_World2Object);  
54.                 //顶点转化到世界空间  
55.                 float3 worldPos = mul(_Object2World, v.vertex).xyz;  
56.                 //可以把计算计算ViewDir的操作放在vertex shader阶段，毕竟逐顶点计算比较省  
57.                 o.worldViewDir = _WorldSpaceCameraPos.xyz - worldPos;  
58.                 return o;  
59.             }  
60.   
61.             //定义片元shader  
62.             fixed4 frag(v2f i) : SV_Target  
63.             {  
64.                 //unity自身的diffuse也是带了环境光，这里我们也增加一下环境光  
65.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * _Diffuse.xyz;  
66.                 //归一化法线，即使在vert归一化也不行，从vert到frag阶段有差值处理，传入的法线方向并不是vertex shader直接传出的  
67.                 fixed3 worldNormal = normalize(i.worldNormal);  
68.                 //把光照方向归一化  
69.                 fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);  
70.                 //根据半兰伯特模型计算像素的光照信息  
71.                 fixed3 lambert = 0.5 * dot(worldNormal, worldLightDir) + 0.5;  
72.                 //最终输出颜色为lambert光强*材质diffuse颜色*光颜色  
73.                 fixed3 diffuse = lambert * _Diffuse.xyz * _LightColor0.xyz + ambient;  
74.                 //进行纹理采样  
75.                 fixed4 color = tex2D(_MainTex, i.uv);  
76.                   
77.                 //以下为本篇主题：计算RimLight  
78.                 //把视线方向归一化  
79.                 float3 worldViewDir = normalize(i.worldViewDir);  
80.                 //计算视线方向与法线方向的夹角，夹角越大，dot值越接近0，说明视线方向越偏离该点，也就是平视，该点越接近边缘  
81.                 float rim = 1 - max(0, dot(worldViewDir, worldNormal));  
82.                 //计算RimLight  
83.                 fixed3 rimColor = _RimColor * pow(rim, 1 / _RimPower);  
84.                 //通过RimMask控制是否有边缘光,Rim目前存在一张Alpha8类型的图片中  
85.                 fixed rimMask = tex2D(_RimMask, i.uv).a;  
86.                 //输出颜色+边缘光颜色  
87.                 color.rgb = color.rgb* diffuse + rimColor * (1 - rimMask);  
88.                   
89.                 return fixed4(color);  
90.             }  
91.   
92.             //使用vert函数和frag函数  
93.             #pragma vertex vert  
94.             #pragma fragment frag     
95.   
96.             ENDCG  
97.         }  
98.     }  
99.     //前面的Shader失效的话，使用默认的Diffuse  
100.     FallBack "Diffuse"  
101. }  

我们把下面这张自发光Mask图赋给材质：

通过采样这张Mask就能控制那部分开启自发光，那部分关闭自发光了：

调整Mask图，也可以得到一些比较好玩的效果：

动态RimLight效果

看了一篇博文，其中的边缘光使用了一张动态图，达到了流动的效果，感谢 作者的无私分享，于是我也尝试一下动态RimLight的效果。其实思路跟上面的Mask图一样，只不过这次改成一张扫面线类型的纹理，然后通过这张纹理的采样滚动，达到动态的效果。一提到动态效果，我们第一个想到的应该就是_Time向量，这个向量中几个值都是跟时间相关的，我们如果做动态效果，肯定少不了和这个变量打交道，关于_Time及其变种，可以参考 这篇文章，我们这里用_Time.y就可以获得时间了。

我们用一张Mask纹理，白色代表有边缘光，黑色无边缘光，通过采样这张Mask纹理，控制模型上显示边缘光的部分：

动态RimLight的shader如下：

[csharp]  view plain  copy

1. //边缘发光Shader  
2. //by：puppet_master  
3. //2016.12.11  
4.   
5. Shader "ApcShader/RimLight"  
6. {  
7.     //属性  
8.     Properties{  
9.         _Diffuse("Diffuse", Color) = (1,1,1,1)  
10.         _RimColor("RimColor", Color) = (1,1,1,1)  
11.         _RimPower("RimPower", Range(0.000001, 20.0)) = 0.1  
12.         _RimMask("RimMask", 2D) = "white"{}  
13.         _MainTex("Base 2D", 2D) = "white"{}  
14.         _RimSpeed("RimSpeed", Range(-10, 10)) = 1.0  
15.     }  
16.   
17.     //子着色器    
18.     SubShader  
19.     {  
20.         Pass  
21.         {  
22.             //定义Tags  
23.             Tags{ "RenderType" = "Opaque" }  
24.   
25.             CGPROGRAM  
26.             //引入头文件  
27.             #include "Lighting.cginc"  
28.             //定义Properties中的变量  
29.             fixed4 _Diffuse;  
30.             sampler2D _MainTex;  
31.             //使用了TRANSFROM_TEX宏就需要定义XXX_ST  
32.             float4 _MainTex_ST;  
33.             sampler2D _RimMask;  
34.             fixed4 _RimColor;  
35.             float _RimPower;  
36.             float _RimSpeed;  
37.   
38.             //定义结构体：vertex shader阶段输出的内容  
39.             struct v2f  
40.             {  
41.                 float4 pos : SV_POSITION;  
42.                 float3 worldNormal : TEXCOORD0;  
43.                 float2 uv : TEXCOORD1;  
44.                 //在vertex shader中计算观察方向传递给fragment shader  
45.                 float3 worldViewDir : TEXCOORD2;  
46.             };  
47.   
48.             //定义顶点shader,参数直接使用appdata_base（包含position, noramal, texcoord）  
49.             v2f vert(appdata_base v)  
50.             {  
51.                 v2f o;  
52.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
53.                 //通过TRANSFORM_TEX宏转化纹理坐标，主要处理了Offset和Tiling的改变,默认时等同于o.uv = v.texcoord.xy;  
54.                 o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);  
55.                 o.worldNormal = mul(v.normal, (float3x3)_World2Object);  
56.                 //顶点转化到世界空间  
57.                 float3 worldPos = mul(_Object2World, v.vertex).xyz;  
58.                 //可以把计算计算ViewDir的操作放在vertex shader阶段，毕竟逐顶点计算比较省  
59.                 o.worldViewDir = _WorldSpaceCameraPos.xyz - worldPos;  
60.                 return o;  
61.             }  
62.   
63.             //定义片元shader  
64.             fixed4 frag(v2f i) : SV_Target  
65.             {  
66.                 //unity自身的diffuse也是带了环境光，这里我们也增加一下环境光  
67.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * _Diffuse.xyz;  
68.                 //归一化法线，即使在vert归一化也不行，从vert到frag阶段有差值处理，传入的法线方向并不是vertex shader直接传出的  
69.                 fixed3 worldNormal = normalize(i.worldNormal);  
70.                 //把光照方向归一化  
71.                 fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);  
72.                 //根据半兰伯特模型计算像素的光照信息  
73.                 fixed3 lambert = 0.5 * dot(worldNormal, worldLightDir) + 0.5;  
74.                 //最终输出颜色为lambert光强*材质diffuse颜色*光颜色  
75.                 fixed3 diffuse = lambert * _Diffuse.xyz * _LightColor0.xyz + ambient;  
76.                 //进行纹理采样  
77.                 fixed4 color = tex2D(_MainTex, i.uv);  
78.                   
79.                 //以下为本篇主题：计算RimLight  
80.                 //把视线方向归一化  
81.                 float3 worldViewDir = normalize(i.worldViewDir);  
82.                 //计算视线方向与法线方向的夹角，夹角越大，dot值越接近0，说明视线方向越偏离该点，也就是平视，该点越接近边缘  
83.                 float rim = 1 - max(0, dot(worldViewDir, worldNormal));  
84.                 //计算RimLight  
85.                 fixed3 rimColor = _RimColor * pow(rim, 1 / _RimPower);  
86.                 //通过RimMask控制是否有边缘光,Rim目前存在一张Alpha8类型的图片中  
87.                 fixed rimMask = tex2D(_RimMask, i.uv + float2(0 , _Time.y * _RimSpeed)).r;  
88.                 //输出颜色+边缘光颜色  
89.                 color.rgb = color.rgb* diffuse + rimColor * (1-rimMask);  
90.                   
91.                 return fixed4(color);  
92.             }  
93.   
94.             //使用vert函数和frag函数  
95.             #pragma vertex vert  
96.             #pragma fragment frag     
97.   
98.             ENDCG  
99.         }  
100.     }  
101.     //前面的Shader失效的话，使用默认的Diffuse  
102.     FallBack "Diffuse"  
103. }  

来一张Gif截图（旁边好像有什么抢镜了）：

Unity Shader中可用的变量类型整理

在传递参数时总是忘了能传递哪些类型的参数，记录一下，方便以后查找，这种东西也没必要死记硬背下来，需要的时候几秒钟之内能找到就好了。

[csharp]  view plain  copy

1. //Float类型，下面对应变量可以用flaot,half,fixed  
2. _Name("Inspector Name", Float) = defaultValue  
3. //Float类型,可以用一个滑动条控制范围,下面对应变量可以用float,half,fixed  
4. _Name("Inspector Name", Range(min, max)) = defaultValue  
5. //颜色类型，下面对应变量可以用float4,half4,fixed4，如果是颜色，尽量fixed4  
6. _Name("Inspector Name", Color) = (defaultValue.r, defaultValue.g, defaultValue.b, defaultValue.a)  
7. //2D纹理类型,默认纹理可以为空，白，黑，灰，凹凸，下面对应变量sampler2D  
8. _Name("Inspector Name", 2D) = "" / "white" / "black" / "gray" / "bump"{options}  
9. //长方形纹理，非2次方大小的纹理，其同上  
10. _Name("Inspector Name", Rect) = "" / "white" / "black" / "gray" / "bump"{options}  
11. //立方体贴图CubeMap  
12. _Name("Inspector Name", Cube) = "" {options}  
13. //传递一个Vector4向量  
14. _Name("Inspector Name", Vector) = (defaultValue.x, defaultValue.y, defaultValue.z, defaultValue.w)  
15.   
16. //注：上面纹理后面{}里面是一些纹理TexGen，LightmapMode光照模式等内容