Struct firework_rs::particle::ParticleConfig

pub struct ParticleConfig {
    pub init_pos: Vec2,
    pub init_vel: Vec2,
    pub trail_length: usize,
    pub life_time: Duration,
    pub color: (u8, u8, u8),
}

Struct that defines the configuration of Particle

Fields

init_pos: Vec2

init_vel: Vec2

trail_length: usize

life_time: Duration

Duration from Particle’s initialization to its Dead

color: (u8, u8, u8)

Color in RGB (from 0 to 255)

Implementations

impl ParticleConfig

pub fn new( init_pos: Vec2, init_vel: Vec2, trail_length: usize, life_time: Duration, color: (u8, u8, u8) ) -> Self

Create a new ParticleConfig

Examples found in repository

examples/fountain.rs (lines 83-89)

fn gen_fountain_firework(center: Vec2) -> Firework {
    let colors = vec![(226, 196, 136), (255, 245, 253), (208, 58, 99)];
    let mut particles = Vec::new();
    for v in gen_points_fan(
        300.,
        45,
        5 as f32 / 12 as f32 * PI,
        7 as f32 / 12 as f32 * PI,
    )
    .iter()
    {
        particles.push(ParticleConfig::new(
            center,
            *v,
            thread_rng().gen_range(28..38),
            Duration::from_secs_f32(thread_rng().gen_range(2.5..3.8)),
            *colors.iter().choose(&mut thread_rng()).unwrap(),
        ));
    }
    let mut config = FireworkConfig::default()
        .with_ar_scale(0.15)
        .with_gravity_scale(0.5)
        .with_gradient_scale(gradient);
    config.set_enable_gradient(true);
    Firework {
        init_time: SystemTime::now(),
        spawn_after: Duration::ZERO,
        center,
        particles,
        config,
        form: ExplosionForm::Sustained {
            lasts: Duration::from_secs(5),
            time_interval: Duration::from_secs_f32(0.08),
            timer: Duration::ZERO,
        },
        ..Default::default()
    }
}

examples/vortex.rs (lines 81-87)

fn gen_vortex_firework(center: Vec2) -> Firework {
    let colors = vec![
        (6, 55, 63),
        (24, 90, 96),
        (47, 123, 119),
        (92, 174, 166),
        (200, 255, 255),
    ];
    let mut particles = Vec::new();
    for p in gen_points_circle(30, 45).iter() {
        particles.push(ParticleConfig::new(
            center + *p,
            Vec2::new((*p).y, -(*p).x).normalize() * 15.,
            thread_rng().gen_range(28..40),
            Duration::from_secs_f32(thread_rng().gen_range(4.5..7.0)),
            *colors.iter().choose(&mut thread_rng()).unwrap(),
        ));
    }
    let mut config = FireworkConfig::default()
        .with_ar_scale(0.05)
        .with_gravity_scale(0.)
        .with_gradient_scale(gradient)
        .with_additional_force(move |particle| {
            (center - particle.pos).normalize() * (1. / center.distance(particle.pos)) * 150.
        });
    config.set_enable_gradient(true);
    Firework {
        init_time: SystemTime::now(),
        spawn_after: Duration::ZERO,
        center,
        particles,
        config,
        form: ExplosionForm::Sustained {
            lasts: Duration::from_secs(10),
            time_interval: Duration::from_secs_f32(0.01),
            timer: Duration::ZERO,
        },
        ..Default::default()
    }
}

examples/heart.rs (lines 84-90)

fn gen_heart_firework(center: Vec2) -> Firework {
    let colors = vec![
        (233, 232, 237),
        (254, 142, 130),
        (200, 27, 72),
        (86, 18, 31),
    ];
    let mut particles = Vec::new();
    let trail_length = thread_rng().gen_range(100..105);
    let life_time = Duration::from_secs_f32(thread_rng().gen_range(3.0..3.2));
    let init_pos = center - Vec2::NEG_Y * 15.;
    for v in gen_points_fan(300., 45, 0.2 * PI, 0.3 * PI).iter() {
        particles.push(ParticleConfig::new(
            init_pos,
            *v,
            trail_length,
            life_time,
            *colors.iter().choose(&mut thread_rng()).unwrap(),
        ));
    }
    for v in gen_points_fan(300., 45, 0.7 * PI, 0.8 * PI).iter() {
        particles.push(ParticleConfig::new(
            init_pos,
            *v,
            trail_length,
            life_time,
            *colors.iter().choose(&mut thread_rng()).unwrap(),
        ));
    }
    let mut config = FireworkConfig::default()
        .with_ar_scale(0.1)
        .with_gravity_scale(0.1)
        .with_gradient_scale(gradient)
        .with_additional_force(move |particle| (center - particle.pos) * 2.);
    config.set_enable_gradient(true);
    Firework {
        init_time: SystemTime::now(),
        spawn_after: Duration::ZERO,
        center,
        particles,
        config,
        form: ExplosionForm::Instant { used: false },
        ..Default::default()
    }
}

Trait Implementations

impl Clone for ParticleConfig

fn clone(&self) -> ParticleConfig

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ParticleConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ParticleConfig

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for ParticleConfig

fn eq(&self, other: &ParticleConfig) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ParticleConfig

impl StructuralPartialEq for ParticleConfig