《OGRE 3D 渲染引擎原理与架构》4.1 Pass 的渲染状态

一个 Pass 就是一次独立绘制所需的完整状态集:深度读写用 1 位 bitfield 压缩,剔除模式是 uint8 枚举,混合用 ColourBlendState 描述写掩码/因子/操作。setSceneBlending 把 SceneBlendType 翻译成源/目标因子。lab 复现 bitfield、CullingMode、混合状态与 isTransparent 判定。

4.1 Pass 的渲染状态

3.x 讲完了 GPU 程序和它的参数缓冲——「程序要跑起来」还需要一套完整的渲染状态:深度测试开不开、写不写深度、剔除哪一面、颜色怎么和帧缓冲混合。OGRE 把这些全部收进 Pass:一个 Pass 就是一次独立绘制所需的全部状态。这一节解剖 Pass 里的三类核心状态:深度位、剔除模式、混合状态。

本章与站内既有内容的分工

helio 四卷渲染器把渲染状态散在各 RenderCommand 里;卷一 ogre-core 从资源角度看过 Material/Technique/Pass 的层次。这里从「状态本身」切入:看 OGRE 如何用 bitfield 压深度标志、用 uint8 枚举描述剔除、用 ColourBlendState 结构化描述混合,并让高层 setSceneBlending(SBT_*) 自动落到低层因子。

深度状态:两个 bitfield

深度检查与深度写入是布尔量,OGRE 直接把它们声明成 1 位 bitfield,塞进一个字节里节省内存:

// OgreMain/include/OgrePass.h:Pass 深度成员(v14.6.3 源码摘录,已删减)
        // Depth buffer settings
        bool mDepthCheck : 1;
        bool mDepthWrite : 1;
        bool mAlphaToCoverageEnabled : 1;
// OgreMain/include/OgrePass.h:setDepthCheckEnabled(v14.6.3 源码摘录,已删减)
        void setDepthCheckEnabled(bool enabled) {  mDepthCheck = enabled; }
// OgreMain/include/OgrePass.h:setDepthWriteEnabled(v14.6.3 源码摘录,已删减)
        void setDepthWriteEnabled(bool enabled) { mDepthWrite = enabled; }

两个 setter 都是内联单行赋值,不触发 hash 失效(那是别处的责任)。语义上的组合很有讲究:

  • mDepthCheck = true 时,每个像素写入前都要和深度缓冲比较,比较函数由 mDepthFunc(默认 CMPF_LESS_EQUAL)决定;关闭则「无条件写入」。
  • mDepthWrite = false 常用于静态背景或透明物体排序后自遮挡:先画的地形不写深度,后面的半透明物体按正确顺序互相叠加。

剔除模式:CullingMode

剔除是三角形面对的方向问题,OGRE 用 uint8 枚举在 OgreCommon.h 里定义:

// OgreMain/include/OgreCommon.h:CullingMode(v14.6.3 源码摘录,已删减)
    /** Hardware culling modes based on vertex winding.
        This setting applies to how the hardware API culls triangles it is sent. */
    enum CullingMode : uint8
    {
        /// Hardware never culls triangles and renders everything it receives.
        CULL_NONE = 1,
        /// Hardware culls triangles whose vertices are listed clockwise in the view (default).
        CULL_CLOCKWISE = 2,
        /// Hardware culls triangles whose vertices are listed anticlockwise in the view.
        CULL_ANTICLOCKWISE = 3
    };

注意枚举值从 1 开始(0 留给未知/未初始化语义)。CULL_CLOCKWISE 是默认:只渲染顶点逆时针排列的三角形。Pass 持有这个枚举并暴露内联 setter:

// OgreMain/include/OgrePass.h:setCullingMode(v14.6.3 源码摘录,已删减)
        void setCullingMode( CullingMode mode ) { mCullMode = mode; }
值含义典型用途
CULL_NONE硬件不剔除双面渲染、数据已自行裁剪的网格
CULL_CLOCKWISE剔除顺时针面(默认)大多数实心几何
CULL_ANTICLOCKWISE剔除逆时针面反射平面、从内部看的效果

混合状态:ColourBlendState

混合最复杂,OGRE 把它独立成结构体,定义在 OgreBlendMode.h:

// OgreMain/include/OgreBlendMode.h:ColourBlendState(v14.6.3 源码摘录,已删减)
    struct _OgreExport ColourBlendState
    {
        /** @name Write Mask
         * Whether writing is enabled for each of the 4 colour channels */
        /// @{
        bool writeR : 1;
        bool writeG : 1;
        bool writeB : 1;
        bool writeA : 1;
        /// @}

        /** @name Blending factors
         * used to weight the render colour components and the frame colour components */
        /// @{
        SceneBlendFactor sourceFactor;
        SceneBlendFactor destFactor;
        SceneBlendFactor sourceFactorAlpha;
        SceneBlendFactor destFactorAlpha;
        /// @}

        /** @name Blending operations
         * The blend operation mode for combining colour values */
        /// @{
        SceneBlendOperation operation;
        SceneBlendOperation alphaOperation;
        /// @}

        ColourBlendState()
            : writeR(true), writeG(true), writeB(true), writeA(true), sourceFactor(SBF_ONE),
              destFactor(SBF_ZERO), sourceFactorAlpha(SBF_ONE), destFactorAlpha(SBF_ZERO),
              operation(SBO_ADD), alphaOperation(SBO_ADD)
        {
        }

        /// can we simply overwrite the existing pixels or do we have to blend
        bool blendingEnabled() const
        {
            return !(sourceFactor == SBF_ONE && destFactor == SBF_ZERO &&
                     sourceFactorAlpha == SBF_ONE && destFactorAlpha == SBF_ZERO);
        }
    };

结构分三组:4 个写掩码(RGBA 各 1 位)、4 个混合因子(源/目标 × RGB/Alpha)、2 个混合操作(RGB 与 Alpha)。blendingEnabled() 是精妙的一行:只有四项因子恰好等于「源 ONE、目标 ZERO」的覆盖组合时才返回 false——只要有一项偏离默认,就必须走混合管线。

混合因子本身又是枚举(SceneBlendFactor:SBF_ONE/SBF_ZERO/SBF_SOURCE_ALPHA/SBF_ONE_MINUS_SOURCE_ALPHA…),操作有 SBO_ADD/SBO_SUBTRACT/SBO_MIN/SBO_MAX。

高层语义到低层因子:setSceneBlending

材料脚本里 scene_blend alpha_blend 用的是 SceneBlendType(高层语义),而 ColourBlendState 要的是因子(低层表达)。_getBlendFlags 做这个翻译:

// OgreMain/src/OgrePass.cpp:_getBlendFlags(v14.6.3 源码摘录,已删减)
    static void _getBlendFlags(SceneBlendType type, SceneBlendFactor& source, SceneBlendFactor& dest)
    {
        switch ( type )
        {
        case SBT_TRANSPARENT_ALPHA:
            source = SBF_SOURCE_ALPHA;
            dest = SBF_ONE_MINUS_SOURCE_ALPHA;
            return;
        case SBT_TRANSPARENT_COLOUR:
            source = SBF_SOURCE_COLOUR;
            dest = SBF_ONE_MINUS_SOURCE_COLOUR;
            return;
        case SBT_MODULATE:
            source = SBF_DEST_COLOUR;
            dest = SBF_ZERO;
            return;
        case SBT_ADD:
            source = SBF_ONE;
            dest = SBF_ONE;
            return;
        default:
        case SBT_REPLACE:
            source = SBF_ONE;
            dest = SBF_ZERO;
            return;
        }
    }

setSceneBlending(SceneBlendType) 先翻译再落因子,且非分离版本把 Alpha 因子也设为与 RGB 相同:

// OgreMain/src/OgrePass.cpp:setSceneBlending(v14.6.3 源码摘录,已删减)
    void Pass::setSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor)
    {
        mBlendState.sourceFactor = sourceFactor;
        mBlendState.sourceFactorAlpha = sourceFactor;
        mBlendState.destFactor = destFactor;
        mBlendState.destFactorAlpha = destFactor;
    }

setSeparateSceneBlending 则让 RGB 与 Alpha 各走各的因子——做色相/饱和度分离效果时用得到。透明判定 isTransparent() 看的是 destFactor 是否参与:SBT_ADD(ONE/ONE)和 SBT_MODULATE(DEST_COLOUR/ZERO)都算透明,纯覆盖 SBT_REPLACE 不算。

源码定位

  • OgreMain/include/OgrePass.h :mBlendState(147)、深度 bitfield(152-153)、mCullMode(191)、setDepthCheckEnabled/setDepthWriteEnabled(759/775)、setCullingMode(847)
  • OgreMain/include/OgreBlendMode.h :SceneBlendType(215-223)、SceneBlendFactor(229-241)、SceneBlendOperation(247-254)、ColourBlendState(266-306)
  • OgreMain/src/OgrePass.cpp :_getBlendFlags(473-499)、setSceneBlending(501-546)、isTransparent(560-569)

上游引用固定到 OGRE v14.6.3 源码 。

可运行产物:C++ 最小验证

下面复现 bitfield 深度标志、CullingMode 枚举、ColourBlendState 与 setSceneBlending 因子翻译。它与 src/04-1-pass-render-state.cpp 逐字节一致:

// file: src/04-1-pass-render-state.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/04-1-pass-render-state.cpp -o bin/04-1-pass-render-state && ./bin/04-1-pass-render-state
//
// 复现 Pass 的渲染状态(对应 OgrePass.h 147/152-153/191、OgreBlendMode.h 215-306、OgrePass.cpp 473-546):
//   mDepthCheck/mDepthWrite 是 1 位 bitfield;mCullMode 是 CullingMode:uint8 枚举;
//   ColourBlendState 用 4 个 1 位 write 掩码 + 4 个混合因子 + 2 个混合操作,blendingEnabled() 判断是否纯覆盖;
//   _getBlendFlags 把 SceneBlendType 翻译成源/目标因子;setSceneBlending 同步 RGB 与 Alpha 因子。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>

namespace ogre_repro {

enum CullingMode : uint8_t {
  CULL_NONE = 1,
  CULL_CLOCKWISE = 2,
  CULL_ANTICLOCKWISE = 3
};

enum SceneBlendType {
  SBT_TRANSPARENT_ALPHA,
  SBT_TRANSPARENT_COLOUR,
  SBT_ADD,
  SBT_MODULATE,
  SBT_REPLACE
};

enum SceneBlendFactor {
  SBF_ONE,
  SBF_ZERO,
  SBF_DEST_COLOUR,
  SBF_SOURCE_COLOUR,
  SBF_ONE_MINUS_DEST_COLOUR,
  SBF_ONE_MINUS_SOURCE_COLOUR,
  SBF_DEST_ALPHA,
  SBF_SOURCE_ALPHA,
  SBF_ONE_MINUS_DEST_ALPHA,
  SBF_ONE_MINUS_SOURCE_ALPHA
};

enum SceneBlendOperation { SBO_ADD, SBO_SUBTRACT, SBO_REVERSE_SUBTRACT, SBO_MIN, SBO_MAX };

// 对应 ColourBlendState(OgreBlendMode.h 266-306)
struct ColourBlendState {
  bool writeR : 1;
  bool writeG : 1;
  bool writeB : 1;
  bool writeA : 1;

  SceneBlendFactor sourceFactor;
  SceneBlendFactor destFactor;
  SceneBlendFactor sourceFactorAlpha;
  SceneBlendFactor destFactorAlpha;

  SceneBlendOperation operation;
  SceneBlendOperation alphaOperation;

  ColourBlendState()
      : writeR(true), writeG(true), writeB(true), writeA(true), sourceFactor(SBF_ONE),
        destFactor(SBF_ZERO), sourceFactorAlpha(SBF_ONE), destFactorAlpha(SBF_ZERO),
        operation(SBO_ADD), alphaOperation(SBO_ADD) {}

  // 对应 blendingEnabled():四项因子全是 ONE/ZERO 覆盖时关闭混合
  bool blendingEnabled() const {
    return !(sourceFactor == SBF_ONE && destFactor == SBF_ZERO &&
             sourceFactorAlpha == SBF_ONE && destFactorAlpha == SBF_ZERO);
  }
};

// 对应 _getBlendFlags(OgrePass.cpp 473-499)
static void _getBlendFlags(SceneBlendType type, SceneBlendFactor& source, SceneBlendFactor& dest) {
  switch (type) {
    case SBT_TRANSPARENT_ALPHA:
      source = SBF_SOURCE_ALPHA;
      dest = SBF_ONE_MINUS_SOURCE_ALPHA;
      return;
    case SBT_TRANSPARENT_COLOUR:
      source = SBF_SOURCE_COLOUR;
      dest = SBF_ONE_MINUS_SOURCE_COLOUR;
      return;
    case SBT_MODULATE:
      source = SBF_DEST_COLOUR;
      dest = SBF_ZERO;
      return;
    case SBT_ADD:
      source = SBF_ONE;
      dest = SBF_ONE;
      return;
    default:
    case SBT_REPLACE:
      source = SBF_ONE;
      dest = SBF_ZERO;
      return;
  }
}

// 对应 Pass 渲染状态子集(OgrePass.h 147/152-153/191)
class Pass {
 public:
  // 对应 setDepthCheckEnabled / setDepthWriteEnabled(内联 setter)
  void setDepthCheckEnabled(bool enabled) { mDepthCheck = enabled; }
  bool getDepthCheckEnabled() const { return mDepthCheck; }
  void setDepthWriteEnabled(bool enabled) { mDepthWrite = enabled; }
  bool getDepthWriteEnabled() const { return mDepthWrite; }

  // 对应 setCullingMode(内联 setter)
  void setCullingMode(CullingMode mode) { mCullMode = mode; }
  CullingMode getCullingMode() const { return mCullMode; }

  // 对应 setSceneBlending(SceneBlendType):先翻译因子,再同步 RGB 与 Alpha
  void setSceneBlending(SceneBlendType sbt) {
    SceneBlendFactor source;
    SceneBlendFactor dest;
    _getBlendFlags(sbt, source, dest);
    setSceneBlending(source, dest);
  }

  // 对应 setSceneBlending(SceneBlendFactor, SceneBlendFactor):Alpha 因子与 RGB 相同
  void setSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor) {
    mBlendState.sourceFactor = sourceFactor;
    mBlendState.sourceFactorAlpha = sourceFactor;
    mBlendState.destFactor = destFactor;
    mBlendState.destFactorAlpha = destFactor;
  }

  // 对应 setSeparateSceneBlending:RGB 与 Alpha 各自独立
  void setSeparateSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor,
                                SceneBlendFactor sourceFactorAlpha,
                                SceneBlendFactor destFactorAlpha) {
    mBlendState.sourceFactor = sourceFactor;
    mBlendState.destFactor = destFactor;
    mBlendState.sourceFactorAlpha = sourceFactorAlpha;
    mBlendState.destFactorAlpha = destFactorAlpha;
  }

  void setSceneBlendingOperation(SceneBlendOperation op) {
    mBlendState.operation = op;
    mBlendState.alphaOperation = op;
  }

  // 对应 isTransparent(OgrePass.cpp 560-569)
  bool isTransparent() const {
    if (mBlendState.destFactor == SBF_ZERO &&
        mBlendState.sourceFactor != SBF_DEST_COLOUR &&
        mBlendState.sourceFactor != SBF_ONE_MINUS_DEST_COLOUR &&
        mBlendState.sourceFactor != SBF_DEST_ALPHA &&
        mBlendState.sourceFactor != SBF_ONE_MINUS_DEST_ALPHA) {
      return false;
    }
    return true;
  }

  const ColourBlendState& getBlendState() const { return mBlendState; }

 private:
  bool mDepthCheck : 1;
  bool mDepthWrite : 1;
  CullingMode mCullMode;
  ColourBlendState mBlendState;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // CullingMode 是 uint8 枚举,值为 1/2/3
  CHECK(CULL_NONE == 1);
  CHECK(CULL_CLOCKWISE == 2);
  CHECK(CULL_ANTICLOCKWISE == 3);

  // ColourBlendState 默认值:全写掩码开、ONE/ZERO 覆盖、ADD
  ColourBlendState bs;
  CHECK(bs.writeR == true);
  CHECK(bs.writeA == true);
  CHECK(bs.sourceFactor == SBF_ONE);
  CHECK(bs.destFactor == SBF_ZERO);
  CHECK(bs.sourceFactorAlpha == SBF_ONE);
  CHECK(bs.destFactorAlpha == SBF_ZERO);
  CHECK(bs.operation == SBO_ADD);
  CHECK(!bs.blendingEnabled());  // ONE/ZERO 覆盖 = 无需混合

  // 改 Alpha 写掩码:掩码与混合启用无关
  bs.writeA = false;
  CHECK(!bs.blendingEnabled());

  // Pass 深度与剔除 setter
  Pass pass;
  pass.setDepthCheckEnabled(true);
  CHECK(pass.getDepthCheckEnabled() == true);
  pass.setDepthWriteEnabled(false);
  CHECK(pass.getDepthWriteEnabled() == false);
  pass.setDepthCheckEnabled(false);
  pass.setDepthWriteEnabled(true);
  CHECK(pass.getDepthCheckEnabled() == false);
  CHECK(pass.getDepthWriteEnabled() == true);

  // 剔除模式
  pass.setCullingMode(CULL_ANTICLOCKWISE);
  CHECK(pass.getCullingMode() == CULL_ANTICLOCKWISE);
  pass.setCullingMode(CULL_NONE);
  CHECK(pass.getCullingMode() == CULL_NONE);

  // setSceneBlending(SBT_TRANSPARENT_ALPHA):源=源 Alpha,目标=1-源 Alpha
  pass.setSceneBlending(SBT_TRANSPARENT_ALPHA);
  CHECK(pass.getBlendState().sourceFactor == SBF_SOURCE_ALPHA);
  CHECK(pass.getBlendState().destFactor == SBF_ONE_MINUS_SOURCE_ALPHA);
  CHECK(pass.getBlendState().sourceFactorAlpha == SBF_SOURCE_ALPHA);  // 非分离混合:Alpha 同 RGB
  CHECK(pass.getBlendState().destFactorAlpha == SBF_ONE_MINUS_SOURCE_ALPHA);
  CHECK(pass.getBlendState().blendingEnabled());

  // setSceneBlending(SBT_ADD):ONE/ONE
  pass.setSceneBlending(SBT_ADD);
  CHECK(pass.getBlendState().sourceFactor == SBF_ONE);
  CHECK(pass.getBlendState().destFactor == SBF_ONE);

  // setSceneBlending(SBT_MODULATE):源=目标颜色,目标=ZERO
  pass.setSceneBlending(SBT_MODULATE);
  CHECK(pass.getBlendState().sourceFactor == SBF_DEST_COLOUR);
  CHECK(pass.getBlendState().destFactor == SBF_ZERO);
  CHECK(pass.isTransparent());  // destFactor=SBF_ZERO 但源取目标颜色 -> 仍透明

  // setSceneBlending(SBT_REPLACE):纯覆盖,非透明
  pass.setSceneBlending(SBT_REPLACE);
  CHECK(pass.getBlendState().sourceFactor == SBF_ONE);
  CHECK(pass.getBlendState().destFactor == SBF_ZERO);
  CHECK(!pass.isTransparent());

  // 分离混合:RGB 与 Alpha 因子独立
  pass.setSeparateSceneBlending(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA, SBF_ONE, SBF_ONE);
  CHECK(pass.getBlendState().sourceFactor == SBF_SOURCE_ALPHA);
  CHECK(pass.getBlendState().destFactor == SBF_ONE_MINUS_SOURCE_ALPHA);
  CHECK(pass.getBlendState().sourceFactorAlpha == SBF_ONE);
  CHECK(pass.getBlendState().destFactorAlpha == SBF_ONE);

  // setSceneBlendingOperation 同步 RGB 与 Alpha 操作
  pass.setSceneBlendingOperation(SBO_SUBTRACT);
  CHECK(pass.getBlendState().operation == SBO_SUBTRACT);
  CHECK(pass.getBlendState().alphaOperation == SBO_SUBTRACT);

  return lab::report("04-1 Pass 的渲染状态");
}

本机实测(Apple clang 16,clang++ -std=c++20):编译通过(-Wall 零警告),断言 37/37 通过。

小结

  • 深度检查/写入是两个 1 位 bitfield,setter 是内联单行赋值。
  • CullingMode : uint8 从 1 开始计数,默认 CULL_CLOCKWISE。
  • ColourBlendState 用写掩码(RGBA 各 1 位)+ 四因子 + 双操作描述混合,blendingEnabled() 一行判定是否需要混合。
  • _getBlendFlags 把 SceneBlendType 翻译成源/目标因子;非分离 setSceneBlending 让 Alpha 跟随 RGB。
  • isTransparent() 以目标因子是否参与混合判定透明度。

阅读导航:上一节:3.3 自动参数绑定 · 下一节:4.2 Technique 状态合并 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图