This crate provides the utilities for creating strictly ordered execution graphs of systems for the Bevy game engine.
|Bevy Version|bevy_system_graph| |:-----------|:------------------| |0.1 |0.6 |
To start building a system graph, one or more systems must be added to the graph as root nodes. Root systems have no dependencies within the graph. ```rust let graph = SystemGraph::new();
// Create a root system for the graph. let roota = graph.root(sysa);
// Graphs can have multiple root nodes. let rootb = graph.root(sysb); let rootc = graph.root(sysc); ```
Systems can still use labels to establish the ordering of systems relative
to other systems outside of the graph.
rust
let graph = SystemGraph::new();
let root_a = graph.root(
sys_a
.label("Physics")
.before("Propagate Transforms")
);
To ease adding all of the graph's systems into a Schedule, both
SystemGraph and SystemGraphNode implement Into<SystemSet>.
```rust
let graph = SystemGraph::new();
let roota = graph.root(sysa);
// Convert into a SystemSet let system_set: SystemSet = graph.into(); ```
Graph nodes can be sequentially chained via SystemGraphNode::then. This
creates a new node from a system and adds a "after" dependency on the original
system.
```rust
let graph = SystemGraph::new();
graph
.root(sysa)
.then(sysb)
.then(sys_c);
// Convert into a SystemSet let system_set: SystemSet = graph.into(); ```
SystemGraphNode::fork can be used to fan out into multiple branches. All fanned out systems will not execute
until the original has finished, but do not have a mutual dependency on each other.
```rust
let graph = SystemGraph::new();
// Fork out from one original node. // sysb, sysc, and sysd will only start when sysa finishes. let (c, b, d) = graph.root(sysa) .fork(( sysb, sysc, sysd, ));
// Alternatively, calling "then" repeatedly achieves the same thing. let e = d.then(syse); let f = d.then(sysf);
// Convert into a SystemSet let system_set: SystemSet = graph.into(); ```
A graph node can wait on multiple systems before running via SystemJoin::join.
The system will not run until all prior systems are finished.
```rust
let graph = SystemGraph::new();
let starta = graph.root(sysa); let startb = graph.root(sysb); let startc = graph.root(sysc);
(starta, startb, startc) .join(sysd) .then(sys_e);
// Convert into a SystemSet let system_set: SystemSet = graph.into(); ```
The types used to implement fork and join are composable.
```rust
let graph = SystemGraph::new();
graph.root(sysa)
.fork((sysb, sysc, sysd))
.join(syse)
.then(sysf);
// Convert into a SystemSet let system_set: SystemSet = graph.into(); ```
Individual [graph nodes] are backed by a Rc, so cloning it will still
point to the same logical underlying graph.