Struct MainWorld 

pub struct MainWorld(/* private fields */);

Stores the main world for rendering as a resource. This resource is only available during the extract schedule and is used to move data from the main world to the render world. It is wrapped in a resource to avoid borrowing issues when extracting data from the main world.

Methods from Deref<Target = World>

pub fn register_event_key<E>(&mut self) -> EventKey

where E: Event,

Generates the [EventKey] for this event type.

If this type has already been registered, this will return the existing [EventKey].

This is used by various dynamically typed observer APIs, such as DeferredWorld::trigger_raw.

pub fn event_key<E>(&self) -> Option<EventKey>

where E: Event,

Fetches the [EventKey] for this event type, if it has already been generated.

This is used by various dynamically typed observer APIs, such as DeferredWorld::trigger_raw.

pub fn add_observer<E, B, M>( &mut self, system: impl IntoObserverSystem<E, B, M>, ) -> EntityWorldMut<'_>

where E: Event, B: Bundle,

Spawns a “global” [Observer] which will watch for the given event. Returns its [Entity] as a [EntityWorldMut].

system can be any system whose first parameter is [On].

Example

#[derive(Component)]
struct A;

world.add_observer(|_: On<Add, A>| {
    // ...
});
world.add_observer(|_: On<Remove, A>| {
    // ...
});

Calling observe on the returned [EntityWorldMut] will observe the observer itself, which you very likely do not want.

Panics

Panics if the given system is an exclusive system.

pub fn trigger<'a, E>(&mut self, event: E)

where E: Event, <E as Event>::Trigger<'a>: Default,

Triggers the given [Event], which will run any [Observer]s watching for it.

For a variant that borrows the event rather than consuming it, use [World::trigger_ref] instead.

pub fn trigger_with<'a, E>( &mut self, event: E, trigger: <E as Event>::Trigger<'a>, )

where E: Event,

Triggers the given [Event] using the given Trigger, which will run any [Observer]s watching for it.

For a variant that borrows the event rather than consuming it, use [World::trigger_ref] instead.

pub fn trigger_ref<'a, E>(&mut self, event: &mut E)

where E: Event, <E as Event>::Trigger<'a>: Default,

Triggers the given mutable [Event] reference, which will run any [Observer]s watching for it.

Compared to [World::trigger], this method is most useful when it’s necessary to check or use the event after it has been modified by observers.

pub fn trigger_ref_with<'a, E>( &mut self, event: &mut E, trigger: &mut <E as Event>::Trigger<'a>, )

where E: Event,

Triggers the given mutable [Event] reference using the given mutable Trigger reference, which will run any [Observer]s watching for it.

Compared to [World::trigger], this method is most useful when it’s necessary to check or use the event after it has been modified by observers.

pub fn register_system<I, O, M>( &mut self, system: impl IntoSystem<I, O, M> + 'static, ) -> SystemId<I, O>

where I: SystemInput + 'static, O: 'static,

Registers a system and returns a [SystemId] so it can later be called by [World::run_system].

It’s possible to register multiple copies of the same system by calling this function multiple times. If that’s not what you want, consider using [World::register_system_cached] instead.

This is different from adding systems to a Schedule, because the [SystemId] that is returned can be used anywhere in the [World] to run the associated system. This allows for running systems in a pushed-based fashion. Using a Schedule is still preferred for most cases due to its better performance and ability to run non-conflicting systems simultaneously.

pub fn register_boxed_system<I, O>( &mut self, system: Box<dyn System<Out = O, In = I>>, ) -> SystemId<I, O>

where I: SystemInput + 'static, O: 'static,

Similar to [Self::register_system], but allows passing in a [BoxedSystem].

This is useful if the [IntoSystem] implementor has already been turned into a System trait object and put in a Box.

pub fn unregister_system<I, O>( &mut self, id: SystemId<I, O>, ) -> Result<RemovedSystem<I, O>, RegisteredSystemError<I, O>>

where I: SystemInput + 'static, O: 'static,

Removes a registered system and returns the system, if it exists. After removing a system, the [SystemId] becomes invalid and attempting to use it afterwards will result in errors. Re-adding the removed system will register it on a new [SystemId].

If no system corresponds to the given [SystemId], this method returns an error. Systems are also not allowed to remove themselves, this returns an error too.

pub fn run_system<O>( &mut self, id: SystemId<(), O>, ) -> Result<O, RegisteredSystemError<(), O>>

where O: 'static,

Run stored systems by their [SystemId]. Before running a system, it must first be registered. The method [World::register_system] stores a given system and returns a [SystemId]. This is different from RunSystemOnce::run_system_once, because it keeps local state between calls and change detection works correctly.

Also runs any queued-up commands.

In order to run a chained system with an input, use [World::run_system_with] instead.

Examples

Running a system

fn increment(mut counter: Local<u8>) {
   *counter += 1;
   println!("{}", *counter);
}

let mut world = World::default();
let counter_one = world.register_system(increment);
let counter_two = world.register_system(increment);
world.run_system(counter_one); // -> 1
world.run_system(counter_one); // -> 2
world.run_system(counter_two); // -> 1

Change detection

#[derive(Resource, Default)]
struct ChangeDetector;

let mut world = World::default();
world.init_resource::<ChangeDetector>();
let detector = world.register_system(|change_detector: ResMut<ChangeDetector>| {
    if change_detector.is_changed() {
        println!("Something happened!");
    } else {
        println!("Nothing happened.");
    }
});

// Resources are changed when they are first added
let _ = world.run_system(detector); // -> Something happened!
let _ = world.run_system(detector); // -> Nothing happened.
world.resource_mut::<ChangeDetector>().set_changed();
let _ = world.run_system(detector); // -> Something happened!

Getting system output

#[derive(Resource)]
struct PlayerScore(i32);

#[derive(Resource)]
struct OpponentScore(i32);

fn get_player_score(player_score: Res<PlayerScore>) -> i32 {
  player_score.0
}

fn get_opponent_score(opponent_score: Res<OpponentScore>) -> i32 {
  opponent_score.0
}

let mut world = World::default();
world.insert_resource(PlayerScore(3));
world.insert_resource(OpponentScore(2));

let scoring_systems = [
  ("player", world.register_system(get_player_score)),
  ("opponent", world.register_system(get_opponent_score)),
];

for (label, scoring_system) in scoring_systems {
  println!("{label} has score {}", world.run_system(scoring_system).expect("system succeeded"));
}

pub fn run_system_with<I, O>( &mut self, id: SystemId<I, O>, input: <I as SystemInput>::Inner<'_>, ) -> Result<O, RegisteredSystemError<I, O>>

where I: SystemInput + 'static, O: 'static,

Run a stored chained system by its [SystemId], providing an input value. Before running a system, it must first be registered. The method [World::register_system] stores a given system and returns a [SystemId].

Also runs any queued-up commands.

Examples

fn increment(In(increment_by): In<u8>, mut counter: Local<u8>) -> u8 {
  *counter += increment_by;
  *counter
}

let mut world = World::default();
let counter_one = world.register_system(increment);
let counter_two = world.register_system(increment);
assert_eq!(world.run_system_with(counter_one, 1).unwrap(), 1);
assert_eq!(world.run_system_with(counter_one, 20).unwrap(), 21);
assert_eq!(world.run_system_with(counter_two, 30).unwrap(), 30);

See [World::run_system] for more examples.

pub fn register_system_cached<I, O, M, S>( &mut self, system: S, ) -> SystemId<I, O>

where I: SystemInput + 'static, O: 'static, S: IntoSystem<I, O, M> + 'static,

Registers a system or returns its cached [SystemId].

If you want to run the system immediately and you don’t need its SystemId, see [World::run_system_cached].

The first time this function is called for a particular system, it will register it and store its [SystemId] in a [CachedSystemId] resource for later. If you would rather manage the SystemId yourself, or register multiple copies of the same system, use [World::register_system] instead.

Limitations

This function only accepts ZST (zero-sized) systems to guarantee that any two systems of the same type must be equal. This means that closures that capture the environment, and function pointers, are not accepted.

If you want to access values from the environment within a system, consider passing them in as inputs via [World::run_system_cached_with]. If that’s not an option, consider [World::register_system] instead.

pub fn unregister_system_cached<I, O, M, S>( &mut self, _system: S, ) -> Result<RemovedSystem<I, O>, RegisteredSystemError<I, O>>

where I: SystemInput + 'static, O: 'static, S: IntoSystem<I, O, M> + 'static,

Removes a cached system and its [CachedSystemId] resource.

See [World::register_system_cached] for more information.

pub fn run_system_cached<O, M, S>( &mut self, system: S, ) -> Result<O, RegisteredSystemError<(), O>>

where O: 'static, S: IntoSystem<(), O, M> + 'static,

Runs a cached system, registering it if necessary.

See [World::register_system_cached] for more information.

pub fn run_system_cached_with<I, O, M, S>( &mut self, system: S, input: <I as SystemInput>::Inner<'_>, ) -> Result<O, RegisteredSystemError<I, O>>

where I: SystemInput + 'static, O: 'static, S: IntoSystem<I, O, M> + 'static,

Runs a cached system with an input, registering it if necessary.

See [World::register_system_cached] for more information.

pub fn get_reflect( &self, entity: Entity, type_id: TypeId, ) -> Result<&(dyn Reflect + 'static), GetComponentReflectError>

Retrieves a reference to the given entity’s [Component] of the given type_id using reflection.

Requires implementing Reflect for the [Component] (e.g., using #[derive(Reflect)) and app.register_type::<TheComponent>() to have been called¹.

If you want to call this with a [ComponentId], see [World::components] and Components::get_id to get the corresponding TypeId.

Also see the crate documentation for [bevy_reflect] for more information on Reflect and bevy’s reflection capabilities.

Errors

See [GetComponentReflectError] for the possible errors and their descriptions.

Example

use bevy_ecs::prelude::*;
use bevy_reflect::Reflect;
use std::any::TypeId;

// define a `Component` and derive `Reflect` for it
#[derive(Component, Reflect)]
struct MyComponent;

// create a `World` for this example
let mut world = World::new();

// Note: This is usually handled by `App::register_type()`, but this example cannot use `App`.
world.init_resource::<AppTypeRegistry>();
world.get_resource_mut::<AppTypeRegistry>().unwrap().write().register::<MyComponent>();

// spawn an entity with a `MyComponent`
let entity = world.spawn(MyComponent).id();

// retrieve a reflected reference to the entity's `MyComponent`
let comp_reflected: &dyn Reflect = world.get_reflect(entity, TypeId::of::<MyComponent>()).unwrap();

// make sure we got the expected type
assert!(comp_reflected.is::<MyComponent>());

Note

Requires the bevy_reflect feature (included in the default features).

---

1. More specifically: Requires TypeData for ReflectFromPtr to be registered for the given type_id, which is automatically handled when deriving Reflect and calling App::register_type. ↩

pub fn get_reflect_mut( &mut self, entity: Entity, type_id: TypeId, ) -> Result<Mut<'_, dyn Reflect>, GetComponentReflectError>

Retrieves a mutable reference to the given entity’s [Component] of the given type_id using reflection.

Requires implementing Reflect for the [Component] (e.g., using #[derive(Reflect)) and app.register_type::<TheComponent>() to have been called.

This is the mutable version of [World::get_reflect], see its docs for more information and an example.

Just calling this method does not trigger change detection.

Errors

See [GetComponentReflectError] for the possible errors and their descriptions.

Example

See the documentation for [World::get_reflect].

Note

Requires the feature bevy_reflect (included in the default features).

pub fn id(&self) -> WorldId

Retrieves this [World]’s unique ID

pub fn as_unsafe_world_cell(&mut self) -> UnsafeWorldCell<'_>

Creates a new [UnsafeWorldCell] view with complete read+write access.

pub fn as_unsafe_world_cell_readonly(&self) -> UnsafeWorldCell<'_>

Creates a new [UnsafeWorldCell] view with only read access to everything.

pub fn entities(&self) -> &Entities

Retrieves this world’s [Entities] collection.

pub fn entities_allocator(&self) -> &EntityAllocator

Retrieves this world’s [EntityAllocator] collection.

pub fn entities_allocator_mut(&mut self) -> &mut EntityAllocator

Retrieves this world’s [EntityAllocator] collection mutably.

pub unsafe fn entities_mut(&mut self) -> &mut Entities

Retrieves this world’s [Entities] collection mutably.

Safety

Mutable reference must not be used to put the [Entities] data in an invalid state for this [World]

pub fn entity_count(&self) -> u32

Retrieves the number of [Entities] in the world.

This is helpful as a diagnostic, but it can also be used effectively in tests.

pub fn archetypes(&self) -> &Archetypes

Retrieves this world’s [Archetypes] collection.

pub fn components(&self) -> &Components

Retrieves this world’s [Components] collection.

pub fn components_queue(&self) -> ComponentsQueuedRegistrator<'_>

Prepares a [ComponentsQueuedRegistrator] for the world. NOTE: [ComponentsQueuedRegistrator] is easily misused. See its docs for important notes on when and how it should be used.

pub fn components_registrator(&mut self) -> ComponentsRegistrator<'_>

Prepares a [ComponentsRegistrator] for the world.

pub fn storages(&self) -> &Storages

Retrieves this world’s [Storages] collection.

pub fn bundles(&self) -> &Bundles

Retrieves this world’s [Bundles] collection.

pub fn removed_components(&self) -> &RemovedComponentMessages

Retrieves this world’s [RemovedComponentMessages] collection

pub fn observers(&self) -> &Observers

Retrieves this world’s [Observers] list

pub fn commands(&mut self) -> Commands<'_, '_>

Creates a new [Commands] instance that writes to the world’s command queue Use [World::flush] to apply all queued commands

pub fn register_component<T>(&mut self) -> ComponentId

where T: Component,

Registers a new [Component] type and returns the [ComponentId] created for it.

Usage Notes

In most cases, you don’t need to call this method directly since component registration happens automatically during system initialization.

pub fn register_disabling_component<C>(&mut self)

where C: Component,

Registers a component type as “disabling”, using default query filters to exclude entities with the component from queries.

pub fn register_component_hooks<T>(&mut self) -> &mut ComponentHooks

where T: Component,

Returns a mutable reference to the [ComponentHooks] for a [Component] type.

Will panic if T exists in any archetypes.

pub fn register_component_hooks_by_id( &mut self, id: ComponentId, ) -> Option<&mut ComponentHooks>

Returns a mutable reference to the [ComponentHooks] for a [Component] with the given id if it exists.

Will panic if id exists in any archetypes.

pub fn register_required_components<T, R>(&mut self)

where T: Component, R: Component + Default,

Registers the given component R as a required component for T.

When T is added to an entity, R and its own required components will also be added if R was not already provided. The Default constructor will be used for the creation of R. If a custom constructor is desired, use [World::register_required_components_with] instead.

For the non-panicking version, see [World::try_register_required_components].

Note that requirements must currently be registered before T is inserted into the world for the first time. This limitation may be fixed in the future.

Panics

Panics if R is already a directly required component for T, or if T has ever been added on an entity before the registration.

Indirect requirements through other components are allowed. In those cases, any existing requirements will only be overwritten if the new requirement is more specific.

Example

#[derive(Component)]
struct A;

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct B(usize);

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct C(u32);

// Register B as required by A and C as required by B.
world.register_required_components::<A, B>();
world.register_required_components::<B, C>();

// This will implicitly also insert B and C with their Default constructors.
let id = world.spawn(A).id();
assert_eq!(&B(0), world.entity(id).get::<B>().unwrap());
assert_eq!(&C(0), world.entity(id).get::<C>().unwrap());

pub fn register_required_components_with<T, R>( &mut self, constructor: fn() -> R, )

where T: Component, R: Component,

Registers the given component R as a required component for T.

When T is added to an entity, R and its own required components will also be added if R was not already provided. The given constructor will be used for the creation of R. If a Default constructor is desired, use [World::register_required_components] instead.

For the non-panicking version, see [World::try_register_required_components_with].

Note that requirements must currently be registered before T is inserted into the world for the first time. This limitation may be fixed in the future.

Panics

Panics if R is already a directly required component for T, or if T has ever been added on an entity before the registration.

Indirect requirements through other components are allowed. In those cases, any existing requirements will only be overwritten if the new requirement is more specific.

Example

#[derive(Component)]
struct A;

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct B(usize);

#[derive(Component, PartialEq, Eq, Debug)]
struct C(u32);

// Register B and C as required by A and C as required by B.
// A requiring C directly will overwrite the indirect requirement through B.
world.register_required_components::<A, B>();
world.register_required_components_with::<B, C>(|| C(1));
world.register_required_components_with::<A, C>(|| C(2));

// This will implicitly also insert B with its Default constructor and C
// with the custom constructor defined by A.
let id = world.spawn(A).id();
assert_eq!(&B(0), world.entity(id).get::<B>().unwrap());
assert_eq!(&C(2), world.entity(id).get::<C>().unwrap());

pub fn try_register_required_components<T, R>( &mut self, ) -> Result<(), RequiredComponentsError>

where T: Component, R: Component + Default,

Tries to register the given component R as a required component for T.

When T is added to an entity, R and its own required components will also be added if R was not already provided. The Default constructor will be used for the creation of R. If a custom constructor is desired, use [World::register_required_components_with] instead.

For the panicking version, see [World::register_required_components].

Note that requirements must currently be registered before T is inserted into the world for the first time. This limitation may be fixed in the future.

Errors

Returns a [RequiredComponentsError] if R is already a directly required component for T, or if T has ever been added on an entity before the registration.

Indirect requirements through other components are allowed. In those cases, any existing requirements will only be overwritten if the new requirement is more specific.

Example

#[derive(Component)]
struct A;

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct B(usize);

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct C(u32);

// Register B as required by A and C as required by B.
world.register_required_components::<A, B>();
world.register_required_components::<B, C>();

// Duplicate registration! This will fail.
assert!(world.try_register_required_components::<A, B>().is_err());

// This will implicitly also insert B and C with their Default constructors.
let id = world.spawn(A).id();
assert_eq!(&B(0), world.entity(id).get::<B>().unwrap());
assert_eq!(&C(0), world.entity(id).get::<C>().unwrap());

pub fn try_register_required_components_with<T, R>( &mut self, constructor: fn() -> R, ) -> Result<(), RequiredComponentsError>

where T: Component, R: Component,

Tries to register the given component R as a required component for T.

When T is added to an entity, R and its own required components will also be added if R was not already provided. The given constructor will be used for the creation of R. If a Default constructor is desired, use [World::register_required_components] instead.

For the panicking version, see [World::register_required_components_with].

Note that requirements must currently be registered before T is inserted into the world for the first time. This limitation may be fixed in the future.

Errors

Returns a [RequiredComponentsError] if R is already a directly required component for T, or if T has ever been added on an entity before the registration.

Indirect requirements through other components are allowed. In those cases, any existing requirements will only be overwritten if the new requirement is more specific.

Example

#[derive(Component)]
struct A;

#[derive(Component, Default, PartialEq, Eq, Debug)]
struct B(usize);

#[derive(Component, PartialEq, Eq, Debug)]
struct C(u32);

// Register B and C as required by A and C as required by B.
// A requiring C directly will overwrite the indirect requirement through B.
world.register_required_components::<A, B>();
world.register_required_components_with::<B, C>(|| C(1));
world.register_required_components_with::<A, C>(|| C(2));

// Duplicate registration! Even if the constructors were different, this would fail.
assert!(world.try_register_required_components_with::<B, C>(|| C(1)).is_err());

// This will implicitly also insert B with its Default constructor and C
// with the custom constructor defined by A.
let id = world.spawn(A).id();
assert_eq!(&B(0), world.entity(id).get::<B>().unwrap());
assert_eq!(&C(2), world.entity(id).get::<C>().unwrap());

pub fn get_required_components<C>(&self) -> Option<&RequiredComponents>

where C: Component,

Retrieves the required components for the given component type, if it exists.

pub fn get_required_components_by_id( &self, id: ComponentId, ) -> Option<&RequiredComponents>

Retrieves the required components for the component of the given [ComponentId], if it exists.

pub fn register_component_with_descriptor( &mut self, descriptor: ComponentDescriptor, ) -> ComponentId

Registers a new [Component] type and returns the [ComponentId] created for it.

This method differs from [World::register_component] in that it uses a [ComponentDescriptor] to register the new component type instead of statically available type information. This enables the dynamic registration of new component definitions at runtime for advanced use cases.

While the option to register a component from a descriptor is useful in type-erased contexts, the standard [World::register_component] function should always be used instead when type information is available at compile time.

pub fn component_id<T>(&self) -> Option<ComponentId>

where T: Component,

Returns the [ComponentId] of the given [Component] type T.

The returned ComponentId is specific to the World instance it was retrieved from and should not be used with another World instance.

Returns None if the Component type has not yet been initialized within the World using [World::register_component].

use bevy_ecs::prelude::*;

let mut world = World::new();

#[derive(Component)]
struct ComponentA;

let component_a_id = world.register_component::<ComponentA>();

assert_eq!(component_a_id, world.component_id::<ComponentA>().unwrap())

See also

• ComponentIdFor
• [Components::component_id()]
• [Components::get_id()]

pub fn register_resource<R>(&mut self) -> ComponentId

where R: Resource,

Registers a new [Resource] type and returns the [ComponentId] created for it.

The [Resource] doesn’t have a value in the [World], it’s only registered. If you want to insert the [Resource] in the [World], use [World::init_resource] or [World::insert_resource] instead.

pub fn resource_id<T>(&self) -> Option<ComponentId>

where T: Resource,

Returns the [ComponentId] of the given [Resource] type T.

The returned [ComponentId] is specific to the [World] instance it was retrieved from and should not be used with another [World] instance.

Returns None if the [Resource] type has not yet been initialized within the [World] using [World::register_resource], [World::init_resource] or [World::insert_resource].

pub fn entity<F>(&self, entities: F) -> <F as WorldEntityFetch>::Ref<'_>

where F: WorldEntityFetch,

Returns [EntityRef]s that expose read-only operations for the given entities. This will panic if any of the given entities do not exist. Use [World::get_entity] if you want to check for entity existence instead of implicitly panicking.

This function supports fetching a single entity or multiple entities:

• Pass an [Entity] to receive a single [EntityRef].
• Pass a slice of [Entity]s to receive a Vec<EntityRef>.
• Pass an array of [Entity]s to receive an equally-sized array of [EntityRef]s.

Panics

If any of the given entities do not exist in the world.

Examples

Single [Entity]

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn(Position { x: 0.0, y: 0.0 }).id();

let position = world.entity(entity).get::<Position>().unwrap();
assert_eq!(position.x, 0.0);

Array of [Entity]s

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let e1 = world.spawn(Position { x: 0.0, y: 0.0 }).id();
let e2 = world.spawn(Position { x: 1.0, y: 1.0 }).id();

let [e1_ref, e2_ref] = world.entity([e1, e2]);
let e1_position = e1_ref.get::<Position>().unwrap();
assert_eq!(e1_position.x, 0.0);
let e2_position = e2_ref.get::<Position>().unwrap();
assert_eq!(e2_position.x, 1.0);

Slice of [Entity]s

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let e1 = world.spawn(Position { x: 0.0, y: 1.0 }).id();
let e2 = world.spawn(Position { x: 0.0, y: 1.0 }).id();
let e3 = world.spawn(Position { x: 0.0, y: 1.0 }).id();

let ids = vec![e1, e2, e3];
for eref in world.entity(&ids[..]) {
    assert_eq!(eref.get::<Position>().unwrap().y, 1.0);
}

EntityHashSet

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let e1 = world.spawn(Position { x: 0.0, y: 1.0 }).id();
let e2 = world.spawn(Position { x: 0.0, y: 1.0 }).id();
let e3 = world.spawn(Position { x: 0.0, y: 1.0 }).id();

let ids = EntityHashSet::from_iter([e1, e2, e3]);
for (_id, eref) in world.entity(&ids) {
    assert_eq!(eref.get::<Position>().unwrap().y, 1.0);
}

pub fn entity_mut<F>(&mut self, entities: F) -> <F as WorldEntityFetch>::Mut<'_>

where F: WorldEntityFetch,

Returns [EntityMut]s that expose read and write operations for the given entities. This will panic if any of the given entities do not exist. Use [World::get_entity_mut] if you want to check for entity existence instead of implicitly panicking.

This function supports fetching a single entity or multiple entities:

• Pass an [Entity] to receive a single [EntityWorldMut].
  • This reference type allows for structural changes to the entity, such as adding or removing components, or despawning the entity.
• Pass a slice of [Entity]s to receive a Vec<EntityMut>.
• Pass an array of [Entity]s to receive an equally-sized array of [EntityMut]s.
• Pass a reference to a EntityHashSet to receive an EntityHashMap<EntityMut>.

In order to perform structural changes on the returned entity reference, such as adding or removing components, or despawning the entity, only a single [Entity] can be passed to this function. Allowing multiple entities at the same time with structural access would lead to undefined behavior, so [EntityMut] is returned when requesting multiple entities.

Panics

If any of the given entities do not exist in the world.

Examples

Single [Entity]

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn(Position { x: 0.0, y: 0.0 }).id();

let mut entity_mut = world.entity_mut(entity);
let mut position = entity_mut.get_mut::<Position>().unwrap();
position.y = 1.0;
assert_eq!(position.x, 0.0);
entity_mut.despawn();

Array of [Entity]s

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let e1 = world.spawn(Position { x: 0.0, y: 0.0 }).id();
let e2 = world.spawn(Position { x: 1.0, y: 1.0 }).id();

let [mut e1_ref, mut e2_ref] = world.entity_mut([e1, e2]);
let mut e1_position = e1_ref.get_mut::<Position>().unwrap();
e1_position.x = 1.0;
assert_eq!(e1_position.x, 1.0);
let mut e2_position = e2_ref.get_mut::<Position>().unwrap();
e2_position.x = 2.0;
assert_eq!(e2_position.x, 2.0);

Slice of [Entity]s

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let e1 = world.spawn(Position { x: 0.0, y: 1.0 }).id();
let e2 = world.spawn(Position { x: 0.0, y: 1.0 }).id();
let e3 = world.spawn(Position { x: 0.0, y: 1.0 }).id();

let ids = vec![e1, e2, e3];
for mut eref in world.entity_mut(&ids[..]) {
    let mut pos = eref.get_mut::<Position>().unwrap();
    pos.y = 2.0;
    assert_eq!(pos.y, 2.0);
}

EntityHashSet

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let e1 = world.spawn(Position { x: 0.0, y: 1.0 }).id();
let e2 = world.spawn(Position { x: 0.0, y: 1.0 }).id();
let e3 = world.spawn(Position { x: 0.0, y: 1.0 }).id();

let ids = EntityHashSet::from_iter([e1, e2, e3]);
for (_id, mut eref) in world.entity_mut(&ids) {
    let mut pos = eref.get_mut::<Position>().unwrap();
    pos.y = 2.0;
    assert_eq!(pos.y, 2.0);
}

pub fn inspect_entity( &self, entity: Entity, ) -> Result<impl Iterator<Item = &ComponentInfo>, EntityNotSpawnedError>

Returns the components of an [Entity] through [ComponentInfo].

pub fn get_entity<F>( &self, entities: F, ) -> Result<<F as WorldEntityFetch>::Ref<'_>, EntityNotSpawnedError>

where F: WorldEntityFetch,

Returns [EntityRef]s that expose read-only operations for the given entities, returning Err if any of the given entities do not exist. Instead of immediately unwrapping the value returned from this function, prefer [World::entity].

This function supports fetching a single entity or multiple entities:

• Pass an [Entity] to receive a single [EntityRef].
• Pass a slice of [Entity]s to receive a Vec<EntityRef>.
• Pass an array of [Entity]s to receive an equally-sized array of [EntityRef]s.
• Pass a reference to a EntityHashSet to receive an EntityHashMap<EntityRef>.

Errors

If any of the given entities do not exist in the world, the first [Entity] found to be missing will return an [EntityNotSpawnedError].

Examples

For examples, see [World::entity].

pub fn get_entity_mut<F>( &mut self, entities: F, ) -> Result<<F as WorldEntityFetch>::Mut<'_>, EntityMutableFetchError>

where F: WorldEntityFetch,

Returns [EntityMut]s that expose read and write operations for the given entities, returning Err if any of the given entities do not exist. Instead of immediately unwrapping the value returned from this function, prefer [World::entity_mut].

This function supports fetching a single entity or multiple entities:

• Pass an [Entity] to receive a single [EntityWorldMut].
  • This reference type allows for structural changes to the entity, such as adding or removing components, or despawning the entity.
• Pass a slice of [Entity]s to receive a Vec<EntityMut>.
• Pass an array of [Entity]s to receive an equally-sized array of [EntityMut]s.
• Pass a reference to a EntityHashSet to receive an EntityHashMap<EntityMut>.

In order to perform structural changes on the returned entity reference, such as adding or removing components, or despawning the entity, only a single [Entity] can be passed to this function. Allowing multiple entities at the same time with structural access would lead to undefined behavior, so [EntityMut] is returned when requesting multiple entities.

Errors

• Returns [EntityMutableFetchError::NotSpawned] if any of the given entities do not exist in the world.
  • Only the first entity found to be missing will be returned.
• Returns [EntityMutableFetchError::AliasedMutability] if the same entity is requested multiple times.

Examples

For examples, see [World::entity_mut].

pub fn entities_and_commands(&mut self) -> (EntityFetcher<'_>, Commands<'_, '_>)

Simultaneously provides access to entity data and a command queue, which will be applied when the world is next flushed.

This allows using borrowed entity data to construct commands where the borrow checker would otherwise prevent it.

See [DeferredWorld::entities_and_commands] for the deferred version.

Example

#[derive(Component)]
struct Targets(Vec<Entity>);
#[derive(Component)]
struct TargetedBy(Entity);

let mut world: World = // ...
let (entities, mut commands) = world.entities_and_commands();

let entity = entities.get(eid).unwrap();
for &target in entity.get::<Targets>().unwrap().0.iter() {
    commands.entity(target).insert(TargetedBy(eid));
}

pub fn spawn_at<B>( &mut self, entity: Entity, bundle: B, ) -> Result<EntityWorldMut<'_>, SpawnError>

where B: Bundle,

Spawns the bundle on the valid but not spawned entity. If the entity can not be spawned for any reason, returns an error.

If it succeeds, this declares the entity to have this bundle.

In general, you should prefer spawn. Spawn internally calls this method, but it takes care of finding a suitable [Entity] for you. This is made available for advanced use, which you can see at [EntityAllocator::alloc].

Risk

It is possible to spawn an entity that has not been allocated yet; however, doing so is currently a bad idea as the allocator may hand out this entity index in the future, assuming it to be not spawned. This would cause a panic.

Manual spawning is a powerful tool, but must be used carefully.

Example

Currently, this is primarily used to spawn entities that come from [EntityAllocator::alloc]. See that for an example.

pub fn spawn_empty_at( &mut self, entity: Entity, ) -> Result<EntityWorldMut<'_>, SpawnError>

A faster version of spawn_at for the empty bundle.

pub fn spawn<B>(&mut self, bundle: B) -> EntityWorldMut<'_>

where B: Bundle,

Spawns a new [Entity] with a given [Bundle] of components and returns a corresponding [EntityWorldMut], which can be used to add components to the entity or retrieve its id. In case large batches of entities need to be spawned, consider using [World::spawn_batch] instead.

use bevy_ecs::{bundle::Bundle, component::Component, world::World};

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

#[derive(Component)]
struct Velocity {
    x: f32,
    y: f32,
};

#[derive(Component)]
struct Name(&'static str);

#[derive(Bundle)]
struct PhysicsBundle {
    position: Position,
    velocity: Velocity,
}

let mut world = World::new();

// `spawn` can accept a single component:
world.spawn(Position { x: 0.0, y: 0.0 });

// It can also accept a tuple of components:
world.spawn((
    Position { x: 0.0, y: 0.0 },
    Velocity { x: 1.0, y: 1.0 },
));

// Or it can accept a pre-defined Bundle of components:
world.spawn(PhysicsBundle {
    position: Position { x: 2.0, y: 2.0 },
    velocity: Velocity { x: 0.0, y: 4.0 },
});

let entity = world
    // Tuples can also mix Bundles and Components
    .spawn((
        PhysicsBundle {
            position: Position { x: 2.0, y: 2.0 },
            velocity: Velocity { x: 0.0, y: 4.0 },
        },
        Name("Elaina Proctor"),
    ))
    // Calling id() will return the unique identifier for the spawned entity
    .id();
let position = world.entity(entity).get::<Position>().unwrap();
assert_eq!(position.x, 2.0);

pub fn spawn_empty(&mut self) -> EntityWorldMut<'_>

Spawns a new [Entity] and returns a corresponding [EntityWorldMut], which can be used to add components to the entity or retrieve its id.

use bevy_ecs::{component::Component, world::World};

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}
#[derive(Component)]
struct Label(&'static str);
#[derive(Component)]
struct Num(u32);

let mut world = World::new();
let entity = world.spawn_empty()
    .insert(Position { x: 0.0, y: 0.0 }) // add a single component
    .insert((Num(1), Label("hello"))) // add a bundle of components
    .id();

let position = world.entity(entity).get::<Position>().unwrap();
assert_eq!(position.x, 0.0);

pub fn spawn_batch<I>( &mut self, iter: I, ) -> SpawnBatchIter<'_, <I as IntoIterator>::IntoIter>

where I: IntoIterator, <I as IntoIterator>::Item: Bundle, <<I as IntoIterator>::Item as DynamicBundle>::Effect: NoBundleEffect,

Spawns a batch of entities with the same component [Bundle] type. Takes a given [Bundle] iterator and returns a corresponding [Entity] iterator. This is more efficient than spawning entities and adding components to them individually using [World::spawn], but it is limited to spawning entities with the same [Bundle] type, whereas spawning individually is more flexible.

use bevy_ecs::{component::Component, entity::Entity, world::World};

#[derive(Component)]
struct Str(&'static str);
#[derive(Component)]
struct Num(u32);

let mut world = World::new();
let entities = world.spawn_batch(vec![
  (Str("a"), Num(0)), // the first entity
  (Str("b"), Num(1)), // the second entity
]).collect::<Vec<Entity>>();

assert_eq!(entities.len(), 2);

pub fn get<T>(&self, entity: Entity) -> Option<&T>

where T: Component,

Retrieves a reference to the given entity’s [Component] of the given type. Returns None if the entity does not have a [Component] of the given type.

use bevy_ecs::{component::Component, world::World};

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn(Position { x: 0.0, y: 0.0 }).id();
let position = world.get::<Position>(entity).unwrap();
assert_eq!(position.x, 0.0);

pub fn get_mut<T>(&mut self, entity: Entity) -> Option<Mut<'_, T>>

where T: Component<Mutability = Mutable>,

Retrieves a mutable reference to the given entity’s [Component] of the given type. Returns None if the entity does not have a [Component] of the given type.

use bevy_ecs::{component::Component, world::World};

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn(Position { x: 0.0, y: 0.0 }).id();
let mut position = world.get_mut::<Position>(entity).unwrap();
position.x = 1.0;

pub fn modify_component<T, R>( &mut self, entity: Entity, f: impl FnOnce(&mut T) -> R, ) -> Result<Option<R>, EntityMutableFetchError>

where T: Component,

Temporarily removes a [Component] T from the provided [Entity] and runs the provided closure on it, returning the result if T was available. This will trigger the Remove and Replace component hooks without causing an archetype move.

This is most useful with immutable components, where removal and reinsertion is the only way to modify a value.

If you do not need to ensure the above hooks are triggered, and your component is mutable, prefer using get_mut.

Examples

#[derive(Component, PartialEq, Eq, Debug)]
#[component(immutable)]
struct Foo(bool);

world.modify_component(entity, |foo: &mut Foo| {
    foo.0 = true;
});

pub fn modify_component_by_id<R>( &mut self, entity: Entity, component_id: ComponentId, f: impl for<'a> FnOnce(MutUntyped<'a>) -> R, ) -> Result<Option<R>, EntityMutableFetchError>

Temporarily removes a [Component] identified by the provided [ComponentId] from the provided [Entity] and runs the provided closure on it, returning the result if the component was available. This will trigger the Remove and Replace component hooks without causing an archetype move.

This is most useful with immutable components, where removal and reinsertion is the only way to modify a value.

If you do not need to ensure the above hooks are triggered, and your component is mutable, prefer using get_mut_by_id.

You should prefer the typed modify_component whenever possible.

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

Despawns the given [Entity], if it exists. This will also remove all of the entity’s Components.

Returns true if the entity is successfully despawned and false if the entity does not exist. This counts despawning a not constructed entity as a success, and frees it to the allocator. See entity module docs for more about construction.

Note

This will also despawn the entities in any RelationshipTarget that is configured to despawn descendants. For example, this will recursively despawn Children.

use bevy_ecs::{component::Component, world::World};

#[derive(Component)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entity = world.spawn(Position { x: 0.0, y: 0.0 }).id();
assert!(world.despawn(entity));
assert!(world.get_entity(entity).is_err());
assert!(world.get::<Position>(entity).is_none());

pub fn try_despawn(&mut self, entity: Entity) -> Result<(), EntityDespawnError>

Despawns the given entity, if it exists. This will also remove all of the entity’s Components.

Returns an [EntityDespawnError] if the entity is not spawned to be despawned.

Note

This will also despawn the entities in any RelationshipTarget that is configured to despawn descendants. For example, this will recursively despawn Children.

pub fn despawn_no_free(&mut self, entity: Entity) -> Option<Entity>

Performs try_despawn_no_free, warning on errors. See that method for more information.

pub fn try_despawn_no_free( &mut self, entity: Entity, ) -> Result<Entity, EntityDespawnError>

Despawns the given entity, if it exists. This will also remove all of the entity’s [Component]s.

The only difference between this and despawning an entity is that this does not release the entity to be reused. It is up to the caller to either re-spawn or free the entity; otherwise, the EntityIndex will not be able to be reused. In general, despawn should be used instead, which automatically allows the row to be reused.

Returns the new [Entity] if of the despawned EntityIndex, which should eventually either be re-spawned or freed to the allocator. Returns an [EntityDespawnError] if the entity is not spawned.

Note

This will also despawn the entities in any RelationshipTarget that is configured to despawn descendants. For example, this will recursively despawn Children.

Example

There is no simple example in which this would be practical, but one use for this is a custom entity allocator. Despawning internally calls this and frees the entity id to Bevy’s default entity allocator. The same principal can be used to create custom allocators with additional properties. For example, this could be used to make an allocator that yields groups of consecutive EntityIndexs, etc. See [EntityAllocator::alloc] for more on this.

pub fn clear_trackers(&mut self)

Clears the internal component tracker state.

The world maintains some internal state about changed and removed components. This state is used by RemovedComponents to provide access to the entities that had a specific type of component removed since last tick.

The state is also used for change detection when accessing components and resources outside of a system, for example via [World::get_mut()] or [World::get_resource_mut()].

By clearing this internal state, the world “forgets” about those changes, allowing a new round of detection to be recorded.

When using bevy_ecs as part of the full Bevy engine, this method is called automatically by bevy_app::App::update and bevy_app::SubApp::update, so you don’t need to call it manually. When using bevy_ecs as a separate standalone crate however, you do need to call this manually.

// a whole new world
let mut world = World::new();

// you changed it
let entity = world.spawn(Transform::default()).id();

// change is detected
let transform = world.get_mut::<Transform>(entity).unwrap();
assert!(transform.is_changed());

// update the last change tick
world.clear_trackers();

// change is no longer detected
let transform = world.get_mut::<Transform>(entity).unwrap();
assert!(!transform.is_changed());

pub fn query<D>(&mut self) -> QueryState<D>

where D: QueryData,

Returns [QueryState] for the given [QueryData], which is used to efficiently run queries on the [World] by storing and reusing the [QueryState].

use bevy_ecs::{component::Component, entity::Entity, world::World};

#[derive(Component, Debug, PartialEq)]
struct Position {
  x: f32,
  y: f32,
}

#[derive(Component)]
struct Velocity {
  x: f32,
  y: f32,
}

let mut world = World::new();
let entities = world.spawn_batch(vec![
    (Position { x: 0.0, y: 0.0}, Velocity { x: 1.0, y: 0.0 }),
    (Position { x: 0.0, y: 0.0}, Velocity { x: 0.0, y: 1.0 }),
]).collect::<Vec<Entity>>();

let mut query = world.query::<(&mut Position, &Velocity)>();
for (mut position, velocity) in query.iter_mut(&mut world) {
   position.x += velocity.x;
   position.y += velocity.y;
}

assert_eq!(world.get::<Position>(entities[0]).unwrap(), &Position { x: 1.0, y: 0.0 });
assert_eq!(world.get::<Position>(entities[1]).unwrap(), &Position { x: 0.0, y: 1.0 });

To iterate over entities in a deterministic order, sort the results of the query using the desired component as a key. Note that this requires fetching the whole result set from the query and allocation of a Vec to store it.

use bevy_ecs::{component::Component, entity::Entity, world::World};

#[derive(Component, PartialEq, Eq, PartialOrd, Ord, Debug)]
struct Order(i32);
#[derive(Component, PartialEq, Debug)]
struct Label(&'static str);

let mut world = World::new();
let a = world.spawn((Order(2), Label("second"))).id();
let b = world.spawn((Order(3), Label("third"))).id();
let c = world.spawn((Order(1), Label("first"))).id();
let mut entities = world.query::<(Entity, &Order, &Label)>()
    .iter(&world)
    .collect::<Vec<_>>();
// Sort the query results by their `Order` component before comparing
// to expected results. Query iteration order should not be relied on.
entities.sort_by_key(|e| e.1);
assert_eq!(entities, vec![
    (c, &Order(1), &Label("first")),
    (a, &Order(2), &Label("second")),
    (b, &Order(3), &Label("third")),
]);

pub fn query_filtered<D, F>(&mut self) -> QueryState<D, F>

where D: QueryData, F: QueryFilter,

Returns [QueryState] for the given filtered [QueryData], which is used to efficiently run queries on the [World] by storing and reusing the [QueryState].

use bevy_ecs::{component::Component, entity::Entity, world::World, query::With};

#[derive(Component)]
struct A;
#[derive(Component)]
struct B;

let mut world = World::new();
let e1 = world.spawn(A).id();
let e2 = world.spawn((A, B)).id();

let mut query = world.query_filtered::<Entity, With<B>>();
let matching_entities = query.iter(&world).collect::<Vec<Entity>>();

assert_eq!(matching_entities, vec![e2]);

pub fn try_query<D>(&self) -> Option<QueryState<D>>

where D: QueryData,

Returns [QueryState] for the given [QueryData], which is used to efficiently run queries on the [World] by storing and reusing the [QueryState].

use bevy_ecs::{component::Component, entity::Entity, world::World};

#[derive(Component, Debug, PartialEq)]
struct Position {
  x: f32,
  y: f32,
}

let mut world = World::new();
world.spawn_batch(vec![
    Position { x: 0.0, y: 0.0 },
    Position { x: 1.0, y: 1.0 },
]);

fn get_positions(world: &World) -> Vec<(Entity, &Position)> {
    let mut query = world.try_query::<(Entity, &Position)>().unwrap();
    query.iter(world).collect()
}

let positions = get_positions(&world);

assert_eq!(world.get::<Position>(positions[0].0).unwrap(), positions[0].1);
assert_eq!(world.get::<Position>(positions[1].0).unwrap(), positions[1].1);

Requires only an immutable world reference, but may fail if, for example, the components that make up this query have not been registered into the world.

use bevy_ecs::{component::Component, entity::Entity, world::World};

#[derive(Component)]
struct A;

let mut world = World::new();

let none_query = world.try_query::<&A>();
assert!(none_query.is_none());

world.register_component::<A>();

let some_query = world.try_query::<&A>();
assert!(some_query.is_some());

pub fn try_query_filtered<D, F>(&self) -> Option<QueryState<D, F>>

where D: QueryData, F: QueryFilter,

Returns [QueryState] for the given filtered [QueryData], which is used to efficiently run queries on the [World] by storing and reusing the [QueryState].

use bevy_ecs::{component::Component, entity::Entity, world::World, query::With};

#[derive(Component)]
struct A;
#[derive(Component)]
struct B;

let mut world = World::new();
let e1 = world.spawn(A).id();
let e2 = world.spawn((A, B)).id();

let mut query = world.try_query_filtered::<Entity, With<B>>().unwrap();
let matching_entities = query.iter(&world).collect::<Vec<Entity>>();

assert_eq!(matching_entities, vec![e2]);

Requires only an immutable world reference, but may fail if, for example, the components that make up this query have not been registered into the world.

pub fn removed<T>(&self) -> impl Iterator<Item = Entity>

where T: Component,

Returns an iterator of entities that had components of type T removed since the last call to [World::clear_trackers].

pub fn removed_with_id( &self, component_id: ComponentId, ) -> impl Iterator<Item = Entity>

Returns an iterator of entities that had components with the given component_id removed since the last call to [World::clear_trackers].

pub fn register_resource_with_descriptor( &mut self, descriptor: ComponentDescriptor, ) -> ComponentId

Registers a new [Resource] type and returns the [ComponentId] created for it.

This enables the dynamic registration of new [Resource] definitions at runtime for advanced use cases.

Note

Registering a [Resource] does not insert it into [World]. For insertion, you could use [World::insert_resource_by_id].

pub fn init_resource<R>(&mut self) -> ComponentId

where R: Resource + FromWorld,

Initializes a new resource and returns the [ComponentId] created for it.

If the resource already exists, nothing happens.

The value given by the [FromWorld::from_world] method will be used. Note that any resource with the Default trait automatically implements [FromWorld], and those default values will be here instead.

pub fn insert_resource<R>(&mut self, value: R)

where R: Resource,

Inserts a new resource with the given value.

Resources are “unique” data of a given type. If you insert a resource of a type that already exists, you will overwrite any existing data.

pub fn init_non_send_resource<R>(&mut self) -> ComponentId

where R: 'static + FromWorld,

Initializes a new non-send resource and returns the [ComponentId] created for it.

If the resource already exists, nothing happens.

The value given by the [FromWorld::from_world] method will be used. Note that any resource with the Default trait automatically implements FromWorld, and those default values will be here instead.

Panics

Panics if called from a thread other than the main thread.

pub fn insert_non_send_resource<R>(&mut self, value: R)

where R: 'static,

Inserts a new non-send resource with the given value.

NonSend resources cannot be sent across threads, and do not need the Send + Sync bounds. Systems with NonSend resources are always scheduled on the main thread.

Panics

If a value is already present, this function will panic if called from a different thread than where the original value was inserted from.

pub fn remove_resource<R>(&mut self) -> Option<R>

where R: Resource,

Removes the resource of a given type and returns it, if it exists. Otherwise returns None.

pub fn remove_non_send_resource<R>(&mut self) -> Option<R>

where R: 'static,

Removes a !Send resource from the world and returns it, if present.

NonSend resources cannot be sent across threads, and do not need the Send + Sync bounds. Systems with NonSend resources are always scheduled on the main thread.

Returns None if a value was not previously present.

Panics

If a value is present, this function will panic if called from a different thread than where the value was inserted from.

pub fn contains_resource<R>(&self) -> bool

where R: Resource,

Returns true if a resource of type R exists. Otherwise returns false.

pub fn contains_resource_by_id(&self, component_id: ComponentId) -> bool

Returns true if a resource with provided component_id exists. Otherwise returns false.

pub fn contains_non_send<R>(&self) -> bool

where R: 'static,

Returns true if a resource of type R exists. Otherwise returns false.

pub fn contains_non_send_by_id(&self, component_id: ComponentId) -> bool

Returns true if a resource with provided component_id exists. Otherwise returns false.

pub fn is_resource_added<R>(&self) -> bool

where R: Resource,

Returns true if a resource of type R exists and was added since the world’s last_change_tick. Otherwise, this returns false.

This means that:

• When called from an exclusive system, this will check for additions since the system last ran.
• When called elsewhere, this will check for additions since the last time that [World::clear_trackers] was called.

pub fn is_resource_added_by_id(&self, component_id: ComponentId) -> bool

Returns true if a resource with id component_id exists and was added since the world’s last_change_tick. Otherwise, this returns false.

This means that:

• When called from an exclusive system, this will check for additions since the system last ran.
• When called elsewhere, this will check for additions since the last time that [World::clear_trackers] was called.

pub fn is_resource_changed<R>(&self) -> bool

where R: Resource,

Returns true if a resource of type R exists and was modified since the world’s last_change_tick. Otherwise, this returns false.

This means that:

• When called from an exclusive system, this will check for changes since the system last ran.
• When called elsewhere, this will check for changes since the last time that [World::clear_trackers] was called.

pub fn is_resource_changed_by_id(&self, component_id: ComponentId) -> bool

Returns true if a resource with id component_id exists and was modified since the world’s last_change_tick. Otherwise, this returns false.

This means that:

• When called from an exclusive system, this will check for changes since the system last ran.
• When called elsewhere, this will check for changes since the last time that [World::clear_trackers] was called.

pub fn get_resource_change_ticks<R>(&self) -> Option<ComponentTicks>

where R: Resource,

Retrieves the change ticks for the given resource.

pub fn get_resource_change_ticks_by_id( &self, component_id: ComponentId, ) -> Option<ComponentTicks>

Retrieves the change ticks for the given [ComponentId].

You should prefer to use the typed API [World::get_resource_change_ticks] where possible.

pub fn resource<R>(&self) -> &R

where R: Resource,

Gets a reference to the resource of the given type

Panics

Panics if the resource does not exist. Use get_resource instead if you want to handle this case.

If you want to instead insert a value if the resource does not exist, use get_resource_or_insert_with.

pub fn resource_ref<R>(&self) -> Ref<'_, R>

where R: Resource,

Gets a reference to the resource of the given type

Panics

Panics if the resource does not exist. Use get_resource_ref instead if you want to handle this case.

If you want to instead insert a value if the resource does not exist, use get_resource_or_insert_with.

pub fn resource_mut<R>(&mut self) -> Mut<'_, R>

where R: Resource,

Gets a mutable reference to the resource of the given type

Panics

Panics if the resource does not exist. Use get_resource_mut instead if you want to handle this case.

If you want to instead insert a value if the resource does not exist, use get_resource_or_insert_with.

pub fn get_resource<R>(&self) -> Option<&R>

where R: Resource,

Gets a reference to the resource of the given type if it exists

pub fn get_resource_ref<R>(&self) -> Option<Ref<'_, R>>

where R: Resource,

Gets a reference including change detection to the resource of the given type if it exists.

pub fn get_resource_mut<R>(&mut self) -> Option<Mut<'_, R>>

where R: Resource,

Gets a mutable reference to the resource of the given type if it exists

pub fn get_resource_or_insert_with<R>( &mut self, func: impl FnOnce() -> R, ) -> Mut<'_, R>

where R: Resource,

Gets a mutable reference to the resource of type T if it exists, otherwise inserts the resource using the result of calling func.

Example

#[derive(Resource)]
struct MyResource(i32);

let my_res = world.get_resource_or_insert_with(|| MyResource(10));
assert_eq!(my_res.0, 10);

pub fn get_resource_or_init<R>(&mut self) -> Mut<'_, R>

where R: Resource + FromWorld,

Gets a mutable reference to the resource of type T if it exists, otherwise initializes the resource by calling its [FromWorld] implementation.

Example

#[derive(Resource)]
struct Foo(i32);

impl Default for Foo {
    fn default() -> Self {
        Self(15)
    }
}

#[derive(Resource)]
struct MyResource(i32);

impl FromWorld for MyResource {
    fn from_world(world: &mut World) -> Self {
        let foo = world.get_resource_or_init::<Foo>();
        Self(foo.0 * 2)
    }
}

let my_res = world.get_resource_or_init::<MyResource>();
assert_eq!(my_res.0, 30);

pub fn non_send_resource<R>(&self) -> &R

where R: 'static,

Gets an immutable reference to the non-send resource of the given type, if it exists.

Panics

Panics if the resource does not exist. Use get_non_send_resource instead if you want to handle this case.

This function will panic if it isn’t called from the same thread that the resource was inserted from.

pub fn non_send_resource_mut<R>(&mut self) -> Mut<'_, R>

where R: 'static,

Gets a mutable reference to the non-send resource of the given type, if it exists.

Panics

Panics if the resource does not exist. Use get_non_send_resource_mut instead if you want to handle this case.

This function will panic if it isn’t called from the same thread that the resource was inserted from.

pub fn get_non_send_resource<R>(&self) -> Option<&R>

where R: 'static,

Gets a reference to the non-send resource of the given type, if it exists. Otherwise returns None.

Panics

This function will panic if it isn’t called from the same thread that the resource was inserted from.

pub fn get_non_send_resource_mut<R>(&mut self) -> Option<Mut<'_, R>>

where R: 'static,

Gets a mutable reference to the non-send resource of the given type, if it exists. Otherwise returns None.

Panics

This function will panic if it isn’t called from the same thread that the resource was inserted from.

pub fn insert_batch<I, B>(&mut self, batch: I)

where I: IntoIterator, <I as IntoIterator>::IntoIter: Iterator<Item = (Entity, B)>, B: Bundle, <B as DynamicBundle>::Effect: NoBundleEffect,

For a given batch of ([Entity], [Bundle]) pairs, adds the Bundle of components to each Entity. This is faster than doing equivalent operations one-by-one.

A batch can be any type that implements IntoIterator containing (Entity, Bundle) tuples, such as a Vec<(Entity, Bundle)> or an array [(Entity, Bundle); N].

This will overwrite any previous values of components shared by the Bundle. See [World::insert_batch_if_new] to keep the old values instead.

Panics

This function will panic if any of the associated entities do not exist.

For the fallible version, see [World::try_insert_batch].

pub fn insert_batch_if_new<I, B>(&mut self, batch: I)

where I: IntoIterator, <I as IntoIterator>::IntoIter: Iterator<Item = (Entity, B)>, B: Bundle, <B as DynamicBundle>::Effect: NoBundleEffect,

For a given batch of ([Entity], [Bundle]) pairs, adds the Bundle of components to each Entity without overwriting. This is faster than doing equivalent operations one-by-one.

A batch can be any type that implements IntoIterator containing (Entity, Bundle) tuples, such as a Vec<(Entity, Bundle)> or an array [(Entity, Bundle); N].

This is the same as [World::insert_batch], but in case of duplicate components it will leave the old values instead of replacing them with new ones.

Panics

This function will panic if any of the associated entities do not exist.

For the fallible version, see [World::try_insert_batch_if_new].

pub fn try_insert_batch<I, B>( &mut self, batch: I, ) -> Result<(), TryInsertBatchError>

where I: IntoIterator, <I as IntoIterator>::IntoIter: Iterator<Item = (Entity, B)>, B: Bundle, <B as DynamicBundle>::Effect: NoBundleEffect,

For a given batch of ([Entity], [Bundle]) pairs, adds the Bundle of components to each Entity. This is faster than doing equivalent operations one-by-one.

A batch can be any type that implements IntoIterator containing (Entity, Bundle) tuples, such as a Vec<(Entity, Bundle)> or an array [(Entity, Bundle); N].

This will overwrite any previous values of components shared by the Bundle. See [World::try_insert_batch_if_new] to keep the old values instead.

Returns a [TryInsertBatchError] if any of the provided entities do not exist.

For the panicking version, see [World::insert_batch].

pub fn try_insert_batch_if_new<I, B>( &mut self, batch: I, ) -> Result<(), TryInsertBatchError>

where I: IntoIterator, <I as IntoIterator>::IntoIter: Iterator<Item = (Entity, B)>, B: Bundle, <B as DynamicBundle>::Effect: NoBundleEffect,

For a given batch of ([Entity], [Bundle]) pairs, adds the Bundle of components to each Entity without overwriting. This is faster than doing equivalent operations one-by-one.

A batch can be any type that implements IntoIterator containing (Entity, Bundle) tuples, such as a Vec<(Entity, Bundle)> or an array [(Entity, Bundle); N].

This is the same as [World::try_insert_batch], but in case of duplicate components it will leave the old values instead of replacing them with new ones.

Returns a [TryInsertBatchError] if any of the provided entities do not exist.

For the panicking version, see [World::insert_batch_if_new].

pub fn resource_scope<R, U>( &mut self, f: impl FnOnce(&mut World, Mut<'_, R>) -> U, ) -> U

where R: Resource,

Temporarily removes the requested resource from this [World], runs custom user code, then re-adds the resource before returning.

This enables safe simultaneous mutable access to both a resource and the rest of the [World]. For more complex access patterns, consider using SystemState.

Panics

Panics if the resource does not exist. Use try_resource_scope instead if you want to handle this case.

Example

use bevy_ecs::prelude::*;
#[derive(Resource)]
struct A(u32);
#[derive(Component)]
struct B(u32);
let mut world = World::new();
world.insert_resource(A(1));
let entity = world.spawn(B(1)).id();

world.resource_scope(|world, mut a: Mut<A>| {
    let b = world.get_mut::<B>(entity).unwrap();
    a.0 += b.0;
});
assert_eq!(world.get_resource::<A>().unwrap().0, 2);

pub fn try_resource_scope<R, U>( &mut self, f: impl FnOnce(&mut World, Mut<'_, R>) -> U, ) -> Option<U>

where R: Resource,

Temporarily removes the requested resource from this [World] if it exists, runs custom user code, then re-adds the resource before returning. Returns None if the resource does not exist in this [World].

This enables safe simultaneous mutable access to both a resource and the rest of the [World]. For more complex access patterns, consider using SystemState.

See also resource_scope.

pub fn write_message<M>(&mut self, message: M) -> Option<MessageId<M>>

where M: Message,

Writes a [Message]. This method returns the [MessageId] of the written message, or None if the message could not be written.

pub fn write_message_default<M>(&mut self) -> Option<MessageId<M>>

where M: Message + Default,

Writes the default value of the [Message] of type M. This method returns the [MessageId] of the written message, or None if the event could not be written.

pub fn write_message_batch<M>( &mut self, messages: impl IntoIterator<Item = M>, ) -> Option<WriteBatchIds<M>>

where M: Message,

Writes a batch of [Message]s from an iterator. This method returns the IDs of the written messages, or None if the events could not be written.

pub unsafe fn insert_resource_by_id( &mut self, component_id: ComponentId, value: OwningPtr<'_>, caller: MaybeLocation, )

Inserts a new resource with the given value. Will replace the value if it already existed.

You should prefer to use the typed API [World::insert_resource] where possible and only use this in cases where the actual types are not known at compile time.

Safety

The value referenced by value must be valid for the given [ComponentId] of this world.

pub unsafe fn insert_non_send_by_id( &mut self, component_id: ComponentId, value: OwningPtr<'_>, caller: MaybeLocation, )

Inserts a new !Send resource with the given value. Will replace the value if it already existed.

You should prefer to use the typed API [World::insert_non_send_resource] where possible and only use this in cases where the actual types are not known at compile time.

Panics

If a value is already present, this function will panic if not called from the same thread that the original value was inserted from.

Safety

The value referenced by value must be valid for the given [ComponentId] of this world.

pub fn flush(&mut self)

Flushes queued entities and commands.

Queued entities will be spawned, and then commands will be applied.

pub fn increment_change_tick(&mut self) -> Tick

Increments the world’s current change tick and returns the old value.

If you need to call this method, but do not have &mut access to the world, consider using as_unsafe_world_cell_readonly to obtain an [UnsafeWorldCell] and calling increment_change_tick on that. Note that this can be done in safe code, despite the name of the type.

pub fn read_change_tick(&self) -> Tick

Reads the current change tick of this world.

If you have exclusive (&mut) access to the world, consider using change_tick(), which is more efficient since it does not require atomic synchronization.

pub fn change_tick(&mut self) -> Tick

Reads the current change tick of this world.

This does the same thing as read_change_tick(), only this method is more efficient since it does not require atomic synchronization.

pub fn last_change_tick(&self) -> Tick

When called from within an exclusive system (a System that takes &mut World as its first parameter), this method returns the [Tick] indicating the last time the exclusive system was run.

Otherwise, this returns the Tick indicating the last time that [World::clear_trackers] was called.

pub fn last_change_tick_scope<T>( &mut self, last_change_tick: Tick, f: impl FnOnce(&mut World) -> T, ) -> T

Sets [World::last_change_tick()] to the specified value during a scope. When the scope terminates, it will return to its old value.

This is useful if you need a region of code to be able to react to earlier changes made in the same system.

Examples

// This function runs an update loop repeatedly, allowing each iteration of the loop
// to react to changes made in the previous loop iteration.
fn update_loop(
    world: &mut World,
    mut update_fn: impl FnMut(&mut World) -> std::ops::ControlFlow<()>,
) {
    let mut last_change_tick = world.last_change_tick();

    // Repeatedly run the update function until it requests a break.
    loop {
        let control_flow = world.last_change_tick_scope(last_change_tick, |world| {
            // Increment the change tick so we can detect changes from the previous update.
            last_change_tick = world.change_tick();
            world.increment_change_tick();

            // Update once.
            update_fn(world)
        });

        // End the loop when the closure returns `ControlFlow::Break`.
        if control_flow.is_break() {
            break;
        }
    }
}

pub fn check_change_ticks(&mut self) -> Option<CheckChangeTicks>

Iterates all component change ticks and clamps any older than MAX_CHANGE_AGE. This also triggers [CheckChangeTicks] observers and returns the same event here.

Calling this method prevents [Tick]s overflowing and thus prevents false positives when comparing them.

Note: Does nothing and returns None if the [World] counter has not been incremented at least [CHECK_TICK_THRESHOLD] times since the previous pass.

pub fn clear_all(&mut self)

Runs both clear_entities and clear_resources, invalidating all [Entity] and resource fetches such as Res, ResMut

pub fn clear_entities(&mut self)

Despawns all entities in this [World].

pub fn clear_resources(&mut self)

Clears all resources in this [World].

Note: Any resource fetch to this [World] will fail unless they are re-initialized, including engine-internal resources that are only initialized on app/world construction.

This can easily cause systems expecting certain resources to immediately start panicking. Use with caution.

pub fn register_bundle<B>(&mut self) -> &BundleInfo

where B: Bundle,

Registers all of the components in the given [Bundle] and returns both the component ids and the bundle id.

This is largely equivalent to calling register_component on each component in the bundle.

pub fn register_dynamic_bundle( &mut self, component_ids: &[ComponentId], ) -> &BundleInfo

Registers the given [ComponentId]s as a dynamic bundle and returns both the required component ids and the bundle id.

Note that the components need to be registered first, this function only creates a bundle combining them. Components can be registered with [World::register_component]/_with_descriptor.

You should prefer to use the typed API [World::register_bundle] where possible and only use this in cases where not all of the actual types are known at compile time.

Panics

This function will panic if any of the provided component ids do not belong to a component known to this [World].

pub fn default_error_handler(&self) -> fn(BevyError, ErrorContext)

Convenience method for accessing the world’s default error handler, which can be overwritten with [DefaultErrorHandler].

pub fn get_resource_by_id(&self, component_id: ComponentId) -> Option<Ptr<'_>>

Gets a pointer to the resource with the id [ComponentId] if it exists. The returned pointer must not be used to modify the resource, and must not be dereferenced after the immutable borrow of the [World] ends.

You should prefer to use the typed API [World::get_resource] where possible and only use this in cases where the actual types are not known at compile time.

pub fn get_resource_mut_by_id( &mut self, component_id: ComponentId, ) -> Option<MutUntyped<'_>>

Gets a pointer to the resource with the id [ComponentId] if it exists. The returned pointer may be used to modify the resource, as long as the mutable borrow of the [World] is still valid.

You should prefer to use the typed API [World::get_resource_mut] where possible and only use this in cases where the actual types are not known at compile time.

pub fn iter_resources(&self) -> impl Iterator<Item = (&ComponentInfo, Ptr<'_>)>

Iterates over all resources in the world.

The returned iterator provides lifetimed, but type-unsafe pointers. Actually reading the contents of each resource will require the use of unsafe code.

Examples

Printing the size of all resources

let mut total = 0;
for (info, _) in world.iter_resources() {
   println!("Resource: {}", info.name());
   println!("Size: {} bytes", info.layout().size());
   total += info.layout().size();
}
println!("Total size: {} bytes", total);

Dynamically running closures for resources matching specific TypeIds

// In this example, `A` and `B` are resources. We deliberately do not use the
// `bevy_reflect` crate here to showcase the low-level [`Ptr`] usage. You should
// probably use something like `ReflectFromPtr` in a real-world scenario.

// Create the hash map that will store the closures for each resource type
let mut closures: HashMap<TypeId, Box<dyn Fn(&Ptr<'_>)>> = HashMap::default();

// Add closure for `A`
closures.insert(TypeId::of::<A>(), Box::new(|ptr| {
    // SAFETY: We assert ptr is the same type of A with TypeId of A
    let a = unsafe { &ptr.deref::<A>() };
    // ... do something with `a` here
}));

// Add closure for `B`
closures.insert(TypeId::of::<B>(), Box::new(|ptr| {
    // SAFETY: We assert ptr is the same type of B with TypeId of B
    let b = unsafe { &ptr.deref::<B>() };
    // ... do something with `b` here
}));

// Iterate all resources, in order to run the closures for each matching resource type
for (info, ptr) in world.iter_resources() {
    let Some(type_id) = info.type_id() else {
       // It's possible for resources to not have a `TypeId` (e.g. non-Rust resources
       // dynamically inserted via a scripting language) in which case we can't match them.
       continue;
    };

    let Some(closure) = closures.get(&type_id) else {
       // No closure for this resource type, skip it.
       continue;
    };

    // Run the closure for the resource
    closure(&ptr);
}

pub fn iter_resources_mut( &mut self, ) -> impl Iterator<Item = (&ComponentInfo, MutUntyped<'_>)>

Mutably iterates over all resources in the world.

The returned iterator provides lifetimed, but type-unsafe pointers. Actually reading from or writing to the contents of each resource will require the use of unsafe code.

Example

// In this example, `A` and `B` are resources. We deliberately do not use the
// `bevy_reflect` crate here to showcase the low-level `MutUntyped` usage. You should
// probably use something like `ReflectFromPtr` in a real-world scenario.

// Create the hash map that will store the mutator closures for each resource type
let mut mutators: HashMap<TypeId, Box<dyn Fn(&mut MutUntyped<'_>)>> = HashMap::default();

// Add mutator closure for `A`
mutators.insert(TypeId::of::<A>(), Box::new(|mut_untyped| {
    // Note: `MutUntyped::as_mut()` automatically marks the resource as changed
    // for ECS change detection, and gives us a `PtrMut` we can use to mutate the resource.
    // SAFETY: We assert ptr is the same type of A with TypeId of A
    let a = unsafe { &mut mut_untyped.as_mut().deref_mut::<A>() };
    // ... mutate `a` here
}));

// Add mutator closure for `B`
mutators.insert(TypeId::of::<B>(), Box::new(|mut_untyped| {
    // SAFETY: We assert ptr is the same type of B with TypeId of B
    let b = unsafe { &mut mut_untyped.as_mut().deref_mut::<B>() };
    // ... mutate `b` here
}));

// Iterate all resources, in order to run the mutator closures for each matching resource type
for (info, mut mut_untyped) in world.iter_resources_mut() {
    let Some(type_id) = info.type_id() else {
       // It's possible for resources to not have a `TypeId` (e.g. non-Rust resources
       // dynamically inserted via a scripting language) in which case we can't match them.
       continue;
    };

    let Some(mutator) = mutators.get(&type_id) else {
       // No mutator closure for this resource type, skip it.
       continue;
    };

    // Run the mutator closure for the resource
    mutator(&mut mut_untyped);
}

pub fn get_non_send_by_id(&self, component_id: ComponentId) -> Option<Ptr<'_>>

Gets a !Send resource to the resource with the id [ComponentId] if it exists. The returned pointer must not be used to modify the resource, and must not be dereferenced after the immutable borrow of the [World] ends.

You should prefer to use the typed API [World::get_resource] where possible and only use this in cases where the actual types are not known at compile time.

Panics

This function will panic if it isn’t called from the same thread that the resource was inserted from.

pub fn get_non_send_mut_by_id( &mut self, component_id: ComponentId, ) -> Option<MutUntyped<'_>>

Gets a !Send resource to the resource with the id [ComponentId] if it exists. The returned pointer may be used to modify the resource, as long as the mutable borrow of the [World] is still valid.

You should prefer to use the typed API [World::get_resource_mut] where possible and only use this in cases where the actual types are not known at compile time.

Panics

This function will panic if it isn’t called from the same thread that the resource was inserted from.

pub fn remove_resource_by_id(&mut self, component_id: ComponentId) -> Option<()>

Removes the resource of a given type, if it exists. Otherwise returns None.

You should prefer to use the typed API [World::remove_resource] where possible and only use this in cases where the actual types are not known at compile time.

pub fn remove_non_send_by_id(&mut self, component_id: ComponentId) -> Option<()>

Removes the resource of a given type, if it exists. Otherwise returns None.

You should prefer to use the typed API [World::remove_resource] where possible and only use this in cases where the actual types are not known at compile time.

Panics

This function will panic if it isn’t called from the same thread that the resource was inserted from.

pub fn get_by_id( &self, entity: Entity, component_id: ComponentId, ) -> Option<Ptr<'_>>

Retrieves an immutable untyped reference to the given entity’s [Component] of the given [ComponentId]. Returns None if the entity does not have a [Component] of the given type.

You should prefer to use the typed API [World::get_mut] where possible and only use this in cases where the actual types are not known at compile time.

Panics

This function will panic if it isn’t called from the same thread that the resource was inserted from.

pub fn get_mut_by_id( &mut self, entity: Entity, component_id: ComponentId, ) -> Option<MutUntyped<'_>>

Retrieves a mutable untyped reference to the given entity’s [Component] of the given [ComponentId]. Returns None if the entity does not have a [Component] of the given type.

You should prefer to use the typed API [World::get_mut] where possible and only use this in cases where the actual types are not known at compile time.

pub fn add_schedule(&mut self, schedule: Schedule)

Adds the specified [Schedule] to the world. If a schedule already exists with the same label, it will be replaced.

The schedule can later be run by calling .run_schedule(label) or by directly accessing the [Schedules] resource.

The Schedules resource will be initialized if it does not already exist.

An alternative to this is to call [Schedules::add_systems()] with some [ScheduleLabel] and let the schedule for that label be created if it does not already exist.

pub fn try_schedule_scope<R>( &mut self, label: impl ScheduleLabel, f: impl FnOnce(&mut World, &mut Schedule) -> R, ) -> Result<R, TryRunScheduleError>

Temporarily removes the schedule associated with label from the world, runs user code, and finally re-adds the schedule. This returns a [TryRunScheduleError] if there is no schedule associated with label.

The [Schedule] is fetched from the [Schedules] resource of the world by its label, and system state is cached.

For simple cases where you just need to call the schedule once, consider using [World::try_run_schedule] instead. For other use cases, see the example on [World::schedule_scope].

pub fn schedule_scope<R>( &mut self, label: impl ScheduleLabel, f: impl FnOnce(&mut World, &mut Schedule) -> R, ) -> R

Temporarily removes the schedule associated with label from the world, runs user code, and finally re-adds the schedule.

The [Schedule] is fetched from the [Schedules] resource of the world by its label, and system state is cached.

Examples

// Run the schedule five times.
world.schedule_scope(MySchedule, |world, schedule| {
    for _ in 0..5 {
        schedule.run(world);
    }
});

For simple cases where you just need to call the schedule once, consider using [World::run_schedule] instead.

Panics

If the requested schedule does not exist.

pub fn try_run_schedule( &mut self, label: impl ScheduleLabel, ) -> Result<(), TryRunScheduleError>

Attempts to run the [Schedule] associated with the label a single time, and returns a [TryRunScheduleError] if the schedule does not exist.

The [Schedule] is fetched from the [Schedules] resource of the world by its label, and system state is cached.

For simple testing use cases, call Schedule::run(&mut world) instead.

pub fn run_schedule(&mut self, label: impl ScheduleLabel)

Runs the [Schedule] associated with the label a single time.

The [Schedule] is fetched from the [Schedules] resource of the world by its label, and system state is cached.

For simple testing use cases, call Schedule::run(&mut world) instead. This avoids the need to create a unique [ScheduleLabel].

Panics

If the requested schedule does not exist.

pub fn allow_ambiguous_component<T>(&mut self)

where T: Component,

Ignore system order ambiguities caused by conflicts on [Component]s of type T.

pub fn allow_ambiguous_resource<T>(&mut self)

where T: Resource,

Ignore system order ambiguities caused by conflicts on [Resource]s of type T.

Trait Implementations

impl Default for MainWorld

fn default() -> MainWorld

Returns the “default value” for a type.

impl Deref for MainWorld

type Target = World

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for MainWorld

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Resource for MainWorld

where Self: Send + Sync + 'static,