Struct ParticleEmitterRecord 

pub struct ParticleEmitterRecord {

    pub texture_slot: usize,
    pub position: [f32; 3],
    pub direction: [f32; 3],
    pub spread_cos: f32,
    pub speed_min: f32,
    pub speed_max: f32,
    pub lifetime_min: f32,
    pub lifetime_max: f32,
    pub gravity: [f32; 3],
    pub spawn_rate: f32,
    pub max_particles: u32,
    pub size_start: f32,
    pub size_end: f32,
    pub color_start: [f32; 4],
    pub color_end: [f32; 4],
}

Resolved per-emitter state threaded into the backend at init. The backend allocates one GPU particle pool of max_particles slots per record and drives its compute + render passes from these fields each frame.

Fields

texture_slot: usize

Index of the albedo texture in the renderer’s bindless / per-frame texture pool. 0 means “no texture authored”: the renderer’s white fallback at slot 0 is sampled and the colour gradient still shows.

position: [f32; 3]

World-space spawn origin.

direction: [f32; 3]

Mean emission direction, unit-length. The compute kernel samples a new particle’s initial velocity from the cone of half-angle spread_cos around this vector.

spread_cos: f32

Cosine of the cone half-angle. 1.0 = straight jet, -1.0 = full sphere. Pre-computed so the kernel does not call cos() per spawn.

speed_min: f32

Inclusive lower bound on the initial particle speed (m/s).

speed_max: f32

Inclusive upper bound on the initial particle speed (m/s).

lifetime_min: f32

Inclusive lower bound on the particle lifetime (seconds).

lifetime_max: f32

Inclusive upper bound on the particle lifetime (seconds).

gravity: [f32; 3]

Constant acceleration applied each frame, in m/s².

spawn_rate: f32

Particles spawned per second.

max_particles: u32

Pool size in slots. Live + dead particles share this fixed pool.

size_start: f32

World-space billboard side length at age = 0 (m).

size_end: f32

World-space billboard side length at age = lifetime (m).

color_start: [f32; 4]

Linear-space RGBA at age = 0.

color_end: [f32; 4]

Linear-space RGBA at age = lifetime.

Implementations

impl ParticleEmitterRecord

pub fn aabb(&self) -> ([f32; 3], [f32; 3])

Conservative world-space AABB enclosing every particle this emitter could spawn over its full lifetime. Used by the per-frame frustum-cull skip so an off-screen emitter pays no render cost; the compute kernel still ticks so the pool keeps evolving while the camera looks away.

The bound is a sphere centred on the emission point and is intentionally loose: it ignores the cone-spread restriction (spread_cos) so the same AABB also covers full-sphere emitters, and it sums the worst-case ballistic terms: speed_max * lifetime_max (straight-line reach), 0.5 * |gravity| * lifetime_max² (gravity drift), and a max(size_start, size_end) * sqrt(2) / 2 half-diagonal for the camera-facing billboard quad. A tighter cone-aware bound is a future refinement; this version is correct (never false-cull) and cheap.

pub fn params( &self, dt: f32, spawn_budget: u32, random_seed: u32, ) -> ParticleParams

Build the per-frame compute + render uniform from this record’s static fields and the dynamic spawn / time state the runtime carries.

dt is the elapsed seconds since the previous compute dispatch (the integration step); spawn_budget is floor(spawn_accumulator), the integer count of fresh particles the kernel may emit this frame; and random_seed is the per-frame seed the kernel mixes with the thread id to drive its cheap on-GPU RNG.

Trait Implementations

impl Clone for ParticleEmitterRecord

fn clone(&self) -> ParticleEmitterRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ParticleEmitterRecord

impl Debug for ParticleEmitterRecord

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

Formats the value using the given formatter.

impl PartialEq for ParticleEmitterRecord

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ParticleEmitterRecord