devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity HDRP Custom Pass (Post processing) 后处理特效学习（二）总结

作者：我家小花儿 | 2024-02-17 22:01:03

赞

踩

hdrp custompass

目录

B站视频

B站视频，录制不易，求关注、一键三连(点赞、投币、收藏)。置顶评论内有PPT(内有优秀参考资源链接)、工程、插件、群号。

官方社区

文字版总结，编写不易，求关注、点赞。手机版阅读困难的，记得是在电脑浏览器中查看 开发者社区 。

分享背景

突然开始做分享主要2个原因。
  • 有朋友和我说Unity是不是只是手游引擎呀，UE能做的Unity能不能做呀，恰巧看到虚幻官方月神的直播讲后处理，所以就试着也录一期Unity的，证明Unity并不只是手游引擎。
  • 最近被一个Unity官方合作的知名博主up主麦扣的群里的管理员傲娇修酒z侮辱了，发现如果没有粉丝，被人侮辱的时候甚至没有人帮我说话，所以希望吸引一些愿意帮我说话的粉丝。除非麦扣把侮辱人的管理员踢掉，否则这事情永远不会揭过。
另外这可能不是最好的分享，但是绝对是最详细的分享，不会不求甚解的去分享一些一眼就能看明白的东西。

感谢

首先要感谢一下叶月葵(Hazukiaoi)，没有他，无法制作这系列视频和分享。

上一期有更新

上一期有更新，补充了很多内容和配图，务必重新阅读一遍。 Unity HDRP Custom Pass (Post processing) 后处理特效学习(一)总结

屏幕尺寸 _ScreenSize

屏幕尺寸_ScreenSize是一个float4，内容分别是(W,H,1/W,1/H)。W和H很好理解，就是屏幕宽高。那么1/W和1/H是什么用途的呢？可以回想上一期视频和分享中提到的PositionInput结构体中的positionNDC跟positionSS，_ScreenSize主要用于这两个坐标之间的转换。 
  1.     
  2.     
  3.      
  4.      positionNDC 
  5.      
  6.      =
  7.      
  8.       positionSS 
  9.      
  10.      *
  11.      
  12.       _ScreenSize
  13.      
  14.      .
  15.      
  16.      zw
  17.      
  18.      ;
  19.      
  20.      
  21. positionSS 
  22.      
  23.      =
  24.      
  25.       positionNDC 
  26.      
  27.      *
  28.      
  29.       _ScreenSize
  30.      
  31.      .
  32.      
  33.      xy
  34.      
  35.      ;
  36.

ddx/ddy

ddx

返回指定值相对于屏幕空间x坐标的偏导数。

ddy

返回指定值相对于屏幕空间y座标的偏导数。

计算方法

在三角形光栅化过程中，GPU一次运行许多片段着色器的实例，将它们组织成2×2像素的块。dFdx是将块中像素值的差值减去块左侧的像素值和右侧的像素值，dFdy是将底部像素的值减去顶部像素的值。请看下面的图片，其中网格表示渲染的屏幕像素，dFdx、dFdy表达式是为由片段着色器实例在(x、y)屏幕坐标处计算的通用值p提供的，属于2×2块的红色高亮显示的2×2块。导数可以对片段着色器中的每个变量进行计算。 对于向量和矩阵类型，导数是按元素计算的。
值得注意的是图上是以glsl中的dFdx和dFdy进行讲解，实际上Unity中使用的是hlsl中的ddx和ddy，并且是以左下角为坐标原点。其次，既然ddx和ddy是像图中一样，ddx(p(x,y))=p(x+1,y)-p(x,y)，ddy(p(x,y))=p(x,y+1)-p(x,y)。对于显卡内部计算这个2x2块，并不知道旁边的2x2块的数据，那么他是怎么计算ddx(p(x+1,y))、ddx(p(x,y+1))、ddx(p(x+1,y+1))、ddy(p(x+1,y))、ddy(p(x,y+1))、ddy(p(x+1,y+1))的呢？
怀着这个疑问，进行了测试与探讨，最终得出结论，2x2块中，4个像素的ddx共享一个值，4个像素的ddy共享一个值。ddx只与p(x,y)、p(x+1,y)有关，ddy只与p(x,y)、p(x,y+1)有关。无论ddx与ddy都与p(x+1,y+1)无关。
可以自行查看工程中的CheckDDX场景进行验证，下面有些截图证明这个结论。
从上面几张图，可以看出，ddx跟左下p(x,y)，右下p(x+1,y)有关，跟左上p(x,y+1)，右上p(x+1,y+1)无关。看颜色变化，输出的是ddx的值。
从上面几张图，可以看出，ddy跟左下p(x,y)，左上p(x,y+1)有关，跟右下p(x+1,y)，右上p(x+1,y+1)无关。看颜色变化，输出的是ddy的值。
从上面几张图，可以看出，ddx ddy都跟右上右上p(x+1,y+1)无关。
那为什么一定要搞明白这个ddx和ddy的计算方式呢？那是因为后面介绍的第一种最简单的勾边方式，就是使用ddx、ddy对设备深度、线性深度、世界法线计算来达到勾边的目的。但是你会发现ddx和ddy的方式勾边会有断线的情况，其实这个就是因为这个4个像素共享ddx ddy值导致的，所以如果真的用ddx、ddy进行勾边，一般还会加上一个TAA的抗锯齿。

abs

返回指定值的绝对值。

clamp/saturate

clamp

将指定的值夹在指定的最小和最大范围内。

saturate

将指定的值夹在0到1的范围内。如果你是要夹在0到1的之间的话，应该使用saturate，他基本上是一个硬件级别的函数，几乎无消耗。

使用ddx、ddy进行勾边

使用设备深度

可以看到，简单的使用ddx、ddy就能做到一个简单的勾边。
首先来说计算方法，计算方法就是对设备深度数据进行了ddx、ddy计算后取绝对值相加，然后再通过saturate去把数值夹在0-1之间。
那么再来说说原理，原理就是ddx对ddy分别对每个像素对x、y计算偏导数，得到变化率，变化率高的地方代表设备深度差异大，是边缘。
那么，为什么表面会有亮面一样的效果呢？因为平面并不是平行于摄像机平面，有深度差异，所以变化率并不是0，因此会有微光，如果想去掉可以用后面介绍手动计算勾边的方法里的Contrast方法来增强对比度的方式来去除这些微光。
最后，来说说为什么断线，相信你阅读了前面的分享，你应该已经明白ddx和ddy是2x2块里4个像素共享ddx和ddy的值，因此，除了左下的像素，另外3个像素计算变化率的结果是不准确的，这就是造成断线的原因。
后续在介绍如何手动计算勾边的方法，再介绍如何与原场景融合。 
  1.     
  2.     
  3.      
  4.      // ddx & ddy outline by device depth
  5.      
  6.      
  7. md 
  8.      
  9.      =
  10.      
  11.       posInput
  12.      
  13.      .
  14.      
  15.      deviceDepth 
  16.      
  17.      *
  18.      
  19.       
  20.      
  21.      1000
  22.      
  23.      ;
  24.      
  25.      
  26. finalColor 
  27.      
  28.      =
  29.      
  30.       
  31.      
  32.      abs
  33.      
  34.      (
  35.      
  36.      ddx
  37.      
  38.      (
  39.      
  40.      md
  41.      
  42.      )
  43.      
  44.      )
  45.      
  46.       
  47.      
  48.      +
  49.      
  50.       
  51.      
  52.      abs
  53.      
  54.      (
  55.      
  56.      ddy
  57.      
  58.      (
  59.      
  60.      md
  61.      
  62.      )
  63.      
  64.      )
  65.      
  66.      ;
  67.      
  68.      
  69. finalColor 
  70.      
  71.      =
  72.      
  73.       
  74.      
  75.      saturate
  76.      
  77.      (
  78.      
  79.      finalColor
  80.      
  81.      )
  82.      
  83.      ;
  84.

使用线性深度

同样的，用相同的原理，通过线性深度使用ddx、ddy做到了一个简单的勾边。 
  1.     
  2.     
  3.      
  4.      // ddx & ddy outline by linear depth
  5.      
  6.      
  7. md 
  8.      
  9.      =
  10.      
  11.       posInput
  12.      
  13.      .
  14.      
  15.      linearDepth 
  16.      
  17.      *
  18.      
  19.       
  20.      
  21.      10
  22.      
  23.      ;
  24.      
  25.      
  26. finalColor 
  27.      
  28.      =
  29.      
  30.       
  31.      
  32.      abs
  33.      
  34.      (
  35.      
  36.      ddx
  37.      
  38.      (
  39.      
  40.      md
  41.      
  42.      )
  43.      
  44.      )
  45.      
  46.       
  47.      
  48.      +
  49.      
  50.       
  51.      
  52.      abs
  53.      
  54.      (
  55.      
  56.      ddy
  57.      
  58.      (
  59.      
  60.      md
  61.      
  62.      )
  63.      
  64.      )
  65.      
  66.      ;
  67.      
  68.      
  69. finalColor 
  70.      
  71.      =
  72.      
  73.       
  74.      
  75.      saturate
  76.      
  77.      (
  78.      
  79.      finalColor
  80.      
  81.      )
  82.      
  83.      ;
  84.

使用世界法线

同样的，用相同的原理，通过世界法线使用ddx、ddy做到了一个简单的勾边。
那么为什么地上有种脏脏的感觉呢，为什么都被勾上了弱边呢？那是因为地面是凹凸不平的发现，法线变化率有弱小变化。同样的，可以通过后面介绍手动计算勾边的方法里的Contrast方法来增强对比度的方式来去除这些弱边。

distance

返回两个向量之间的距离标量。

lerp

进行线性插值。

max

选择x和y中的较大者。

Contrast

((valueInput - 0.5f) * contrastInput) + 0.5f;
通过简单数值计算，达到增大或者降低对比度的目的。valueInput为原始值，contrastInput为缩放洗漱。 
  1.     
  2.     
  3.      
  4.      float
  5.      
  6.       
  7.      
  8.      Contrast
  9.      
  10.      (
  11.      
  12.      float
  13.      
  14.       contrastInput
  15.      
  16.      ,
  17.      
  18.       
  19.      
  20.      float
  21.      
  22.       valueInput
  23.      
  24.      )
  25.      
  26.      {
  27.      
  28.      
  29.     
  30.      
  31.      return
  32.      
  33.       
  34.      
  35.      (
  36.      
  37.      (
  38.      
  39.      valueInput 
  40.      
  41.      -
  42.      
  43.       
  44.      
  45.      0.5f
  46.      
  47.      )
  48.      
  49.       
  50.      
  51.      *
  52.      
  53.       contrastInput
  54.      
  55.      )
  56.      
  57.       
  58.      
  59.      +
  60.      
  61.       
  62.      
  63.      0.5f
  64.      
  65.      ;
  66.      
  67.      
  68.  
  69.      
  70.      }
  71.

手动计算进行勾边

使用世界法线

我们先来看整段代码，首先这个方法原理上跟ddx和ddy的方式类似，不一样的是，他并不会像ddx、ddy那样2x2块里的4个像素都共享一个值，而是每个像素都会单独计算。 
  1.     
  2.     
  3.      
  4.      // offset outline by world normal
  5.      
  6.      
  7. linearDepth 
  8.      
  9.      =
  10.      
  11.       posInput
  12.      
  13.      .
  14.      
  15.      linearDepth
  16.      
  17.      ;
  18.      
  19.      
  20. outlineWidth 
  21.      
  22.      =
  23.      
  24.       _OutlineWidth
  25.      
  26.      ;
  27.      
  28.      
  29. outlineWidth 
  30.      
  31.      =
  32.      
  33.       
  34.      
  35.      saturate
  36.      
  37.      (
  38.      
  39.      1
  40.      
  41.       
  42.      
  43.      -
  44.      
  45.       linearDepth 
  46.      
  47.      /
  48.      
  49.       
  50.      
  51.      1000
  52.      
  53.      )
  54.      
  55.       
  56.      
  57.      *
  58.      
  59.       outlineWidth
  60.      
  61.      ;
  62.      
  63.       
  64.  
  65.      
  66.      NormalData
  67.      
  68.       normalData0
  69.      
  70.      ;
  71.      
  72.      
  73.  
  74.      
  75.      NormalData
  76.      
  77.       normalData1
  78.      
  79.      ;
  80.      
  81.      
  82.  
  83.      
  84.      NormalData
  85.      
  86.       normalData2
  87.      
  88.      ;
  89.      
  90.      
  91.  
  92.      
  93.      DecodeFromNormalBuffer
  94.      
  95.      (
  96.      
  97.      posInput
  98.      
  99.      .
  100.      
  101.      positionSS
  102.      
  103.      ,
  104.      
  105.       normalData0
  106.      
  107.      )
  108.      
  109.      ;
  110.      
  111.      
  112.  
  113.      
  114.      DecodeFromNormalBuffer
  115.      
  116.      (
  117.      
  118.      posInput
  119.      
  120.      .
  121.      
  122.      positionSS 
  123.      
  124.      +
  125.      
  126.       
  127.      
  128.      float2
  129.      
  130.      (
  131.      
  132.      outlineWidth
  133.      
  134.      ,
  135.      
  136.      0
  137.      
  138.      )
  139.      
  140.      ,
  141.      
  142.       normalData1
  143.      
  144.      )
  145.      
  146.      ;
  147.      
  148.      
  149.  
  150.      
  151.      DecodeFromNormalBuffer
  152.      
  153.      (
  154.      
  155.      posInput
  156.      
  157.      .
  158.      
  159.      positionSS 
  160.      
  161.      +
  162.      
  163.       
  164.      
  165.      float2
  166.      
  167.      (
  168.      
  169.      0
  170.      
  171.      ,
  172.      
  173.      outlineWidth
  174.      
  175.      )
  176.      
  177.      ,
  178.      
  179.       normalData2
  180.      
  181.      )
  182.      
  183.      ;
  184.      
  185.      
  186. distanceXNormal 
  187.      
  188.      =
  189.      
  190.       
  191.      
  192.      distance
  193.      
  194.      (
  195.      
  196.      normalData0
  197.      
  198.      .
  199.      
  200.      normalWS
  201.      
  202.      ,
  203.      
  204.       normalData1
  205.      
  206.      .
  207.      
  208.      normalWS
  209.      
  210.      )
  211.      
  212.      ;
  213.      
  214.      
  215. distanceYNormal 
  216.      
  217.      =
  218.      
  219.       
  220.      
  221.      distance
  222.      
  223.      (
  224.      
  225.      normalData0
  226.      
  227.      .
  228.      
  229.      normalWS
  230.      
  231.      ,
  232.      
  233.       normalData2
  234.      
  235.      .
  236.      
  237.      normalWS
  238.      
  239.      )
  240.      
  241.      ;
  242.      
  243.      
  244. distanceSumNormal 
  245.      
  246.      =
  247.      
  248.       distanceXNormal 
  249.      
  250.      +
  251.      
  252.       distanceYNormal
  253.      
  254.      ;
  255.      
  256.      
  257. distanceSumNormal 
  258.      
  259.      =
  260.      
  261.       distanceSumNormal 
  262.      
  263.      /
  264.      
  265.       _DivideFactor
  266.      
  267.      ;
  268.     
  269.         
  270.     
  271.      
  272.      distanceSum 
  273.      
  274.      =
  275.      
  276.       distanceSumNormal
  277.      
  278.      ;
  279.      
  280.      
  281. distanceSum 
  282.      
  283.      =
  284.      
  285.       distanceSum 
  286.      
  287.      /
  288.      
  289.       _DivideFactor
  290.      
  291.      ;
  292.      
  293.      
  294. distanceSum 
  295.      
  296.      =
  297.      
  298.       
  299.      
  300.      Contrast
  301.      
  302.      (
  303.      
  304.      _ContrastInput
  305.      
  306.      ,
  307.      
  308.       distanceSum
  309.      
  310.      )
  311.      
  312.      ;
  313.      
  314.      
  315. distanceSum 
  316.      
  317.      =
  318.      
  319.       
  320.      
  321.      saturate
  322.      
  323.      (
  324.      
  325.      distanceSum
  326.      
  327.      )
  328.      
  329.      ;
  330.      
  331.      
  332. finalColor 
  333.      
  334.      =
  335.      
  336.       
  337.      
  338.      lerp
  339.      
  340.      (
  341.      
  342.      color
  343.      
  344.      ,
  345.      
  346.       _OutlineColor
  347.      
  348.      ,
  349.      
  350.       distanceSum
  351.      
  352.      )
  353.      
  354.      ;
  355.      
  356.      
  357.  
  358.      
  359.      //finalColor = color + distanceSum * _OutlineColor;
  360.
与ddx、ddy不同的是，ddx、ddy只能跟旁边一个像素对比，自己写的话，可以与偏移好几个像素的进行对比。那么你可以控制勾边的宽度。 
  1.     
  2.     
  3.      
  4.      linearDepth 
  5.      
  6.      =
  7.      
  8.       posInput
  9.      
  10.      .
  11.      
  12.      linearDepth
  13.      
  14.      ;
  15.      
  16.      
  17. outlineWidth 
  18.      
  19.      =
  20.      
  21.       _OutlineWidth
  22.      
  23.      ;
  24.      
  25.      
  26. outlineWidth 
  27.      
  28.      =
  29.      
  30.       
  31.      
  32.      saturate
  33.      
  34.      (
  35.      
  36.      1
  37.      
  38.       
  39.      
  40.      -
  41.      
  42.       linearDepth 
  43.      
  44.      /
  45.      
  46.       
  47.      
  48.      1000
  49.      
  50.      )
  51.      
  52.       
  53.      
  54.      *
  55.      
  56.       outlineWidth
  57.      
  58.      ;
  59.
那么我们先来看前三行代码，这里的目的是根据远近来控制勾边的宽度。我们这里先获取线性深度。然后，我们给outlineWidth赋值一个初值_OutlineWidth，这是shader定义的属性，可以方便我们通过材质进行控制勾边的宽度。最后，我们的Near是0.3，Far是1000，那么linearDepth/1000可以计算出与我们的远近比例。最近的为0.3/1000=0.0003，最远为1000/1000=1。那么(1-linearDepth/1000)就变成了最近的是0.9997，最远的是0。这里采用saturate是你可以Far设置1000以上，那么通过saturate可以压回到0到1之间，不会导致有负数的勾边的宽度，这里再乘以初始的勾边的宽度，达到近处勾边粗，远处勾边细的目的。 
  1.     
  2.     
  3.      
  4.      NormalData
  5.      
  6.       normalData0
  7.      
  8.      ;
  9.      
  10.      
  11.  
  12.      
  13.      NormalData
  14.      
  15.       normalData1
  16.      
  17.      ;
  18.      
  19.      
  20.  
  21.      
  22.      NormalData
  23.      
  24.       normalData2
  25.      
  26.      ;
  27.      
  28.      
  29.  
  30.      
  31.      DecodeFromNormalBuffer
  32.      
  33.      (
  34.      
  35.      posInput
  36.      
  37.      .
  38.      
  39.      positionSS
  40.      
  41.      ,
  42.      
  43.       normalData0
  44.      
  45.      )
  46.      
  47.      ;
  48.      
  49.      
  50.  
  51.      
  52.      DecodeFromNormalBuffer
  53.      
  54.      (
  55.      
  56.      posInput
  57.      
  58.      .
  59.      
  60.      positionSS 
  61.      
  62.      +
  63.      
  64.       
  65.      
  66.      float2
  67.      
  68.      (
  69.      
  70.      outlineWidth
  71.      
  72.      ,
  73.      
  74.      0
  75.      
  76.      )
  77.      
  78.      ,
  79.      
  80.       normalData1
  81.      
  82.      )
  83.      
  84.      ;
  85.      
  86.      
  87.  
  88.      
  89.      DecodeFromNormalBuffer
  90.      
  91.      (
  92.      
  93.      posInput
  94.      
  95.      .
  96.      
  97.      positionSS 
  98.      
  99.      +
  100.      
  101.       
  102.      
  103.      float2
  104.      
  105.      (
  106.      
  107.      0
  108.      
  109.      ,
  110.      
  111.      outlineWidth
  112.      
  113.      )
  114.      
  115.      ,
  116.      
  117.       normalData2
  118.      
  119.      )
  120.      
  121.      ;
  122.
接下来我们读取p(x,y)、p(x+oultineWidth,y)，p(x,y+outlineWidth)的法线数据，用于后续的对比。 
  1.     
  2.     
  3.      
  4.      distanceXNormal 
  5.      
  6.      =
  7.      
  8.       
  9.      
  10.      distance
  11.      
  12.      (
  13.      
  14.      normalData0
  15.      
  16.      .
  17.      
  18.      normalWS
  19.      
  20.      ,
  21.      
  22.       normalData1
  23.      
  24.      .
  25.      
  26.      normalWS
  27.      
  28.      )
  29.      
  30.      ;
  31.      
  32.      
  33. distanceYNormal 
  34.      
  35.      =
  36.      
  37.       
  38.      
  39.      distance
  40.      
  41.      (
  42.      
  43.      normalData0
  44.      
  45.      .
  46.      
  47.      normalWS
  48.      
  49.      ,
  50.      
  51.       normalData2
  52.      
  53.      .
  54.      
  55.      normalWS
  56.      
  57.      )
  58.      
  59.      ;
  60.
由于法线是float3的向量，因此这里采取最简单的对比方式，通过distance对比两个向量的距离标量，达到计算变化率的目的。 
  1.     
  2.     
  3.      
  4.      distanceSumNormal 
  5.      
  6.      =
  7.      
  8.       distanceXNormal 
  9.      
  10.      +
  11.      
  12.       distanceYNormal
  13.      
  14.      ;
  15.
把x跟y的变化率相加，类似ddx、ddy方式里面的计算方式。 
  1.     
  2.     
  3.      
  4.      distanceSum 
  5.      
  6.      =
  7.      
  8.       distanceSumNormal
  9.      
  10.      ;
  11.      
  12.      
  13. distanceSum 
  14.      
  15.      =
  16.      
  17.       distanceSum 
  18.      
  19.      /
  20.      
  21.       _DivideFactor
  22.      
  23.      ;
  24.      
  25.      
  26. distanceSum 
  27.      
  28.      =
  29.      
  30.       
  31.      
  32.      Contrast
  33.      
  34.      (
  35.      
  36.      _ContrastInput
  37.      
  38.      ,
  39.      
  40.       distanceSum
  41.      
  42.      )
  43.      
  44.      ;
  45.      
  46.      
  47. distanceSum 
  48.      
  49.      =
  50.      
  51.       
  52.      
  53.      saturate
  54.      
  55.      (
  56.      
  57.      distanceSum
  58.      
  59.      )
  60.      
  61.      ;
  62.      
  63.      
  64.  
  65.      
  66.      //color = float4(0,0,0,1);
  67.      
  68.      
  69. finalColor 
  70.      
  71.      =
  72.      
  73.       
  74.      
  75.      lerp
  76.      
  77.      (
  78.      
  79.      color
  80.      
  81.      ,
  82.      
  83.       _OutlineColor
  84.      
  85.      ,
  86.      
  87.       distanceSum
  88.      
  89.      )
  90.      
  91.      ;
  92.
类似_OulineWidth，我们给一个_DivideFacter的shader属性，因为距离最大可能是2，通过控制_DivideFactor来达到控制勾线强度的目的。用Contrast函数控制对比度，达到把法线导致的脏脏的弱小勾边去除。最后，通过saturate，把值压回到0到1之间。最后，通过lerp在场景颜色和_OutlineColor勾边的颜色之间进行线性差值，达到在原场景颜色上勾边的效果。我们为了观察方便，先把_DivideFactor和_ContrastInput都设置回1，通过去掉color的那行注释可以看到初始勾边效果。 仔细查看，你可以发现工作台上的木棍，上方的勾边没了，那是因为木棍表面刚好平行地面，法线一致，distance为0。所以没能勾出来边，可以通过用设备深度勾边或者混合使用世界法线、设备深度勾边来解决。其次，地面有脏脏的效果，这里，可以通过调节_ContrastInput来增大对比度达到去除这个因为地面呕吐不平法线导致的微小勾边的脏脏的效果去掉。 可以根据场景需要自由调节_ContrastInput和_DivideFactor的值来控制勾边效果。把color那行注释，可以在原场景颜色上勾边了。 除了lerp的勾边方式，还可以使用加法的方式进行勾边，能提亮的效果。 
  1.     
  2.     
  3.      
  4.      finalColor 
  5.      
  6.      =
  7.      
  8.       color 
  9.      
  10.      +
  11.      
  12.       distanceSum 
  13.      
  14.      *
  15.      
  16.       _OutlineColor
  17.      
  18.      ;
  19.

使用线性深度

我们先来看整段代码，首先这个方法和上面使用世界法线不一样的是使用的是设备深度。 
  1.     
  2.     
  3.      
  4.      // offset outline by device depth
  5.      
  6.      
  7. linearDepth 
  8.      
  9.      =
  10.      
  11.       posInput
  12.      
  13.      .
  14.      
  15.      linearDepth
  16.      
  17.      ;
  18.      
  19.      
  20. outlineWidth 
  21.      
  22.      =
  23.      
  24.       _OutlineWidth
  25.      
  26.      ;
  27.      
  28.      
  29. outlineWidth 
  30.      
  31.      =
  32.      
  33.       
  34.      
  35.      saturate
  36.      
  37.      (
  38.      
  39.      1
  40.      
  41.       
  42.      
  43.      -
  44.      
  45.       linearDepth 
  46.      
  47.      /
  48.      
  49.       
  50.      
  51.      10000
  52.      
  53.      )
  54.      
  55.       
  56.      
  57.      *
  58.      
  59.       outlineWidth
  60.      
  61.      ;
  62.      
  63.      
  64.  
  65.      
  66.      float2
  67.      
  68.       positionCS0 
  69.      
  70.      =
  71.      
  72.       varyings
  73.      
  74.      .
  75.      
  76.      positionCS
  77.      
  78.      .
  79.      
  80.      xy
  81.      
  82.      ;
  83.      
  84.      
  85.  
  86.      
  87.      float
  88.      
  89.       depth0 
  90.      
  91.      =
  92.      
  93.       
  94.      
  95.      LoadCameraDepth
  96.      
  97.      (
  98.      
  99.      positionCS0
  100.      
  101.      )
  102.      
  103.      ;
  104.      
  105.      
  106.  
  107.      
  108.      PositionInputs
  109.      
  110.       posInput0 
  111.      
  112.      =
  113.      
  114.       
  115.      
  116.      GetPositionInput
  117.      
  118.      (
  119.      
  120.      positionCS0
  121.      
  122.      ,
  123.      
  124.       _ScreenSize
  125.      
  126.      .
  127.      
  128.      zw
  129.      
  130.      ,
  131.      
  132.       depth
  133.      
  134.      ,
  135.      
  136.       UNITY_MATRIX_I_VP
  137.      
  138.      ,
  139.      
  140.       UNITY_MATRIX_V
  141.      
  142.      )
  143.      
  144.      ;
  145.      
  146.      
  147.  
  148.      
  149.      float2
  150.      
  151.       positionCS1 
  152.      
  153.      =
  154.      
  155.       varyings
  156.      
  157.      .
  158.      
  159.      positionCS
  160.      
  161.      .
  162.      
  163.      xy 
  164.      
  165.      +
  166.      
  167.       
  168.      
  169.      float2
  170.      
  171.      (
  172.      
  173.      outlineWidth
  174.      
  175.      ,
  176.      
  177.      0
  178.      
  179.      )
  180.      
  181.      ;
  182.      
  183.      
  184.  
  185.      
  186.      float
  187.      
  188.       depth1 
  189.      
  190.      =
  191.      
  192.       
  193.      
  194.      LoadCameraDepth
  195.      
  196.      (
  197.      
  198.      positionCS1
  199.      
  200.      )
  201.      
  202.      ;
  203.      
  204.      
  205.  
  206.      
  207.      PositionInputs
  208.      
  209.       posInput1 
  210.      
  211.      =
  212.      
  213.       
  214.      
  215.      GetPositionInput
  216.      
  217.      (
  218.      
  219.      positionCS1
  220.      
  221.      ,
  222.      
  223.       _ScreenSize
  224.      
  225.      .
  226.      
  227.      zw
  228.      
  229.      ,
  230.      
  231.       depth1
  232.      
  233.      ,
  234.      
  235.       UNITY_MATRIX_I_VP
  236.      
  237.      ,
  238.      
  239.       UNITY_MATRIX_V
  240.      
  241.      )
  242.      
  243.      ;
  244.      
  245.      
  246.  
  247.      
  248.      float2
  249.      
  250.       positionCS2 
  251.      
  252.      =
  253.      
  254.       varyings
  255.      
  256.      .
  257.      
  258.      positionCS
  259.      
  260.      .
  261.      
  262.      xy 
  263.      
  264.      +
  265.      
  266.       
  267.      
  268.      float2
  269.      
  270.      (
  271.      
  272.      0
  273.      
  274.      ,
  275.      
  276.      outlineWidth
  277.      
  278.      )
  279.      
  280.      ;
  281.      
  282.      
  283.  
  284.      
  285.      float
  286.      
  287.       depth2 
  288.      
  289.      =
  290.      
  291.       
  292.      
  293.      LoadCameraDepth
  294.      
  295.      (
  296.      
  297.      positionCS2
  298.      
  299.      )
  300.      
  301.      ;
  302.      
  303.      
  304.  
  305.      
  306.      PositionInputs
  307.      
  308.       posInput2 
  309.      
  310.      =
  311.      
  312.       
  313.      
  314.      GetPositionInput
  315.      
  316.      (
  317.      
  318.      positionCS2
  319.      
  320.      ,
  321.      
  322.       _ScreenSize
  323.      
  324.      .
  325.      
  326.      zw
  327.      
  328.      ,
  329.      
  330.       depth2
  331.      
  332.      ,
  333.      
  334.       UNITY_MATRIX_I_VP
  335.      
  336.      ,
  337.      
  338.       UNITY_MATRIX_V
  339.      
  340.      )
  341.      
  342.      ;
  343.      
  344.      
  345. distanceXDepth 
  346.      
  347.      =
  348.      
  349.       
  350.      
  351.      distance
  352.      
  353.      (
  354.      
  355.      posInput0
  356.      
  357.      .
  358.      
  359.      linearDepth
  360.      
  361.      ,
  362.      
  363.       posInput1
  364.      
  365.      .
  366.      
  367.      linearDepth
  368.      
  369.      )
  370.      
  371.      ;
  372.      
  373.      
  374. distanceYDepth 
  375.      
  376.      =
  377.      
  378.       
  379.      
  380.      distance
  381.      
  382.      (
  383.      
  384.      posInput0
  385.      
  386.      .
  387.      
  388.      linearDepth
  389.      
  390.      ,
  391.      
  392.       posInput2
  393.      
  394.      .
  395.      
  396.      linearDepth
  397.      
  398.      )
  399.      
  400.      ;
  401.      
  402.      
  403. distanceSumDepth 
  404.      
  405.      =
  406.      
  407.       distanceXDepth 
  408.      
  409.      +
  410.      
  411.       distanceYDepth
  412.      
  413.      ;
  414.     
  415.         
  416.     
  417.      
  418.      distanceSum 
  419.      
  420.      =
  421.      
  422.       distanceSumDepth
  423.      
  424.      ;
  425.      
  426.      
  427. distanceSum 
  428.      
  429.      =
  430.      
  431.       distanceSum 
  432.      
  433.      /
  434.      
  435.       _DivideFactor
  436.      
  437.      ;
  438.      
  439.      
  440. distanceSum 
  441.      
  442.      =
  443.      
  444.       
  445.      
  446.      Contrast
  447.      
  448.      (
  449.      
  450.      _ContrastInput
  451.      
  452.      ,
  453.      
  454.       distanceSum
  455.      
  456.      )
  457.      
  458.      ;
  459.      
  460.      
  461. distanceSum 
  462.      
  463.      =
  464.      
  465.       
  466.      
  467.      saturate
  468.      
  469.      (
  470.      
  471.      distanceSum
  472.      
  473.      )
  474.      
  475.      ;
  476.      
  477.      
  478.  
  479.      
  480.      //color = float4(0,0,0,1);
  481.      
  482.      
  483. finalColor 
  484.      
  485.      =
  486.      
  487.       
  488.      
  489.      lerp
  490.      
  491.      (
  492.      
  493.      color
  494.      
  495.      ,
  496.      
  497.       _OutlineColor
  498.      
  499.      ,
  500.      
  501.       distanceSum
  502.      
  503.      )
  504.      
  505.      ;
  506.      
  507.      
  508.  
  509.      
  510.      //finalColor = color + distanceSum * _OutlineColor;
  511.
接下来具体看看计算的方法。 
  1.     
  2.     
  3.      
  4.      float2
  5.      
  6.       positionCS0 
  7.      
  8.      =
  9.      
  10.       varyings
  11.      
  12.      .
  13.      
  14.      positionCS
  15.      
  16.      .
  17.      
  18.      xy
  19.      
  20.      ;
  21.      
  22.      
  23.  
  24.      
  25.      float
  26.      
  27.       depth0 
  28.      
  29.      =
  30.      
  31.       
  32.      
  33.      LoadCameraDepth
  34.      
  35.      (
  36.      
  37.      positionCS0
  38.      
  39.      )
  40.      
  41.      ;
  42.      
  43.      
  44.  
  45.      
  46.      PositionInputs
  47.      
  48.       posInput0 
  49.      
  50.      =
  51.      
  52.       
  53.      
  54.      GetPositionInput
  55.      
  56.      (
  57.      
  58.      positionCS0
  59.      
  60.      ,
  61.      
  62.       _ScreenSize
  63.      
  64.      .
  65.      
  66.      zw
  67.      
  68.      ,
  69.      
  70.       depth
  71.      
  72.      ,
  73.      
  74.       UNITY_MATRIX_I_VP
  75.      
  76.      ,
  77.      
  78.       UNITY_MATRIX_V
  79.      
  80.      )
  81.      
  82.      ;
  83.      
  84.      
  85.  
  86.      
  87.      float2
  88.      
  89.       positionCS1 
  90.      
  91.      =
  92.      
  93.       varyings
  94.      
  95.      .
  96.      
  97.      positionCS
  98.      
  99.      .
  100.      
  101.      xy 
  102.      
  103.      +
  104.      
  105.       
  106.      
  107.      float2
  108.      
  109.      (
  110.      
  111.      outlineWidth
  112.      
  113.      ,
  114.      
  115.      0
  116.      
  117.      )
  118.      
  119.      ;
  120.      
  121.      
  122.  
  123.      
  124.      float
  125.      
  126.       depth1 
  127.      
  128.      =
  129.      
  130.       
  131.      
  132.      LoadCameraDepth
  133.      
  134.      (
  135.      
  136.      positionCS1
  137.      
  138.      )
  139.      
  140.      ;
  141.      
  142.      
  143.  
  144.      
  145.      PositionInputs
  146.      
  147.       posInput1 
  148.      
  149.      =
  150.      
  151.       
  152.      
  153.      GetPositionInput
  154.      
  155.      (
  156.      
  157.      positionCS1
  158.      
  159.      ,
  160.      
  161.       _ScreenSize
  162.      
  163.      .
  164.      
  165.      zw
  166.      
  167.      ,
  168.      
  169.       depth1
  170.      
  171.      ,
  172.      
  173.       UNITY_MATRIX_I_VP
  174.      
  175.      ,
  176.      
  177.       UNITY_MATRIX_V
  178.      
  179.      )
  180.      
  181.      ;
  182.      
  183.      
  184.  
  185.      
  186.      float2
  187.      
  188.       positionCS2 
  189.      
  190.      =
  191.      
  192.       varyings
  193.      
  194.      .
  195.      
  196.      positionCS
  197.      
  198.      .
  199.      
  200.      xy 
  201.      
  202.      +
  203.      
  204.       
  205.      
  206.      float2
  207.      
  208.      (
  209.      
  210.      0
  211.      
  212.      ,
  213.      
  214.      outlineWidth
  215.      
  216.      )
  217.      
  218.      ;
  219.      
  220.      
  221.  
  222.      
  223.      float
  224.      
  225.       depth2 
  226.      
  227.      =
  228.      
  229.       
  230.      
  231.      LoadCameraDepth
  232.      
  233.      (
  234.      
  235.      positionCS2
  236.      
  237.      )
  238.      
  239.      ;
  240.      
  241.      
  242.  
  243.      
  244.      PositionInputs
  245.      
  246.       posInput2 
  247.      
  248.      =
  249.      
  250.       
  251.      
  252.      GetPositionInput
  253.      
  254.      (
  255.      
  256.      positionCS2
  257.      
  258.      ,
  259.      
  260.       _ScreenSize
  261.      
  262.      .
  263.      
  264.      zw
  265.      
  266.      ,
  267.      
  268.       depth2
  269.      
  270.      ,
  271.      
  272.       UNITY_MATRIX_I_VP
  273.      
  274.      ,
  275.      
  276.       UNITY_MATRIX_V
  277.      
  278.      )
  279.      
  280.      ;
  281.
前三行跟使用世界法线的方法一样，略过。同理，这里读取p(x,y)、p(x+oultineWidth,y)，p(x,y+outlineWidth)的设备深度，用于后续的对比。 
  1.     
  2.     
  3.      
  4.      distanceXDepth 
  5.      
  6.      =
  7.      
  8.       
  9.      
  10.      distance
  11.      
  12.      (
  13.      
  14.      posInput0
  15.      
  16.      .
  17.      
  18.      linearDepth
  19.      
  20.      ,
  21.      
  22.       posInput1
  23.      
  24.      .
  25.      
  26.      linearDepth
  27.      
  28.      )
  29.      
  30.      ;
  31.      
  32.      
  33. distanceYDepth 
  34.      
  35.      =
  36.      
  37.       
  38.      
  39.      distance
  40.      
  41.      (
  42.      
  43.      posInput0
  44.      
  45.      .
  46.      
  47.      linearDepth
  48.      
  49.      ,
  50.      
  51.       posInput2
  52.      
  53.      .
  54.      
  55.      linearDepth
  56.      
  57.      )
  58.      
  59.      ;
  60.
类似的通过distance方式获得变化率。 
  1.     
  2.     
  3.      
  4.      distanceSumNormal 
  5.      
  6.      =
  7.      
  8.       distanceXNormal 
  9.      
  10.      +
  11.      
  12.       distanceYNormal
  13.      
  14.      ;
  15.
类似的把x跟y的变化率相加。 
  1.     
  2.     
  3.      
  4.      distanceSum 
  5.      
  6.      =
  7.      
  8.       distanceSumDepth
  9.      
  10.      ;
  11.      
  12.      
  13. distanceSum 
  14.      
  15.      =
  16.      
  17.       distanceSum 
  18.      
  19.      /
  20.      
  21.       _DivideFactor
  22.      
  23.      ;
  24.      
  25.      
  26. distanceSum 
  27.      
  28.      =
  29.      
  30.       
  31.      
  32.      Contrast
  33.      
  34.      (
  35.      
  36.      _ContrastInput
  37.      
  38.      ,
  39.      
  40.       distanceSum
  41.      
  42.      )
  43.      
  44.      ;
  45.      
  46.      
  47. distanceSum 
  48.      
  49.      =
  50.      
  51.       
  52.      
  53.      saturate
  54.      
  55.      (
  56.      
  57.      distanceSum
  58.      
  59.      )
  60.      
  61.      ;
  62.      
  63.      
  64.  
  65.      
  66.      //color = float4(0,0,0,1);
  67.      
  68.      
  69. finalColor 
  70.      
  71.      =
  72.      
  73.       
  74.      
  75.      lerp
  76.      
  77.      (
  78.      
  79.      color
  80.      
  81.      ,
  82.      
  83.       _OutlineColor
  84.      
  85.      ,
  86.      
  87.       distanceSum
  88.      
  89.      )
  90.      
  91.      ;
  92.
最后通过类似的方式把颜色附加到场景颜色中去。我们为了观察方便，先把_DivideFactor和_ContrastInput都设置回1，通过去掉color的那行注释可以看到初始勾边效果。 仔细查看，你可以发现工作台上的木棍，棱角上的边没了，因为这是通过深度来求变化率，对于棱角法线变化率大的地方，深度变化并不大。其次，地面有发光的效果，在ddx、ddy中使用的深度的方法中已经解释过了。这里，可以通过调节_ContrastInput来增大对比度达到去除这个发光效果。 可以根据场景需要自由调节_ContrastInput和_DivideFactor的值来控制勾边效果。把color那行注释，可以在原场景颜色上勾边了。 类似除了lerp的勾边方式，还可以使用加法的方式进行勾边，能提亮的效果。 
  1.     
  2.     
  3.      
  4.      finalColor 
  5.      
  6.      =
  7.      
  8.       color 
  9.      
  10.      +
  11.      
  12.       distanceSum 
  13.      
  14.      *
  15.      
  16.       _OutlineColor
  17.      
  18.      ;
  19.

使用混合世界法线、设备深度

我们先来看整段代码，这个方法兼顾了世界法线和设备深度，可以在法线变化大和深度变化大的地方同时勾上边。 
  1.     
  2.     
  3.      
  4.      // offset outline by world normal
  5.      
  6.      
  7. linearDepth 
  8.      
  9.      =
  10.      
  11.       posInput
  12.      
  13.      .
  14.      
  15.      linearDepth
  16.      
  17.      ;
  18.      
  19.      
  20. outlineWidth 
  21.      
  22.      =
  23.      
  24.       _OutlineWidth
  25.      
  26.      ;
  27.      
  28.      
  29. outlineWidth 
  30.      
  31.      =
  32.      
  33.       
  34.      
  35.      saturate
  36.      
  37.      (
  38.      
  39.      1
  40.      
  41.       
  42.      
  43.      -
  44.      
  45.       linearDepth 
  46.      
  47.      /
  48.      
  49.       
  50.      
  51.      1000
  52.      
  53.      )
  54.      
  55.       
  56.      
  57.      *
  58.      
  59.       outlineWidth
  60.      
  61.      ;
  62.      
  63.       
  64.  
  65.      
  66.      NormalData
  67.      
  68.       normalData0
  69.      
  70.      ;
  71.      
  72.      
  73.  
  74.      
  75.      NormalData
  76.      
  77.       normalData1
  78.      
  79.      ;
  80.      
  81.      
  82.  
  83.      
  84.      NormalData
  85.      
  86.       normalData2
  87.      
  88.      ;
  89.      
  90.      
  91.  
  92.      
  93.      DecodeFromNormalBuffer
  94.      
  95.      (
  96.      
  97.      posInput
  98.      
  99.      .
  100.      
  101.      positionSS
  102.      
  103.      ,
  104.      
  105.       normalData0
  106.      
  107.      )
  108.      
  109.      ;
  110.      
  111.      
  112.  
  113.      
  114.      DecodeFromNormalBuffer
  115.      
  116.      (
  117.      
  118.      posInput
  119.      
  120.      .
  121.      
  122.      positionSS 
  123.      
  124.      +
  125.      
  126.       
  127.      
  128.      float2
  129.      
  130.      (
  131.      
  132.      outlineWidth
  133.      
  134.      ,
  135.      
  136.      0
  137.      
  138.      )
  139.      
  140.      ,
  141.      
  142.       normalData1
  143.      
  144.      )
  145.      
  146.      ;
  147.      
  148.      
  149.  
  150.      
  151.      DecodeFromNormalBuffer
  152.      
  153.      (
  154.      
  155.      posInput
  156.      
  157.      .
  158.      
  159.      positionSS 
  160.      
  161.      +
  162.      
  163.       
  164.      
  165.      float2
  166.      
  167.      (
  168.      
  169.      0
  170.      
  171.      ,
  172.      
  173.      outlineWidth
  174.      
  175.      )
  176.      
  177.      ,
  178.      
  179.       normalData2
  180.      
  181.      )
  182.      
  183.      ;
  184.      
  185.      
  186. distanceXNormal 
  187.      
  188.      =
  189.      
  190.       
  191.      
  192.      distance
  193.      
  194.      (
  195.      
  196.      normalData0
  197.      
  198.      .
  199.      
  200.      normalWS
  201.      
  202.      ,
  203.      
  204.       normalData1
  205.      
  206.      .
  207.      
  208.      normalWS
  209.      
  210.      )
  211.      
  212.      ;
  213.      
  214.      
  215. distanceYNormal 
  216.      
  217.      =
  218.      
  219.       
  220.      
  221.      distance
  222.      
  223.      (
  224.      
  225.      normalData0
  226.      
  227.      .
  228.      
  229.      normalWS
  230.      
  231.      ,
  232.      
  233.       normalData2
  234.      
  235.      .
  236.      
  237.      normalWS
  238.      
  239.      )
  240.      
  241.      ;
  242.      
  243.      
  244. distanceSumNormal 
  245.      
  246.      =
  247.      
  248.       distanceXNormal 
  249.      
  250.      +
  251.      
  252.       distanceYNormal
  253.      
  254.      ;
  255.      
  256.      
  257.  
  258.      
  259.      // offset outline by device depth
  260.      
  261.      
  262. linearDepth 
  263.      
  264.      =
  265.      
  266.       posInput
  267.      
  268.      .
  269.      
  270.      linearDepth
  271.      
  272.      ;
  273.      
  274.      
  275. outlineWidth 
  276.      
  277.      =
  278.      
  279.       _OutlineWidth
  280.      
  281.      ;
  282.      
  283.      
  284. outlineWidth 
  285.      
  286.      =
  287.      
  288.       
  289.      
  290.      saturate
  291.      
  292.      (
  293.      
  294.      1
  295.      
  296.       
  297.      
  298.      -
  299.      
  300.       linearDepth 
  301.      
  302.      /
  303.      
  304.       
  305.      
  306.      10000
  307.      
  308.      )
  309.      
  310.       
  311.      
  312.      *
  313.      
  314.       outlineWidth
  315.      
  316.      ;
  317.      
  318.      
  319.  
  320.      
  321.      float2
  322.      
  323.       positionCS0 
  324.      
  325.      =
  326.      
  327.       varyings
  328.      
  329.      .
  330.      
  331.      positionCS
  332.      
  333.      .
  334.      
  335.      xy
  336.      
  337.      ;
  338.      
  339.      
  340.  
  341.      
  342.      float
  343.      
  344.       depth0 
  345.      
  346.      =
  347.      
  348.       
  349.      
  350.      LoadCameraDepth
  351.      
  352.      (
  353.      
  354.      positionCS0
  355.      
  356.      )
  357.      
  358.      ;
  359.      
  360.      
  361.  
  362.      
  363.      PositionInputs
  364.      
  365.       posInput0 
  366.      
  367.      =
  368.      
  369.       
  370.      
  371.      GetPositionInput
  372.      
  373.      (
  374.      
  375.      positionCS0
  376.      
  377.      ,
  378.      
  379.       _ScreenSize
  380.      
  381.      .
  382.      
  383.      zw
  384.      
  385.      ,
  386.      
  387.       depth
  388.      
  389.      ,
  390.      
  391.       UNITY_MATRIX_I_VP
  392.      
  393.      ,
  394.      
  395.       UNITY_MATRIX_V
  396.      
  397.      )
  398.      
  399.      ;
  400.      
  401.      
  402.  
  403.      
  404.      float2
  405.      
  406.       positionCS1 
  407.      
  408.      =
  409.      
  410.       varyings
  411.      
  412.      .
  413.      
  414.      positionCS
  415.      
  416.      .
  417.      
  418.      xy 
  419.      
  420.      +
  421.      
  422.       
  423.      
  424.      float2
  425.      
  426.      (
  427.      
  428.      outlineWidth
  429.      
  430.      ,
  431.      
  432.      0
  433.      
  434.      )
  435.      
  436.      ;
  437.      
  438.      
  439.  
  440.      
  441.      float
  442.      
  443.       depth1 
  444.      
  445.      =
  446.      
  447.       
  448.      
  449.      LoadCameraDepth
  450.      
  451.      (
  452.      
  453.      positionCS1
  454.      
  455.      )
  456.      
  457.      ;
  458.      
  459.      
  460.  
  461.      
  462.      PositionInputs
  463.      
  464.       posInput1 
  465.      
  466.      =
  467.      
  468.       
  469.      
  470.      GetPositionInput
  471.      
  472.      (
  473.      
  474.      positionCS1
  475.      
  476.      ,
  477.      
  478.       _ScreenSize
  479.      
  480.      .
  481.      
  482.      zw
  483.      
  484.      ,
  485.      
  486.       depth1
  487.      
  488.      ,
  489.      
  490.       UNITY_MATRIX_I_VP
  491.      
  492.      ,
  493.      
  494.       UNITY_MATRIX_V
  495.      
  496.      )
  497.      
  498.      ;
  499.      
  500.      
  501.  
  502.      
  503.      float2
  504.      
  505.       positionCS2 
  506.      
  507.      =
  508.      
  509.       varyings
  510.      
  511.      .
  512.      
  513.      positionCS
  514.      
  515.      .
  516.      
  517.      xy 
  518.      
  519.      +
  520.      
  521.       
  522.      
  523.      float2
  524.      
  525.      (
  526.      
  527.      0
  528.      
  529.      ,
  530.      
  531.      outlineWidth
  532.      
  533.      )
  534.      
  535.      ;
  536.      
  537.      
  538.  
  539.      
  540.      float
  541.      
  542.       depth2 
  543.      
  544.      =
  545.      
  546.       
  547.      
  548.      LoadCameraDepth
  549.      
  550.      (
  551.      
  552.      positionCS2
  553.      
  554.      )
  555.      
  556.      ;
  557.      
  558.      
  559.  
  560.      
  561.      PositionInputs
  562.      
  563.       posInput2 
  564.      
  565.      =
  566.      
  567.       
  568.      
  569.      GetPositionInput
  570.      
  571.      (
  572.      
  573.      positionCS2
  574.      
  575.      ,
  576.      
  577.       _ScreenSize
  578.      
  579.      .
  580.      
  581.      zw
  582.      
  583.      ,
  584.      
  585.       depth2
  586.      
  587.      ,
  588.      
  589.       UNITY_MATRIX_I_VP
  590.      
  591.      ,
  592.      
  593.       UNITY_MATRIX_V
  594.      
  595.      )
  596.      
  597.      ;
  598.      
  599.      
  600. distanceXDepth 
  601.      
  602.      =
  603.      
  604.       
  605.      
  606.      distance
  607.      
  608.      (
  609.      
  610.      posInput0
  611.      
  612.      .
  613.      
  614.      linearDepth
  615.      
  616.      ,
  617.      
  618.       posInput1
  619.      
  620.      .
  621.      
  622.      linearDepth
  623.      
  624.      )
  625.      
  626.      ;
  627.      
  628.      
  629. distanceYDepth 
  630.      
  631.      =
  632.      
  633.       
  634.      
  635.      distance
  636.      
  637.      (
  638.      
  639.      posInput0
  640.      
  641.      .
  642.      
  643.      linearDepth
  644.      
  645.      ,
  646.      
  647.       posInput2
  648.      
  649.      .
  650.      
  651.      linearDepth
  652.      
  653.      )
  654.      
  655.      ;
  656.      
  657.      
  658. distanceSumDepth 
  659.      
  660.      =
  661.      
  662.       distanceXDepth 
  663.      
  664.      +
  665.      
  666.       distanceYDepth
  667.      
  668.      ;
  669.     
  670.         
  671.     
  672.      
  673.      distanceSum 
  674.      
  675.      =
  676.      
  677.       _NormalFactor 
  678.      
  679.      *
  680.      
  681.       distanceSumNormal 
  682.      
  683.      +
  684.      
  685.       
  686.      
  687.      (
  688.      
  689.      1
  690.      
  691.      -
  692.      
  693.      _NormalFactor
  694.      
  695.      )
  696.      
  697.       
  698.      
  699.      *
  700.      
  701.       distanceSumDepth
  702.      
  703.      ;
  704.      
  705.      
  706.  
  707.      
  708.      //distanceSum = max(distanceSumDepth, distanceSumNormal);
  709.      
  710.      
  711. distanceSum 
  712.      
  713.      =
  714.      
  715.       distanceSum 
  716.      
  717.      /
  718.      
  719.       _DivideFactor
  720.      
  721.      ;
  722.      
  723.      
  724. distanceSum 
  725.      
  726.      =
  727.      
  728.       
  729.      
  730.      Contrast
  731.      
  732.      (
  733.      
  734.      _ContrastInput
  735.      
  736.      ,
  737.      
  738.       distanceSum
  739.      
  740.      )
  741.      
  742.      ;
  743.      
  744.      
  745. distanceSum 
  746.      
  747.      =
  748.      
  749.       
  750.      
  751.      saturate
  752.      
  753.      (
  754.      
  755.      distanceSum
  756.      
  757.      )
  758.      
  759.      ;
  760.      
  761.      
  762.  
  763.      
  764.      //color = float4(0,0,0,1);
  765.      
  766.      
  767. finalColor 
  768.      
  769.      =
  770.      
  771.       
  772.      
  773.      lerp
  774.      
  775.      (
  776.      
  777.      color
  778.      
  779.      ,
  780.      
  781.       _OutlineColor
  782.      
  783.      ,
  784.      
  785.       distanceSum
  786.      
  787.      )
  788.      
  789.      ;
  790.      
  791.      
  792.  
  793.      
  794.      //finalColor = color + distanceSum * _OutlineColor;
  795.
这里对distanceSum有两种方式，一种是通过Shader属性_NormalFactor和(1-_NormalFactor)来控制以哪种勾边为主。 
  1.  
  2.      
  3.      
  4.       
  5.       distanceSum 
  6.       
  7.       =
  8.       
  9.        _NormalFactor 
  10.       
  11.       *
  12.       
  13.        distanceSumNormal 
  14.       
  15.       +
  16.       
  17.        
  18.       
  19.       (
  20.       
  21.       1
  22.       
  23.       -
  24.       
  25.       _NormalFactor
  26.       
  27.       )
  28.       
  29.        
  30.       
  31.       *
  32.       
  33.        distanceSumDepth
  34.       
  35.       ;
  36.
一种是通过取max的方式，来确保两种模式的都勾到边，大家可以自行测试。 
  1.     
  2.     
  3.      
  4.      //distanceSum = max(distanceSumDepth, distanceSumNormal);
  5.

下期预告

下一期分享，将会分享alelievr的HDRP-Custom-Passes库中的TIPS特效，并且介绍其中的原理等。最后，对于本文，求关注、点赞。对于B站视频，求关注、一键三连(点赞、投币、收藏)。
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/101657?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号