Struct bevy_particle_systems::components::ParticleSystem

source ·

pub struct ParticleSystem {Show 23 fields
    pub max_particles: usize,
    pub texture: ParticleTexture,
    pub rescale_texture: Option<Vec2>,
    pub spawn_rate_per_second: ValueOverTime,
    pub emitter_shape: EmitterShape,
    pub initial_speed: JitteredValue,
    pub velocity_modifiers: Vec<VelocityModifier>,
    pub lifetime: JitteredValue,
    pub color: ColorOverTime,
    pub initial_scale: JitteredValue,
    pub scale: ValueOverTime,
    pub initial_rotation: JitteredValue,
    pub rotation_speed: JitteredValue,
    pub rotate_to_movement_direction: bool,
    pub looping: bool,
    pub system_duration_seconds: f32,
    pub max_distance: Option<f32>,
    pub z_value_override: Option<JitteredValue>,
    pub bursts: Vec<ParticleBurst>,
    pub space: ParticleSpace,
    pub use_scaled_time: bool,
    pub despawn_on_finish: bool,
    pub despawn_particles_with_system: bool,
}

Expand description

Defines the parameters of how a system and its particles behave.

A ParticleSystem will emit particles until it reaches the system_duration_seconds or forever if looping is true, so long as the entity with the ParticleSystem also has a Playing component.

If a ParticleSystem component is removed before all particles have finished their lifetime, the associated particles will all despawn themselves on the next frame.

Fields§

§max_particles: usize

The maximum number of particles the system can have alive at any given time.

§texture: ParticleTexture

The texture used for each particle.

§rescale_texture: Option<Vec2>

If provided, re-scale the texture size

This is simply passed directly to Sprite::custom_size or TextureAtlasSprite::custom_size

§spawn_rate_per_second: ValueOverTime

The number of particles to spawn per second.

This uses a ValueOverTime so that the spawn rate can vary over the lifetime of the system.

§emitter_shape: EmitterShape

The shape of the emitter.

§initial_speed: JitteredValue

The initial movement speed of a particle.

This value can be constant, or have added jitter to have particles move at varying speeds.

§velocity_modifiers: Vec<VelocityModifier>

Modifiers affecting the particle velocity.

They can be stacked, and will be applied in order. No modifiers makes the particle move at its initial_speed for its lifetime.

§lifetime: JitteredValue

The lifetime of each particle, in seconds.

This value can have jitter, causing lifetimes to vary per particle.

§color: ColorOverTime

The color of each particle over time.

Color is used to modify the default_sprite. A constant value of bevy_render::prelude::Color::WHITE will make the sprite appear with no modifications.

This can vary over time and be used to modify alpha as well.

§initial_scale: JitteredValue

The initial scale of a particle.

This value can be constant, or have added jitter to have particles with different sizes

This value is multiplied with scale to produce the final scale.

§scale: ValueOverTime

The scale or size of the particle over time.

Changing this value over time shrinks or grows the particle accordingly.

Multiplied with initial_scale to produce the final scale.

§initial_rotation: JitteredValue

The rotation of a particle around the z access at spawn in radian.

§rotation_speed: JitteredValue

The speed at which the particle rotates in radian per second.

§rotate_to_movement_direction: bool

Rotates the particle to be facing the movement direction at spawn.

This is useful if the image used for the particle has a visual ‘forward’ that should match it’s movement, such as an arrow.

This rotation for the movement direction will be added to the initial_rotation value, to account for needing to apply a base rotation to the sprite.

§looping: bool

Whether or not the system will start over automatically.

§system_duration_seconds: f32

How long the system will emit particles for.

§max_distance: Option<f32>

A maximum distance a particle can travel before being despawned.

§z_value_override: Option<JitteredValue>

Set a fixed/constant z value (useful for 2D to set a fixed z-depth).

§bursts: Vec<ParticleBurst>

A series of bursts of particles at configured times.

§space: ParticleSpace

What coordinate space particles should use.

§use_scaled_time: bool

Dictates whether this system respects Bevy’s time scaling by using bevy_time::Virtual when true, or bevy_time::Real when false.

§despawn_on_finish: bool

Indicates that the entity the ParticleSystem is on should be despawned when the system completes and has no more particles.

Defaults to false.

Note that this will never trigger on a system that has looping set to true.

§despawn_particles_with_system: bool

Indicates whether alive particles should be despawned when the system itself is despawned.

When this is false (the default), particles will live out their lifetime even if the system has been despawned.

Struct bevy_particle_systems::components::ParticleSystem

Fields§

Implementations§

impl ParticleSystem

pub fn oneshot() -> Self

Trait Implementations§

impl Clone for ParticleSystem

fn clone(&self) -> ParticleSystem

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

impl Component for ParticleSystemwhere Self: Send + Sync + 'static,

type Storage = TableStorage

impl Debug for ParticleSystem

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

impl Default for ParticleSystem

fn default() -> Self

fn from_reflect(reflect: &dyn Reflect) -> Option<Self>

fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>

fn get_type_registration() -> TypeRegistration

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn into_any(self: Box<Self>) -> Box<dyn Any>

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

fn as_reflect(&self) -> &dyn Reflect

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

fn clone_value(&self) -> Box<dyn Reflect>

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

fn apply(&mut self, value: &dyn Reflect)

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Self>) -> ReflectOwned

fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>

fn reflect_hash(&self) -> Option<u64>

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

fn serializable(&self) -> Option<Serializable<'_>>

fn is_dynamic(&self) -> bool

fn field(&self, name: &str) -> Option<&dyn Reflect>

fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect>

fn field_at(&self, index: usize) -> Option<&dyn Reflect>

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>

fn name_at(&self, index: usize) -> Option<&str>

fn field_len(&self) -> usize

fn iter_fields(&self) -> FieldIter<'_>

fn clone_dynamic(&self) -> DynamicStruct

impl TypePath for ParticleSystemwhere Self: Any + Send + Sync,

fn type_path() -> &'static str

fn short_type_path() -> &'static str

fn type_ident() -> Option<&'static str>

fn crate_name() -> Option<&'static str>

fn module_path() -> Option<&'static str>

fn type_info() -> &'static TypeInfo

Auto Trait Implementations§

impl !RefUnwindSafe for ParticleSystem

impl Send for ParticleSystem

impl Sync for ParticleSystem

impl Unpin for ParticleSystem

impl !UnwindSafe for ParticleSystem

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T, U> AsBindGroupShaderType<U> for Twhere U: ShaderType, &'a T: for<'a> Into<U>,

fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<C> Bundle for Cwhere C: Component,

fn component_ids( components: &mut Components, storages: &mut Storages, ids: &mut impl FnMut(ComponentId) )

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> Cwhere F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

impl<T> Downcast<T> for T

fn downcast(&self) -> &T

impl<T> Downcast for Twhere T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

fn as_any(&self) -> &(dyn Any + 'static)

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

impl<T> DowncastSync for Twhere T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

impl<C> DynamicBundle for Cwhere C: Component,

impl Component for ParticleSystem
where Self: Send + Sync + 'static,

impl TypePath for ParticleSystem
where Self: Any + Send + Sync,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<C> Bundle for C
where C: Component,

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

impl<T> Downcast for T
where T: Any,

impl<T> DowncastSync for T
where T: Any + Send + Sync,

impl<C> DynamicBundle for C
where C: Component,

impl<T> DynamicTypePath for T
where T: TypePath,

impl<T> FromWorld for T
where T: Default,

impl<S> GetField for S
where S: Struct,

fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,

fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
where T: Reflect,

impl<T> GetPath for T
where T: Reflect + ?Sized,

fn path<'p, T>( &self, path: impl ReflectPath<'p> ) -> Result<&T, ReflectPathError<'p>>
where T: Reflect,

fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p> ) -> Result<&mut T, ReflectPathError<'p>>
where T: Reflect,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<T> TypeData for T
where T: 'static + Send + Sync + Clone,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

impl<T> Settings for T
where T: 'static + Send + Sync,

impl<T> WasmNotSend for T
where T: Send,

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

impl<T> WasmNotSync for T
where T: Sync,