# RenderGraph in maplibre::render::graph - Rust
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.
Keywords: rust, rustlang, rust-lang, RenderGraph

# Struct maplibre::render::graph::RenderGraph

source · [−]

    pub struct RenderGraph {
        nodes: HashMap<NodeId, NodeState>,
        node_names: HashMap<Cow<'static, str>, NodeId>,
        sub_graphs: HashMap<Cow<'static, str>, RenderGraph>,
        input_node: Option<NodeId>,
        current_id: usize,
    }

Expand description

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();

## Fields

`nodes: HashMap<NodeId, NodeState>` `node_names: HashMap<Cow<'static, str>, NodeId>` `sub_graphs: HashMap<Cow<'static, str>, RenderGraph>` `input_node: Option<NodeId>` `current_id: usize`

## Implementations

source

### impl RenderGraph

source

#### pub const INPUT_NODE_NAME: &'static str

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

source

#### pub fn update(&mut self, state: &mut RenderState)

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

source

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

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

source

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

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

source

#### 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.

source

#### pub fn remove_node(
&mut self,
name: impl Into<Cow<'static, str>>
) -> Result<(), RenderGraphError>

Removes the `node` with the `name` from the graph. If the name is does not exist, nothing happens.

source

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

Retrieves the `NodeState` referenced by the `label`.

source

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

Retrieves the `NodeState` referenced by the `label` mutably.

source

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

Retrieves the `NodeId` referenced by the `label`.

source

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

Retrieves the `Node` referenced by the `label`.

source

#### 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.

source

#### 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`.

source

#### pub fn remove_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>

Removes the `Edge::SlotEdge` from the graph. If any nodes or slots do not exist then nothing happens.

source

#### 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`.

source

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

Removes the `Edge::NodeEdge` from the graph. If either node does not exist then nothing happens.

source

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

Verifies that the edge existence is as expected and checks that slot edges are connected correctly.

source

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

Checks whether the `edge` already exists in the graph.

source

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

Returns an iterator over the `NodeStates`.

source

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

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

source

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

Returns an iterator over the sub graphs.

source

#### 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.

source

#### 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.

source

#### 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.

source

#### 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.

source

#### pub fn remove_sub_graph(&mut self, name: impl Into<Cow<'static, str>>)

Removes the `sub_graph` with the `name` from the graph. If the name does not exist then nothing happens.

source

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

Retrieves the sub graph corresponding to the `name`.

source

#### 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

source

### impl Debug for RenderGraph

source

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

Formats the value using the given formatter. Read more

source

### impl Default for RenderGraph

source

#### fn default() -> RenderGraph

Returns the “default value” for a type. Read more

## Auto Trait Implementations

### impl !RefUnwindSafe for RenderGraph

### impl Send for RenderGraph

### impl Sync for RenderGraph

### impl Unpin for RenderGraph

### impl !UnwindSafe for RenderGraph

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### pub fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

### impl<T> Downcast for T where
T: Any,

#### 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

#### 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

#### 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

#### 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

### impl<T> Downcast<T> for T

#### pub fn downcast(&self) -> &T

### impl<T> DowncastSync for T where
T: Any + Send + Sync,

#### pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync + 'static>

Convert `Arc<Trait>` (where `Trait: Downcast`) to `Arc<Any>`. `Arc<Any>` can then be further `downcast` into `Arc<ConcreteType>` where `ConcreteType` implements `Trait`. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### pub fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T> Instrument for T

source

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more

source

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### pub fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> Same<T> for T

#### type Output = T

Should always be `Self`

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

### impl<T> Upcast<T> for T

#### pub fn upcast(&self) -> Option<&T>

source

### impl<T> WithSubscriber for T

source

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more

source

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more