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 的生命周期:
| 步骤 | 调用 | 产物 |
|---|---|---|
| 1 | TextureManager::createTexture(name, group, w, h, 0, fmt, TU_RENDERTARGET) | 可作渲染目标的 Texture |
| 2 | Texture::getBuffer() | HardwarePixelBuffer(纹理的像素缓冲) |
| 3 | buffer->getRenderTarget() | RenderTexture(宽高来自 buffer,见 12.1) |
| 4 | rt->addViewport(camera) | 给 RTT 挂相机视口(Z 序见 11.1) |
| 5 | Root::getRenderSystem()->setDepthBufferFor(rt) 或 rt->setDepthBufferPool(id) | 深度缓冲池挂接 |
| 6 | rt->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 组 key | poolNum + 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.cpp85-92),避免旧深度缓冲悬空。DepthBuffer::detachFromAllRenderTargets():遍历mAttachedRenderTargets,逐个调目标的_detachDepthBuffer()后清空集合(OgreDepthBuffer.cpp104-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 两级离屏实验 观察写红、采样转绿和移除源对象后清黑。两张纹理分别作为不同目标,更新顺序由宿主显式安排。
源码定位
OgreMain/src/OgreRenderSystem.cpp:RenderSystem::setDepthBufferFor(512-553)OgreMain/src/OgreRenderTarget.cpp:setDepthBufferPool(85-92)、attachDepthBuffer(94-106)、detachDepthBuffer(108-115)OgreMain/include/OgreRenderTarget.h:FrameBuffer枚举(82-87)、attachDepthBuffer声明(115)、detachDepthBuffer(117)、_detachDepthBuffer(123)OgreMain/src/OgreDepthBuffer.cpp:isManual(72-75)、isCompatible(77-87)、_notifyRenderTargetAttached(89-94)、_notifyRenderTargetDetached(96-102)、detachFromAllRenderTargets(104-110)OgreMain/include/OgreDepthBuffer.h:类注释与池语义(62-75)、class _OgreExport DepthBuffer(76-147)、isCompatible(112)、登记接口(121-128)OgreMain/include/OgreCommon.h:RenderBufferPool枚举RBP_NONE = 0 / RBP_DEFAULT = 1(132-139)OgreMain/include/OgreRenderSystem.h:setDepthBufferFor声明(499-504)、mDepthBufferPool(1137)
上游引用固定到 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 深度缓冲 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。