Struct ParticleSystem 

pub struct ParticleSystem {
    pub seed: u64,
    pub emitters: Vec<Emitter>,
    pub inputs: Vec<Input>,
    pub states: u32,
    pub warmup: f32,
    pub time_scale: Option<Value>,
    pub max_view_distance: Option<f32>,
    pub termination: Termination,
    pub end: Option<f32>,
    pub lost: Vec<(String, u32)>,
}

A particle effect.

Fields

seed: u64

The seed of every random draw of the system.

emitters: Vec<Emitter>

The emitters, parents before children.

inputs: Vec<Input>

Quantities a program may drive.

states: u32

The number of states the system has (a source’s state machine; a renderer plays state 0 unless it is told another).

warmup: f32

Seconds the system is run before it is first shown, so that a placed fire is already burning when its area loads.

time_scale: Option<Value>

The rate at which the system’s time runs, a function of its active time (1 is real time); None for 1.

max_view_distance: Option<f32>

Beyond this distance (metres) from the camera nothing of the system is drawn; None for any distance.

termination: Termination

What happens when the thing that spawned the system goes away (a source’s termination).

end: Option<f32>

Seconds after which a system with no endless emitter has no live particle: the longest an emitter is active plus its particles’ longest life; None when something runs for ever. A renderer that loops a system restarts at this time.

lost: Vec<(String, u32)>

What the source’s pass could not carry, by reason, with a count (a placed and lost accounting).

Trait Implementations

impl Clone for ParticleSystem

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for ParticleSystem

fn references(&self, out: &mut Vec<Entity>)

The textures, meshes and clips the draws name, and the systems the emitters start.

fn verify(&self, _e: Entity, _w: &World) -> Result<(), String>

Emitters in order with parents before children, curves with ascending finite keys, variations naming an input the system has, an end that is finite, and finite numbers throughout the placement.

const NAME: &'static str = "core.particles"

const GEOMETRY: Geometry = crate::Geometry::None

What the value holds of its entity’s mesh primitives and vertices (Geometry). Stated by every component, with no default, so data that describes a mesh can’t be left behind by an edit of it unawares: the World’s edit paths take it from there.

fn to_json(&self) -> Result<Option<Json>, JsonError>

The component as JSON, for glTF extras, the debug text form and golden tests; Ok(None) for components that are not shown (bulk data, handles). The view must never lose a value: components that can be shown derive serde::Serialize and return crate::json::to_value(self).map(Some), which refuses non-finite floats instead of writing them as null.

const VERSION: u32 = 1

Schema version of the component’s content. Bump it when the meaning or layout of a field changes.

fn payload_bytes(&self) -> u64

The bytes of bulk payload the value holds (vertex streams and indices, texture levels, triangle soups), for memory reports: element counts times element sizes, not allocated capacity. 0 for small components.

fn remap_primitives(&self, _from: &[usize]) -> Option<Result<Self, String>>

The component after its entity’s mesh primitives were rebuilt, for a component that holds something per primitive (Geometry::PerPrimitive, Geometry::PerVertex): new primitive i comes from old primitive from[i] (a source may repeat, when a primitive is split, or be absent, when one is dropped). Such a component always answers (a value holding nothing per primitive answers with itself); None, the default, is for components of Geometry::None, and World::remap_primitives refuses a dependent component that gives it. An index the component does not have is an error. remap_list does the work for a list with one entry per primitive.

fn remap_vertices( &self, _primitive: usize, _from: &[u32], ) -> Option<Result<Self, String>>

The component after the vertices of its entity’s mesh primitive primitive were compacted or reordered, for a component that holds something per vertex (Geometry::PerVertex): new vertex i of that primitive is old vertex from[i] (a source may repeat or be absent). Such a component always answers (with itself when it holds nothing for that primitive); None, the default, is for the others, and World::remap_vertices refuses a per-vertex component that gives it. An index the component does not have is an error. Every pass that compacts or reorders a primitive’s vertices calls World::remap_vertices. After a rebuild of the primitive list (World::rebuild_primitives, Component::remap_primitives) a primitive’s per-vertex data is its source primitive’s, and the vertex map is relative to that source.

fn blend_vertices( &self, _primitive: usize, _from: &[VertexBlend], ) -> Option<Result<Self, String>>

The component after the vertices of its entity’s mesh primitive primitive were rebuilt as blends of old ones (VertexBlend), for a component that holds something per vertex (Geometry::PerVertex): new vertex i is the combination from[i] of old vertices, in whatever way the component’s data combines (a morph target’s delta is interpolated, the way the surface it moves is). It answers as Component::remap_vertices does: with itself when it holds nothing for that primitive; None, the default, is for a component that does not know how to combine its data, and World::blend_vertices refuses a per-vertex component that gives it. An index the component does not have is an error. A vertex that is a copy of one old vertex (VertexBlend::copy) is the case Component::remap_vertices states, and a component answering one answers the other alike.

fn apply_linear(&self, _l: &Linear) -> Linearity<Self>

The component after its entity’s local space was mapped by l (a pass that bakes a placement’s mirror or shear into a copy of its geometry, so transforms stay rigid). World::apply_linear calls it for every component of the entity. The default is Linearity::Unsupported: a component that holds local-space geometry and does not say how it follows is never silently left behind; one without geometry says Linearity::Invariant.

fn restate(&self, _resolved: &Resolved<'_>) -> Restated<Self>

The component after resolve-state (crate::state::ResolveState) gave the axes in resolved their values: a component that holds crate::state::Clauses of its own (a record of parts each present in some states) reduces them as core.condition is reduced (crate::state::Resolved::reduce: a clause that fails is dropped, a clause left with no literal holds whatever the other axes are). Restated::Absent says the entity is not present in this state (every clause failed): it is despawned as one whose core.condition fails is. The default holds no clause: Restated::Unchanged.

impl Debug for ParticleSystem

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

Formats the value using the given formatter.

impl PartialEq for ParticleSystem

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ParticleSystem

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ParticleSystem