Enum NodeKind

pub enum NodeKind {
    Input,
    Color([u8; 4]),
    Clip(u64),
    Asset(u64),
    Effect(Effect),
    Blend {
        mode: BlendMode,
        opacity: Animated,
    },
    Combine {
        mode: BlendMode,
        factor: Animated,
    },
    Merge,
    Matte {
        invert: bool,
        use_alpha: bool,
    },
    Mask(Mask),
    String(TextStyle),
    Number(Animated),
    Bool(bool),
    Random {
        seed: u32,
        min: f64,
        max: f64,
    },
    Math(MathOp),
    Compare(CmpOp),
    Logic(LogicOp),
    Select,
    Output,
}

What a node does. Input is the clip’s own decoded layer; Output is what the compositor draws.

Two kinds of wire run through a graph: pictures (one texture per node, evaluated on the GPU) and values (one number per node, NodeGraph::eval_values). Value ports on a picture node — an effect’s parameter ports, a blend’s amount — are what let the logic nodes drive the image.

Variants

Input

The clip’s decoded layer (or, in an adjustment clip, everything below it).

Color([u8; 4])

A solid colour (RGBA) filling the canvas.

Clip(u64)

Another clip’s layer at the same time (compositing across tracks).

Asset(u64)

A project asset sampled as a texture — footage that need not be on the timeline at all.

Effect(Effect)

Blend

Combines two inputs (a under b) with a blend mode and opacity.

Fields

mode: BlendMode

opacity: Animated

Combine

Same two inputs, mixed in by factor (0..1) — “how much of b”, not its opacity.

Fields

mode: BlendMode

factor: Animated

Merge

b composited straight over a (alpha over, no knobs).

Matte

Uses b’s luminance (or alpha) as a matte for a.

Fields

invert: bool

use_alpha: bool

Mask(Mask)

A standalone mask (matte generator).

String(TextStyle)

A string rasterised into the graph. {frame}, {time} and {n} expand at evaluation time, which is all a frame counter or a running clock needs (see expand_text). Called Text in projects written before it was renamed — the alias keeps those loading.

Number(Animated)

A keyframeable constant: the plain number input, and a grey card at its value as a picture.

Bool(bool)

A constant flag — 1.0 or 0.0 downstream.

Random

Deterministic noise in min..max, hashed from (seed, frame): the same project always renders the same numbers, and every frame gets a different one. A constant is a Number.

Fields

seed: u32

min: f64

max: f64

Math(MathOp)

Arithmetic on two value inputs.

Compare(CmpOp)

Compares two value inputs: 1.0 when it holds, 0.0 when it does not.

Logic(LogicOp)

Boolean logic on two value inputs (Not reads only a); anything >= 0.5 counts as true.

Select

cond ? a : b — the switch. Works on values and on pictures.

Output

Implementations

impl NodeKind

pub fn inputs(&self) -> usize

How many inputs the node consumes. An effect takes its picture on port 0 and one optional value per parameter after it, so any number in the graph can drive any knob.

pub fn port_label(&self, i: usize) -> &str

What port i takes, for the node box and the tooltips. Empty when it has no name.

pub fn is_value(&self) -> bool

Nodes whose output is a number rather than a picture (they still paint as a grey card, so a value can be used as a matte without a conversion node).

pub fn title(&self) -> String

Trait Implementations

impl Clone for NodeKind

fn clone(&self) -> NodeKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NodeKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodeKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NodeKind

fn eq(&self, other: &NodeKind) -> 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 NodeKind

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 NodeKind