Crate oxframe_core 

Core of oxframe: signals, tweens, easing and a deterministic, single-threaded coroutine executor.

Status: oxframe is under very active development. The API is not stable yet and may change from version to version. Pin the exact version in your Cargo.toml and check the changelog before upgrading.

An animation is an async fn; every .await on a Tween, wait_for or next_frame is a frame boundary. One poll of the root future is exactly one frame, with a fixed dt = 1 / fps.

Re-exports

pub use rand;

pub use self;

Modules

presets

Named Bézier presets (values follow easings.net / CSS).

Structs

Affine

A 2D affine transform.

All

Future returned by all.

BezPath

A Bézier path.

Color

sRGB color with straight (non-premultiplied) alpha, components in 0..=1.

CubicBezier

CSS-style cubic Bézier easing with control points (x1, y1), (x2, y2); the end points are fixed at (0, 0) and (1, 1).

Executor

Deterministic single-threaded executor: one step is one frame. The root future and every spawned task are polled once per step, in a fixed order (root, then tasks in spawn order). No wakers, no clocks, no threads — the same input always produces the same frames.

Gradient

A gradient in the node’s local coordinates (origin at the node center).

Image

8-bit sRGB RGBA, straight alpha, row-major, no padding.

JoinHandle

Awaiting it waits for the spawned task to finish.

Point

A 2D point.

Signal

A reactive value.

Transform

Decomposed 2D transform. Interpolates component-wise, so rotations turn instead of shearing through the matrix midpoint.

Tween

Animates a Signal towards a target. Created by Signal::to.

Vec2

A 2D vector.

Enums

BlendMode

How a node’s layer is composited onto what is below it.

GradientKind

Shape of a Gradient.

Constants

TIME_EPSILON

Times are compared with this tolerance so that sums of f64 seconds (0.1 + 0.2) land on the frame they were meant for.

Traits

Ease

Maps linear progress t ∈ [0, 1] to eased progress.

FrameSource

A timeline that can draw any of its frames: “give me frame n”.

Lerp

Linear interpolation; t is already eased and may leave [0, 1] (e.g. with back easings).

Functions

all

Runs futures concurrently and completes when all of them have. Takes a tuple of up to 12 futures and returns a tuple of their outputs.

all_vec

all for a dynamic number of futures.

bounce_in

Bounces before leaving.

bounce_in_out

Bounces at both ends.

bounce_out

Bounces into place, like a dropped ball.

dt

Duration of one frame in seconds, 1 / fps.

ease_named

Named easing from meta.json; default is recorded there on first use. Use through the ease! macro.

elastic_in

Oscillates before leaving, like a spring being wound.

elastic_in_out

Spring at both ends.

elastic_out

Overshoots and oscillates into place, like a spring.

fps

Frames per second of the running project.

frame

Index of the frame being computed.

meta_snapshot

Copy of the running scene’s markers, eases and tunables.

next_frame

Yields until the next frame.

now

Time of the current frame, frame / fps seconds.

random

Uniform random number in [0, 1) from the scene’s seeded generator.

random_range

Uniform random number in [min, max) from the scene’s seeded generator.

sequence

Starts the futures one after another with delay seconds between their starts; they then run concurrently. Completes when all have.

spawn

Runs fut in the background, starting this frame. Background tasks stop when the scene ends.

time

Virtual time of the current task — where the next animation starts.

tunable

Value of tunable name from meta.json; default is recorded there on first use. Use through the tune! macro.

wait_for

Waits seconds of scene time.

wait_until

Waits until marker name from meta.json. On first encounter the current time becomes the marker’s default, so it does not wait at all.

with_rng

Runs f with the scene’s random generator. It is seeded from the project seed and the scene name, so results are reproducible; never use rand::rng() or other entropy sources in scenes.

Type Aliases

BoxFuture

A boxed scene future, e.g. for sequence.