《OGRE 3D 渲染引擎原理与架构》14.2 子渲染状态

子渲染状态(SubRenderState)把一段着色器功能(变换、颜色、光照、纹理、雾)建模成可排序单元:getType 返回唯一类型名,getExecutionOrder 对齐 FFPShaderStage 阶段常量;RenderState::addTemplateSubRenderState 收集模板子状态,同类型覆盖、其余按执行顺序排序。源码在 Components/RTShaderSystem/ 的 OgreShaderSubRenderState.h、OgreShaderFFPRenderState.h 与 OgreShaderRenderState.cpp。lab 复现阶段枚举、排序与同类型覆盖。

14.2 子渲染状态

14.1 看到 RTSS 用工厂注册子渲染状态。这一节看子状态本身:它是什么、怎么决定在生成着色器里的位置、RenderState 怎么把它们收集成一段程序。RTSS 把 FFP 功能拆成「阶段」——变换、颜色、光照、纹理、雾——每个阶段是一个 SubRenderState,执行顺序由阶段常量保证。

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

卷二 3.x 讲 GPU 程序的 shader 语言与绑定;本卷 14.1 讲了 ShaderGenerator 的工厂注册。这一节的 SubRenderState 是 RTSS 对「一段着色器逻辑」的抽象:它不是最终 GLSL/HLSL,而是一个中间表示(CPU 侧对象),在生成阶段展开成 Function 与 FunctionInvocation。本卷 15 章才回到场景对象本身。

FFP 阶段常量:执行顺序的锚点

FFPShaderStage 定义在 OgreShaderFFPRenderState.h,通用阶段值把顶点与片段的阶段对齐:

// Components/RTShaderSystem/include/OgreShaderFFPRenderState.h:FFPVertexShaderStage / FFPShaderStage(v14.6.3 源码摘录,已删减)
// Fixed Function vertex shader stages.
enum FFPVertexShaderStage
{
    FFP_VS_PRE_PROCESS                  = 0,    
    FFP_VS_TRANSFORM                    = 100,
    FFP_VS_COLOUR                       = 200,
    FFP_VS_LIGHTING                     = 300,
    FFP_VS_TEXTURING                    = 400,      
    FFP_VS_FOG                          = 500,  
    FFP_VS_POST_PROCESS                 = 2000
};
...
// Fixed Function generic stages.
enum FFPShaderStage
{
    FFP_PRE_PROCESS                     = 0,    
    FFP_TRANSFORM                       = 100,  
    FFP_COLOUR                          = 200,  
    FFP_LIGHTING                        = 300,
    FFP_TEXTURING                       = 400,
    FFP_FOG                             = 500,
    FFP_POST_PROCESS                    = 600,
	FFP_ALPHA_TEST						= 1000
};

阶段值不是连续整数,而是百位对齐的锚点(100、200、300…),中间留空给扩展。任何一个子渲染状态的 getExecutionOrder() 都必须与这些值同步——这样无论按什么顺序加入,排序后总能得到「transform → colour → lighting → texturing → fog」的固定管线顺序。

SubRenderState:一段着色器功能的基类

SubRenderState 是 RTSS 里所有子状态的基类。它要求的核心契约只有三个纯虚方法:

// Components/RTShaderSystem/include/OgreShaderSubRenderState.h:SubRenderState(v14.6.3 源码摘录,已删减)
class _OgreRTSSExport SubRenderState : public RTShaderSystemAlloc
{

// Interface.
public:

    /** Class default constructor */
    SubRenderState();

    /** Class destructor */
    virtual ~SubRenderState();


    /** Get the type of this sub render state.

    The type string should be unique among all registered sub render states.    
    */
    virtual const String& getType() const = 0;


    /** Get the execution order of this sub render state.

    The return value should be synchronized with the predefined values
    of the FFPShaderStage enum.
    */
    virtual int getExecutionOrder() const = 0;


    /** Copy details from a given sub render state to this one.
    @param rhs the source sub state to copy from.   
    */
    virtual void copyFrom(const SubRenderState& rhs) = 0;
  • getType():唯一类型名,与工厂注册表的键一致。
  • getExecutionOrder():与 FFPShaderStage 对齐的执行顺序。
  • copyFrom:材质继承时复制参数。

除此之外,SubRenderState 还提供两个重要的钩子:createCpuSubPrograms(ProgramSet*) 在生成阶段把自身展开成 CPU 程序(往 Program 里加 Function);preAddToRenderState 在目标渲染状态组装时被调用,返回 false 可取消本次加入——它常用来检查源 pass 是否真的启用了某功能(例如没有纹理就不加纹理阶段)。

FFP 的具体状态实现都派生自它。FFP 光照位于 src/(核心着色器编译条件开启才可用):

// Components/RTShaderSystem/src/OgreShaderFFPLighting.h:FFPLighting(v14.6.3 源码摘录,已删减)
class FFPLighting : public SubRenderState
{

// Interface.
public:
    
    /** Class default constructor */
    FFPLighting();

    /** 
    @see SubRenderState::getType.
    */
    const String& getType() const override;

    /** 
    @see SubRenderState::getType.
    */
    int getExecutionOrder() const override;

    /** 
    @see SubRenderState::copyFrom.
    */
    void copyFrom(const SubRenderState& rhs) override;

    /** 
    @see SubRenderState::preAddToRenderState.
    */
    bool preAddToRenderState(const RenderState* renderState, Pass* srcPass, Pass* dstPass) override;

FFP 雾则额外暴露计算模式枚举(逐顶点/逐像素):

// Components/RTShaderSystem/src/OgreShaderFFPFog.h:FFPFog(v14.6.3 源码摘录,已删减)
class FFPFog : public SubRenderState
{
public:

    // Fog calculation mode enum.
    enum CalcMode
    {
        CM_PER_VERTEX   = 1,        // Per vertex fog calculations. (Default).
        CM_PER_PIXEL    = 2         // Per pixel fog calculations.
    };

// Interface.
public:

    /** Class default constructor */
    FFPFog();

    /** 
    @see SubRenderState::getType.
    */
    const String& getType() const override;

    /** 
    @see SubRenderState::getType.
    */
    int getExecutionOrder() const override;

    /** 
    @see SubRenderState::copyFrom.
    */
    void copyFrom(const SubRenderState& rhs) override;

同类实现还有 FFPTransform、FFPColour、FFPTexturing、FFPAlphaTest;扩展机制(法线贴图、PBR、皮肤、三平面贴图……)同样派生自 SubRenderState。

RenderState:收集与排序

RenderState 是「一段生成程序的子状态集合」。addTemplateSubRenderState 的语义很关键:同类型覆盖,其余按执行顺序排序。

// Components/RTShaderSystem/src/OgreShaderRenderState.cpp:RenderState::addTemplateSubRenderState(v14.6.3 源码摘录,已删减)
void RenderState::addTemplateSubRenderState(SubRenderState* subRenderState)
{
    bool addSubRenderState = true;

    // Go over the current sub render state.
    for (auto & it : mSubRenderStateList)
    {
        // Case the same instance already exists -> do not add to list.
        if (it == subRenderState)
        {
            addSubRenderState = false;
            break;
        }

        // Case it is different sub render state instance with the same type, use the new sub render state
        // instead of the previous sub render state. This scenario is usually caused by material inheritance, so we use the derived material sub render state
        // and destroy the base sub render state.
        else if (it->getType() == subRenderState->getType())
        {
            removeSubRenderState(it);
            break;
        }
    }

    // Add only if this sub render state instance is not on the list.
    if (addSubRenderState)
    {
        mSubRenderStateList.push_back(subRenderState);  
    }   
}

三条规则:

  • 同一实例重复加入 → 忽略。
  • 不同实例但类型相同 → 用新实例替换旧实例(材质继承时,派生材质覆盖基材质的子状态)。
  • 类型不同 → 追加进列表,之后整体按 getExecutionOrder() 排序。

排序后 mSubRenderStateList 里的顺序就是生成程序里的顺序。这个顺序保证上下游依赖:FFPLighting 产出插值后的光照颜色,FFPTexturing 乘上纹理,FFPFog 最后混合——阶段常量的大小关系恰好编码了依赖方向。

源码定位

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

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

下面用纯 C++ 复现子渲染状态的执行顺序:阶段枚举常量、具体 FFP 状态的 getExecutionOrder、RenderState 的同类型覆盖与排序、preAddToRenderState 返回 false 时的取消加入。它与 src/14-2-shader-sub-render-state.cpp 逐字节一致:

// file: src/14-2-shader-sub-render-state.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/14-2-shader-sub-render-state.cpp -o bin/14-2-shader-sub-render-state && ./bin/14-2-shader-sub-render-state
//
// 复现 RTSS 子渲染状态与其执行顺序(对应 Components/RTShaderSystem/include/
// OgreShaderSubRenderState.h 87-209 与 OgreShaderFFPRenderState.h 42-80,以及
// OgreShaderFFPLighting.cpp 56-58、OgreShaderFFPFog.cpp 52-54 的 getExecutionOrder):
//   FFP 顶点/片段/通用三套阶段枚举值;
//   SubRenderState 基类:getType / getExecutionOrder;
//   FFP 状态类按固定顺序排序(transform -> colour -> lighting -> texturing -> fog);
//   RenderState 收集模板子状态:同类型覆盖、其余按执行顺序排序;
//   lighting -> texturing -> fog 的上下游依赖由执行顺序保证。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <algorithm>
#include <cstdint>
#include <string>
#include <vector>

namespace ogre_repro {

// 对应 OgreShaderFFPRenderState.h 42-52:固定功能顶点着色器阶段。
enum FFPVertexShaderStage {
  FFP_VS_PRE_PROCESS = 0,
  FFP_VS_TRANSFORM = 100,
  FFP_VS_COLOUR = 200,
  FFP_VS_LIGHTING = 300,
  FFP_VS_TEXTURING = 400,
  FFP_VS_FOG = 500,
  FFP_VS_POST_PROCESS = 2000
};

// 对应 OgreShaderFFPRenderState.h 69-80:固定功能通用阶段。
enum FFPShaderStage {
  FFP_PRE_PROCESS = 0,
  FFP_TRANSFORM = 100,
  FFP_COLOUR = 200,
  FFP_LIGHTING = 300,
  FFP_TEXTURING = 400,
  FFP_FOG = 500,
  FFP_POST_PROCESS = 600,
  FFP_ALPHA_TEST = 1000
};

// 对应 OgreShaderSubRenderState.h 87:子渲染状态基类。
class SubRenderState {
 public:
  SubRenderState(const std::string& type, int executionOrder)
      : mType(type), mExecutionOrder(executionOrder) {}
  virtual ~SubRenderState() {}
  const std::string& getType() const { return mType; }
  int getExecutionOrder() const { return mExecutionOrder; }

  // 对应 preAddToRenderState(157):返回 false 则取消加入。
  virtual bool preAddToRenderState() { return true; }

 protected:
  std::string mType;
  int mExecutionOrder;
};

// FFP 状态类:与 getExecutionOrder 返回值一致(FFPLighting.cpp 58 等)。
class FFPTransform : public SubRenderState {
 public:
  FFPTransform() : SubRenderState("FFP_Transform", FFP_TRANSFORM) {}
};
class FFPColour : public SubRenderState {
 public:
  FFPColour() : SubRenderState("FFP_Colour", FFP_COLOUR) {}
};
class FFPLighting : public SubRenderState {
 public:
  FFPLighting() : SubRenderState("FFP_Lighting", FFP_LIGHTING) {}
  bool preAddToRenderState() override { return mAllowed; }
  bool mAllowed = true;
};
class FFPTexturing : public SubRenderState {
 public:
  FFPTexturing() : SubRenderState("FFP_Texturing", FFP_TEXTURING) {}
};
class FFPFog : public SubRenderState {
 public:
  FFPFog() : SubRenderState("FFP_Fog", FFP_FOG) {}
};

// 对应 OgreShaderRenderState.h 68:收集并按执行顺序排序子状态。
class RenderState {
 public:
  // 同类型覆盖(后加入者替换先加入者),否则插入并排序。
  void addTemplateSubRenderState(SubRenderState* srs) {
    if (!srs->preAddToRenderState()) {
      delete srs;
      return;
    }
    for (size_t i = 0; i < mSubRenderStateList.size(); ++i) {
      if (mSubRenderStateList[i]->getType() == srs->getType()) {
        delete mSubRenderStateList[i];
        mSubRenderStateList[i] = srs;
        return;
      }
    }
    mSubRenderStateList.push_back(srs);
  }

  // 排序:按执行顺序升序。
  void sortByExecutionOrder() {
    std::stable_sort(mSubRenderStateList.begin(), mSubRenderStateList.end(),
                     [](const SubRenderState* a, const SubRenderState* b) {
                       return a->getExecutionOrder() < b->getExecutionOrder();
                     });
  }

  size_t size() const { return mSubRenderStateList.size(); }
  SubRenderState* operator[](size_t i) { return mSubRenderStateList[i]; }
  const std::string& typeAt(size_t i) const { return mSubRenderStateList[i]->getType(); }

  std::vector<SubRenderState*> mSubRenderStateList;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 三套阶段枚举值:顶点着色器与通用阶段一一对应
  CHECK_EQ(FFP_VS_TRANSFORM, 100);
  CHECK_EQ(FFP_VS_LIGHTING, 300);
  CHECK_EQ(FFP_VS_TEXTURING, 400);
  CHECK_EQ(FFP_VS_FOG, 500);
  CHECK_EQ(FFP_TRANSFORM, 100);
  CHECK_EQ(FFP_LIGHTING, 300);
  CHECK_EQ(FFP_TEXTURING, 400);
  CHECK_EQ(FFP_FOG, 500);
  CHECK(FFP_TRANSFORM < FFP_COLOUR);
  CHECK(FFP_COLOUR < FFP_LIGHTING);
  CHECK(FFP_LIGHTING < FFP_TEXTURING);
  CHECK(FFP_TEXTURING < FFP_FOG);

  // 具体 FFP 状态的执行顺序
  FFPLighting lighting;
  FFPTexturing texturing;
  FFPFog fog;
  CHECK_EQ(lighting.getExecutionOrder(), FFP_LIGHTING);
  CHECK_EQ(texturing.getExecutionOrder(), FFP_TEXTURING);
  CHECK_EQ(fog.getExecutionOrder(), FFP_FOG);
  CHECK(lighting.getType() == "FFP_Lighting");
  CHECK(texturing.getType() == "FFP_Texturing");

  // 打乱加入,排序后成为 lighting -> texturing -> fog 序列
  RenderState rs;
  rs.addTemplateSubRenderState(new FFPFog());
  rs.addTemplateSubRenderState(new FFPLighting());
  rs.addTemplateSubRenderState(new FFPTexturing());
  rs.addTemplateSubRenderState(new FFPTransform());
  rs.addTemplateSubRenderState(new FFPColour());
  rs.sortByExecutionOrder();
  CHECK_EQ(rs.size(), size_t(5));
  CHECK(rs.typeAt(0) == "FFP_Transform");
  CHECK(rs.typeAt(1) == "FFP_Colour");
  CHECK(rs.typeAt(2) == "FFP_Lighting");
  CHECK(rs.typeAt(3) == "FFP_Texturing");
  CHECK(rs.typeAt(4) == "FFP_Fog");

  // 同类型覆盖:后加入的 lighting 替换先加入的
  RenderState rs2;
  rs2.addTemplateSubRenderState(new FFPLighting());
  rs2.addTemplateSubRenderState(new FFPFog());
  FFPLighting* lighting2 = new FFPLighting();
  rs2.addTemplateSubRenderState(lighting2);
  CHECK_EQ(rs2.size(), size_t(2));
  CHECK(rs2[0] == lighting2);  // 同类型位置被替换
  CHECK_EQ(rs2[0]->getExecutionOrder(), FFP_LIGHTING);

  // preAddToRenderState 返回 false:取消加入
  RenderState rs3;
  FFPLighting* blocked = new FFPLighting();
  blocked->mAllowed = false;
  rs3.addTemplateSubRenderState(blocked);
  rs3.addTemplateSubRenderState(new FFPTexturing());
  CHECK_EQ(rs3.size(), size_t(1));
  CHECK(rs3.typeAt(0) == "FFP_Texturing");

  // 上下游依赖:fog 依赖 lighting 的输出,顺序保证 lighting 先执行
  CHECK(lighting.getExecutionOrder() < fog.getExecutionOrder());
  CHECK(texturing.getExecutionOrder() < fog.getExecutionOrder());

  // 清理 rs 中未释放的子状态(rs3/rs2 部分已由容器接管)
  for (auto* s : rs.mSubRenderStateList) delete s;
  for (auto* s : rs2.mSubRenderStateList) delete s;
  for (auto* s : rs3.mSubRenderStateList) delete s;

  return lab::report("14-2 子渲染状态");
}

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

小结

  • FFPShaderStage 用百位锚点(0/100/…/600)对齐顶点与片段的固定管线阶段。
  • SubRenderState 以 getType(唯一名)、getExecutionOrder(对齐阶段常量)、copyFrom 为纯虚契约。
  • FFP 光照/雾等具体状态在 src/,派生自 SubRenderState,用 preAddToRenderState 决定是否加入。
  • RenderState::addTemplateSubRenderState:同实例忽略、同类型覆盖(材质继承)、其余追加后按执行顺序排序。
  • 阶段常量的大小关系编码了光照 → 纹理 → 雾的上下游依赖。

阅读导航:上一节:14.1 RTSS 概览 · 下一节:14.3 RTSS 与场景集成 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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