Struct bevy::prelude::QueryBuilder
source · pub struct QueryBuilder<'w, D = (), F = ()>where
D: QueryData,
F: QueryFilter,{ /* private fields */ }
Expand description
Builder struct to create QueryState
instances at runtime.
let mut world = World::new();
let entity_a = world.spawn((A, B)).id();
let entity_b = world.spawn((A, C)).id();
// Instantiate the builder using the type signature of the iterator you will consume
let mut query = QueryBuilder::<(Entity, &B)>::new(&mut world)
// Add additional terms through builder methods
.with::<A>()
.without::<C>()
.build();
// Consume the QueryState
let (entity, b) = query.single(&world);
Implementations§
source§impl<'w, D, F> QueryBuilder<'w, D, F>where
D: QueryData,
F: QueryFilter,
impl<'w, D, F> QueryBuilder<'w, D, F>where
D: QueryData,
F: QueryFilter,
sourcepub fn new(world: &'w mut World) -> QueryBuilder<'w, D, F>
pub fn new(world: &'w mut World) -> QueryBuilder<'w, D, F>
Creates a new builder with the accesses required for Q
and F
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 world_mut(&mut self) -> &mut World
pub fn world_mut(&mut self) -> &mut World
Returns a mutable reference to the world passed to Self::new
.
sourcepub fn extend_access(&mut self, access: FilteredAccess<ComponentId>)
pub fn extend_access(&mut self, access: FilteredAccess<ComponentId>)
Adds access to self’s underlying FilteredAccess
respecting Self::or
and Self::and
sourcepub fn data<T>(&mut self) -> &mut QueryBuilder<'w, D, F>where
T: QueryData,
pub fn data<T>(&mut self) -> &mut QueryBuilder<'w, D, F>where
T: QueryData,
Adds accesses required for T
to self.
sourcepub fn filter<T>(&mut self) -> &mut QueryBuilder<'w, D, F>where
T: QueryFilter,
pub fn filter<T>(&mut self) -> &mut QueryBuilder<'w, D, F>where
T: QueryFilter,
Adds filter from T
to self.
sourcepub fn with<T>(&mut self) -> &mut QueryBuilder<'w, D, F>where
T: Component,
pub fn with<T>(&mut self) -> &mut QueryBuilder<'w, D, F>where
T: Component,
Adds With<T>
to the FilteredAccess
of self.
sourcepub fn with_id(&mut self, id: ComponentId) -> &mut QueryBuilder<'w, D, F>
pub fn with_id(&mut self, id: ComponentId) -> &mut QueryBuilder<'w, D, F>
Adds With<T>
to the FilteredAccess
of self from a runtime ComponentId
.
Examples found in repository?
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
fn parse_term<Q: QueryData>(
str: &str,
builder: &mut QueryBuilder<Q>,
components: &HashMap<String, ComponentId>,
) {
let mut matched = false;
let str = str.trim();
match str.chars().next() {
// Optional term
Some('?') => {
builder.optional(|b| parse_term(&str[1..], b, components));
matched = true;
}
// Reference term
Some('&') => {
let mut parts = str.split_whitespace();
let first = parts.next().unwrap();
if first == "&mut" {
if let Some(str) = parts.next() {
if let Some(&id) = components.get(str) {
builder.mut_id(id);
matched = true;
}
};
} else if let Some(&id) = components.get(&first[1..]) {
builder.ref_id(id);
matched = true;
}
}
// With term
Some(_) => {
if let Some(&id) = components.get(str) {
builder.with_id(id);
matched = true;
}
}
None => {}
};
if !matched {
println!("Unable to find component: {}", str);
}
}
sourcepub fn without<T>(&mut self) -> &mut QueryBuilder<'w, D, F>where
T: Component,
pub fn without<T>(&mut self) -> &mut QueryBuilder<'w, D, F>where
T: Component,
Adds Without<T>
to the FilteredAccess
of self.
sourcepub fn without_id(&mut self, id: ComponentId) -> &mut QueryBuilder<'w, D, F>
pub fn without_id(&mut self, id: ComponentId) -> &mut QueryBuilder<'w, D, F>
Adds Without<T>
to the FilteredAccess
of self from a runtime ComponentId
.
sourcepub fn ref_id(&mut self, id: ComponentId) -> &mut QueryBuilder<'w, D, F>
pub fn ref_id(&mut self, id: ComponentId) -> &mut QueryBuilder<'w, D, F>
Adds &T
to the FilteredAccess
of self.
Examples found in repository?
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
fn parse_term<Q: QueryData>(
str: &str,
builder: &mut QueryBuilder<Q>,
components: &HashMap<String, ComponentId>,
) {
let mut matched = false;
let str = str.trim();
match str.chars().next() {
// Optional term
Some('?') => {
builder.optional(|b| parse_term(&str[1..], b, components));
matched = true;
}
// Reference term
Some('&') => {
let mut parts = str.split_whitespace();
let first = parts.next().unwrap();
if first == "&mut" {
if let Some(str) = parts.next() {
if let Some(&id) = components.get(str) {
builder.mut_id(id);
matched = true;
}
};
} else if let Some(&id) = components.get(&first[1..]) {
builder.ref_id(id);
matched = true;
}
}
// With term
Some(_) => {
if let Some(&id) = components.get(str) {
builder.with_id(id);
matched = true;
}
}
None => {}
};
if !matched {
println!("Unable to find component: {}", str);
}
}
sourcepub fn mut_id(&mut self, id: ComponentId) -> &mut QueryBuilder<'w, D, F>
pub fn mut_id(&mut self, id: ComponentId) -> &mut QueryBuilder<'w, D, F>
Adds &mut T
to the FilteredAccess
of self.
Examples found in repository?
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
fn parse_term<Q: QueryData>(
str: &str,
builder: &mut QueryBuilder<Q>,
components: &HashMap<String, ComponentId>,
) {
let mut matched = false;
let str = str.trim();
match str.chars().next() {
// Optional term
Some('?') => {
builder.optional(|b| parse_term(&str[1..], b, components));
matched = true;
}
// Reference term
Some('&') => {
let mut parts = str.split_whitespace();
let first = parts.next().unwrap();
if first == "&mut" {
if let Some(str) = parts.next() {
if let Some(&id) = components.get(str) {
builder.mut_id(id);
matched = true;
}
};
} else if let Some(&id) = components.get(&first[1..]) {
builder.ref_id(id);
matched = true;
}
}
// With term
Some(_) => {
if let Some(&id) = components.get(str) {
builder.with_id(id);
matched = true;
}
}
None => {}
};
if !matched {
println!("Unable to find component: {}", str);
}
}
sourcepub fn optional(
&mut self,
f: impl Fn(&mut QueryBuilder<'_>)
) -> &mut QueryBuilder<'w, D, F>
pub fn optional( &mut self, f: impl Fn(&mut QueryBuilder<'_>) ) -> &mut QueryBuilder<'w, D, F>
Takes a function over mutable access to a QueryBuilder
, calls that function
on an empty builder and then adds all accesses from that builder to self as optional.
Examples found in repository?
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
fn parse_term<Q: QueryData>(
str: &str,
builder: &mut QueryBuilder<Q>,
components: &HashMap<String, ComponentId>,
) {
let mut matched = false;
let str = str.trim();
match str.chars().next() {
// Optional term
Some('?') => {
builder.optional(|b| parse_term(&str[1..], b, components));
matched = true;
}
// Reference term
Some('&') => {
let mut parts = str.split_whitespace();
let first = parts.next().unwrap();
if first == "&mut" {
if let Some(str) = parts.next() {
if let Some(&id) = components.get(str) {
builder.mut_id(id);
matched = true;
}
};
} else if let Some(&id) = components.get(&first[1..]) {
builder.ref_id(id);
matched = true;
}
}
// With term
Some(_) => {
if let Some(&id) = components.get(str) {
builder.with_id(id);
matched = true;
}
}
None => {}
};
if !matched {
println!("Unable to find component: {}", str);
}
}
sourcepub fn and(
&mut self,
f: impl Fn(&mut QueryBuilder<'_>)
) -> &mut QueryBuilder<'w, D, F>
pub fn and( &mut self, f: impl Fn(&mut QueryBuilder<'_>) ) -> &mut QueryBuilder<'w, D, F>
Takes a function over mutable access to a QueryBuilder
, calls that function
on an empty builder and then adds all accesses from that builder to self.
Primarily used when inside a Self::or
closure to group several terms.
sourcepub fn or(
&mut self,
f: impl Fn(&mut QueryBuilder<'_>)
) -> &mut QueryBuilder<'w, D, F>
pub fn or( &mut self, f: impl Fn(&mut QueryBuilder<'_>) ) -> &mut QueryBuilder<'w, D, F>
Takes a function over mutable access to a QueryBuilder
, calls that function
on an empty builder, all accesses added to that builder will become terms in an or expression.
QueryBuilder::<Entity>::new(&mut world).or(|builder| {
builder.with::<A>();
builder.with::<B>();
});
// is equivalent to
QueryBuilder::<Entity>::new(&mut world).filter::<Or<(With<A>, With<B>)>>();
Examples found in repository?
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
fn parse_query<Q: QueryData>(
str: &str,
builder: &mut QueryBuilder<Q>,
components: &HashMap<String, ComponentId>,
) {
let str = str.split(',');
str.for_each(|term| {
let sub_terms: Vec<_> = term.split("||").collect();
if sub_terms.len() == 1 {
parse_term(sub_terms[0], builder, components);
} else {
builder.or(|b| {
sub_terms
.iter()
.for_each(|term| parse_term(term, b, components));
});
}
});
}
sourcepub fn access(&self) -> &FilteredAccess<ComponentId>
pub fn access(&self) -> &FilteredAccess<ComponentId>
Returns a reference to the the FilteredAccess
that will be provided to the built Query
.
sourcepub fn transmute<NewD>(&mut self) -> &mut QueryBuilder<'w, NewD>where
NewD: QueryData,
pub fn transmute<NewD>(&mut self) -> &mut QueryBuilder<'w, NewD>where
NewD: QueryData,
Transmute the existing builder adding required accesses. This will maintain all exisiting accesses.
If including a filter type see Self::transmute_filtered
sourcepub fn transmute_filtered<NewD, NewF>(
&mut self
) -> &mut QueryBuilder<'w, NewD, NewF>where
NewD: QueryData,
NewF: QueryFilter,
pub fn transmute_filtered<NewD, NewF>(
&mut self
) -> &mut QueryBuilder<'w, NewD, NewF>where
NewD: QueryData,
NewF: QueryFilter,
Transmute the existing builder adding required accesses. This will maintain all existing accesses.
sourcepub fn build(&mut self) -> QueryState<D, F>
pub fn build(&mut self) -> QueryState<D, F>
Create a QueryState
with the accesses of the builder.
Takes &mut self
to access the innner world reference while initializing
state for the new QueryState
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,
}
}
}
Trait Implementations§
source§impl<D, F> From<QueryBuilder<'_, D, F>> for QueryState<D, F>where
D: QueryData,
F: QueryFilter,
impl<D, F> From<QueryBuilder<'_, D, F>> for QueryState<D, F>where
D: QueryData,
F: QueryFilter,
source§fn from(value: QueryBuilder<'_, D, F>) -> QueryState<D, F>
fn from(value: QueryBuilder<'_, D, F>) -> QueryState<D, F>
Auto Trait Implementations§
impl<'w, D, F> Freeze for QueryBuilder<'w, D, F>where
F: WorldQuery,
D: WorldQuery,
impl<'w, D = (), F = ()> !RefUnwindSafe for QueryBuilder<'w, D, F>
impl<'w, D, F> Send for QueryBuilder<'w, D, F>
impl<'w, D, F> Sync for QueryBuilder<'w, D, F>
impl<'w, D, F> Unpin for QueryBuilder<'w, D, F>
impl<'w, D = (), F = ()> !UnwindSafe for QueryBuilder<'w, D, F>
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.