《OGRE 3D 渲染引擎原理与架构》12.1 布告板集合

布告板集合是粒子和地面特效的渲染单元:BillboardSet 同时继承 MovableObject 与 Renderable,用预分配池管理活板,池耗尽时可自动翻倍或静默失败,并按到相机的距离排序。lab 复现池配额、autoextend 翻倍、耗竭返回 null 与按距离降序排序。

12.1 布告板集合

布告板(billboard)是始终面向相机的一块矩形,两块三角形拼成,广泛用于粒子、光晕、地面贴花。OGRE 不单画一块,而是把「同样尺寸、同一材质、相近位置」的板收进一个 BillboardSet,作为单个渲染操作一次画完。这一节看这个集合怎么管理它的池与排序;12.2 看板的类型,12.3 看面片生成。

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

helio 四卷的粒子用独立精灵节点,逐帧更新节点变换,量大了性能堪忧;ogre-render 卷讲过渲染操作但没谈布告板。这里解析真实 OGRE 的 BillboardSet:它同时继承 MovableObject(挂场景)与 Renderable(进渲染队列),用池复用板实例,用排序决定半透明板的绘制顺序。

BillboardSet:一个集合两块身份

类声明就点明它的双重身份——能挂场景节点、能渲染:

// OgreMain/include/OgreBillboardSet.h:BillboardSet(v14.6.3 源码摘录,已删减)
    class _OgreExport BillboardSet : public MovableObject, public Renderable
    {

MovableObject 让它像实体一样被挂到 SceneNode 上、被视锥剔除;Renderable 让它能提供 RenderOperation 进渲染队列。它自己是个「批量渲染器」——集合里成百上千块板,最终只产生一个渲染操作(4 顶点 + 6 索引 × 板数,见 12.3)。

池:预分配 + 活板计数

BillboardSet 不动态 new/delete 板实例,而是维护一个池:mBillboardPool 预先放好板对象,createBillboard 只把池里的下一个标记为激活。createBillboard 的完整逻辑见源码:

// OgreMain/src/OgreBillboardSet.cpp:BillboardSet::createBillboard(v14.6.3 源码摘录,已删减)
    Billboard* BillboardSet::createBillboard(
        const Vector3& position,
        const ColourValue& colour )
    {
        if( mActiveBillboards == mBillboardPool.size() )
        {
            if( mAutoExtendPool )
            {
                setPoolSize( getPoolSize() * 2 );
            }
            else
            {
                return 0;
            }
        }

        // Get a new billboard
        Billboard* newBill = mBillboardPool[mActiveBillboards++];
        newBill->setPosition(position);
        newBill->setColour(colour);
        ...
        return newBill;
    }

池耗尽的两种结局:mAutoExtendPool 为真则 setPoolSize(getPoolSize() * 2)——翻倍扩展;为假则返回 0(空指针)静默失败。setPoolSize 只增不减,小于当前容量直接返回:

// OgreMain/src/OgreBillboardSet.cpp:BillboardSet::setPoolSize/increasePool(v14.6.3 源码摘录,已删减)
    void BillboardSet::setPoolSize( size_t size )
    {
        // If we're driving this from our own data, allocate billboards
        if (!mExternalData)
        {
            // Never shrink below size()
            size_t currSize = mBillboardPool.size();
            if (currSize >= size)
                return;

            this->increasePool(size);
        }
        ...
    }
    ...
    void BillboardSet::increasePool(size_t size)
    {
        size_t oldSize = mBillboardPool.size();

        // Increase size
        mBillboardPool.resize(size);

        // Create new billboards
        for( size_t i = oldSize; i < size; ++i )
            mBillboardPool[i] = OGRE_NEW Billboard();
    }

配额相关访问器集中在头文件:

// OgreMain/include/OgreBillboardSet.h:getNumBillboards/setAutoextend/getPoolSize(v14.6.3 源码摘录,已删减)
        int getNumBillboards(void) const { return static_cast<int>(mActiveBillboards); }
        ...
        void setAutoextend(bool autoextend) { mAutoExtendPool = autoextend; }
        ...
        unsigned int getPoolSize() const { return static_cast<unsigned int>(mBillboardPool.size()); }
成员/方法语义
mBillboardPool预分配池,容量即 getPoolSize()
mActiveBillboards已激活(活)板数,getNumBillboards() 返回它
setAutoextend(true)池耗尽时翻倍扩展
setAutoextend(false)池耗尽时返回 null 静默失败

排序:半透明的代价

布告板常带半透明纹理,绘制顺序错了就会出现透明错误。_sortBillboards 按距离排序,默认走方向排序(SM_DIRECTION),启用精确面向或垂直类型时走距离排序(SM_DISTANCE):

// OgreMain/src/OgreBillboardSet.cpp:BillboardSet::_sortBillboards(v14.6.3 源码摘录,已删减)
    void BillboardSet::_sortBillboards( Camera* cam)
    {
        static RadixSort<BillboardPool, Billboard*, float> mRadixSorter;

        switch (_getSortMode())
        {
        case SM_DIRECTION:
            mRadixSorter.sort(mBillboardPool.begin(), mBillboardPool.begin() + mActiveBillboards,
                              SortByDirectionFunctor(-mCamDir));
            break;
        case SM_DISTANCE:
            mRadixSorter.sort(mBillboardPool.begin(), mBillboardPool.begin() + mActiveBillboards,
                              SortByDistanceFunctor(mCamPos));
            break;
        }
    }

距离排序的关键在 functor 的返回值:

// OgreMain/src/OgreBillboardSet.cpp:SortByDistanceFunctor(v14.6.3 源码摘录,已删减)
    float BillboardSet::SortByDistanceFunctor::operator()(Billboard* bill) const
    {
        // Sort descending by squared distance
        return - (sortPos - bill->getPosition()).squaredLength();
    }

返回负的平方距离,配合升序排序器得到最远在前的顺序——先画远的半透明板,近的板盖在上面。用平方距离免去每板一次开方,是批量排序的经典优化。

源码定位

  • OgreMain/include/OgreBillboardSet.h :BillboardSet(118)、createBillboard(345)、getNumBillboards(357)、setAutoextend(374)、setPoolSize(403)、getPoolSize(411)、_sortBillboards(666)
  • OgreMain/src/OgreBillboardSet.cpp :createBillboard(109)、_sortBillboards(190)、SortByDistanceFunctor(214)、setPoolSize(522)、increasePool(749)

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

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

下面用纯 C++ 复现布告板池的配额、扩展与按距离排序。它与 src/12-1-billboard-set.cpp 逐字节一致:

// file: src/12-1-billboard-set.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/12-1-billboard-set.cpp -o bin/12-1-billboard-set && ./bin/12-1-billboard-set
//
// 复现 BillboardSet 的池与排序(对应 OgreBillboardSet.h 118/345/403/411、OgreBillboardSet.cpp 109/749/190):
//   setPoolSize 预分配池;createBillboard 从池取活板、池耗尽时按 setAutoextend 翻倍或返回 null;
//   _sortBillboards 按到相机的平方距离降序(最远先画)。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <algorithm>
#include <cstdint>
#include <vector>

namespace ogre_repro {

struct Vec3 {
  float x = 0.f;
  float y = 0.f;
  float z = 0.f;
  Vec3() = default;
  Vec3(float px, float py, float pz) : x(px), y(py), z(pz) {}
};

float sqDist(const Vec3& a, const Vec3& b) {
  float dx = a.x - b.x;
  float dy = a.y - b.y;
  float dz = a.z - b.z;
  return dx * dx + dy * dy + dz * dz;
}

// 对应 OgreBillboard.h 68:Billboard(简化)
struct Billboard {
  Vec3 mPosition;
  explicit Billboard(const Vec3& p) : mPosition(p) {}
};

// 对应 OgreBillboardSet.h 118:BillboardSet(池 + 排序,节选)
class BillboardSet {
 public:
  explicit BillboardSet(unsigned int poolSize) : mAutoExtendPool(true) {
    increasePool(poolSize);
  }
  // 对应 OgreBillboardSet.h 403:setPoolSize
  void setPoolSize(size_t size) { increasePool(size); }
  // 对应 OgreBillboardSet.h 411:getPoolSize
  unsigned int getPoolSize() const { return static_cast<unsigned int>(mBillboardPool.size()); }
  // 对应 OgreBillboardSet.h 374:setAutoextend
  void setAutoextend(bool autoextend) { mAutoExtendPool = autoextend; }
  // 对应 OgreBillboardSet.h 357:getNumBillboards
  int getNumBillboards() const { return static_cast<int>(mActiveBillboards); }
  // 对应 OgreBillboardSet.h 345:createBillboard
  Billboard* createBillboard(const Vec3& position) {
    if (mActiveBillboards == mBillboardPool.size()) {
      if (mAutoExtendPool) {
        setPoolSize(getPoolSize() * 2);
      } else {
        return nullptr;
      }
    }
    Billboard* bb = mBillboardPool[mActiveBillboards++];
    bb->mPosition = position;
    return bb;
  }
  // 对应 OgreBillboardSet.h 427:getBillboard
  Billboard* getBillboard(unsigned int index) const { return mBillboardPool.at(index); }
  // 对应 OgreBillboardSet.cpp 190:_sortBillboards(按距离降序 = 最远在前)
  void sortByDistance(const Vec3& camPos) {
    std::sort(mBillboardPool.begin(), mBillboardPool.begin() + mActiveBillboards,
              [&](Billboard* a, Billboard* b) {
                return sqDist(a->mPosition, camPos) > sqDist(b->mPosition, camPos);
              });
  }

 private:
  // 对应 OgreBillboardSet.cpp 749:increasePool
  void increasePool(size_t size) {
    size_t oldSize = mBillboardPool.size();
    mBillboardPool.resize(size);
    for (size_t i = oldSize; i < size; ++i)
      mBillboardPool[i] = new Billboard(Vec3(0.f, 0.f, 0.f));
  }
  // 对应 OgreBillboardSet.h 156:BillboardPool
  std::vector<Billboard*> mBillboardPool;
  // 对应 OgreBillboardSet.h 164:mActiveBillboards
  size_t mActiveBillboards = 0;
  // 对应 OgreBillboardSet.h 146:mAutoExtendPool
  bool mAutoExtendPool;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 初始池大小 = quota
  BillboardSet set(20);
  CHECK_EQ(set.getPoolSize(), 20u);
  CHECK_EQ(set.getNumBillboards(), 0);

  // createBillboard 添加活板
  Billboard* a = set.createBillboard(Vec3(0.f, 0.f, 0.f));
  Billboard* b = set.createBillboard(Vec3(10.f, 0.f, 0.f));
  CHECK(a != nullptr);
  CHECK(b != nullptr);
  CHECK_EQ(set.getNumBillboards(), 2);
  CHECK_EQ(set.getBillboard(1), b);

  // 池耗尽且不允许扩展:返回 null
  BillboardSet tight(2);
  tight.setAutoextend(false);
  tight.createBillboard(Vec3(1.f, 0.f, 0.f));
  tight.createBillboard(Vec3(2.f, 0.f, 0.f));
  CHECK(tight.createBillboard(Vec3(3.f, 0.f, 0.f)) == nullptr);

  // 池耗尽且允许扩展:翻倍
  BillboardSet grow(2);
  grow.setAutoextend(true);
  grow.createBillboard(Vec3(1.f, 0.f, 0.f));
  grow.createBillboard(Vec3(2.f, 0.f, 0.f));
  grow.createBillboard(Vec3(3.f, 0.f, 0.f));
  CHECK_EQ(grow.getPoolSize(), 4u);
  CHECK_EQ(grow.getNumBillboards(), 3);

  // 按距离排序:相机在原点,(10,0,0) 最远在前
  BillboardSet sorted(2);
  Billboard* near = sorted.createBillboard(Vec3(1.f, 0.f, 0.f));
  Billboard* far = sorted.createBillboard(Vec3(10.f, 0.f, 0.f));
  sorted.sortByDistance(Vec3(0.f, 0.f, 0.f));
  CHECK_EQ(sorted.getBillboard(0), far);
  CHECK_EQ(sorted.getBillboard(1), near);

  return lab::report("12-1 布告板集合");
}

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

小结

  • BillboardSet : MovableObject, Renderable 是粒子的批量渲染容器,整集合一次渲染。
  • 池管理:mBillboardPool 预分配,createBillboard 只激活池中下一个实例。
  • 池耗尽两结局:setAutoextend(true) 翻倍扩展,false 返回 null 静默失败。
  • setPoolSize 只增不减,小于当前容量直接返回。
  • 距离排序返回负平方距离,配合升序得到「最远在前」,正确绘制半透明板。

阅读导航:上一节:11.3 天空渲染实现 · 下一节:12.2 布告板类型 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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