Enum Event 

pub enum Event {
    Ready {
        protocol_version: u32,
        engine_version: String,
        fps: u32,
        size: [u32; 2],
        scenes: Vec<SceneInfo>,
    },
    Reloaded,
    Building,
    Error {
        kind: ErrorKind,
        message: String,
        spans: Vec<Span>,
    },
    Frame {
        index: u32,
    },
    Timeline {
        frames: u32,
        markers: Vec<MarkerInfo>,
        scenes: Vec<SceneInfo>,
        audio_waveform: Option<Vec<f32>>,
    },
    Tree {
        nodes: Vec<NodeInfo>,
    },
    Signals {
        node_id: u32,
        values: Vec<SignalValue>,
        bounds: Option<[f64; 8]>,
    },
    Selected {
        node_id: Option<u32>,
    },
    Playback {
        playing: bool,
        frame: u32,
    },
    MetaChanged {
        scene: String,
        meta: Meta,
    },
}

Engine → UI.

Variants

Ready

Answer to Hello: the engine and the project.

Fields

protocol_version: u32

PROTOCOL_VERSION of the engine.

engine_version: String

Version of the oxframe crate.

fps: u32

Frames per second.

size: [u32; 2]

Project size in pixels, [width, height].

scenes: Vec<SceneInfo>

Scenes in order.

Reloaded

A new build is running (sent after a hot reload).

Building

The CLI started rebuilding the project.

Error

Something failed; the last good state stays visible.

Fields

kind: ErrorKind

What failed.

message: String

Human-readable message.

spans: Vec<Span>

Source locations, for compile errors.

Frame

Followed by a binary frame (see FrameHeader).

Fields

index: u32

Global frame index.

Timeline

Timeline layout; sent on start and when it changes.

Fields

frames: u32

Total number of frames.

markers: Vec<MarkerInfo>

All markers of all scenes.

scenes: Vec<SceneInfo>

Scenes in order.

audio_waveform: Option<Vec<f32>>

Peak amplitudes of the soundtrack in 0..=1, one per frame (at most 4096).

Tree

The node tree of the current frame’s scene.

Fields

nodes: Vec<NodeInfo>

Nodes in tree order (parents before children).

Signals

Current values of the selected node; sent after each frame while something is selected.

Fields

node_id: u32

The selected node.

values: Vec<SignalValue>

One entry per property.

bounds: Option<[f64; 8]>

Selection box as four corners [x0, y0, x1, y1, x2, y2, x3, y3] in frame pixels (rotated nodes give a rotated box).

Selected

Selection changed (answer to Pick and Select).

Fields

node_id: Option<u32>

Selected node, if any.

Playback

Playback state changed (also sent while playing).

Fields

playing: bool

Whether playback is running.

frame: u32

Current global frame.

MetaChanged

A scene’s meta changed and was saved.

Fields

scene: String

Scene name.

meta: Meta

New contents.

Trait Implementations

impl Clone for Event

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Event

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Event

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 Event