游戏客户端架构 / 系统课时

实现粒子发射器

实现粒子发射器

有了粒子数据后,还需要一个对象负责持续创建、更新和回收粒子。本课将实现最小可运行的粒子发射器,并用固定容量对象池避免频繁申请内存,最终得到稳定可验证的粒子生命周期循环。

学习目标

  • 使用时间累加器按固定频率生成粒子
  • 为新粒子设置统一的初始位置、速度、寿命和尺寸
  • 更新全部活动粒子,并把失效对象归还对象池

发射器的工作流程

每一帧中,发射器先累加经过时间,根据发射间隔决定生成数量;随后更新所有活动粒子;最后将寿命结束的粒子移出活动集合并归还空闲池。三个阶段顺序固定,便于定位数量异常和生命周期错误。

粒子发射器生命周期流程图

固定容量对象池有两个集合:freeParticles 保存可复用对象,activeParticles 保存正在模拟的对象。生成时从空闲池取出并重置,失效时再放回空闲池,因此运行过程中不需要反复创建和销毁粒子。

完整实现

发射频率使用“每秒粒子数”表示。若频率为 4,发射间隔就是 0.25 秒。使用时间累加器而不是简单判断单帧时间,可以在帧率波动时补发遗漏的粒子。初始参数集中放入 EmitterConfig,实际项目可进一步改成随机范围。

下面代码可使用 C++17 编译运行。对象池容量为 5,每秒生成 4 颗粒子,每颗存活 1 秒。循环每帧推进 0.25 秒,因此活动数量会先增长,再稳定在 3。

cpp
#include <algorithm>
#include <iostream>
#include <memory>
#include <vector>

struct Vec2 {
    float x = 0.0f;
    float y = 0.0f;
};

struct Particle {
    Vec2 position;
    Vec2 velocity;
    float age = 0.0f;
    float lifetime = 1.0f;
    float size = 1.0f;

    void reset(Vec2 startPosition, Vec2 startVelocity,
               float newLifetime, float newSize) {
        position = startPosition;
        velocity = startVelocity;
        age = 0.0f;
        lifetime = newLifetime;
        size = newSize;
    }

    void update(float deltaTime) {
        position.x += velocity.x * deltaTime;
        position.y += velocity.y * deltaTime;
        age += deltaTime;
    }

    bool isAlive() const {
        return age < lifetime;
    }
};

struct EmitterConfig {
    float emissionRate = 4.0f;
    int maxEmitPerFrame = 8;
    Vec2 position{0.0f, 0.0f};
    Vec2 initialVelocity{1.0f, 2.0f};
    float lifetime = 1.0f;
    float startSize = 6.0f;
};

class ParticleEmitter {
public:
    ParticleEmitter(std::size_t capacity, EmitterConfig config)
        : config_(config) {
        storage_.reserve(capacity);
        freeParticles_.reserve(capacity);
        activeParticles_.reserve(capacity);

        for (std::size_t i = 0; i < capacity; ++i) {
            storage_.push_back(std::make_unique<Particle>());
            freeParticles_.push_back(storage_.back().get());
        }
    }

    void update(float deltaTime) {
        if (deltaTime <= 0.0f || config_.emissionRate <= 0.0f) {
            return;
        }

        emitAccumulator_ += deltaTime;
        const float interval = 1.0f / config_.emissionRate;
        int emittedThisFrame = 0;

        // 用 while 补偿低帧率,但限制单帧生成量,避免瞬时爆发。
        while (emitAccumulator_ >= interval &&
               emittedThisFrame < config_.maxEmitPerFrame) {
            emitAccumulator_ -= interval;
            emitOne();
            ++emittedThisFrame;
        }

        for (Particle* particle : activeParticles_) {
            particle->update(deltaTime);
        }

        activeParticles_.erase(
            std::remove_if(
                activeParticles_.begin(),
                activeParticles_.end(),
                [this](Particle* particle) {
                    if (particle->isAlive()) {
                        return false;
                    }
                    freeParticles_.push_back(particle);
                    return true;
                }),
            activeParticles_.end());
    }

    std::size_t activeCount() const {
        return activeParticles_.size();
    }

    std::size_t freeCount() const {
        return freeParticles_.size();
    }

private:
    void emitOne() {
        if (freeParticles_.empty()) {
            return;
        }

        Particle* particle = freeParticles_.back();
        freeParticles_.pop_back();
        particle->reset(
            config_.position,
            config_.initialVelocity,
            config_.lifetime,
            config_.startSize);
        activeParticles_.push_back(particle);
    }

    EmitterConfig config_;
    float emitAccumulator_ = 0.0f;
    std::vector<std::unique_ptr<Particle>> storage_;
    std::vector<Particle*> freeParticles_;
    std::vector<Particle*> activeParticles_;
};

int main() {
    ParticleEmitter emitter(5, EmitterConfig{});

    for (int frame = 1; frame <= 8; ++frame) {
        emitter.update(0.25f);
        std::cout << "frame=" << frame
                  << " active=" << emitter.activeCount()
                  << " free=" << emitter.freeCount() << '\n';
    }
}

预期输出:

text
frame=1 active=1 free=4
frame=2 active=2 free=3
frame=3 active=3 free=2
frame=4 active=3 free=2
frame=5 active=3 free=2
frame=6 active=3 free=2
frame=7 active=3 free=2
frame=8 active=3 free=2

若编译器、构建目录或可执行文件路径不同,只会影响运行命令,不会改变以上活动粒子与空闲粒子数量。

边界与验收

对象池为空时,示例直接跳过生成,这比临时扩容更容易控制性能峰值。若视觉效果要求粒子不能缺失,可以增加池容量;若内存预算更严格,则应降低发射频率或缩短寿命。

maxEmitPerFrame 用来限制卡顿后一帧内的补发数量。没有这个上限时,长时间停顿可能一次创建大量粒子,进一步拖慢当前帧。生产实现还应限制 deltaTime 最大值,并按需加入随机初始参数和颜色、尺寸插值。

运行示例后,前三帧的活动数量应从 1 增长到 3,之后保持稳定;同时 active + free 应始终等于对象池容量 5。如果总数发生变化,说明生成或回收流程丢失了对象。

本课总结

  • 时间累加器能在帧率波动时保持平均发射频率
  • 对象池通过“空闲、活动、回收”循环避免频繁分配内存
  • 单帧生成上限和容量检查能够防止卡顿后的粒子数量失控

下一课预告

下一课可以在发射器输出的活动粒子基础上接入批量渲染,并让颜色、透明度和尺寸随生命周期连续变化。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

实现粒子发射器

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通