Surface Shader 执行流程

Surface Shader 统一了着色流程，同时为 vs 和 fs 提供了大量的自定义函数，大家可以根据自己的需求，重写相关函数。

请参考 Surface Shader 内置函数 和 使用宏定义实现函数替换。

本文主要目的在于帮助开发者熟悉 Surface Shader 执行流程，弄清楚各函数调用时机。

函数入口

我们先看一下内置的 Surface Shader 文件的 CCEffect 部分：

  1. CCEffect %{
  2.   techniques:
  3.   - name: opaque
  4.     passes:
  5.     - vert: standard-vs
  6.       frag: standard-fs
  7.     ...
  8. }%

可以看到， 每一个 pass 的 vert 和 frag 没有指定专有的入口函数，这就表示，它所用到的 vs 和 fs 的入口函数为 main。

从 Surface Shader 结构 中，我们可以了解到， 在 Surface Shader 组装 环节，每一个 Surface Shader 会根据不同的 渲染用途，引入不同的头文件。 这个头文件就是我们的入口函数。

VS 主函数

以内置 Surface Shader 的 standard-vs 为例：

  1. CCProgram standard-vs %{
  2.     #include <shading-entries/main-functions/render-to-scene/vs>
  3. }%

可以看到，它引入的是 render-to-scene 下面的 vs.chunk。

打开 render-to-scene/vs.chunk，可以看到，它只有一个 main 函数。代码和注释如下：

  1. void main()
  2. {
  3.     //声明一个表面材质数据结构
  4.     SurfacesStandardVertexIntermediate In;
  6.     //获取顶点基本数据
  7.     CCSurfacesVertexInput(In);
  8.     //获取顶点动画数据
  9.     CCSurfacesVertexAnimation(In);
  10.     // ===== 本地坐标相关 ====
  11.     //处理本地坐标，用户可用宏替换
  12.     In.position.xyz = SurfacesVertexModifyLocalPos(In);
  13.     //处理本地法线，用户可用宏替换
  14.     In.normal.xyz = SurfacesVertexModifyLocalNormal(In);
  15.     //处理本地切线，用户可用宏替换
  16.     #if CC_SURFACES_USE_TANGENT_SPACE
  17.         In.tangent = SurfacesVertexModifyLocalTangent(In);
  18.     #endif
  19.     //进一步处理自定义本地数据，用户可用宏替换
  20.     SurfacesVertexModifyLocalSharedData(In);
  22.     //==== 世界坐标相关======
  23.     //进行世界坐标转换，并填充数据结构
  24.     CCSurfacesVertexWorldTransform(In);
  25.     //额外的处理世界坐标函数，用户可用宏替换
  26.     In.worldPos = SurfacesVertexModifyWorldPos(In);
  28.     //投影空间坐标
  29.     In.clipPos = cc_matProj * cc_matView * vec4(In.worldPos, 1.0);
  30.     //进一步处理投影空间坐标，用户可用宏替换
  31.     In.clipPos = SurfacesVertexModifyClipPos(In);
  33.     //其它一些数据变换
  34.     vec3 viewDirect = normalize(cc_cameraPos.xyz - In.worldPos);
  35.     In.worldNormal.w = dot(In.worldNormal.xyz, viewDirect) < 0.0 ? -1.0 : 1.0;
  36.     //进一步处理世界法线，用户可用宏替换
  37.     In.worldNormal.xyz = SurfacesVertexModifyWorldNormal(In);
  39.     //进一步处理UV，用户可用宏替换
  40.     SurfacesVertexModifyUV(In);
  41.     //进一步处理自定义数据，用户可用宏替换
  42.     SurfacesVertexModifySharedData(In);
  44.     //其它变换
  45.     //UV
  46.     CCSurfacesVertexTransformUV(In);
  47.     //雾效
  48.     CCSurfacesVertexTransferFog(In);
  49.     //阴影
  50.     CCSurfacesVertexTransferShadow(In);
  51.     //光照贴图UV
  52.     CCSurfacesVertexTransferLightMapUV(In);
  54.     //最终输出
  55.     CCSurfacesVertexOutput(In);
  56. }

FS 主函数

同样的，我们以内置 Surface Shader 的 standard-fs 为例：

  1. CCProgram standard-fs %{
  2.   #include <shading-entries/main-functions/render-to-scene/fs>
  3. }%

render-to-scene/fs.chunk 文件内容如下：

  1. #if (CC_PIPELINE_TYPE == CC_PIPELINE_TYPE_FORWARD || CC_FORCE_FORWARD_SHADING)
  2.   #include <shading-entries/main-functions/render-to-scene/pipeline/forward-fs>
  3. #elif CC_PIPELINE_TYPE == CC_PIPELINE_TYPE_DEFERRED
  4.   #include <shading-entries/main-functions/render-to-scene/pipeline/deferred-fs>
  5. #endif

可以看到它区分了 forward 和 deferred 管线。

forward-fs

  1. //定义颜色输出目标
  2. layout(location = 0) out vec4 fragColorX;
  4. void main()  {
  5.     #if CC_DISABLE_STRUCTURE_IN_FRAGMENT_SHADER
  6.     //获取基本颜色和透明度，用户可用宏替换
  7.     vec4 color = SurfacesFragmentModifyBaseColorAndTransparency();
  8.     #else
  9.     //获取表面材质数据
  10.     SurfacesMaterialData surfaceData;
  11.     CCSurfacesFragmentGetMaterialData(surfaceData);
  13.     //计算阴影参数
  14.     vec2 shadowBias = vec2(0.0);
  15.     ...
  18.     //计算雾效参数
  19.     #if !CC_FORWARD_ADD
  20.         float fogFactor = 1.0;
  21.     #endif
  23.     //计算光照
  24.     LightingResult lightingResult;
  25.     CCSurfacesLighting(lightingResult, surfaceData, shadowBias);
  28.     //渲染调试相关
  29.     ...
  31.     //像素着色计算
  32.     vec4 color = CCSurfacesShading(surfaceData, lightingResult);
  34.     ...
  36.     //颜色输出
  37.     #if CC_USE_RGBE_OUTPUT
  38.         fragColorX = packRGBE(color.rgb); // for reflection-map
  39.         return;
  40.     #endif
  42.     //HDR，LinearToSRGB 等最终运算
  43.     #if CC_USE_HDR
  44.         #if CC_USE_DEBUG_VIEW == CC_SURFACES_DEBUG_VIEW_COMPOSITE_AND_MISC && CC_SURFACES_ENABLE_DEBUG_VIEW
  45.         if (IS_DEBUG_VIEW_COMPOSITE_ENABLE_TONE_MAPPING)
  46.         #endif
  47.         color.rgb = ACESToneMap(color.rgb);
  48.     #endif
  49.     #if CC_USE_DEBUG_VIEW == CC_SURFACES_DEBUG_VIEW_COMPOSITE_AND_MISC
  50.         if (IS_DEBUG_VIEW_COMPOSITE_ENABLE_GAMMA_CORRECTION)
  51.     #endif
  52.     color.rgb = LinearToSRGB(color.rgb);
  54.     #if !CC_FORWARD_ADD && CC_USE_FOG != CC_FOG_NONE
  55.         CC_APPLY_FOG_BASE(color, fogFactor);
  56.     #endif
  58.     fragColorX = CCSurfacesDebugDisplayInvalidNumber(color);
  59. }

deferred-fs

延迟渲染由于分成两个阶段：GBuffer 和 Lighting。

在 GBuffer 阶段主要是填充各个渲染目标，只需要收集对应的材质表面数据即可，代码如下：

  1. //GBuffer 0，1，2
  2. layout(location = 0) out vec4 fragColor0;
  3. layout(location = 1) out vec4 fragColor1;
  4. layout(location = 2) out vec4 fragColor2;
  6. void main () {
  7.     //收集表面材质数据
  8.     SurfacesMaterialData surfaceData;
  9.     CCSurfacesFragmentGetMaterialData(surfaceData);
  11.     //填充 GBuffer
  12.     fragColor0 = CCSurfacesDeferredOutput0(surfaceData);
  13.     fragColor1 = CCSurfacesDeferredOutput1(surfaceData);
  14.     fragColor2 = CCSurfacesDeferredOutput2(surfaceData);
  16.     //调试渲染相关
  17.     #if CC_USE_DEBUG_VIEW == CC_SURFACES_DEBUG_VIEW_SINGLE && CC_SURFACES_ENABLE_DEBUG_VIEW
  18.         vec4 debugColor = vec4(0.0, 0.0, 0.0, 1.0);
  19.         CCSurfacesDebugViewMeshData(debugColor);
  20.         CCSurfacesDebugViewSurfaceData(debugColor, surfaceData);
  21.         if (IS_DEBUG_VIEW_ENABLE_WITH_CAMERA) {
  22.         fragColor0 = debugColor;
  23.         }
  24.     #endif
  25. }

延迟渲染的 Lighting 阶段，是受引擎渲染管线控制的，会统一使用 GBuffer 进行光照计算，可参考 internal/effects/deferred-lighting.effect。

其余的渲染用途主函数同理，可以到 internal/chunks/shading-entries/ 目录下查看。

提示：可以被替换的代码，都以 Surface###Modify### 方式命名。