zoukankan      html  css  js  c++  java

  • Unity Shader实现描边效果

    http://gad.qq.com/article/detail/28346

    描边效果是游戏里面非常常用的一种效果，一般是为了凸显游戏中的某个对象，会给对象增加一个描边效果。本篇文章和大家介绍下利用Shader实现描边效果，一起来看看吧。

     

    最近又跑回去玩了玩《剑灵》，虽然出了三年了，感觉在现在的网游里面画面仍然算很好的了，剑灵里面走近或者选中NPC的一瞬间，NPC就会出现描边效果，不过这个描边效果是渐变的，会很快减弱最后消失（抓了好久才抓住一张图....）


    还有就是最常见的LOL中的塔，我们把鼠标移动到塔上，就会有很明显的描边效果：

     

    简单描边效果的原理

     
    描 边效果有几种实现方式。其实边缘光效果与描边效果有些类似，适当调整边缘光效果，其实也可以达到凸显要表达的对象的意思。边缘光的实现最为简单，只是在计 算的时候增加了一次计算法线方向与视线方向的夹角计算，用1减去结果作为系数乘以一个边缘光颜色就达到了边缘光的效果，是性能最好的一种方法，关于边缘光 效果，可以参考一下之前的一篇文章：边缘光效果。边缘光的效果如下图所示：
     
    原始模型渲染：

    使用了边缘光的效果：

     
    边 缘光效果虽然简单，但是有很大的局限性，边缘光效果只是在当前模型本身的光照计算时调整了边缘位置的颜色值，并没有达到真正的“描边”（当然，有时候我们 就是想要这种边缘光的效果），而我们希望的描边效果，一般都是在正常模型的渲染状态下，在模型外面扩展出一个描边的效果。既然要让模型的形状有所改变（向 外拓一点），那么肯定就和vertex shader有关系了。而我们的描边效果，肯定就是要让模型更“胖”一点，能够把我们原来的大小包裹住；微观一点来看，一个面，如果我们让它向外拓展，而 我们指的外，也就是这个面的法线所指向的方向，那么就让这个面朝着法线的方向平移一点；再微观一点来看，对于顶点来说，也就是我们的vertex shader真正要写的内容了，我们正常计算顶点的时候，传入的vertex会经过MVP变换，最终传递给fragment shader，那么我们就可以在这一步让顶点沿着法线的方向稍微平移一些。我们在描边后，描边这一次渲染的边缘其实是没有办法和我们正常的模型进行区分 的，为了解决这个问题，就需要用两个Pass来渲染，第一个Pass渲染描边的效果，进行外拓，而第二个Pass进行原本效果的渲染，这样，后面显示的就 是稍微“胖”一点的模型，然后正常的模型贴在上面，把中间的部分挡住，边缘挡不住就露出了描边的部分了。
     

    开启深度写入，剔除正面的描边效果

     
    知 道了原理，我们来考虑一下外拓的实现，我们可以在vertex阶段获得顶点的坐标，并且有法线的坐标，最直接的方式就是直接用顶点坐标+法线方向*描边粗 细参数，然后用这个偏移的坐标值再进行MVP变换；但是这样做有一个弊端，其实就是我们透视的近大远小的问题，模型上离相机近的地方描边效果较粗，而远的 地方描边效果较细。一种解决的方案是先进行MPV变换，变换完之后再去按照法线方向调整外拓。代码如下：
    [csharp] view plain copy
    1. //描边Shader  
    2. //by：puppet_master  
    3. //2017.1.5  
    4.   
    5. Shader "ApcShader/Outline"  
    6. {  
    7.     //属性  
    8.     Properties{  
    9.         _Diffuse("Diffuse", Color) = (1,1,1,1)  
    10.         _OutlineCol("OutlineCol", Color) = (1,0,0,1)  
    11.         _OutlineFactor("OutlineFactor", Range(0,1)) = 0.1  
    12.         _MainTex("Base 2D", 2D) = "white"{}  
    13.     }  
    14.   
    15.     //子着色器    
    16.     SubShader  
    17.     {  
    18.           
    19.         //描边使用两个Pass，第一个pass沿法线挤出一点，只输出描边的颜色  
    20.         Pass  
    21.         {  
    22.             //剔除正面，只渲染背面，对于大多数模型适用，不过如果需要背面的，就有问题了  
    23.             Cull Front  
    24.               
    25.             CGPROGRAM  
    26.             #include "UnityCG.cginc"  
    27.             fixed4 _OutlineCol;  
    28.             float _OutlineFactor;  
    29.               
    30.             struct v2f  
    31.             {  
    32.                 float4 pos : SV_POSITION;  
    33.             };  
    34.               
    35.             v2f vert(appdata_full v)  
    36.             {  
    37.                 v2f o;  
    38.                 //在vertex阶段，每个顶点按照法线的方向偏移一部分，不过这种会造成近大远小的透视问题  
    39.                 //v.vertex.xyz += v.normal * _OutlineFactor;  
    40.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    41.                 //将法线方向转换到视空间  
    42.                 float3 vnormal = mul((float3x3)UNITY_MATRIX_IT_MV, v.normal);  
    43.                 //将视空间法线xy坐标转化到投影空间，只有xy需要，z深度不需要了  
    44.                 float2 offset = TransformViewToProjection(vnormal.xy);  
    45.                 //在最终投影阶段输出进行偏移操作  
    46.                 o.pos.xy += offset * _OutlineFactor;  
    47.                 return o;  
    48.             }  
    49.               
    50.             fixed4 frag(v2f i) : SV_Target  
    51.             {  
    52.                 //这个Pass直接输出描边颜色  
    53.                 return _OutlineCol;  
    54.             }  
    55.               
    56.             //使用vert函数和frag函数  
    57.             #pragma vertex vert  
    58.             #pragma fragment frag  
    59.             ENDCG  
    60.         }  
    61.           
    62.         //正常着色的Pass  
    63.         Pass  
    64.         {  
    65.             CGPROGRAM     
    66.           
    67.             //引入头文件  
    68.             #include "Lighting.cginc"  
    69.             //定义Properties中的变量  
    70.             fixed4 _Diffuse;  
    71.             sampler2D _MainTex;  
    72.             //使用了TRANSFROM_TEX宏就需要定义XXX_ST  
    73.             float4 _MainTex_ST;  
    74.   
    75.             //定义结构体：vertex shader阶段输出的内容  
    76.             struct v2f  
    77.             {  
    78.                 float4 pos : SV_POSITION;  
    79.                 float3 worldNormal : TEXCOORD0;  
    80.                 float2 uv : TEXCOORD1;  
    81.             };  
    82.   
    83.             //定义顶点shader,参数直接使用appdata_base（包含position, noramal, texcoord）  
    84.             v2f vert(appdata_base v)  
    85.             {  
    86.                 v2f o;  
    87.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    88.                 //通过TRANSFORM_TEX宏转化纹理坐标，主要处理了Offset和Tiling的改变,默认时等同于o.uv = v.texcoord.xy;  
    89.                 o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);  
    90.                 o.worldNormal = mul(v.normal, (float3x3)_World2Object);  
    91.                 return o;  
    92.             }  
    93.   
    94.             //定义片元shader  
    95.             fixed4 frag(v2f i) : SV_Target  
    96.             {  
    97.                 //unity自身的diffuse也是带了环境光，这里我们也增加一下环境光  
    98.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * _Diffuse.xyz;  
    99.                 //归一化法线，即使在vert归一化也不行，从vert到frag阶段有差值处理，传入的法线方向并不是vertex shader直接传出的  
    100.                 fixed3 worldNormal = normalize(i.worldNormal);  
    101.                 //把光照方向归一化  
    102.                 fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);  
    103.                 //根据半兰伯特模型计算像素的光照信息  
    104.                 fixed3 lambert = 0.5 * dot(worldNormal, worldLightDir) + 0.5;  
    105.                 //最终输出颜色为lambert光强*材质diffuse颜色*光颜色  
    106.                 fixed3 diffuse = lambert * _Diffuse.xyz * _LightColor0.xyz + ambient;  
    107.                 //进行纹理采样  
    108.                 fixed4 color = tex2D(_MainTex, i.uv);  
    109.                 color.rgb = color.rgb* diffuse;  
    110.                 return fixed4(color);  
    111.             }  
    112.   
    113.             //使用vert函数和frag函数  
    114.             #pragma vertex vert  
    115.             #pragma fragment frag     
    116.   
    117.             ENDCG  
    118.         }  
    119.     }  
    120.     //前面的Shader失效的话，使用默认的Diffuse  
    121.     FallBack "Diffuse"  
    122. }  
    开启了描边效果：

    原始模型渲染采用了半兰伯特Diffuse进 行渲染，主要是前面多了一个描边的Pass。这个Pass里，我们没有关闭深度写入，主要是开启了模型的正面剔除，这样，在这个Pass渲染的时候，就只 会渲染模型的背面，让背面向外拓展一下，既不会影响什么，并且背面一般都在正面的后面，一般情况下不会遮挡住正面，正好符合我们后面的部分外拓的需求。这 个的主要优点是没有关闭深度写入，因为关闭深度写入，引入的其他问题实在是太多了。
    附上一张进行了Cull Front操作的效果，只渲染了我们正常看不到的面，效果比较惊悚：
    然 后再来看看转换的部分，我们通过UNITY_MATRIX_IT_MV矩阵将法线转换到视空间，这里可能会比较好奇，为什么不用正常的顶点转化矩阵来转化 法线，其实主要原因是如果按照顶点的转换方式，对于非均匀缩放（scalex, scaley,scalez不一致）时，会导致变换的法线归一化后与面不垂直。如下图所示，左边是变化前的，而中间是沿x轴缩放了0.5倍的情况，显然变 化后就不满足法线的性质了，而最右边的才是我们希望的结果。造成这一现象的主要原因是法线只能保证方向的一致性，而不能保证位置的一致性；顶点可以经过坐 标变换变换到正确的位置，但是法线是一个向量，我们不能直接使用顶点的变换矩阵进行变换。
    我们可以推导一个法线的变换矩阵，就能够保证转化后的法线与面垂直，法线的变换矩阵为模型变换矩阵的逆转置矩阵。具体推导过程可以参考这篇文章。
    在 把法线变换到了视空间后，就可以取出其中只与xy面有关的部分，视空间的z轴近似于深度，我们只需要法线在x,y轴的方向，再通过 TransformViewToProjection方法，将这个方向转化到投影空间，最后用这个方向加上经过MVP变换的坐标，实现轻微外拓的效果。 （从网上和书上看到了不少在这一步计算的时候，又乘上了pos.z的操作，个人感觉没有太大的用处，而且会导致描边效果越远，线条越粗的情况，离远了就会 出现一团黑的问题，所以把这个去掉了）
     
    上 面说过，一般情况下背面是在我们看到的后面的部分，但是理想很美好，现实很残酷，具体情况千差万别，比如我之前常用的一个模型，模型的袖子里面，其实用的 就是背面，如果想要渲染，就需要关闭背面剔除（Cull Off），这种情况下，使用Cull Front只渲染背面，就有可能和第二次正常渲染的时候的背面穿插，造成效果不对的情况，比如：

    不过，解决问题的方法肯定要比问题多，我们可以用深度操作神器Offset指令，控制深度测试，比如我们可以让渲染描边的Pass深度远离相机一点，这样就不会与正常的Pass穿插了，修改一下描边的Pass，其实只多了一句话Offset 1,1：
    [csharp] view plain copy
    1. //描边使用两个Pass，第一个pass沿法线挤出一点，只输出描边的颜色  
    2.         Pass  
    3.         {  
    4.             //剔除正面，只渲染背面，对于大多数模型适用，不过如果需要背面的，就有问题了  
    5.             Cull Front  
    6.             //控制深度偏移，描边pass远离相机一些，防止与正常pass穿插  
    7.             Offset 1,1  
    8.             CGPROGRAM  
    9.             #include "UnityCG.cginc"  
    10.             fixed4 _OutlineCol;  
    11.             float _OutlineFactor;  
    12.               
    13.             struct v2f  
    14.             {  
    15.                 float4 pos : SV_POSITION;  
    16.             };  
    17.               
    18.             v2f vert(appdata_full v)  
    19.             {  
    20.                 v2f o;  
    21.                 //在vertex阶段，每个顶点按照法线的方向偏移一部分，不过这种会造成近大远小的透视问题  
    22.                 //v.vertex.xyz += v.normal * _OutlineFactor;  
    23.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    24.                 //将法线方向转换到视空间  
    25.                 float3 vnormal = mul((float3x3)UNITY_MATRIX_IT_MV, v.normal);  
    26.                 //将视空间法线xy坐标转化到投影空间  
    27.                 float2 offset = TransformViewToProjection(vnormal.xy);  
    28.                 //在最终投影阶段输出进行偏移操作  
    29.                 o.pos.xy += offset * _OutlineFactor;  
    30.                 return o;  
    31.             }  
    32.               
    33.             fixed4 frag(v2f i) : SV_Target  
    34.             {  
    35.                 //这个Pass直接输出描边颜色  
    36.                 return _OutlineCol;  
    37.             }  
    38.               
    39.             //使用vert函数和frag函数  
    40.             #pragma vertex vert  
    41.             #pragma fragment frag  
    42.             ENDCG  
    43.         }  
    这样，我们的描边效果也可以支持不能背面剔除的模型了：
     

    Offset指令

     
    写 到这里强行插一波基础知识。上面的描边效果，我们用了一个Offset指令，很好地解决了穿插的问题。其实Offset就是解决Stiching和Z- Fighting的最佳途径之一。当然，也可以用模板测试，但是Offset操作更快一点。关于Stiching和Z-Fighting，引用一下这篇文章：
     
    在 OpenGL中，如果想绘制一个多边形同时绘制其边界，可是先使用多边形模式GL_FILL绘制物体，然后使用多边形模式GL_LINE和不同的颜色再次 绘制这个多边形。但是由于直线和多边形的光栅化方式不同，导致位于同一位置的多边形和直线的深度值并不相同，进而导致直线有时在多边形的里面，有时在多边 形的外面，这种现象就是"Stiching"。而Z-fighting主要是指当两个面共面时，二者的深度值一样，深度缓冲就不能清楚的将它们两者分离开 来，位于后面的图元上的一些像素就会被渲染到前面的图元上，最终导致图象在帧与帧之间产生微弱的闪光。

    比 如我们要绘制两个面完全共面时，两者深度值完全相同，那么我们在进行深度测试的时候，就不能分辨到底哪个在前，哪个在后了。类似我们上面的例子，当我们需 要渲染背面时，通过背面进行外拓的Pass渲染的结果就和正常的Pass有穿插了。那么，要解决这个问题，很明显，我们就可以强行设置某个pass的深度 偏移，推测这个offset的偏移值是针对ZTest阶段，在进行深度测试的时候，将当前pass的深度用offset进行调整再与深度缓冲区中的值进行 比对。附上一张官方文档中关于Offset的部分：
    Offset 指令有两个参数，一个是Factor，主要影响我们绘制多边形的深度斜率slope的最大值；另一个是Units，主要影响的是能产生在窗口坐标系的深度 值中可变分辨率差异的最小值r，这个r一般是OpenGL平台给定的常量。最终的Offset = slope * Factor + r * Units。Units我们一般在有使用Offset指令的地方给一个统一的值就可以了，主要起作用的就是Factor。Offset操作的层面是像素级 别的，多边形光栅化之后对应的每个Fragment都有一个偏移值，我们调整Factor，其实相当于沿着当前多边形的斜率深度前进或者后退了一段距离， 默认的深度方向是向Z正方向，如果我们给一个大于0的Factor，那么偏移值就会指向Z正方向，深度测试的时候相当于更远了一点；而如果给了个小于0的 Factor，相当于原理Z正方向，深度测试时就更近了一点。
    总结一句话就是：Offset大于0，Pass对应的模型离摄像机更远；Offset小于0，Pass对应的模型离摄像机更近。
     
    有一种描边效果的实现，其实是利用Offset强行导致Z-Fighting达到描边的目的，不过效果很差，这里简单实验了一版：
    [csharp] view plain copy
    1. //描边Shader  
    2. //by：puppet_master  
    3. //2017.1.10  
    4.   
    5. Shader "ApcShader/OutlineZOffset"  
    6. {  
    7.     //属性  
    8.     Properties{  
    9.         _Diffuse("Diffuse", Color) = (1,1,1,1)  
    10.         _OutlineCol("OutlineCol", Color) = (1,0,0,1)  
    11.         _MainTex("Base 2D", 2D) = "white"{}  
    12.     }  
    13.   
    14.     //子着色器    
    15.     SubShader  
    16.     {  
    17.         //描边使用两个Pass,第一个Pass渲染背面，但是拉近一点  
    18.         Pass  
    19.         {  
    20.             //剔除正面，只渲染背面  
    21.             Cull Front  
    22.             //拉近一点，为了与后面的Pass重叠  
    23.             Offset -1,-1  
    24.               
    25.             CGPROGRAM  
    26.             #include "UnityCG.cginc"  
    27.             fixed4 _OutlineCol;  
    28.             float _OutlineFactor;  
    29.               
    30.             struct v2f  
    31.             {  
    32.                 float4 pos : SV_POSITION;  
    33.             };  
    34.               
    35.             v2f vert(appdata_full v)  
    36.             {  
    37.                 v2f o;  
    38.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    39.                 return o;  
    40.             }  
    41.               
    42.             fixed4 frag(v2f i) : SV_Target  
    43.             {  
    44.                 //这个Pass直接输出描边颜色  
    45.                 return _OutlineCol;  
    46.             }  
    47.               
    48.             //使用vert函数和frag函数  
    49.             #pragma vertex vert  
    50.             #pragma fragment frag  
    51.             ENDCG  
    52.         }  
    53.           
    54.         //正常着色的Pass，拉远一点  
    55.         Pass  
    56.         {  
    57.             //拉远一点，强行导致上一个Pass渲染的背面与此处发生Z-Fighting  
    58.             Offset 3,-1  
    59.             CGPROGRAM     
    60.               
    61.             //引入头文件  
    62.             #include "Lighting.cginc"  
    63.             //定义Properties中的变量  
    64.             fixed4 _Diffuse;  
    65.             sampler2D _MainTex;  
    66.             //使用了TRANSFROM_TEX宏就需要定义XXX_ST  
    67.             float4 _MainTex_ST;  
    68.   
    69.             //定义结构体：vertex shader阶段输出的内容  
    70.             struct v2f  
    71.             {  
    72.                 float4 pos : SV_POSITION;  
    73.                 float3 worldNormal : TEXCOORD0;  
    74.                 float2 uv : TEXCOORD1;  
    75.             };  
    76.   
    77.             //定义顶点shader,参数直接使用appdata_base（包含position, noramal, texcoord）  
    78.             v2f vert(appdata_base v)  
    79.             {  
    80.                 v2f o;  
    81.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    82.                 //通过TRANSFORM_TEX宏转化纹理坐标，主要处理了Offset和Tiling的改变,默认时等同于o.uv = v.texcoord.xy;  
    83.                 o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);  
    84.                 o.worldNormal = mul(v.normal, (float3x3)_World2Object);  
    85.                 return o;  
    86.             }  
    87.   
    88.             //定义片元shader  
    89.             fixed4 frag(v2f i) : SV_Target  
    90.             {  
    91.                 //unity自身的diffuse也是带了环境光，这里我们也增加一下环境光  
    92.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * _Diffuse.xyz;  
    93.                 //归一化法线，即使在vert归一化也不行，从vert到frag阶段有差值处理，传入的法线方向并不是vertex shader直接传出的  
    94.                 fixed3 worldNormal = normalize(i.worldNormal);  
    95.                 //把光照方向归一化  
    96.                 fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);  
    97.                 //根据半兰伯特模型计算像素的光照信息  
    98.                 fixed3 lambert = 0.5 * dot(worldNormal, worldLightDir) + 0.5;  
    99.                 //最终输出颜色为lambert光强*材质diffuse颜色*光颜色  
    100.                 fixed3 diffuse = lambert * _Diffuse.xyz * _LightColor0.xyz + ambient;  
    101.                 //进行纹理采样  
    102.                 fixed4 color = tex2D(_MainTex, i.uv);  
    103.                 color.rgb = color.rgb* diffuse;  
    104.                 return fixed4(color);  
    105.             }  
    106.   
    107.             //使用vert函数和frag函数  
    108.             #pragma vertex vert  
    109.             #pragma fragment frag     
    110.   
    111.             ENDCG  
    112.         }  
    113.           
    114.           
    115.     }  
    116.     //前面的Shader失效的话，使用默认的Diffuse  
    117.     FallBack "Diffuse"  
    118. }  
    效果如下：
    效 果确实不怎么样，圆球的描边很明显会看出Z-Fighting的痕迹，而人物的渲染，帽子直接就不对了。不过这种实现的描边效果计算最为简单，而且不存在 边缘不连续时会出现描边的断裂的问题。这种方式，主要是通过把后面的描边Pass向前提前，由于描边Pass只渲染了背面，正常情况下是不可见的，而正常 的Pass又向后推了一点，导致重合的部分发生了Z-Fighting。
     
    关于Offset指令，再附上一篇参考文章。
     

    关闭深度写入的描边效果实现

     
    个 人不是很喜欢这种方式，关了深度写入麻烦事太多。还是硬着头皮练习一下吧。上面的描边shader，如果注意观察的话，其实并不仅仅是描物体的外轮廓边， 在模型内部（模型面前，不是边缘的部分）也被描上了边，不过并不影响表现。而我们通过关闭深度写入实现的描边效果，则仅仅会描模型的外轮廓。代码如下：
    [csharp] view plain copy
    1. //描边Shader  
    2. //by：puppet_master  
    3. //2017.1.9  
    4.   
    5. Shader "ApcShader/OutlineZWriteOff"  
    6. {  
    7.     //属性  
    8.     Properties{  
    9.         _Diffuse("Diffuse", Color) = (1,1,1,1)  
    10.         _OutlineCol("OutlineCol", Color) = (1,0,0,1)  
    11.         _OutlineFactor("OutlineFactor", Range(0,1)) = 0.1  
    12.         _MainTex("Base 2D", 2D) = "white"{}  
    13.     }  
    14.   
    15.     //子着色器    
    16.     SubShader  
    17.     {  
    18.           
    19.         //描边使用两个Pass，第一个pass沿法线挤出一点，只输出描边的颜色  
    20.         Pass  
    21.         {  
    22.             //剔除正面，只渲染背面  
    23.             Cull Front  
    24.             //关闭深度写入  
    25.             ZWrite Off  
    26.               
    27.             CGPROGRAM  
    28.             #include "UnityCG.cginc"  
    29.             fixed4 _OutlineCol;  
    30.             float _OutlineFactor;  
    31.               
    32.             struct v2f  
    33.             {  
    34.                 float4 pos : SV_POSITION;  
    35.             };  
    36.               
    37.             v2f vert(appdata_full v)  
    38.             {  
    39.                 v2f o;  
    40.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    41.                 //将法线方向转换到视空间  
    42.                 float3 vnormal = mul((float3x3)UNITY_MATRIX_IT_MV, v.normal);  
    43.                 //将视空间法线xy坐标转化到投影空间  
    44.                 float2 offset = TransformViewToProjection(vnormal.xy);  
    45.                 //在最终投影阶段输出进行偏移操作  
    46.                 o.pos.xy += offset * _OutlineFactor;  
    47.                 return o;  
    48.             }  
    49.               
    50.             fixed4 frag(v2f i) : SV_Target  
    51.             {  
    52.                 //这个Pass直接输出描边颜色  
    53.                 return _OutlineCol;  
    54.             }  
    55.               
    56.             //使用vert函数和frag函数  
    57.             #pragma vertex vert  
    58.             #pragma fragment frag  
    59.             ENDCG  
    60.         }  
    61.           
    62.         //正常着色的Pass  
    63.         Pass  
    64.         {  
    65.             CGPROGRAM     
    66.               
    67.             //引入头文件  
    68.             #include "Lighting.cginc"  
    69.             //定义Properties中的变量  
    70.             fixed4 _Diffuse;  
    71.             sampler2D _MainTex;  
    72.             //使用了TRANSFROM_TEX宏就需要定义XXX_ST  
    73.             float4 _MainTex_ST;  
    74.   
    75.             //定义结构体：vertex shader阶段输出的内容  
    76.             struct v2f  
    77.             {  
    78.                 float4 pos : SV_POSITION;  
    79.                 float3 worldNormal : TEXCOORD0;  
    80.                 float2 uv : TEXCOORD1;  
    81.             };  
    82.   
    83.             //定义顶点shader,参数直接使用appdata_base（包含position, noramal, texcoord）  
    84.             v2f vert(appdata_base v)  
    85.             {  
    86.                 v2f o;  
    87.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    88.                 //通过TRANSFORM_TEX宏转化纹理坐标，主要处理了Offset和Tiling的改变,默认时等同于o.uv = v.texcoord.xy;  
    89.                 o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);  
    90.                 o.worldNormal = mul(v.normal, (float3x3)_World2Object);  
    91.                 return o;  
    92.             }  
    93.   
    94.             //定义片元shader  
    95.             fixed4 frag(v2f i) : SV_Target  
    96.             {  
    97.                 //unity自身的diffuse也是带了环境光，这里我们也增加一下环境光  
    98.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * _Diffuse.xyz;  
    99.                 //归一化法线，即使在vert归一化也不行，从vert到frag阶段有差值处理，传入的法线方向并不是vertex shader直接传出的  
    100.                 fixed3 worldNormal = normalize(i.worldNormal);  
    101.                 //把光照方向归一化  
    102.                 fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);  
    103.                 //根据半兰伯特模型计算像素的光照信息  
    104.                 fixed3 lambert = 0.5 * dot(worldNormal, worldLightDir) + 0.5;  
    105.                 //最终输出颜色为lambert光强*材质diffuse颜色*光颜色  
    106.                 fixed3 diffuse = lambert * _Diffuse.xyz * _LightColor0.xyz + ambient;  
    107.                 //进行纹理采样  
    108.                 fixed4 color = tex2D(_MainTex, i.uv);  
    109.                 color.rgb = color.rgb* diffuse;  
    110.                 return fixed4(color);  
    111.             }  
    112.   
    113.             //使用vert函数和frag函数  
    114.             #pragma vertex vert  
    115.             #pragma fragment frag     
    116.   
    117.             ENDCG  
    118.         }  
    119.     }  
    120.     //前面的Shader失效的话，使用默认的Diffuse  
    121.     FallBack "Diffuse"  
    122. }  
    结果如下：
     
    看着效果不错，而且只有最外边有黑色轮廓。然而事情没有这么简单....比如我们加一个天空盒，描边效果就不见鸟！
    万 恶的ZWrite Off，一定要慎用啊！其实这个问题在上一篇文章中遇到过，简单解释一下，默认的渲染队列是Geometry，而天空盒渲染在Geometry之后，描边 部分没有写深度，那么当渲染天空盒的时候，深度小于无穷，深度测试通过，就会把描边的部分覆盖了。如下图，在画完模型本身时描边还是可见的，再画天空盒就 覆盖了描边。
    通过上一篇文章我们可以知道，调整渲染队列就可以解决这个问题。但是对于同一个渲染队列，又会有别的问题，我们复制一个一样的对象，有一部分重合，重合的部分描边效果又不见鸟！！！
    出现这个情况的原因也是没写深度造成描边被覆盖了：对于不透明类型的物体，unity的渲染顺序是从前到后。前面的描边渲染之后，渲染后面的模型，后面的模型在描边部分深度测试仍然通过，就覆盖了。
     
    怎 么解决这个问题呢？首先我们需要找到一个靠后渲染的渲染队列，保证我们的描边效果不被其他geomerty类型的对象遮挡；而对于同一渲染队列，我们也希 望最前面的物体描边效果不被遮挡，也就是说渲染顺序最好是从后向前。那么，答案已经有了，把渲染队列改成Transparent，unity对于透明类型 的物体渲染顺序是从后到前，这就符合我们的需求了。修改后的shader如下，只加了一句话，把队列改成Transparent。
    [csharp] view plain copy
    1. //描边Shader  
    2. //by：puppet_master  
    3. //2017.1.9  
    4.   
    5. Shader "ApcShader/OutlineZWriteOff"  
    6. {  
    7.     //属性  
    8.     Properties{  
    9.         _Diffuse("Diffuse", Color) = (1,1,1,1)  
    10.         _OutlineCol("OutlineCol", Color) = (1,0,0,1)  
    11.         _OutlineFactor("OutlineFactor", Range(0,1)) = 0.1  
    12.         _MainTex("Base 2D", 2D) = "white"{}  
    13.     }  
    14.   
    15.     //子着色器    
    16.     SubShader  
    17.     {  
    18.         //让渲染队列靠后，并且渲染顺序为从后向前，保证描边效果不被其他对象遮挡。  
    19.         Tags{"Queue" = "Transparent"}  
    20.         //描边使用两个Pass，第一个pass沿法线挤出一点，只输出描边的颜色  
    21.         Pass  
    22.         {  
    23.             //剔除正面，只渲染背面  
    24.             Cull Front  
    25.             //关闭深度写入  
    26.             ZWrite Off  
    27.               
    28.             CGPROGRAM  
    29.             #include "UnityCG.cginc"  
    30.             fixed4 _OutlineCol;  
    31.             float _OutlineFactor;  
    32.               
    33.             struct v2f  
    34.             {  
    35.                 float4 pos : SV_POSITION;  
    36.             };  
    37.               
    38.             v2f vert(appdata_full v)  
    39.             {  
    40.                 v2f o;  
    41.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    42.                 //将法线方向转换到视空间  
    43.                 float3 vnormal = mul((float3x3)UNITY_MATRIX_IT_MV, v.normal);  
    44.                 //将视空间法线xy坐标转化到投影空间  
    45.                 float2 offset = TransformViewToProjection(vnormal.xy);  
    46.                 //在最终投影阶段输出进行偏移操作  
    47.                 o.pos.xy += offset * _OutlineFactor;  
    48.                 return o;  
    49.             }  
    50.               
    51.             fixed4 frag(v2f i) : SV_Target  
    52.             {  
    53.                 //这个Pass直接输出描边颜色  
    54.                 return _OutlineCol;  
    55.             }  
    56.               
    57.             //使用vert函数和frag函数  
    58.             #pragma vertex vert  
    59.             #pragma fragment frag  
    60.             ENDCG  
    61.         }  
    62.           
    63.         //正常着色的Pass  
    64.         Pass  
    65.         {  
    66.             CGPROGRAM     
    67.               
    68.             //引入头文件  
    69.             #include "Lighting.cginc"  
    70.             //定义Properties中的变量  
    71.             fixed4 _Diffuse;  
    72.             sampler2D _MainTex;  
    73.             //使用了TRANSFROM_TEX宏就需要定义XXX_ST  
    74.             float4 _MainTex_ST;  
    75.   
    76.             //定义结构体：vertex shader阶段输出的内容  
    77.             struct v2f  
    78.             {  
    79.                 float4 pos : SV_POSITION;  
    80.                 float3 worldNormal : TEXCOORD0;  
    81.                 float2 uv : TEXCOORD1;  
    82.             };  
    83.   
    84.             //定义顶点shader,参数直接使用appdata_base（包含position, noramal, texcoord）  
    85.             v2f vert(appdata_base v)  
    86.             {  
    87.                 v2f o;  
    88.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    89.                 //通过TRANSFORM_TEX宏转化纹理坐标，主要处理了Offset和Tiling的改变,默认时等同于o.uv = v.texcoord.xy;  
    90.                 o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);  
    91.                 o.worldNormal = mul(v.normal, (float3x3)_World2Object);  
    92.                 return o;  
    93.             }  
    94.   
    95.             //定义片元shader  
    96.             fixed4 frag(v2f i) : SV_Target  
    97.             {  
    98.                 //unity自身的diffuse也是带了环境光，这里我们也增加一下环境光  
    99.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * _Diffuse.xyz;  
    100.                 //归一化法线，即使在vert归一化也不行，从vert到frag阶段有差值处理，传入的法线方向并不是vertex shader直接传出的  
    101.                 fixed3 worldNormal = normalize(i.worldNormal);  
    102.                 //把光照方向归一化  
    103.                 fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);  
    104.                 //根据半兰伯特模型计算像素的光照信息  
    105.                 fixed3 lambert = 0.5 * dot(worldNormal, worldLightDir) + 0.5;  
    106.                 //最终输出颜色为lambert光强*材质diffuse颜色*光颜色  
    107.                 fixed3 diffuse = lambert * _Diffuse.xyz * _LightColor0.xyz + ambient;  
    108.                 //进行纹理采样  
    109.                 fixed4 color = tex2D(_MainTex, i.uv);  
    110.                 color.rgb = color.rgb* diffuse;  
    111.                 return fixed4(color);  
    112.             }  
    113.   
    114.             //使用vert函数和frag函数  
    115.             #pragma vertex vert  
    116.             #pragma fragment frag     
    117.   
    118.             ENDCG  
    119.         }  
    120.     }  
    121.     //前面的Shader失效的话，使用默认的Diffuse  
    122.     FallBack "Diffuse"  
    123. }  
    这样，我们的ZWrite Off版本的描边效果也OK了。效果如下：
    仔细观察一下，虽然腿的部分描边效果正常了，但是手的部分，由于穿插过于密集，还是有一些穿帮的地方。总之，没事不要关闭深度写入...
     

    基于后处理的描边效果

     
    除了Cull Front+法线外拓+Offset实现的一版描边效果还不错，其他的描边效果弊端都比较明显，而法线外拓实现的描边都存在一个问题，如果相邻面的法线方向彼此分离，比如一个正方体，相邻面的法线方向互相垂直，就会造成轮廓间断，如下图所示：

    有一种解决方案，就是使用模型空间的顶点方向和法线方向插值得到的值进行外拓，并且需要判断顶点的指向（可以参考《Shader Lab开发实战详解》）。不过个人感觉一般描边效果用于的模型面数较高，法线方向过渡较为平缓，也就不会出现这种断裂的情况。
     
    要 放大招啦，当普通shader搞不定的时候，那就用后处理吧！用后处理进行描边的原理，就是把物体的轮廓渲染到一张RenderTexture上，然后把 RT按照某种方式再贴回原始场景图。那么，我们要怎么样得到物体的轮廓呢？首先，我们可以渲染一个物体到RT上，可以通过RenderCommond进行 处理，不过RenderCommond是Unity5才提供的特性，加上这篇文章实在拖太久了，决定还是先用比较土的办法实现吧。
     
    用 一个额外的摄像机：通过增加一个和Main Camera一样的摄像机，通过设置摄像机的LayerMask，将要渲染的对象设置到这个层中，然后将摄像机的Render Target设置为我们设定好的一张Render Texture上，就实现了渲染到RT上的部分，而这张RT由于我们需要在后处理的时候使用，所以我们在之前获得这张RT，Unity为我们提供了一 个 OnPreRender函数，这个函数是在渲染之前的回调，我们就可以在这个地方完成RT的渲染。但是还有一个问题，就是我们默认的shader是模 型自身设置的shader，而不是纯色的shader，我们要怎么临时换成一个纯色的shader呢？其实Unity也为我们准备好了一个函 数：Camera.RenderWithShader，可以让摄像机的本次渲染采用我们设置的shader，这个函数接受两个参数，第一个是需要用的 shader，第二个是一个字符串，还记得shader里面经常写的RenderType吗，其实主要就是为了RenderWithShader服务的， 如果我们没给RenderType，那么摄像机需要渲染的所有物体都会被替换shader渲染，如果我们给了RenderType，Unity就会去对比 目前使用的shader中的RenderType，有的话才去渲染，不匹配的不会被替换shader渲染（关于RenderWithShader，可以参 考这篇文章）。到了这里，我们就能够得到渲染到RT上的纯色的渲染RT了，如下图：

    下 一步，为了让轮廓出现，我们需要考虑的是怎么让这个轮廓图“胖一点”，回想一下之前的几篇文章，通过模糊效果，就可以让轮廓图胖一些，所谓模糊，就是让当 前像素的颜色值从当前像素以及像素周围的几个采样点按照加权平均重新计算，很明显，上面的这张图进行计算时，人边缘部分的颜色肯定会和周围的黑色平均，导 致颜色溢出，进而达到发胖的效果。关于模糊，可以参考之前的两篇文章：简单均值模糊和高斯模糊，这里就不多做解释了，经过模糊后的结果如下：

    然后呢，我们就可以让两者相减一下，让胖的扣去瘦的部分，就留下了轮廓部分：

    最后，再把这张RT和我们正常渲染的场景图进行结合，就可以得到基于后处理的描边效果了。最后的结合方式有很多种，最简单的方式是直接叠加，附上后处理的C#及Shader代码，为了更清晰，此处把每个步骤拆成单独的Pass实现了。
    C#脚本部分（PostEffect为后处理基类，见简单屏幕较色）：
    [csharp] view plain copy
    1. /******************************************************************** 
    2.  FileName: OutlinePostEffect.cs 
    3.  Description: 后处理描边效果 
    4.  Created: 2017/01/12 
    5.  history: 12:1:2017 0:42 by puppet_master 
    6. *********************************************************************/  
    7. using UnityEngine;  
    8. using System.Collections;  
    9.   
    10. public class OutlinePostEffect : PostEffectBase  
    11. {  
    12.   
    13.     private Camera mainCam = null;  
    14.     private Camera additionalCam = null;  
    15.     private RenderTexture renderTexture = null;  
    16.   
    17.     public Shader outlineShader = null;  
    18.     //采样率  
    19.     public float samplerScale = 1;  
    20.     public int downSample = 1;  
    21.     public int iteration = 2;  
    22.   
    23.     void Awake()  
    24.     {  
    25.         //创建一个和当前相机一致的相机  
    26.         InitAdditionalCam();  
    27.   
    28.     }  
    29.   
    30.     private void InitAdditionalCam()  
    31.     {  
    32.         mainCam = GetComponent();  
    33.         if (mainCam == null)  
    34.             return;  
    35.   
    36.         Transform addCamTransform = transform.FindChild("additionalCam");  
    37.         if (addCamTransform != null)  
    38.             DestroyImmediate(addCamTransform.gameObject);  
    39.   
    40.         GameObject additionalCamObj = new GameObject("additionalCam");  
    41.         additionalCam = additionalCamObj.AddComponent();  
    42.   
    43.         SetAdditionalCam();  
    44.     }  
    45.   
    46.     private void SetAdditionalCam()  
    47.     {  
    48.         if (additionalCam)  
    49.         {  
    50.             additionalCam.transform.parent = mainCam.transform;  
    51.             additionalCam.transform.localPosition = Vector3.zero;  
    52.             additionalCam.transform.localRotation = Quaternion.identity;  
    53.             additionalCam.transform.localScale = Vector3.one;  
    54.             additionalCam.farClipPlane = mainCam.farClipPlane;  
    55.             additionalCam.nearClipPlane = mainCam.nearClipPlane;  
    56.             additionalCam.fieldOfView = mainCam.fieldOfView;  
    57.             additionalCam.backgroundColor = Color.clear;  
    58.             additionalCam.clearFlags = CameraClearFlags.Color;  
    59.             additionalCam.cullingMask = 1 << LayerMask.NameToLayer("Additional");  
    60.             additionalCam.depth = -999;   
    61.             if (renderTexture == null)  
    62.                 renderTexture = RenderTexture.GetTemporary(additionalCam.pixelWidth >> downSample, additionalCam.pixelHeight >> downSample, 0);  
    63.         }  
    64.     }  
    65.   
    66.     void OnEnable()  
    67.     {  
    68.         SetAdditionalCam();  
    69.         additionalCam.enabled = true;  
    70.     }  
    71.   
    72.     void OnDisable()  
    73.     {  
    74.         additionalCam.enabled = false;  
    75.     }  
    76.   
    77.     void OnDestroy()  
    78.     {  
    79.         if (renderTexture)  
    80.         {  
    81.             RenderTexture.ReleaseTemporary(renderTexture);  
    82.         }  
    83.         DestroyImmediate(additionalCam.gameObject);  
    84.     }  
    85.   
    86.     //unity提供的在渲染之前的接口，在这一步渲染描边到RT  
    87.     void OnPreRender()  
    88.     {  
    89.         //使用OutlinePrepass进行渲染，得到RT  
    90.         if(additionalCam.enabled)  
    91.         {  
    92.             //渲染到RT上  
    93.             //首先检查是否需要重设RT，比如屏幕分辨率变化了  
    94.             if (renderTexture != null && (renderTexture.width != Screen.width >> downSample || renderTexture.height != Screen.height >> downSample))  
    95.             {  
    96.                 RenderTexture.ReleaseTemporary(renderTexture);  
    97.                 renderTexture = RenderTexture.GetTemporary(Screen.width >> downSample, Screen.height >> downSample, 0);  
    98.             }  
    99.             additionalCam.targetTexture = renderTexture;  
    100.             additionalCam.RenderWithShader(outlineShader, "");  
    101.         }  
    102.     }  
    103.   
    104.     void OnRenderImage(RenderTexture source, RenderTexture destination)  
    105.     {  
    106.         if (_Material && renderTexture)  
    107.         {  
    108.             //renderTexture.width = 111;  
    109.             //对RT进行Blur处理  
    110.             RenderTexture temp1 = RenderTexture.GetTemporary(source.width >> downSample, source.height >> downSample, 0);  
    111.             RenderTexture temp2 = RenderTexture.GetTemporary(source.width >> downSample, source.height >> downSample, 0);  
    112.   
    113.             //高斯模糊，两次模糊，横向纵向，使用pass0进行高斯模糊  
    114.             _Material.SetVector("_offsets", new Vector4(0, samplerScale, 0, 0));  
    115.             Graphics.Blit(renderTexture, temp1, _Material, 0);  
    116.             _Material.SetVector("_offsets", new Vector4(samplerScale, 0, 0, 0));  
    117.             Graphics.Blit(temp1, temp2, _Material, 0);  
    118.   
    119.             //如果有叠加再进行迭代模糊处理  
    120.             for(int i = 0; i < iteration; i++)  
    121.             {  
    122.                 _Material.SetVector("_offsets", new Vector4(0, samplerScale, 0, 0));  
    123.                 Graphics.Blit(temp2, temp1, _Material, 0);  
    124.                 _Material.SetVector("_offsets", new Vector4(samplerScale, 0, 0, 0));  
    125.                 Graphics.Blit(temp1, temp2, _Material, 0);  
    126.             }  
    127.   
    128.             //用模糊图和原始图计算出轮廓图  
    129.             _Material.SetTexture("_BlurTex", temp2);  
    130.             Graphics.Blit(renderTexture, temp1, _Material, 1);  
    131.   
    132.             //轮廓图和场景图叠加  
    133.             _Material.SetTexture("_BlurTex", temp1);  
    134.             Graphics.Blit(source, destination, _Material, 2);  
    135.   
    136.             RenderTexture.ReleaseTemporary(temp1);  
    137.             RenderTexture.ReleaseTemporary(temp2);  
    138.         }  
    139.         else  
    140.         {  
    141.             Graphics.Blit(source, destination);  
    142.         }  
    143.     }  
    144.   
    145.   
    146. }  
    Prepass Shader（用于把模型渲染到RT的shader）：
    [csharp] view plain copy
    1. //描边Shader（输出纯色）  
    2. //by：puppet_master  
    3. //2017.1.12  
    4.   
    5. Shader "ApcShader/OutlinePrePass"  
    6. {  
    7.     //子着色器    
    8.     SubShader  
    9.     {  
    10.         //描边使用两个Pass，第一个pass沿法线挤出一点，只输出描边的颜色  
    11.         Pass  
    12.         {     
    13.             CGPROGRAM  
    14.             #include "UnityCG.cginc"  
    15.             fixed4 _OutlineCol;  
    16.               
    17.             struct v2f  
    18.             {  
    19.                 float4 pos : SV_POSITION;  
    20.             };  
    21.               
    22.             v2f vert(appdata_full v)  
    23.             {  
    24.                 v2f o;  
    25.                 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    26.                 return o;  
    27.             }  
    28.               
    29.             fixed4 frag(v2f i) : SV_Target  
    30.             {  
    31.                 //这个Pass直接输出描边颜色  
    32.                 return fixed4(1,0,0,1);  
    33.             }  
    34.               
    35.             //使用vert函数和frag函数  
    36.             #pragma vertex vert  
    37.             #pragma fragment frag  
    38.             ENDCG  
    39.         }  
    40.     }  
    41. }  
    后处理shader（三个Pass，模糊处理，抠出轮廓，最终混合）：
    [csharp] view plain copy
    1. //后处理描边Shader  
    2. //by：puppet_master  
    3. //2017.1.12  
    4.   
    5. Shader "Custom/OutLinePostEffect" {  
    6.   
    7.     Properties{  
    8.         _MainTex("Base (RGB)", 2D) = "white" {}  
    9.         _BlurTex("Blur", 2D) = "white"{}  
    10.     }  
    11.   
    12.     CGINCLUDE  
    13.     #include "UnityCG.cginc"  
    14.       
    15.     //用于剔除中心留下轮廓  
    16.     struct v2f_cull  
    17.     {  
    18.         float4 pos : SV_POSITION;  
    19.         float2 uv : TEXCOORD0;  
    20.     };  
    21.   
    22.     //用于模糊  
    23.     struct v2f_blur  
    24.     {  
    25.         float4 pos : SV_POSITION;  
    26.         float2 uv  : TEXCOORD0;  
    27.         float4 uv01 : TEXCOORD1;  
    28.         float4 uv23 : TEXCOORD2;  
    29.         float4 uv45 : TEXCOORD3;  
    30.     };  
    31.   
    32.     //用于最后叠加  
    33.     struct v2f_add  
    34.     {  
    35.         float4 pos : SV_POSITION;  
    36.         float2 uv  : TEXCOORD0;  
    37.         float2 uv1 : TEXCOORD1;  
    38.     };  
    39.   
    40.     sampler2D _MainTex;  
    41.     float4 _MainTex_TexelSize;  
    42.     sampler2D _BlurTex;  
    43.     float4 _BlurTex_TexelSize;  
    44.     float4 _offsets;  
    45.   
    46.     //Blur图和原图进行相减获得轮廓  
    47.     v2f_cull vert_cull(appdata_img v)  
    48.     {  
    49.         v2f_cull o;  
    50.         o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    51.         o.uv = v.texcoord.xy;  
    52.         //dx中纹理从左上角为初始坐标，需要反向  
    53. #if UNITY_UV_STARTS_AT_TOP  
    54.         if (_MainTex_TexelSize.y < 0)  
    55.             o.uv.y = 1 - o.uv.y;  
    56. #endif    
    57.         return o;  
    58.     }  
    59.   
    60.     fixed4 frag_cull(v2f_cull i) : SV_Target  
    61.     {  
    62.         fixed4 colorMain = tex2D(_MainTex, i.uv);  
    63.         fixed4 colorBlur = tex2D(_BlurTex, i.uv);  
    64.         //最后的颜色是_BlurTex - _MainTex，周围0-0=0，黑色；边框部分为描边颜色-0=描边颜色；中间部分为描边颜色-描边颜色=0。最终输出只有边框  
    65.         //return fixed4((colorBlur - colorMain).rgb, 1);  
    66.         return colorBlur - colorMain;  
    67.     }  
    68.   
    69.     //高斯模糊 vert shader（之前的文章有详细注释，此处也可以用BoxBlur，更省一点）  
    70.     v2f_blur vert_blur(appdata_img v)  
    71.     {  
    72.         v2f_blur o;  
    73.         _offsets *= _MainTex_TexelSize.xyxy;  
    74.         o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    75.         o.uv = v.texcoord.xy;  
    76.   
    77.         o.uv01 = v.texcoord.xyxy + _offsets.xyxy * float4(1, 1, -1, -1);  
    78.         o.uv23 = v.texcoord.xyxy + _offsets.xyxy * float4(1, 1, -1, -1) * 2.0;  
    79.         o.uv45 = v.texcoord.xyxy + _offsets.xyxy * float4(1, 1, -1, -1) * 3.0;  
    80.   
    81.         return o;  
    82.     }  
    83.   
    84.     //高斯模糊 pixel shader  
    85.     fixed4 frag_blur(v2f_blur i) : SV_Target  
    86.     {  
    87.         fixed4 color = fixed4(0,0,0,0);  
    88.         color += 0.40 * tex2D(_MainTex, i.uv);  
    89.         color += 0.15 * tex2D(_MainTex, i.uv01.xy);  
    90.         color += 0.15 * tex2D(_MainTex, i.uv01.zw);  
    91.         color += 0.10 * tex2D(_MainTex, i.uv23.xy);  
    92.         color += 0.10 * tex2D(_MainTex, i.uv23.zw);  
    93.         color += 0.05 * tex2D(_MainTex, i.uv45.xy);  
    94.         color += 0.05 * tex2D(_MainTex, i.uv45.zw);  
    95.         return color;  
    96.     }  
    97.   
    98.     //最终叠加 vertex shader  
    99.     v2f_add vert_add(appdata_img v)  
    100.     {  
    101.         v2f_add o;  
    102.         //mvp矩阵变换  
    103.         o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    104.         //uv坐标传递  
    105.         o.uv.xy = v.texcoord.xy;  
    106.         o.uv1.xy = o.uv.xy;  
    107. #if UNITY_UV_STARTS_AT_TOP  
    108.         if (_MainTex_TexelSize.y < 0)  
    109.             o.uv.y = 1 - o.uv.y;  
    110. #endif    
    111.         return o;  
    112.     }  
    113.   
    114.     fixed4 frag_add(v2f_add i) : SV_Target  
    115.     {  
    116.         //取原始场景图片进行采样  
    117.         fixed4 ori = tex2D(_MainTex, i.uv1);  
    118.         //取得到的轮廓图片进行采样  
    119.         fixed4 blur = tex2D(_BlurTex, i.uv);  
    120.         //输出：直接叠加  
    121.         fixed4 final = ori + blur;  
    122.         return final;  
    123.     }  
    124.   
    125.         ENDCG  
    126.   
    127.     SubShader  
    128.     {  
    129.         //pass 0: 高斯模糊  
    130.         Pass  
    131.         {  
    132.             ZTest Off  
    133.             Cull Off  
    134.             ZWrite Off  
    135.             Fog{ Mode Off }  
    136.   
    137.             CGPROGRAM  
    138.             #pragma vertex vert_blur  
    139.             #pragma fragment frag_blur  
    140.             ENDCG  
    141.         }  
    142.           
    143.         //pass 1: 剔除中心部分   
    144.         Pass  
    145.         {  
    146.             ZTest Off  
    147.             Cull Off  
    148.             ZWrite Off  
    149.             Fog{ Mode Off }  
    150.   
    151.             CGPROGRAM  
    152.             #pragma vertex vert_cull  
    153.             #pragma fragment frag_cull  
    154.             ENDCG  
    155.         }  
    156.   
    157.   
    158.         //pass 2: 最终叠加  
    159.         Pass  
    160.         {  
    161.   
    162.             ZTest Off  
    163.             Cull Off  
    164.             ZWrite Off  
    165.             Fog{ Mode Off }  
    166.   
    167.             CGPROGRAM  
    168.             #pragma vertex vert_add  
    169.             #pragma fragment frag_add  
    170.             ENDCG  
    171.         }  
    172.   
    173.     }  
    174. }  
    描边结果（把要描边的对象放到Additional层中）：

    换个颜色，加大一下模糊程度：

    这 种类型的shader其实跟最上面的剑灵中的描边效果很像，尤其是第一张图，描边并不是一个硬边，而是一个柔和的，渐变的边缘效果，在最靠近模型的部分颜 色最强，越向外，描边效果逐渐减弱。个人最喜欢这个描边效果，不过这个后处理是真的费啊，强烈不推荐移动上使用，一般带模糊的效果，都要慎用，超级费（然 而本人超级喜欢的效果基本都是需要模糊来实现的，比如景深，Bloom，毛玻璃等等，效果永远是跟性能成反比的）。这个后处理还有一个问题，就是不能遮 挡，因为渲染到RT之后，再通过模糊减去原图，只会留下整体的边界，而不会把中间重叠的部分留下。暂时没想到什么好办法，如果哪位热心人有好点子，还望不 吝赐教。
     
    下 面再调整一下这个shader，首先，我们把这个描边效果换成一个硬边，跟我们最早通过增加个外拓Pass达到一样的效果；然后就是让我们输出的颜色是我 们自己想要的颜色，因为上面的实现实际上是一种叠加，并不是我们原始的写在Prepass那个shader里面输出的颜色，而且那个是写死在shader 里的，不能调整。我们希望给一个可调整的参数；最后，由于上面shader中最后的两个Pass其实是可以合并成一个Pass来实现的，通过增加一个贴图 槽，这样就可以省下一次全屏Pass。
    C#部分：
    [csharp] view plain copy
    1. /******************************************************************** 
    2.  FileName: OutlinePostEffect.cs 
    3.  Description: 后处理描边效果 
    4.  Created: 2017/01/12 
    5.  history: 12:1:2017 0:42 by puppet_master 
    6. *********************************************************************/  
    7. using UnityEngine;  
    8. using System.Collections;  
    9.   
    10. public class OutlinePostEffectX : PostEffectBase  
    11. {  
    12.   
    13.     private Camera mainCam = null;  
    14.     private Camera additionalCam = null;  
    15.     private RenderTexture renderTexture = null;  
    16.   
    17.     public Shader outlineShader = null;  
    18.     //采样率  
    19.     public float samplerScale = 0.01f;  
    20.     public int downSample = 0;  
    21.     public int iteration = 0;  
    22.     public Color outlineColor = Color.green;  
    23.   
    24.     void Awake()  
    25.     {  
    26.         //创建一个和当前相机一致的相机  
    27.         InitAdditionalCam();  
    28.   
    29.     }  
    30.   
    31.     private void InitAdditionalCam()  
    32.     {  
    33.         mainCam = GetComponent();  
    34.         if (mainCam == null)  
    35.             return;  
    36.   
    37.         Transform addCamTransform = transform.FindChild("additionalCam");  
    38.         if (addCamTransform != null)  
    39.             DestroyImmediate(addCamTransform.gameObject);  
    40.   
    41.         GameObject additionalCamObj = new GameObject("additionalCam");  
    42.         additionalCam = additionalCamObj.AddComponent();  
    43.   
    44.         SetAdditionalCam();  
    45.     }  
    46.   
    47.     private void SetAdditionalCam()  
    48.     {  
    49.         if (additionalCam)  
    50.         {  
    51.             additionalCam.transform.parent = mainCam.transform;  
    52.             additionalCam.transform.localPosition = Vector3.zero;  
    53.             additionalCam.transform.localRotation = Quaternion.identity;  
    54.             additionalCam.transform.localScale = Vector3.one;  
    55.             additionalCam.farClipPlane = mainCam.farClipPlane;  
    56.             additionalCam.nearClipPlane = mainCam.nearClipPlane;  
    57.             additionalCam.fieldOfView = mainCam.fieldOfView;  
    58.             additionalCam.backgroundColor = Color.clear;  
    59.             additionalCam.clearFlags = CameraClearFlags.Color;  
    60.             additionalCam.cullingMask = 1 << LayerMask.NameToLayer("Additional");  
    61.             additionalCam.depth = -999;  
    62.             if (renderTexture == null)  
    63.                 renderTexture = RenderTexture.GetTemporary(additionalCam.pixelWidth >> downSample, additionalCam.pixelHeight >> downSample, 0);  
    64.         }  
    65.     }  
    66.   
    67.     void OnEnable()  
    68.     {  
    69.         SetAdditionalCam();  
    70.         additionalCam.enabled = true;  
    71.     }  
    72.   
    73.     void OnDisable()  
    74.     {  
    75.         additionalCam.enabled = false;  
    76.     }  
    77.   
    78.     void OnDestroy()  
    79.     {  
    80.         if (renderTexture)  
    81.         {  
    82.             RenderTexture.ReleaseTemporary(renderTexture);  
    83.         }  
    84.         DestroyImmediate(additionalCam.gameObject);  
    85.     }  
    86.   
    87.     //unity提供的在渲染之前的接口，在这一步渲染描边到RT  
    88.     void OnPreRender()  
    89.     {  
    90.         //使用OutlinePrepass进行渲染，得到RT  
    91.         if (additionalCam.enabled)  
    92.         {  
    93.             //渲染到RT上  
    94.             //首先检查是否需要重设RT，比如屏幕分辨率变化了  
    95.             if (renderTexture != null && (renderTexture.width != Screen.width >> downSample || renderTexture.height != Screen.height >> downSample))  
    96.             {  
    97.                 RenderTexture.ReleaseTemporary(renderTexture);  
    98.                 renderTexture = RenderTexture.GetTemporary(Screen.width >> downSample, Screen.height >> downSample, 0);  
    99.             }  
    100.             additionalCam.targetTexture = renderTexture;  
    101.             additionalCam.RenderWithShader(outlineShader, "");  
    102.         }  
    103.     }  
    104.   
    105.     void OnRenderImage(RenderTexture source, RenderTexture destination)  
    106.     {  
    107.         if (_Material && renderTexture)  
    108.         {  
    109.             //renderTexture.width = 111;  
    110.             //对RT进行Blur处理  
    111.             RenderTexture temp1 = RenderTexture.GetTemporary(source.width >> downSample, source.height >> downSample, 0);  
    112.             RenderTexture temp2 = RenderTexture.GetTemporary(source.width >> downSample, source.height >> downSample, 0);  
    113.   
    114.             //高斯模糊，两次模糊，横向纵向，使用pass0进行高斯模糊  
    115.             _Material.SetVector("_offsets", new Vector4(0, samplerScale, 0, 0));  
    116.             Graphics.Blit(renderTexture, temp1, _Material, 0);  
    117.             _Material.SetVector("_offsets", new Vector4(samplerScale, 0, 0, 0));  
    118.             Graphics.Blit(temp1, temp2, _Material, 0);  
    119.   
    120.             //如果有叠加再进行迭代模糊处理  
    121.             for (int i = 0; i < iteration; i++)  
    122.             {  
    123.                 _Material.SetVector("_offsets", new Vector4(0, samplerScale, 0, 0));  
    124.                 Graphics.Blit(temp2, temp1, _Material, 0);  
    125.                 _Material.SetVector("_offsets", new Vector4(samplerScale, 0, 0, 0));  
    126.                 Graphics.Blit(temp1, temp2, _Material, 0);  
    127.             }  
    128.   
    129.             //用模糊图和原始图计算出轮廓图,并和场景图叠加,节省一个Pass  
    130.             _Material.SetTexture("_OriTex", renderTexture);  
    131.             _Material.SetTexture("_BlurTex", temp2);  
    132.             _Material.SetColor("_OutlineColor", outlineColor);  
    133.             Graphics.Blit(source, destination, _Material, 1);  
    134.   
    135.             RenderTexture.ReleaseTemporary(temp1);  
    136.             RenderTexture.ReleaseTemporary(temp2);  
    137.         }  
    138.         else  
    139.         {  
    140.             Graphics.Blit(source, destination);  
    141.         }  
    142.     }  
    143. }  
    描边Shader部分：
    [csharp] view plain copy
    1. //后处理描边Shader  
    2. //by：puppet_master  
    3. //2017.1.12  
    4.   
    5. Shader "Custom/OutLinePostEffectX" {  
    6.   
    7.     Properties{  
    8.         _MainTex("Base (RGB)", 2D) = "white" {}  
    9.         _BlurTex("Blur", 2D) = "white"{}  
    10.         _OriTex("Ori", 2D) = "white"{}  
    11.     }  
    12.     CGINCLUDE  
    13.     #include "UnityCG.cginc"  
    14.       
    15.   
    16.     //用于模糊  
    17.     struct v2f_blur  
    18.     {  
    19.         float4 pos : SV_POSITION;  
    20.         float2 uv  : TEXCOORD0;  
    21.         float4 uv01 : TEXCOORD1;  
    22.         float4 uv23 : TEXCOORD2;  
    23.         float4 uv45 : TEXCOORD3;  
    24.     };  
    25.   
    26.     //用于最后叠加  
    27.     struct v2f_add  
    28.     {  
    29.         float4 pos : SV_POSITION;  
    30.         float2 uv  : TEXCOORD0;  
    31.         float2 uv1 : TEXCOORD1;  
    32.         float2 uv2 : TEXCOORD2;  
    33.     };  
    34.   
    35.     sampler2D _MainTex;  
    36.     float4 _MainTex_TexelSize;  
    37.     sampler2D _BlurTex;  
    38.     float4 _BlurTex_TexelSize;  
    39.     sampler2D _OriTex;  
    40.     float4 _OriTex_TexelSize;  
    41.     float4 _offsets;  
    42.     fixed4 _OutlineColor;  
    43.   
    44.     //高斯模糊 vert shader（之前的文章有详细注释，此处也可以用BoxBlur，更省一点）  
    45.     v2f_blur vert_blur(appdata_img v)  
    46.     {  
    47.         v2f_blur o;  
    48.         _offsets *= _MainTex_TexelSize.xyxy;  
    49.         o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    50.         o.uv = v.texcoord.xy;  
    51.   
    52.         o.uv01 = v.texcoord.xyxy + _offsets.xyxy * float4(1, 1, -1, -1);  
    53.         o.uv23 = v.texcoord.xyxy + _offsets.xyxy * float4(1, 1, -1, -1) * 2.0;  
    54.         o.uv45 = v.texcoord.xyxy + _offsets.xyxy * float4(1, 1, -1, -1) * 3.0;  
    55.   
    56.         return o;  
    57.     }  
    58.   
    59.     //高斯模糊 pixel shader  
    60.     fixed4 frag_blur(v2f_blur i) : SV_Target  
    61.     {  
    62.         fixed4 color = fixed4(0,0,0,0);  
    63.         color += 0.40 * tex2D(_MainTex, i.uv);  
    64.         color += 0.15 * tex2D(_MainTex, i.uv01.xy);  
    65.         color += 0.15 * tex2D(_MainTex, i.uv01.zw);  
    66.         color += 0.10 * tex2D(_MainTex, i.uv23.xy);  
    67.         color += 0.10 * tex2D(_MainTex, i.uv23.zw);  
    68.         color += 0.05 * tex2D(_MainTex, i.uv45.xy);  
    69.         color += 0.05 * tex2D(_MainTex, i.uv45.zw);  
    70.         return color;  
    71.     }  
    72.   
    73.     //最终叠加 vertex shader  
    74.     v2f_add vert_add(appdata_img v)  
    75.     {  
    76.         v2f_add o;  
    77.         //mvp矩阵变换  
    78.         o.pos = mul(UNITY_MATRIX_MVP, v.vertex);  
    79.         //uv坐标传递  
    80.         o.uv.xy = v.texcoord.xy;  
    81.         o.uv1.xy = o.uv.xy;  
    82.         o.uv2.xy = o.uv.xy;  
    83. #if UNITY_UV_STARTS_AT_TOP  
    84.         //if  (_OriTex_TexelSize.y < 0)  
    85.             o.uv.y = 1 - o.uv.y;  
    86.             o.uv2.y = 1 - o.uv2.y;  
    87. #endif    
    88.         return o;  
    89.     }  
    90.   
    91.     fixed4 frag_add(v2f_add i) : SV_Target  
    92.     {  
    93.         //取原始场景纹理进行采样  
    94.         fixed4 scene = tex2D(_MainTex, i.uv1);  
    95.         //return scene;  
    96.         //对blur后的纹理进行采样  
    97.         fixed4 blur = tex2D(_BlurTex, i.uv);  
    98.         //对blur之前的rt进行采样  
    99.         fixed4 ori = tex2D(_OriTex, i.uv);  
    100.         //轮廓是_BlurTex - _OriTex，周围0-0=0，黑色；边框部分为描边颜色-0=描边颜色；中间部分为描边颜色-描边颜色=0。最终输出只有边框  
    101.         fixed4 outline = blur - ori;  
    102.           
    103.         //输出：blur部分为0的地方返回原始图像，否则为0，然后叠加描边  
    104.         fixed4 final = scene * (1 - all(outline.rgb)) + _OutlineColor * any(outline.rgb);//0.01,1,1  
    105.         return final;  
    106.     }  
    107.   
    108.         ENDCG  
    109.   
    110.     SubShader  
    111.     {  
    112.         //pass 0: 高斯模糊  
    113.         Pass  
    114.         {  
    115.             ZTest Off  
    116.             Cull Off  
    117.             ZWrite Off  
    118.             Fog{ Mode Off }  
    119.   
    120.             CGPROGRAM  
    121.             #pragma vertex vert_blur  
    122.             #pragma fragment frag_blur  
    123.             ENDCG  
    124.         }  
    125.   
    126.         //pass 1: 剔除中心部分以及最后和场景图叠加  
    127.         Pass  
    128.         {  
    129.             ZTest Off  
    130.             Cull Off  
    131.             ZWrite Off  
    132.             Fog{ Mode Off }  
    133.   
    134.             CGPROGRAM  
    135.             #pragma vertex vert_add  
    136.             #pragma fragment frag_add  
    137.             ENDCG  
    138.         }  
    139.   
    140.     }  
    141. }  
    结果如下：

    总结

     
    本 篇文章主要研究了一下描边效果的几种类型（边缘发光型，硬描边，柔和边缘的描边）以及实现方式（边缘光，深度偏移，法线外拓，后处理）：几种描边效果各有 各的优点和缺点，最省的是边缘光效果，深度偏移+法线外拓的方式基本可以满足真正的描边需求，而后处理的效果比较好，但是如果能只增加一个pass就能得 到的效果，就没有必要用后处理了，尤其是移动平台上。最后推荐一个后处理的插件：Highting System，里面有各种类型的描边效果，不过这个插件也是通过后处理来实现的（使用了RenderCommand+后处理），也是比较费。插件中模糊的 描边效果：

    硬边的描边效果：
  • 相关阅读:
    swift网络数据请求方法
    使用jQuery在javascript中自定义事件
    javascript循环事件只响应最后一次的问题处理
    关于PHP 时区错误的问题
    安装MySql出现Error Nr.1045的解决办法
    view的阴影效果shadowColor
    关于Swift中的泛函数find的问题
    [BZOJ3196][Tyvj1730]二逼平衡树
    [BZOJ4671]异或图
    [BZOJ4621]Tc605
  • 原文地址：https://www.cnblogs.com/alps/p/7606028.html
Copyright © 2011-2022 走看看