《OGRE 3D 渲染引擎原理与架构》6.1 粒子系统

粒子特效的骨架是 ParticleSystem:它继承 MovableObject 与 StringInterface,用发射器造粒子、用影响器改粒子,并通过 particle quota 限制同时存活的粒子数。lab 复现粒子数据结构、quota 限制与激活/死亡生命周期。

6.1 粒子系统

爆炸的火花、升腾的烟雾、飘落的尘埃——OGRE 用一个统一的抽象做这些特效:粒子系统。它的本体是一个 ParticleSystem,同时继承 MovableObject(能挂到场景节点上)与 StringInterface(能读脚本参数)。这一节先看这个「容器」怎么组织粒子,以及一个贯穿全章的概念——粒子配额。

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

helio 四卷从零实现的引擎里有布告板精灵但没做通用粒子系统;cg 三卷讲粒子运动学的图形学原理。这里解析真实 OGRE 的 ParticleSystem:粒子在内存里怎么存、配额怎么卡、每帧生命周期怎么推进,以及 12 章的 BillboardSet 怎么被当作默认渲染器复用。

ParticleSystem:一个会自我更新的粒子容器

ParticleSystem 的类声明很短,但信息量大:

// OgreMain/include/OgreParticleSystem.h:ParticleSystem 类(v14.6.3 源码摘录,已删减)
    class _OgreExport ParticleSystem : public MovableObject, public StringInterface
    {
    public:
        /// Default constructor required for STL creation in manager
        ParticleSystem();
        /** Creates a particle system with no emitters or affectors.

            You should use the ParticleSystemManager to create particle systems rather than creating
            them directly.
        */
        ParticleSystem(const String& name, const String& resourceGroupName);

        virtual ~ParticleSystem();

两个基类各司其职:MovableObject 让它能像实体、灯光一样被挂到 SceneNode 上、进渲染队列;StringInterface 让它能从粒子脚本里按名字读写参数。注意构造函数旁边那句注释:粒子系统不要直接 new,用 ParticleSystemManager 创建。

粒子系统自己不画粒子——画的部分交给一个 ParticleSystemRenderer(默认是 12 章的 BillboardParticleRenderer)。ParticleSystem 只做三件事:生成(emitters)、修改(affectors)、推进(每帧 _update)。

发射器与影响器的挂载点

粒子从哪来、被谁改?答案是两个平行的列表,各自带一套工厂体系:

// OgreMain/include/OgreParticleSystem.h:ParticleSystem::addEmitter(v14.6.3 源码摘录,已删减)
        ParticleEmitter* addEmitter(const String& emitterType);
// OgreMain/include/OgreParticleSystem.h:ParticleSystem::addAffector(v14.6.3 源码摘录,已删减)
        ParticleAffector* addAffector(const String& affectorType);

参数都是一个类型名字符串(如 "Point"、"ColourFader")。系统内部查表:ParticleSystemManager 里登记着发射器工厂与影响器工厂,按名字创建实例(6.2、6.3 展开)。私有成员把两者分开存:

// OgreMain/include/OgreParticleSystem.h:ParticleSystem 私有成员(v14.6.3 源码摘录,已删减)
        typedef std::vector<ParticleEmitter*> ParticleEmitterList;
        typedef std::vector<ParticleAffector*> ParticleAffectorList;

        /// List of particle emitters, ie sources of particles
        ParticleEmitterList mEmitters;
        /// List of particle affectors, ie modifiers of particles
        ParticleAffectorList mAffectors;
成员含义
mEmitters粒子来源:每个发射器每帧请求一定数量的粒子
mAffectors粒子修改器:每帧遍历活动粒子施加影响

Particle:粒子的数据单元

每个粒子的全部状态在一个 Particle 结构里,字段全公开——注释说得很直白,几千上万粒子的系统里用 get/set 太贵:

// OgreMain/include/OgreParticle.h:Particle(v14.6.3 源码摘录,已删减)
    class _OgreExport Particle : public FXAlloc
    {
    public:
        /// Particle width
        float mWidth;
        /// Particle height
        float mHeight;
        /// Current rotation value
        Radian mRotation;
        // Note the intentional public access to internal variables
        // Accessing via get/set would be too costly for 000's of particles
        /// World position
        Vector3 mPosition;
        /// Direction (and speed) 
        Vector3 mDirection;
        /// Current colour
        RGBA mColour;
        /// Time to live, number of seconds left of particles natural life
        float mTimeToLive;
        /// Total Time to live, number of seconds of particles natural life
        float mTotalTimeToLive;
字段含义
mPosition / mDirection位置与方向(方向向量长度即速度)
mTimeToLive剩余生命秒数,每帧递减,归零回收
mTotalTimeToLive初始生命秒数,颜色淡出等效果按它归一化
mColour / mWidth / mHeight / mRotation外观参数

关键的是双生命字段:mTimeToLive 每帧被 _expire 递减;mTotalTimeToLive 保持初始值不变。影响器(6.3)要算「生命还剩百分之几」时就拿 mTimeToLive / mTotalTimeToLive——这是颜色淡出、尺寸缩放等效果的时间基准。

粒子池与配额

粒子系统的内存管理是「池复用」而不是「新建/删除」:所有粒子实例预先分配在一个池子里,活着的指针进活动列表,死了的退回空闲列表,下次发射直接复用,避免内存抖动。三个私有成员分工明确:

// OgreMain/include/OgreParticleSystem.h:ParticleSystem 池结构(v14.6.3 源码摘录,已删减)
        /** Active particle list.

                This is a linked list of pointers to particles in the particle pool.
            @par
                This allows very fast insertions and deletions from anywhere in 
                the list to activate / deactivate particles as well as reuse of 
                Particle instances in the pool without construction & destruction 
                which avoids memory thrashing.
        */
        ParticlePool mActiveParticles;

        /** Free particle queue.

                This contains a list of the particles free for use as new instances
                as required by the set. Particle instances are preconstructed up 
                to the estimated size in the mParticlePool vector and are 
                referenced on this deque at startup. As they get used this list
                reduces, as they get released back to to the set they get added
                back to the list.
        */
        ParticlePool mFreeParticles;

        /** Pool of particle instances for use and reuse in the active particle list.

                This vector will be preallocated with the estimated size of the set,and will extend as required.
        */
        ParticlePool mParticlePool;

mParticlePool 是容量本体,mActiveParticles/mFreeParticles 都只存指针。配额就是池子大小:

// OgreMain/include/OgreParticleSystem.h:ParticleSystem::setParticleQuota(v14.6.3 源码摘录,已删减)
        void setParticleQuota(size_t quota);

配额语义有三条要点:

  • 配额是同时存活的粒子数上限。发射器每帧请求发射时,_triggerEmitters 用 mFreeParticles.size() 当 emissionAllowed:请求总数超过空闲数,就按比例摊派(ratio = emissionAllowed / totalRequested),保证系统不超配额。
  • 配额只能增不能减:setParticleQuota 内部先比较当前池大小,只有 currSize < size 才会扩充(见 6.1 的 lab 复现)。
  • 粒子死了就退回 mFreeParticles,空出来的容量立刻可被任何发射器复用。

每帧生命周期

_update(timeElapsed) 每帧被调用,内部顺序严格:

  1. _expire(timeElapsed):遍历活动列表,mTimeToLive < timeElapsed 的粒子通知渲染器后回收,其余递减 TTL。
  2. _triggerAffectors(timeElapsed):让每个影响器过一遍活动粒子(6.3)。
  3. _applyMotion(timeElapsed):mPosition += mDirection * timeElapsed 推进位置。
  4. 若开启发射,_triggerEmitters(timeElapsed) 按配额摊派后的请求数发射新粒子。

先过期、后运动的顺序保证同一帧里刚死的粒子不再动、刚生的粒子从出生点开始动。

粒子池与帧更新

flowchart LR
  Q["配额与空闲粒子池"] --> E["发射器计算数量并初始化"]
  E --> A["活动粒子列表"]
  A --> X["寿命检查"]
  X -->|"到期"| Q
  X -->|"存活"| F["影响器和运动更新"]
  F --> R["渲染器消费粒子状态"]
  F --> A

粒子数量由时间步长和池共同决定

系统更新将到期粒子归还池,活动粒子经过影响器与运动更新。发射器将速率换算为本次尝试发射的数量,再受池容量限制。渲染器读取活动集合。

固定随机种子和时间步长,逐次记录在用、发射、回收与受限数量。改变配额后区分仿真数量与绘制批次。

源码定位

  • OgreMain/include/OgreParticleSystem.h :ParticleSystem(63)、addEmitter(102)、addAffector(148)、setParticleQuota(239)、getNumParticles(188)、池成员 mActiveParticles/mFreeParticles/mParticlePool(607-624)、_expire/_triggerEmitters/_applyMotion(686-700)
  • OgreMain/include/OgreParticle.h :Particle(43)、字段 mPosition/mDirection/mTimeToLive/mTotalTimeToLive(62-74)
  • OgreMain/src/OgreParticleSystem.cpp :_update(429)、_expire(506)、_triggerEmitters(552)、_applyMotion(676)

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

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

下面用纯 C++ 复现粒子数据结构、quota 限制与激活/死亡生命周期。它与 src/06-1-particle-system.cpp 逐字节一致:

// file: src/06-1-particle-system.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/06-1-particle-system.cpp -o bin/06-1-particle-system && ./bin/06-1-particle-system
//
// 复现 ParticleSystem/Particle 与粒子生命周期(对应 OgreParticleSystem.h 63-、OgreParticle.h 43-):
//   Particle 携带位置/方向/生命字段(mPosition/mDirection/mTimeToLive/mTotalTimeToLive);
//   ParticleSystem 用 mParticlePool + mFreeParticles + mActiveParticles 管理粒子复用;
//   setParticleQuota() 只增不减,超出 quota 时停止发射(_triggerEmitters 按空闲数摊派);
//   _update 每帧先 _expire(TTL 耗尽回收进空闲池)再 _applyMotion(位置 += 方向*dt)。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <vector>

namespace ogre_repro {

struct Vec3 {
  float x, y, z;
};

// 对应 OgreParticle.h 的 Particle(43-):public 成员直接读写
struct Particle {
  Vec3 position{0, 0, 0};       // mPosition
  Vec3 direction{0, 0, 0};      // mDirection(含速度)
  float timeToLive = 10.0f;     // mTimeToLive
  float totalTimeToLive = 10.0f;  // mTotalTimeToLive
  bool inUse = false;
};

// 对应 OgreParticleSystem.h 的 ParticleSystem(63-)
class ParticleSystem {
 public:
  explicit ParticleSystem(size_t quota) { increasePool(quota); }

  // 对应 setParticleQuota(239-):只增不减,新增容量进空闲池
  void setParticleQuota(size_t size) {
    if (size > mQuota) {
      size_t add = size - mQuota;
      mQuota = size;
      for (size_t i = 0; i < add; ++i) {
        size_t idx = mParticlePool.size();
        mParticlePool.emplace_back();
        mFreeParticles.push_back(idx);
      }
    }
  }
  size_t getQuota() const { return mQuota; }

  // 对应 createParticle(201-):从空闲池取一个,复用旧实例
  size_t createParticle() {
    if (mFreeParticles.empty()) return kNoParticle;  // quota 已满
    size_t idx = mFreeParticles.front();             // 从队列头部取
    mFreeParticles.erase(mFreeParticles.begin());
    mParticlePool[idx].inUse = true;
    mActiveParticles.push_back(idx);
    return idx;
  }

  // 对应 _expire(506-):TTL 耗尽移出活动列表并回收
  void expire(float dt) {
    for (auto it = mActiveParticles.begin(); it != mActiveParticles.end();) {
      Particle& p = mParticlePool[*it];
      if (p.timeToLive < dt) {
        p.inUse = false;
        mFreeParticles.push_back(*it);
        it = mActiveParticles.erase(it);
      } else {
        p.timeToLive -= dt;
        ++it;
      }
    }
  }

  // 对应 _applyMotion(676-):位置 += 方向 * 时间
  void applyMotion(float dt) {
    for (size_t idx : mActiveParticles) {
      Particle& p = mParticlePool[idx];
      p.position.x += p.direction.x * dt;
      p.position.y += p.direction.y * dt;
      p.position.z += p.direction.z * dt;
    }
  }

  void update(float dt) {
    expire(dt);
    applyMotion(dt);
  }

  size_t activeCount() const { return mActiveParticles.size(); }
  size_t freeCount() const { return mFreeParticles.size(); }
  Particle& particle(size_t idx) { return mParticlePool[idx]; }

  // 对应 _triggerEmitters 里的 emissionAllowed = mFreeParticles.size()
  size_t emissionAllowed() const { return mFreeParticles.size(); }

  static const size_t kNoParticle;

 private:
  void increasePool(size_t size) {
    mQuota = size;
    for (size_t i = 0; i < size; ++i) {
      size_t idx = mParticlePool.size();
      mParticlePool.emplace_back();
      mFreeParticles.push_back(idx);
    }
  }

  size_t mQuota = 0;
  std::vector<Particle> mParticlePool;    // mParticlePool
  std::vector<size_t> mFreeParticles;     // mFreeParticles
  std::vector<size_t> mActiveParticles;   // mActiveParticles
};

const size_t ParticleSystem::kNoParticle = static_cast<size_t>(-1);

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  ParticleSystem ps(10);
  CHECK(ps.getQuota() == 10);
  CHECK(ps.freeCount() == 10);
  CHECK(ps.activeCount() == 0);

  // 创建第一个粒子:写位置/速度/生命
  size_t p0 = ps.createParticle();
  CHECK(p0 == 0);
  ps.particle(p0).position = Vec3{1, 2, 3};
  ps.particle(p0).direction = Vec3{1, 0, 0};
  ps.particle(p0).timeToLive = ps.particle(p0).totalTimeToLive = 5.0f;
  CHECK(ps.activeCount() == 1);
  CHECK(ps.freeCount() == 9);

  // 运动:位置 += 方向 * dt
  ps.applyMotion(0.5f);
  CHECK_EQ(ps.particle(p0).position.x, 1.5f);  // 1 + 1*0.5
  CHECK_EQ(ps.particle(p0).position.y, 2.0f);

  // 生命递减
  ps.expire(1.0f);
  CHECK(ps.activeCount() == 1);                // TTL 5 -> 4,仍存活
  CHECK_EQ(ps.particle(p0).timeToLive, 4.0f);

  // 占满 quota:再创建 9 个
  for (int i = 0; i < 9; ++i) ps.createParticle();
  CHECK(ps.activeCount() == 10);
  CHECK(ps.freeCount() == 0);
  CHECK(ps.createParticle() == ParticleSystem::kNoParticle);  // quota 耗尽

  // quota 只增不减
  ps.setParticleQuota(5);
  CHECK(ps.getQuota() == 10);   // 不缩减
  ps.setParticleQuota(15);
  CHECK(ps.getQuota() == 15);
  CHECK(ps.freeCount() == 5);   // 新增 5 个空闲

  // 粒子死亡回收到空闲池
  ps.particle(p0).timeToLive = 0.2f;
  ps.update(0.5f);              // TTL(0.2) < dt(0.5) -> 死亡
  CHECK(ps.activeCount() == 9);
  CHECK(ps.freeCount() == 6);

  // 创建复用被回收的实例
  size_t reused = ps.createParticle();
  CHECK(ps.particle(reused).inUse);
  CHECK(ps.activeCount() == 10);

  // 配额摊派:空闲 5 个、请求 10 个 -> 只发 5
  size_t requested = 10, allowed = ps.emissionAllowed();
  size_t actual = requested < allowed ? requested : allowed;
  CHECK_EQ(actual, 5u);

  return lab::report("06-1 粒子系统");
}

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

小结

  • ParticleSystem 继承 MovableObject 与 StringInterface,是粒子特效的容器,不直接画粒子。
  • 粒子由发射器产生、影响器修改,mEmitters 与 mAffectors 两个列表各自挂工厂体系。
  • Particle 字段全公开:位置/方向/颜色/尺寸,加 mTimeToLive 与 mTotalTimeToLive 双生命。
  • 粒子走「池复用」:mParticlePool + 活动/空闲两个指针列表,避免反复构造析构。
  • 配额只增不减,_triggerEmitters 在请求超配时按比例摊派,超配则停发。

阅读导航:上一节:5.3 纹理阴影与投射 · 下一节:6.2 发射器 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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