《OGRE 3D 渲染引擎原理与架构》12.1 渲染纹理

RenderTexture 是画进纹理的 RenderTarget:构造时从 HardwarePixelBuffer 取宽高与格式,优先级进入 REND_TO_TEX 组,深度格式跳过深度缓冲池。纹理的每个 slice/face/mip 是独立的 HardwarePixelBuffer,各持一个 RenderTexture 引用。lab 复现 RenderTexture 构造、slice 表挂接与 copyContentsToMemory。

12.1 渲染纹理

11.1 的 RenderTarget 抽象分岔出两个方向:一个是显示到屏幕的窗口(交换链见 11.2),另一个就是这章的渲染纹理(RenderTexture)——把一帧画进一块纹理,而不是屏幕。渲染纹理是「把屏幕内容当贴图用」的全部基础:反射/折射水面、镜像、小地图、动态阴影贴图全都靠它。它位于 OgreMain/include/OgreRenderTexture.h,是 RenderTarget 的直接子类。

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

helio 四卷在各后端分别实现 FBO/Attachment 的纹理挂接;OGRE 用 RenderTexture 做平台无关的「画进纹理」抽象,真正的 FBO 创建在各后端的 createRenderTexture(如 GL3Plus 的 GL3PlusFBORenderTexture)。这节聚焦 RenderTexture 与 HardwarePixelBuffer 的关系,12.2 讲它的多目标兄弟 MultiRenderTarget。

RenderTexture:把帧画进纹理

RenderTexture 的类注释直接点破它和 Texture 不是一一对应:同一块纹理可以有多个渲染目标,分别画到不同的 mipmap、立方体贴图的 face 或 3D 纹理的 slice:

// OgreMain/include/OgreRenderTexture.h:RenderTexture 类定义(v14.6.3 源码摘录)
    class _OgreExport RenderTexture: public RenderTarget
    {
    public:
        RenderTexture(HardwarePixelBuffer *buffer, uint32 zoffset);
        virtual ~RenderTexture();

        using RenderTarget::copyContentsToMemory;
        void copyContentsToMemory(const Box& src, const PixelBox &dst, FrameBuffer buffer = FB_AUTO) override;
        PixelFormat suggestPixelFormat() const override;

    protected:
        HardwarePixelBuffer *mBuffer;
        uint32 mZOffset;
    };

它只多两个成员:mBuffer(画到哪块像素缓冲)和 mZOffset(画到哪个 z-slice)。其余宽高、优先级、深度缓冲池等全部继承 RenderTarget。

构造细节:宽高、优先级与深度池

构造器从 mBuffer 取尺寸,把优先级设为 OGRE_REND_TO_TEX_RT_GROUP(渲染纹理组),并检测深度格式:

// OgreMain/src/OgreRenderTexture.cpp:RenderTexture 构造器(v14.6.3 源码摘录)
    RenderTexture::RenderTexture(HardwarePixelBuffer *buffer, uint32 zoffset):
        mBuffer(buffer), mZOffset(zoffset)
    {
        mPriority = OGRE_REND_TO_TEX_RT_GROUP;
        mWidth = mBuffer->getWidth();
        mHeight = mBuffer->getHeight();

        if(PixelUtil::isDepth(mBuffer->getFormat()))
            mDepthBufferPoolId = RBP_NONE;
    }
初始化含义
mPriority = OGRE_REND_TO_TEX_RT_GROUP渲染纹理与窗口属于不同优先级组,调度顺序不同
mWidth/mHeight = mBuffer->...尺寸来自目标像素缓冲,而不是另行指定
mDepthBufferPoolId = RBP_NONE深度格式的渲染纹理不向深度池申请独立深度缓冲

copyContentsToMemory 是「读回像素」的入口:FB_AUTO 落成 FB_FRONT(渲染纹理只有前台概念,没有交换链的前后台),然后委托给像素缓冲的 blitToMemory:

// OgreMain/src/OgreRenderTexture.cpp:copyContentsToMemory(v14.6.3 源码摘录)
    void RenderTexture::copyContentsToMemory(const Box& src, const PixelBox &dst, FrameBuffer buffer)
    {
        if (buffer == FB_AUTO) buffer = FB_FRONT;
        OgreAssert(buffer == FB_FRONT, "Invalid buffer");

        mBuffer->blitToMemory(src, dst);
    }

HardwarePixelBuffer:slice 与 RTT 的挂接

HardwarePixelBuffer 是纹理数据与 GPU 表面之间的桥梁。它内部持有一个按 slice 索引的 RenderTexture* 数组,getRenderTarget(zoffset) 按下标返回(要求纹理以 TU_RENDERTARGET 用途创建):

// OgreMain/include/OgreHardwarePixelBuffer.h:slice RTT 表(v14.6.3 源码摘录,已删减)
        typedef std::vector<RenderTexture*> SliceTRT;
        SliceTRT mSliceTRT;
        ...
        /** Get a render target for this PixelBuffer, or a slice of it. The texture this
            was acquired from must have TU_RENDERTARGET set
            @param slice    Which slice
            @return A pointer to the render target. This pointer has the lifespan of this
            PixelBuffer.
        */
        RenderTexture *getRenderTarget(size_t slice=0) const;

实现里先断言用途标志,再校验下标,最后查表:

// OgreMain/src/OgreHardwarePixelBuffer.cpp:getRenderTarget 与 _clearSliceRTT(v14.6.3 源码摘录)
    RenderTexture *HardwarePixelBuffer::getRenderTarget(size_t zoffset) const
    {
        assert(mUsage & TU_RENDERTARGET);
        OgreAssert(zoffset < mSliceTRT.size(), "out of range");
        return mSliceTRT[zoffset];
    }
    //-----------------------------------------------------------------------------    

    void HardwarePixelBuffer::_clearSliceRTT(size_t zoffset)
    {
        if(zoffset < mSliceTRT.size())
            mSliceTRT[zoffset] = NULL;
    }

RenderTexture 的析构函数调用 mBuffer->_clearSliceRTT(0) 清掉引用,防止悬垂指针。整条链自洽:纹理按 (face, mip) 拆成多个 HardwarePixelBuffer(10.3 已见 getBuffer(face, mip) 的索引公式),每个 HardwarePixelBuffer 又能挂一个(或多个,3D 纹理按 z-slice)RenderTexture——这正是类注释说的「没有 1 对 1 关系」。

源码定位

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

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

下面用纯 C++ 复现 RenderTexture 与 HardwarePixelBuffer 的关系:slice RTT 表、getRenderTarget 的下标/用途校验、构造时从 buffer 取宽高/优先级/深度池、copyContentsToMemory 的 FB_AUTO 归并与 blit 委托、多 slice 复用。它与 src/12-1-render-texture.cpp 逐字节一致:

// file: src/12-1-render-texture.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/12-1-render-texture.cpp -o bin/12-1-render-texture && ./bin/12-1-render-texture
//
// 复现 RenderTexture 渲染纹理(对应 OgreMain/include/OgreRenderTexture.h 43-61、
// OgreMain/src/OgreRenderTexture.cpp 35-61 与
// OgreMain/src/OgreHardwarePixelBuffer.cpp 180-199):
//   HardwarePixelBuffer 持一个 mSliceTRT 数组,每 slice 一个 RenderTexture*;
//   getRenderTarget(zoffset) 要求 TU_RENDERTARGET 并按下标返回,_clearSliceRTT 清引用;
//   RenderTexture 构造时从 buffer 取宽高/格式,深度格式则跳过深度缓冲池;
//   copyContentsToMemory 把 FB_AUTO 落成 FB_FRONT 后走 blitToMemory。
//   同一块纹理可被多个 RenderTexture 复用(不同 slice/face/mip)。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <vector>

namespace ogre_repro {

enum PixelFormat : uint8_t { PF_UNKNOWN, PF_R8G8B8, PF_A8R8G8B8, PF_DEPTH24_STENCIL8 };
enum Usage : uint32_t { TU_STATIC = 1u << 0, TU_RENDERTARGET = 1u << 1 };

// 对应 PixelUtil::isDepth 的简化(真实实现查描述表 flags)
bool isDepthFormat(PixelFormat f) { return f == PF_DEPTH24_STENCIL8; }

// 对应 RenderTarget 的最小子集(宽/高/优先级/深度缓冲池)
class RenderTarget {
 public:
  uint32_t getWidth() const { return mWidth; }
  uint32_t getHeight() const { return mHeight; }
  uint8_t getPriority() const { return mPriority; }
  uint16_t getDepthBufferPoolId() const { return mDepthBufferPoolId; }

 protected:
  uint32_t mWidth = 0, mHeight = 0;
  uint8_t mPriority = 0;
  uint16_t mDepthBufferPoolId = 1;  // 对应 RBP_DEFAULT(OgreCommon.h:138)
};

// 对应 HardwarePixelBuffer(OgreHardwarePixelBuffer.h 52-195)的关键子集
class HardwarePixelBuffer {
 public:
  HardwarePixelBuffer(uint32_t w, uint32_t h, uint32_t slices, PixelFormat fmt, uint32_t usage)
      : mWidth(w), mHeight(h), mFormat(fmt), mUsage(usage), mSliceTRT(slices, nullptr) {}

  uint32_t getWidth() const { return mWidth; }
  uint32_t getHeight() const { return mHeight; }
  PixelFormat getFormat() const { return mFormat; }

  // 对应 getRenderTarget(OgreHardwarePixelBuffer.cpp 180-185)
  class RenderTexture* getRenderTarget(size_t zoffset) const {
    if (!(mUsage & TU_RENDERTARGET)) return nullptr;  // 真实代码此处是 assert
    if (zoffset >= mSliceTRT.size()) return nullptr;
    return mSliceTRT[zoffset];
  }

  // 对应 _clearSliceRTT(188-192)
  void _clearSliceRTT(size_t zoffset) {
    if (zoffset < mSliceTRT.size()) mSliceTRT[zoffset] = nullptr;
  }

  // 后端把 RTT 挂到某个 slice(模拟纹理 slice 创建时的登记)
  void _setSliceRTT(size_t zoffset, class RenderTexture* rt) { mSliceTRT[zoffset] = rt; }

  size_t numSlices() const { return mSliceTRT.size(); }

  // 对应 blitToMemory 的简化:只验证被调用
  bool blitToMemory(uint32_t dstW, uint32_t dstH) {
    ++mBlitCount;
    mLastBlitW = dstW;
    mLastBlitH = dstH;
    return mBlitCount > 0;
  }
  uint32_t getBlitCount() const { return mBlitCount; }
  uint32_t getLastBlitW() const { return mLastBlitW; }
  uint32_t getLastBlitH() const { return mLastBlitH; }

 private:
  uint32_t mWidth, mHeight;
  PixelFormat mFormat;
  uint32_t mUsage;
  std::vector<class RenderTexture*> mSliceTRT;
  uint32_t mBlitCount = 0;
  uint32_t mLastBlitW = 0, mLastBlitH = 0;
};

// 对应 RenderTexture(OgreRenderTexture.h 48-61)的关键子集
class RenderTexture : public RenderTarget {
 public:
  RenderTexture(HardwarePixelBuffer* buffer, uint32_t zoffset)
      : mBuffer(buffer), mZOffset(zoffset) {
    mPriority = OGRE_REND_TO_TEX_RT_GROUP;
    mWidth = mBuffer->getWidth();
    mHeight = mBuffer->getHeight();
    if (isDepthFormat(mBuffer->getFormat())) mDepthBufferPoolId = RBP_NONE;
  }

  ~RenderTexture() { mBuffer->_clearSliceRTT(0); }

  PixelFormat suggestPixelFormat() const { return mBuffer->getFormat(); }

  // 对应 copyContentsToMemory(OgreRenderTexture.cpp 50-56)
  void copyContentsToMemory(uint32_t dstW, uint32_t dstH, uint32_t buffer) {
    if (buffer == FB_AUTO) buffer = FB_FRONT;
    // OgreAssert(buffer == FB_FRONT, ...)
    mBuffer->blitToMemory(dstW, dstH);
  }

  uint32_t getZOffset() const { return mZOffset; }

  enum : uint8_t { OGRE_REND_TO_TEX_RT_GROUP = 2 };    // OgreRenderTarget.h:40
  enum : uint16_t { RBP_NONE = 0 };                     // OgreCommon.h:136
  enum : uint32_t { FB_FRONT = 0, FB_BACK = 1, FB_AUTO = 2 };  // FrameBuffer

 private:
  HardwarePixelBuffer* mBuffer;
  uint32_t mZOffset;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 一块 512x512 双 slice 的渲染目标纹理(TU_RENDERTARGET)
  HardwarePixelBuffer buffer(512, 512, 2, PF_A8R8G8B8, TU_RENDERTARGET);

  // 每个 slice 独立创建 RenderTexture
  RenderTexture rt0(&buffer, 0);
  RenderTexture rt1(&buffer, 1);

  // 构造时从 buffer 取尺寸、优先级进入 REND_TO_TEX 组;普通 RT 默认深度池 RBP_DEFAULT(1)
  CHECK(rt0.getWidth() == 512);
  CHECK(rt0.getHeight() == 512);
  CHECK(rt0.getPriority() == RenderTexture::OGRE_REND_TO_TEX_RT_GROUP);
  CHECK(rt0.getDepthBufferPoolId() == 1);

  // 登记到 slice 表后 getRenderTarget 可取回
  buffer._setSliceRTT(0, &rt0);
  buffer._setSliceRTT(1, &rt1);
  CHECK(buffer.getRenderTarget(0) == &rt0);
  CHECK(buffer.getRenderTarget(1) == &rt1);
  CHECK(buffer.getRenderTarget(2) == nullptr);  // 越界
  CHECK(buffer.numSlices() == 2);

  // 深度格式:渲染纹理不参与深度缓冲池
  HardwarePixelBuffer depthBuf(256, 256, 1, PF_DEPTH24_STENCIL8, TU_RENDERTARGET);
  RenderTexture rtDepth(&depthBuf, 0);
  CHECK(rtDepth.getDepthBufferPoolId() == RenderTexture::RBP_NONE);

  // suggestPixelFormat 来自 buffer
  CHECK(rt0.suggestPixelFormat() == PF_A8R8G8B8);
  CHECK(rtDepth.suggestPixelFormat() == PF_DEPTH24_STENCIL8);

  // copyContentsToMemory:FB_AUTO 落成 FB_FRONT,走 blitToMemory
  rt0.copyContentsToMemory(512, 512, RenderTexture::FB_AUTO);
  CHECK(buffer.getBlitCount() == 1);
  CHECK(buffer.getLastBlitW() == 512);
  CHECK(buffer.getLastBlitH() == 512);

  // 非 TU_RENDERTARGET 纹理取不到 RTT
  HardwarePixelBuffer plainBuf(64, 64, 1, PF_R8G8B8, TU_STATIC);
  CHECK(plainBuf.getRenderTarget(0) == nullptr);

  // 清除 slice 1 的引用后取不到
  buffer._clearSliceRTT(1);
  CHECK(buffer.getRenderTarget(1) == nullptr);

  // 同一块纹理可被多个 RenderTexture 复用:rt0 仍绑定 slice 0
  CHECK(buffer.getRenderTarget(0) == &rt0);

  return lab::report("12-1 渲染纹理");
}

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

小结

  • RenderTexture 是画进纹理的 RenderTarget,只多 mBuffer 与 mZOffset 两个成员。
  • 构造器从 mBuffer 取宽高,优先级进 OGRE_REND_TO_TEX_RT_GROUP;深度格式把深度缓冲池设为 RBP_NONE。
  • HardwarePixelBuffer 持 mSliceTRT 数组,getRenderTarget(zoffset) 要求 TU_RENDERTARGET 并按下标返回。
  • copyContentsToMemory 把 FB_AUTO 落成 FB_FRONT,委托给 mBuffer->blitToMemory。
  • 一块纹理的每个 face/mip/slice 是独立的 HardwarePixelBuffer,可各自挂 RenderTexture——纹理与渲染纹理不是一一对应。

阅读导航:上一节:11.3 像素格式 · 下一节:12.2 多渲染目标 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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