Struct NodeGraph

pub struct NodeGraph {
    pub nodes: Vec<Node>,
    pub edges: Vec<Edge>,
}

A clip’s effect chain as a DAG. When present it replaces Clip.effects (kept as the simple linear stack for clips that never opened the node editor). Always contains exactly one Output.

Fields

nodes: Vec<Node>

edges: Vec<Edge>

Implementations

impl NodeGraph

pub fn new(next_id: &mut impl FnMut() -> u64) -> Self

Input -> Output, ready to have effects dropped in between.

pub fn from_effects( effects: &[Effect], next_id: &mut impl FnMut() -> u64, ) -> Self

A graph equivalent to a linear effect stack (used when a clip’s stack is converted).

pub fn to_effects(&self) -> Result<Vec<Effect>, String>

The inverse of from_effects: the port-0 chain from Output back to Input as a linear stack. Err (with a reason for the toast) when the graph is not that shape — anything the output does not read is not part of the picture and is dropped without complaint.

pub fn node(&self, id: u64) -> Option<&Node>

pub fn node_mut(&mut self, id: u64) -> Option<&mut Node>

pub fn output(&self) -> Option<u64>

pub fn input_of(&self, to: u64, port: usize) -> Option<u64>

The node feeding to’s input port.

pub fn connect(&mut self, from: u64, to: u64, port: usize) -> bool

Connect (replacing whatever fed that port). Refused when it would create a cycle.

pub fn disconnect(&mut self, to: u64, port: usize)

pub fn remove_node(&mut self, id: u64)

Remove a node (the Output can never be removed) and re-link its first input to its consumers.

pub fn has_cycle(&self) -> bool

Depth-first cycle check (the editor refuses connections that would loop).

pub fn eval_order(&self) -> Vec<u64>

Nodes reachable from the output, inputs before consumers.

pub fn eval_values(&self, lt: f64, fps: f64) -> HashMap<u64, f64>

The scalar half of the graph at clip-local time lt: one number per node, in evaluation order, so a Math/Compare/Select chain resolves in a single pass. Picture-only nodes evaluate to 0. GL-free on purpose — the renderer calls it once per frame and it is what the tests exercise.

pub fn animated_mut(&mut self) -> Vec<&mut Animated>

Every animated property in the graph (effect params, blend opacity, numbers, mask properties).

pub fn animated(&self) -> Vec<&Animated>

Trait Implementations

impl Clone for NodeGraph

fn clone(&self) -> NodeGraph

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NodeGraph

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

Formats the value using the given formatter.

impl Default for NodeGraph

fn default() -> NodeGraph

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NodeGraph

where NodeGraph: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NodeGraph

fn eq(&self, other: &NodeGraph) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for NodeGraph

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for NodeGraph