Struct bevy::ecs::world::EntityWorldMut
source · pub struct EntityWorldMut<'w> { /* private fields */ }
Expand description
A mutable reference to a particular Entity
, and the entire world.
This is essentially a performance-optimized (Entity, &mut World)
tuple,
which caches the EntityLocation
to reduce duplicate lookups.
Since this type provides mutable access to the entire world, only one
EntityWorldMut
can exist at a time for a given world.
See also EntityMut
, which allows disjoint mutable access to multiple
entities at once. Unlike EntityMut
, this type allows adding and
removing components, and despawning the entity.
Implementations§
source§impl<'w> EntityWorldMut<'w>
impl<'w> EntityWorldMut<'w>
sourcepub fn id(&self) -> Entity
pub fn id(&self) -> Entity
Returns the ID of the current entity.
Examples found in repository?
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
fn main() {
let mut world = World::new();
let mut lines = std::io::stdin().lines();
let mut component_names = HashMap::<String, ComponentId>::new();
let mut component_info = HashMap::<ComponentId, ComponentInfo>::new();
println!("{}", PROMPT);
loop {
print!("\n> ");
let _ = std::io::stdout().flush();
let Some(Ok(line)) = lines.next() else {
return;
};
if line.is_empty() {
return;
};
let Some((first, rest)) = line.trim().split_once(|c: char| c.is_whitespace()) else {
match &line.chars().next() {
Some('c') => println!("{}", COMPONENT_PROMPT),
Some('s') => println!("{}", ENTITY_PROMPT),
Some('q') => println!("{}", QUERY_PROMPT),
_ => println!("{}", PROMPT),
}
continue;
};
match &first[0..1] {
"c" => {
rest.split(',').for_each(|component| {
let mut component = component.split_whitespace();
let Some(name) = component.next() else {
return;
};
let size = match component.next().map(|s| s.parse::<usize>()) {
Some(Ok(size)) => size,
_ => 0,
};
// Register our new component to the world with a layout specified by it's size
// SAFETY: [u64] is Send + Sync
let id = world.init_component_with_descriptor(unsafe {
ComponentDescriptor::new_with_layout(
name.to_string(),
StorageType::Table,
Layout::array::<u64>(size).unwrap(),
None,
)
});
let Some(info) = world.components().get_info(id) else {
return;
};
component_names.insert(name.to_string(), id);
component_info.insert(id, info.clone());
println!("Component {} created with id: {:?}", name, id.index());
});
}
"s" => {
let mut to_insert_ids = Vec::new();
let mut to_insert_data = Vec::new();
rest.split(',').for_each(|component| {
let mut component = component.split_whitespace();
let Some(name) = component.next() else {
return;
};
// Get the id for the component with the given name
let Some(&id) = component_names.get(name) else {
println!("Component {} does not exist", name);
return;
};
// Calculate the length for the array based on the layout created for this component id
let info = world.components().get_info(id).unwrap();
let len = info.layout().size() / std::mem::size_of::<u64>();
let mut values: Vec<u64> = component
.take(len)
.filter_map(|value| value.parse::<u64>().ok())
.collect();
values.resize(len, 0);
// Collect the id and array to be inserted onto our entity
to_insert_ids.push(id);
to_insert_data.push(values);
});
let mut entity = world.spawn_empty();
// Construct an `OwningPtr` for each component in `to_insert_data`
let to_insert_ptr = to_owning_ptrs(&mut to_insert_data);
// SAFETY:
// - Component ids have been taken from the same world
// - Each array is created to the layout specified in the world
unsafe {
entity.insert_by_ids(&to_insert_ids, to_insert_ptr.into_iter());
}
println!("Entity spawned with id: {:?}", entity.id());
}
"q" => {
let mut builder = QueryBuilder::<FilteredEntityMut>::new(&mut world);
parse_query(rest, &mut builder, &component_names);
let mut query = builder.build();
query.iter_mut(&mut world).for_each(|filtered_entity| {
let terms = filtered_entity
.components()
.map(|id| {
let ptr = filtered_entity.get_by_id(id).unwrap();
let info = component_info.get(&id).unwrap();
let len = info.layout().size() / std::mem::size_of::<u64>();
// SAFETY:
// - All components are created with layout [u64]
// - len is calculated from the component descriptor
let data = unsafe {
std::slice::from_raw_parts_mut(
ptr.assert_unique().as_ptr().cast::<u64>(),
len,
)
};
// If we have write access, increment each value once
if filtered_entity.access().has_write(id) {
data.iter_mut().for_each(|data| {
*data += 1;
});
}
format!("{}: {:?}", info.name(), data[0..len].to_vec())
})
.collect::<Vec<_>>()
.join(", ");
println!("{:?}: {}", filtered_entity.id(), terms);
});
}
_ => continue,
}
}
}
sourcepub fn location(&self) -> EntityLocation
pub fn location(&self) -> EntityLocation
Gets metadata indicating the location where the current entity is stored.
sourcepub fn archetype(&self) -> &Archetype
pub fn archetype(&self) -> &Archetype
Returns the archetype that the current entity belongs to.
sourcepub fn contains<T>(&self) -> boolwhere
T: Component,
pub fn contains<T>(&self) -> boolwhere
T: Component,
Returns true
if the current entity has a component of type T
.
Otherwise, this returns false
.
§Notes
If you do not know the concrete type of a component, consider using
Self::contains_id
or Self::contains_type_id
.
sourcepub fn contains_id(&self, component_id: ComponentId) -> bool
pub fn contains_id(&self, component_id: ComponentId) -> bool
Returns true
if the current entity has a component identified by component_id
.
Otherwise, this returns false.
§Notes
- If you know the concrete type of the component, you should prefer
Self::contains
. - If you know the component’s
TypeId
but not itsComponentId
, consider usingSelf::contains_type_id
.
sourcepub fn contains_type_id(&self, type_id: TypeId) -> bool
pub fn contains_type_id(&self, type_id: TypeId) -> bool
Returns true
if the current entity has a component with the type identified by type_id
.
Otherwise, this returns false.
§Notes
- If you know the concrete type of the component, you should prefer
Self::contains
. - If you have a
ComponentId
instead of aTypeId
, consider usingSelf::contains_id
.
sourcepub fn get<T>(&self) -> Option<&T>where
T: Component,
pub fn get<T>(&self) -> Option<&T>where
T: Component,
Gets access to the component of type T
for the current entity.
Returns None
if the entity does not have a component of type T
.
sourcepub fn get_ref<T>(&self) -> Option<Ref<'_, T>>where
T: Component,
pub fn get_ref<T>(&self) -> Option<Ref<'_, T>>where
T: Component,
Gets access to the component of type T
for the current entity,
including change detection information as a Ref
.
Returns None
if the entity does not have a component of type T
.
sourcepub fn get_mut<T>(&mut self) -> Option<Mut<'_, T>>where
T: Component,
pub fn get_mut<T>(&mut self) -> Option<Mut<'_, T>>where
T: Component,
Gets mutable access to the component of type T
for the current entity.
Returns None
if the entity does not have a component of type T
.
sourcepub fn get_change_ticks<T>(&self) -> Option<ComponentTicks>where
T: Component,
pub fn get_change_ticks<T>(&self) -> Option<ComponentTicks>where
T: Component,
Retrieves the change ticks for the given component. This can be useful for implementing change detection in custom runtimes.
sourcepub fn get_change_ticks_by_id(
&self,
component_id: ComponentId
) -> Option<ComponentTicks>
pub fn get_change_ticks_by_id( &self, component_id: ComponentId ) -> Option<ComponentTicks>
Retrieves the change ticks for the given ComponentId
. This can be useful for implementing change
detection in custom runtimes.
You should prefer to use the typed API EntityWorldMut::get_change_ticks
where possible and only
use this in cases where the actual component types are not known at
compile time.
sourcepub fn get_by_id(&self, component_id: ComponentId) -> Option<Ptr<'_>>
pub fn get_by_id(&self, component_id: ComponentId) -> Option<Ptr<'_>>
Gets the component of the given ComponentId
from the entity.
You should prefer to use the typed API EntityWorldMut::get
where possible and only
use this in cases where the actual component types are not known at
compile time.
Unlike EntityWorldMut::get
, this returns a raw pointer to the component,
which is only valid while the EntityWorldMut
is alive.
sourcepub fn get_mut_by_id(
&mut self,
component_id: ComponentId
) -> Option<MutUntyped<'_>>
pub fn get_mut_by_id( &mut self, component_id: ComponentId ) -> Option<MutUntyped<'_>>
Gets a MutUntyped
of the component of the given ComponentId
from the entity.
You should prefer to use the typed API EntityWorldMut::get_mut
where possible and only
use this in cases where the actual component types are not known at
compile time.
Unlike EntityWorldMut::get_mut
, this returns a raw pointer to the component,
which is only valid while the EntityWorldMut
is alive.
sourcepub fn insert<T>(&mut self, bundle: T) -> &mut EntityWorldMut<'w>where
T: Bundle,
pub fn insert<T>(&mut self, bundle: T) -> &mut EntityWorldMut<'w>where
T: Bundle,
Adds a Bundle
of components to the entity.
This will overwrite any previous value(s) of the same component type.
Examples found in repository?
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
fn spawn_tasks(mut commands: Commands) {
let thread_pool = AsyncComputeTaskPool::get();
for x in 0..NUM_CUBES {
for y in 0..NUM_CUBES {
for z in 0..NUM_CUBES {
// Spawn new task on the AsyncComputeTaskPool; the task will be
// executed in the background, and the Task future returned by
// spawn() can be used to poll for the result
let entity = commands.spawn_empty().id();
let task = thread_pool.spawn(async move {
let mut rng = rand::thread_rng();
let duration = Duration::from_secs_f32(rng.gen_range(0.05..0.2));
// Pretend this is a time-intensive function. :)
thread::sleep(duration);
// Such hard work, all done!
let transform = Transform::from_xyz(x as f32, y as f32, z as f32);
let mut command_queue = CommandQueue::default();
// we use a raw command queue to pass a FnOne(&mut World) back to be
// applied in a deferred manner.
command_queue.push(move |world: &mut World| {
let (box_mesh_handle, box_material_handle) = {
let mut system_state = SystemState::<(
Res<BoxMeshHandle>,
Res<BoxMaterialHandle>,
)>::new(world);
let (box_mesh_handle, box_material_handle) =
system_state.get_mut(world);
(box_mesh_handle.clone(), box_material_handle.clone())
};
world
.entity_mut(entity)
// Add our new PbrBundle of components to our tagged entity
.insert(PbrBundle {
mesh: box_mesh_handle,
material: box_material_handle,
transform,
..default()
})
// Task is complete, so remove task component from entity
.remove::<ComputeTransform>();
});
command_queue
});
// Spawn new entity and add our new task as a component
commands.entity(entity).insert(ComputeTransform(task));
}
}
}
}
sourcepub unsafe fn insert_by_id(
&mut self,
component_id: ComponentId,
component: OwningPtr<'_>
) -> &mut EntityWorldMut<'w>
pub unsafe fn insert_by_id( &mut self, component_id: ComponentId, component: OwningPtr<'_> ) -> &mut EntityWorldMut<'w>
Inserts a dynamic Component
into the entity.
This will overwrite any previous value(s) of the same component type.
You should prefer to use the typed API EntityWorldMut::insert
where possible.
§Safety
ComponentId
must be from the same world asEntityWorldMut
OwningPtr
must be a valid reference to the type represented byComponentId
sourcepub unsafe fn insert_by_ids<'a, I>(
&mut self,
component_ids: &[ComponentId],
iter_components: I
) -> &mut EntityWorldMut<'w>
pub unsafe fn insert_by_ids<'a, I>( &mut self, component_ids: &[ComponentId], iter_components: I ) -> &mut EntityWorldMut<'w>
Inserts a dynamic Bundle
into the entity.
This will overwrite any previous value(s) of the same component type.
You should prefer to use the typed API EntityWorldMut::insert
where possible.
If your Bundle
only has one component, use the cached API EntityWorldMut::insert_by_id
.
If possible, pass a sorted slice of ComponentId
to maximize caching potential.
§Safety
- Each
ComponentId
must be from the same world asEntityWorldMut
- Each
OwningPtr
must be a valid reference to the type represented byComponentId
Examples found in repository?
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
fn main() {
let mut world = World::new();
let mut lines = std::io::stdin().lines();
let mut component_names = HashMap::<String, ComponentId>::new();
let mut component_info = HashMap::<ComponentId, ComponentInfo>::new();
println!("{}", PROMPT);
loop {
print!("\n> ");
let _ = std::io::stdout().flush();
let Some(Ok(line)) = lines.next() else {
return;
};
if line.is_empty() {
return;
};
let Some((first, rest)) = line.trim().split_once(|c: char| c.is_whitespace()) else {
match &line.chars().next() {
Some('c') => println!("{}", COMPONENT_PROMPT),
Some('s') => println!("{}", ENTITY_PROMPT),
Some('q') => println!("{}", QUERY_PROMPT),
_ => println!("{}", PROMPT),
}
continue;
};
match &first[0..1] {
"c" => {
rest.split(',').for_each(|component| {
let mut component = component.split_whitespace();
let Some(name) = component.next() else {
return;
};
let size = match component.next().map(|s| s.parse::<usize>()) {
Some(Ok(size)) => size,
_ => 0,
};
// Register our new component to the world with a layout specified by it's size
// SAFETY: [u64] is Send + Sync
let id = world.init_component_with_descriptor(unsafe {
ComponentDescriptor::new_with_layout(
name.to_string(),
StorageType::Table,
Layout::array::<u64>(size).unwrap(),
None,
)
});
let Some(info) = world.components().get_info(id) else {
return;
};
component_names.insert(name.to_string(), id);
component_info.insert(id, info.clone());
println!("Component {} created with id: {:?}", name, id.index());
});
}
"s" => {
let mut to_insert_ids = Vec::new();
let mut to_insert_data = Vec::new();
rest.split(',').for_each(|component| {
let mut component = component.split_whitespace();
let Some(name) = component.next() else {
return;
};
// Get the id for the component with the given name
let Some(&id) = component_names.get(name) else {
println!("Component {} does not exist", name);
return;
};
// Calculate the length for the array based on the layout created for this component id
let info = world.components().get_info(id).unwrap();
let len = info.layout().size() / std::mem::size_of::<u64>();
let mut values: Vec<u64> = component
.take(len)
.filter_map(|value| value.parse::<u64>().ok())
.collect();
values.resize(len, 0);
// Collect the id and array to be inserted onto our entity
to_insert_ids.push(id);
to_insert_data.push(values);
});
let mut entity = world.spawn_empty();
// Construct an `OwningPtr` for each component in `to_insert_data`
let to_insert_ptr = to_owning_ptrs(&mut to_insert_data);
// SAFETY:
// - Component ids have been taken from the same world
// - Each array is created to the layout specified in the world
unsafe {
entity.insert_by_ids(&to_insert_ids, to_insert_ptr.into_iter());
}
println!("Entity spawned with id: {:?}", entity.id());
}
"q" => {
let mut builder = QueryBuilder::<FilteredEntityMut>::new(&mut world);
parse_query(rest, &mut builder, &component_names);
let mut query = builder.build();
query.iter_mut(&mut world).for_each(|filtered_entity| {
let terms = filtered_entity
.components()
.map(|id| {
let ptr = filtered_entity.get_by_id(id).unwrap();
let info = component_info.get(&id).unwrap();
let len = info.layout().size() / std::mem::size_of::<u64>();
// SAFETY:
// - All components are created with layout [u64]
// - len is calculated from the component descriptor
let data = unsafe {
std::slice::from_raw_parts_mut(
ptr.assert_unique().as_ptr().cast::<u64>(),
len,
)
};
// If we have write access, increment each value once
if filtered_entity.access().has_write(id) {
data.iter_mut().for_each(|data| {
*data += 1;
});
}
format!("{}: {:?}", info.name(), data[0..len].to_vec())
})
.collect::<Vec<_>>()
.join(", ");
println!("{:?}: {}", filtered_entity.id(), terms);
});
}
_ => continue,
}
}
}
sourcepub fn take<T>(&mut self) -> Option<T>where
T: Bundle,
pub fn take<T>(&mut self) -> Option<T>where
T: Bundle,
Removes all components in the Bundle
from the entity and returns their previous values.
Note: If the entity does not have every component in the bundle, this method will not remove any of them.
sourcepub fn remove<T>(&mut self) -> &mut EntityWorldMut<'w>where
T: Bundle,
pub fn remove<T>(&mut self) -> &mut EntityWorldMut<'w>where
T: Bundle,
Removes any components in the Bundle
from the entity.
See EntityCommands::remove
for more details.
Examples found in repository?
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
fn spawn_tasks(mut commands: Commands) {
let thread_pool = AsyncComputeTaskPool::get();
for x in 0..NUM_CUBES {
for y in 0..NUM_CUBES {
for z in 0..NUM_CUBES {
// Spawn new task on the AsyncComputeTaskPool; the task will be
// executed in the background, and the Task future returned by
// spawn() can be used to poll for the result
let entity = commands.spawn_empty().id();
let task = thread_pool.spawn(async move {
let mut rng = rand::thread_rng();
let duration = Duration::from_secs_f32(rng.gen_range(0.05..0.2));
// Pretend this is a time-intensive function. :)
thread::sleep(duration);
// Such hard work, all done!
let transform = Transform::from_xyz(x as f32, y as f32, z as f32);
let mut command_queue = CommandQueue::default();
// we use a raw command queue to pass a FnOne(&mut World) back to be
// applied in a deferred manner.
command_queue.push(move |world: &mut World| {
let (box_mesh_handle, box_material_handle) = {
let mut system_state = SystemState::<(
Res<BoxMeshHandle>,
Res<BoxMaterialHandle>,
)>::new(world);
let (box_mesh_handle, box_material_handle) =
system_state.get_mut(world);
(box_mesh_handle.clone(), box_material_handle.clone())
};
world
.entity_mut(entity)
// Add our new PbrBundle of components to our tagged entity
.insert(PbrBundle {
mesh: box_mesh_handle,
material: box_material_handle,
transform,
..default()
})
// Task is complete, so remove task component from entity
.remove::<ComputeTransform>();
});
command_queue
});
// Spawn new entity and add our new task as a component
commands.entity(entity).insert(ComputeTransform(task));
}
}
}
}
sourcepub fn retain<T>(&mut self) -> &mut EntityWorldMut<'w>where
T: Bundle,
pub fn retain<T>(&mut self) -> &mut EntityWorldMut<'w>where
T: Bundle,
Removes any components except those in the Bundle
from the entity.
See EntityCommands::retain
for more details.
sourcepub fn despawn(self)
pub fn despawn(self)
Despawns the current entity.
See World::despawn
for more details.
sourcepub fn world(&self) -> &World
pub fn world(&self) -> &World
Gets read-only access to the world that the current entity belongs to.
sourcepub unsafe fn world_mut(&mut self) -> &mut World
pub unsafe fn world_mut(&mut self) -> &mut World
Returns this entity’s world.
See EntityWorldMut::world_scope
or EntityWorldMut::into_world_mut
for a safe alternative.
§Safety
Caller must not modify the world in a way that changes the current entity’s location
If the caller does do something that could change the location, self.update_location()
must be called before using any other methods on this EntityWorldMut
.
sourcepub fn into_world_mut(self) -> &'w mut World
pub fn into_world_mut(self) -> &'w mut World
Returns this entity’s World
, consuming itself.
sourcepub fn world_scope<U>(&mut self, f: impl FnOnce(&mut World) -> U) -> U
pub fn world_scope<U>(&mut self, f: impl FnOnce(&mut World) -> U) -> U
Gives mutable access to this entity’s World
in a temporary scope.
This is a safe alternative to using EntityWorldMut::world_mut
.
§Examples
#[derive(Resource, Default, Clone, Copy)]
struct R(u32);
// This closure gives us temporary access to the world.
let new_r = entity.world_scope(|world: &mut World| {
// Mutate the world while we have access to it.
let mut r = world.resource_mut::<R>();
r.0 += 1;
// Return a value from the world before giving it back to the `EntityWorldMut`.
*r
});
sourcepub fn update_location(&mut self)
pub fn update_location(&mut self)
Updates the internal entity location to match the current location in the internal
World
.
This is only required when using the unsafe function EntityWorldMut::world_mut
,
which enables the location to change.
sourcepub fn entry<'a, T>(&'a mut self) -> Entry<'w, 'a, T>where
T: Component,
pub fn entry<'a, T>(&'a mut self) -> Entry<'w, 'a, T>where
T: Component,
Gets an Entry into the world for this entity and component for in-place manipulation.
The type parameter specifies which component to get.
§Examples
#[derive(Component, Default, Clone, Copy, Debug, PartialEq)]
struct Comp(u32);
let mut entity = world.spawn_empty();
entity.entry().or_insert_with(|| Comp(4));
assert_eq!(world.query::<&Comp>().single(&world).0, 4);
entity.entry::<Comp>().and_modify(|mut c| c.0 += 1);
assert_eq!(world.query::<&Comp>().single(&world).0, 5);
Trait Implementations§
source§impl<'w> BuildWorldChildren for EntityWorldMut<'w>
impl<'w> BuildWorldChildren for EntityWorldMut<'w>
source§fn with_children(
&mut self,
spawn_children: impl FnOnce(&mut WorldChildBuilder<'_>)
) -> &mut EntityWorldMut<'w>
fn with_children( &mut self, spawn_children: impl FnOnce(&mut WorldChildBuilder<'_>) ) -> &mut EntityWorldMut<'w>
WorldChildBuilder
.source§fn add_child(&mut self, child: Entity) -> &mut EntityWorldMut<'w>
fn add_child(&mut self, child: Entity) -> &mut EntityWorldMut<'w>
source§fn push_children(&mut self, children: &[Entity]) -> &mut EntityWorldMut<'w>
fn push_children(&mut self, children: &[Entity]) -> &mut EntityWorldMut<'w>
source§fn insert_children(
&mut self,
index: usize,
children: &[Entity]
) -> &mut EntityWorldMut<'w>
fn insert_children( &mut self, index: usize, children: &[Entity] ) -> &mut EntityWorldMut<'w>
source§fn remove_children(&mut self, children: &[Entity]) -> &mut EntityWorldMut<'w>
fn remove_children(&mut self, children: &[Entity]) -> &mut EntityWorldMut<'w>
source§fn set_parent(&mut self, parent: Entity) -> &mut EntityWorldMut<'w>
fn set_parent(&mut self, parent: Entity) -> &mut EntityWorldMut<'w>
source§fn remove_parent(&mut self) -> &mut EntityWorldMut<'w>
fn remove_parent(&mut self) -> &mut EntityWorldMut<'w>
source§fn clear_children(&mut self) -> &mut EntityWorldMut<'w>
fn clear_children(&mut self) -> &mut EntityWorldMut<'w>
Children
component will be removed if it exists, otherwise this does nothing.source§fn replace_children(&mut self, children: &[Entity]) -> &mut EntityWorldMut<'w>
fn replace_children(&mut self, children: &[Entity]) -> &mut EntityWorldMut<'w>
source§impl<'w> DespawnRecursiveExt for EntityWorldMut<'w>
impl<'w> DespawnRecursiveExt for EntityWorldMut<'w>
source§fn despawn_recursive(self)
fn despawn_recursive(self)
Despawns the provided entity and its children.
source§fn despawn_descendants(&mut self) -> &mut EntityWorldMut<'w>
fn despawn_descendants(&mut self) -> &mut EntityWorldMut<'w>
source§impl<'a> From<&'a EntityWorldMut<'_>> for EntityRef<'a>
impl<'a> From<&'a EntityWorldMut<'_>> for EntityRef<'a>
source§fn from(value: &'a EntityWorldMut<'_>) -> EntityRef<'a>
fn from(value: &'a EntityWorldMut<'_>) -> EntityRef<'a>
source§impl<'a> From<&'a EntityWorldMut<'_>> for FilteredEntityRef<'a>
impl<'a> From<&'a EntityWorldMut<'_>> for FilteredEntityRef<'a>
source§fn from(entity: &'a EntityWorldMut<'_>) -> FilteredEntityRef<'a>
fn from(entity: &'a EntityWorldMut<'_>) -> FilteredEntityRef<'a>
source§impl<'a> From<&'a mut EntityWorldMut<'_>> for EntityMut<'a>
impl<'a> From<&'a mut EntityWorldMut<'_>> for EntityMut<'a>
source§fn from(value: &'a mut EntityWorldMut<'_>) -> EntityMut<'a>
fn from(value: &'a mut EntityWorldMut<'_>) -> EntityMut<'a>
source§impl<'a> From<&'a mut EntityWorldMut<'_>> for FilteredEntityMut<'a>
impl<'a> From<&'a mut EntityWorldMut<'_>> for FilteredEntityMut<'a>
source§fn from(entity: &'a mut EntityWorldMut<'_>) -> FilteredEntityMut<'a>
fn from(entity: &'a mut EntityWorldMut<'_>) -> FilteredEntityMut<'a>
source§impl<'a> From<EntityWorldMut<'a>> for FilteredEntityMut<'a>
impl<'a> From<EntityWorldMut<'a>> for FilteredEntityMut<'a>
source§fn from(entity: EntityWorldMut<'a>) -> FilteredEntityMut<'a>
fn from(entity: EntityWorldMut<'a>) -> FilteredEntityMut<'a>
source§impl<'a> From<EntityWorldMut<'a>> for FilteredEntityRef<'a>
impl<'a> From<EntityWorldMut<'a>> for FilteredEntityRef<'a>
source§fn from(entity: EntityWorldMut<'a>) -> FilteredEntityRef<'a>
fn from(entity: EntityWorldMut<'a>) -> FilteredEntityRef<'a>
source§impl<'w> From<EntityWorldMut<'w>> for EntityMut<'w>
impl<'w> From<EntityWorldMut<'w>> for EntityMut<'w>
source§fn from(value: EntityWorldMut<'w>) -> EntityMut<'w>
fn from(value: EntityWorldMut<'w>) -> EntityMut<'w>
source§impl<'w> From<EntityWorldMut<'w>> for EntityRef<'w>
impl<'w> From<EntityWorldMut<'w>> for EntityRef<'w>
source§fn from(entity_mut: EntityWorldMut<'w>) -> EntityRef<'w>
fn from(entity_mut: EntityWorldMut<'w>) -> EntityRef<'w>
Auto Trait Implementations§
impl<'w> Freeze for EntityWorldMut<'w>
impl<'w> !RefUnwindSafe for EntityWorldMut<'w>
impl<'w> Send for EntityWorldMut<'w>
impl<'w> Sync for EntityWorldMut<'w>
impl<'w> Unpin for EntityWorldMut<'w>
impl<'w> !UnwindSafe for EntityWorldMut<'w>
Blanket Implementations§
source§impl<T, U> AsBindGroupShaderType<U> for T
impl<T, U> AsBindGroupShaderType<U> for T
source§fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U
fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U
T
ShaderType
for self
. When used in AsBindGroup
derives, it is safe to assume that all images in self
exist.source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
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>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
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)
fn as_any(&self) -> &(dyn Any + 'static)
&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)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.