Struct legion::systems::SystemBuilder
source · [−]Expand description
A low level builder for constructing systems.
#[derive(Copy, Clone, Debug, PartialEq)]
struct Static;
#[derive(Debug)]
struct TestResource {}
let mut system_one = SystemBuilder::new("TestSystem")
.read_resource::<TestResource>()
.with_query(
<(Entity, Read<Position>, Read<Model>)>::query()
.filter(!component::<Static>() | maybe_changed::<Position>()),
)
.build(
move |commands, world, resource, queries| {
for (entity, pos, model) in queries.iter_mut(world) {}
},
);
Implementations
sourceimpl SystemBuilder<(), ()>
impl SystemBuilder<(), ()>
sourceimpl<Q, R> SystemBuilder<Q, R> where
Q: 'static + Send + ConsFlatten,
R: 'static + ConsFlatten,
impl<Q, R> SystemBuilder<Q, R> where
Q: 'static + Send + ConsFlatten,
R: 'static + ConsFlatten,
sourcepub fn with_query<V, F>(
self,
query: Query<V, F>
) -> SystemBuilder<<Q as ConsAppend<Query<V, F>>>::Output, R> where
V: IntoView,
F: 'static + EntityFilter,
Q: ConsAppend<Query<V, F>>,
pub fn with_query<V, F>(
self,
query: Query<V, F>
) -> SystemBuilder<<Q as ConsAppend<Query<V, F>>>::Output, R> where
V: IntoView,
F: 'static + EntityFilter,
Q: ConsAppend<Query<V, F>>,
Defines a query to provide this system for its execution. Multiple queries can be provided, and queries are cached internally for efficiency for filtering and archetype ID handling.
It is best practice to define your queries here, to allow for the caching to take place. These queries are then provided to the executing closure as a tuple of queries.
sourcepub fn read_resource<T>(
self
) -> SystemBuilder<Q, <R as ConsAppend<Read<T>>>::Output> where
T: 'static + Resource,
R: ConsAppend<Read<T>>,
<R as ConsAppend<Read<T>>>::Output: ConsFlatten,
pub fn read_resource<T>(
self
) -> SystemBuilder<Q, <R as ConsAppend<Read<T>>>::Output> where
T: 'static + Resource,
R: ConsAppend<Read<T>>,
<R as ConsAppend<Read<T>>>::Output: ConsFlatten,
Flag this resource type as being read by this system.
This will inform the dispatcher to not allow any writes access to this resource while this system is running. Parralel reads still occur during execution.
sourcepub fn write_resource<T>(
self
) -> SystemBuilder<Q, <R as ConsAppend<Write<T>>>::Output> where
T: 'static + Resource,
R: ConsAppend<Write<T>>,
<R as ConsAppend<Write<T>>>::Output: ConsFlatten,
pub fn write_resource<T>(
self
) -> SystemBuilder<Q, <R as ConsAppend<Write<T>>>::Output> where
T: 'static + Resource,
R: ConsAppend<Write<T>>,
<R as ConsAppend<Write<T>>>::Output: ConsFlatten,
Flag this resource type as being written by this system.
This will inform the dispatcher to not allow any parallel access to this resource while this system is running.
sourcepub fn read_component<T>(self) -> Self where
T: Component,
pub fn read_component<T>(self) -> Self where
T: Component,
This performs a soft resource block on the component for writing. The dispatcher will generally handle dispatching read and writes on components based on archetype, allowing for more granular access and more parallelization of systems.
Using this method will mark the entire component as read by this system, blocking writing systems from accessing any archetypes which contain this component for the duration of its execution.
This type of access with SubWorld
is provided for cases where sparse component access
is required and searching entire query spaces for entities is inefficient.
sourcepub fn write_component<T>(self) -> Self where
T: Component,
pub fn write_component<T>(self) -> Self where
T: Component,
This performs a exclusive resource block on the component for writing. The dispatcher will generally handle dispatching read and writes on components based on archetype, allowing for more granular access and more parallelization of systems.
Using this method will mark the entire component as written by this system, blocking other systems from accessing any archetypes which contain this component for the duration of its execution.
This type of access with SubWorld
is provided for cases where sparse component access
is required and searching entire query spaces for entities is inefficient.
sourcepub fn build<F>(
self,
run_fn: F
) -> System<<R as ConsFlatten>::Output, <Q as ConsFlatten>::Output, F> where
<R as ConsFlatten>::Output: for<'a> ResourceSet<'a>,
<Q as ConsFlatten>::Output: QuerySet,
F: FnMut(&mut CommandBuffer, &mut SubWorld<'_>, &mut <<R as ConsFlatten>::Output as ResourceSet<'static>>::Result, &mut <Q as ConsFlatten>::Output),
pub fn build<F>(
self,
run_fn: F
) -> System<<R as ConsFlatten>::Output, <Q as ConsFlatten>::Output, F> where
<R as ConsFlatten>::Output: for<'a> ResourceSet<'a>,
<Q as ConsFlatten>::Output: QuerySet,
F: FnMut(&mut CommandBuffer, &mut SubWorld<'_>, &mut <<R as ConsFlatten>::Output as ResourceSet<'static>>::Result, &mut <Q as ConsFlatten>::Output),
Builds a system which is not Schedulable
, as it is not thread safe (!Send and !Sync),
but still implements all the calling infrastructure of the Runnable
trait. This provides
a way for legion consumers to leverage the System
construction and type-handling of
this build for thread local systems which cannot leave the main initializing thread.
Trait Implementations
Auto Trait Implementations
impl<Q, R> RefUnwindSafe for SystemBuilder<Q, R> where
Q: RefUnwindSafe,
R: RefUnwindSafe,
impl<Q, R> Send for SystemBuilder<Q, R> where
Q: Send,
R: Send,
impl<Q, R> Sync for SystemBuilder<Q, R> where
Q: Sync,
R: Sync,
impl<Q, R> Unpin for SystemBuilder<Q, R> where
Q: Unpin,
R: Unpin,
impl<Q, R> UnwindSafe for SystemBuilder<Q, R> where
Q: UnwindSafe,
R: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcepub fn borrow_mut(&mut self) -> &mut T
pub fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Downcast for T where
T: Any,
impl<T> Downcast for T where
T: Any,
sourcepub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
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
. Read more
sourcepub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
sourcepub fn as_any(&self) -> &(dyn Any + 'static)
pub 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. Read more
sourcepub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
pub 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. Read more