《OGRE 3D 渲染引擎原理与架构》13.1 深度缓冲

DepthBuffer 抽象类承载深度/模板缓冲,成员只有池 ID、宽高、FSAA 与手动标记。isCompatible 用「宽高不小于目标且 FSAA 相同」判定可否附着;附着/摘除通过 mAttachedRenderTargets 集合双向通知。lab 复现兼容判定与附着集合维护。

13.1 深度缓冲

光栅化把三角形变成像素时,谁挡在前面、谁被覆盖,靠的是深度缓冲(z-buffer)。OGRE 把「深度缓冲 + 模板缓冲」打包成一个 DepthBuffer 抽象类:它只描述一块可附着到渲染目标的缓冲资源,不关心底层 API 里它是 FBO 的 depth attachment 还是 D3D 的 DSV。这一节逐字节看 DepthBuffer 的声明与实现,重点是它怎么判定「这块缓冲能不能给某张渲染目标用」。

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

卷一 6.2 讲过 ArchiveManager 的登记范式,这里 DepthBuffer 的「池 + 附着集合」是同一思想的资源侧表达;cg 三卷只讲深度测试的原理公式,这里讲 OGRE 里深度缓冲如何成为可复用的对象。与卷一 ogre-core 的 RenderTarget 相接:RenderTarget::attachDepthBuffer 是二者唯一的连接点。

DepthBuffer 类:字段与查询

// OgreMain/include/OgreDepthBuffer.h:DepthBuffer 类声明(v14.6.3 源码摘录,已删减)
    class _OgreExport DepthBuffer : public RenderSysAlloc
    {
    public:
        /// @deprecated use #RenderBufferPool instead
        enum PoolId
        {
            POOL_NO_DEPTH       = RBP_NONE,
            POOL_MANUAL_USAGE   = RBP_NONE,
            POOL_DEFAULT        = RBP_DEFAULT
        };

        DepthBuffer(uint16 poolId, uint32 width, uint32 height, uint32 fsaa, bool manual);
        virtual ~DepthBuffer();

        /// Gets the pool id in which this DepthBuffer lives
        virtual uint16 getPoolId() const;
        virtual uint32 getWidth() const;
        virtual uint32 getHeight() const;
        uint32 getFSAA() const { return mFsaa; }
        ...
    protected:
        typedef std::set<RenderTarget*> RenderTargetSet;

        uint16                      mPoolId;
        uint32                      mWidth;
        uint32                      mHeight;
        uint32                      mFsaa;

        bool                        mManual; //We don't Release manual surfaces on destruction
        RenderTargetSet             mAttachedRenderTargets;

        void detachFromAllRenderTargets();
    };

注意类里没有位深(bit depth)字段:位深信息由各后端在创建时决定,DepthBuffer 只记录几何形状(宽、高)与多重采样 mFsaa。池 ID 用 RBP_NONE/RBP_DEFAULT 三个别名(RenderBufferPool 枚举),POOL_NO_DEPTH 与 POOL_MANUAL_USAGE 在内部等价——都表示「OGRE 不托管,手动管理」。mAttachedRenderTargets 是附着它的渲染目标集合,detachFromAllRenderTargets 用于换池或析构时一次性解绑。

兼容判定与附着通知

构造函数把五个参数原样写进成员;isCompatible 是 DepthBuffer 能否被某张 RT 使用的唯一裁判:

// OgreMain/src/OgreDepthBuffer.cpp:DepthBuffer::isCompatible(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;
    }
条件含义
getWidth() >= rt->getWidth()缓冲必须不小于目标的宽
getHeight() >= rt->getHeight()缓冲必须不小于目标的高
getFSAA() == rt->getFSAA()多重采样档位必须完全一致

「宽高大于等于」而不是「等于」,是因为 API 允许大缓冲给小目标用(RSC_RTT_INDEPENDENT_BUFFER_SIZE 能力决定是否放宽这一条,见 13.3)。附着时是双向通知:RT 记下 mDepthBuffer,DepthBuffer 把 RT 记进自己的集合,摘除时对称地各删各的:

// OgreMain/src/OgreDepthBuffer.cpp:DepthBuffer::_notifyRenderTargetAttached/detachFromAllRenderTargets(v14.6.3 源码摘录,已删减)
    void DepthBuffer::_notifyRenderTargetAttached( RenderTarget *renderTarget )
    {
        assert( mAttachedRenderTargets.find( renderTarget ) == mAttachedRenderTargets.end() );

        mAttachedRenderTargets.insert( renderTarget );
    }
    //-----------------------------------------------------------------------
    void DepthBuffer::detachFromAllRenderTargets()
    {
        for (auto *r : mAttachedRenderTargets)
            r->_detachDepthBuffer();

        mAttachedRenderTargets.clear();
    }

assert 保证同一张 RT 不会重复入集;detachFromAllRenderTargets 遍历时直接调 r->_detachDepthBuffer()——注意是带下划线的不通知版本,避免遍历中再改集合。这个「遍历中只做单向操作」的细节,是 _detachDepthBuffer(不通知)与 detachDepthBuffer(通知)两个名字存在的原因。

源码定位

  • OgreMain/include/OgreDepthBuffer.h :DepthBuffer 类声明(76-142),含 PoolId 枚举(80-85)、成员 mPoolId/mWidth/mHeight/mFsaa/mManual/mAttachedRenderTargets(133-139)、detachFromAllRenderTargets(141)
  • OgreMain/src/OgreDepthBuffer.cpp :构造函数(32-40)、isCompatible(77-87)、_notifyRenderTargetAttached(89-94)、_notifyRenderTargetDetached(96-102)、detachFromAllRenderTargets(104-110)
  • OgreMain/include/OgreRenderTarget.h :attachDepthBuffer(115)、detachDepthBuffer(117)、_detachDepthBuffer(123)、getDepthBuffer(112)

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

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

下面复现兼容判定、附着双向通知与全部摘除。它与 src/13-1-depth-buffer.cpp 逐字节一致:

// file: src/13-1-depth-buffer.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/13-1-depth-buffer.cpp -o bin/13-1-depth-buffer && ./bin/13-1-depth-buffer
//
// 复现 DepthBuffer 的尺寸/FSAA 兼容判定与附着集合(对应 OgreDepthBuffer.cpp 57-110):
//   isCompatible = 自身宽高 >= RT 宽高 且 FSAA 相等;
//   _notifyRenderTargetAttached/_notifyRenderTargetDetached 维护 mAttachedRenderTargets;
//   detachFromAllRenderTargets 在改 PoolId/析构时逐个通知 RT 摘除。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <set>

namespace ogre_repro {

class RenderTargetRepro;

class DepthBufferRepro {
 public:
  DepthBufferRepro(uint16_t poolId, uint32_t width, uint32_t height, uint32_t fsaa, bool manual)
      : mPoolId(poolId), mWidth(width), mHeight(height), 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:宽高 >= 目标 且 FSAA 相同
  bool isCompatible(const RenderTargetRepro* rt) const;

  // 对应 _notifyRenderTargetAttached
  void _notifyRenderTargetAttached(RenderTargetRepro* rt);
  // 对应 _notifyRenderTargetDetached
  void _notifyRenderTargetDetached(RenderTargetRepro* rt);
  // 对应 detachFromAllRenderTargets
  void detachFromAllRenderTargets();

  size_t attachedCount() const { return mAttached.size(); }

 private:
  uint16_t mPoolId;
  uint32_t mWidth;
  uint32_t mHeight;
  uint32_t mFsaa;
  bool mManual;
  std::set<RenderTargetRepro*> mAttached;
};

class RenderTargetRepro {
 public:
  RenderTargetRepro(uint32_t width, uint32_t height, uint32_t fsaa)
      : mWidth(width), mHeight(height), mFsaa(fsaa) {}

  uint32_t getWidth() const { return mWidth; }
  uint32_t getHeight() const { return mHeight; }
  uint32_t getFSAA() const { return mFsaa; }

  // 对应 RenderTarget::attachDepthBuffer:兼容才附,附前先摘旧
  bool attachDepthBuffer(DepthBufferRepro* db) {
    if (!db->isCompatible(this)) return false;
    detachDepthBuffer();
    mDepthBuffer = db;
    db->_notifyRenderTargetAttached(this);
    return true;
  }
  // 对应 RenderTarget::detachDepthBuffer
  void detachDepthBuffer() {
    if (mDepthBuffer) {
      mDepthBuffer->_notifyRenderTargetDetached(this);
      mDepthBuffer = nullptr;
    }
  }
  // 对应 _detachDepthBuffer:由 DepthBuffer 遍历时调用
  void _detachDepthBuffer() { mDepthBuffer = nullptr; }
  DepthBufferRepro* getDepthBuffer() const { return mDepthBuffer; }

 private:
  uint32_t mWidth;
  uint32_t mHeight;
  uint32_t mFsaa;
  DepthBufferRepro* mDepthBuffer = nullptr;
};

inline bool DepthBufferRepro::isCompatible(const RenderTargetRepro* rt) const {
  return getWidth() >= rt->getWidth() && getHeight() >= rt->getHeight() &&
         getFSAA() == rt->getFSAA();
}
inline void DepthBufferRepro::_notifyRenderTargetAttached(RenderTargetRepro* rt) {
  mAttached.insert(rt);
}
inline void DepthBufferRepro::_notifyRenderTargetDetached(RenderTargetRepro* rt) {
  mAttached.erase(rt);
}
inline void DepthBufferRepro::detachFromAllRenderTargets() {
  for (auto* r : mAttached) r->_detachDepthBuffer();
  mAttached.clear();
}

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  DepthBufferRepro db(1, 1024, 768, 4, true);
  CHECK_EQ(db.getPoolId(), uint16_t(1));
  CHECK_EQ(db.getWidth(), 1024u);
  CHECK_EQ(db.getHeight(), 768u);
  CHECK_EQ(db.getFSAA(), 4u);
  CHECK(db.isManual());

  // 宽高更小、FSAA 相同 -> 兼容
  RenderTargetRepro rtSmall(800, 600, 4);
  CHECK(db.isCompatible(&rtSmall));

  // RT 比缓冲还大 -> 不兼容
  RenderTargetRepro rtBig(1280, 1024, 4);
  CHECK(!db.isCompatible(&rtBig));

  // FSAA 不同 -> 不兼容
  RenderTargetRepro rtFsaa(800, 600, 8);
  CHECK(!db.isCompatible(&rtFsaa));

  // 兼容附着:通知集合维护
  CHECK(rtSmall.attachDepthBuffer(&db));
  CHECK(rtSmall.getDepthBuffer() == &db);
  CHECK_EQ(db.attachedCount(), size_t(1));

  // 换一张同样兼容的 RT:老目标保持附着
  RenderTargetRepro rtSmall2(640, 480, 4);
  CHECK(rtSmall2.attachDepthBuffer(&db));
  CHECK_EQ(db.attachedCount(), size_t(2));

  // 不兼容附着失败,集合不变
  RenderTargetRepro rtBig2(2048, 2048, 4);
  CHECK(!rtBig2.attachDepthBuffer(&db));
  CHECK_EQ(db.attachedCount(), size_t(2));

  // 单个摘除
  rtSmall2.detachDepthBuffer();
  CHECK(rtSmall2.getDepthBuffer() == nullptr);
  CHECK_EQ(db.attachedCount(), size_t(1));

  // 全部摘除(模拟改 PoolId / 析构)
  db.detachFromAllRenderTargets();
  CHECK_EQ(db.attachedCount(), size_t(0));
  CHECK(rtSmall.getDepthBuffer() == nullptr);

  return lab::report("13-1 深度缓冲");
}

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

小结

  • DepthBuffer 只记录几何形状与多重采样:mPoolId/mWidth/mHeight/mFsaa/mManual,没有位深字段。
  • isCompatible 的裁判标准:宽高不小于目标、FSAA 完全相同。
  • 附着是双向通知:RT 记指针、DepthBuffer 记集合,摘除对称。
  • 遍历集合摘除时用不通知的 _detachDepthBuffer,避免修改正在遍历的集合。
  • POOL_NO_DEPTH 与 POOL_MANUAL_USAGE 等价,都表示 OGRE 不托管。

阅读导航:上一节:12.3 RTT 使用流程 · 下一节:13.2 模板测试 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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