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

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

作者：知新_RL | 2024-02-17 22:00:53

赞

踩

hdrp custompostprocess

目录

B站视频

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

官方社区

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

原因

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

感谢

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

什么是HDRP Custom Pass呢？

HDRP Custom Pass允许你注入Shader或者C#在渲染管线循环的特定的点，赋予你绘制对象、做全屏pass、读取一些摄像机缓冲(如深度、颜色、法线)的能力。

延迟渲染

月神的后处理视频中，虚幻使用的是延迟渲染管线。因此，作为对比，这里也选择的是同样使用延迟渲染的HDRP高清渲染管线。因为延迟渲染的各种缓冲数据，给了我们更多的可能性，从而可以实现后处理的各种特效。

创建HDRP Custom Pass着色器

右键->Create->Shader->HDRP->Custom Full Screen Pass，由于这里我们针对后处理，所以创建是全屏Custom Pass。

获取缓冲数据

那么，我们要如何获取各种缓冲数据呢？

获取PositionInputs数据

获取的方式在我们创建的Shader里就有这个例子。获取方式如下： 
  1.     
  2.     
  3.      
  4.      float
  5.      
  6.       depth 
  7.      
  8.      =
  9.      
  10.       
  11.      
  12.      LoadCameraDepth
  13.      
  14.      (
  15.      
  16.      varyings
  17.      
  18.      .
  19.      
  20.      positionCS
  21.      
  22.      .
  23.      
  24.      xy
  25.      
  26.      )
  27.      
  28.      ;
  29.      
  30.      
  31.  
  32.      
  33.      PositionInputs
  34.      
  35.       posInput 
  36.      
  37.      =
  38.      
  39.       
  40.      
  41.      GetPositionInput
  42.      
  43.      (
  44.      
  45.      varyings
  46.      
  47.      .
  48.      
  49.      positionCS
  50.      
  51.      .
  52.      
  53.      xy
  54.      
  55.      ,
  56.      
  57.       _ScreenSize
  58.      
  59.      .
  60.      
  61.      zw
  62.      
  63.      ,
  64.      
  65.       depth
  66.      
  67.      ,
  68.      
  69.       UNITY_MATRIX_I_VP
  70.      
  71.      ,
  72.      
  73.       UNITY_MATRIX_V
  74.      
  75.      )
  76.      
  77.      ;
  78.
另外，可以从Common.hlsl中的顺着这4个函数，可以看出posInput中的positionSS就是传递进去的varyings.positionCS.xy转换成uint2。最后一个当中做了如下转换： 
  1.     
  2.     
  3.      
  4.      posInput
  5.      
  6.      .
  7.      
  8.      positionSS 
  9.      
  10.      =
  11.      
  12.       
  13.      
  14.      uint2
  15.      
  16.      (
  17.      
  18.      positionSS
  19.      
  20.      )
  21.      
  22.      ;
  23.
  • PositionInputs GetPositionInput(float2 positionSS, float2 invScreenSize, float deviceDepth, float4x4 invViewProjMatrix, float4x4 viewMatrix, uint2 tileCoord)
  • PositionInputs GetPositionInput(float2 positionSS, float2 invScreenSize, float deviceDepth, float4x4 invViewProjMatrix, float4x4 viewMatrix, uint2 tileCoord)
  • PositionInputs GetPositionInput(float2 positionSS, float2 invScreenSize, float deviceDepth, float linearDepth, float3 positionWS, uint2 tileCoord)
  • PositionInputs GetPositionInput(float2 positionSS, float2 invScreenSize, uint2 tileCoord)
PositionInput结构体中的数据如下
  • positionWS，世界空间位置(可能是摄像机相对位置)
  • positionNDC，视口中的单位化屏幕坐标，值域[0,1)(带半像素偏移)，和我们平常理解的NDC不太一样，平常理解的NDC是-1到1的，这里的是被映射过的。
  • positionSS，屏幕空间像素坐标，值域[0, NumPixels)
  • tileCoord，屏幕tile坐标，值域[0, NumTiles)
  • deviceDepth，深度缓冲中的深度，设备深度，值域[0,1)，一般取反，越近越靠近1，越远越靠近0
  • linearDepth，线性深度，视图空间Z坐标，值域[Near, Far]，远近裁剪面之间。 
  1.     
  2.     
  3.      
  4.      // The PositionInputs struct allow you to retrieve a lot of useful information for your fullScreenShader:
  5.      
  6.      
  7.  
  8.      
  9.      // struct PositionInputs
  10.      
  11.      
  12.  
  13.      
  14.      // {
  15.      
  16.      
  17.  
  18.      
  19.      //     float3 positionWS;  // World space position (could be camera-relative)
  20.      
  21.      
  22.  
  23.      
  24.      //     float2 positionNDC; // Normalized screen coordinates within the viewport    : [0, 1) (with the half-pixel offset)
  25.      
  26.      
  27.  
  28.      
  29.      //     uint2  positionSS;  // Screen space pixel coordinates                       : [0, NumPixels)
  30.      
  31.      
  32.  
  33.      
  34.      //     uint2  tileCoord;   // Screen tile coordinates                              : [0, NumTiles)
  35.      
  36.      
  37.  
  38.      
  39.      //     float  deviceDepth; // Depth from the depth buffer                          : [0, 1] (typically reversed)
  40.      
  41.      
  42.  
  43.      
  44.      //     float  linearDepth; // View space Z coordinate                              : [Near, Far]
  45.      
  46.      
  47.  
  48.      
  49.      // };
  50.

获取颜色数据

  • 方法1，使用CustomPassLoadCameraColor加载获取。 
  1.     
  2.     
  3.      
  4.      float4
  5.      
  6.       color 
  7.      
  8.      =
  9.      
  10.       
  11.      
  12.      float4
  13.      
  14.      (
  15.      
  16.      0.0
  17.      
  18.      ,
  19.      
  20.       
  21.      
  22.      0.0
  23.      
  24.      ,
  25.      
  26.       
  27.      
  28.      0.0
  29.      
  30.      ,
  31.      
  32.       
  33.      
  34.      0.0
  35.      
  36.      )
  37.      
  38.      ;
  39.      
  40.      
  41.  
  42.  
  43.      
  44.      // Load the camera color buffer at the mip 0 if we're not at the before rendering injection point
  45.      
  46.      
  48.      
  49.      if
  50.      
  51.       
  52.      
  53.      (
  54.      
  55.      _CustomPassInjectionPoint 
  56.      
  57.      !=
  58.      
  59.       CUSTOMPASSINJECTIONPOINT_BEFORE_RENDERING
  60.      
  61.      )
  62.      
  63.      
  64.     color 
  65.      
  66.      =
  67.      
  68.       
  69.      
  70.      float4
  71.      
  72.      (
  73.      
  74.      CustomPassLoadCameraColor
  75.      
  76.      (
  77.      
  78.      varyings
  79.      
  80.      .
  81.      
  82.      positionCS
  83.      
  84.      .
  85.      
  86.      xy
  87.      
  88.      ,
  89.      
  90.       
  91.      
  92.      0
  93.      
  94.      )
  95.      
  96.      ,
  97.      
  98.       
  99.      
  100.      1
  101.      
  102.      )
  103.      
  104.      ;
  105.      
  106.      
  109.      
  110.      // get color method 1
  111.      
  112.      
  113. finalColor 
  114.      
  115.      =
  116.      
  117.       color
  118.      
  119.      ;
  120.     
  121.
  • 方法2，使用CustomPassSampleCameraColor采样获取。 
  1.     
  2.     
  3.      
  4.       
  5.      
  6.      // get color method 2
  7.      
  8.      
  9.  
  10.      
  11.      // Load the camera color buffer at the mip 0 if we're not at the before rendering injection point
  12.      
  13.      
  14.  
  15.      
  16.      if
  17.      
  18.       
  19.      
  20.      (
  21.      
  22.      _CustomPassInjectionPoint 
  23.      
  24.      !=
  25.      
  26.       CUSTOMPASSINJECTIONPOINT_BEFORE_RENDERING
  27.      
  28.      )
  29.      
  30.      
  31.      color 
  32.      
  33.      =
  34.      
  35.       
  36.      
  37.      float4
  38.      
  39.      (
  40.      
  41.      CustomPassSampleCameraColor
  42.      
  43.      (
  44.      
  45.      varyings
  46.      
  47.      .
  48.      
  49.      positionCS
  50.      
  51.      .
  52.      
  53.      xy 
  54.      
  55.      *
  56.      
  57.       _ScreenSize
  58.      
  59.      .
  60.      
  61.      zw
  62.      
  63.      ,
  64.      
  65.       
  66.      
  67.      0
  68.      
  69.      )
  70.      
  71.      ,
  72.      
  73.       
  74.      
  75.      1
  76.      
  77.      )
  78.      
  79.      ;
  80.      
  81.      
  82.  finalColor 
  83.      
  84.      =
  85.      
  86.       color
  87.      
  88.      ;
  89.      
  90.      //finalColor = color;
  91.     
  92.

获取设备深度数据

  • 方法1，使用LoadCameraDepth加载获取。其实这里的depth就是设备深度，之前PositionInput结构体获取的代码中的变量。需要注意的是，这是对Z取反的，就是越近的深度越趋向于1，越远的深度越趋向于0。 
  1.     
  2.     
  3.      
  4.      // get device depth method 1
  5.      
  6.      
  7. deviceDepth 
  8.      
  9.      =
  10.      
  11.       depth
  12.      
  13.      ;
  14.
  • 方法2，通过PositionInputs获取。其实这里没有必要，因为depth其实就已经是设备深度数据了。但是如果是别的函数中使用，可以直接把PositionInput结构体传递出去带的数据更多，故此列出。 
  1.     
  2.     
  3.      
  4.      // get device depth method 2
  5.      
  6.      
  7. deviceDepth 
  8.      
  9.      =
  10.      
  11.       posInput
  12.      
  13.      .
  14.      
  15.      deviceDepth
  16.      
  17.      ;
  18.
  • 方法3，通过SampleCameraDepth采样获取。 
  1.     
  2.     
  3.      
  4.      // get device depth method 3
  5.      
  6.      
  7. deviceDepth 
  8.      
  9.      =
  10.      
  11.       
  12.      
  13.      SampleCameraDepth
  14.      
  15.      (
  16.      
  17.      varyings
  18.      
  19.      .
  20.      
  21.      positionCS
  22.      
  23.      .
  24.      
  25.      xy 
  26.      
  27.      *
  28.      
  29.       _ScreenSize
  30.      
  31.      .
  32.      
  33.      zw
  34.      
  35.      )
  36.      
  37.      ;
  38.
  • 方法4( 错误 )，写了一个真正的采样方法， 结果错误(如上图)，而且没必要 。 
  1.     
  2.     
  3.      
  4.      // Incorrect result
  5.      
  6.      
  7.  
  8.      
  9.      float
  10.      
  11.       
  12.      
  13.      SampleCameraDepthSK
  14.      
  15.      (
  16.      
  17.      float2
  18.      
  19.       uv
  20.      
  21.      )
  22.      
  23.      
  24.  
  25.      
  26.      {
  27.      
  28.      
  29.     
  30.      
  31.      return
  32.      
  33.       
  34.      
  35.      SAMPLE_TEXTURE2D_X_LOD
  36.      
  37.      (
  38.      
  39.      _CameraDepthTexture
  40.      
  41.      ,
  42.      
  43.       sampler_CameraDepthTexture
  44.      
  45.      ,
  46.      
  47.       uv 
  48.      
  49.      *
  50.      
  51.       _RTHandleScaleHistory
  52.      
  53.      .
  54.      
  55.      xy
  56.      
  57.      ,
  58.      
  59.       
  60.      
  61.      0
  62.      
  63.      )
  64.      
  65.      .
  66.      
  67.      r
  68.      
  69.      ;
  70.      
  71.      
  72.  
  73.      
  74.      }
  75.     
  76.         
  77.     
  78.      
  79.      // get device depth method 4 (Incorrect result)
  80.      
  81.      
  82. deviceDepth 
  83.      
  84.      =
  85.      
  86.       
  87.      
  88.      SampleCameraDepthSK
  89.      
  90.      (
  91.      
  92.      varyings
  93.      
  94.      .
  95.      
  96.      positionCS
  97.      
  98.      .
  99.      
  100.      xy 
  101.      
  102.      *
  103.      
  104.       _ScreenSize
  105.      
  106.      .
  107.      
  108.      zw
  109.      
  110.      )
  111.      
  112.      ;
  113.
首先，为什么说真正的采样方法？我们可以跟踪一下方法3中的SampleCameraDepth方法的定义，在ShaderVariables.hlsl中，里面调用的其实是LoadCameraDepth，并没有真正的用Sampler进行采样。 
  1.     
  2.     
  3.      
  4.      float
  5.      
  6.       
  7.      
  8.      SampleCameraDepth
  9.      
  10.      (
  11.      
  12.      float2
  13.      
  14.       uv
  15.      
  16.      )
  17.      
  18.      
  19.  
  20.      
  21.      {
  22.      
  23.      
  24.     
  25.      
  26.      return
  27.      
  28.       
  29.      
  30.      LoadCameraDepth
  31.      
  32.      (
  33.      
  34.      uint2
  35.      
  36.      (
  37.      
  38.      uv 
  39.      
  40.      *
  41.      
  42.       _ScreenSize
  43.      
  44.      .
  45.      
  46.      xy
  47.      
  48.      )
  49.      
  50.      )
  51.      
  52.      ;
  53.      
  54.      
  55.  
  56.      
  57.      }
  58.
其次，为什么结果错误呢(看起来像Pyramid贴图)？我们可以继续跟踪一下，看注释，目前它是一个Atlas，它的Layout可以再HDUtils.cs中的ComputePackedMipChainInfo中找到。 
  1.     
  2.     
  3.      
  4.      // Note: To sample camera depth in HDRP we provide these utils functions because the way we store the depth mips can change
  5.      
  6.      
  7.  
  8.      
  9.      // Currently it's an atlas and it's layout can be found at ComputePackedMipChainInfo in HDUtils.cs
  10.      
  11.      
  12.  
  13.      
  14.      float
  15.      
  16.       
  17.      
  18.      LoadCameraDepth
  19.      
  20.      (
  21.      
  22.      uint2
  23.      
  24.       pixelCoords
  25.      
  26.      )
  27.      
  28.      
  29.  
  30.      
  31.      {
  32.      
  33.      
  34.     
  35.      
  36.      return
  37.      
  38.       
  39.      
  40.      LOAD_TEXTURE2D_X_LOD
  41.      
  42.      (
  43.      
  44.      _CameraDepthTexture
  45.      
  46.      ,
  47.      
  48.       pixelCoords
  49.      
  50.      ,
  51.      
  52.       
  53.      
  54.      0
  55.      
  56.      )
  57.      
  58.      .
  59.      
  60.      r
  61.      
  62.      ;
  63.      
  64.      
  65.  
  66.      
  67.      }
  68.
我们继续跟踪一下，看注释，我们打包所有MIP到顶层MIP层级中，也就是LOD0中，来避免Pow2 MIP链的限制。这就是为什么结果错误，因为他根本没有用Pyramid进行储存各个层级，而是直接全都存到LOD0里，自然采样出来就是图中的效果了。那么你可能又会问，那么为什么Load不需要特殊处理，可以适配Pyramid的ColorTexture，又能兼容打包的非Pyramid的DepthTexture呢？那是因为Load是通过绝对坐标来加载，无论是ColorTexture和DepthTexture，对于LOD0，他的坐标都是从左下角的(0,0)到右上角的(W,H)。 
  1.     
  2.     
  3.      
  4.      // We pack all MIP levels into the top MIP level to avoid the Pow2 MIP chain restriction.
  5.      
  6.      
  7.  
  8.      
  9.      // We compute the required size iteratively.
  10.      
  11.      
  12.  
  13.      
  14.      // This function is NOT fast, but it is illustrative, and can be optimized later.
  15.      
  16.      
  17.  
  18.      
  19.      public
  20.      
  21.       
  22.      
  23.      void
  24.      
  25.       
  26.      
  27.      ComputePackedMipChainInfo
  28.      
  29.      (
  30.      
  31.      Vector2Int
  32.      
  33.       viewportSize
  34.      
  35.      )
  36.
那么，为什么说没必要呢？那是因为，Depth的映射关系本来就是非线性的，不适合用线性过滤进行插值采样，即使你要采样也是应该采用点过滤。而点过滤的处理方式跟Load就没有什么差别了，因此，这里说没必要。

获得线性深度数据

这里全白了，曝了是因为线性深度，视图空间Z坐标，值域[Near, Far]，远近裁剪面之间，实际数字大于1。虚线是后处理等导致的。 
  1.     
  2.     
  3.      
  4.      float
  5.      
  6.       depth 
  7.      
  8.      =
  9.      
  10.       
  11.      
  12.      LoadCameraDepth
  13.      
  14.      (
  15.      
  16.      varyings
  17.      
  18.      .
  19.      
  20.      positionCS
  21.      
  22.      .
  23.      
  24.      xy
  25.      
  26.      )
  27.      
  28.      ;
  29.      
  30.      
  31.  
  32.      
  33.      PositionInputs
  34.      
  35.       posInput 
  36.      
  37.      =
  38.      
  39.       
  40.      
  41.      GetPositionInput
  42.      
  43.      (
  44.      
  45.      varyings
  46.      
  47.      .
  48.      
  49.      positionCS
  50.      
  51.      .
  52.      
  53.      xy
  54.      
  55.      ,
  56.      
  57.       _ScreenSize
  58.      
  59.      .
  60.      
  61.      zw
  62.      
  63.      ,
  64.      
  65.       depth
  66.      
  67.      ,
  68.      
  69.       UNITY_MATRIX_I_VP
  70.      
  71.      ,
  72.      
  73.       UNITY_MATRIX_V
  74.      
  75.      )
  76.      
  77.      ;
  78.      
  79.      
  80.  
  81.      
  82.      float
  83.      
  84.       linearDepth 
  85.      
  86.      =
  87.      
  88.       posInput
  89.      
  90.      .
  91.      
  92.      linearDepth
  93.      
  94.      ;
  95.      
  96.      `
  97.

获取绝对世界空间位置数据

注意如果你是想获取绝对世界空间位置，一定要调用GetAbsolutePositionWS，这样永远都会返回绝对世界空间位置。 
  1.     
  2.     
  3.      
  4.      float
  5.      
  6.       depth 
  7.      
  8.      =
  9.      
  10.       
  11.      
  12.      LoadCameraDepth
  13.      
  14.      (
  15.      
  16.      varyings
  17.      
  18.      .
  19.      
  20.      positionCS
  21.      
  22.      .
  23.      
  24.      xy
  25.      
  26.      )
  27.      
  28.      ;
  29.      
  30.      
  31.  
  32.      
  33.      PositionInputs
  34.      
  35.       posInput 
  36.      
  37.      =
  38.      
  39.       
  40.      
  41.      GetPositionInput
  42.      
  43.      (
  44.      
  45.      varyings
  46.      
  47.      .
  48.      
  49.      positionCS
  50.      
  51.      .
  52.      
  53.      xy
  54.      
  55.      ,
  56.      
  57.       _ScreenSize
  58.      
  59.      .
  60.      
  61.      zw
  62.      
  63.      ,
  64.      
  65.       depth
  66.      
  67.      ,
  68.      
  69.       UNITY_MATRIX_I_VP
  70.      
  71.      ,
  72.      
  73.       UNITY_MATRIX_V
  74.      
  75.      )
  76.      
  77.      ;
  78.      
  79.      
  80.  
  81.      
  82.      float3
  83.      
  84.       positionWS 
  85.      
  86.      =
  87.      
  88.       posInput
  89.      
  90.      .
  91.      
  92.      positionWS
  93.      
  94.      ;
  95.      
  96.      
  97. positionWS 
  98.      
  99.      =
  100.      
  101.       
  102.      
  103.      GetAbsolutePositionWS
  104.      
  105.      (
  106.      
  107.      positionWS
  108.      
  109.      )
  110.      
  111.      ;
  112.
参考SpaceTransforms.hlsl的GetAbsolutePositionWS可以知道，在相对摄像机渲染模式中，posInput.positionWS中并不是真正的世界空间位置。 
  1.     
  2.     
  3.      
  4.      // This function always return the absolute position in WS
  5.      
  6.      
  7.  
  8.      
  9.      float3
  10.      
  11.       
  12.      
  13.      GetAbsolutePositionWS
  14.      
  15.      (
  16.      
  17.      float3
  18.      
  19.       positionRWS
  20.      
  21.      )
  22.      
  23.      
  24.  
  25.      
  26.      {
  27.      
  28.      
  29.  
  30.      
  31.      #
  32.      
  33.      if
  34.      
  35.       (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
  36.      
  37.      
  38.     positionRWS 
  39.      
  40.      +=
  41.      
  42.       _WorldSpaceCameraPos
  43.      
  44.      ;
  45.      
  46.      
  47.  
  48.      
  49.      #
  50.      
  51.      endif
  52.      
  53.      
  54.     
  55.      
  56.      return
  57.      
  58.       positionRWS
  59.      
  60.      ;
  61.      
  62.      
  63.  
  64.      
  65.      }
  66.

获取世界法线数据

  • 方法1，这里使用的是屏幕空间坐标来获取，你只能获得绝对屏幕坐标的法线数据。 
  1.     
  2.     
  3.      
  4.      NormalData
  5.      
  6.       normalData
  7.      
  8.      ;
  9.      
  10.      
  11.  
  12.      
  13.      // get world normal method 1
  14.      
  15.      
  16.  
  17.      
  18.      DecodeFromNormalBuffer
  19.      
  20.      (
  21.      
  22.      posInput
  23.      
  24.      .
  25.      
  26.      positionSS
  27.      
  28.      ,
  29.      
  30.       normalData
  31.      
  32.      )
  33.      
  34.      ;
  35.      
  36.      
  37.  
  38.      
  39.      float3
  40.      
  41.       normal 
  42.      
  43.      =
  44.      
  45.       normalData
  46.      
  47.      .
  48.      
  49.      normalWS
  50.      
  51.      ;
  52.
要注意的是，需要include一个额外的hlsl。 
  1.     
  2.     
  3.      
  4.      #include 
  5.      
  6.      "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
  7.
  • 方法2，这里使用的是映射后的[0,1)的NDC坐标来采样，也是需要include那个额外的hlsl的。 
  1.     
  2.     
  3.      
  4.      SAMPLER
  5.      
  6.      (
  7.      
  8.      sampler_NormalBufferTexture
  9.      
  10.      )
  11.      
  12.      ;
  13.      
  14.      
  15.  
  16.      
  17.      void
  18.      
  19.       
  20.      
  21.      DecodeFromNormalBufferNDC
  22.      
  23.      (
  24.      
  25.      float2
  26.      
  27.       positionNDC
  28.      
  29.      ,
  30.      
  31.       
  32.      
  33.      out
  34.      
  35.       
  36.      
  37.      NormalData
  38.      
  39.       normalData
  40.      
  41.      )
  42.      
  43.      
  44.  
  45.      
  46.      {
  47.      
  48.      
  49.     
  50.      
  51.      float4
  52.      
  53.       normalBuffer 
  54.      
  55.      =
  56.      
  57.       
  58.      
  59.      SAMPLE_TEXTURE2D_X
  60.      
  61.      (
  62.      
  63.      _NormalBufferTexture
  64.      
  65.      ,
  66.      
  67.       sampler_NormalBufferTexture
  68.      
  69.      ,
  70.      
  71.       positionNDC
  72.      
  73.      )
  74.      
  75.      ;
  76.      
  77.      
  78.     
  79.      
  80.      DecodeFromNormalBuffer
  81.      
  82.      (
  83.      
  84.      normalBuffer
  85.      
  86.      ,
  87.      
  88.       positionNDC
  89.      
  90.      ,
  91.      
  92.       normalData
  93.      
  94.      )
  95.      
  96.      ;
  97.      
  98.      
  99.  
  100.      
  101.      }
  102.     
  103.         
  104.     
  105.      
  106.      NormalData
  107.      
  108.       normalData
  109.      
  110.      ;
  111.      
  112.      
  113.  
  114.      
  115.      // get world normal method 2
  116.      
  117.      
  118.  
  119.      
  120.      DecodeFromNormalBufferNDC
  121.      
  122.      (
  123.      
  124.      posInput
  125.      
  126.      .
  127.      
  128.      positionNDC
  129.      
  130.      ,
  131.      
  132.       normalData
  133.      
  134.      )
  135.      
  136.      ;
  137.      
  138.      
  139.  
  140.      
  141.      float3
  142.      
  143.       normal 
  144.      
  145.      =
  146.      
  147.       normalData
  148.      
  149.      .
  150.      
  151.      normalWS
  152.      
  153.      ;
  154.

获取视口中的单位化屏幕坐标数据，值域[0,1) 

  1.     
  2.     
  3.      
  4.      // get positionNDC[0, 1)
  5.      
  6.      
  7.  
  8.      
  9.      float2
  10.      
  11.       positionNDC 
  12.      
  13.      =
  14.      
  15.       posInput
  16.      
  17.      .
  18.      
  19.      positionNDC
  20.      
  21.      ;
  22.      
  23.      
  24. finalColor 
  25.      
  26.      =
  27.      
  28.       
  29.      
  30.      float4
  31.      
  32.      (
  33.      
  34.      positionNDC
  35.      
  36.      ,
  37.      
  38.      0
  39.      
  40.      ,
  41.      
  42.      1
  43.      
  44.      )
  45.      
  46.      ;
  47.

获取裁剪空间位置数据

虽然叫varyings.positionCS，但是那个并不是真正的裁剪空间位置。 
  1.     
  2.     
  3.      
  4.      float4
  5.      
  6.       positionCS 
  7.      
  8.      =
  9.      
  10.       
  11.      
  12.      ComputeClipSpacePosition
  13.      
  14.      (
  15.      
  16.      posInput
  17.      
  18.      .
  19.      
  20.      positionNDC
  21.      
  22.      ,
  23.      
  24.       posInput
  25.      
  26.      .
  27.      
  28.      deviceDepth
  29.      
  30.      )
  31.      
  32.      ;
  33.

调试小技巧，输出矩阵数据

输出Matrix数据，有助于排查矩阵是否正确。 
  1.     
  2.     
  3.      
  4.      // get UNITY_MATRIX_I_VP
  5.      
  6.      
  7.  
  8.      
  9.      if
  10.      
  11.      (
  12.      
  13.      posInput
  14.      
  15.      .
  16.      
  17.      positionNDC
  18.      
  19.      .
  20.      
  21.      x 
  22.      
  23.      <
  24.      
  25.       
  26.      
  27.      0.5
  28.      
  29.       
  30.      
  31.      &&
  32.      
  33.       posInput
  34.      
  35.      .
  36.      
  37.      positionNDC
  38.      
  39.      .
  40.      
  41.      y 
  42.      
  43.      <
  44.      
  45.       
  46.      
  47.      0.5
  48.      
  49.      )
  50.      
  51.      
  52.     finalColor 
  53.      
  54.      =
  55.      
  56.       UNITY_MATRIX_I_VP
  57.      
  58.      [
  59.      
  60.      0
  61.      
  62.      ]
  63.      
  64.      ;
  65.      
  66.      
  67.  
  68.  
  69.      
  70.      if
  71.      
  72.      (
  73.      
  74.      posInput
  75.      
  76.      .
  77.      
  78.      positionNDC
  79.      
  80.      .
  81.      
  82.      x 
  83.      
  84.      >
  85.      
  86.       
  87.      
  88.      0.5
  89.      
  90.       
  91.      
  92.      &&
  93.      
  94.       posInput
  95.      
  96.      .
  97.      
  98.      positionNDC
  99.      
  100.      .
  101.      
  102.      y 
  103.      
  104.      <
  105.      
  106.       
  107.      
  108.      0.5
  109.      
  110.      )
  111.      
  112.      
  113.     finalColor 
  114.      
  115.      =
  116.      
  117.        UNITY_MATRIX_I_VP
  118.      
  119.      [
  120.      
  121.      1
  122.      
  123.      ]
  124.      
  125.      ;
  126.      
  127.      
  128.  
  129.  
  130.      
  131.      if
  132.      
  133.      (
  134.      
  135.      posInput
  136.      
  137.      .
  138.      
  139.      positionNDC
  140.      
  141.      .
  142.      
  143.      x 
  144.      
  145.      <
  146.      
  147.       
  148.      
  149.      0.5
  150.      
  151.       
  152.      
  153.      &&
  154.      
  155.       posInput
  156.      
  157.      .
  158.      
  159.      positionNDC
  160.      
  161.      .
  162.      
  163.      y 
  164.      
  165.      >
  166.      
  167.       
  168.      
  169.      0.5
  170.      
  171.      )
  172.      
  173.      
  174.     finalColor 
  175.      
  176.      =
  177.      
  178.        UNITY_MATRIX_I_VP
  179.      
  180.      [
  181.      
  182.      2
  183.      
  184.      ]
  185.      
  186.      ;
  187.      
  188.      
  189.  
  190.  
  191.      
  192.      if
  193.      
  194.      (
  195.      
  196.      posInput
  197.      
  198.      .
  199.      
  200.      positionNDC
  201.      
  202.      .
  203.      
  204.      x 
  205.      
  206.      >
  207.      
  208.       
  209.      
  210.      0.5
  211.      
  212.       
  213.      
  214.      &&
  215.      
  216.       posInput
  217.      
  218.      .
  219.      
  220.      positionNDC
  221.      
  222.      .
  223.      
  224.      y 
  225.      
  226.      >
  227.      
  228.       
  229.      
  230.      0.5
  231.      
  232.      )
  233.      
  234.      
  235.     finalColor 
  236.      
  237.      =
  238.      
  239.        UNITY_MATRIX_I_VP
  240.      
  241.      [
  242.      
  243.      3
  244.      
  245.      ]
  246.      
  247.      ;
  248.

下期预告

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

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

  

闽ICP备14008679号