《OGRE 3D 渲染引擎原理与架构》12.3 RTT 使用流程

RTT 完整流程:TextureManager::createTexture(TU_RENDERTARGET) 建纹理,Texture::getBuffer 拿 HardwarePixelBuffer,getRenderTarget 得到 RenderTexture,加 viewport 后由 RenderSystem::setDepthBufferFor 按池 id/FSAA/尺寸找兼容深度缓冲并 attach,找不到就 _createDepthBufferFor 新建。attachDepthBuffer 依赖 isCompatible 检查,detach 双向清理登记。lab 复现深度缓冲池的查找、挂接与批量清理。

12.3 RTT 使用流程

12.1 讲了 RenderTexture 本体,12.2 讲了 MultiRenderTarget,这一节把「画进纹理」从创建到渲染串成一条完整流程。核心是两点:从 Texture 到 RenderTexture 的创建链(前两节的 getRenderTarget 是它的中间站),以及深度缓冲池的查找与挂接(RenderSystem::setDepthBufferFor 是入口)。

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

helio 四卷在 FBO 创建时同步管理深度附件;OGRE 把深度缓冲与渲染目标解耦成「池」。本节聚焦 RTT 使用流程与深度池分配,深度缓冲本身的完整机制由 13.1《深度缓冲》展开。本节不再重复 12.1 的 slice 表与 12.2 的绑定策略。

从纹理到渲染目标:完整创建链

一个典型 RTT 的生命周期:

步骤调用产物
1TextureManager::createTexture(name, group, w, h, 0, fmt, TU_RENDERTARGET)可作渲染目标的 Texture
2Texture::getBuffer()HardwarePixelBuffer(纹理的像素缓冲)
3buffer->getRenderTarget()RenderTexture(宽高来自 buffer,见 12.1)
4rt->addViewport(camera)给 RTT 挂相机视口(Z 序见 11.1)
5Root::getRenderSystem()->setDepthBufferFor(rt) 或 rt->setDepthBufferPool(id)深度缓冲池挂接
6rt->update()三段式更新:_beginUpdate → _updateAutoUpdatedViewports → _endUpdate(11.1)

步骤 3 要求纹理以 TU_RENDERTARGET 用途创建,否则 getRenderTarget 直接断言失败(assert(mUsage & TU_RENDERTARGET),见 12.1 摘录)。步骤 5 是本节重点。

RenderSystem::setDepthBufferFor:池的查找与创建

RenderSystem::setDepthBufferFor 是深度缓冲池分配的统一入口。它按池 id、FSAA(必要时加宽高)算出 poolId,先在池里找兼容的深度缓冲 attach,找不到就调用纯虚的 _createDepthBufferFor 新建:

// OgreMain/src/OgreRenderSystem.cpp:RenderSystem::setDepthBufferFor(v14.6.3 源码摘录,已删减)
    void RenderSystem::setDepthBufferFor( RenderTarget *renderTarget )
    {
        uint16 poolNum = renderTarget->getDepthBufferPool();
        if( poolNum == RBP_NONE )
            return; //RenderTarget explicitly requested no depth buffer

        uint32 poolId = HashCombine(0, poolNum);
        poolId = HashCombine(poolId, renderTarget->getFSAA());

        if(!getCapabilities()->hasCapability(RSC_RTT_INDEPENDENT_BUFFER_SIZE))
        {
            //Depth buffer must be EXACT same size as RT
            poolId = HashCombine(poolId, renderTarget->getWidth());
            poolId = HashCombine(poolId, renderTarget->getHeight());
        }

        //Find a depth buffer in the pool
        bool bAttached = false;
        for (auto& d : mDepthBufferPool[poolId]) {
            bAttached = renderTarget->attachDepthBuffer(d);
            if (bAttached) break;
        }

        //Not found yet? Create a new one!
        if( !bAttached )
        {
            DepthBuffer *newDepthBuffer = _createDepthBufferFor( renderTarget );

            if( newDepthBuffer )
            {
                mDepthBufferPool[poolId].push_back( newDepthBuffer );

                bAttached = renderTarget->attachDepthBuffer( newDepthBuffer );

                OgreAssert( bAttached ,"A new DepthBuffer for a RenderTarget was created, but after creation"
                                     " it says it's incompatible with that RT" );
            }
        }
    }
机制含义
poolNum == RBP_NONE 提前返回目标显式不要深度缓冲(如深度纹理 RTT,见 12.1 构造器)
HashCombine 组 keypoolNum + FSAA (+ 宽高);无 RSC_RTT_INDEPENDENT_BUFFER_SIZE 时深度缓冲必须与 RT 完全同尺寸
遍历 mDepthBufferPool[poolId]复用池里已有深度缓冲,attachDepthBuffer 返回 true 即命中
未命中则 _createDepthBufferFor新建后入池再 attach,断言新缓冲必与目标兼容

attach 与 detach:双向登记

attachDepthBuffer 的入口条件由 DepthBuffer::isCompatible 把关:宽度、高度不小于目标,且 FSAA 相同。兼容则先 detach 旧的,再挂新的,并让新缓冲登记目标:

// OgreMain/src/OgreRenderTarget.cpp:attachDepthBuffer/detachDepthBuffer(v14.6.3 源码摘录,已删减)
    bool RenderTarget::attachDepthBuffer( DepthBuffer *depthBuffer )
    {
        bool retVal = false;

        if( (retVal = depthBuffer->isCompatible( this )) )
        {
            detachDepthBuffer();
            mDepthBuffer = depthBuffer;
            mDepthBuffer->_notifyRenderTargetAttached( this );
        }

        return retVal;
    }
    //-----------------------------------------------------------------------
    void RenderTarget::detachDepthBuffer()
    {
        if( mDepthBuffer )
        {
            mDepthBuffer->_notifyRenderTargetDetached( this );
            _detachDepthBuffer();
        }
    }

isCompatible 的比较逻辑,以及 _notifyRenderTargetAttached/_notifyRenderTargetDetached 对 mAttachedRenderTargets 集合的插入/删除,就是深度缓冲跟踪「谁挂着我」的方式:

// OgreMain/src/OgreDepthBuffer.cpp:兼容检查与登记(v14.6.3 源码摘录,已删减)
    bool DepthBuffer::isCompatible( RenderTarget *renderTarget ) const
    {
        if( this->getWidth() >= renderTarget->getWidth() &&
            this->getHeight() >= renderTarget->getHeight() &&
            this->getFSAA() == renderTarget->getFSAA() )
        {
            return true;
        }

        return false;
    }
    //-----------------------------------------------------------------------
    void DepthBuffer::_notifyRenderTargetAttached( RenderTarget *renderTarget )
    {
        assert( mAttachedRenderTargets.find( renderTarget ) == mAttachedRenderTargets.end() );

        mAttachedRenderTargets.insert( renderTarget );
    }
    //-----------------------------------------------------------------------
    void DepthBuffer::_notifyRenderTargetDetached( RenderTarget *renderTarget )
    {
        RenderTargetSet::iterator itor = mAttachedRenderTargets.find( renderTarget );
        assert( itor != mAttachedRenderTargets.end() );

        mAttachedRenderTargets.erase( itor );
    }

配套的两个动作:

  • RenderTarget::setDepthBufferPool(poolId):池 id 变化时自动 detachDepthBuffer()(OgreRenderTarget.cpp 85-92),避免旧深度缓冲悬空。
  • DepthBuffer::detachFromAllRenderTargets():遍历 mAttachedRenderTargets,逐个调目标的 _detachDepthBuffer() 后清空集合(OgreDepthBuffer.cpp 104-110)。手动深度缓冲在 RenderSystem 析构时走这条路径批量释放。

RTT 创建、挂接和消费

flowchart TD
  A["TextureManager 创建带 RTT 用途的 Texture"] --> B["后端分配纹理硬件资源"]
  B --> C["HardwarePixelBuffer 按 slice 提供 RenderTexture"]
  C --> D["RenderSystem 登记目标"]
  D --> E["挂 Viewport,按需分配深度缓冲"]
  E --> F["按优先级更新到纹理"]
  F --> G["后续 Pass 从纹理采样"]
  C -.-> H["销毁时清除 slice 引用并摘除目标"]

把中间纹理的写入和采样连成一帧

从 Texture 到 HardwarePixelBuffer,再按 slice 取得 RenderTexture 并挂视口。第一次目标更新写入像素,后续 Pass 采样同一资源。目标在调度中的优先级和明确更新时点决定采样看到哪一帧。

验收固定色块或梯度的写入,再从采样结果比较像素。尺寸变化要检查目标、视口与深度附件一起更新。Tiny 场景的窗口读回用于基础绘制,RTT 能力依具体后端验证。

渲染纹理的生产者和消费者

flowchart LR
  T["Texture 资源"] --> B["HardwarePixelBuffer"]
  B -->|"按 slice 关联"| R["RenderTexture"]
  R -->|"拥有"| V["写入视口"]
  S["后端 RenderSystem"] -->|"按目标调度"| R
  V -->|"写颜色与深度"| R
  R -->|"产出同一纹理数据"| T
  T -.->|"采样输入"| P["后续材质 Pass"]
  P --> O["另一输出目标"]

用Metal 两级离屏实验 观察写红、采样转绿和移除源对象后清黑。两张纹理分别作为不同目标,更新顺序由宿主显式安排。

源码定位

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

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

下面用纯 C++ 复现 RTT 深度缓冲池挂接环节:isCompatible 的宽高/FSAA 比较、attachDepthBuffer 的兼容才挂与双向登记、换缓冲时旧登记的清理、detachDepthBuffer 置空、setDepthBufferPool 池变化自动 detach、detachFromAllRenderTargets 批量清空。它与 src/12-3-rtt-pipeline.cpp 逐字节一致:

// file: src/12-3-rtt-pipeline.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/12-3-rtt-pipeline.cpp -o bin/12-3-rtt-pipeline && ./bin/12-3-rtt-pipeline
//
// 复现渲染纹理的深度缓冲池挂接环节(对应 OgreMain/src/OgreRenderTarget.cpp 85-115、
// OgreMain/include/OgreDepthBuffer.h 76-147 与 OgreMain/src/OgreDepthBuffer.cpp 72-110):
//   RenderTarget::attachDepthBuffer 先查 DepthBuffer::isCompatible(宽高 >= 目标且 FSAA 相等),
//   兼容则 detach 旧的、挂新的并 _notifyRenderTargetAttached;
//   detachDepthBuffer 通知 DepthBuffer 移除登记后 _detachDepthBuffer 置空;
//   setDepthBufferPool 池 id 变化时自动 detach;
//   DepthBuffer::detachFromAllRenderTargets 批量清空所有挂接。
//   RTT 完整流程:TextureManager::createTexture(TU_RENDERTARGET) -> Texture::getBuffer
//   -> HardwarePixelBuffer::getRenderTarget -> RenderTexture -> addViewport(camera)
//   -> attachDepthBuffer / setDepthBufferPool -> update()。本 lab 聚焦深度缓冲池环节。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <set>

namespace ogre_repro {

enum : uint16_t { RBP_NONE = 0, RBP_DEFAULT = 1 };  // OgreCommon.h:136-138

class RenderTarget;

// 对应 DepthBuffer(OgreDepthBuffer.h 76-147)
class DepthBuffer {
 public:
  DepthBuffer(uint16_t poolId, uint32_t w, uint32_t h, uint32_t fsaa, bool manual)
      : mPoolId(poolId), mWidth(w), mHeight(h), mFsaa(fsaa), mManual(manual) {}

  uint16_t getPoolId() const { return mPoolId; }
  uint32_t getWidth() const { return mWidth; }
  uint32_t getHeight() const { return mHeight; }
  uint32_t getFSAA() const { return mFsaa; }
  bool isManual() const { return mManual; }

  // 对应 isCompatible(OgreDepthBuffer.cpp 77-87)
  bool isCompatible(RenderTarget* rt) const;

  // 对应 _notifyRenderTargetAttached / _notifyRenderTargetDetached(89-102)
  void _notifyRenderTargetAttached(RenderTarget* rt);
  void _notifyRenderTargetDetached(RenderTarget* rt);

  // 对应 detachFromAllRenderTargets(104-110)
  void detachFromAllRenderTargets();

  size_t getAttachedCount() const { return mAttachedRenderTargets.size(); }
  bool isAttached(RenderTarget* rt) const { return mAttachedRenderTargets.count(rt) > 0; }

 private:
  uint16_t mPoolId;
  uint32_t mWidth, mHeight, mFsaa;
  bool mManual;
  std::set<RenderTarget*> mAttachedRenderTargets;
};

// RenderTarget 最小子集(含深度缓冲池,OgreRenderTarget.cpp 85-115)
class RenderTarget {
 public:
  RenderTarget(uint32_t w, uint32_t h, uint32_t fsaa) : mWidth(w), mHeight(h), mFsaa(fsaa) {}

  uint32_t getWidth() const { return mWidth; }
  uint32_t getHeight() const { return mHeight; }
  uint32_t getFSAA() const { return mFsaa; }
  uint16_t getDepthBufferPoolId() const { return mDepthBufferPoolId; }
  DepthBuffer* getDepthBuffer() const { return mDepthBuffer; }

  // 对应 setDepthBufferPool(OgreRenderTarget.cpp 85-92)
  void setDepthBufferPool(uint16_t poolId) {
    if (mDepthBufferPoolId != poolId) {
      mDepthBufferPoolId = poolId;
      detachDepthBuffer();
    }
  }

  // 对应 attachDepthBuffer(94-106)
  bool attachDepthBuffer(DepthBuffer* depthBuffer) {
    bool retVal = false;
    if ((retVal = depthBuffer->isCompatible(this))) {
      detachDepthBuffer();
      mDepthBuffer = depthBuffer;
      mDepthBuffer->_notifyRenderTargetAttached(this);
    }
    return retVal;
  }

  // 对应 detachDepthBuffer(108-115)
  void detachDepthBuffer() {
    if (mDepthBuffer) {
      mDepthBuffer->_notifyRenderTargetDetached(this);
      _detachDepthBuffer();
    }
  }

  void _detachDepthBuffer() { mDepthBuffer = nullptr; }

 private:
  uint32_t mWidth, mHeight, mFsaa;
  uint16_t mDepthBufferPoolId = RBP_DEFAULT;
  DepthBuffer* mDepthBuffer = nullptr;
};

// RenderTexture 最小子集(12-1 完整版已见)
class RenderTexture : public RenderTarget {
 public:
  RenderTexture(uint32_t w, uint32_t h, uint32_t fsaa) : RenderTarget(w, h, fsaa) {}
};

bool DepthBuffer::isCompatible(RenderTarget* rt) const {
  if (mWidth >= rt->getWidth() && mHeight >= rt->getHeight() && mFsaa == rt->getFSAA())
    return true;
  return false;
}

void DepthBuffer::_notifyRenderTargetAttached(RenderTarget* rt) {
  mAttachedRenderTargets.insert(rt);
}

void DepthBuffer::_notifyRenderTargetDetached(RenderTarget* rt) {
  mAttachedRenderTargets.erase(rt);
}

void DepthBuffer::detachFromAllRenderTargets() {
  for (RenderTarget* r : mAttachedRenderTargets) r->_detachDepthBuffer();
  mAttachedRenderTargets.clear();
}

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 两个 RTT 目标(12-1 的 getRenderTarget 产物):256x256、无 FSAA
  RenderTexture rttA(256, 256, 0);
  RenderTexture rttB(256, 256, 0);

  // 默认池里的深度缓冲:512x512、无 FSAA、由池自动管理(非手动)
  DepthBuffer poolDepth(1, 512, 512, 0, false);
  CHECK(poolDepth.getPoolId() == 1);
  CHECK(poolDepth.getWidth() == 512);
  CHECK(poolDepth.getHeight() == 512);
  CHECK(poolDepth.getFSAA() == 0);
  CHECK(!poolDepth.isManual());

  // isCompatible:宽高 >= 目标且 FSAA 相等
  CHECK(poolDepth.isCompatible(&rttA));

  // 目标比深度缓冲大 -> 不兼容
  RenderTexture huge(1024, 1024, 0);
  CHECK(!poolDepth.isCompatible(&huge));

  // FSAA 不同 -> 不兼容
  DepthBuffer msaaDepth(1, 512, 512, 4, false);
  RenderTexture msaaRtt(512, 512, 4);
  CHECK(!msaaDepth.isCompatible(&rttA));
  CHECK(msaaDepth.isCompatible(&msaaRtt));

  // attachDepthBuffer:挂载成功 + DepthBuffer 登记
  CHECK(rttA.attachDepthBuffer(&poolDepth));
  CHECK(rttA.getDepthBuffer() == &poolDepth);
  CHECK(poolDepth.isAttached(&rttA));
  CHECK(poolDepth.getAttachedCount() == 1);

  // 第二个 RTT 共享同一深度缓冲(同尺寸无 FSAA)
  CHECK(rttB.attachDepthBuffer(&poolDepth));
  CHECK(poolDepth.getAttachedCount() == 2);

  // 换一个新的深度缓冲:旧缓冲移除登记、新缓冲登记,旧引用被 detach
  DepthBuffer poolDepth2(1, 256, 256, 0, true);  // 手动深度缓冲
  CHECK(poolDepth2.isManual());
  CHECK(rttA.attachDepthBuffer(&poolDepth2));
  CHECK(!poolDepth.isAttached(&rttA));
  CHECK(poolDepth.getAttachedCount() == 1);  // 只剩 rttB
  CHECK(poolDepth2.isAttached(&rttA));
  CHECK(rttA.getDepthBuffer() == &poolDepth2);

  // 不兼容的 attach 被拒绝:mDepthBuffer 不变
  RenderTexture tooBig(1024, 1024, 0);
  CHECK(!tooBig.attachDepthBuffer(&poolDepth2));
  CHECK(tooBig.getDepthBuffer() == nullptr);

  // detachDepthBuffer:清引用 + 移除登记
  rttB.detachDepthBuffer();
  CHECK(rttB.getDepthBuffer() == nullptr);
  CHECK(!poolDepth.isAttached(&rttB));
  CHECK(poolDepth.getAttachedCount() == 0);

  // setDepthBufferPool 池 id 变化 -> 自动 detach
  rttA.setDepthBufferPool(5);
  CHECK(rttA.getDepthBufferPoolId() == 5);
  CHECK(rttA.getDepthBuffer() == nullptr);
  CHECK(!poolDepth2.isAttached(&rttA));

  // 同一池 id 不变 -> 不触发 detach
  rttA.setDepthBufferPool(5);
  CHECK(rttA.getDepthBuffer() == nullptr);

  // detachFromAllRenderTargets:批量清空所有挂接
  RenderTexture rttC(256, 256, 0);
  RenderTexture rttD(256, 256, 0);
  DepthBuffer shared(1, 512, 512, 0, false);
  rttC.attachDepthBuffer(&shared);
  rttD.attachDepthBuffer(&shared);
  CHECK(shared.getAttachedCount() == 2);
  shared.detachFromAllRenderTargets();
  CHECK(shared.getAttachedCount() == 0);
  CHECK(rttC.getDepthBuffer() == nullptr);
  CHECK(rttD.getDepthBuffer() == nullptr);

  // 默认池 id:RBP_DEFAULT(1)
  CHECK(rttC.getDepthBufferPoolId() == RBP_DEFAULT);
  CHECK(RBP_NONE == 0);

  return lab::report("12-3 RTT 使用流程");
}

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

小结

  • RTT 完整链:createTexture(TU_RENDERTARGET) → getBuffer() → getRenderTarget() → addViewport() → setDepthBufferFor() → update()。
  • RenderSystem::setDepthBufferFor 按 poolNum + FSAA (+ 宽高) 组池 key,先复用池中兼容缓冲,未命中则 _createDepthBufferFor 新建。
  • RenderTarget 默认深度池 RBP_DEFAULT = 1,RBP_NONE = 0 表示不要深度缓冲。
  • attachDepthBuffer 以 isCompatible(宽高不小于目标且 FSAA 相等)为前提,挂接时双向登记。
  • detachDepthBuffer 通知深度缓冲移除登记后置空;setDepthBufferPool 池变化自动 detach;detachFromAllRenderTargets 批量清空。

阅读导航:上一节:12.2 多渲染目标 · 下一节:13.1 深度缓冲 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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