particles.cpp

Go to the documentation of this file.

 
 
#include "asw/modules/particles.h"
 
#include <algorithm>
#include <cmath>
 
#include "asw/modules/draw.h"
#include "asw/modules/random.h"
#include "asw/modules/util.h"
 
namespace asw {
 
ParticleEmitter::ParticleEmitter(const ParticleConfig& config, uint32_t maxParticles)
    : config(config)
    , particles(maxParticles)
{
}
 
void ParticleEmitter::set_emission_rate(float rate)
{
    emission_rate = rate;
}
 
void ParticleEmitter::emit(uint32_t count)
{
    for (uint32_t i = 0; i < count; ++i) {
        spawn_particle();
    }
}
 
void ParticleEmitter::start()
{
    emitting = true;
}
 
void ParticleEmitter::stop()
{
    emitting = false;
}
 
void ParticleEmitter::update(float dt)
{
    // Auto-emit
    if (emitting && emission_rate > 0.0F) {
        emission_accumulator += emission_rate * dt;
        while (emission_accumulator >= 1.0F) {
            spawn_particle();
            emission_accumulator -= 1.0F;
        }
    }
 
    // Update alive particles (swap-and-shrink)
    for (uint32_t i = 0; i < alive_count;) {
        auto& p = particles[i];
        p.age += dt;
 
        if (p.age >= p.lifetime) {
            particles[i] = particles[alive_count - 1];
            alive_count--;
            continue;
        }
 
        p.velocity += config.gravity * dt;
        p.position += p.velocity * dt;
        ++i;
    }
}
 
void ParticleEmitter::draw()
{
    draw_offset(Vec2<float>(0.0F, 0.0F));
}
 
void ParticleEmitter::draw(const Camera& camera)
{
    draw_offset(camera.get_view().position);
}
 
void ParticleEmitter::draw_offset(const Vec2<float>& offset)
{
    // Sentinel: the first textured particle always pushes its alpha, so the
    // emitter never assumes what the shared texture was left at.
    float last_alpha = -1.0F;
 
    for (uint32_t i = 0; i < alive_count; ++i) {
        const auto& p = particles[i];
        // A zero lifetime would divide by zero, treat it as already over
        const float t = p.lifetime > 0.0F ? std::min(p.age / p.lifetime, 1.0F) : 1.0F;
 
        // Interpolate visuals
        const float size = util::lerp(config.size_start, config.size_end, t);
        const float alpha = util::lerp(config.alpha_start, config.alpha_end, t);
 
        if (config.texture != nullptr) {
            const auto dest = Quad<float>(p.position.x - offset.x - (size / 2.0F),
                p.position.y - offset.y - (size / 2.0F), size, size);
 
            if (alpha != last_alpha) {
                draw::set_alpha(config.texture, alpha);
                last_alpha = alpha;
            }
 
            draw::stretch_sprite(config.texture, dest);
        } else {
            auto color = config.color_start.lerp(config.color_end, t);
            color.a = Color::to_channel(color.a * alpha);
 
            draw::circle_fill(p.position - offset, size / 2.0F, color);
        }
    }
 
    // Restore the default once per emitter instead of once per particle.
    if (last_alpha >= 0.0F && last_alpha != 1.0F) {
        draw::set_alpha(config.texture, 1.0F);
    }
}
 
uint32_t ParticleEmitter::get_alive_count() const
{
    return alive_count;
}
 
void ParticleEmitter::spawn_particle()
{
    if (alive_count >= particles.size()) {
        return;
    }
 
    auto& p = particles[alive_count];
    p.position = transform.position;
    p.age = 0.0F;
    p.lifetime = random::between(config.lifetime_min, config.lifetime_max);
    p.alive = true;
 
    const float speed = random::between(config.speed_min, config.speed_max);
    const float angle = random::between(config.angle_min, config.angle_max);
    p.velocity = Vec2<float>::from_angle(angle, speed);
 
    p.size = config.size_start;
    p.rotation = 0.0F;
 
    alive_count++;
}
 
} // namespace asw