bevy_ecs::world

Struct World

Source
pub struct World { /* private fields */ }
Expand description

Stores and exposes operations on entities, components, resources, and their associated metadata.

Each Entity has a set of components. Each component can have up to one instance of each component type. Entity components can be created, updated, removed, and queried using a given World.

For complex access patterns involving SystemParam, consider using SystemState.

To mutate different parts of the world simultaneously, use World::resource_scope or SystemState.

§Resources

Worlds can also store Resources, which are unique instances of a given type that don’t belong to a specific Entity. There are also non send resources, which can only be accessed on the main thread. See Resource for usage.

Implementations§

Source§

impl World

Source

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

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

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

§Example
#[derive(Component)]
struct A;

world.add_observer(|_: Trigger<OnAdd, A>| {
    // ...
});
world.add_observer(|_: Trigger<OnRemove, A>| {
    // ...
});
Source

pub fn trigger(&mut self, event: impl Event)

Triggers the given Event, which will run any Observers watching for it.

While event types commonly implement Copy, those that don’t will be consumed and will no longer be accessible. If you need to use the event after triggering it, use World::trigger_ref instead.

Source

pub fn trigger_ref(&mut self, event: &mut impl Event)

Triggers the given Event as a mutable reference, which will run any Observers 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.

Source

pub fn trigger_targets( &mut self, event: impl Event, targets: impl TriggerTargets, )

Triggers the given Event for the given targets, which will run any Observers watching for it.

While event types commonly implement Copy, those that don’t will be consumed and will no longer be accessible. If you need to use the event after triggering it, use World::trigger_targets_ref instead.

Source

pub fn trigger_targets_ref( &mut self, event: &mut impl Event, targets: impl TriggerTargets, )

Triggers the given Event as a mutable reference for the given targets, which will run any Observers watching for it.

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

Source§

impl World

Source

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.

Source

pub fn register_boxed_system<I, O>( &mut self, system: BoxedSystem<I, O>, ) -> 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.

Source

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.

Source

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

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.

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

§Limitations
§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"));
}
Source

pub fn run_system_with_input<I, O>( &mut self, id: SystemId<I, O>, input: I::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.

§Limitations
§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_input(counter_one, 1).unwrap(), 1);
assert_eq!(world.run_system_with_input(counter_one, 20).unwrap(), 21);
assert_eq!(world.run_system_with_input(counter_two, 30).unwrap(), 30);

See World::run_system for more examples.

Source

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.

Source

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.

Source

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

Runs a cached system, registering it if necessary.

See World::register_system_cached for more information.

Source

pub fn run_system_cached_with<I, O, M, S>( &mut self, system: S, input: I::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.

Source§

impl World

Source

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

Available on crate feature bevy_reflect only.

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 called1.

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

Source

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

Available on crate feature bevy_reflect only.

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).

Source§

impl World

Source

pub fn new() -> World

Creates a new empty World.

§Panics

If usize::MAX Worlds have been created. This guarantee allows System Parameters to safely uniquely identify a World, since its WorldId is unique

Source

pub fn id(&self) -> WorldId

Retrieves this World’s unique ID

Source

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

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

Source

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

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

Source

pub fn entities(&self) -> &Entities

Retrieves this world’s Entities collection.

Source

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

Source

pub fn archetypes(&self) -> &Archetypes

Retrieves this world’s Archetypes collection.

Source

pub fn components(&self) -> &Components

Retrieves this world’s Components collection.

Source

pub fn storages(&self) -> &Storages

Retrieves this world’s Storages collection.

Source

pub fn bundles(&self) -> &Bundles

Retrieves this world’s Bundles collection.

Source

pub fn removed_components(&self) -> &RemovedComponentEvents

Retrieves this world’s RemovedComponentEvents collection

Source

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

Source

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

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

Source

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

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

Will panic if T exists in any archetypes.

Source

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.

Source

pub fn register_required_components<T: Component, R: Component + Default>( &mut self, )

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());
Source

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

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());
Source

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

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());
Source

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

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());
Source

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

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

Source

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.

Source

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.

Source

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

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
Source

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

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.

Source

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

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.

Source

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

Returns EntityRefs 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:

§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 Entitys
#[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 Entitys
#[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);
}
Source

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

Returns EntityMuts 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:

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 Entitys
#[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 Entitys
#[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);
}
Source

pub fn many_entities<const N: usize>( &mut self, entities: [Entity; N], ) -> [EntityRef<'_>; N]

👎Deprecated since 0.15.0: Use World::entity::<[Entity; N]> instead

Gets an EntityRef for multiple entities at once.

§Panics

If any entity does not exist in the world.

§Examples
// Getting multiple entities.
let [entity1, entity2] = world.many_entities([id1, id2]);
// Trying to get a despawned entity will fail.
world.despawn(id2);
world.many_entities([id1, id2]);
Source

pub fn many_entities_mut<const N: usize>( &mut self, entities: [Entity; N], ) -> [EntityMut<'_>; N]

👎Deprecated since 0.15.0: Use World::entity_mut::<[Entity; N]> instead

Gets mutable access to multiple entities at once.

§Panics

If any entities do not exist in the world, or if the same entity is specified multiple times.

§Examples

Disjoint mutable access.

// Disjoint mutable access.
let [entity1, entity2] = world.many_entities_mut([id1, id2]);

Trying to access the same entity multiple times will fail.

world.many_entities_mut([id, id]);
Source

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

Returns the components of an Entity through ComponentInfo.

Source

pub fn get_or_spawn(&mut self, entity: Entity) -> Option<EntityWorldMut<'_>>

👎Deprecated since 0.15.0: use World::spawn instead

Returns an EntityWorldMut for the given entity (if it exists) or spawns one if it doesn’t exist. This will return None if the entity exists with a different generation.

§Note

Spawning a specific entity value is rarely the right choice. Most apps should favor World::spawn. This method should generally only be used for sharing entities across apps, and only when they have a scheme worked out to share an ID space (which doesn’t happen by default).

Source

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

Returns EntityRefs 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:

§Errors

If any of the given entities do not exist in the world, the first Entity found to be missing will be returned in the Err.

§Examples

For examples, see World::entity.

Source

pub fn get_many_entities<const N: usize>( &self, entities: [Entity; N], ) -> Result<[EntityRef<'_>; N], Entity>

👎Deprecated since 0.15.0: Use World::get_entity::<[Entity; N]> instead

Gets an EntityRef for multiple entities at once.

§Errors

If any entity does not exist in the world.

§Examples
// Getting multiple entities.
let [entity1, entity2] = world.get_many_entities([id1, id2]).unwrap();

// Trying to get a despawned entity will fail.
world.despawn(id2);
assert!(world.get_many_entities([id1, id2]).is_err());
Source

pub fn get_many_entities_dynamic<'w>( &'w self, entities: &[Entity], ) -> Result<Vec<EntityRef<'w>>, Entity>

👎Deprecated since 0.15.0: Use World::get_entity::<&[Entity]> instead

Gets an EntityRef for multiple entities at once, whose number is determined at runtime.

§Errors

If any entity does not exist in the world.

§Examples
// Getting multiple entities.
let entities = world.get_many_entities_dynamic(&[id1, id2]).unwrap();
let entity1 = entities.get(0).unwrap();
let entity2 = entities.get(1).unwrap();

// Trying to get a despawned entity will fail.
world.despawn(id2);
assert!(world.get_many_entities_dynamic(&[id1, id2]).is_err());
Source

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

Returns EntityMuts 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:

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
§Examples

For examples, see World::entity_mut.

Source

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

Returns an Entity iterator of current entities.

This is useful in contexts where you only have read-only access to the World.

Source

pub fn iter_entities_mut(&mut self) -> impl Iterator<Item = EntityMut<'_>> + '_

Returns a mutable iterator over all entities in the World.

Source

pub fn get_many_entities_mut<const N: usize>( &mut self, entities: [Entity; N], ) -> Result<[EntityMut<'_>; N], QueryEntityError<'_>>

👎Deprecated since 0.15.0: Use World::get_entity_mut::<[Entity; N]> instead

Gets mutable access to multiple entities.

§Errors

If any entities do not exist in the world, or if the same entity is specified multiple times.

§Examples
// Disjoint mutable access.
let [entity1, entity2] = world.get_many_entities_mut([id1, id2]).unwrap();

// Trying to access the same entity multiple times will fail.
assert!(world.get_many_entities_mut([id1, id1]).is_err());
Source

pub fn get_many_entities_dynamic_mut<'w>( &'w mut self, entities: &[Entity], ) -> Result<Vec<EntityMut<'w>>, QueryEntityError<'w>>

👎Deprecated since 0.15.0: Use World::get_entity_mut::<&[Entity]> instead

Gets mutable access to multiple entities, whose number is determined at runtime.

§Errors

If any entities do not exist in the world, or if the same entity is specified multiple times.

§Examples
// Disjoint mutable access.
let mut entities = world.get_many_entities_dynamic_mut(&[id1, id2]).unwrap();
let entity1 = entities.get_mut(0).unwrap();

// Trying to access the same entity multiple times will fail.
assert!(world.get_many_entities_dynamic_mut(&[id1, id1]).is_err());
Source

pub fn get_many_entities_from_set_mut<'w>( &'w mut self, entities: &EntityHashSet, ) -> Result<Vec<EntityMut<'w>>, QueryEntityError<'w>>

👎Deprecated since 0.15.0: Use World::get_entity_mut::<&EntityHashSet> instead.

Gets mutable access to multiple entities, contained in a EntityHashSet. The uniqueness of items in a EntityHashSet allows us to avoid checking for duplicates.

§Errors

If any entities do not exist in the world.

§Examples
let s = EntityHash::default();
let mut set = EntityHashSet::with_hasher(s);
set.insert(id1);
set.insert(id2);

// Disjoint mutable access.
let mut entities = world.get_many_entities_from_set_mut(&set).unwrap();
let entity1 = entities.get_mut(0).unwrap();
Source

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);
Source

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

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);
Source

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

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);
Source

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

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);
Source

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

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;
Source

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.

§Note

This won’t clean up external references to the entity (such as parent-child relationships if you’re using bevy_hierarchy), which may leave the world in an invalid state.

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());
Source

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

Performs the same function as Self::despawn but does not emit a warning if the entity does not exist.

Source

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());
Source

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

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")),
]);
Source

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

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]);
Source

pub fn removed<T: Component>(&self) -> impl Iterator<Item = Entity> + '_

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

Source

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.

Source

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.

Source

pub fn init_resource<R: Resource + FromWorld>(&mut self) -> ComponentId

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.

Source

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

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.

Source

pub fn init_non_send_resource<R: 'static + FromWorld>(&mut self) -> ComponentId

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.

Source

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

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.

Source

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

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

Source

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

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.

Source

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

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

Source

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

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

Source

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

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

Source

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.

Source

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

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.
Source

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.
Source

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

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.
Source

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.
Source

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

Retrieves the change ticks for the given resource.

Source

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.

Source

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

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.

Source

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

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.

Source

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

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.

Source

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

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

Source

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

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

Source

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

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

Source

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

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);
Source

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

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);
Source

pub fn non_send_resource<R: 'static>(&self) -> &R

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.

Source

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

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.

Source

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

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.

Source

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

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.

Source

pub fn insert_or_spawn_batch<I, B>( &mut self, iter: I, ) -> Result<(), Vec<Entity>>
where I: IntoIterator, I::IntoIter: Iterator<Item = (Entity, B)>, B: Bundle,

For a given batch of (Entity, Bundle) pairs, either spawns each Entity with the given bundle (if the entity does not exist), or inserts the Bundle (if the entity already exists). This is faster than doing equivalent operations one-by-one. Returns Ok if all entities were successfully inserted into or spawned. Otherwise it returns an Err with a list of entities that could not be spawned or inserted into. A “spawn or insert” operation can only fail if an Entity is passed in with an “invalid generation” that conflicts with an existing Entity.

§Note

Spawning a specific entity value is rarely the right choice. Most apps should use World::spawn_batch. This method should generally only be used for sharing entities across apps, and only when they have a scheme worked out to share an ID space (which doesn’t happen by default).

use bevy_ecs::{entity::Entity, world::World, component::Component};
#[derive(Component)]
struct A(&'static str);
#[derive(Component, PartialEq, Debug)]
struct B(f32);

let mut world = World::new();
let e0 = world.spawn_empty().id();
let e1 = world.spawn_empty().id();
world.insert_or_spawn_batch(vec![
  (e0, (A("a"), B(0.0))), // the first entity
  (e1, (A("b"), B(1.0))), // the second entity
]);

assert_eq!(world.get::<B>(e0), Some(&B(0.0)));
Source

pub fn insert_batch<I, B>(&mut self, batch: I)
where I: IntoIterator, I::IntoIter: Iterator<Item = (Entity, B)>, B: Bundle,

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 non-panicking version, see World::try_insert_batch.

Source

pub fn insert_batch_if_new<I, B>(&mut self, batch: I)
where I: IntoIterator, I::IntoIter: Iterator<Item = (Entity, B)>, B: Bundle,

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 non-panicking version, see World::try_insert_batch_if_new.

Source

pub fn try_insert_batch<I, B>(&mut self, batch: I)
where I: IntoIterator, I::IntoIter: Iterator<Item = (Entity, B)>, B: Bundle,

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.

This function silently fails by ignoring any entities that do not exist.

For the panicking version, see World::insert_batch.

Source

pub fn try_insert_batch_if_new<I, B>(&mut self, batch: I)
where I: IntoIterator, I::IntoIter: Iterator<Item = (Entity, B)>, B: Bundle,

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.

This function silently fails by ignoring any entities that do not exist.

For the panicking version, see World::insert_batch_if_new.

Source

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

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.

§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);
Source

pub fn send_event<E: Event>(&mut self, event: E) -> Option<EventId<E>>

Sends an Event. This method returns the ID of the sent event, or None if the event could not be sent.

Source

pub fn send_event_default<E: Event + Default>(&mut self) -> Option<EventId<E>>

Sends the default value of the Event of type E. This method returns the ID of the sent event, or None if the event could not be sent.

Source

pub fn send_event_batch<E: Event>( &mut self, events: impl IntoIterator<Item = E>, ) -> Option<SendBatchIds<E>>

Sends a batch of Events from an iterator. This method returns the IDs of the sent events, or None if the event could not be sent.

Source

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

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.

Source

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

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.

Source

pub fn flush(&mut self)

Flushes queued entities and commands.

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

Source

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.

Source

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.

Source

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.

Source

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.

Source

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;
        }
    }
}
Source

pub fn check_change_ticks(&mut self)

Iterates all component change ticks and clamps any older than MAX_CHANGE_AGE. This prevents overflow and thus prevents false positives.

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

Source

pub fn clear_all(&mut self)

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

Source

pub fn clear_entities(&mut self)

Despawns all entities in this World.

Source

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.

Source

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

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.

Source§

impl World

Source

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.

Source

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.

Source

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::new();

// 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);
}
Source

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::new();

// 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);
}
Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source§

impl World

Source

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

Adds the specified Schedule to the world. 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.

Source

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.

Source

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.

Source

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.

Source

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.

§Panics

If the requested schedule does not exist.

Source

pub fn allow_ambiguous_component<T: Component>(&mut self)

Ignore system order ambiguities caused by conflicts on Components of type T.

Source

pub fn allow_ambiguous_resource<T: Resource>(&mut self)

Ignore system order ambiguities caused by conflicts on Resources of type T.

Trait Implementations§

Source§

impl Debug for World

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for World

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl Drop for World

Source§

fn drop(&mut self)

Executes the destructor for this type. Read more
Source§

impl<F> EntityCommand<World> for F
where F: FnOnce(EntityWorldMut<'_>) + Send + 'static,

Source§

fn apply(self, id: Entity, world: &mut World)

Executes this command for the given Entity.
Source§

fn with_entity(self, entity: Entity) -> impl Command
where Self: Sized,

Returns a Command which executes this EntityCommand for the given Entity. Read more
Source§

impl<'w> From<&'w World> for FilteredResources<'w, 'static>

Source§

fn from(value: &'w World) -> Self

Converts to this type from the input type.
Source§

impl<'w> From<&'w World> for UnsafeWorldCell<'w>

Source§

fn from(value: &'w World) -> Self

Converts to this type from the input type.
Source§

impl<'w> From<&'w mut World> for DeferredWorld<'w>

Source§

fn from(world: &'w mut World) -> DeferredWorld<'w>

Converts to this type from the input type.
Source§

impl<'w> From<&'w mut World> for FilteredResources<'w, 'static>

Source§

fn from(value: &'w mut World) -> Self

Converts to this type from the input type.
Source§

impl<'w> From<&'w mut World> for FilteredResourcesMut<'w, 'static>

Source§

fn from(value: &'w mut World) -> Self

Converts to this type from the input type.
Source§

impl<'w> From<&'w mut World> for UnsafeWorldCell<'w>

Source§

fn from(value: &'w mut World) -> Self

Converts to this type from the input type.
Source§

impl RunSystemOnce for &mut World

Source§

fn run_system_once_with<T, In, Out, Marker>( self, input: SystemIn<'_, T::System>, system: T, ) -> Result<Out, RunSystemError>
where T: IntoSystem<In, Out, Marker>, In: SystemInput,

Tries to run a system with given input and apply deferred parameters.
Source§

fn run_system_once<T, Out, Marker>( self, system: T, ) -> Result<Out, RunSystemError>
where T: IntoSystem<(), Out, Marker>,

Tries to run a system and apply its deferred parameters.
Source§

impl SystemParam for &World

Source§

type State = ()

Used to store data which persists across invocations of a system.
Source§

type Item<'w, 's> = &'w World

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes. Read more
Source§

fn init_state(_world: &mut World, system_meta: &mut SystemMeta) -> Self::State

Registers any World access used by this SystemParam and creates a new instance of this param’s State.
Source§

unsafe fn get_param<'w, 's>( _state: &'s mut Self::State, _system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, _change_tick: Tick, ) -> Self::Item<'w, 's>

Creates a parameter to be passed into a SystemParamFunction. Read more
Source§

unsafe fn new_archetype( state: &mut Self::State, archetype: &Archetype, system_meta: &mut SystemMeta, )

For the specified Archetype, registers the components accessed by this SystemParam (if applicable).a Read more
Source§

fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during apply_deferred.
Source§

fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next apply_deferred.
Source§

unsafe fn validate_param( _state: &Self::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'_>, ) -> bool

Validates that the param can be acquired by the get_param. Built-in executors use this to prevent systems with invalid params from running. For nested SystemParams validation will fail if any delegated validation fails. Read more
Source§

impl<'w> ReadOnlySystemParam for &'w World

SAFETY: only reads world

Source§

impl Send for World

Source§

impl Sync for World

Auto Trait Implementations§

§

impl !Freeze for World

§

impl !RefUnwindSafe for World

§

impl Unpin for World

§

impl !UnwindSafe for World

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

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

Source§

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

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

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

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

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

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

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

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

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

Source§

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

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

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

Source§

fn from_world(_world: &mut World) -> T

Creates Self using default().

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

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

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

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

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

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

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> WithSubscriber for T

Source§

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

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

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

type Item = Entity;
"}