Struct bevy::render::render_graph::RenderGraph

pub struct RenderGraph { /* private fields */ }

The render graph configures the modular, parallel and re-usable render logic. It is a retained and stateless (nodes itself my have their internal state) structure, which can not be modified while it is executed by the graph runner.

The RenderGraphRunner is responsible for executing the entire graph each frame.

It consists of three main components: Nodes, Edges and Slots.

Nodes are responsible for generating draw calls and operating on input and output slots. Edges specify the order of execution for nodes and connect input and output slots together. Slots describe the render resources created or used by the nodes.

Additionally a render graph can contain multiple sub graphs, which are run by the corresponding nodes. Every render graph can have it’s own optional input node.

Example

Here is a simple render graph example with two nodes connected by a node edge.

let mut graph = RenderGraph::default();
graph.add_node("input_node", MyNode);
graph.add_node("output_node", MyNode);
graph.add_node_edge("output_node", "input_node").unwrap();

Implementations

impl RenderGraph

pub const INPUT_NODE_NAME: &'static str

The name of the GraphInputNode of this graph. Used to connect other nodes to it.

pub fn update(&mut self, world: &mut World)

Updates all nodes and sub graphs of the render graph. Should be called before executing it.

pub fn set_input(&mut self, inputs: Vec<SlotInfo, Global>) -> NodeId

Creates an GraphInputNode with the specified slots if not already present.

pub fn input_node(&self) -> Option<&NodeState>

Returns the NodeState of the input node of this graph..

pub fn add_node<T>(
    &mut self,
    name: impl Into<Cow<'static, str>>,
    node: T
) -> NodeId where
    T: Node, 

Adds the node with the name to the graph. If the name is already present replaces it instead.

pub fn get_node_state(
    &self,
    label: impl Into<NodeLabel>
) -> Result<&NodeState, RenderGraphError>

Retrieves the NodeState referenced by the label.

pub fn get_node_state_mut(
    &mut self,
    label: impl Into<NodeLabel>
) -> Result<&mut NodeState, RenderGraphError>

Retrieves the NodeState referenced by the label mutably.

pub fn get_node_id(
    &self,
    label: impl Into<NodeLabel>
) -> Result<NodeId, RenderGraphError>

Retrieves the NodeId referenced by the label.

pub fn get_node<T>(
    &self,
    label: impl Into<NodeLabel>
) -> Result<&T, RenderGraphError> where
    T: Node, 

Retrieves the Node referenced by the label.

pub fn get_node_mut<T>(
    &mut self,
    label: impl Into<NodeLabel>
) -> Result<&mut T, RenderGraphError> where
    T: Node, 

Retrieves the Node referenced by the label mutably.

pub fn add_slot_edge(
    &mut self,
    output_node: impl Into<NodeLabel>,
    output_slot: impl Into<SlotLabel>,
    input_node: impl Into<NodeLabel>,
    input_slot: impl Into<SlotLabel>
) -> Result<(), RenderGraphError>

Adds the Edge::SlotEdge to the graph. This guarantees that the output_node is run before the input_node and also connects the output_slot to the input_slot.

pub fn add_node_edge(
    &mut self,
    output_node: impl Into<NodeLabel>,
    input_node: impl Into<NodeLabel>
) -> Result<(), RenderGraphError>

Adds the Edge::NodeEdge to the graph. This guarantees that the output_node is run before the input_node.

pub fn validate_edge(&mut self, edge: &Edge) -> Result<(), RenderGraphError>

Verifies that the edge is not already existing and checks that slot edges are connected correctly.

pub fn has_edge(&self, edge: &Edge) -> bool

Checks whether the edge already exists in the graph.

pub fn iter_nodes(&self) -> impl Iterator<Item = &NodeState>

Returns an iterator over the NodeStates.

pub fn iter_nodes_mut(&mut self) -> impl Iterator<Item = &mut NodeState>

Returns an iterator over the NodeStates, that allows modifying each value.

pub fn iter_sub_graphs(&self) -> impl Iterator<Item = (&str, &RenderGraph)>

Returns an iterator over the sub graphs.

pub fn iter_sub_graphs_mut(
    &mut self
) -> impl Iterator<Item = (&str, &mut RenderGraph)>

Returns an iterator over the sub graphs, that allows modifying each value.

pub fn iter_node_inputs(
    &self,
    label: impl Into<NodeLabel>
) -> Result<impl Iterator<Item = (&Edge, &NodeState)>, RenderGraphError>

Returns an iterator over a tuple of the input edges and the corresponding output nodes for the node referenced by the label.

pub fn iter_node_outputs(
    &self,
    label: impl Into<NodeLabel>
) -> Result<impl Iterator<Item = (&Edge, &NodeState)>, RenderGraphError>

Returns an iterator over a tuple of the output edges and the corresponding input nodes for the node referenced by the label.

pub fn add_sub_graph(
    &mut self,
    name: impl Into<Cow<'static, str>>,
    sub_graph: RenderGraph
)

Adds the sub_graph with the name to the graph. If the name is already present replaces it instead.

pub fn get_sub_graph(&self, name: impl AsRef<str>) -> Option<&RenderGraph>

Retrieves the sub graph corresponding to the name.

pub fn get_sub_graph_mut(
    &mut self,
    name: impl AsRef<str>
) -> Option<&mut RenderGraph>

Retrieves the sub graph corresponding to the name mutably.

Trait Implementations

impl Debug for RenderGraph

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for RenderGraph

pub fn default() -> RenderGraph

Returns the “default value” for a type.