《OGRE 3D 渲染引擎原理与架构》4.3 状态应用到 RenderSystem

Pass 里的状态只是声明,真正生效靠 SceneManager::_setPass:它把 Pass 的状态按固定顺序转发给 RenderSystem 的纯虚 setter——混合、纹理单元、深度缓冲、Alpha 剔除、剔除模式、着色模式。后端各自记录已应用状态。lab 复现这个分发链与每个 setter 的记录语义。

4.3 状态应用到 RenderSystem

4.1 定义了 Pass 里存什么,4.2 定义了 Technique 怎么装 Pass。但状态存在 Pass 的成员里不等于显卡知道——把 mDepthCheck 变成一次 glEnable(GL_DEPTH_TEST),是 SceneManager::_setPass 的工作。这一节看这条状态转发链:SceneManager 如何把 Pass 的状态按固定顺序喂给 RenderSystem 的一组纯虚 setter。

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

helio 四卷渲染器的状态直接写进 DrawCommand 交给后端;卷一 ogre-core 讲 Resource 层。这里看 OGRE 的分层:Pass(声明)→ SceneManager::_setPass(分发)→ RenderSystem(抽象后端)。这层抽象正是 GL3+ 与 Vulkan/GLES 后端能并存的原因——SceneManager 不关心具体 API。

抽象的 RenderSystem

后端必须实现的是一组纯虚 setter。RenderSystem.h 把它们声明得清清楚楚:

// OgreMain/include/OgreRenderSystem.h:抽象状态 setter(v14.6.3 源码摘录,已删减)
        virtual void _setTextureUnitSettings(size_t texUnit, TextureUnitState& tl);
        virtual void _disableTextureUnitsFrom(size_t texUnit);
// OgreMain/include/OgreRenderSystem.h:抽象状态 setter(v14.6.3 源码摘录,已删减)
        virtual void setColourBlendState(const ColourBlendState& state) = 0;
// OgreMain/include/OgreRenderSystem.h:抽象状态 setter(v14.6.3 源码摘录,已删减)
        virtual void _setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverage) = 0;
// OgreMain/include/OgreRenderSystem.h:抽象状态 setter(v14.6.3 源码摘录,已删减)
        virtual void _setCullingMode(CullingMode mode) = 0;
// OgreMain/include/OgreRenderSystem.h:_setDepthBufferParams(v14.6.3 源码摘录,已删减)
        virtual void _setDepthBufferParams(bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL) = 0;

注意 _setTextureUnitSettings 和 _disableTextureUnitsFrom 不带 = 0——RenderSystem 基类给了默认实现,其余(混合、深度、剔除、Alpha 剔除)都是纯虚,强制每个后端自己实现。每个具体后端(GL3PlusRenderSystem、GLES2、Vulkan…)把参数翻译成对应的 API 调用,并维护一份「当前已应用状态」。

分发链:SceneManager::_setPass

SceneManager::_setPass 开头先处理两件解耦的事:延迟材质解析(isLateMaterialResolving 时换用最合适 Technique 的同索引 Pass)和阴影推导(纹理阴影时用 mTextureShadowRenderer 派生一份阴影 Pass)。之后是程序绑定:

// OgreMain/src/OgreSceneManager.cpp:_setPass 程序绑定(v14.6.3 源码摘录,已删减)
    GpuProgram* vprog = pass->hasVertexProgram() ? pass->getVertexProgram().get() : 0;
    GpuProgram* fprog = pass->hasFragmentProgram() ? pass->getFragmentProgram().get() : 0;

    bool passSurfaceAndLightParams = !vprog || vprog->getPassSurfaceAndLightStates();

    if (vprog)
    {
        bindGpuProgram(vprog->_getBindingDelegate());
    }
    else if (!mDestRenderSystem->getCapabilities()->hasCapability(RSC_FIXED_FUNCTION) &&
             !pass->hasGpuProgram(GPT_MESH_PROGRAM))
    {
        OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
                    "RenderSystem does not support FixedFunction, "
                    "but technique of '" +
                        pass->getParent()->getParent()->getName() +
                        "' has no Vertex Shader. Use the RTSS or write custom shaders.",
                    "SceneManager::_setPass");
    }

有顶点程序就绑定;没有而硬件又不支持固定管线,直接抛 ERR_INVALID_STATE——这是老显卡兼容性检查的落点。片元程序同样处理,中间还顺手设了雾参数(mAutoParamDataSource->setFog(...))。真正渲染状态的应用在注释「The rest of the settings are the same no matter whether we use programs or not」之后的固定段落:

// OgreMain/src/OgreSceneManager.cpp:_setPass 渲染状态应用(v14.6.3 源码摘录,已删减)
    // Set scene blending
    mDestRenderSystem->setColourBlendState(pass->getBlendState());

    // Line width
    if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_WIDE_LINES))
        mDestRenderSystem->_setLineWidth(pass->getLineWidth());

    // Set point parameters
    mDestRenderSystem->_setPointParameters(pass->isPointAttenuationEnabled(), pass->getPointMinSize(),
                                           pass->getPointMaxSize());

    if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_POINT_SPRITES))
        mDestRenderSystem->_setPointSpritesEnabled(pass->getPointSpritesEnabled());

纹理单元与深度/剔除:应用顺序

纹理单元是「先逐个启用,再统一禁用多余」的模式——getTextureUnitStates() 返回数组,逐个 _setTextureUnitSettings(unit, *pTex),然后 _disableTextureUnitsFrom(getNumTextureUnitStates()) 关掉后面用不到的单元:

// OgreMain/src/OgreSceneManager.cpp:_setPass 纹理单元(v14.6.3 源码摘录,已删减)
        mDestRenderSystem->_setTextureUnitSettings(unit, *pTex);
        ++unit;
    }
    // Disable remaining texture units
    mDestRenderSystem->_disableTextureUnitsFrom(pass->getNumTextureUnitStates());

    // Set up non-texture related material settings
    // Depth buffer settings
    mDestRenderSystem->_setDepthBufferParams(pass->getDepthCheckEnabled(), pass->getDepthWriteEnabled(),
                                             pass->getDepthFunction());
    mDestRenderSystem->_setDepthBias(pass->getDepthBiasConstant(), pass->getDepthBiasSlopeScale());
    // Alpha-reject settings
    mDestRenderSystem->_setAlphaRejectSettings(pass->getAlphaRejectFunction(),
                                               pass->getAlphaRejectValue(),
                                               pass->isAlphaToCoverageEnabled());

_setTextureUnitSettings 里还处理了阴影纹理解析(mTextureShadowRenderer.resolveShadowTexture)和投影纹理(setTextureProjector),但核心动作就是「把 pass 的状态喂给后端」。

剔除模式有一段影子专用的翻转逻辑——渲染阴影贴图时把顺时针改成逆时针,让背面朝向光源,改善深度比较:

// OgreMain/src/OgreSceneManager.cpp:_setPass 剔除模式(v14.6.3 源码摘录,已删减)
    // Culling mode
    if (isShadowTechniqueTextureBased() && mIlluminationStage == IRS_RENDER_TO_TEXTURE &&
        getShadowCasterRenderBackFaces() && pass->getCullingMode() == CULL_CLOCKWISE)
    {
        // render back faces into shadow caster, can help with depth comparison
        mPassCullingMode = CULL_ANTICLOCKWISE;
    }
    else
    {
        mPassCullingMode = pass->getCullingMode();
    }
    mDestRenderSystem->_setCullingMode(mPassCullingMode);
    mDestRenderSystem->setShadingType(pass->getShadingMode());

最后 setShadingType(平面/高洛德/Phong 着色模式)收尾,mAutoParamDataSource->setPassNumber(pass->getIndex()) 记录当前是第几道 Pass。整条链的顺序是:程序 → 雾 → 混合 → 线宽/点参数 → 纹理单元 → 深度 → Alpha 剔除 → 剔除模式 → 着色模式。lab 复现了这个转发顺序,并用「每个 setter 都在后端记录」验证状态确实到达。

材质选择与绑定发生在不同阶段

入队时确认 Technique,消费队列时 _setPass 应用程序、纹理和渲染状态。真正绘制前还要完成与对象关联的 GPU 参数。某个 Pass 的状态会影响后续的深度、混合和像素结果。

把两个绘制项的 material、scheme、Pass、世界矩阵和深度状态放在同一行。可区分选错方案、绑定错资源和更新错实例参数。

从材质方案到后端状态

sequenceDiagram
  participant Q as RenderQueue
  participant S as SceneManager
  participant R as RenderSystem
  Q-->>S: 提供 Renderable 与 Pass
  S->>R: 绑定程序、纹理与渲染状态
  S->>S: 选择对象变换与光源参数
  S->>R: 在绘制前绑定更新后的参数
  S->>R: 传入 RenderOperation

源码定位

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

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

下面复现 _setPass 的状态转发链与 RenderSystem 后端的记录语义。它与 src/04-3-render-system-apply.cpp 逐字节一致:

// file: src/04-3-render-system-apply.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/04-3-render-system-apply.cpp -o bin/04-3-render-system-apply && ./bin/04-3-render-system-apply
//
// 复现 SceneManager::_setPass 把 Pass 状态应用进 RenderSystem(对应 OgreSceneManager.cpp 768-873、OgreRenderSystem.h 348/538-544/620/643/692/709):
//   _setPass 按固定顺序把 Pass 的状态转发给 RenderSystem 的抽象 setter:
//     setColourBlendState -> _setTextureUnitSettings(逐个) -> _disableTextureUnitsFrom -> _setDepthBufferParams
//     -> _setAlphaRejectSettings -> _setCullingMode -> setShadingType;
//   RenderSystem 是纯虚接口,具体后端记录已应用状态;同一 Pass 状态可反复应用。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <vector>

namespace ogre_repro {

enum CullingMode : uint8_t { CULL_NONE = 1, CULL_CLOCKWISE = 2, CULL_ANTICLOCKWISE = 3 };
enum CompareFunction : uint8_t { CMPF_ALWAYS_PASS = 1, CMPF_LESS_EQUAL = 2 };
enum ShadeOptions : uint8_t { SO_FLAT = 0, SO_GOURAUD = 1, SO_PHONG = 2 };

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
};

struct ColourBlendState {
  SceneBlendFactor sourceFactor;
  SceneBlendFactor destFactor;

  ColourBlendState() : sourceFactor(SBF_ONE), destFactor(SBF_ZERO) {}
};

struct TextureUnitSettings {
  int index;
  explicit TextureUnitSettings(int i) : index(i) {}
};

// 对应 Pass 的渲染状态子集(4.1 已细看)
struct Pass {
  ColourBlendState blend;
  bool depthCheck = true;
  bool depthWrite = true;
  CompareFunction depthFunc = CMPF_LESS_EQUAL;
  CullingMode cull = CULL_CLOCKWISE;
  CompareFunction alphaFunc = CMPF_ALWAYS_PASS;
  uint8_t alphaValue = 0;
  bool alphaToCoverage = false;
  ShadeOptions shading = SO_GOURAUD;
  std::vector<TextureUnitSettings> texUnits;

  size_t getNumTextureUnitStates() const { return texUnits.size(); }
};

// 对应 RenderSystem 的抽象状态 setter(OgreRenderSystem.h 348/538-544/620/643/692/709)
class RenderSystem {
 public:
  virtual ~RenderSystem() = default;

  virtual void setColourBlendState(const ColourBlendState& state) = 0;
  virtual void _setTextureUnitSettings(size_t texUnit) = 0;
  virtual void _disableTextureUnitsFrom(size_t texUnit) = 0;
  virtual void _setDepthBufferParams(bool depthTest, bool depthWrite, CompareFunction depthFunction) = 0;
  virtual void _setAlphaRejectSettings(CompareFunction func, uint8_t value, bool alphaToCoverage) = 0;
  virtual void _setCullingMode(CullingMode mode) = 0;
  virtual void setShadingType(ShadeOptions so) = 0;
};

// 具体后端:记录「已应用状态」,模拟 GL3+ 渲染系统
class GL3RenderSystem : public RenderSystem {
 public:
  struct AppliedState {
    ColourBlendState blend;
    bool depthCheck = false;
    bool depthWrite = false;
    CompareFunction depthFunc = CMPF_ALWAYS_PASS;
    CompareFunction alphaFunc = CMPF_ALWAYS_PASS;
    uint8_t alphaValue = 0;
    bool alphaToCoverage = false;
    CullingMode cull = CULL_NONE;
    ShadeOptions shading = SO_FLAT;
    bool texUnitActive[4] = {false, false, false, false};
    int setterCalls = 0;
  };

  AppliedState state;

  void setColourBlendState(const ColourBlendState& s) override {
    state.blend = s;
    state.setterCalls++;
  }
  void _setTextureUnitSettings(size_t texUnit) override {
    if (texUnit < 4) state.texUnitActive[texUnit] = true;
    state.setterCalls++;
  }
  void _disableTextureUnitsFrom(size_t texUnit) override {
    for (size_t i = texUnit; i < 4; ++i) state.texUnitActive[i] = false;
    state.setterCalls++;
  }
  void _setDepthBufferParams(bool depthTest, bool depthWrite, CompareFunction depthFunction) override {
    state.depthCheck = depthTest;
    state.depthWrite = depthWrite;
    state.depthFunc = depthFunction;
    state.setterCalls++;
  }
  void _setAlphaRejectSettings(CompareFunction func, uint8_t value, bool alphaToCoverage) override {
    state.alphaFunc = func;
    state.alphaValue = value;
    state.alphaToCoverage = alphaToCoverage;
    state.setterCalls++;
  }
  void _setCullingMode(CullingMode mode) override {
    state.cull = mode;
    state.setterCalls++;
  }
  void setShadingType(ShadeOptions so) override {
    state.shading = so;
    state.setterCalls++;
  }
};

// 对应 SceneManager::_setPass 的状态转发顺序(OgreSceneManager.cpp 768-873)
void _setPass(const Pass& pass, RenderSystem& rs) {
  rs.setColourBlendState(pass.blend);
  for (const auto& tu : pass.texUnits) rs._setTextureUnitSettings(tu.index);
  rs._disableTextureUnitsFrom(pass.getNumTextureUnitStates());
  rs._setDepthBufferParams(pass.depthCheck, pass.depthWrite, pass.depthFunc);
  rs._setAlphaRejectSettings(pass.alphaFunc, pass.alphaValue, pass.alphaToCoverage);
  rs._setCullingMode(pass.cull);
  rs.setShadingType(pass.shading);
}

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 默认 Pass 应用到全新 RenderSystem:状态被完整转发
  Pass def;
  GL3RenderSystem rs1;
  _setPass(def, rs1);
  CHECK(rs1.state.depthCheck == true);
  CHECK(rs1.state.depthWrite == true);
  CHECK(rs1.state.depthFunc == CMPF_LESS_EQUAL);
  CHECK(rs1.state.cull == CULL_CLOCKWISE);
  CHECK(rs1.state.alphaFunc == CMPF_ALWAYS_PASS);
  CHECK(rs1.state.shading == SO_GOURAUD);
  CHECK(rs1.state.blend.sourceFactor == SBF_ONE);
  CHECK(rs1.state.blend.destFactor == SBF_ZERO);
  CHECK(rs1.state.setterCalls == 6);  // 6 个状态 setter(默认 Pass 无纹理单元)

  // 修改 Pass 后重新应用:RenderSystem 状态跟随更新
  Pass glow = def;
  glow.blend.sourceFactor = SBF_SOURCE_ALPHA;
  glow.blend.destFactor = SBF_ONE_MINUS_SOURCE_ALPHA;
  glow.cull = CULL_NONE;
  glow.depthWrite = false;
  glow.alphaFunc = CMPF_LESS_EQUAL;
  glow.alphaValue = 128;
  glow.alphaToCoverage = true;
  glow.shading = SO_PHONG;
  _setPass(glow, rs1);
  CHECK(rs1.state.blend.sourceFactor == SBF_SOURCE_ALPHA);
  CHECK(rs1.state.blend.destFactor == SBF_ONE_MINUS_SOURCE_ALPHA);
  CHECK(rs1.state.cull == CULL_NONE);
  CHECK(rs1.state.depthWrite == false);
  CHECK(rs1.state.alphaFunc == CMPF_LESS_EQUAL);
  CHECK(rs1.state.alphaValue == 128);
  CHECK(rs1.state.alphaToCoverage == true);
  CHECK(rs1.state.shading == SO_PHONG);

  // 纹理单元:先逐个启用,再统一禁用多余单元
  Pass textured = def;
  textured.texUnits.push_back(TextureUnitSettings(0));
  textured.texUnits.push_back(TextureUnitSettings(1));
  GL3RenderSystem rs2;
  _setPass(textured, rs2);
  CHECK(rs2.state.texUnitActive[0] == true);
  CHECK(rs2.state.texUnitActive[1] == true);
  CHECK(rs2.state.texUnitActive[2] == false);  // 从 getNumTextureUnitStates()=2 起禁用
  CHECK(rs2.state.texUnitActive[3] == false);

  // 三个纹理单元:0/1/2 启用,3 保持禁用
  textured.texUnits.push_back(TextureUnitSettings(2));
  _setPass(textured, rs2);
  CHECK(rs2.state.texUnitActive[0] == true);
  CHECK(rs2.state.texUnitActive[1] == true);
  CHECK(rs2.state.texUnitActive[2] == true);
  CHECK(rs2.state.texUnitActive[3] == false);

  // 两个 RenderSystem 实例状态互不影响(后端各自持有已应用状态)
  GL3RenderSystem rs3;
  CHECK(rs3.state.cull == CULL_NONE);  // 全新实例未应用任何 Pass
  _setPass(glow, rs3);
  CHECK(rs3.state.cull == CULL_NONE);
  CHECK(rs1.state.cull == CULL_NONE);  // rs1 上次也是 CULL_NONE
  _setPass(def, rs3);
  CHECK(rs3.state.cull == CULL_CLOCKWISE);
  CHECK(rs1.state.cull == CULL_NONE);  // rs1 不被 rs3 影响

  return lab::report("04-3 状态应用到 RenderSystem");
}

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

小结

  • RenderSystem 把混合/深度/剔除/Alpha 剔除声明成纯虚 setter,具体后端负责翻译成 API 调用。
  • SceneManager::_setPass 按固定顺序转发:程序 → 雾 → 混合 → 点/线 → 纹理单元 → 深度 → Alpha 剔除 → 剔除 → 着色。
  • 纹理单元「先逐个启用、再统一禁用」;深度与剔除参数直接从 Pass getter 取。
  • 阴影阶段有剔除翻转特例:纹理阴影贴图渲染背面以改善深度比较。
  • 后端各自维护「已应用状态」,同一个 Pass 可对多个后端反复应用。

阅读导航:上一节:4.2 Technique 状态合并 · 下一节:5.1 渲染队列 RenderQueue 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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