Struct World 

pub struct World {
    pub transforms: ComponentStore<Transform>,
    pub names: ComponentStore<Name>,
    pub renderables: ComponentStore<Renderable>,
    pub scripts: ComponentStore<ScriptList>,
    pub cameras: ComponentStore<CameraComponent>,
    pub persistent: ComponentStore<()>,
    pub camera: Camera,
    /* private fields */
}

A spatial container of entities, distinct from crate::scene::Scene (which means “game state/screen” in this framework, not a place). Each entity is a Transform plus a Renderable and an optional Name.

Clone is cheap and GPU-allocation-free: a cloned Renderable’s wgpu::Buffer/ wgpu::BindGroup handles are refcount copies of the same GPU resource, not duplicates (wgpu itself derives Clone for both). The editor relies on this to snapshot the whole World before entering Play and restore it wholesale on Stop.

Fields

transforms: ComponentStore<Transform>

names: ComponentStore<Name>

renderables: ComponentStore<Renderable>

scripts: ComponentStore<ScriptList>

cameras: ComponentStore<CameraComponent>

persistent: ComponentStore<()>

Marks an entity as surviving a scene change (WorldCommand::ChangeScene) instead of being torn down with the rest of the outgoing scene — Unity’s DontDestroyOnLoad. A plain ComponentStore<()> marker, mirroring how CameraComponent::active flags “the” active camera, since most entities never need it. Deliberately not part of EntityRecord/ SceneFile — like DontDestroyOnLoad itself, it’s a runtime-only script call (entity.set_persistent(true)), not an authorable/serialized property.

camera: Camera

Implementations

impl World

pub fn new(camera: Camera) -> Self

pub fn spawn_empty( &mut self, name: impl Into<String>, transform: Transform, ) -> Entity

pub fn set_renderable(&mut self, entity: Entity, renderable: Renderable)

pub fn clear_renderable(&mut self, entity: Entity)

pub fn set_camera(&mut self, entity: Entity, component: CameraComponent)

pub fn clear_camera(&mut self, entity: Entity)

pub fn set_persistent(&mut self, entity: Entity, persistent: bool)

Marks (or unmarks) entity as persistent — see World::persistent’s doc comment.

pub fn is_persistent(&self, entity: Entity) -> bool

pub fn despawn(&mut self, entity: Entity)

pub fn is_alive(&self, entity: Entity) -> bool

pub fn iter_entities(&self) -> impl Iterator<Item = Entity> + '_

Every live entity (every entity has a Transform, so iterating that store enumerates them all — unlike renderables, which only some entities have).

pub fn despawn_non_persistent(&mut self)

Despawns every entity except ones marked persistent — the “full teardown” half of a scene change (see WorldCommand::ChangeScene’s handling in ScriptRuntime::drain_commands). Collects into a Vec first since despawn mutates the same transforms store iter_entities reads from.

pub fn sync_transforms(&mut self)

Syncs every entity’s ECS Transform into its Renderable’s own GPU-facing matrix. Call once per frame before drawing.

pub fn active_camera(&self, aspect: f32) -> Option<Camera>

The derived Camera for whichever entity has CameraComponent::active set, if any — what Play mode pushes to the renderer in place of the edit-mode fly camera. aspect is threaded through rather than read off self.camera so the caller can supply the current viewport’s aspect the same frame it’s computed.

Returns None if no entity is marked active (or the active entity’s Transform is somehow missing) — callers should fall back to whatever camera they’d otherwise use.

Trait Implementations

impl Clone for World

fn clone(&self) -> World

Returns a duplicate of the value.

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

Performs copy-assignment from source.