《OGRE 3D 渲染引擎原理与架构》6.2 发射器

粒子的来源是 ParticleEmitter:它决定每帧发射多少粒子(emission rate 经小数累积折算)、给粒子什么初始速度/方向/生命。lab 复现恒定速率计数、圆锥散布方向、速度/生命区间与 Point 两种初始化。

6.2 发射器

上一节看到 ParticleSystem::addEmitter("Point") 往系统里挂发射器。发射器就是粒子的来源:它负责回答两件事——「这一帧要发多少个粒子」「新粒子的初速度/方向/生命/颜色是什么」。OGRE 把这两件事拆成两个方法:_getEmissionCount(计数)与 _initParticle(初始化),这一节逐个拆解。

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

helio 四卷没有通用发射器抽象;cg 三卷讲粒子初速度的随机分布公式。这里解析真实 OGRE 的 ParticleEmitter:恒定速率怎么折算成逐帧整数、方向散布(randomDeviant)怎么落成代码、PointEmitter 等具体类型如何只覆写少量虚函数。

ParticleEmitter:计数与初始化分家

ParticleEmitter 同时继承 StringInterface 与 Particle——它既是一张「可读参数的表」,自己也是一个粒子(6.1 提过 Emitter 型粒子,发射器本身可以当粒子被发射):

// OgreMain/include/OgreParticleEmitter.h:ParticleEmitter 类(v14.6.3 源码摘录,已删减)
    class _OgreExport ParticleEmitter : public StringInterface, public Particle
    {
    protected:
        /// Parent particle system
        ParticleSystem* mParent;

        /// Rate in particles per second at which this emitter wishes to emit particles
        Real mEmissionRate;
        /// Name of the type of emitter, MUST be initialised by subclasses
        String mType;
        /// Base direction of the emitter, may not be used by some emitters
        Vector3 mDirection;
        /// Angle around direction which particles may be emitted, internally radians but angleunits for interface
        Radian mAngle;
        /// Min speed of particles
        Real mMinSpeed;
        /// Max speed of particles
        Real mMaxSpeed;
        /// Initial time-to-live of particles (min)
        Real mMinTTL;
        /// Initial time-to-live of particles (max)
        Real mMaxTTL;
参数含义
mEmissionRate每秒想发射的粒子数
mDirection / mAngle基方向 + 最大散布角(圆锥半径)
mMinSpeed / mMaxSpeed初速度区间
mMinTTL / mMaxTTL初始生命区间

每个具体发射器在构造函数里写 mType(如 "Point"、"Area"),ParticleSystemManager 按类型查工厂创建实例。

恒定速率:小数累积换算

发射速率是每秒的粒子数,而更新是每帧调用一次——高帧率下 rate * dt 往往小于 1。直接截断会让高帧率系统「一个都不发」。OGRE 用 mRemainder 累积小数:

// OgreMain/src/OgreParticleEmitter.cpp:ParticleEmitter::genConstantEmissionCount(v14.6.3 源码摘录,已删减)
    unsigned short ParticleEmitter::genConstantEmissionCount(Real timeElapsed)
    {
        if (mEnabled)
        {
            if(mDurationMax < 0)
            {
                // single-shot burst
                setEnabled(false);
                return mEmissionRate;
            }

            unsigned short intRequest = (unsigned short)mRemainder;
            mRemainder -= intRequest;

            // Keep fractions, otherwise a high frame rate will result in zero emissions!
            mRemainder += mEmissionRate * timeElapsed;

            // Check duration
            if (mDurationMax)
            {
                mDurationRemain -= timeElapsed;
                if (mDurationRemain <= 0) 
                {
                    // Disable, duration is out (takes effect next time)
                    setEnabled(false);
                }
            }
            return intRequest;
        }

读出来的逻辑:每帧先把 mRemainder 的整数部分 intRequest 返回,再从余数里减掉,最后加上 mEmissionRate * timeElapsed。这样低帧率攒出的 0.5 个粒子会滚到下帧一起发,长期平均正好等于速率。注释点明初衷:Keep fractions, otherwise a high frame rate will result in zero emissions!

_getEmissionCount 只是把这个函数包一层虚接口,让子类能换成别的计数策略:

// OgreMain/include/OgreParticleEmitter.h:ParticleEmitter::_getEmissionCount(v14.6.3 源码摘录,已删减)
        virtual unsigned short _getEmissionCount(Real timeElapsed)
        {
            return genConstantEmissionCount(timeElapsed);
        }

初始方向与速度:gen 系列工具

新粒子的方向由 genEmissionDirection 生成。它处理两种情况:以 mDirPositionRef 为参照(爆炸/内爆按粒子位置指向中心),或者按 mDirection 做圆锥散布:

// OgreMain/src/OgreParticleEmitter.cpp:ParticleEmitter::genEmissionDirection(v14.6.3 源码摘录,已删减)
    void ParticleEmitter::genEmissionDirection( const Vector3 &particlePos, Vector3& destVector )
    {
        if( mUseDirPositionRef )
        {
            Vector3 particleDir = particlePos - mDirPositionRef;
            particleDir.normalise();

            if (mAngle != Radian(0))
            {
                // Randomise angle
                Radian angle(sampleSphereUniform(mAngle.valueRadians()));

                // Randomise direction
                destVector = particleDir.randomDeviant( angle );
            }
            else
            {
                // Constant angle
                destVector = particleDir;
            }
        }
        else
        {
            if (mAngle != Radian(0))
            {
                // Randomise angle
                Radian angle(sampleSphereUniform(mAngle.valueRadians()));

                // Randomise direction
                destVector = mDirection.randomDeviant(angle, mUp);
            }
            else
            {
                // Constant angle
                destVector = mDirection;
            }
        }
    }

randomDeviant(angle) 返回与基方向夹角不超过 angle 的随机单位向量;sampleSphereUniform 保证散布在球面锥内均匀。方向定了之后,genEmissionVelocity 给它乘上速度标量:

// OgreMain/src/OgreParticleEmitter.cpp:ParticleEmitter::genEmissionVelocity(v14.6.3 源码摘录,已删减)
    void ParticleEmitter::genEmissionVelocity(Vector3& destVector)
    {
        Real scalar;
        if (mMinSpeed != mMaxSpeed)
        {
            scalar = Math::RangeRandom(mMinSpeed, mMaxSpeed);
        }
        else
        {
            scalar = mMinSpeed;
        }

        destVector *= scalar;
    }

初生命同理,genEmissionTTL 在 [mMinTTL, mMaxTTL] 里取随机值(6.1 的 lab 已经验证过双生命字段)。

PointEmitter:覆写最少的典型

具体发射器做的工作极少。PointEmitter 只覆写 _initParticle,其余全用基类工具:

// PlugIns/ParticleFX/src/OgrePointEmitter.cpp:PointEmitter::_initParticle(v14.6.3 源码摘录,已删减)
    void PointEmitter::_initParticle(Particle* pParticle)
    {
        // Very simple emitter, uses default implementations with no modification

        // Call superclass
        ParticleEmitter::_initParticle(pParticle);

        // Point emitter emits from own position
        pParticle->mPosition = mPosition;

        // Generate complex data by reference
        genEmissionColour(pParticle->mColour);
        genEmissionDirection( pParticle->mPosition, pParticle->mDirection );
        genEmissionVelocity(pParticle->mDirection);

        // Generate simpler data
        pParticle->mTimeToLive = pParticle->mTotalTimeToLive = genEmissionTTL();
    }

流程就是组装:位置取发射器自己的位置,颜色/方向/速度/生命逐个调 gen 函数。DirectionEmitter 并不是 OGRE 自带类——方向型发射行为住在基类的 genEmissionDirection 里,ParticleFX 插件提供的是 Point/Area/Box/Ring/Ellipsoid 等按发射区域划分的类型。OGRE 用「基类给工具、子类只覆写初始化」的方式,让新发射器只需写十几行。

源码定位

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

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

下面用纯 C++ 复现发射速率计数、圆锥散布与初速度/生命区间。它与 src/06-2-particle-emitter.cpp 逐字节一致:

// file: src/06-2-particle-emitter.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/06-2-particle-emitter.cpp -o bin/06-2-particle-emitter && ./bin/06-2-particle-emitter
//
// 复现 ParticleEmitter 的发射速率与粒子初始化(对应 OgreParticleEmitter.h 71-、
//   OgreParticleEmitter.cpp 243-365、PlugIns/ParticleFX/src/OgrePointEmitter.cpp 48-):
//   genConstantEmissionCount() 用 mRemainder 保留小数,把 emissionRate*dt 折算成整数请求;
//   genEmissionDirection() 以 mDirection 为基向量、按 mAngle 做圆锥随机散布;
//   genEmissionVelocity() 在 [mMinSpeed,mMaxSpeed] 内随机缩放单位方向(方向向量长度即速度);
//   genEmissionTTL() 在 [mMinTTL,mMaxTTL] 内给初始生命;
//   PointEmitter 从自身位置发射,DirectionEmitter 沿基方向发射,两者共享基类计数逻辑。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cmath>
#include <cstdint>
#include <vector>

namespace ogre_repro {

// 固定种子的伪随机,保证断言可复现
static uint64_t gSeed = 0x9E3779B97F4A7C15ull;
static float randUnit() {
  gSeed ^= gSeed << 13;
  gSeed ^= gSeed >> 7;
  gSeed ^= gSeed << 17;
  return static_cast<float>((gSeed >> 8) & 0xFFFFFF) / static_cast<float>(1 << 24);
}
static float randRange(float min, float max) { return min + (max - min) * randUnit(); }

struct Vec3 {
  float x, y, z;
  Vec3 operator+(const Vec3& o) const { return {x + o.x, y + o.y, z + o.z}; }
  Vec3 operator*(float s) const { return {x * s, y * s, z * s}; }
  float dot(const Vec3& o) const { return x * o.x + y * o.y + z * o.z; }
  float length() const { return std::sqrt(dot(*this)); }
  Vec3 normalized() const {
    float l = length();
    return l > 1e-6f ? Vec3{x / l, y / l, z / l} : Vec3{0, 0, 0};
  }
  static Vec3 cross(const Vec3& a, const Vec3& b) {
    return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
  }
};

struct Particle {
  Vec3 position{0, 0, 0};
  Vec3 direction{0, 0, 0};   // 长度即速度
  float timeToLive = 0;
  float totalTimeToLive = 0;
};

// 对应 OgreParticleEmitter.h 的 ParticleEmitter(71-,extends StringInterface, Particle)
class ParticleEmitter {
 public:
  // 对应 genConstantEmissionCount(162-):返回本帧应发射的整数请求数
  unsigned int genConstantEmissionCount(float dt) {
    if (!mEnabled) return 0;
    unsigned int intRequest = static_cast<unsigned int>(mRemainder);
    mRemainder -= static_cast<float>(intRequest);
    mRemainder += mEmissionRate * dt;
    return intRequest;
  }

  // 对应 genEmissionDirection(243-):基方向 + 圆锥随机散布,返回单位向量
  Vec3 genEmissionDirection() {
    if (mAngle <= 0) return mDirection.normalized();
    float cosMax = std::cos(mAngle);
    float cosA = 1.0f - randUnit() * (1.0f - cosMax);  // 均匀取锥内方向
    float sinA = std::sqrt(1.0f - cosA * cosA);
    float phi = randRange(0.0f, 2.0f * 3.14159265f);
    Vec3 axis = std::fabs(mDirection.z) < 0.999f ? Vec3{0, 0, 1} : Vec3{0, 1, 0};
    Vec3 u = Vec3::cross(axis, mDirection).normalized();
    Vec3 v = Vec3::cross(mDirection, u).normalized();
    Vec3 d = mDirection * cosA + u * (sinA * std::cos(phi)) + v * (sinA * std::sin(phi));
    return d.normalized();
  }

  // 对应 genEmissionVelocity(285-):在 [min,max] 内随机缩放方向
  void genEmissionVelocity(Vec3& dir) {
    float scalar = (mMinSpeed != mMaxSpeed) ? randRange(mMinSpeed, mMaxSpeed) : mMinSpeed;
    dir = dir * scalar;
  }

  // 对应 genEmissionTTL(300-):在 [min,max] 内取初始生命
  float genEmissionTTL() {
    return (mMaxTTL != mMinTTL) ? randRange(mMinTTL, mMaxTTL) : mMinTTL;
  }

  // 对应 _initParticle(399-):初始化一个粒子(子类覆写位置来源)
  virtual void initParticle(Particle& p) {
    p.direction = genEmissionDirection();
    genEmissionVelocity(p.direction);
    p.timeToLive = p.totalTimeToLive = genEmissionTTL();
  }

  void setEmissionRate(float rate) { mEmissionRate = rate; }
  void setAngle(float angle) { mAngle = angle; }
  void setParticleVelocity(float min, float max) {
    mMinSpeed = min;
    mMaxSpeed = max;
  }
  void setTimeToLive(float min, float max) {
    mMinTTL = min;
    mMaxTTL = max;
  }
  void setDirection(const Vec3& dir) { mDirection = dir; }
  void setEnabled(bool on) { mEnabled = on; }

 protected:
  float mEmissionRate = 10.0f;
  float mRemainder = 0.0f;    // 小数累积,对应 mRemainder
  Vec3 mDirection{0, 1, 0};   // 对应 mDirection
  float mAngle = 0.0f;        // 对应 mAngle(弧度)
  float mMinSpeed = 1.0f;
  float mMaxSpeed = 1.0f;
  float mMinTTL = 3.0f;
  float mMaxTTL = 5.0f;
  bool mEnabled = true;       // 对应 mEnabled
};

// 对应 PlugIns/ParticleFX 的 PointEmitter(OgrePointEmitter.cpp 48-)
class PointEmitter : public ParticleEmitter {
 public:
  explicit PointEmitter(const Vec3& pos) : mPosition(pos) {}
  void initParticle(Particle& p) override {
    p.position = mPosition;   // 点发射器从自身位置发射
    ParticleEmitter::initParticle(p);
  }
  Vec3 mPosition;
};

// 方向发射器:位置固定原点,沿基方向发射(基类逻辑的直接使用)
class DirectionEmitter : public ParticleEmitter {
 public:
  void initParticle(Particle& p) override {
    p.position = Vec3{0, 0, 0};  // 从原点沿基方向发射
    ParticleEmitter::initParticle(p);
  }
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 恒定速率 + 小数累积:rate=10, dt=0.1
  PointEmitter pe(Vec3{1, 2, 3});
  pe.setEmissionRate(10.0f);
  pe.setAngle(0.0f);
  pe.setParticleVelocity(2.0f, 2.0f);
  pe.setTimeToLive(4.0f, 4.0f);

  unsigned int total = 0;
  unsigned int first = pe.genConstantEmissionCount(0.1f);
  CHECK_EQ(first, 0u);                      // 首帧只累积小数
  unsigned int second = pe.genConstantEmissionCount(0.1f);
  CHECK_EQ(second, 1u);                     // 之后每帧整数请求
  for (int i = 0; i < 9; ++i) total += pe.genConstantEmissionCount(0.1f);
  CHECK_EQ(total + second, 10u);            // 11 帧共发出 10 个

  // PointEmitter 初始化:位置 = 发射器位置,速度与生命落在区间内
  Particle p;
  pe.initParticle(p);
  CHECK_EQ(p.position.x, 1.0f);
  CHECK_EQ(p.position.y, 2.0f);
  CHECK_EQ(p.position.z, 3.0f);
  float speed = p.direction.length();
  CHECK(speed >= 2.0f && speed <= 2.0f + 1e-5f);   // min==max -> 恒速 2
  CHECK(p.timeToLive >= 4.0f && p.timeToLive <= 4.0f + 1e-5f);
  CHECK(p.totalTimeToLive == p.timeToLive);

  // 角度散布:方向与基方向的夹角不超过 mAngle
  PointEmitter scatter(Vec3{0, 0, 0});
  scatter.setEmissionRate(10.0f);
  scatter.setAngle(0.5f);                     // 约 28.6 度
  scatter.setParticleVelocity(1.0f, 1.0f);
  Vec3 base{0, 1, 0};
  scatter.setDirection(base);
  Particle sp;
  scatter.initParticle(sp);
  float cosMin = std::cos(0.5f);
  CHECK(sp.direction.normalized().dot(base) >= cosMin - 1e-4f);
  CHECK(sp.position.x == 0.0f && sp.position.z == 0.0f);

  // DirectionEmitter:从原点沿基方向发射
  DirectionEmitter de;
  de.setEmissionRate(10.0f);
  de.setDirection(base);
  de.setParticleVelocity(5.0f, 10.0f);
  de.setTimeToLive(1.0f, 2.0f);
  Particle dp;
  de.initParticle(dp);
  CHECK_EQ(dp.position.x, 0.0f);
  float dspeed = dp.direction.length();
  CHECK(dspeed >= 5.0f && dspeed <= 10.0f);   // 速度随机落在 [5,10]
  CHECK(dp.timeToLive >= 1.0f && dp.timeToLive <= 2.0f);

  // 禁用的发射器不再请求粒子
  de.setEnabled(false);
  CHECK_EQ(de.genConstantEmissionCount(1.0f), 0u);

  return lab::report("06-2 发射器");
}

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

小结

  • ParticleEmitter 继承 StringInterface 与 Particle,是粒子的来源,计数与初始化分家。
  • genConstantEmissionCount 用 mRemainder 累积小数,把每秒速率折算成逐帧整数请求。
  • genEmissionDirection 按 mDirection + mAngle 做圆锥散布,genEmissionVelocity 在速度区间内缩放。
  • genEmissionTTL 给出 [mMinTTL, mMaxTTL] 内的初始生命,写入双生命字段。
  • 具体发射器(如 PointEmitter)只覆写 _initParticle,复用基类 gen 系列工具。
  • OGRE 用「基类给工具、工厂注册类型」的插件体系,新发射器十几行即可接入。

阅读导航:上一节:6.1 粒子系统 · 下一节:6.3 影响器 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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