Struct ParticleEmitter 

pub struct ParticleEmitter {

    pub asset_id: AssetId,
    pub texture: Option<TextureHandle>,
    pub position: [f32; 3],
    pub direction: [f32; 3],
    pub spread_deg: 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],
    pub visible: bool,
}

A billboard particle emitter.

Particles spawn from position in a cone centred on direction (half-angle spread_deg), with a speed drawn from [speed_min, speed_max] and a lifetime from [lifetime_min, lifetime_max]. Over each particle’s life its size interpolates from size_start to size_end and its colour from color_start to color_end. Each particle is drawn as a camera-facing quad textured by texture.

The pool holds max_particles particles; new ones spawn at spawn_rate per second, reusing slots as old particles die.

ParticleEmitter {
    position: [0.0, 1.0, 0.0],
    direction: [0.0, 1.0, 0.0],
    spread_deg: 25.0,
    speed_min: 2.0,
    speed_max: 5.0,
    lifetime_min: 0.5,
    ..Default::default()
};

Fields

asset_id: AssetId

Asset identity; injected via inject_name. Not part of args.

texture: Option<TextureHandle>

Texture sampled per particle. None uses a white fallback so the colour gradient still shows.

position: [f32; 3]

World-space spawn origin.

direction: [f32; 3]

Mean emission direction. The cone of width spread_deg is centred on this vector. Normalised on load; a zero vector falls back to [0, 1, 0].

spread_deg: f32

Cone half-angle in degrees around direction. 0 emits a straight jet; 180 emits in all directions.

speed_min: f32

Lower bound on initial speed (m/s). Floored at 0.

speed_max: f32

Upper bound on initial speed (m/s). Lifted to at least speed_min.

lifetime_min: f32

Lower bound on particle lifetime (seconds). Must be > 0.

lifetime_max: f32

Upper bound on particle lifetime (seconds). Lifted to at least lifetime_min.

gravity: [f32; 3]

Constant acceleration applied to each particle, in world units per second squared.

spawn_rate: f32

Particles spawned per second. 0 produces a one-shot burst that then empties as particles age out.

max_particles: u32

Maximum number of particles alive at once. Clamped to [1, 65536].

size_start: f32

Billboard side length at spawn, in world units.

size_end: f32

Billboard side length at death, in world units.

color_start: [f32; 4]

Linear-space RGBA multiplier applied to the texture at spawn.

color_end: [f32; 4]

Linear-space RGBA multiplier applied to the texture at death.

visible: bool

When false the emitter is skipped each frame.

Trait Implementations

impl Clone for ParticleEmitter

fn clone(&self) -> ParticleEmitter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for ParticleEmitter

const NAME: &'static str = "ParticleEmitter"

The registry name a world authors this component under.

fn inject_name(&mut self, id: AssetId)

Called after construction to inject the asset’s identity from the blob def. Only meaningful for components that look themselves up by id at runtime. The default implementation does nothing.

fn from_baked(bytes: &[u8]) -> Result<ParticleEmitter, CnResult>

Reconstruct this component from a blob record, whose bytes are the serialized runtime component (cook already ran the asset -> component translation). The default rejects: runtime-only components are never stored in a blob, so only loadable types provide an implementation.

fn inject_locator(&mut self, _locator: PayloadLocator)

Called after construction to inject the payload locator from the blob def. Only meaningful for components with a compiled payload. The default implementation does nothing (correct for most components).

impl ComponentSlot for ParticleEmitter

const DISCRIMINANT: u8

The component type’s stable id, used as its ComponentId.

fn slot(s: &ComponentStorage) -> &Column<ParticleEmitter>

Borrow this type’s column out of the storage.

fn slot_mut(s: &mut ComponentStorage) -> &mut Column<ParticleEmitter>

Mutably borrow this type’s column out of the storage.

impl Debug for ParticleEmitter

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

Formats the value using the given formatter.

impl Default for ParticleEmitter

fn default() -> ParticleEmitter

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ParticleEmitter

where ParticleEmitter: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<ParticleEmitter, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ParticleEmitter> for ComponentAsset

fn from(c: ParticleEmitter) -> ComponentAsset

Converts to this type from the input type.

impl RuntimeComponent for ParticleEmitter

impl Serialize for ParticleEmitter

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.