Struct ParticleBuffer 

pub struct ParticleBuffer {
    pub positions_x: Vec<f32>,
    pub positions_y: Vec<f32>,
    pub positions_z: Vec<f32>,
    pub velocities_x: Vec<f32>,
    pub velocities_y: Vec<f32>,
    pub velocities_z: Vec<f32>,
    pub masses: Vec<f32>,
    pub lifetimes: Vec<f32>,
    pub ages: Vec<f32>,
    pub count: usize,
}

Structure-of-Arrays particle buffer, optimised for GPU upload.

Fields

positions_x: Vec<f32>

X positions of each particle slot.

positions_y: Vec<f32>

Y positions of each particle slot.

positions_z: Vec<f32>

Z positions of each particle slot.

velocities_x: Vec<f32>

X velocities.

velocities_y: Vec<f32>

Y velocities.

velocities_z: Vec<f32>

Z velocities.

masses: Vec<f32>

Per-particle mass.

lifetimes: Vec<f32>

Remaining lifetime; negative means the slot is dead.

ages: Vec<f32>

Elapsed age since spawn.

count: usize

Number of slots allocated (alive + dead).

Implementations

impl ParticleBuffer

pub fn new(capacity: usize) -> Self

Allocate a buffer with capacity slots (all dead initially).

pub fn add_particle( &mut self, pos: [f32; 3], vel: [f32; 3], mass: f32, lifetime: f32, ) -> Option<usize>

Spawn a new particle in the first dead slot. Returns its index or None if the buffer is full.

pub fn get_position(&self, i: usize) -> [f32; 3]

Get the position of slot i as \[x, y, z\].

pub fn get_velocity(&self, i: usize) -> [f32; 3]

Get the velocity of slot i as \[vx, vy, vz\].

pub fn set_position(&mut self, i: usize, p: [f32; 3])

Set the position of slot i.

pub fn set_velocity(&mut self, i: usize, v: [f32; 3])

Set the velocity of slot i.

pub fn is_alive(&self, i: usize) -> bool

Return true if the slot at i holds a live particle.

pub fn kill(&mut self, i: usize)

Kill the particle at slot i by setting its lifetime negative.

pub fn active_count(&self) -> usize

Count how many slots are currently alive.