Enum MotionExpr 

pub enum MotionExpr {
    Value(MotionValue),
    IntrinsicWidth,
    IntrinsicHeight,
    LayoutX(WidgetId),
    LayoutY(WidgetId),
    LayoutWidth(WidgetId),
    LayoutHeight(WidgetId),
    PointerLocalX,
    PointerLocalY,
    If {
        predicate: MotionPredicate,
        then_expr: Box<MotionExpr>,
        else_expr: Box<MotionExpr>,
    },
    Add(Box<MotionExpr>, Box<MotionExpr>),
    Sub(Box<MotionExpr>, Box<MotionExpr>),
    Mul(Box<MotionExpr>, Box<MotionExpr>),
    Div(Box<MotionExpr>, Box<MotionExpr>),
    Neg(Box<MotionExpr>),
    Abs(Box<MotionExpr>),
    Min(Box<MotionExpr>, Box<MotionExpr>),
    Max(Box<MotionExpr>, Box<MotionExpr>),
    Clamp {
        value: Box<MotionExpr>,
        min: Box<MotionExpr>,
        max: Box<MotionExpr>,
    },
    Lerp {
        from: Box<MotionExpr>,
        to: Box<MotionExpr>,
        t: Box<MotionExpr>,
    },
    MapRange {
        value: Box<MotionExpr>,
        from_start: f32,
        from_end: f32,
        to_start: f32,
        to_end: f32,
        clamp: bool,
    },
}

Declarative expression evaluated by the motion runtime.

Expressions are the closed IR for motion targets. They can reference layout snapshots, pointer position, interaction predicates, and numeric operators without requiring arbitrary per-frame callbacks.

use fission::motion::{
    scalar, MotionExpr, MotionPredicate, MotionPropertyId, MotionStartValue, MotionTrack,
};
use fission::WidgetId;

let button_id = WidgetId::explicit("save_button");
let scale = MotionTrack::composite(
    MotionPropertyId::Scale,
    MotionStartValue::Current,
    MotionExpr::If {
        predicate: MotionPredicate::Pressed(button_id),
        then_expr: Box::new(scalar(0.96)),
        else_expr: Box::new(scalar(1.0)),
    },
);

Variants

Value(MotionValue)

Literal typed value.

IntrinsicWidth

Current widget intrinsic width.

IntrinsicHeight

Current widget intrinsic height.

LayoutX(WidgetId)

X position of another widget from the latest layout snapshot.

LayoutY(WidgetId)

Y position of another widget from the latest layout snapshot.

LayoutWidth(WidgetId)

Width of another widget from the latest layout snapshot.

LayoutHeight(WidgetId)

Height of another widget from the latest layout snapshot.

PointerLocalX

Pointer x-position local to the tracked widget.

PointerLocalY

Pointer y-position local to the tracked widget.

If

Conditional expression selected by a runtime predicate.

Fields

predicate: MotionPredicate

Runtime predicate to test.

then_expr: Box<MotionExpr>

Expression evaluated when the predicate is true.

else_expr: Box<MotionExpr>

Expression evaluated when the predicate is false.

Add(Box<MotionExpr>, Box<MotionExpr>)

Numeric addition.

Sub(Box<MotionExpr>, Box<MotionExpr>)

Numeric subtraction.

Mul(Box<MotionExpr>, Box<MotionExpr>)

Numeric multiplication.

Div(Box<MotionExpr>, Box<MotionExpr>)

Numeric division. Division by zero leaves the left value unchanged.

Neg(Box<MotionExpr>)

Numeric negation.

Abs(Box<MotionExpr>)

Absolute value.

Min(Box<MotionExpr>, Box<MotionExpr>)

Minimum of two scalar-like expressions.

Max(Box<MotionExpr>, Box<MotionExpr>)

Maximum of two scalar-like expressions.

Clamp

Clamps a scalar-like expression between min and max.

Fields

value: Box<MotionExpr>

Value to clamp.

min: Box<MotionExpr>

Minimum allowed value.

max: Box<MotionExpr>

Maximum allowed value.

Lerp

Interpolates between two values using scalar-like t.

Fields

from: Box<MotionExpr>

Start expression.

to: Box<MotionExpr>

End expression.

t: Box<MotionExpr>

Interpolation progress, normally 0.0..=1.0.

MapRange

Maps a scalar-like expression from one range to another.

Fields

value: Box<MotionExpr>

Source expression.

from_start: f32

Lower bound of the input range.

from_end: f32

Upper bound of the input range.

to_start: f32

Lower bound of the output range.

to_end: f32

Upper bound of the output range.

clamp: bool

Whether to clamp the mapped progress to 0.0..=1.0.

Implementations

impl MotionExpr

pub fn eval(&self, input: &MotionEvalInput<'_>) -> MotionValue

Evaluates the expression against runtime and layout inputs.

Application code usually does not call this directly; shells and tests use it to turn declarative targets into concrete MotionValues.

Trait Implementations

impl Clone for MotionExpr

fn clone(&self) -> MotionExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MotionExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MotionExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<MotionValue> for MotionExpr

fn from(value: MotionValue) -> Self

Converts to this type from the input type.

impl PartialEq for MotionExpr

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

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 MotionExpr