Struct Graph 

pub struct Graph { /* private fields */ }

A built, type-checked DAG. Tile-independent; build once per style and evaluate many times.

Implementations

impl Graph

pub fn len(&self) -> usize

Number of nodes.

pub fn is_empty(&self) -> bool

pub fn output(&self) -> NodeIx

pub fn topo_order(&self) -> &[NodeIx]

Topological order; output node is last.

pub fn asset_inputs(&self) -> BTreeSet<String>

The union of every node’s Node::asset_inputs, deduplicated and ordered. A host consults this to learn which named bindings the document’s graph samples — including the @<dx>,<dy> neighbour names (see crate::neighbor) a cross-tile node requests, so it can fetch and bind exactly the neighbour tiles the graph needs rather than the whole 3×3 window unconditionally.

pub fn node(&self, ix: NodeIx) -> &dyn Node

pub fn node_id(&self, ix: NodeIx) -> &str

pub fn index_of(&self, id: &str) -> Option<NodeIx>

Look up a node’s index by id.

pub fn upstream(&self, ix: NodeIx) -> impl Iterator<Item = NodeIx> + '_

Upstream nodes feeding ix, deduplicated.

pub fn downstream(&self, ix: NodeIx) -> &[NodeIx]

Downstream nodes consuming ix’s output (may contain duplicates if the same node connects multiple of its input ports to ix).

pub fn downstream_unique(&self, ix: NodeIx) -> &[NodeIx]

Distinct downstream nodes consuming ix’s output, each listed once.

pub fn indegree(&self, ix: NodeIx) -> usize

Number of distinct upstream nodes feeding ix (0 for sources).

pub fn incoming(&self, ix: NodeIx, port_ix: usize) -> Option<NodeIx>

The source feeding node.inputs()[port_ix], if connected.

pub fn output_kind(&self, ix: NodeIx) -> PortKind

Resolved output PortKind for ix. Decided at build time; polymorphic nodes’ kind is fixed once the graph is built.

pub fn required_pad(&self) -> Result<u32, BuildError>

The canvas margin this graph needs, in pixels.

Every node that reads beyond the pixel it writes declares how far (Node::required_pad), and the fields those distances depend on must carry a static bound — precisely so this is answerable before anything renders. A host can therefore size its canvas from the graph instead of asking the style’s author to work it out:

let pad = doc.pad.max(graph.required_pad()?);

Treating the document’s pad as a floor rather than the answer keeps a deliberately generous margin intact while removing the failure mode where too small a one silently clamps edges.

It is a worst case: a $param contributes its declared max, so a blur whose sigma can reach 16 costs 48 px of margin on every render, not only the ones that use it. Pin pad explicitly to trade that back.

pub fn influence_pads(&self, assets: &dyn AssetLoader) -> Vec<u32>

Per node, how far outside the canvas that node’s geometry can still reach the rendered tile — see Node::influence_pad.

A source consults its own entry to decide which features are worth carrying. Unlike Graph::compute_pad this never fails: a distance too large to be useful saturates at u32::MAX, which reads as “keep everything” and so errs towards drawing.

pub fn compute_pad(&self, doc_pad: u32) -> Result<Vec<u32>, BuildError>

Compute the canvas padding each node must supply, given the margin requested at the output.

Pass 0 to learn what the chain itself adds — see Graph::required_pad. Passing the document’s pad answers a different question: what sources must supply for the padded canvas to be clean out to its own corners, which the final crop discards.

Trait Implementations

impl Debug for Graph

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

Formats the value using the given formatter.