Struct specs_task::TaskMaker

pub struct TaskMaker<'a> { /* fields omitted */ }

A SystemData used for creating and assembling task graphs.

Implementations

impl<'a> TaskMaker<'a>

pub fn make_task_with_entity<'b, T: TaskComponent<'b> + Send + Sync>(
    &self,
    entity: Entity,
    task: T
)

Like make_task, but use entity for tracking the task components. This can make it easier to manage tasks coupled with a specific entity (rather than storing a separate task entity in a component).

pub fn make_task<'b, T: TaskComponent<'b> + Send + Sync>(
    &self,
    task: T
) -> Entity

Create a new task entity with the given TaskComponent. The task will not make progress until it is either finalized or the descendent of a finalized entity.

pub fn make_final_task_with_entity<'b, T: TaskComponent<'b> + Send + Sync>(
    &self,
    entity: Entity,
    task: T,
    on_completion: OnCompletion
) -> Entity

Same as make_task_with_entity, but also finalizes the task.

pub fn make_final_task<'b, T: TaskComponent<'b> + Send + Sync>(
    &self,
    task: T,
    on_completion: OnCompletion
) -> Entity

Same as make_task, but also finalizes the task.

pub fn make_fork(&self) -> Entity

Create a new fork entity with no children.

pub fn add_prong(&self, fork_entity: Entity, prong: Entity)

Add prong as a child on the MultiEdge of fork_entity.

pub fn join(&self, parent: Entity, child: Entity)

Creates a SingleEdge from parent to child. Creates a fork-join if parent is a fork.

pub fn finalize(&self, entity: Entity, on_completion: OnCompletion)

Mark entity as final. This will make all of entity's descendents visible to the TaskManagerSystem, allowing them to make progress. If OnCompletion::Delete, then entity and all of its descendents will be deleted when entity is complete (and hence the entire graph is complete). Otherwise, you need to clean up the entities your self by calling delete_entity_and_descendents. God help you if you leak an orphaned entity.

Trait Implementations

impl<'a> SystemData<'a> for TaskMaker<'a> where
    Read<'a, LazyUpdate>: SystemData<'a>,
    Entities<'a>: SystemData<'a>, 

fn setup(world: &mut World)

Sets up the system data for fetching it from the World.

fn fetch(world: &'a World) -> Self

Fetches the system data from World. Note that this is only specified for one concrete lifetime 'a, you need to implement the SystemData trait for every possible lifetime.

fn reads() -> Vec<ResourceId>

Returns all read dependencies as fetched from Self::fetch.

fn writes() -> Vec<ResourceId>

Returns all write dependencies as fetched from Self::fetch.