Struct Transition

pub struct Transition {
    pub id: u64,
    pub right: u64,
    pub kind: TransitionKind,
    pub duration: f64,
    pub color: [u8; 4],
    pub direction: u8,
    pub ease: Ease,
    pub edge: TransitionEdge,
}

A transition on a cut or a clip edge. For Cut it is centred on the cut between right and its left neighbour, spanning [right.start - duration/2, right.start + duration/2); both clips are extended virtually into that window (the engine clamps source times). For In / Out, right is the single clip it belongs to and the window is its first/last duration seconds. Audio tracks use CrossFade (a gain crossfade / fade).

Fields

id: u64

right: u64

The clip on the right side of the cut (Cut), or the clip the edge transition belongs to.

kind: TransitionKind

duration: f64

color: [u8; 4]

direction: u8

0 = left, 1 = right, 2 = up, 3 = down (Push / Wipe).

ease: Ease

edge: TransitionEdge

Implementations

impl Transition

pub fn half(&self, left: &Clip, right: &Clip) -> f64

Half the transition length, clamped to the clips it joins: an over-long transition must not reach past either neighbour (it would hide the clips beside them).

pub fn progress_at(&self, cut: f64, half: f64, t: f64) -> f64

Eased progress 0..1 across a window of cut ± half.

pub fn cut_half( &self, left: Option<&Clip>, right: Option<&Clip>, ) -> Option<(f64, f64)>

(centre, half-width) of the clamped window for any placement; the window is centre ± half. Cut needs both clips; In / Out need only their own (the window stays inside the clip).

Trait Implementations

impl Clone for Transition

fn clone(&self) -> Transition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Transition

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

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 Transition