《OGRE 3D 渲染引擎原理与架构》11.1 帧缓冲抽象

RenderTarget 是所有渲染输出目标(窗口、纹理、离屏表面)的共同抽象:持宽度/高度、优先级、active/autoUpdate 状态与按 Z-order 排序的视口表。update() 按 updateImpl 三段式驱动视口重绘并可交换缓冲,事件监听器与帧统计贯穿全程。lab 复现帧缓冲抽象、Z-order 视口表与更新流程。

11.1 帧缓冲抽象

第 10 章讲完了「纹理作为输入」的整条链路:TextureUnitState 定采样状态、Sampler 定采样细节、Texture 把图像数据搬进显存。这一章把镜头从「输入」转向「输出目标」:无论窗口还是离屏表面,最终像素都要落到一个帧缓冲上。OGRE 用 RenderTarget 一个类统一抽象它们——它是窗口、纹理、深度缓冲池共同的「画布」基类,位于 OgreMain/include/OgreRenderTarget.h。

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

helio 四卷的渲染目标按平台分别实现(Vulkan framebuffer / Metal drawable / GL FBO),OGRE 反过来用 RenderTarget 做平台无关的统一抽象,各后端再派生 GLRenderTarget、MetalRenderTarget 等。卷一 ogre-core 已讲过渲染系统接口与目标创建入口,这节深入到 RenderTarget 内部的数据结构与更新流程。

RenderTarget:宽高、优先级与开关状态

RenderTarget 的类注释点明它的身份:一个渲染目标可以是屏幕上的窗口,也可以是纹理、凹凸贴图之类的离屏表面。类定义的开头给出每帧渲染的统计结构与目标种类:

// OgreMain/include/OgreRenderTarget.h:FrameStats 与 FrameBuffer(v14.6.3 源码摘录)
        struct FrameStats
        {
            /// frames per second (FPS) based on the frames rendered in the last second
            float lastFPS;
            /// average frames per second (FPS) since call to Root::startRendering
            float avgFPS;
            /// best frames per second (FPS) since call to Root::startRendering
            float bestFPS;
            /// worst frames per second (FPS) since call to Root::startRendering
            float worstFPS;
            unsigned long bestFrameTime;
            unsigned long worstFrameTime;
            /// number of triangles rendered in the last update() call.
            size_t triangleCount;
            /// number of batches rendered in the last update() call.
            size_t batchCount;
            int vBlankMissCount; // -1 means that the value is not applicable
        };

        enum FrameBuffer
        {
            FB_FRONT,
            FB_BACK,
            FB_AUTO
        };

FrameBuffer 的 FB_FRONT/FB_BACK/FB_AUTO 对应窗口后端的双缓冲语义:copyContentsToMemory 等读写操作可以显式指定读前台还是后台缓冲。宽高是目标最基础的度量:

// OgreMain/include/OgreRenderTarget.h:度量与开关(v14.6.3 源码摘录,已删减)
        /// Retrieve information about the render target.
        void getMetrics(unsigned int& width, unsigned int& height);

        uint32 getWidth(void) const { return mWidth; }
        uint32 getHeight(void) const { return mHeight; }
        ...
        void setPriority( uchar priority ) { mPriority = priority; }
        /** Gets the priority of a render target. */
        uchar getPriority() const { return mPriority; }
        ...
        virtual bool isActive() const { return mActive; }
        ...
        void setActive( bool state ) { mActive = state; }
        ...
        void setAutoUpdated(bool autoupdate) { mAutoUpdate = autoupdate; }
        /** Gets whether this target is automatically updated if Ogre's rendering
            loop or Root::_updateAllRenderTargets is being used.
        */
        bool isAutoUpdated(void) const { return mAutoUpdate; }

几个开关各司其职:

状态含义默认
mPriority目标在渲染调度里的优先级,低者先渲染OGRE_DEFAULT_RT_GROUP
mActive目标是否激活(失活时不参与自动更新)true
mAutoUpdate在 Root::startRendering 自动循环里是否被更新true
mHwGamma写入时是否做 sRGB 硬件伽马转换false
mFSAA多重采样等级0

构造器里这些默认值一次到位:

// OgreMain/src/OgreRenderTarget.cpp:RenderTarget 构造器(v14.6.3 源码摘录,已删减)
    RenderTarget::RenderTarget()
        : mPriority(OGRE_DEFAULT_RT_GROUP)
        , mDepthBufferPoolId(RBP_DEFAULT)
        , mDepthBuffer(0)
        , mActive(true)
        , mAutoUpdate(true)
        , mHwGamma(false)
        , mFSAA(0)
    {
        mTimer = Root::getSingleton().getTimer();
        resetStatistics();
    }

视口表:按 Z-order 排序的 map

RenderTarget 不是单独画一帧,它可能被多个**视口(Viewport)**切分——每个视口对应一个相机的画面,支持画中画(picture-in-picture)。视口存在一张按 Z-order 排序的 std::map<int, Viewport*> 里:

// OgreMain/include/OgreRenderTarget.h:视口表(v14.6.3 源码摘录)
        typedef std::map<int, Viewport*> ViewportList;
        /// List of viewports, map on Z-order
        ViewportList mViewportList;

        typedef std::vector<RenderTargetListener*> RenderTargetListenerList;
        RenderTargetListenerList mListeners;

std::map 的 key 是 Z-order,addViewport 在插入前先查重——同一 Z-order 只能有一个视口:

// OgreMain/src/OgreRenderTarget.cpp:addViewport(v14.6.3 源码摘录,已删减)
    Viewport* RenderTarget::addViewport(Camera* cam, int ZOrder, FloatRect rect)
    {       
        // Check no existing viewport with this Z-order
        ViewportList::iterator it = mViewportList.find(ZOrder);

        if (it != mViewportList.end())
        {
            StringStream str;
            str << "Can't create another viewport for "
                << mName << " with Z-order " << ZOrder
                << " because a viewport exists with this Z-order already.";
            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, str.str(), "RenderTarget::addViewport");
        }
        // Add viewport to list
        // Order based on Z-order
        Viewport* vp = OGRE_NEW Viewport(cam, this, rect, ZOrder);

        mViewportList.emplace(ZOrder, vp);

        fireViewportAdded(vp);

        return vp;
    }

注意 rect 是参数化的相对矩形(FloatRect),这样视口能随目标一起缩放。用 std::map 而非 std::vector 的好处是迭代天然按 Z-order 升序——更新视口时不需要额外排序。

update:三段式的更新流程

手动刷新一个目标走 update(bool swapBuffers = true)。它先调虚函数 updateImpl() 完成渲染,再按参数决定是否 swapBuffers()(交换前后缓冲 / 做 MSAA resolve):

// OgreMain/src/OgreRenderTarget.cpp:update(v14.6.3 源码摘录,已删减)
    void RenderTarget::update(bool swap)
    {
        GpuEventScope profileScope(mName);
        // call implementation
        updateImpl();


        if (swap)
        {
            // Swap buffers
            swapBuffers();
        }
    }

swapBuffers() 在基类是空实现(virtual void swapBuffers() {}),真正的前后台交换由各后端派生类完成——比如 GL 后端做 SwapBuffers,Metal 后端提交命令缓冲并等待帧信号量。

updateImpl() 把一次刷新切成三个清晰阶段:清统计 → 更新自动视口 → 收尾统计:

// OgreMain/src/OgreRenderTarget.cpp:updateImpl 三段式(v14.6.3 源码摘录)
    void RenderTarget::updateImpl(void)
    {
        _beginUpdate();
        _updateAutoUpdatedViewports(true);
        _endUpdate();
    }

    void RenderTarget::_beginUpdate()
    {
        // notify listeners (pre)
        firePreUpdate();

        mStats.triangleCount = 0;
        mStats.batchCount = 0;
    }

    void RenderTarget::_updateAutoUpdatedViewports(bool updateStatistics)
    {
        // Go through viewports in Z-order
        // Tell each to refresh
        for (const auto& v : mViewportList)
        {
            Viewport* viewport = v.second;
            if(viewport->isAutoUpdated())
            {
                _updateViewport(viewport,updateStatistics);
            }
        }
    }

    void RenderTarget::_endUpdate()
    {
         // notify listeners (post)
        firePostUpdate();

        // Update statistics (always on top)
        updateStats();
    }

_updateAutoUpdatedViewports 遍历整个视口表,跳过 isAutoUpdated() == false 的视口——这就是 mAutoUpdate 在视口层面的体现。真正渲染单个视口的 _updateViewport 会累计三角形与批次统计:

// OgreMain/src/OgreRenderTarget.cpp:_updateViewport(v14.6.3 源码摘录)
    void RenderTarget::_updateViewport(Viewport* viewport, bool updateStatistics)
    {
        assert(viewport->getTarget() == this &&
                "RenderTarget::_updateViewport the requested viewport is "
                "not bound to the rendertarget!");

        fireViewportPreUpdate(viewport);
        viewport->update();
        if(updateStatistics)
        {
            mStats.triangleCount += viewport->_getNumRenderedFaces();
            mStats.batchCount += viewport->_getNumRenderedBatches();
        }
        fireViewportPostUpdate(viewport);
    }

断言保证视口必须绑定到当前目标(不能拿别的目标的视口来更新);每个视口更新前后还会触发 preViewportUpdate/postViewportUpdate 事件。

事件与帧统计

mListeners 是一串 RenderTargetListener,update 与视口更新前后都会派发事件,派生类(如 RTSS、compositor)靠它挂钩子:

事件时机
preUpdate / postUpdate目标整体更新开始前 / 结束后
preViewportUpdate / postViewportUpdate单个视口渲染前 / 后
viewportAdded / viewportRemoved视口加入 / 移除

帧统计的核心是 updateStats(),它每秒最多更新一次 FPS:

// OgreMain/src/OgreRenderTarget.cpp:updateStats(v14.6.3 源码摘录)
    void RenderTarget::updateStats(void)
    {
        ++mFrameCount;
        unsigned long thisTime = mTimer->getMilliseconds();

        // check frame time
        unsigned long frameTime = thisTime - mLastTime ;
        mLastTime = thisTime ;

        mStats.bestFrameTime = std::min(mStats.bestFrameTime, frameTime);
        mStats.worstFrameTime = std::max(mStats.worstFrameTime, frameTime);

        // check if new second (update only once per second)
        if (thisTime - mLastSecond > 1000) 
        { 
            // new second - not 100% precise
            mStats.lastFPS = (float)mFrameCount / (float)(thisTime - mLastSecond) * 1000.0f;

            if (mStats.avgFPS == 0)
                mStats.avgFPS = mStats.lastFPS;
            else
                mStats.avgFPS = (mStats.avgFPS + mStats.lastFPS) / 2; // not strictly correct, but good enough

            mStats.bestFPS = std::max(mStats.bestFPS, mStats.lastFPS);
            mStats.worstFPS = std::min(mStats.worstFPS, mStats.lastFPS);

            mLastSecond = thisTime ;
            mFrameCount  = 0;

        }

注意它的注释「not strictly correct, but good enough」——平均 FPS 用「新值与旧平均再平均」的简单递推,不做真正的累积均值;bestFrameTime/worstFrameTime 每帧都参与 min/max,而 FPS 相关字段只在跨过 1000ms 时更新一次。resetStatistics 里把 worstFPS 初值设成 999.0、bestFrameTime 设成 999999,正是为了让第一帧能正确触发 min/max。

源码定位

  • OgreMain/include/OgreRenderTarget.h :class _OgreExport RenderTarget(60-491)、FrameStats(63-80)、enum FrameBuffer(82-87)、getWidth/getHeight(98-99)、update(141)、swapBuffers(154)、addViewport(173)、setPriority/getPriority(272/274)、isActive/setActive(278/282)、setAutoUpdated/isAutoUpdated(295/299)、copyContentsToMemory(306)、requiresTextureFlipping(329)、保护成员与视口表(438-490)
  • OgreMain/src/OgreRenderTarget.cpp :构造器(57-74)、addViewport(172-194)、resetStatistics(223-238)、updateStats(240-269)、updateImpl(117-122)、_beginUpdate(124-131)、_updateAutoUpdatedViewports(133-145)、_endUpdate(147-154)、_updateViewport(156-170)、getViewportByZOrder(339-348)、fire*(356-402)、update(446-458)

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

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

下面用纯 C++ 复现 RenderTarget 的帧缓冲抽象:默认状态、按 Z-order 排序的视口表、update 三段式流程、事件派发与 FPS 统计。它与 src/11-1-framebuffer.cpp 逐字节一致:

// file: src/11-1-framebuffer.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/11-1-framebuffer.cpp -o bin/11-1-framebuffer && ./bin/11-1-framebuffer
//
// 复现 RenderTarget 帧缓冲抽象(对应 OgreMain/include/OgreRenderTarget.h 60-491
// 与 OgreMain/src/OgreRenderTarget.cpp 117-458):
//   抽象基类持宽度/高度、优先级、active/autoUpdate,视口存进按 Z-order 排序的
//   std::map<int, Viewport*>;addViewport 拒绝重复 Z-order;
//   update(bool swap) = updateImpl() + 可选 swapBuffers();
//   updateImpl 分 _beginUpdate/_updateAutoUpdatedViewports/_endUpdate 三段,
//   只更新 autoUpdated 视口并累加 triangleCount/batchCount,_endUpdate 里做 FPS 统计;
//   RenderTargetListener 在 update/视口更新前后收到事件。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

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

namespace ogre_repro {

using String = std::string;

// 对应 FrameStats(OgreRenderTarget.h 63-80);worstFPS 初值 999 对应
// resetStatistics(OgreRenderTarget.cpp 223-238)
struct FrameStats {
  float lastFPS = 0, avgFPS = 0, bestFPS = 0, worstFPS = 999.0f;
  uint64_t bestFrameTime = 999999, worstFrameTime = 0;
  size_t triangleCount = 0, batchCount = 0;
};

// 对应 RenderTargetListener 的回调集合(只保留用到的六个)
struct RenderTargetListener {
  virtual void preUpdate() {}
  virtual void postUpdate() {}
  virtual void viewportAdded() {}
  virtual void viewportRemoved() {}
  virtual void preViewportUpdate() {}
  virtual void postViewportUpdate() {}
  virtual ~RenderTargetListener() = default;
};

// 简化 Viewport:isAutoUpdated 决定是否被自动更新,update() 模拟一次场景提交
class Viewport {
 public:
  Viewport(bool autoUpdated, int zOrder) : mAutoUpdated(autoUpdated), mZOrder(zOrder) {}
  bool isAutoUpdated() const { return mAutoUpdated; }
  void setAutoUpdated(bool v) { mAutoUpdated = v; }
  int getZOrder() const { return mZOrder; }
  size_t _getNumRenderedFaces() const { return mNumUpdates * 2; }
  size_t _getNumRenderedBatches() const { return mNumUpdates; }
  void update() { ++mNumUpdates; }
  size_t getNumUpdates() const { return mNumUpdates; }

 private:
  bool mAutoUpdated;
  int mZOrder;
  size_t mNumUpdates = 0;
};

// 对应 RenderTarget(OgreRenderTarget.h 60-491)的关键子集
class RenderTarget {
 public:
  using ViewportList = std::map<int, Viewport*>;

  enum { OGRE_DEFAULT_RT_GROUP = 4 };  // OgreRenderTarget.h:39

  RenderTarget() : mPriority(OGRE_DEFAULT_RT_GROUP), mActive(true), mAutoUpdate(true) {}

  virtual ~RenderTarget() {
    for (auto& v : mViewportList) delete v.second;
  }

  uint32_t getWidth() const { return mWidth; }
  uint32_t getHeight() const { return mHeight; }
  void setWidth(uint32_t w) { mWidth = w; }
  void setHeight(uint32_t h) { mHeight = h; }

  void setPriority(uint8_t priority) { mPriority = priority; }
  uint8_t getPriority() const { return mPriority; }

  bool isActive() const { return mActive; }
  void setActive(bool state) { mActive = state; }

  void setAutoUpdated(bool autoupdate) { mAutoUpdate = autoupdate; }
  bool isAutoUpdated() const { return mAutoUpdate; }

  // 对应 update(OgreRenderTarget.cpp 446-458):updateImpl + 可选 swapBuffers
  void update(bool swap = true) {
    updateImpl();
    if (swap) swapBuffers();
  }

  // 对应 addViewport(OgreRenderTarget.cpp 172-194):重复 Z-order 直接拒绝
  Viewport* addViewport(int zOrder, bool autoUpdated) {
    ViewportList::iterator it = mViewportList.find(zOrder);
    if (it != mViewportList.end()) return nullptr;
    Viewport* vp = new Viewport(autoUpdated, zOrder);
    mViewportList.emplace(zOrder, vp);
    fireViewportAdded();
    return vp;
  }

  void removeViewport(int zOrder) {
    ViewportList::iterator it = mViewportList.find(zOrder);
    if (it != mViewportList.end()) {
      fireViewportRemoved();
      delete it->second;
      mViewportList.erase(zOrder);
    }
  }

  size_t getNumViewports() const { return mViewportList.size(); }
  const ViewportList& getViewportList() const { return mViewportList; }

  // 对应 updateImpl(OgreRenderTarget.cpp 117-122)
  void updateImpl() {
    _beginUpdate();
    _updateAutoUpdatedViewports(true);
    _endUpdate();
  }

  // 对应 _beginUpdate(124-131):清统计 + 触发 preUpdate
  void _beginUpdate() {
    firePreUpdate();
    mStats.triangleCount = 0;
    mStats.batchCount = 0;
  }

  // 对应 _updateAutoUpdatedViewports(133-145):按 Z-order 迭代,只更新 autoUpdated
  void _updateAutoUpdatedViewports(bool updateStatistics) {
    for (const auto& v : mViewportList) {
      Viewport* viewport = v.second;
      if (viewport->isAutoUpdated()) _updateViewport(viewport, updateStatistics);
    }
  }

  // 对应 _endUpdate(147-154):postUpdate + FPS 统计
  void _endUpdate() {
    firePostUpdate();
    updateStats();
  }

  // 对应 _updateViewport(156-170)
  void _updateViewport(Viewport* viewport, bool updateStatistics) {
    fireViewportPreUpdate(viewport);
    viewport->update();
    if (updateStatistics) {
      mStats.triangleCount += viewport->_getNumRenderedFaces();
      mStats.batchCount += viewport->_getNumRenderedBatches();
    }
    fireViewportPostUpdate(viewport);
  }

  // 对应 _updateViewport(int, bool)(405-408):手动指定 Z-order 更新
  void _updateViewport(int zorder, bool updateStatistics = true) {
    _updateViewport(getViewportByZOrder(zorder), updateStatistics);
  }

  Viewport* getViewportByZOrder(int zOrder) {
    ViewportList::iterator i = mViewportList.find(zOrder);
    return (i == mViewportList.end()) ? nullptr : i->second;
  }

  // 对应 swapBuffers()(154):窗口后端在此交换前后缓冲 / 做 MSAA resolve
  virtual void swapBuffers() { ++mSwapCount; }
  uint32_t getSwapCount() const { return mSwapCount; }

  // fire* 系列:对应 OgreRenderTarget.cpp 356-402
  void firePreUpdate() { for (auto* l : mListeners) l->preUpdate(); }
  void firePostUpdate() { for (auto* l : mListeners) l->postUpdate(); }
  void fireViewportAdded() { for (auto* l : mListeners) l->viewportAdded(); }
  void fireViewportRemoved() { for (auto* l : mListeners) l->viewportRemoved(); }
  void fireViewportPreUpdate(Viewport*) { for (auto* l : mListeners) l->preViewportUpdate(); }
  void fireViewportPostUpdate(Viewport*) { for (auto* l : mListeners) l->postViewportUpdate(); }

  void addListener(RenderTargetListener* l) { mListeners.push_back(l); }

  const FrameStats& getStats() const { return mStats; }

  // 对应 updateStats(240-269):每帧记一次帧时间,跨过 1000ms 才更新 FPS
  void updateStats() {
    ++mFrameCount;
    uint64_t frameTime = mNowMs - mLastTime;
    mLastTime = mNowMs;
    mStats.bestFrameTime = std::min(mStats.bestFrameTime, frameTime);
    mStats.worstFrameTime = std::max(mStats.worstFrameTime, frameTime);
    if (mNowMs - mLastSecond > 1000) {
      mStats.lastFPS = static_cast<float>(mFrameCount) / static_cast<float>(mNowMs - mLastSecond) * 1000.0f;
      if (mStats.avgFPS == 0)
        mStats.avgFPS = mStats.lastFPS;
      else
        mStats.avgFPS = (mStats.avgFPS + mStats.lastFPS) / 2;
      mStats.bestFPS = std::max(mStats.bestFPS, mStats.lastFPS);
      mStats.worstFPS = std::min(mStats.worstFPS, mStats.lastFPS);
      mLastSecond = mNowMs;
      mFrameCount = 0;
    }
  }

  // 手动推进虚拟时钟,模拟真实 Timer 的时间流逝
  void advanceClock(uint64_t ms) { mNowMs += ms; }

 protected:
  String mName;
  uint8_t mPriority;
  uint32_t mWidth = 0, mHeight = 0;
  FrameStats mStats;
  uint64_t mNowMs = 0, mLastSecond = 0, mLastTime = 0;
  size_t mFrameCount = 0;
  bool mActive, mAutoUpdate;
  ViewportList mViewportList;
  std::vector<RenderTargetListener*> mListeners;
  uint32_t mSwapCount = 0;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  RenderTarget rt;
  rt.setWidth(1920);
  rt.setHeight(1080);

  // 默认状态:优先级 OGRE_DEFAULT_RT_GROUP(4)、active、autoUpdate
  CHECK(rt.getWidth() == 1920);
  CHECK(rt.getHeight() == 1080);
  CHECK(rt.getPriority() == RenderTarget::OGRE_DEFAULT_RT_GROUP);
  CHECK(rt.isActive());
  CHECK(rt.isAutoUpdated());

  // addViewport:重复 Z-order 被拒绝
  Viewport* vp0 = rt.addViewport(0, true);
  Viewport* vp5 = rt.addViewport(5, true);
  Viewport* vp1 = rt.addViewport(1, false);  // 不自动更新
  CHECK(rt.getNumViewports() == 3);
  CHECK(rt.addViewport(5, true) == nullptr);  // Z-order 5 已存在
  CHECK(rt.getNumViewports() == 3);

  // 视口表按 Z-order 排序
  {
    std::vector<int> zorders;
    for (const auto& v : rt.getViewportList()) zorders.push_back(v.first);
    CHECK(zorders.size() == 3);
    CHECK(zorders[0] == 0);
    CHECK(zorders[1] == 1);
    CHECK(zorders[2] == 5);
  }

  // update(swap=false):不交换缓冲
  rt.update(false);
  CHECK(rt.getSwapCount() == 0);

  // update(swap=true):交换缓冲
  rt.update(true);
  CHECK(rt.getSwapCount() == 1);

  // 两次 update 中只有 autoUpdated 的 vp0/vp5 被更新,vp1 保持 0
  CHECK(vp0->getNumUpdates() == 2);
  CHECK(vp5->getNumUpdates() == 2);
  CHECK(vp1->getNumUpdates() == 0);

  // 统计只反映最后一次 update:vp0/vp5 各贡献 2 次 update(faces=2*updates)
  CHECK(rt.getStats().triangleCount == 8);
  CHECK(rt.getStats().batchCount == 4);

  // 手动 _updateViewport(zorder):非 autoUpdated 视口也能被渲染
  rt._updateViewport(1);
  CHECK(vp1->getNumUpdates() == 1);
  CHECK(rt.getStats().triangleCount == 10);
  CHECK(rt.getStats().batchCount == 5);

  // RenderTargetListener:update 前后 + 每个视口前后都有事件
  struct CountingListener : RenderTargetListener {
    int pre = 0, post = 0, preVp = 0, postVp = 0, added = 0, removed = 0;
    void preUpdate() override { ++pre; }
    void postUpdate() override { ++post; }
    void preViewportUpdate() override { ++preVp; }
    void postViewportUpdate() override { ++postVp; }
    void viewportAdded() override { ++added; }
    void viewportRemoved() override { ++removed; }
  };
  CountingListener cl;
  rt.addListener(&cl);
  rt.update(false);
  CHECK(cl.pre == 1);
  CHECK(cl.post == 1);
  CHECK(cl.preVp == 2);  // vp0 与 vp5 两个 autoUpdated 视口
  CHECK(cl.postVp == 2);

  // addViewport / removeViewport 触发 viewportAdded / viewportRemoved
  rt.addViewport(2, true);
  CHECK(cl.added == 1);
  rt.removeViewport(2);
  CHECK(cl.removed == 1);
  CHECK(rt.getNumViewports() == 3);

  // setAutoUpdated(false):该视口不再被自动更新
  vp0->setAutoUpdated(false);
  rt.update(false);
  CHECK(vp0->getNumUpdates() == 3);  // 不再增加
  CHECK(vp5->getNumUpdates() == 4);
  CHECK(vp1->getNumUpdates() == 1);
  CHECK(rt.getStats().triangleCount == 8);  // 只有 vp5(faces=8)
  CHECK(rt.getStats().batchCount == 4);

  // FPS 统计:单独目标上推进 300/500/300ms 三帧
  RenderTarget fps;
  fps.advanceClock(300); fps.update(false);  // 帧时间 300
  fps.advanceClock(500); fps.update(false);  // 帧时间 500
  fps.advanceClock(300); fps.update(false);  // 帧时间 300,累计 1100ms
  CHECK(fps.getStats().bestFrameTime == 300);
  CHECK(fps.getStats().worstFrameTime == 500);
  CHECK(fps.getStats().lastFPS > 2.7f);   // 3 帧 / 1100ms ≈ 2.73
  CHECK(fps.getStats().lastFPS < 2.8f);
  CHECK(fps.getStats().avgFPS == fps.getStats().lastFPS);
  CHECK(fps.getStats().bestFPS == fps.getStats().lastFPS);
  CHECK(fps.getStats().worstFPS == fps.getStats().lastFPS);

  // setActive / setPriority
  rt.setActive(false);
  CHECK(!rt.isActive());
  rt.setPriority(1);
  CHECK(rt.getPriority() == 1);

  return lab::report("11-1 帧缓冲抽象");
}

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

小结

  • RenderTarget 是窗口与离屏表面的共同抽象,持宽度/高度、优先级、active/autoUpdate、MSAA 与 sRGB 伽马等状态。
  • 视口按 Z-order 存进 std::map<int, Viewport*>,addViewport 拒绝重复 Z-order,迭代天然有序。
  • update(bool swap) = updateImpl() + 可选 swapBuffers();updateImpl 三段式:_beginUpdate 清统计 → _updateAutoUpdatedViewports 只更新自动视口 → _endUpdate 收尾并统计。
  • RenderTargetListener 在目标与视口更新前后收到六类事件,是 compositor / RTSS 的挂接点。
  • updateStats 每帧追踪 best/worst 帧时间,FPS 只在跨过 1000ms 时更新一次;worstFPS 初值 999 保证第一帧 min/max 正确。

阅读导航:上一节:10.3 纹理硬件加载 · 下一节:11.2 交换链 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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