Struct bevy::ecs::world::FilteredEntityMut
pub struct FilteredEntityMut<'w> { /* private fields */ }
Expand description
Provides mutable access to a single entity and some of its components defined by the contained Access
.
Implementations§
§impl<'w> FilteredEntityMut<'w>
impl<'w> FilteredEntityMut<'w>
pub fn reborrow(&mut self) -> FilteredEntityMut<'_>
pub fn reborrow(&mut self) -> FilteredEntityMut<'_>
Returns a new instance with a shorter lifetime.
This is useful if you have &mut FilteredEntityMut
, but you need FilteredEntityMut
.
pub fn as_readonly(&self) -> FilteredEntityRef<'_>
pub fn as_readonly(&self) -> FilteredEntityRef<'_>
Gets read-only access to all of the entity’s components.
pub 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,
}
}
}
pub fn location(&self) -> EntityLocation
pub fn location(&self) -> EntityLocation
Gets metadata indicating the location where the current entity is stored.
pub fn components(&self) -> impl Iterator<Item = ComponentId>
pub fn components(&self) -> impl Iterator<Item = ComponentId>
Returns an iterator over the component ids that are accessed by self.
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,
}
}
}
pub fn access(&self) -> &Access<ComponentId>
pub fn access(&self) -> &Access<ComponentId>
Returns a reference to the underlying Access
.
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,
}
}
}
pub 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
.
pub 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
.
pub 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
.
pub 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
.
pub 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
.
pub 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
.
pub 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.
pub 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 Self::get_change_ticks
where possible and only
use this in cases where the actual component types are not known at
compile time.
pub 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 Self::get
where possible and only
use this in cases where the actual component types are not known at
compile time.
Unlike FilteredEntityMut::get
, this returns a raw pointer to the component,
which is only valid while the FilteredEntityMut
is alive.
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,
}
}
}
pub 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 Self::get_mut
where possible and only
use this in cases where the actual component types are not known at
compile time.
Unlike FilteredEntityMut::get_mut
, this returns a raw pointer to the component,
which is only valid while the FilteredEntityMut
is alive.
Trait Implementations§
§impl<'a> From<&'a FilteredEntityMut<'_>> for FilteredEntityRef<'a>
impl<'a> From<&'a FilteredEntityMut<'_>> for FilteredEntityRef<'a>
§fn from(entity_mut: &'a FilteredEntityMut<'_>) -> FilteredEntityRef<'a>
fn from(entity_mut: &'a FilteredEntityMut<'_>) -> FilteredEntityRef<'a>
§impl<'a> From<&'a mut EntityMut<'_>> for FilteredEntityMut<'a>
impl<'a> From<&'a mut EntityMut<'_>> for FilteredEntityMut<'a>
§fn from(entity: &'a mut EntityMut<'_>) -> FilteredEntityMut<'a>
fn from(entity: &'a mut EntityMut<'_>) -> FilteredEntityMut<'a>
§impl<'a> From<&'a mut EntityWorldMut<'_>> for FilteredEntityMut<'a>
impl<'a> From<&'a mut EntityWorldMut<'_>> for FilteredEntityMut<'a>
§fn from(entity: &'a mut EntityWorldMut<'_>) -> FilteredEntityMut<'a>
fn from(entity: &'a mut EntityWorldMut<'_>) -> FilteredEntityMut<'a>
§impl<'a> From<EntityMut<'a>> for FilteredEntityMut<'a>
impl<'a> From<EntityMut<'a>> for FilteredEntityMut<'a>
§fn from(entity: EntityMut<'a>) -> FilteredEntityMut<'a>
fn from(entity: EntityMut<'a>) -> FilteredEntityMut<'a>
§impl<'a> From<EntityWorldMut<'a>> for FilteredEntityMut<'a>
impl<'a> From<EntityWorldMut<'a>> for FilteredEntityMut<'a>
§fn from(entity: EntityWorldMut<'a>) -> FilteredEntityMut<'a>
fn from(entity: EntityWorldMut<'a>) -> FilteredEntityMut<'a>
§impl<'w> From<FilteredEntityMut<'w>> for FilteredEntityRef<'w>
impl<'w> From<FilteredEntityMut<'w>> for FilteredEntityRef<'w>
§fn from(entity_mut: FilteredEntityMut<'w>) -> FilteredEntityRef<'w>
fn from(entity_mut: FilteredEntityMut<'w>) -> FilteredEntityRef<'w>
§impl<'a> QueryData for FilteredEntityMut<'a>
impl<'a> QueryData for FilteredEntityMut<'a>
SAFETY: access of FilteredEntityRef
is a subset of FilteredEntityMut
§type ReadOnly = FilteredEntityRef<'a>
type ReadOnly = FilteredEntityRef<'a>
QueryData
, which satisfies the ReadOnlyQueryData
trait.§impl<'a> TryFrom<&'a FilteredEntityMut<'_>> for EntityRef<'a>
impl<'a> TryFrom<&'a FilteredEntityMut<'_>> for EntityRef<'a>
§impl<'a> TryFrom<&'a mut FilteredEntityMut<'_>> for EntityMut<'a>
impl<'a> TryFrom<&'a mut FilteredEntityMut<'_>> for EntityMut<'a>
§impl<'a> TryFrom<FilteredEntityMut<'a>> for EntityMut<'a>
impl<'a> TryFrom<FilteredEntityMut<'a>> for EntityMut<'a>
§impl<'a> TryFrom<FilteredEntityMut<'a>> for EntityRef<'a>
impl<'a> TryFrom<FilteredEntityMut<'a>> for EntityRef<'a>
§impl<'a> WorldQuery for FilteredEntityMut<'a>
impl<'a> WorldQuery for FilteredEntityMut<'a>
SAFETY: The accesses of Self::ReadOnly
are a subset of the accesses of Self
§type Fetch<'w> = (UnsafeWorldCell<'w>, Access<ComponentId>)
type Fetch<'w> = (UnsafeWorldCell<'w>, Access<ComponentId>)
WorldQuery
to fetch Self::Item
§type Item<'w> = FilteredEntityMut<'w>
type Item<'w> = FilteredEntityMut<'w>
WorldQuery
For QueryData
this will be the item returned by the query.
For QueryFilter
this will be either ()
, or a bool
indicating whether the entity should be included
or a tuple of such things.§type State = FilteredAccess<ComponentId>
type State = FilteredAccess<ComponentId>
Self::Fetch
. This will be cached inside QueryState
,
so it is best to move as much data / computation here as possible to reduce the cost of
constructing Self::Fetch
.§fn shrink<'wlong, 'wshort>(
item: <FilteredEntityMut<'a> as WorldQuery>::Item<'wlong>
) -> <FilteredEntityMut<'a> as WorldQuery>::Item<'wshort>where
'wlong: 'wshort,
fn shrink<'wlong, 'wshort>(
item: <FilteredEntityMut<'a> as WorldQuery>::Item<'wlong>
) -> <FilteredEntityMut<'a> as WorldQuery>::Item<'wshort>where
'wlong: 'wshort,
§const IS_DENSE: bool = false
const IS_DENSE: bool = false
WorldQuery::set_table
must be used before
WorldQuery::fetch
can be called for iterators. If this returns false,
WorldQuery::set_archetype
must be used before WorldQuery::fetch
can be called for
iterators.§unsafe fn init_fetch<'w>(
world: UnsafeWorldCell<'w>,
_state: &<FilteredEntityMut<'a> as WorldQuery>::State,
_last_run: Tick,
_this_run: Tick
) -> <FilteredEntityMut<'a> as WorldQuery>::Fetch<'w>
unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, _state: &<FilteredEntityMut<'a> as WorldQuery>::State, _last_run: Tick, _this_run: Tick ) -> <FilteredEntityMut<'a> as WorldQuery>::Fetch<'w>
§unsafe fn set_archetype<'w>(
fetch: &mut <FilteredEntityMut<'a> as WorldQuery>::Fetch<'w>,
state: &<FilteredEntityMut<'a> as WorldQuery>::State,
archetype: &'w Archetype,
_table: &Table
)
unsafe fn set_archetype<'w>( fetch: &mut <FilteredEntityMut<'a> as WorldQuery>::Fetch<'w>, state: &<FilteredEntityMut<'a> as WorldQuery>::State, archetype: &'w Archetype, _table: &Table )
Archetype
. This will always be called on
archetypes that match this WorldQuery
. Read more§unsafe fn set_table<'w>(
fetch: &mut <FilteredEntityMut<'a> as WorldQuery>::Fetch<'w>,
state: &<FilteredEntityMut<'a> as WorldQuery>::State,
table: &'w Table
)
unsafe fn set_table<'w>( fetch: &mut <FilteredEntityMut<'a> as WorldQuery>::Fetch<'w>, state: &<FilteredEntityMut<'a> as WorldQuery>::State, table: &'w Table )
Table
. This will always be called on tables
that match this WorldQuery
. Read more§fn set_access<'w>(
state: &mut <FilteredEntityMut<'a> as WorldQuery>::State,
access: &FilteredAccess<ComponentId>
)
fn set_access<'w>( state: &mut <FilteredEntityMut<'a> as WorldQuery>::State, access: &FilteredAccess<ComponentId> )
FilteredEntityRef
or FilteredEntityMut
. Read more§unsafe fn fetch<'w>(
_: &mut <FilteredEntityMut<'a> as WorldQuery>::Fetch<'w>,
entity: Entity,
_table_row: TableRow
) -> <FilteredEntityMut<'a> as WorldQuery>::Item<'w>
unsafe fn fetch<'w>( _: &mut <FilteredEntityMut<'a> as WorldQuery>::Fetch<'w>, entity: Entity, _table_row: TableRow ) -> <FilteredEntityMut<'a> as WorldQuery>::Item<'w>
Self::Item
for either the given entity
in the current Table
,
or for the given entity
in the current Archetype
. This must always be called after
WorldQuery::set_table
with a table_row
in the range of the current Table
or after
WorldQuery::set_archetype
with a entity
in the current archetype. Read more§fn update_component_access(
state: &<FilteredEntityMut<'a> as WorldQuery>::State,
filtered_access: &mut FilteredAccess<ComponentId>
)
fn update_component_access( state: &<FilteredEntityMut<'a> as WorldQuery>::State, filtered_access: &mut FilteredAccess<ComponentId> )
WorldQuery
to access
.§fn init_state(
_world: &mut World
) -> <FilteredEntityMut<'a> as WorldQuery>::State
fn init_state( _world: &mut World ) -> <FilteredEntityMut<'a> as WorldQuery>::State
State
for this WorldQuery
type.§fn get_state(
_world: &World
) -> Option<<FilteredEntityMut<'a> as WorldQuery>::State>
fn get_state( _world: &World ) -> Option<<FilteredEntityMut<'a> as WorldQuery>::State>
State
for this WorldQuery
type.§fn matches_component_set(
_state: &<FilteredEntityMut<'a> as WorldQuery>::State,
_set_contains_id: &impl Fn(ComponentId) -> bool
) -> bool
fn matches_component_set( _state: &<FilteredEntityMut<'a> as WorldQuery>::State, _set_contains_id: &impl Fn(ComponentId) -> bool ) -> bool
true
if this query matches a set of components. Otherwise, returns false
.Auto Trait Implementations§
impl<'w> !RefUnwindSafe for FilteredEntityMut<'w>
impl<'w> Send for FilteredEntityMut<'w>
impl<'w> Sync for FilteredEntityMut<'w>
impl<'w> Unpin for FilteredEntityMut<'w>
impl<'w> !UnwindSafe for FilteredEntityMut<'w>
Blanket Implementations§
§impl<T, U> AsBindGroupShaderType<U> for T
impl<T, U> AsBindGroupShaderType<U> for T
§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
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§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
.§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
.§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.§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.