Struct Spawner 

pub struct Spawner {
    pub template: AssetId,
    pub interval: f32,
    pub lifetime: f32,
    pub elapsed: f32,
    pub count: u32,
}

Periodically instantiates copies of an existing placement at this entity’s position.

A spawner clones template (the name of another placement in the world) every interval seconds, giving each copy a lifetime after which it is automatically removed. Pairing a short lifetime with a short interval keeps a bounded population churning (an enemy wave, a particle of debris, a fountain of props) and is what exercises GPU draw-slot recycling: each expiry frees a slot the next spawn reuses.

The spawner’s own Transform (its position) is where copies appear, so place the spawner where you want the stream to originate.

Fields

template: AssetId

Name of the placement to copy on each spawn.

interval: f32

Seconds between spawns.

lifetime: f32

Seconds each spawned copy lives before auto-removal; 0 keeps it forever.

elapsed: f32

Runtime: seconds accumulated toward the next spawn.

count: u32

Runtime: number of copies spawned so far.

Implementations

impl Spawner

pub fn bake(args: SpawnerArgs) -> Spawner

Translate the authored args into the runtime spawner: clamp the timing knobs and zero the runtime counters. Run by cook at build time (the baked blob record carries the result).

Trait Implementations

impl Clone for Spawner

fn clone(&self) -> Spawner

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for Spawner

const NAME: &'static str = "Spawner"

The registry name a world authors this component under.

fn from_baked(bytes: &[u8]) -> Result<Spawner, 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).

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.

impl ComponentSlot for Spawner

const DISCRIMINANT: u8

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

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

Borrow this type’s column out of the storage.

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

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

impl Debug for Spawner

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Spawner

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Spawner> for ComponentAsset

fn from(c: Spawner) -> ComponentAsset

Converts to this type from the input type.

impl RuntimeComponent for Spawner

impl Serialize for Spawner

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.