🥮 mooncakes.io

    moonbit-easings

    A dependency-free MoonBit motion toolkit for media timelines, easing curves, cubic Bezier inversion, and scalar keyframes.

    animation
    easing
    tween
    bezier
    keyframe
    media
    Download zip
    Author
    Version
    0.1.1
    License
    MIT
    Repository
    Last updated
    2 months ago
    Downloads
    40

    No dependencies

    #moonbit-easings

    MoonBit 数字媒体补间动画与贝塞尔缓动函数库：为 UI 交互、游戏镜头、数字艺术和离线媒体提供可组合、无运行时依赖的运动学基础设施。

    #项目定位

    moonbit-easings 负责“时间、数值和运动轨迹如何变化”，不负责窗口渲染、资源解析或具体 UI 框架。它可以作为渲染器、游戏循环、音视频导出器和交互式编辑器的底层采样层，输出标量、向量、颜色、变换、路径和事件数据。

    项目把 easing、Cubic-Bezier 时间轴求逆、Tween、关键帧轨道、时间线、路径和传输控制放在统一的数据模型中，同时保持核心包不依赖平台 I/O，适合 Wasm、Wasm-GC、JavaScript 和 Native 目标。

    #核心能力

    • 31 个内建 easing：Linear、Quad、Cubic、Quart、Quint、Sine、Expo、Circ、Back、Elastic、Bounce。
    • Bezier::new(x1, y1, x2, y2)：缓存采样表、Newton 迭代和二分回退组成稳定的时间轴求逆器。
    • Tween 与 ScalarTrack：支持 delay、repeat、Mirror、Continue、逐段曲线、速度和加速度。
    • 多媒体类型：Point2、Point3、RGBA、Transform2D、颜色渐变、Hermite 和 Catmull-Rom。
    • 轨迹编排：命名标记、MarkerCursor、ScalarTrackBundle、MotionStateMachine、MotionClip 和 ClipSequence。
    • 几何与时间：Spline2D/Spline3D、复合 Path2D、距离采样、投影、边界框和 Piecewise RetimeMap。
    • 离线分析：固定帧率与自适应采样、信号滤波、峰值、积分、单调性、曲线报告和可复现实验入口。

    与只提供基础 easing 函数的包相比，本项目的重点是可直接接入数字媒体工作流的轨道、时间、路径和导出层；它不复制其他生态包的实现，也不绑定 Lottie、Canvas 或某个游戏引擎。

    #快速开始

    要求 MoonBit stable 0.10.9 或更新版本。

    moon add Zlj6566/moonbit-easings

    在 moon.pkg 中导入：

    ///|
    import {
      "Zlj6566/moonbit-easings" @easings,
    }

    最小 Tween 示例：

    let curve = try! @easings.Bezier::new(0.25, 0.1, 0.25, 1.0)
    let tween = try! @easings.Tween::new(
      0.0,
      320.0,
      1.0,
      curve=@easings.Curve::bezier(curve),
    )
    let sample = tween.sample_motion(0.5)
    println(sample.value().to_string())
    println(sample.velocity().to_string())

    #CLI

    仓库提供两个可运行入口：

    # 展示 Tween、关键帧、颜色渐变和序列组合
moon run cmd/demo

# 运行可复现的 Native 工作负载并打印校验和
moon run --target native --release cmd/bench

    cmd/bench 不把主机时钟写入库 API；它打印固定迭代次数、采样校验和和自适应采样结果，主机耗时由 BENCHMARKS.md 中的测量命令取得。

    #架构

    Easing / Bezier
      │
      ├── Tween / Keyframe / ScalarTrack
      │          │
      │          ├── Timeline / Bundle / StateMachine
      │          └── Clip / Sequence / Transport / Markers
      │
      ├── Point / Color / Transform Tracks
      ├── Spline / Path / RetimeMap
      └── Sampling / Signal / Diagnostics

    主要模块按职责拆分：easing_*.mbt 与 bezier*.mbt 提供曲线内核；keyframe_*.mbt、tween.mbt 和 timeline.mbt 提供时间数据模型；typed_tracks.mbt、path.mbt、spline.mbt 和 path_geometry.mbt 提供数字媒体值与几何；adaptive_sampling.mbt、signal_processing.mbt 和 curve_analysis.mbt 面向离线导出与质量检查；motion_clip.mbt、motion_transport.mbt、motion_markers.mbt 和 motion_state_machine.mbt 面向运行时编排。

    核心采样函数只在调用者明确请求批量结果时分配输出数组；Bezier 单点采样使用缓存表、Newton 迭代和二分回退，不创建临时采样数组。

    #基准

    基准说明、工具链版本、机器环境、完整输出和重复测量方式见 BENCHMARKS.md。本地执行：

    moon build --target native --release cmd/bench
moon run --target native --release cmd/bench

    校验和用于确认不同构建目标实际执行了同一工作负载；墙钟数据不被当作跨机器的绝对性能承诺。

    #测试

    提交前执行完整检查：

    moon fmt --check
moon info --target all
git diff --exit-code
moon check --fmt --deny-warn --target all
moon build --target all
moon test --deny-warn --target all

    测试覆盖 easing 边界、Bezier 参数求逆、重复和镜像时间、关键帧排序、向量/颜色/变换插值、路径端点、空输入、非法参数、标记方向、轨迹投影、自适应采样、重映射、信号边界和 Native/JS/Wasm 全目标行为。

    #CI

    .github/workflows/test.yml 在 Ubuntu、macOS 和 Windows 上安装官方 MoonBit stable 工具链，执行格式化、moon info 生成物差异检查、全目标检查、全目标构建和全目标测试，并开启 --deny-warn。

    .github/workflows/publish.yml 只在手动触发时验证同一检查链，并使用仓库 Secret 中的 MOONCAKES_TOKEN 发布包；日常 CI 不执行发布。基准程序不进入普通测试矩阵，可按文档在 Native Release 模式单独运行。

    #许可证

    本项目采用 MIT License，见 LICENSE。实现来源和第三方生态边界见 SOURCES.md。

    MotionError

    source
    pub(all) suberror MotionError {
      InvalidBezierX(Double, Double)
      InvalidSampleCount(Int)
      InvalidTime(Double)
      InvalidDuration(Double)
      InvalidDelay(Double)
      InvalidRepeatCount(Int)
      EmptyTrack
      NonIncreasingKeyframe(Double, Double)
      InvalidFrameRate(Double)
      InvalidPointCount(Int)
      InvalidTension(Double)
      InvalidSegmentCount(Int)
      InvalidThreshold(Double)
      InvalidMarkerName
      InvalidChannelName
      InvalidRetimeSegment
      InvalidStateName
    }

    Errors raised while constructing or validating motion primitives.

    AdaptiveSamplePoint

    source
    pub(all) struct AdaptiveSamplePoint {
      time : Double
      value : Double
      depth : Int
    } derive(
    Debug    )

    A scalar sample with a subdivision depth for diagnostics and renderers.

    AdaptiveSamplePoint::depth

    source
    fn AdaptiveSamplePoint::depth(self : AdaptiveSamplePoint) -> Int

    AdaptiveSamplePoint::time

    source
    fn AdaptiveSamplePoint::time(self : AdaptiveSamplePoint) -> Double

    AdaptiveSamplePoint::value

    source
    fn AdaptiveSamplePoint::value(self : AdaptiveSamplePoint) -> Double

    AdaptiveSampleResult

    source
    pub(all) struct AdaptiveSampleResult {
      points : Array[AdaptiveSamplePoint]
      accepted_segments : Int
      rejected_segments : Int
      maximum_error : Double
    } derive(
    Debug    )

    Result metadata for an adaptive sample pass.

    AdaptiveSampleResult::accepted_segments

    source
    fn AdaptiveSampleResult::accepted_segments(self : AdaptiveSampleResult) -> Int

    AdaptiveSampleResult::maximum_error

    source
    fn AdaptiveSampleResult::maximum_error(self : AdaptiveSampleResult) -> Double

    AdaptiveSampleResult::points

    source

    AdaptiveSampleResult::rejected_segments

    source
    fn AdaptiveSampleResult::rejected_segments(self : AdaptiveSampleResult) -> Int

    AdaptiveSamplingConfig

    source
    pub struct AdaptiveSamplingConfig {
      tolerance : Double
      max_depth : Int
      max_samples : Int
    } derive(
    Debug    )

    Controls recursive subdivision of a scalar motion signal.

    AdaptiveSamplingConfig::max_depth

    source
    fn AdaptiveSamplingConfig::max_depth(self : AdaptiveSamplingConfig) -> Int

    AdaptiveSamplingConfig::max_samples

    source
    fn AdaptiveSamplingConfig::max_samples(self : AdaptiveSamplingConfig) -> Int

    AdaptiveSamplingConfig::new

    source
    fn AdaptiveSamplingConfig::new(tolerance : Double, max_depth? : Int, max_samples? : Int) -> AdaptiveSamplingConfig raise MotionError

    AdaptiveSamplingConfig::tolerance

    source
    fn AdaptiveSamplingConfig::tolerance(self : AdaptiveSamplingConfig) -> Double

    Affine2D

    source
    pub struct Affine2D {
      a : Double
      b : Double
      c : Double
      d : Double
      tx : Double
      ty : Double
    } derive(
    Debug    )

    Compact 2D affine matrix used when many sprites share one transform hierarchy. The six values follow the conventional column-vector form.

    Affine2D::a

    source
    fn Affine2D::a(self : Affine2D) -> Double

    Affine2D::apply

    source
    fn Affine2D::apply(self : Affine2D, point : Point2) -> Point2

    Affine2D::b

    source
    fn Affine2D::b(self : Affine2D) -> Double

    Affine2D::c

    source
    fn Affine2D::c(self : Affine2D) -> Double

    Affine2D::d

    source
    fn Affine2D::d(self : Affine2D) -> Double

    Affine2D::decompose

    source
    fn Affine2D::decompose(self : Affine2D) -> AffineDecomposition2D

    Affine2D::determinant

    source
    fn Affine2D::determinant(self : Affine2D) -> Double

    Affine2D::inverse

    source
    fn Affine2D::inverse(self : Affine2D) -> Affine2D

    Affine2D::lerp

    source
    fn Affine2D::lerp(self : Affine2D, other : Affine2D, ratio : Double) -> Affine2D

    Affine2D::multiply

    source
    fn Affine2D::multiply(self : Affine2D, other : Affine2D) -> Affine2D

    Affine2D::translation

    source
    fn Affine2D::translation(self : Affine2D) -> Point2

    AffineDecomposition2D

    source
    pub struct AffineDecomposition2D {
      position : Point2
      scale : Point2
      rotation : Double
      skew : Double
      determinant : Double
    } derive(
    Debug    )

    AffineDecomposition2D::determinant

    source
    fn AffineDecomposition2D::determinant(self : AffineDecomposition2D) -> Double

    AffineDecomposition2D::position

    source

    AffineDecomposition2D::rotation

    source
    fn AffineDecomposition2D::rotation(self : AffineDecomposition2D) -> Double

    AffineDecomposition2D::scale

    source

    AffineDecomposition2D::skew

    source
    fn AffineDecomposition2D::skew(self : AffineDecomposition2D) -> Double

    BeatCue

    source
    pub struct BeatCue {
      beat : Double
      label : String
      duration : Double
      strength : Double
    } derive(
    Debug    )

    BeatCue::beat

    source
    fn BeatCue::beat(self : BeatCue) -> Double

    BeatCue::duration

    source
    fn BeatCue::duration(self : BeatCue) -> Double

    BeatCue::label

    source
    fn BeatCue::label(self : BeatCue) -> String

    BeatCue::seconds

    source
    fn BeatCue::seconds(self : BeatCue, tempo : TempoTimeline) -> Double

    BeatCue::strength

    source
    fn BeatCue::strength(self : BeatCue) -> Double

    BeatGrid

    source
    pub struct BeatGrid {
      tempo : TempoTimeline
      signature : TimeSignature2
      groove : GroovePattern
    } derive(
    Debug    )

    BeatGrid::bar_index

    source
    fn BeatGrid::bar_index(self : BeatGrid, beat : Double) -> Int

    BeatGrid::bar_start

    source
    fn BeatGrid::bar_start(self : BeatGrid, bar : Int) -> Double

    BeatGrid::beat_to_seconds

    source
    fn BeatGrid::beat_to_seconds(self : BeatGrid, beat : Double) -> Double

    BeatGrid::groove

    source
    fn BeatGrid::groove(self : BeatGrid) -> GroovePattern

    BeatGrid::quantize

    source
    fn BeatGrid::quantize(self : BeatGrid, beat : Double, subdivision : Int) -> Double

    BeatGrid::seconds_to_beat

    source
    fn BeatGrid::seconds_to_beat(self : BeatGrid, seconds : Double) -> Double

    BeatGrid::signature

    source
    fn BeatGrid::signature(self : BeatGrid) -> TimeSignature2

    BeatGrid::tempo

    source
    fn BeatGrid::tempo(self : BeatGrid) -> TempoTimeline

    BeatGrid::with_groove

    source
    fn BeatGrid::with_groove(self : BeatGrid, groove : GroovePattern) -> BeatGrid

    Bezier

    source
    pub struct Bezier {
      x1 : Double
      y1 : Double
      x2 : Double
      y2 : Double
      sample_values : Array[Double]
    } derive(
    Debug    )

    A cached cubic Bézier timing curve.

    The x controls must lie in [0, 1], while y controls may overshoot for spring-like or expressive motion. Construction builds a small lookup table; evaluation only reads the table and performs scalar arithmetic.

    Bezier::approximate_length

    source
    fn Bezier::approximate_length(self : Bezier, segments : Int) -> Double

    A coarse arc-length estimate in parameter space, useful for diagnostics.

    Bezier::as_easing

    source
    fn Bezier::as_easing(self : Bezier) -> ((Double) -> Double)

    Return the curve as a first-class easing function.

    Bezier::control_points

    source
    fn Bezier::control_points(self : Bezier) -> (Double, Double, Double, Double)

    Bezier::derivative

    source
    fn Bezier::derivative(self : Bezier, x : Double) -> Double

    Derivative dy/dx at a normalized time. A zero x slope returns zero.

    Bezier::max_error

    source
    fn Bezier::max_error(self : Bezier, reference : (Double) -> Double, samples : Int) -> Double

    Return the maximum absolute difference between this curve and a reference.

    Bezier::new

    source
    fn Bezier::new(x1 : Double, y1 : Double, x2 : Double, y2 : Double, sample_count? : Int) -> Bezier raise MotionError

    Construct a cubic timing curve with a cached lookup table.

    Bezier::reversed

    source
    fn Bezier::reversed(self : Bezier) -> Bezier

    Reverse the direction of a cubic timing curve.

    Bezier::sample

    source
    fn Bezier::sample(self : Bezier, x : Double) -> Double

    Evaluate the y coordinate at normalized time x.

    Bezier::sample_many

    source
    fn Bezier::sample_many(self : Bezier, count : Int) -> Array[Double] raise MotionError

    Bezier::solve_time

    source
    fn Bezier::solve_time(self : Bezier, x : Double) -> Double

    Solve the time parameter t for a normalized x coordinate.

    BlendMask2D

    source
    pub struct BlendMask2D {
      values : Array[Double]
      default_weight : Double
    } derive(
    Debug    )

    BlendMask2D::feather

    source
    fn BlendMask2D::feather(self : BlendMask2D, radius : Int) -> BlendMask2D

    BlendMask2D::length

    source
    fn BlendMask2D::length(self : BlendMask2D) -> Int

    BlendMask2D::multiply

    source
    fn BlendMask2D::multiply(self : BlendMask2D, other : BlendMask2D) -> BlendMask2D

    BlendMask2D::sample

    source
    fn BlendMask2D::sample(self : BlendMask2D, index : Int) -> Double

    BlendMode

    source
    pub enum BlendMode {
      Normal
      Multiply
      Screen
      Overlay
      Additive
      Subtract
      Darken
      Lighten
      Difference
      ColorDodge
      ColorBurn
    } derive(
    Debug    )

    Porter-Duff and artistic blend modes for compositing animated media.

    Bounds2D

    source
    pub(all) struct Bounds2D {
      minimum : Point2
      maximum : Point2
    } derive(
    Debug    )

    Axis-aligned bounds for a sampled media path.

    Bounds2D::maximum

    source
    fn Bounds2D::maximum(self : Bounds2D) -> Point2

    Bounds2D::minimum

    source
    fn Bounds2D::minimum(self : Bounds2D) -> Point2

    Bounds3D

    source
    pub struct Bounds3D {
      minimum : Point3
      maximum : Point3
    } derive(
    Debug    )

    Bounds3D::center

    source
    fn Bounds3D::center(self : Bounds3D) -> Point3

    Bounds3D::contains

    source
    fn Bounds3D::contains(self : Bounds3D, value : Point3) -> Bool

    Bounds3D::expanded

    source
    fn Bounds3D::expanded(self : Bounds3D, amount : Double) -> Bounds3D

    Bounds3D::maximum

    source
    fn Bounds3D::maximum(self : Bounds3D) -> Point3

    Bounds3D::minimum

    source
    fn Bounds3D::minimum(self : Bounds3D) -> Point3

    Bounds3D::size

    source
    fn Bounds3D::size(self : Bounds3D) -> Point3

    Bounds3D::union

    source
    fn Bounds3D::union(self : Bounds3D, other : Bounds3D) -> Bounds3D

    BundleSample

    source
    pub(all) struct BundleSample {
      time : Double
      names : Array[String]
      values : Array[Double]
      weighted_value : Double
      active_weight : Double
    } derive(
    Debug    )

    The combined result at one timestamp. weighted_value is the normalized blend of enabled channels; individual values remain available for output.

    BundleSample::active_weight

    source
    fn BundleSample::active_weight(self : BundleSample) -> Double

    BundleSample::length

    source
    fn BundleSample::length(self : BundleSample) -> Int

    BundleSample::names

    source
    fn BundleSample::names(self : BundleSample) -> Array[String]

    BundleSample::time

    source
    fn BundleSample::time(self : BundleSample) -> Double

    BundleSample::value_at

    source
    fn BundleSample::value_at(self : BundleSample, index : Int) -> Double?

    BundleSample::value_named

    source
    fn BundleSample::value_named(self : BundleSample, name : String) -> Double?

    BundleSample::values

    source
    fn BundleSample::values(self : BundleSample) -> Array[Double]

    BundleSample::weighted_value

    source
    fn BundleSample::weighted_value(self : BundleSample) -> Double

    CachePool2

    source
    pub struct CachePool2 {
      scalar : Array[ScalarSampleCache2]
      point : Array[PointSampleCache2]
      color : Array[ColorSampleCache2]
      capacity : Int
    } derive(
    Debug    )

    CachePool2::capacity

    source
    fn CachePool2::capacity(self : CachePool2) -> Int

    CachePool2::clear

    source
    fn CachePool2::clear(self : CachePool2) -> Unit

    CachePool2::color_count

    source
    fn CachePool2::color_count(self : CachePool2) -> Int

    CachePool2::find_color

    source
    fn CachePool2::find_color(self : CachePool2, key : SampleCacheKey2) -> ColorSampleCache2?

    CachePool2::find_point

    source
    fn CachePool2::find_point(self : CachePool2, key : SampleCacheKey2) -> PointSampleCache2?

    CachePool2::find_scalar

    source
    fn CachePool2::find_scalar(self : CachePool2, key : SampleCacheKey2) -> ScalarSampleCache2?

    CachePool2::point_count

    source
    fn CachePool2::point_count(self : CachePool2) -> Int

    CachePool2::put_color

    source
    fn CachePool2::put_color(self : CachePool2, cache : ColorSampleCache2) -> Unit

    CachePool2::put_point

    source
    fn CachePool2::put_point(self : CachePool2, cache : PointSampleCache2) -> Unit

    CachePool2::put_scalar

    source
    fn CachePool2::put_scalar(self : CachePool2, cache : ScalarSampleCache2) -> Unit

    CachePool2::scalar_count

    source
    fn CachePool2::scalar_count(self : CachePool2) -> Int

    CameraFraming2

    source
    pub struct CameraFraming2 {
      center : Point3
      radius : Double
      policy : FramingPolicy2
      margin : Double
    } derive(
    Debug    )

    CameraFraming2::center

    source
    fn CameraFraming2::center(self : CameraFraming2) -> Point3

    CameraFraming2::effective_radius

    source
    fn CameraFraming2::effective_radius(self : CameraFraming2) -> Double

    CameraFraming2::margin

    source
    fn CameraFraming2::margin(self : CameraFraming2) -> Double

    CameraFraming2::policy

    source

    CameraFraming2::radius

    source
    fn CameraFraming2::radius(self : CameraFraming2) -> Double

    CameraKeyframe

    source
    pub struct CameraKeyframe {
      time : Double
      pose : CameraPose
      lens : CameraLens
      curve : Curve
    } derive(
    Debug    )

    A camera keyframe carries pose and lens changes as one editorial unit.

    CameraKeyframe::curve

    source
    fn CameraKeyframe::curve(self : CameraKeyframe) -> Curve

    CameraKeyframe::lens

    source

    CameraKeyframe::pose

    source

    CameraKeyframe::time

    source
    fn CameraKeyframe::time(self : CameraKeyframe) -> Double

    CameraLens

    source
    pub struct CameraLens {
      model : ProjectionModel
      field_of_view : Double
      orthographic_height : Double
      near_plane : Double
      far_plane : Double
      aperture : Double
      focus_distance : Double
    } derive(
    Debug    )

    Lens parameters shared by 2D and 3D camera tracks.

    CameraLens::aperture

    source
    fn CameraLens::aperture(self : CameraLens) -> Double

    CameraLens::far_plane

    source
    fn CameraLens::far_plane(self : CameraLens) -> Double

    CameraLens::field_of_view

    source
    fn CameraLens::field_of_view(self : CameraLens) -> Double

    CameraLens::focus_distance

    source
    fn CameraLens::focus_distance(self : CameraLens) -> Double

    CameraLens::model

    source

    CameraLens::near_plane

    source
    fn CameraLens::near_plane(self : CameraLens) -> Double

    CameraLens::orthographic_height

    source
    fn CameraLens::orthographic_height(self : CameraLens) -> Double

    CameraLens::with_aperture

    source
    fn CameraLens::with_aperture(self : CameraLens, aperture : Double) -> CameraLens

    CameraLens::with_focus_distance

    source
    fn CameraLens::with_focus_distance(self : CameraLens, distance : Double) -> CameraLens

    CameraPose

    source
    pub struct CameraPose {
      position : Point3
      target : Point3
      up : Point3
      roll : Double
    } derive(
    Debug    )

    A camera pose with an explicit target. Target-based poses are convenient for editorial tools because camera orientation remains stable when the tracked object moves.

    CameraPose::forward

    source
    fn CameraPose::forward(self : CameraPose) -> Point3

    CameraPose::lerp

    source
    fn CameraPose::lerp(self : CameraPose, other : CameraPose, ratio : Double) -> CameraPose

    CameraPose::look_at

    source
    fn CameraPose::look_at(self : CameraPose, target : Point3) -> CameraPose

    CameraPose::position

    source
    fn CameraPose::position(self : CameraPose) -> Point3

    CameraPose::right

    source
    fn CameraPose::right(self : CameraPose) -> Point3

    CameraPose::roll

    source
    fn CameraPose::roll(self : CameraPose) -> Double

    CameraPose::target

    source
    fn CameraPose::target(self : CameraPose) -> Point3

    CameraPose::translated

    source
    fn CameraPose::translated(self : CameraPose, offset : Point3) -> CameraPose

    CameraPose::true_up

    source
    fn CameraPose::true_up(self : CameraPose) -> Point3

    CameraPose::up

    source
    fn CameraPose::up(self : CameraPose) -> Point3

    CameraPostSettings2

    source
    pub struct CameraPostSettings2 {
      safe_margin : Double
      shake : Point2
      exposure : Double
      focus_depth : Double
      vignette : Double
    } derive(
    Debug    )

    Post-process camera samples with screen-safe and optical policies.

    CameraPostSettings2::exposure

    source
    fn CameraPostSettings2::exposure(self : CameraPostSettings2) -> Double

    CameraPostSettings2::focus_depth

    source
    fn CameraPostSettings2::focus_depth(self : CameraPostSettings2) -> Double

    CameraPostSettings2::safe_margin

    source
    fn CameraPostSettings2::safe_margin(self : CameraPostSettings2) -> Double

    CameraPostSettings2::shake

    source

    CameraPostSettings2::vignette

    source
    fn CameraPostSettings2::vignette(self : CameraPostSettings2) -> Double

    CameraPostSettings2::with_exposure

    source
    fn CameraPostSettings2::with_exposure(self : CameraPostSettings2, value : Double) -> CameraPostSettings2

    CameraPostSettings2::with_focus

    source
    fn CameraPostSettings2::with_focus(self : CameraPostSettings2, value : Double) -> CameraPostSettings2

    CameraPostSettings2::with_safe_margin

    source
    fn CameraPostSettings2::with_safe_margin(self : CameraPostSettings2, value : Double) -> CameraPostSettings2

    CameraPostSettings2::with_shake

    source

    CameraPostSettings2::with_vignette

    source
    fn CameraPostSettings2::with_vignette(self : CameraPostSettings2, value : Double) -> CameraPostSettings2

    CameraRig

    source
    pub struct CameraRig {
      pose : CameraPose
      lens : CameraLens
      viewport : Viewport
      jitter : Point2
    } derive(
    Debug    )

    A camera rig combines animated pose, lens, and viewport policies.

    CameraRig::dolly_to_fit

    source
    fn CameraRig::dolly_to_fit(self : CameraRig, center : Point3, radius : Double) -> CameraRig

    CameraRig::fit_distance

    source
    fn CameraRig::fit_distance(self : CameraRig, radius : Double) -> Double

    CameraRig::frame_sphere

    source
    fn CameraRig::frame_sphere(self : CameraRig, framing : CameraFraming2) -> CameraRig

    CameraRig::jitter

    source
    fn CameraRig::jitter(self : CameraRig) -> Point2

    CameraRig::lens

    source
    fn CameraRig::lens(self : CameraRig) -> CameraLens

    CameraRig::pose

    source
    fn CameraRig::pose(self : CameraRig) -> CameraPose

    CameraRig::project

    source
    fn CameraRig::project(self : CameraRig, world : Point3) -> Point2

    CameraRig::ray

    source
    fn CameraRig::ray(self : CameraRig, screen : Point2) -> (Point3, Point3)

    CameraRig::unproject

    source
    fn CameraRig::unproject(self : CameraRig, screen : Point2, depth : Double) -> Point3

    CameraRig::viewport

    source
    fn CameraRig::viewport(self : CameraRig) -> Viewport

    CameraRig::visible

    source
    fn CameraRig::visible(self : CameraRig, world : Point3) -> Bool

    CameraRig::with_jitter

    source
    fn CameraRig::with_jitter(self : CameraRig, jitter : Point2) -> CameraRig

    CameraTrack

    source
    pub struct CameraTrack {
      frames : Array[CameraKeyframe]
      viewport : Viewport
    } derive(
    Debug    )

    CameraTrack::duration

    source
    fn CameraTrack::duration(self : CameraTrack) -> Double

    CameraTrack::end_time

    source
    fn CameraTrack::end_time(self : CameraTrack) -> Double

    CameraTrack::keyframes

    source
    fn CameraTrack::keyframes(self : CameraTrack) -> Array[CameraKeyframe]

    CameraTrack::length

    source
    fn CameraTrack::length(self : CameraTrack) -> Int

    CameraTrack::new

    source
    fn CameraTrack::new(frames : Array[CameraKeyframe], viewport : Viewport) -> CameraTrack raise MotionError

    CameraTrack::sample

    source
    fn CameraTrack::sample(self : CameraTrack, time : Double) -> CameraRig

    CameraTrack::sample_many

    source
    fn CameraTrack::sample_many(self : CameraTrack, count : Int) -> Array[CameraRig] raise MotionError

    CameraTrack::shift

    source
    fn CameraTrack::shift(self : CameraTrack, delta : Double) -> CameraTrack raise MotionError

    CameraTrack::start_time

    source
    fn CameraTrack::start_time(self : CameraTrack) -> Double

    ClipLoopMode

    source
    pub(all) enum ClipLoopMode {
      Once
      Repeat
      PingPong
    } derive(Eq, 
    Debug    )

    Playback policy for a reusable motion clip.

    ClipSequence

    source
    pub struct ClipSequence {
      items : Array[ClipSequenceItem]
      duration : Double
    } derive(
    Debug    )

    A sequence compositor that averages overlapping clip contributions.

    ClipSequence::duration

    source
    fn ClipSequence::duration(self : ClipSequence) -> Double

    ClipSequence::items

    source

    ClipSequence::length

    source
    fn ClipSequence::length(self : ClipSequence) -> Int

    ClipSequence::markers_between

    source
    fn ClipSequence::markers_between(self : ClipSequence, start : Double, end : Double) -> Array[MarkerHit]

    ClipSequence::new

    source

    ClipSequence::sample

    source
    fn ClipSequence::sample(self : ClipSequence, time : Double) -> Double

    ClipSequence::sample_many

    source
    fn ClipSequence::sample_many(self : ClipSequence, count : Int) -> Array[SamplePoint] raise MotionError

    ClipSequenceBuilder

    source
    pub struct ClipSequenceBuilder {
      items : Array[ClipSequenceItem]
    } derive(
    Debug    )

    ClipSequenceBuilder::add

    source

    ClipSequenceBuilder::add_at

    source
    fn ClipSequenceBuilder::add_at(self : ClipSequenceBuilder, clip : MotionClip, start : Double, weight? : Double) -> ClipSequenceBuilder raise MotionError

    ClipSequenceBuilder::build

    source

    ClipSequenceBuilder::length

    source
    fn ClipSequenceBuilder::length(self : ClipSequenceBuilder) -> Int

    ClipSequenceBuilder::new

    source

    ClipSequenceItem

    source
    pub struct ClipSequenceItem {
      clip : MotionClip
      start : Double
      weight : Double
    } derive(
    Debug    )

    A clip placed at a start offset in a larger composition.

    ClipSequenceItem::clip

    source

    ClipSequenceItem::end

    source
    fn ClipSequenceItem::end(self : ClipSequenceItem) -> Double

    ClipSequenceItem::start

    source
    fn ClipSequenceItem::start(self : ClipSequenceItem) -> Double

    ClipSequenceItem::weight

    source
    fn ClipSequenceItem::weight(self : ClipSequenceItem) -> Double

    ColorBlendLayer

    source
    pub struct ColorBlendLayer {
      value : Rgba
      weight : Double
      mode : BlendMode
      priority : Int
    } derive(
    Debug    )

    ColorBlendLayer::mode

    source

    ColorBlendLayer::value

    source
    fn ColorBlendLayer::value(self : ColorBlendLayer) -> Rgba

    ColorBlendLayer::weight

    source
    fn ColorBlendLayer::weight(self : ColorBlendLayer) -> Double

    ColorGradient

    source
    pub struct ColorGradient {
      stops : Array[GradientStop]
      premultiplied : Bool
    } derive(
    Debug    )

    A validated one-dimensional color gradient for UI and media rendering.

    ColorGradient::end

    source
    fn ColorGradient::end(self : ColorGradient) -> Double

    ColorGradient::length

    source
    fn ColorGradient::length(self : ColorGradient) -> Int

    ColorGradient::new

    source
    fn ColorGradient::new(stops : Array[GradientStop], premultiplied? : Bool) -> ColorGradient raise MotionError

    ColorGradient::premultiplied

    source
    fn ColorGradient::premultiplied(self : ColorGradient) -> Bool

    ColorGradient::reversed

    source
    fn ColorGradient::reversed(self : ColorGradient) -> ColorGradient

    Return a gradient with the stop order and transition directions reversed.

    ColorGradient::sample

    source
    fn ColorGradient::sample(self : ColorGradient, position : Double) -> Rgba

    Sample the gradient. Values outside its declared range are clamped.

    ColorGradient::sample_many

    source
    fn ColorGradient::sample_many(self : ColorGradient, count : Int) -> Array[Rgba] raise MotionError

    ColorGradient::start

    source
    fn ColorGradient::start(self : ColorGradient) -> Double

    ColorGradient::stops

    source

    ColorMatrix

    source
    pub struct ColorMatrix {
      red : (Double, Double, Double, Double, Double)
      green : (Double, Double, Double, Double, Double)
      blue : (Double, Double, Double, Double, Double)
      alpha : (Double, Double, Double, Double, Double)
    } derive(
    Debug    )

    ColorMatrix::apply

    source
    fn ColorMatrix::apply(self : ColorMatrix, color : Rgba) -> Rgba

    ColorMatrix::then

    source
    fn ColorMatrix::then(self : ColorMatrix, next : ColorMatrix) -> ColorMatrix

    ColorRamp2

    source
    pub struct ColorRamp2 {
      stops : Array[ColorRampStop]
      interpolation : RampInterpolation
    } derive(
    Debug    )

    ColorRamp2::length

    source
    fn ColorRamp2::length(self : ColorRamp2) -> Int

    ColorRamp2::new

    source
    fn ColorRamp2::new(stops : Array[ColorRampStop], interpolation? : RampInterpolation) -> ColorRamp2

    ColorRamp2::reversed

    source
    fn ColorRamp2::reversed(self : ColorRamp2) -> ColorRamp2

    ColorRamp2::sample

    source
    fn ColorRamp2::sample(self : ColorRamp2, position : Double) -> Rgba

    ColorRamp2::sample_many

    source
    fn ColorRamp2::sample_many(self : ColorRamp2, count : Int) -> Array[Rgba]

    ColorRamp2::stops

    source

    ColorRampStop

    source
    pub struct ColorRampStop {
      position : Double
      color : Rgba
    } derive(
    Debug    )

    ColorRampStop::color

    source
    fn ColorRampStop::color(self : ColorRampStop) -> Rgba

    ColorRampStop::position

    source
    fn ColorRampStop::position(self : ColorRampStop) -> Double

    ColorSampleCache2

    source
    pub struct ColorSampleCache2 {
      key : SampleCacheKey2
      values : Array[Rgba]
    } derive(
    Debug    )

    ColorSampleCache2::key

    source

    ColorSampleCache2::new

    source

    ColorSampleCache2::sample

    source
    fn ColorSampleCache2::sample(self : ColorSampleCache2, time : Double) -> Rgba

    ColorSampleCache2::values

    source

    ColorSeries2

    source
    pub struct ColorSeries2 {
      times : Array[Double]
      values : Array[Rgba]
    } derive(
    Debug    )

    ColorSeries2::sample

    source
    fn ColorSeries2::sample(self : ColorSeries2, time : Double) -> Rgba

    ConstraintResult2

    source
    pub struct ConstraintResult2 {
      value : Double
      velocity : Double
      acceleration : Double
      status : ConstraintStatus2
      iterations : Int
      error : Double
    } derive(
    Debug    )

    ConstraintResult2::acceleration

    source
    fn ConstraintResult2::acceleration(self : ConstraintResult2) -> Double

    ConstraintResult2::error

    source
    fn ConstraintResult2::error(self : ConstraintResult2) -> Double

    ConstraintResult2::iterations

    source
    fn ConstraintResult2::iterations(self : ConstraintResult2) -> Int

    ConstraintResult2::status

    source

    ConstraintResult2::value

    source
    fn ConstraintResult2::value(self : ConstraintResult2) -> Double

    ConstraintResult2::velocity

    source
    fn ConstraintResult2::velocity(self : ConstraintResult2) -> Double

    ConstraintSolveConfig

    source
    pub struct ConstraintSolveConfig {
      frame_rate : Double
      limits : MotionLimitProfile2
      preserve_endpoints : Bool
      passes : Int
    } derive(
    Debug    )

    Discrete constraint solver for a sampled scalar motion signal. It performs forward and backward passes so an edit can honour limits without changing the number of frames requested by the renderer.

    ConstraintSolveConfig::frame_rate

    source
    fn ConstraintSolveConfig::frame_rate(self : ConstraintSolveConfig) -> Double

    ConstraintSolveConfig::limits

    source

    ConstraintSolveConfig::with_endpoints

    source
    fn ConstraintSolveConfig::with_endpoints(self : ConstraintSolveConfig, preserve : Bool) -> ConstraintSolveConfig

    ConstraintSolveConfig::with_passes

    source
    fn ConstraintSolveConfig::with_passes(self : ConstraintSolveConfig, passes : Int) -> ConstraintSolveConfig

    ConstraintSolveResult

    source
    pub struct ConstraintSolveResult {
      values : Array[Double]
      velocities : Array[Double]
      accelerations : Array[Double]
      maximum_error : Double
      iterations : Int
      converged : Bool
    } derive(
    Debug    )

    ConstraintSolveResult::accelerations

    source
    fn ConstraintSolveResult::accelerations(self : ConstraintSolveResult) -> Array[Double]

    ConstraintSolveResult::converged

    source
    fn ConstraintSolveResult::converged(self : ConstraintSolveResult) -> Bool

    ConstraintSolveResult::iterations

    source
    fn ConstraintSolveResult::iterations(self : ConstraintSolveResult) -> Int

    ConstraintSolveResult::maximum_error

    source
    fn ConstraintSolveResult::maximum_error(self : ConstraintSolveResult) -> Double

    ConstraintSolveResult::values

    source
    fn ConstraintSolveResult::values(self : ConstraintSolveResult) -> Array[Double]

    ConstraintSolveResult::velocities

    source
    fn ConstraintSolveResult::velocities(self : ConstraintSolveResult) -> Array[Double]

    ConstraintStatus2

    source
    pub enum ConstraintStatus2 {
      ConstraintSatisfied
      VelocityLimited
      AccelerationLimited
      JerkLimited
      PositionClamped
    } derive(
    Debug    )

    CubicPath2D

    source
    pub struct CubicPath2D {
      start : Point2
      control_start : Point2
      control_end : Point2
      end : Point2
    } derive(
    Debug    )

    A cubic geometric Bézier path. This is separate from Bezier timing curves.

    CubicPath2D::bounds

    source
    fn CubicPath2D::bounds(self : CubicPath2D, segments? : Int) -> Bounds2D

    CubicPath2D::length

    source
    fn CubicPath2D::length(self : CubicPath2D, segments : Int) -> Double

    CubicPath2D::polyline

    source
    fn CubicPath2D::polyline(self : CubicPath2D, segments : Int) -> Array[Point2]

    CubicPath2D::sample

    source
    fn CubicPath2D::sample(self : CubicPath2D, t : Double) -> Point2

    CubicPath2D::sample_by_distance

    source
    fn CubicPath2D::sample_by_distance(self : CubicPath2D, distance : Double, segments? : Int) -> Point2

    CubicPath2D::tangent

    source
    fn CubicPath2D::tangent(self : CubicPath2D, t : Double) -> Point2

    CubicPath3D

    source
    pub struct CubicPath3D {
      start : Point3
      control_start : Point3
      control_end : Point3
      end : Point3
    } derive(
    Debug    )

    Cubic Bézier geometry in scene space. The timing Curve type is kept separate so geometry can be reused by cameras, particles, and masks.

    CubicPath3D::control_end

    source
    fn CubicPath3D::control_end(self : CubicPath3D) -> Point3

    CubicPath3D::control_start

    source
    fn CubicPath3D::control_start(self : CubicPath3D) -> Point3

    CubicPath3D::curvature

    source
    fn CubicPath3D::curvature(self : CubicPath3D, ratio : Double) -> Double

    CubicPath3D::end

    source
    fn CubicPath3D::end(self : CubicPath3D) -> Point3

    CubicPath3D::length

    source
    fn CubicPath3D::length(self : CubicPath3D, samples : Int) -> Double

    CubicPath3D::polyline

    source
    fn CubicPath3D::polyline(self : CubicPath3D, samples : Int) -> Array[Point3]

    CubicPath3D::sample

    source
    fn CubicPath3D::sample(self : CubicPath3D, ratio : Double) -> Point3

    CubicPath3D::sample_by_distance

    source
    fn CubicPath3D::sample_by_distance(self : CubicPath3D, distance : Double, samples? : Int) -> Point3

    CubicPath3D::start

    source
    fn CubicPath3D::start(self : CubicPath3D) -> Point3

    CubicPath3D::tangent

    source
    fn CubicPath3D::tangent(self : CubicPath3D, ratio : Double) -> Point3

    CueTimeline

    source
    pub struct CueTimeline {
      cues : Array[BeatCue]
      grid : BeatGrid
    } derive(
    Debug    )

    CueTimeline::add

    source
    fn CueTimeline::add(self : CueTimeline, cue : BeatCue) -> Unit

    CueTimeline::at_seconds

    source
    fn CueTimeline::at_seconds(self : CueTimeline, seconds : Double) -> Array[BeatCue]

    CueTimeline::cues

    source
    fn CueTimeline::cues(self : CueTimeline) -> Array[BeatCue]

    CueTimeline::grid

    source
    fn CueTimeline::grid(self : CueTimeline) -> BeatGrid

    CueTimeline::length

    source
    fn CueTimeline::length(self : CueTimeline) -> Int

    CueTimeline::new

    source
    fn CueTimeline::new(grid : BeatGrid) -> CueTimeline

    CueTimeline::next_after

    source
    fn CueTimeline::next_after(self : CueTimeline, seconds : Double) -> BeatCue?

    CueTimeline::window

    source
    fn CueTimeline::window(self : CueTimeline, start : Double, end : Double) -> Array[BeatCue]

    Curve

    source
    pub(all) enum Curve {
      Builtin(EasingId)
      CubicBezier(Bezier)
    } derive(
    Debug    )

    A curve selector stored on a keyframe transition.

    Curve::apply

    source
    fn Curve::apply(self : Curve, t : Double) -> Double

    Curve::bezier

    source
    fn Curve::bezier(curve : Bezier) -> Curve

    Curve::builtin

    source
    fn Curve::builtin(id : EasingId) -> Curve

    Curve::derivative

    source
    fn Curve::derivative(self : Curve, t : Double) -> Double

    CurveAnalysisPoint

    source
    pub(all) struct CurveAnalysisPoint {
      time : Double
      value : Double
      velocity : Double
      acceleration : Double
      normalized_value : Double
    } derive(
    Debug    )

    A sample enriched with first and second derivative estimates.

    CurveAnalysisPoint::acceleration

    source
    fn CurveAnalysisPoint::acceleration(self : CurveAnalysisPoint) -> Double

    CurveAnalysisPoint::normalized_value

    source
    fn CurveAnalysisPoint::normalized_value(self : CurveAnalysisPoint) -> Double

    CurveAnalysisPoint::time

    source
    fn CurveAnalysisPoint::time(self : CurveAnalysisPoint) -> Double

    CurveAnalysisPoint::value

    source
    fn CurveAnalysisPoint::value(self : CurveAnalysisPoint) -> Double

    CurveAnalysisPoint::velocity

    source
    fn CurveAnalysisPoint::velocity(self : CurveAnalysisPoint) -> Double

    CurveChain

    source
    pub struct CurveChain {
      curves : Array[Curve]
      weights : Array[Double]
      total_weight : Double
    } derive(
    Debug    )

    A piecewise curve used to choreograph a multi-stage motion.

    CurveChain::derivative

    source
    fn CurveChain::derivative(self : CurveChain, t : Double) -> Double

    CurveChain::length

    source
    fn CurveChain::length(self : CurveChain) -> Int

    CurveChain::new

    source
    fn CurveChain::new(curves : Array[Curve], weights? : Array[Double]) -> CurveChain raise MotionError

    CurveChain::sample

    source
    fn CurveChain::sample(self : CurveChain, t : Double) -> Double

    CurveChain::sample_many

    source
    fn CurveChain::sample_many(self : CurveChain, count : Int) -> Array[Double] raise MotionError

    CurveComparison

    source
    pub struct CurveComparison {
      mean_absolute_error : Double
      root_mean_square_error : Double
      maximum_error : Double
      area_error : Double
      correlation : Double
      samples : Int
    } derive(
    Debug    )

    CurveComparison::area_error

    source
    fn CurveComparison::area_error(self : CurveComparison) -> Double

    CurveComparison::correlation

    source
    fn CurveComparison::correlation(self : CurveComparison) -> Double

    CurveComparison::maximum_error

    source
    fn CurveComparison::maximum_error(self : CurveComparison) -> Double

    CurveComparison::mean_absolute_error

    source
    fn CurveComparison::mean_absolute_error(self : CurveComparison) -> Double

    CurveComparison::root_mean_square_error

    source
    fn CurveComparison::root_mean_square_error(self : CurveComparison) -> Double

    CurveComparison::samples

    source
    fn CurveComparison::samples(self : CurveComparison) -> Int

    CurveEnvelope

    source
    pub struct CurveEnvelope {
      lower : Array[Double]
      upper : Array[Double]
      samples : Int
    } derive(
    Debug    )

    CurveEnvelope::contains

    source
    fn CurveEnvelope::contains(self : CurveEnvelope, curve : Curve) -> Bool

    CurveEnvelope::lower

    source
    fn CurveEnvelope::lower(self : CurveEnvelope) -> Array[Double]

    CurveEnvelope::samples

    source
    fn CurveEnvelope::samples(self : CurveEnvelope) -> Int

    CurveEnvelope::upper

    source
    fn CurveEnvelope::upper(self : CurveEnvelope) -> Array[Double]

    CurveEnvelope::width_at

    source
    fn CurveEnvelope::width_at(self : CurveEnvelope, time : Double) -> Double

    CurveFeature

    source
    pub enum CurveFeature {
      FeatureStart
      FeatureEnd
      FeaturePeakVelocity
      FeaturePeakAcceleration
      FeatureFirstOvershoot
      FeatureSettlingTime
    } derive(
    Debug    )

    CurveInvariantReport2

    source
    pub struct CurveInvariantReport2 {
      start_error : Double
      end_error : Double
      maximum_step : Double
      monotonic : Bool
      finite : Bool
      samples : Int
    } derive(
    Debug    )

    Additional curve invariants for authoring and regression checks.

    CurveInvariantReport2::end_error

    source
    fn CurveInvariantReport2::end_error(self : CurveInvariantReport2) -> Double

    CurveInvariantReport2::finite

    source
    fn CurveInvariantReport2::finite(self : CurveInvariantReport2) -> Bool

    CurveInvariantReport2::maximum_step

    source
    fn CurveInvariantReport2::maximum_step(self : CurveInvariantReport2) -> Double

    CurveInvariantReport2::monotonic

    source
    fn CurveInvariantReport2::monotonic(self : CurveInvariantReport2) -> Bool

    CurveInvariantReport2::samples

    source
    fn CurveInvariantReport2::samples(self : CurveInvariantReport2) -> Int

    CurveInvariantReport2::start_error

    source
    fn CurveInvariantReport2::start_error(self : CurveInvariantReport2) -> Double

    CurveLookupTable

    source
    pub struct CurveLookupTable {
      values : Array[Double]
      derivatives : Array[Double]
      minimum : Double
      maximum : Double
      integral : Double
    } derive(
    Debug    )

    A uniformly sampled, allocation-free-at-read-time representation of a timing curve. Baking is useful when a render loop evaluates the same curve for thousands of particles or UI properties.

    CurveLookupTable::derivative_at

    source
    fn CurveLookupTable::derivative_at(self : CurveLookupTable, time : Double) -> Double

    CurveLookupTable::derivatives

    source
    fn CurveLookupTable::derivatives(self : CurveLookupTable) -> Array[Double]

    CurveLookupTable::error

    source
    fn CurveLookupTable::error(self : CurveLookupTable, curve : Curve, samples : Int) -> Double

    CurveLookupTable::integral

    source
    fn CurveLookupTable::integral(self : CurveLookupTable) -> Double

    CurveLookupTable::integral_until

    source
    fn CurveLookupTable::integral_until(self : CurveLookupTable, time : Double) -> Double

    CurveLookupTable::inverse

    source
    fn CurveLookupTable::inverse(self : CurveLookupTable, value : Double, iterations? : Int) -> Double

    CurveLookupTable::map_range

    source
    fn CurveLookupTable::map_range(self : CurveLookupTable, input : Double, output_min : Double, output_max : Double) -> Double

    CurveLookupTable::maximum

    source
    fn CurveLookupTable::maximum(self : CurveLookupTable) -> Double

    CurveLookupTable::minimum

    source
    fn CurveLookupTable::minimum(self : CurveLookupTable) -> Double

    CurveLookupTable::monotonic

    source
    fn CurveLookupTable::monotonic(self : CurveLookupTable) -> Bool

    CurveLookupTable::new

    source
    fn CurveLookupTable::new(curve : Curve, samples : Int) -> CurveLookupTable raise MotionError

    CurveLookupTable::normalized

    source

    CurveLookupTable::peak_speed

    source
    fn CurveLookupTable::peak_speed(self : CurveLookupTable) -> (Double, Double)

    CurveLookupTable::range

    source
    fn CurveLookupTable::range(self : CurveLookupTable) -> Double

    CurveLookupTable::resample

    source
    fn CurveLookupTable::resample(self : CurveLookupTable, samples : Int) -> CurveLookupTable raise MotionError

    CurveLookupTable::sample

    source
    fn CurveLookupTable::sample(self : CurveLookupTable, time : Double) -> Double

    CurveLookupTable::sample_smooth

    source
    fn CurveLookupTable::sample_smooth(self : CurveLookupTable, time : Double) -> Double

    CurveLookupTable::samples

    source
    fn CurveLookupTable::samples(self : CurveLookupTable) -> Int

    CurveLookupTable::values

    source
    fn CurveLookupTable::values(self : CurveLookupTable) -> Array[Double]

    CurveLutBank

    source
    pub struct CurveLutBank {
      tables : Array[CurveLookupTable]
      labels : Array[String]
    } derive(
    Debug    )

    A compact collection of baked curves with shared sample density.

    CurveLutBank::add

    source
    fn CurveLutBank::add(self : CurveLutBank, label : String, curve : Curve, samples : Int) -> Unit raise MotionError

    CurveLutBank::label

    source
    fn CurveLutBank::label(self : CurveLutBank, index : Int) -> String

    CurveLutBank::length

    source
    fn CurveLutBank::length(self : CurveLutBank) -> Int

    CurveLutBank::max_error

    source
    fn CurveLutBank::max_error(self : CurveLutBank, curves : Array[Curve], samples : Int) -> Double

    CurveLutBank::sample

    source
    fn CurveLutBank::sample(self : CurveLutBank, index : Int, time : Double) -> Double

    CurveLutBank::samples

    source
    fn CurveLutBank::samples(self : CurveLutBank, time : Double) -> Array[Double]

    CurveLutBank::table

    source
    fn CurveLutBank::table(self : CurveLutBank, index : Int) -> CurveLookupTable

    CurveLutBuilder

    source
    pub struct CurveLutBuilder {
      curve : Curve
      samples : Int
      adaptive : Bool
      tolerance : Double
    } derive(
    Debug    )

    CurveLutBuilder::adaptive

    source
    fn CurveLutBuilder::adaptive(self : CurveLutBuilder, enabled : Bool) -> CurveLutBuilder

    CurveLutBuilder::build

    source

    CurveLutBuilder::samples

    source
    fn CurveLutBuilder::samples(self : CurveLutBuilder) -> Int

    CurveLutBuilder::with_samples

    source
    fn CurveLutBuilder::with_samples(self : CurveLutBuilder, samples : Int) -> CurveLutBuilder

    CurveLutBuilder::with_tolerance

    source
    fn CurveLutBuilder::with_tolerance(self : CurveLutBuilder, tolerance : Double) -> CurveLutBuilder

    CurveMonotonicity

    source
    pub(all) enum CurveMonotonicity {
      Increasing
      Decreasing
      Constant
      Mixed
    } derive(Eq, 
    Debug    )

    CurvePipeline2

    source
    pub struct CurvePipeline2 {
      curve : Curve
      stages : Array[CurveStage2]
    } derive(
    Debug    )

    CurvePipeline2::add

    source

    CurvePipeline2::apply

    source
    fn CurvePipeline2::apply(self : CurvePipeline2, time : Double) -> Double

    CurvePipeline2::bake

    source
    fn CurvePipeline2::bake(self : CurvePipeline2, samples : Int) -> CurveLookupTable raise MotionError

    CurvePipeline2::curve

    source
    fn CurvePipeline2::curve(self : CurvePipeline2) -> Curve

    CurvePipeline2::range

    source
    fn CurvePipeline2::range(self : CurvePipeline2, samples : Int) -> (Double, Double)

    CurvePipeline2::sample_many

    source
    fn CurvePipeline2::sample_many(self : CurvePipeline2, count : Int) -> Array[Double]

    CurvePipeline2::stages

    source

    CurvePipeline2::then

    source

    CurveRemap2

    source
    pub struct CurveRemap2 {
      input_min : Double
      input_max : Double
      output_min : Double
      output_max : Double
      extrapolation : Extrapolation
    } derive(
    Debug    )

    CurveRemap2::apply

    source
    fn CurveRemap2::apply(self : CurveRemap2, value : Double) -> Double

    CurveRemap2::with_extrapolation

    source
    fn CurveRemap2::with_extrapolation(self : CurveRemap2, mode : Extrapolation) -> CurveRemap2

    CurveReport

    source
    pub(all) struct CurveReport {
      samples : Int
      minimum : Double
      maximum : Double
      endpoint_error : Double
      monotonic : Bool
      peak_velocity : Double
      peak_acceleration : Double
    } derive(
    Debug    )

    Summary metrics for comparing or previewing a motion curve.

    CurveReport::endpoint_error

    source
    fn CurveReport::endpoint_error(self : CurveReport) -> Double

    CurveReport::is_monotonic

    source
    fn CurveReport::is_monotonic(self : CurveReport) -> Bool

    CurveReport::maximum

    source
    fn CurveReport::maximum(self : CurveReport) -> Double

    CurveReport::minimum

    source
    fn CurveReport::minimum(self : CurveReport) -> Double

    CurveReport::peak_acceleration

    source
    fn CurveReport::peak_acceleration(self : CurveReport) -> Double

    CurveReport::peak_velocity

    source
    fn CurveReport::peak_velocity(self : CurveReport) -> Double

    CurveReport::samples

    source
    fn CurveReport::samples(self : CurveReport) -> Int

    CurveStage2

    source
    pub enum CurveStage2 {
      StageNormalize
      StageClamp(Double, Double)
      StageRemap(Double, Double)
      StageBias(Double)
      StageGain(Double)
      StageQuantize(Int)
      StageMirror
    } derive(
    Debug    )

    Post-processing stages for combining easing curves with editorial ranges.

    CurveStatistics

    source
    pub struct CurveStatistics {
      minimum : Double
      maximum : Double
      mean : Double
      integral : Double
      peak_velocity : Double
      peak_acceleration : Double
      total_variation : Double
      overshoot : Double
      undershoot : Double
    } derive(
    Debug    )

    Measured properties of a timing curve over a normalized interval.

    CurveStatistics::integral

    source
    fn CurveStatistics::integral(self : CurveStatistics) -> Double

    CurveStatistics::maximum

    source
    fn CurveStatistics::maximum(self : CurveStatistics) -> Double

    CurveStatistics::mean

    source
    fn CurveStatistics::mean(self : CurveStatistics) -> Double

    CurveStatistics::minimum

    source
    fn CurveStatistics::minimum(self : CurveStatistics) -> Double

    CurveStatistics::monotonic

    source
    fn CurveStatistics::monotonic(self : CurveStatistics) -> Bool

    CurveStatistics::normalized_overshoot

    source
    fn CurveStatistics::normalized_overshoot(self : CurveStatistics) -> Double

    CurveStatistics::overshoot

    source
    fn CurveStatistics::overshoot(self : CurveStatistics) -> Double

    CurveStatistics::peak_acceleration

    source
    fn CurveStatistics::peak_acceleration(self : CurveStatistics) -> Double

    CurveStatistics::peak_velocity

    source
    fn CurveStatistics::peak_velocity(self : CurveStatistics) -> Double

    CurveStatistics::range

    source
    fn CurveStatistics::range(self : CurveStatistics) -> Double

    CurveStatistics::total_variation

    source
    fn CurveStatistics::total_variation(self : CurveStatistics) -> Double

    CurveStatistics::undershoot

    source
    fn CurveStatistics::undershoot(self : CurveStatistics) -> Double

    DiagnosticCode2

    source
    pub enum DiagnosticCode2 {
      EmptyInputDiagnostic
      NonFiniteDiagnostic
      EndpointMismatchDiagnostic
      VelocityLimitDiagnostic
      SamplingErrorDiagnostic
      ColorRangeDiagnostic
      BoundsDiagnostic
    } derive(
    Debug    )

    DiagnosticIssue2

    source
    pub struct DiagnosticIssue2 {
      severity : DiagnosticSeverity2
      code : DiagnosticCode2
      message : String
      sample_index : Int
      value : Double
      limit : Double
    } derive(
    Debug    )

    DiagnosticIssue2::code

    source

    DiagnosticIssue2::limit

    source
    fn DiagnosticIssue2::limit(self : DiagnosticIssue2) -> Double

    DiagnosticIssue2::message

    source
    fn DiagnosticIssue2::message(self : DiagnosticIssue2) -> String

    DiagnosticIssue2::sample_index

    source
    fn DiagnosticIssue2::sample_index(self : DiagnosticIssue2) -> Int

    DiagnosticIssue2::severity

    source

    DiagnosticIssue2::value

    source
    fn DiagnosticIssue2::value(self : DiagnosticIssue2) -> Double

    DiagnosticReport2

    source
    pub struct DiagnosticReport2 {
      name : String
      issues : Array[DiagnosticIssue2]
      checked_samples : Int
      duration : Double
    } derive(
    Debug    )

    DiagnosticReport2::add

    source
    fn DiagnosticReport2::add(self : DiagnosticReport2, issue : DiagnosticIssue2) -> Unit

    DiagnosticReport2::checked_samples

    source
    fn DiagnosticReport2::checked_samples(self : DiagnosticReport2) -> Int

    DiagnosticReport2::duration

    source
    fn DiagnosticReport2::duration(self : DiagnosticReport2) -> Double

    DiagnosticReport2::error_count

    source
    fn DiagnosticReport2::error_count(self : DiagnosticReport2) -> Int

    DiagnosticReport2::issues

    source

    DiagnosticReport2::name

    source
    fn DiagnosticReport2::name(self : DiagnosticReport2) -> String

    DiagnosticReport2::warning_count

    source
    fn DiagnosticReport2::warning_count(self : DiagnosticReport2) -> Int

    DiagnosticReport2::with_measurements

    source
    fn DiagnosticReport2::with_measurements(self : DiagnosticReport2, samples : Int, duration : Double) -> DiagnosticReport2

    DiagnosticSeverity2

    source
    pub enum DiagnosticSeverity2 {
      InfoDiagnostic
      WarningDiagnostic
      ErrorDiagnostic
    } derive(
    Debug    )

    Structured diagnostics for tooling and CI. Reports contain measurements rather than formatted terminal output so host applications can render warnings in their own UI.

    DiagnosticSummary2

    source
    pub struct DiagnosticSummary2 {
      reports : Int
      errors : Int
      warnings : Int
      samples : Int
    } derive(
    Debug    )

    DiagnosticSummary2::errors

    source
    fn DiagnosticSummary2::errors(self : DiagnosticSummary2) -> Int

    DiagnosticSummary2::passed

    source
    fn DiagnosticSummary2::passed(self : DiagnosticSummary2) -> Bool

    DiagnosticSummary2::reports

    source
    fn DiagnosticSummary2::reports(self : DiagnosticSummary2) -> Int

    DiagnosticSummary2::samples

    source
    fn DiagnosticSummary2::samples(self : DiagnosticSummary2) -> Int

    DiagnosticSummary2::warnings

    source
    fn DiagnosticSummary2::warnings(self : DiagnosticSummary2) -> Int

    EasingId

    source
    pub(all) enum EasingId {
      Linear
      QuadIn
      QuadOut
      QuadInOut
      CubicIn
      CubicOut
      CubicInOut
      QuartIn
      QuartOut
      QuartInOut
      QuintIn
      QuintOut
      QuintInOut
      SineIn
      SineOut
      SineInOut
      ExpoIn
      ExpoOut
      ExpoInOut
      CircIn
      CircOut
      CircInOut
      BackIn
      BackOut
      BackInOut
      ElasticIn
      ElasticOut
      ElasticInOut
      BounceIn
      BounceOut
      BounceInOut
    } derive(Eq, 
    Debug    )

    Families of easing curves used by a motion timeline.

    EasingId::apply

    source
    fn EasingId::apply(self : EasingId, t : Double) -> Double

    Evaluate a built-in easing curve.

    EasingId::derivative

    source
    fn EasingId::derivative(self : EasingId, t : Double) -> Double

    First derivative of a built-in easing curve on normalized time.

    EvaluationContext2

    source
    pub struct EvaluationContext2 {
      time : Double
      frame : Int
      normalized : Double
      delta : Double
      direction : Int
    } derive(
    Debug    )

    Unified evaluation context shared by render, audio, and event consumers.

    EvaluationContext2::delta

    source
    fn EvaluationContext2::delta(self : EvaluationContext2) -> Double

    EvaluationContext2::direction

    source
    fn EvaluationContext2::direction(self : EvaluationContext2) -> Int

    EvaluationContext2::frame

    source
    fn EvaluationContext2::frame(self : EvaluationContext2) -> Int

    EvaluationContext2::normalized

    source
    fn EvaluationContext2::normalized(self : EvaluationContext2) -> Double

    EvaluationContext2::time

    source
    fn EvaluationContext2::time(self : EvaluationContext2) -> Double

    EvaluationStats2

    source
    pub struct EvaluationStats2 {
      frames : Int
      active_nodes : Int
      render_passes : Int
      events : Int
      duration : Double
    } derive(
    Debug    )

    EvaluationStats2::active_nodes

    source
    fn EvaluationStats2::active_nodes(self : EvaluationStats2) -> Int

    EvaluationStats2::duration

    source
    fn EvaluationStats2::duration(self : EvaluationStats2) -> Double

    EvaluationStats2::events

    source
    fn EvaluationStats2::events(self : EvaluationStats2) -> Int

    EvaluationStats2::frames

    source
    fn EvaluationStats2::frames(self : EvaluationStats2) -> Int

    EvaluationStats2::render_passes

    source
    fn EvaluationStats2::render_passes(self : EvaluationStats2) -> Int

    EventWindow2

    source
    pub struct EventWindow2 {
      start : Double
      end : Double
      events : Array[MotionEvent2]
      crossed_forward : Bool
    } derive(
    Debug    )

    EventWindow2::contains

    source
    fn EventWindow2::contains(self : EventWindow2, time : Double) -> Bool

    EventWindow2::crossed_forward

    source
    fn EventWindow2::crossed_forward(self : EventWindow2) -> Bool

    EventWindow2::end

    source
    fn EventWindow2::end(self : EventWindow2) -> Double

    EventWindow2::events

    source

    EventWindow2::normalized_progress

    source
    fn EventWindow2::normalized_progress(self : EventWindow2, time : Double) -> Double

    EventWindow2::start

    source
    fn EventWindow2::start(self : EventWindow2) -> Double

    ExportChunk2

    source
    pub struct ExportChunk2 {
      start_frame : Int
      end_frame : Int
      start_time : Double
      end_time : Double
      bytes : Int
    } derive(
    Debug    )

    ExportChunk2::bytes

    source
    fn ExportChunk2::bytes(self : ExportChunk2) -> Int

    ExportChunk2::end_frame

    source
    fn ExportChunk2::end_frame(self : ExportChunk2) -> Int

    ExportChunk2::end_time

    source
    fn ExportChunk2::end_time(self : ExportChunk2) -> Double

    ExportChunk2::start_frame

    source
    fn ExportChunk2::start_frame(self : ExportChunk2) -> Int

    ExportChunk2::start_time

    source
    fn ExportChunk2::start_time(self : ExportChunk2) -> Double

    ExportFormat2

    source
    pub enum ExportFormat2 {
      ImageSequenceExport
      VideoExport
      DataExport
      AudioExport
    } derive(
    Debug    )

    Backend-neutral export manifest for reproducible media renders.

    ExportManifest2

    source
    pub struct ExportManifest2 {
      settings : ExportSettings2
      entries : Array[ExportManifestEntry2]
      version : Int
    } derive(
    Debug    )

    ExportManifest2::add

    source
    fn ExportManifest2::add(self : ExportManifest2, entry : ExportManifestEntry2) -> Bool

    ExportManifest2::entries

    source

    ExportManifest2::find

    source

    ExportManifest2::settings

    source

    ExportManifest2::time_range

    source
    fn ExportManifest2::time_range(self : ExportManifest2) -> (Double, Double)

    ExportManifest2::total_frames

    source
    fn ExportManifest2::total_frames(self : ExportManifest2) -> Int

    ExportManifest2::validate

    source

    ExportManifest2::version

    source
    fn ExportManifest2::version(self : ExportManifest2) -> Int

    ExportManifestEntry2

    source
    pub struct ExportManifestEntry2 {
      id : Int
      name : String
      start : Double
      end : Double
      checksum : Int
      frame_count : Int
    } derive(
    Debug    )

    ExportManifestEntry2::checksum

    source
    fn ExportManifestEntry2::checksum(self : ExportManifestEntry2) -> Int

    ExportManifestEntry2::end

    source
    fn ExportManifestEntry2::end(self : ExportManifestEntry2) -> Double

    ExportManifestEntry2::frame_count

    source
    fn ExportManifestEntry2::frame_count(self : ExportManifestEntry2) -> Int

    ExportManifestEntry2::id

    source

    ExportManifestEntry2::name

    source
    fn ExportManifestEntry2::name(self : ExportManifestEntry2) -> String

    ExportManifestEntry2::start

    source
    fn ExportManifestEntry2::start(self : ExportManifestEntry2) -> Double

    ExportManifestEntry2::with_checksum

    source
    fn ExportManifestEntry2::with_checksum(self : ExportManifestEntry2, checksum : Int) -> ExportManifestEntry2

    ExportSettings2

    source
    pub struct ExportSettings2 {
      format : ExportFormat2
      width : Int
      height : Int
      frame_rate : Double
      quality : RenderQuality2
      premultiplied : Bool
    } derive(
    Debug    )

    ExportSettings2::format

    source

    ExportSettings2::frame_rate

    source
    fn ExportSettings2::frame_rate(self : ExportSettings2) -> Double

    ExportSettings2::height

    source
    fn ExportSettings2::height(self : ExportSettings2) -> Int

    ExportSettings2::quality

    source

    ExportSettings2::viewport

    source
    fn ExportSettings2::viewport(self : ExportSettings2) -> Viewport

    ExportSettings2::width

    source
    fn ExportSettings2::width(self : ExportSettings2) -> Int

    ExportSettings2::with_premultiplied

    source
    fn ExportSettings2::with_premultiplied(self : ExportSettings2, value : Bool) -> ExportSettings2

    ExportSettings2::with_quality

    source
    fn ExportSettings2::with_quality(self : ExportSettings2, quality : RenderQuality2) -> ExportSettings2

    Extrapolation

    source
    pub(all) enum Extrapolation {
      Clamp
      Repeat
      Mirror
      Continue
    } derive(Eq, 
    Debug    )

    Extrapolation policy for a keyframe track or a tween.

    FieldParticle2

    source
    pub struct FieldParticle2 {
      position : Point2
      velocity : Point2
      age : Double
      lifetime : Double
    } derive(
    Debug    )

    FieldParticle2::age

    source
    fn FieldParticle2::age(self : FieldParticle2) -> Double

    FieldParticle2::alive

    source
    fn FieldParticle2::alive(self : FieldParticle2) -> Bool

    FieldParticle2::lifetime

    source
    fn FieldParticle2::lifetime(self : FieldParticle2) -> Double

    FieldParticle2::position

    source
    fn FieldParticle2::position(self : FieldParticle2) -> Point2

    FieldParticle2::progress

    source
    fn FieldParticle2::progress(self : FieldParticle2) -> Double

    FieldParticle2::velocity

    source
    fn FieldParticle2::velocity(self : FieldParticle2) -> Point2

    FrameBudget2

    source
    pub struct FrameBudget2 {
      frame_count : Int
      frame_bytes : Int
      total_bytes : Int
      duration : Double
      throughput : Double
    } derive(
    Debug    )

    Export-time calculations for frame budgets, timecode, and deterministic chunking. These helpers keep host-specific file writing outside the core.

    FrameBudget2::duration

    source
    fn FrameBudget2::duration(self : FrameBudget2) -> Double

    FrameBudget2::estimated_megabytes

    source
    fn FrameBudget2::estimated_megabytes(self : FrameBudget2) -> Double

    FrameBudget2::estimated_seconds

    source
    fn FrameBudget2::estimated_seconds(self : FrameBudget2) -> Double

    FrameBudget2::frame_bytes

    source
    fn FrameBudget2::frame_bytes(self : FrameBudget2) -> Int

    FrameBudget2::frame_count

    source
    fn FrameBudget2::frame_count(self : FrameBudget2) -> Int

    FrameBudget2::throughput

    source
    fn FrameBudget2::throughput(self : FrameBudget2) -> Double

    FrameBudget2::total_bytes

    source
    fn FrameBudget2::total_bytes(self : FrameBudget2) -> Int

    FrameChannel2

    source
    pub enum FrameChannel2 {
      ScalarChannel
      Point2Channel
      Point3Channel
      ColorChannel
      Transform3Channel
    } derive(
    Debug    )

    FrameClock

    source
    pub struct FrameClock {
      frame_rate : Double
      origin : Double
    } derive(
    Debug    )

    Frame clock for deterministic media time conversion.

    FrameClock::frame_rate

    source
    fn FrameClock::frame_rate(self : FrameClock) -> Double

    FrameClock::frame_times

    source
    fn FrameClock::frame_times(self : FrameClock, first_frame : Int, last_frame : Int) -> Array[Double]

    FrameClock::frame_to_seconds

    source
    fn FrameClock::frame_to_seconds(self : FrameClock, frame : Int) -> Double

    FrameClock::new

    source
    fn FrameClock::new(frame_rate : Double, origin? : Double) -> FrameClock raise MotionError

    FrameClock::quantize

    source
    fn FrameClock::quantize(self : FrameClock, seconds : Double) -> Double

    FrameClock::seconds_to_frame

    source
    fn FrameClock::seconds_to_frame(self : FrameClock, seconds : Double) -> Int

    FrameDropReport2

    source
    pub struct FrameDropReport2 {
      expected : Int
      actual : Int
      missing : Int
      duplicate : Int
      maximum_gap : Int
    } derive(
    Debug    )

    FrameDropReport2::actual

    source
    fn FrameDropReport2::actual(self : FrameDropReport2) -> Int

    FrameDropReport2::duplicate

    source
    fn FrameDropReport2::duplicate(self : FrameDropReport2) -> Int

    FrameDropReport2::expected

    source
    fn FrameDropReport2::expected(self : FrameDropReport2) -> Int

    FrameDropReport2::maximum_gap

    source
    fn FrameDropReport2::maximum_gap(self : FrameDropReport2) -> Int

    FrameDropReport2::missing

    source
    fn FrameDropReport2::missing(self : FrameDropReport2) -> Int

    FramePacket2

    source
    pub struct FramePacket2 {
      stamp : FrameStamp2
      scalar_values : Array[Double]
      point_values : Array[Point2]
      point3_values : Array[Point3]
      color_values : Array[Rgba]
      transform_values : Array[Transform3D]
    } derive(
    Debug    )

    FramePacket2::color_values

    source
    fn FramePacket2::color_values(self : FramePacket2) -> Array[Rgba]

    FramePacket2::point3_values

    source
    fn FramePacket2::point3_values(self : FramePacket2) -> Array[Point3]

    FramePacket2::point_values

    source
    fn FramePacket2::point_values(self : FramePacket2) -> Array[Point2]

    FramePacket2::scalar_values

    source
    fn FramePacket2::scalar_values(self : FramePacket2) -> Array[Double]

    FramePacket2::stamp

    source

    FramePacket2::transform_values

    source
    fn FramePacket2::transform_values(self : FramePacket2) -> Array[Transform3D]

    FramePacket2::with_color

    source
    fn FramePacket2::with_color(self : FramePacket2, value : Rgba) -> FramePacket2

    FramePacket2::with_point

    source
    fn FramePacket2::with_point(self : FramePacket2, value : Point2) -> FramePacket2

    FramePacket2::with_point3

    source
    fn FramePacket2::with_point3(self : FramePacket2, value : Point3) -> FramePacket2

    FramePacket2::with_scalar

    source
    fn FramePacket2::with_scalar(self : FramePacket2, value : Double) -> FramePacket2

    FramePacket2::with_transform

    source
    fn FramePacket2::with_transform(self : FramePacket2, value : Transform3D) -> FramePacket2

    FrameSchedule2

    source
    pub struct FrameSchedule2 {
      start : Double
      end : Double
      frame_rate : Double
      first_frame : Int
    } derive(
    Debug    )

    Deterministic frame clock for export and offline previews.

    FrameSchedule2::contains

    source
    fn FrameSchedule2::contains(self : FrameSchedule2, time : Double) -> Bool

    FrameSchedule2::duration

    source
    fn FrameSchedule2::duration(self : FrameSchedule2) -> Double

    FrameSchedule2::end

    source
    fn FrameSchedule2::end(self : FrameSchedule2) -> Double

    FrameSchedule2::frame_count

    source
    fn FrameSchedule2::frame_count(self : FrameSchedule2) -> Int

    FrameSchedule2::frame_duration

    source
    fn FrameSchedule2::frame_duration(self : FrameSchedule2) -> Double

    FrameSchedule2::frame_rate

    source
    fn FrameSchedule2::frame_rate(self : FrameSchedule2) -> Double

    FrameSchedule2::index_at

    source
    fn FrameSchedule2::index_at(self : FrameSchedule2, time : Double) -> Int

    FrameSchedule2::stamp

    source
    fn FrameSchedule2::stamp(self : FrameSchedule2, index : Int) -> FrameStamp2

    FrameSchedule2::start

    source
    fn FrameSchedule2::start(self : FrameSchedule2) -> Double

    FrameSchedule2::time_at

    source
    fn FrameSchedule2::time_at(self : FrameSchedule2, index : Int) -> Double

    FrameSchedule2::timestamps

    source
    fn FrameSchedule2::timestamps(self : FrameSchedule2) -> Array[Double]

    FrameStamp2

    source
    pub struct FrameStamp2 {
      index : Int
      time : Double
      duration : Double
    } derive(
    Debug    )

    FrameStamp2::duration

    source
    fn FrameStamp2::duration(self : FrameStamp2) -> Double

    FrameStamp2::index

    source
    fn FrameStamp2::index(self : FrameStamp2) -> Int

    FrameStamp2::time

    source
    fn FrameStamp2::time(self : FrameStamp2) -> Double

    FrameTable2

    source
    pub struct FrameTable2 {
      schedule : FrameSchedule2
      packets : Array[FramePacket2]
    } derive(
    Debug    )

    FrameTable2::empty

    source
    fn FrameTable2::empty(schedule : FrameSchedule2) -> FrameTable2

    FrameTable2::from_color

    source
    fn FrameTable2::from_color(schedule : FrameSchedule2, track : RgbaTrack) -> FrameTable2

    FrameTable2::from_point2

    source
    fn FrameTable2::from_point2(schedule : FrameSchedule2, track : Point2Track) -> FrameTable2

    FrameTable2::from_point3

    source
    fn FrameTable2::from_point3(schedule : FrameSchedule2, track : Point3Track) -> FrameTable2

    FrameTable2::from_scalar

    source
    fn FrameTable2::from_scalar(schedule : FrameSchedule2, track : ScalarTrack) -> FrameTable2

    FrameTable2::from_transform3

    source
    fn FrameTable2::from_transform3(schedule : FrameSchedule2, track : Transform3Track) -> FrameTable2

    FrameTable2::length

    source
    fn FrameTable2::length(self : FrameTable2) -> Int

    FrameTable2::map_colors

    source
    fn FrameTable2::map_colors(self : FrameTable2, mapper : (Rgba) -> Rgba) -> FrameTable2

    FrameTable2::packet

    source
    fn FrameTable2::packet(self : FrameTable2, index : Int) -> FramePacket2

    FrameTable2::packets

    source
    fn FrameTable2::packets(self : FrameTable2) -> Array[FramePacket2]

    FrameTable2::schedule

    source
    fn FrameTable2::schedule(self : FrameTable2) -> FrameSchedule2

    FrameTable2::time_range

    source
    fn FrameTable2::time_range(self : FrameTable2) -> (Double, Double)

    FramingPolicy2

    source
    pub enum FramingPolicy2 {
      FitWidthFraming
      FitHeightFraming
      FitBoundsFraming
      FillBoundsFraming
    } derive(
    Debug    )

    Framing utilities for adapting animated cameras to an output viewport.

    GradientBuilder

    source
    pub struct GradientBuilder {
      stops : Array[GradientStop]
      premultiplied : Bool
    }

    A builder for gradients assembled by an editor or an importer.

    GradientBuilder::add

    source
    fn GradientBuilder::add(self : GradientBuilder, stop : GradientStop) -> Unit

    GradientBuilder::build

    source

    GradientBuilder::new

    source
    fn GradientBuilder::new(premultiplied? : Bool) -> GradientBuilder

    GradientBuilder::remove_at

    source
    fn GradientBuilder::remove_at(self : GradientBuilder, index : Int) -> GradientStop?

    GradientStop

    source
    pub struct GradientStop {
      position : Double
      color : Rgba
      curve : Curve
    } derive(
    Debug    )

    A color stop whose curve controls the transition to the next stop.

    GradientStop::color

    source
    fn GradientStop::color(self : GradientStop) -> Rgba

    GradientStop::curve

    source
    fn GradientStop::curve(self : GradientStop) -> Curve

    GradientStop::position

    source
    fn GradientStop::position(self : GradientStop) -> Double

    GraphBuildStatus

    source
    pub enum GraphBuildStatus {
      GraphReady
      GraphCycle
      GraphMissingNode
    } derive(
    Debug    )

    GroovePattern

    source
    pub enum GroovePattern {
      StraightGroove
      SwingGroove(Double)
      TripletGroove
      CustomGroove(Array[Double])
    } derive(
    Debug    )

    Hsv

    source
    pub(all) struct Hsv {
      hue : Double
      saturation : Double
      value : Double
      alpha : Double
    } derive(
    Debug    )

    Hue, saturation, value and alpha representation.

    Hsv::alpha

    source
    fn Hsv::alpha(self : Hsv) -> Double

    Hsv::hue

    source
    fn Hsv::hue(self : Hsv) -> Double

    Hsv::saturation

    source
    fn Hsv::saturation(self : Hsv) -> Double

    Hsv::to_rgba

    source
    fn Hsv::to_rgba(self : Hsv) -> Rgba

    Hsv::value

    source
    fn Hsv::value(self : Hsv) -> Double

    JitterSequence2

    source
    pub struct JitterSequence2 {
      source : NoiseSource2
      amplitude : Point2
      frequency : Double
      phase : Point2
    } derive(
    Debug    )

    JitterSequence2::sample

    source
    fn JitterSequence2::sample(self : JitterSequence2, time : Double) -> Point2

    JitterSequence2::sample_many

    source
    fn JitterSequence2::sample_many(self : JitterSequence2, start : Double, step : Double, count : Int) -> Array[Point2]

    JitterSequence2::with_frequency

    source
    fn JitterSequence2::with_frequency(self : JitterSequence2, frequency : Double) -> JitterSequence2

    JitterSequence2::with_phase

    source
    fn JitterSequence2::with_phase(self : JitterSequence2, phase : Point2) -> JitterSequence2

    JoinStyle2D

    source
    pub enum JoinStyle2D {
      MiterJoin
      RoundJoin
      BevelJoin
    } derive(
    Debug    )

    Keyframe

    source
    pub struct Keyframe {
      time : Double
      value : Double
      curve : Curve
    } derive(
    Debug    )

    A scalar keyframe. Its curve controls the segment beginning at this frame.

    Keyframe::curve

    source
    fn Keyframe::curve(self : Keyframe) -> Curve

    Keyframe::time

    source
    fn Keyframe::time(self : Keyframe) -> Double

    Keyframe::value

    source
    fn Keyframe::value(self : Keyframe) -> Double

    KeyframeCleanupReport

    source
    pub struct KeyframeCleanupReport {
      removed : Int
      merged : Int
      adjusted : Int
      maximum_adjustment : Double
    } derive(
    Debug    )

    KeyframeCleanupReport::adjusted

    source
    fn KeyframeCleanupReport::adjusted(self : KeyframeCleanupReport) -> Int

    KeyframeCleanupReport::maximum_adjustment

    source
    fn KeyframeCleanupReport::maximum_adjustment(self : KeyframeCleanupReport) -> Double

    KeyframeCleanupReport::merged

    source

    KeyframeCleanupReport::removed

    source
    fn KeyframeCleanupReport::removed(self : KeyframeCleanupReport) -> Int

    LayerBlendMode

    source
    pub enum LayerBlendMode {
      OverrideLayer
      AdditiveLayer
      MultiplyLayer
      DifferenceLayer
    } derive(
    Debug    )

    Layer policy for combining animation sources at a common timestamp.

    MarkerCursor

    source
    pub struct MarkerCursor {
      timeline : MarkerTimeline
      time : Double
    } derive(
    Debug    )

    A cursor for deterministic marker dispatch in a transport loop.

    MarkerCursor::advance

    source
    fn MarkerCursor::advance(self : MarkerCursor, time : Double) -> Array[MarkerHit]

    MarkerCursor::reset

    source
    fn MarkerCursor::reset(self : MarkerCursor, time? : Double) -> Unit

    MarkerCursor::seek

    source
    fn MarkerCursor::seek(self : MarkerCursor, time : Double) -> Unit

    MarkerCursor::time

    source
    fn MarkerCursor::time(self : MarkerCursor) -> Double

    MarkerCursor::timeline

    source
    fn MarkerCursor::timeline(self : MarkerCursor) -> MarkerTimeline

    MarkerDirection

    source
    pub(all) enum MarkerDirection {
      Forward
      Backward
    } derive(Eq, 
    Debug    )

    Direction of playback when a marker window is traversed.

    MarkerHit

    source
    pub(all) struct MarkerHit {
      marker : MotionMarker
      direction : MarkerDirection
    } derive(
    Debug    )

    A marker together with the direction in which it was crossed.

    MarkerHit::direction

    source
    fn MarkerHit::direction(self : MarkerHit) -> MarkerDirection

    MarkerHit::marker

    source
    fn MarkerHit::marker(self : MarkerHit) -> MotionMarker

    MarkerHit::name

    source
    fn MarkerHit::name(self : MarkerHit) -> String

    MarkerHit::time

    source
    fn MarkerHit::time(self : MarkerHit) -> Double

    MarkerTimeline

    source
    pub struct MarkerTimeline {
      markers : Array[MotionMarker]
    } derive(
    Debug    )

    A sorted marker index for transport controls, editors, and event dispatch.

    MarkerTimeline::add

    source
    fn MarkerTimeline::add(self : MarkerTimeline, value : MotionMarker) -> Unit

    MarkerTimeline::at

    source
    fn MarkerTimeline::at(self : MarkerTimeline, time : Double, tolerance? : Double) -> Array[MotionMarker]

    MarkerTimeline::between

    source
    fn MarkerTimeline::between(self : MarkerTimeline, start : Double, end : Double) -> Array[MarkerHit]

    Return markers crossed while moving from start to end. The start boundary is excluded and the end boundary is included.

    MarkerTimeline::duration

    source
    fn MarkerTimeline::duration(self : MarkerTimeline) -> Double

    MarkerTimeline::empty

    source

    MarkerTimeline::find

    source
    fn MarkerTimeline::find(self : MarkerTimeline, name : String) -> Array[MotionMarker]

    MarkerTimeline::length

    source
    fn MarkerTimeline::length(self : MarkerTimeline) -> Int

    MarkerTimeline::markers

    source

    MarkerTimeline::new

    source

    MarkerTimeline::next_after

    source
    fn MarkerTimeline::next_after(self : MarkerTimeline, time : Double) -> MotionMarker?

    MarkerTimeline::previous_before

    source
    fn MarkerTimeline::previous_before(self : MarkerTimeline, time : Double) -> MotionMarker?

    MarkerTimeline::remove_at

    source
    fn MarkerTimeline::remove_at(self : MarkerTimeline, index : Int) -> MotionMarker?

    MarkerTimeline::window

    source
    fn MarkerTimeline::window(self : MarkerTimeline, start : Double, end : Double) -> Array[MarkerHit]

    Matrix4

    source
    pub(all) struct Matrix4 {
      m00 : Double
      m01 : Double
      m02 : Double
      m03 : Double
      m10 : Double
      m11 : Double
      m12 : Double
      m13 : Double
      m20 : Double
      m21 : Double
      m22 : Double
      m23 : Double
      m30 : Double
      m31 : Double
      m32 : Double
      m33 : Double
    } derive(
    Debug    )

    A 4x4 affine matrix stored in row-major order.

    Matrix4::from_quaternion

    source
    fn Matrix4::from_quaternion(value : Quaternion) -> Matrix4

    Matrix4::identity

    source
    fn Matrix4::identity() -> Matrix4

    Matrix4::multiply

    source
    fn Matrix4::multiply(self : Matrix4, other : Matrix4) -> Matrix4

    Matrix4::scale

    source
    fn Matrix4::scale(value : Point3) -> Matrix4

    Matrix4::transform_point

    source
    fn Matrix4::transform_point(self : Matrix4, value : Point3) -> Point3

    Matrix4::translation

    source
    fn Matrix4::translation(value : Point3) -> Matrix4

    MediaAsset2

    source
    pub struct MediaAsset2 {
      id : Int
      name : String
      kind : MediaKind2
      start : Double
      duration : Double
      bounds : Bounds2D
      tags : Array[String]
      enabled : Bool
    } derive(
    Debug    )

    MediaAsset2::active_at

    source
    fn MediaAsset2::active_at(self : MediaAsset2, time : Double) -> Bool

    MediaAsset2::bounds

    source
    fn MediaAsset2::bounds(self : MediaAsset2) -> Bounds2D

    MediaAsset2::duration

    source
    fn MediaAsset2::duration(self : MediaAsset2) -> Double

    MediaAsset2::enabled

    source
    fn MediaAsset2::enabled(self : MediaAsset2) -> Bool

    MediaAsset2::end

    source
    fn MediaAsset2::end(self : MediaAsset2) -> Double

    MediaAsset2::id

    source
    fn MediaAsset2::id(self : MediaAsset2) -> Int

    MediaAsset2::kind

    source
    fn MediaAsset2::kind(self : MediaAsset2) -> MediaKind2

    MediaAsset2::name

    source
    fn MediaAsset2::name(self : MediaAsset2) -> String

    MediaAsset2::start

    source
    fn MediaAsset2::start(self : MediaAsset2) -> Double

    MediaAsset2::tags

    source
    fn MediaAsset2::tags(self : MediaAsset2) -> Array[String]

    MediaAsset2::with_enabled

    source
    fn MediaAsset2::with_enabled(self : MediaAsset2, enabled : Bool) -> MediaAsset2

    MediaAsset2::with_tag

    source
    fn MediaAsset2::with_tag(self : MediaAsset2, tag : String) -> MediaAsset2

    MediaCatalog2

    source
    pub struct MediaCatalog2 {
      assets : Array[MediaAsset2]
      revision : Int
    } derive(
    Debug    )

    MediaCatalog2::active_at

    source
    fn MediaCatalog2::active_at(self : MediaCatalog2, time : Double) -> Array[MediaAsset2]

    MediaCatalog2::add

    source
    fn MediaCatalog2::add(self : MediaCatalog2, asset : MediaAsset2) -> Bool

    MediaCatalog2::assets

    source

    MediaCatalog2::bounds

    source
    fn MediaCatalog2::bounds(self : MediaCatalog2) -> Bounds2D

    MediaCatalog2::filter_kind

    source
    fn MediaCatalog2::filter_kind(self : MediaCatalog2, kind : MediaKind2) -> Array[MediaAsset2]

    MediaCatalog2::find

    source
    fn MediaCatalog2::find(self : MediaCatalog2, id : Int) -> MediaAsset2?

    MediaCatalog2::find_name

    source
    fn MediaCatalog2::find_name(self : MediaCatalog2, name : String) -> Array[MediaAsset2]

    MediaCatalog2::find_tag

    source
    fn MediaCatalog2::find_tag(self : MediaCatalog2, tag : String) -> Array[MediaAsset2]

    MediaCatalog2::length

    source
    fn MediaCatalog2::length(self : MediaCatalog2) -> Int

    MediaCatalog2::remove

    source
    fn MediaCatalog2::remove(self : MediaCatalog2, id : Int) -> Bool

    MediaCatalog2::replace

    source
    fn MediaCatalog2::replace(self : MediaCatalog2, asset : MediaAsset2) -> Bool

    MediaCatalog2::revision

    source
    fn MediaCatalog2::revision(self : MediaCatalog2) -> Int

    MediaCatalog2::shift

    source
    fn MediaCatalog2::shift(self : MediaCatalog2, delta : Double) -> MediaCatalog2

    MediaCatalog2::time_range

    source
    fn MediaCatalog2::time_range(self : MediaCatalog2) -> (Double, Double)

    MediaKind2

    source
    pub enum MediaKind2 {
      VectorAsset
      RasterAsset
      AudioAsset
      CameraAsset
      CompositeAsset
    } derive(
    Debug    )

    Lightweight asset descriptors for animation tools. The catalog deliberately stores no file handles; it can be serialized by a host application and reused for preview or final export.

    MotionBounds

    source
    pub struct MotionBounds {
      minimum : Double
      maximum : Double
    } derive(
    Debug    )

    Bounds used to keep generated motion within a safe output range.

    MotionBounds::clamp

    source
    fn MotionBounds::clamp(self : MotionBounds, value : Double) -> Double

    MotionBounds::maximum

    source
    fn MotionBounds::maximum(self : MotionBounds) -> Double

    MotionBounds::minimum

    source
    fn MotionBounds::minimum(self : MotionBounds) -> Double

    MotionBounds::new

    source
    fn MotionBounds::new(minimum : Double, maximum : Double) -> MotionBounds raise MotionError

    MotionBudget2

    source
    pub struct MotionBudget2 {
      maximum_speed : Double
      maximum_acceleration : Double
      maximum_path_length : Double
    } derive(
    Debug    )

    MotionBudget2::accepts

    source
    fn MotionBudget2::accepts(self : MotionBudget2, metrics : MotionMetrics2) -> Bool

    MotionBudget2::maximum_acceleration

    source
    fn MotionBudget2::maximum_acceleration(self : MotionBudget2) -> Double

    MotionBudget2::maximum_path_length

    source
    fn MotionBudget2::maximum_path_length(self : MotionBudget2) -> Double

    MotionBudget2::maximum_speed

    source
    fn MotionBudget2::maximum_speed(self : MotionBudget2) -> Double

    MotionBudget2::violations

    source
    fn MotionBudget2::violations(self : MotionBudget2, metrics : MotionMetrics2) -> Array[Double]

    MotionClip

    source
    pub struct MotionClip {
      name : String
      track : ScalarTrack
      markers : MarkerTimeline
      loop_mode : ClipLoopMode
    } derive(
    Debug    )

    A named, timestamped scalar motion clip with optional marker events.

    MotionClip::duration

    source
    fn MotionClip::duration(self : MotionClip) -> Double

    MotionClip::end_time

    source
    fn MotionClip::end_time(self : MotionClip) -> Double

    MotionClip::loop_mode

    source
    fn MotionClip::loop_mode(self : MotionClip) -> ClipLoopMode

    MotionClip::markers

    source
    fn MotionClip::markers(self : MotionClip) -> MarkerTimeline

    MotionClip::markers_between

    source
    fn MotionClip::markers_between(self : MotionClip, start : Double, end : Double) -> Array[MarkerHit]

    MotionClip::name

    source
    fn MotionClip::name(self : MotionClip) -> String

    MotionClip::sample

    source
    fn MotionClip::sample(self : MotionClip, time : Double) -> Double

    MotionClip::sample_many

    source
    fn MotionClip::sample_many(self : MotionClip, count : Int) -> Array[SamplePoint] raise MotionError

    MotionClip::sample_motion

    source
    fn MotionClip::sample_motion(self : MotionClip, time : Double) -> MotionSample

    MotionClip::scale_time

    source
    fn MotionClip::scale_time(self : MotionClip, factor : Double) -> MotionClip raise MotionError

    MotionClip::shift

    source
    fn MotionClip::shift(self : MotionClip, offset : Double) -> MotionClip raise MotionError

    MotionClip::start_time

    source
    fn MotionClip::start_time(self : MotionClip) -> Double

    MotionClip::track

    source
    fn MotionClip::track(self : MotionClip) -> ScalarTrack

    MotionClip::with_loop_mode

    source
    fn MotionClip::with_loop_mode(self : MotionClip, loop_mode : ClipLoopMode) -> MotionClip

    MotionClip::with_markers

    source
    fn MotionClip::with_markers(self : MotionClip, markers : MarkerTimeline) -> MotionClip

    MotionClipLibrary

    source
    pub struct MotionClipLibrary {
      clips : Array[MotionClip]
    } derive(
    Debug    )

    A small library for resolving named clips at runtime.

    MotionClipLibrary::add

    source
    fn MotionClipLibrary::add(self : MotionClipLibrary, clip : MotionClip) -> Unit

    MotionClipLibrary::clips

    source

    MotionClipLibrary::find

    source
    fn MotionClipLibrary::find(self : MotionClipLibrary, name : String) -> MotionClip?

    MotionClipLibrary::length

    source
    fn MotionClipLibrary::length(self : MotionClipLibrary) -> Int

    MotionClipLibrary::new

    source

    MotionClipLibrary::remove

    source
    fn MotionClipLibrary::remove(self : MotionClipLibrary, name : String) -> MotionClip?

    MotionClipLibrary::total_duration

    source
    fn MotionClipLibrary::total_duration(self : MotionClipLibrary) -> Double

    MotionEvent2

    source
    pub struct MotionEvent2 {
      time : Double
      id : Int
      label : String
      kind : MotionEventKind2
      payload : Double
      consumed : Bool
    } derive(
    Debug    )

    MotionEvent2::consumed

    source
    fn MotionEvent2::consumed(self : MotionEvent2) -> Bool

    MotionEvent2::id

    source
    fn MotionEvent2::id(self : MotionEvent2) -> Int

    MotionEvent2::kind

    source

    MotionEvent2::label

    source
    fn MotionEvent2::label(self : MotionEvent2) -> String

    MotionEvent2::mark_consumed

    source
    fn MotionEvent2::mark_consumed(self : MotionEvent2) -> MotionEvent2

    MotionEvent2::payload

    source
    fn MotionEvent2::payload(self : MotionEvent2) -> Double

    MotionEvent2::time

    source
    fn MotionEvent2::time(self : MotionEvent2) -> Double

    MotionEventKind2

    source
    pub enum MotionEventKind2 {
      MarkerEvent
      TriggerEvent
      LoopEvent
      EnterEvent
      ExitEvent
    } derive(
    Debug    )

    Timestamped events for coordinating motion, audio, and render callbacks.

    MotionEventQueue2

    source
    pub struct MotionEventQueue2 {
      events : Array[MotionEvent2]
      cursor : Int
      last_time : Double
    } derive(
    Debug    )

    MotionEventQueue2::clear

    source
    fn MotionEventQueue2::clear(self : MotionEventQueue2) -> Unit

    MotionEventQueue2::cursor

    source
    fn MotionEventQueue2::cursor(self : MotionEventQueue2) -> Int

    MotionEventQueue2::events

    source

    MotionEventQueue2::length

    source
    fn MotionEventQueue2::length(self : MotionEventQueue2) -> Int

    MotionEventQueue2::peek

    source

    MotionEventQueue2::poll_until

    source
    fn MotionEventQueue2::poll_until(self : MotionEventQueue2, time : Double) -> Array[MotionEvent2]

    MotionEventQueue2::poll_window

    source
    fn MotionEventQueue2::poll_window(self : MotionEventQueue2, start : Double, end : Double) -> Array[MotionEvent2]

    MotionEventQueue2::push

    source
    fn MotionEventQueue2::push(self : MotionEventQueue2, event : MotionEvent2) -> Unit

    MotionEventQueue2::push_many

    source
    fn MotionEventQueue2::push_many(self : MotionEventQueue2, events : Array[MotionEvent2]) -> Unit

    MotionEventQueue2::reset

    source
    fn MotionEventQueue2::reset(self : MotionEventQueue2, time : Double) -> Unit

    MotionLimitProfile2

    source
    pub struct MotionLimitProfile2 {
      maximum_velocity : Double
      maximum_acceleration : Double
      maximum_jerk : Double
      tolerance : Double
      iterations : Int
    } derive(
    Debug    )

    Limits for production motion sampling. The profile is independent of a solver so the same policy can be used for preview, export, and validation.

    MotionLimitProfile2::iterations

    source
    fn MotionLimitProfile2::iterations(self : MotionLimitProfile2) -> Int

    MotionLimitProfile2::maximum_acceleration

    source
    fn MotionLimitProfile2::maximum_acceleration(self : MotionLimitProfile2) -> Double

    MotionLimitProfile2::maximum_jerk

    source
    fn MotionLimitProfile2::maximum_jerk(self : MotionLimitProfile2) -> Double

    MotionLimitProfile2::maximum_velocity

    source
    fn MotionLimitProfile2::maximum_velocity(self : MotionLimitProfile2) -> Double

    MotionLimitProfile2::tolerance

    source
    fn MotionLimitProfile2::tolerance(self : MotionLimitProfile2) -> Double

    MotionMarker

    source
    pub struct MotionMarker {
      time : Double
      name : String
      payload : String
    } derive(
    Debug    )

    A named event attached to a motion timeline.

    MotionMarker::name

    source
    fn MotionMarker::name(self : MotionMarker) -> String

    MotionMarker::payload

    source
    fn MotionMarker::payload(self : MotionMarker) -> String

    MotionMarker::time

    source
    fn MotionMarker::time(self : MotionMarker) -> Double

    MotionMetrics2

    source
    pub struct MotionMetrics2 {
      path_length : Double
      peak_speed : Double
      peak_acceleration : Double
      average_speed : Double
      settled_time : Double
      samples : Int
    } derive(
    Debug    )

    Production-facing motion metrics used to compare export candidates.

    MotionMetrics2::average_speed

    source
    fn MotionMetrics2::average_speed(self : MotionMetrics2) -> Double

    MotionMetrics2::path_length

    source
    fn MotionMetrics2::path_length(self : MotionMetrics2) -> Double

    MotionMetrics2::peak_acceleration

    source
    fn MotionMetrics2::peak_acceleration(self : MotionMetrics2) -> Double

    MotionMetrics2::peak_speed

    source
    fn MotionMetrics2::peak_speed(self : MotionMetrics2) -> Double

    MotionMetrics2::samples

    source
    fn MotionMetrics2::samples(self : MotionMetrics2) -> Int

    MotionMetrics2::settled_time

    source
    fn MotionMetrics2::settled_time(self : MotionMetrics2) -> Double

    MotionReport2

    source
    pub struct MotionReport2 {
      name : String
      metrics : Array[Double]
      budget : MotionBudget2
      quality : RenderQualityMetrics2
      passed : Bool
    } derive(
    Debug    )

    Human-readable metrics are kept as typed records so dashboards and CI can consume the same result without parsing log text.

    MotionReport2::budget

    source

    MotionReport2::budget_score

    source
    fn MotionReport2::budget_score(self : MotionReport2) -> Double

    MotionReport2::budget_violations

    source
    fn MotionReport2::budget_violations(self : MotionReport2) -> Array[Double]

    MotionReport2::complete

    source
    fn MotionReport2::complete(self : MotionReport2) -> Bool

    MotionReport2::coverage_gap

    source
    fn MotionReport2::coverage_gap(self : MotionReport2) -> Double

    MotionReport2::coverage_ok

    source
    fn MotionReport2::coverage_ok(self : MotionReport2) -> Bool

    MotionReport2::error_budget

    source
    fn MotionReport2::error_budget(self : MotionReport2) -> Double

    MotionReport2::export_score

    source
    fn MotionReport2::export_score(self : MotionReport2) -> Double

    MotionReport2::has_frames

    source
    fn MotionReport2::has_frames(self : MotionReport2) -> Bool

    MotionReport2::has_motion_violation

    source
    fn MotionReport2::has_motion_violation(self : MotionReport2) -> Bool

    MotionReport2::is_actionable

    source
    fn MotionReport2::is_actionable(self : MotionReport2) -> Bool

    MotionReport2::meets_all_budgets

    source
    fn MotionReport2::meets_all_budgets(self : MotionReport2) -> Bool

    MotionReport2::merge

    source

    MotionReport2::metric

    source
    fn MotionReport2::metric(self : MotionReport2, index : Int) -> Double

    MotionReport2::metric_average

    source
    fn MotionReport2::metric_average(self : MotionReport2) -> Double

    MotionReport2::metric_count

    source
    fn MotionReport2::metric_count(self : MotionReport2) -> Int

    MotionReport2::metric_sum

    source
    fn MotionReport2::metric_sum(self : MotionReport2) -> Double

    MotionReport2::metrics

    source
    fn MotionReport2::metrics(self : MotionReport2) -> Array[Double]

    MotionReport2::name

    source
    fn MotionReport2::name(self : MotionReport2) -> String

    MotionReport2::needs_review

    source
    fn MotionReport2::needs_review(self : MotionReport2) -> Bool

    MotionReport2::passed

    source
    fn MotionReport2::passed(self : MotionReport2) -> Bool

    MotionReport2::quality

    source

    MotionReport2::quality_coverage

    source
    fn MotionReport2::quality_coverage(self : MotionReport2) -> Double

    MotionReport2::quality_error

    source
    fn MotionReport2::quality_error(self : MotionReport2) -> Double

    MotionReport2::quality_passed

    source
    fn MotionReport2::quality_passed(self : MotionReport2) -> Bool

    MotionReport2::quality_score

    source
    fn MotionReport2::quality_score(self : MotionReport2) -> Double

    MotionReport2::ready_for_export

    source
    fn MotionReport2::ready_for_export(self : MotionReport2) -> Bool

    MotionReport2::score

    source
    fn MotionReport2::score(self : MotionReport2) -> Double

    MotionReport2::stable

    source
    fn MotionReport2::stable(self : MotionReport2) -> Bool

    MotionReport2::status_code

    source
    fn MotionReport2::status_code(self : MotionReport2) -> Int

    MotionReport2::summary_score

    source
    fn MotionReport2::summary_score(self : MotionReport2) -> Double

    MotionReport2::valid

    source
    fn MotionReport2::valid(self : MotionReport2) -> Bool

    MotionReport2::weighted_score

    source
    fn MotionReport2::weighted_score(self : MotionReport2, motion_weight : Double) -> Double

    MotionSample

    source
    pub(all) struct MotionSample {
      time : Double
      value : Double
      velocity : Double
      acceleration : Double
    } derive(
    Debug    )

    A compact sample of a scalar motion function.

    MotionSample::acceleration

    source
    fn MotionSample::acceleration(self : MotionSample) -> Double

    MotionSample::value

    source
    fn MotionSample::value(self : MotionSample) -> Double

    MotionSample::velocity

    source
    fn MotionSample::velocity(self : MotionSample) -> Double

    MotionSignal

    source
    pub struct MotionSignal {
      values : Array[Double]
      start : Double
      step : Double
    } derive(
    Debug    )

    A lightweight signal buffer for post-processing sampled motion data.

    MotionSignal::at

    source
    fn MotionSignal::at(self : MotionSignal, index : Int) -> Double?

    MotionSignal::clamp

    source
    fn MotionSignal::clamp(self : MotionSignal, minimum : Double, maximum : Double) -> MotionSignal

    MotionSignal::duration

    source
    fn MotionSignal::duration(self : MotionSignal) -> Double

    MotionSignal::end

    source
    fn MotionSignal::end(self : MotionSignal) -> Double

    MotionSignal::length

    source
    fn MotionSignal::length(self : MotionSignal) -> Int

    MotionSignal::map

    source
    fn MotionSignal::map(self : MotionSignal, func : (Double) -> Double) -> MotionSignal

    MotionSignal::new

    source
    fn MotionSignal::new(values : Array[Double], start : Double, step : Double) -> MotionSignal raise MotionError

    MotionSignal::offset

    source
    fn MotionSignal::offset(self : MotionSignal, amount : Double) -> MotionSignal

    MotionSignal::reverse

    source
    fn MotionSignal::reverse(self : MotionSignal) -> MotionSignal

    MotionSignal::sample

    source
    fn MotionSignal::sample(self : MotionSignal, time : Double) -> Double

    MotionSignal::sample_many

    source
    fn MotionSignal::sample_many(self : MotionSignal, count : Int) -> Array[SamplePoint] raise MotionError

    MotionSignal::scale

    source
    fn MotionSignal::scale(self : MotionSignal, factor : Double) -> MotionSignal

    MotionSignal::start

    source
    fn MotionSignal::start(self : MotionSignal) -> Double

    MotionSignal::step

    source
    fn MotionSignal::step(self : MotionSignal) -> Double

    MotionSignal::values

    source
    fn MotionSignal::values(self : MotionSignal) -> Array[Double]

    MotionSignal::zip_map

    source
    fn MotionSignal::zip_map(self : MotionSignal, other : MotionSignal, func : (Double, Double) -> Double) -> MotionSignal

    MotionStateMachine

    source
    pub struct MotionStateMachine {
      states : Array[MotionStateNode]
      transitions : Array[MotionStateTransition]
      current : String
      transition_from : String
      transition_to : String
      transition_start : Double
      transition_duration : Double
      transition_curve : Curve
      has_transition : Bool
    } derive(
    Debug    )

    A transition engine with explicit transport time. State changes are deterministic and do not allocate per sample.

    MotionStateMachine::add_state

    source
    fn MotionStateMachine::add_state(self : MotionStateMachine, state : MotionStateNode) -> Unit raise MotionError

    MotionStateMachine::add_transition

    source
    fn MotionStateMachine::add_transition(self : MotionStateMachine, transition : MotionStateTransition) -> Unit raise MotionError

    MotionStateMachine::complete

    source
    fn MotionStateMachine::complete(self : MotionStateMachine) -> Unit

    MotionStateMachine::current

    source
    fn MotionStateMachine::current(self : MotionStateMachine) -> String

    MotionStateMachine::has_state

    source
    fn MotionStateMachine::has_state(self : MotionStateMachine, name : String) -> Bool

    MotionStateMachine::is_transitioning

    source
    fn MotionStateMachine::is_transitioning(self : MotionStateMachine) -> Bool

    MotionStateMachine::new

    source
    fn MotionStateMachine::new(states : Array[MotionStateNode], transitions? : Array[MotionStateTransition], initial? : String) -> MotionStateMachine raise MotionError

    MotionStateMachine::reset

    source
    fn MotionStateMachine::reset(self : MotionStateMachine, state? : String) -> Unit raise MotionError

    MotionStateMachine::sample

    source
    fn MotionStateMachine::sample(self : MotionStateMachine, now : Double) -> Double

    MotionStateMachine::sample_motion

    source
    fn MotionStateMachine::sample_motion(self : MotionStateMachine, now : Double) -> MotionSample

    MotionStateMachine::state_value

    source
    fn MotionStateMachine::state_value(self : MotionStateMachine, name : String) -> Double?

    MotionStateMachine::states

    source

    MotionStateMachine::transition_to

    source
    fn MotionStateMachine::transition_to(self : MotionStateMachine, target : String, now : Double, duration? : Double, curve? : Curve) -> Unit raise MotionError

    Start a transition at an arbitrary transport timestamp.

    MotionStateMachine::transitions

    source

    MotionStateNode

    source
    pub struct MotionStateNode {
      name : String
      value : Double
    } derive(
    Debug    )

    A named scalar state used to model interaction modes and animation poses.

    MotionStateNode::name

    source
    fn MotionStateNode::name(self : MotionStateNode) -> String

    MotionStateNode::value

    source
    fn MotionStateNode::value(self : MotionStateNode) -> Double

    MotionStateTransition

    source
    pub struct MotionStateTransition {
      from : String
      to : String
      duration : Double
      curve : Curve
    } derive(
    Debug    )

    A directed transition between two named motion states.

    MotionStateTransition::curve

    source

    MotionStateTransition::duration

    source
    fn MotionStateTransition::duration(self : MotionStateTransition) -> Double

    MotionStateTransition::from

    source
    fn MotionStateTransition::from(self : MotionStateTransition) -> String

    MotionStateTransition::to

    source

    MotionTransport

    source
    pub struct MotionTransport {
      position : Double
      speed : Double
      status : TransportStatus
      direction : PlaybackDirection
      range : TransportRange
      markers : MarkerTimeline
    } derive(
    Debug    )

    A stateful transport clock for preview, timeline scrubbing, and export.

    MotionTransport::advance

    source
    fn MotionTransport::advance(self : MotionTransport, delta_seconds : Double) -> Array[MarkerHit] raise MotionError

    Advance the clock and return markers crossed by this step.

    MotionTransport::clone_at

    source
    fn MotionTransport::clone_at(self : MotionTransport, position : Double) -> MotionTransport

    MotionTransport::direction

    source

    MotionTransport::elapsed

    source
    fn MotionTransport::elapsed(self : MotionTransport) -> Double

    MotionTransport::fast_forward

    source
    fn MotionTransport::fast_forward(self : MotionTransport) -> Unit

    MotionTransport::is_at_boundary

    source
    fn MotionTransport::is_at_boundary(self : MotionTransport) -> Bool

    MotionTransport::markers

    source

    MotionTransport::new

    source

    MotionTransport::normalized_position

    source
    fn MotionTransport::normalized_position(self : MotionTransport) -> Double

    MotionTransport::pause

    source
    fn MotionTransport::pause(self : MotionTransport) -> Unit

    MotionTransport::play

    source
    fn MotionTransport::play(self : MotionTransport) -> Unit

    MotionTransport::position

    source
    fn MotionTransport::position(self : MotionTransport) -> Double

    MotionTransport::range

    source

    MotionTransport::remaining

    source
    fn MotionTransport::remaining(self : MotionTransport) -> Double

    MotionTransport::rewind

    source
    fn MotionTransport::rewind(self : MotionTransport) -> Unit

    MotionTransport::seek

    source
    fn MotionTransport::seek(self : MotionTransport, position : Double) -> Unit raise MotionError

    MotionTransport::seek_and_collect

    source
    fn MotionTransport::seek_and_collect(self : MotionTransport, position : Double) -> Array[MarkerHit] raise MotionError

    MotionTransport::set_direction

    source
    fn MotionTransport::set_direction(self : MotionTransport, direction : PlaybackDirection) -> Unit

    MotionTransport::set_speed

    source
    fn MotionTransport::set_speed(self : MotionTransport, speed : Double) -> Unit raise MotionError

    MotionTransport::speed

    source
    fn MotionTransport::speed(self : MotionTransport) -> Double

    MotionTransport::status

    source

    MotionTransport::stop

    source
    fn MotionTransport::stop(self : MotionTransport) -> Unit

    NoiseSource2

    source
    pub struct NoiseSource2 {
      seed : Int
      frequency : Double
      octaves : Int
      persistence : Double
      lacunarity : Double
    } derive(
    Debug    )

    Deterministic procedural motion primitives. They are seeded explicitly so a preview and a final export produce identical camera shake and particles.

    NoiseSource2::fractal

    source
    fn NoiseSource2::fractal(self : NoiseSource2, x : Double, y : Double) -> Double

    NoiseSource2::frequency

    source
    fn NoiseSource2::frequency(self : NoiseSource2) -> Double

    NoiseSource2::gradient

    source
    fn NoiseSource2::gradient(self : NoiseSource2, x : Double, y : Double, epsilon? : Double) -> Point2

    NoiseSource2::octaves

    source
    fn NoiseSource2::octaves(self : NoiseSource2) -> Int

    NoiseSource2::sample_many

    source
    fn NoiseSource2::sample_many(self : NoiseSource2, count : Int, x : Double, y : Double, step : Double) -> Array[Double]

    NoiseSource2::seed

    source
    fn NoiseSource2::seed(self : NoiseSource2) -> Int

    NoiseSource2::value

    source
    fn NoiseSource2::value(self : NoiseSource2, x : Double, y : Double) -> Double

    NoiseSource2::with_frequency

    source
    fn NoiseSource2::with_frequency(self : NoiseSource2, frequency : Double) -> NoiseSource2

    NoiseSource2::with_lacunarity

    source
    fn NoiseSource2::with_lacunarity(self : NoiseSource2, lacunarity : Double) -> NoiseSource2

    NoiseSource2::with_octaves

    source
    fn NoiseSource2::with_octaves(self : NoiseSource2, octaves : Int) -> NoiseSource2

    NoiseSource2::with_persistence

    source
    fn NoiseSource2::with_persistence(self : NoiseSource2, persistence : Double) -> NoiseSource2

    Palette2

    source
    pub struct Palette2 {
      colors : Array[Rgba]
      name : String
    } derive(
    Debug    )

    Palette utilities for animated gradients, posterized effects, and export previews.

    Palette2::colors

    source
    fn Palette2::colors(self : Palette2) -> Array[Rgba]

    Palette2::length

    source
    fn Palette2::length(self : Palette2) -> Int

    Palette2::lerp

    source
    fn Palette2::lerp(self : Palette2, other : Palette2, ratio : Double) -> Palette2

    Palette2::map

    source
    fn Palette2::map(self : Palette2, mapper : (Rgba) -> Rgba) -> Palette2

    Palette2::name

    source
    fn Palette2::name(self : Palette2) -> String

    Palette2::nearest

    source
    fn Palette2::nearest(self : Palette2, color : Rgba) -> Rgba

    Palette2::quantize

    source
    fn Palette2::quantize(self : Palette2, color : Rgba) -> PaletteQuantization2

    Palette2::reverse

    source
    fn Palette2::reverse(self : Palette2) -> Palette2

    Palette2::sample

    source
    fn Palette2::sample(self : Palette2, ratio : Double) -> Rgba

    Palette2::with_alpha

    source
    fn Palette2::with_alpha(self : Palette2, alpha : Double) -> Palette2

    PaletteQuantization2

    source
    pub struct PaletteQuantization2 {
      index : Int
      color : Rgba
      error : Double
    } derive(
    Debug    )

    PaletteQuantization2::color

    source

    PaletteQuantization2::error

    source
    fn PaletteQuantization2::error(self : PaletteQuantization2) -> Double

    PaletteQuantization2::index

    source

    Path2D

    source
    pub struct Path2D {
      segments : Array[PathSegment2D]
      lengths : Array[Double]
      total_length : Double
    } derive(
    Debug    )

    A length-indexed composition of line and cubic path segments.

    Path2D::append

    source
    fn Path2D::append(self : Path2D, segment : PathSegment2D, samples_per_curve? : Int) -> Path2D raise MotionError

    Path2D::bounds

    source
    fn Path2D::bounds(self : Path2D, samples_per_curve? : Int) -> Bounds2D

    Path2D::end

    source
    fn Path2D::end(self : Path2D) -> Point2

    Path2D::length

    source
    fn Path2D::length(self : Path2D) -> Int

    Path2D::new

    source
    fn Path2D::new(segments : Array[PathSegment2D], samples_per_curve? : Int) -> Path2D raise MotionError

    Path2D::polyline

    source
    fn Path2D::polyline(self : Path2D, samples_per_segment : Int) -> Array[Point2]

    Path2D::project

    source
    fn Path2D::project(self : Path2D, target : Point2, samples_per_segment? : Int) -> SplineProjection

    Approximate the nearest point by scanning each segment's polyline.

    Path2D::sample

    source
    fn Path2D::sample(self : Path2D, parameter : Double) -> Point2

    Path2D::sample_by_distance

    source
    fn Path2D::sample_by_distance(self : Path2D, distance : Double) -> Point2

    Path2D::segments

    source
    fn Path2D::segments(self : Path2D) -> Array[PathSegment2D]

    Path2D::start

    source
    fn Path2D::start(self : Path2D) -> Point2

    Path2D::tangent

    source
    fn Path2D::tangent(self : Path2D, parameter : Double) -> Point2

    Path2D::total_length

    source
    fn Path2D::total_length(self : Path2D) -> Double

    Path2DMetric2

    source
    pub struct Path2DMetric2 {
      length : Double
      bounds : Bounds2D
      samples : Array[Point2]
      average_speed : Double
      chord_error : Double
    } derive(
    Debug    )

    Higher-level operations for 2D rails and masks.

    Path2DMetric2::average_speed

    source
    fn Path2DMetric2::average_speed(self : Path2DMetric2) -> Double

    Path2DMetric2::bounds

    source
    fn Path2DMetric2::bounds(self : Path2DMetric2) -> Bounds2D

    Path2DMetric2::chord_error

    source
    fn Path2DMetric2::chord_error(self : Path2DMetric2) -> Double

    Path2DMetric2::length

    source
    fn Path2DMetric2::length(self : Path2DMetric2) -> Double

    Path2DMetric2::samples

    source
    fn Path2DMetric2::samples(self : Path2DMetric2) -> Array[Point2]

    Path3D

    source
    pub struct Path3D {
      segments : Array[PathSegment3D]
      lengths : Array[Double]
      total_length : Double
    } derive(
    Debug    )

    Path3D::append

    source
    fn Path3D::append(self : Path3D, segment : PathSegment3D) -> Path3D raise MotionError

    Path3D::bounds

    source
    fn Path3D::bounds(self : Path3D, samples_per_segment? : Int) -> Bounds3D

    Path3D::curvature

    source
    fn Path3D::curvature(self : Path3D, parameter : Double) -> Double

    Path3D::end

    source
    fn Path3D::end(self : Path3D) -> Point3

    Path3D::length

    source
    fn Path3D::length(self : Path3D) -> Int

    Path3D::new

    source
    fn Path3D::new(segments : Array[PathSegment3D], samples_per_curve? : Int) -> Path3D raise MotionError

    Path3D::polyline

    source
    fn Path3D::polyline(self : Path3D, samples_per_segment : Int) -> Array[Point3]

    Path3D::project

    source
    fn Path3D::project(self : Path3D, target : Point3, samples_per_segment? : Int) -> PathProjection3D

    Path3D::reversed

    source
    fn Path3D::reversed(self : Path3D) -> Path3D raise MotionError

    Path3D::sample

    source
    fn Path3D::sample(self : Path3D, parameter : Double) -> Point3

    Path3D::sample_by_distance

    source
    fn Path3D::sample_by_distance(self : Path3D, distance : Double) -> Point3

    Path3D::sample_many

    source
    fn Path3D::sample_many(self : Path3D, count : Int) -> Array[Point3] raise MotionError

    Path3D::segments

    source
    fn Path3D::segments(self : Path3D) -> Array[PathSegment3D]

    Path3D::start

    source
    fn Path3D::start(self : Path3D) -> Point3

    Path3D::tangent

    source
    fn Path3D::tangent(self : Path3D, parameter : Double) -> Point3

    Path3D::total_length

    source
    fn Path3D::total_length(self : Path3D) -> Double

    PathBuilder2D

    source
    pub struct PathBuilder2D {
      current : Point2
      segments : Array[PathSegment2D]
    } derive(
    Debug    )

    Builder for paths constructed from a start point and successive endpoints.

    PathBuilder2D::build

    source
    fn PathBuilder2D::build(self : PathBuilder2D, samples_per_curve? : Int) -> Path2D raise MotionError

    PathBuilder2D::close

    source
    fn PathBuilder2D::close(self : PathBuilder2D) -> Unit

    PathBuilder2D::cubic_to

    source
    fn PathBuilder2D::cubic_to(self : PathBuilder2D, control_start : Point2, control_end : Point2, end : Point2) -> Unit

    PathBuilder2D::current

    source
    fn PathBuilder2D::current(self : PathBuilder2D) -> Point2

    PathBuilder2D::length

    source
    fn PathBuilder2D::length(self : PathBuilder2D) -> Int

    PathBuilder2D::line_to

    source
    fn PathBuilder2D::line_to(self : PathBuilder2D, end : Point2) -> Unit

    PathBuilder3D

    source
    pub struct PathBuilder3D {
      current : Point3
      segments : Array[PathSegment3D]
    } derive(
    Debug    )

    PathBuilder3D::build

    source
    fn PathBuilder3D::build(self : PathBuilder3D, samples_per_curve? : Int) -> Path3D raise MotionError

    PathBuilder3D::close

    source
    fn PathBuilder3D::close(self : PathBuilder3D) -> Unit

    PathBuilder3D::cubic_to

    source
    fn PathBuilder3D::cubic_to(self : PathBuilder3D, control_start : Point3, control_end : Point3, end : Point3) -> Unit

    PathBuilder3D::current

    source
    fn PathBuilder3D::current(self : PathBuilder3D) -> Point3

    PathBuilder3D::line_to

    source
    fn PathBuilder3D::line_to(self : PathBuilder3D, end : Point3) -> Unit

    PathFrame3D

    source
    pub struct PathFrame3D {
      position : Point3
      tangent : Point3
      normal : Point3
      binormal : Point3
    } derive(
    Debug    )

    PathFrame3D::binormal

    source
    fn PathFrame3D::binormal(self : PathFrame3D) -> Point3

    PathFrame3D::look_target

    source
    fn PathFrame3D::look_target(self : PathFrame3D, distance : Double) -> Point3

    PathFrame3D::normal

    source
    fn PathFrame3D::normal(self : PathFrame3D) -> Point3

    PathFrame3D::offset

    source
    fn PathFrame3D::offset(self : PathFrame3D, horizontal : Double, vertical : Double) -> Point3

    PathFrame3D::position

    source
    fn PathFrame3D::position(self : PathFrame3D) -> Point3

    PathFrame3D::tangent

    source
    fn PathFrame3D::tangent(self : PathFrame3D) -> Point3

    PathMetricProfile3D

    source
    pub struct PathMetricProfile3D {
      samples : Array[PathSample3D]
      total_length : Double
      maximum_curvature : Double
      average_curvature : Double
    } derive(
    Debug    )

    PathMetricProfile3D::average_curvature

    source
    fn PathMetricProfile3D::average_curvature(self : PathMetricProfile3D) -> Double

    PathMetricProfile3D::max_speed

    source
    fn PathMetricProfile3D::max_speed(self : PathMetricProfile3D) -> Double

    PathMetricProfile3D::maximum_curvature

    source
    fn PathMetricProfile3D::maximum_curvature(self : PathMetricProfile3D) -> Double

    PathMetricProfile3D::sample

    source
    fn PathMetricProfile3D::sample(self : PathMetricProfile3D, parameter : Double) -> PathSample3D

    PathMetricProfile3D::samples

    source

    PathMetricProfile3D::total_length

    source
    fn PathMetricProfile3D::total_length(self : PathMetricProfile3D) -> Double

    PathProjection3D

    source
    pub struct PathProjection3D {
      parameter : Double
      distance : Double
      value : Point3
      error : Double
    } derive(
    Debug    )

    PathProjection3D::distance

    source
    fn PathProjection3D::distance(self : PathProjection3D) -> Double

    PathProjection3D::error

    source
    fn PathProjection3D::error(self : PathProjection3D) -> Double

    PathProjection3D::parameter

    source
    fn PathProjection3D::parameter(self : PathProjection3D) -> Double

    PathProjection3D::value

    source

    PathSample3D

    source
    pub struct PathSample3D {
      parameter : Double
      distance : Double
      position : Point3
      tangent : Point3
      normal : Point3
      curvature : Double
    } derive(
    Debug    )

    Differential samples for camera rails and particle emitters.

    PathSample3D::curvature

    source
    fn PathSample3D::curvature(self : PathSample3D) -> Double

    PathSample3D::distance

    source
    fn PathSample3D::distance(self : PathSample3D) -> Double

    PathSample3D::normal

    source
    fn PathSample3D::normal(self : PathSample3D) -> Point3

    PathSample3D::parameter

    source
    fn PathSample3D::parameter(self : PathSample3D) -> Double

    PathSample3D::position

    source
    fn PathSample3D::position(self : PathSample3D) -> Point3

    PathSample3D::tangent

    source
    fn PathSample3D::tangent(self : PathSample3D) -> Point3

    PathSegment2D

    source
    pub(all) enum PathSegment2D {
      Line(Point2, Point2)
      Cubic(CubicPath2D)
    } derive(
    Debug    )

    Geometric segment types that can be composed into a renderable path.

    PathSegment2D::bounds

    source
    fn PathSegment2D::bounds(self : PathSegment2D, samples? : Int) -> Bounds2D

    PathSegment2D::polyline

    source
    fn PathSegment2D::polyline(self : PathSegment2D, samples : Int) -> Array[Point2]

    PathSegment3D

    source
    pub enum PathSegment3D {
      Line3D(Point3, Point3)
      Cubic3D(CubicPath3D)
    } derive(
    Debug    )

    PathSegment3D::curvature

    source
    fn PathSegment3D::curvature(self : PathSegment3D, ratio : Double) -> Double

    PathSegment3D::end

    source

    PathSegment3D::length

    source
    fn PathSegment3D::length(self : PathSegment3D, samples : Int) -> Double

    PathSegment3D::polyline

    source
    fn PathSegment3D::polyline(self : PathSegment3D, samples : Int) -> Array[Point3]

    PathSegment3D::sample

    source
    fn PathSegment3D::sample(self : PathSegment3D, ratio : Double) -> Point3

    PathSegment3D::start

    source
    fn PathSegment3D::start(self : PathSegment3D) -> Point3

    PathSegment3D::tangent

    source
    fn PathSegment3D::tangent(self : PathSegment3D, ratio : Double) -> Point3

    PlaybackDirection

    source
    pub(all) enum PlaybackDirection {
      Forward
      Reverse
    } derive(Eq, 
    Debug    )

    Direction of a transport clock.

    Point2

    source
    pub(all) struct Point2 {
      x : Double
      y : Double
    } derive(
    Debug    )

    Two-dimensional point for UI and 2D media transforms.

    Point2::distance

    source
    fn Point2::distance(self : Point2, other : Point2) -> Double

    Point2::lerp

    source
    fn Point2::lerp(self : Point2, other : Point2, t : Double) -> Point2

    Point2::x

    source
    fn Point2::x(self : Point2) -> Double

    Point2::y

    source
    fn Point2::y(self : Point2) -> Double

    Point2BlendLayer

    source
    pub struct Point2BlendLayer {
      value : Point2
      weight : Double
      mode : LayerBlendMode
      priority : Int
    } derive(
    Debug    )

    Point2BlendLayer::mode

    source

    Point2BlendLayer::priority

    source
    fn Point2BlendLayer::priority(self : Point2BlendLayer) -> Int

    Point2BlendLayer::value

    source

    Point2BlendLayer::weight

    source
    fn Point2BlendLayer::weight(self : Point2BlendLayer) -> Double

    Point2ConstraintResult

    source
    pub struct Point2ConstraintResult {
      value : Point2
      velocity : Point2
      acceleration : Point2
      status : ConstraintStatus2
      error : Double
    } derive(
    Debug    )

    Point2ConstraintResult::acceleration

    source

    Point2ConstraintResult::error

    source

    Point2ConstraintResult::status

    source

    Point2ConstraintResult::value

    source

    Point2ConstraintResult::velocity

    source

    Point2Keyframe

    source
    pub struct Point2Keyframe {
      time : Double
      value : Point2
      curve : Curve
    } derive(
    Debug    )

    A point keyframe for UI, camera, and sprite motion tracks.

    Point2Keyframe::curve

    source
    fn Point2Keyframe::curve(self : Point2Keyframe) -> Curve

    Point2Keyframe::time

    source
    fn Point2Keyframe::time(self : Point2Keyframe) -> Double

    Point2Keyframe::value

    source
    fn Point2Keyframe::value(self : Point2Keyframe) -> Point2

    Point2Track

    source
    pub struct Point2Track {
      frames : Array[Point2Keyframe]
    } derive(
    Debug    )

    A validated 2D point track with the same boundary policies as ScalarTrack.

    Point2Track::duration

    source
    fn Point2Track::duration(self : Point2Track) -> Double

    Point2Track::end_time

    source
    fn Point2Track::end_time(self : Point2Track) -> Double

    Point2Track::keyframes

    source
    fn Point2Track::keyframes(self : Point2Track) -> Array[Point2Keyframe]

    Point2Track::length

    source
    fn Point2Track::length(self : Point2Track) -> Int

    Point2Track::new

    source

    Point2Track::sample

    source
    fn Point2Track::sample(self : Point2Track, time : Double, mode? : Extrapolation) -> Point2

    Point2Track::sample_many

    source
    fn Point2Track::sample_many(self : Point2Track, count : Int, mode? : Extrapolation) -> Array[Point2] raise MotionError

    Point2Track::start_time

    source
    fn Point2Track::start_time(self : Point2Track) -> Double

    Point3

    source
    pub(all) struct Point3 {
      x : Double
      y : Double
      z : Double
    } derive(
    Debug    )

    Three-dimensional point for camera, scene, and 3D keyframe data.

    Point3::lerp

    source
    fn Point3::lerp(self : Point3, other : Point3, t : Double) -> Point3

    Point3::x

    source
    fn Point3::x(self : Point3) -> Double

    Point3::y

    source
    fn Point3::y(self : Point3) -> Double

    Point3::z

    source
    fn Point3::z(self : Point3) -> Double

    Point3BlendLayer

    source
    pub struct Point3BlendLayer {
      value : Point3
      weight : Double
      mode : LayerBlendMode
      priority : Int
    } derive(
    Debug    )

    Point3BlendLayer::mode

    source

    Point3BlendLayer::priority

    source
    fn Point3BlendLayer::priority(self : Point3BlendLayer) -> Int

    Point3BlendLayer::value

    source

    Point3BlendLayer::weight

    source
    fn Point3BlendLayer::weight(self : Point3BlendLayer) -> Double

    Point3ConstraintResult

    source
    pub struct Point3ConstraintResult {
      value : Point3
      velocity : Point3
      acceleration : Point3
      status : ConstraintStatus2
      error : Double
    } derive(
    Debug    )

    Point3ConstraintResult::acceleration

    source

    Point3ConstraintResult::error

    source

    Point3ConstraintResult::status

    source

    Point3ConstraintResult::value

    source

    Point3ConstraintResult::velocity

    source

    Point3Keyframe

    source
    pub struct Point3Keyframe {
      time : Double
      value : Point3
      curve : Curve
    } derive(
    Debug    )

    A 3D keyframe for camera and scene transforms.

    Point3Keyframe::curve

    source
    fn Point3Keyframe::curve(self : Point3Keyframe) -> Curve

    Point3Keyframe::time

    source
    fn Point3Keyframe::time(self : Point3Keyframe) -> Double

    Point3Keyframe::value

    source
    fn Point3Keyframe::value(self : Point3Keyframe) -> Point3

    Point3Track

    source
    pub struct Point3Track {
      frames : Array[Point3Keyframe]
    } derive(
    Debug    )

    Point3Track::duration

    source
    fn Point3Track::duration(self : Point3Track) -> Double

    Point3Track::end_time

    source
    fn Point3Track::end_time(self : Point3Track) -> Double

    Point3Track::keyframes

    source
    fn Point3Track::keyframes(self : Point3Track) -> Array[Point3Keyframe]

    Point3Track::length

    source
    fn Point3Track::length(self : Point3Track) -> Int

    Point3Track::new

    source

    Point3Track::sample

    source
    fn Point3Track::sample(self : Point3Track, time : Double, mode? : Extrapolation) -> Point3

    Point3Track::sample_many

    source
    fn Point3Track::sample_many(self : Point3Track, count : Int, mode? : Extrapolation) -> Array[Point3] raise MotionError

    Point3Track::start_time

    source
    fn Point3Track::start_time(self : Point3Track) -> Double

    PointSampleCache2

    source
    pub struct PointSampleCache2 {
      key : SampleCacheKey2
      values : Array[Point2]
    } derive(
    Debug    )

    PointSampleCache2::key

    source

    PointSampleCache2::new

    source

    PointSampleCache2::sample

    source
    fn PointSampleCache2::sample(self : PointSampleCache2, time : Double) -> Point2

    PointSampleCache2::values

    source

    PointSeries2

    source
    pub struct PointSeries2 {
      times : Array[Double]
      values : Array[Point2]
    } derive(
    Debug    )

    PointSeries2::resample

    source
    fn PointSeries2::resample(self : PointSeries2, count : Int) -> PointSeries2

    PointSeries2::sample

    source
    fn PointSeries2::sample(self : PointSeries2, time : Double) -> Point2

    PointSeries2::speed

    source
    fn PointSeries2::speed(self : PointSeries2) -> Array[Double]

    PointSeries2::times

    source
    fn PointSeries2::times(self : PointSeries2) -> Array[Double]

    PointSeries2::values

    source
    fn PointSeries2::values(self : PointSeries2) -> Array[Point2]

    Polygon2D

    source
    pub struct Polygon2D {
      vertices : Array[Point2]
    } derive(
    Debug    )

    Polygon2D::area

    source
    fn Polygon2D::area(self : Polygon2D) -> Double

    Polygon2D::bounds

    source
    fn Polygon2D::bounds(self : Polygon2D) -> Bounds2D

    Polygon2D::centroid

    source
    fn Polygon2D::centroid(self : Polygon2D) -> Point2

    Polygon2D::clockwise

    source
    fn Polygon2D::clockwise(self : Polygon2D) -> Bool

    Polygon2D::contains

    source
    fn Polygon2D::contains(self : Polygon2D, point : Point2) -> Bool

    Polygon2D::length

    source
    fn Polygon2D::length(self : Polygon2D) -> Int

    Polygon2D::perimeter

    source
    fn Polygon2D::perimeter(self : Polygon2D) -> Double

    Polygon2D::reversed

    source
    fn Polygon2D::reversed(self : Polygon2D) -> Polygon2D

    Polygon2D::signed_area

    source
    fn Polygon2D::signed_area(self : Polygon2D) -> Double

    Polygon2D::vertices

    source
    fn Polygon2D::vertices(self : Polygon2D) -> Array[Point2]

    Polyline2D

    source
    pub struct Polyline2D {
      points : Array[Point2]
      closed : Bool
    } derive(
    Debug    )

    A mutable-free polyline view used by editors, masks, and path analysis.

    Polyline2D::bounds

    source
    fn Polyline2D::bounds(self : Polyline2D) -> Bounds2D

    Polyline2D::closed

    source
    fn Polyline2D::closed(self : Polyline2D) -> Bool

    Polyline2D::length

    source
    fn Polyline2D::length(self : Polyline2D) -> Int

    Polyline2D::points

    source
    fn Polyline2D::points(self : Polyline2D) -> Array[Point2]

    Polyline2D::project

    source
    fn Polyline2D::project(self : Polyline2D, target : Point2) -> PolylineProjection2D

    Polyline2D::resample

    source
    fn Polyline2D::resample(self : Polyline2D, count : Int) -> Polyline2D

    Polyline2D::sample_by_distance

    source
    fn Polyline2D::sample_by_distance(self : Polyline2D, distance : Double) -> Point2

    Polyline2D::simplify

    source
    fn Polyline2D::simplify(self : Polyline2D, tolerance : Double) -> Polyline2D

    Polyline2D::total_length

    source
    fn Polyline2D::total_length(self : Polyline2D) -> Double

    PolylineProjection2D

    source
    pub struct PolylineProjection2D {
      point : Point2
      segment : Int
      ratio : Double
      distance : Double
      arc_length : Double
    } derive(
    Debug    )

    PolylineProjection2D::arc_length

    source
    fn PolylineProjection2D::arc_length(self : PolylineProjection2D) -> Double

    PolylineProjection2D::distance

    source
    fn PolylineProjection2D::distance(self : PolylineProjection2D) -> Double

    PolylineProjection2D::point

    source

    PolylineProjection2D::ratio

    source
    fn PolylineProjection2D::ratio(self : PolylineProjection2D) -> Double

    PolylineProjection2D::segment

    source
    fn PolylineProjection2D::segment(self : PolylineProjection2D) -> Int

    ProceduralMotion2

    source
    pub struct ProceduralMotion2 {
      base : Point2
      velocity : Point2
      jitter : JitterSequence2
      envelope : Curve
    } derive(
    Debug    )

    ProceduralMotion2::sample

    source
    fn ProceduralMotion2::sample(self : ProceduralMotion2, time : Double, normalized_time : Double) -> Point2

    ProceduralMotion2::sample_many

    source
    fn ProceduralMotion2::sample_many(self : ProceduralMotion2, start : Double, end : Double, count : Int) -> Array[Point2]

    ProjectionModel

    source
    pub enum ProjectionModel {
      Perspective
      Orthographic
    } derive(
    Debug    )

    Projection model used by a media camera.

    ProjectionSample2

    source
    pub struct ProjectionSample2 {
      world : Point3
      screen : Point2
      visible : Bool
      depth : Double
    } derive(
    Debug    )

    ProjectionSample2::depth

    source
    fn ProjectionSample2::depth(self : ProjectionSample2) -> Double

    ProjectionSample2::screen

    source

    ProjectionSample2::visible

    source
    fn ProjectionSample2::visible(self : ProjectionSample2) -> Bool

    ProjectionSample2::world

    source

    QualityBudget2

    source
    pub struct QualityBudget2 {
      temporal_limit : Double
      spatial_limit : Double
      color_limit : Double
      minimum_coverage : Double
    } derive(
    Debug    )

    QualityBudget2::accepts

    source
    fn QualityBudget2::accepts(self : QualityBudget2, metrics : RenderQualityMetrics2) -> Bool

    Quaternion

    source
    pub(all) struct Quaternion {
      x : Double
      y : Double
      z : Double
      w : Double
    } derive(
    Debug    )

    A unit-friendly quaternion for camera, scene, and object orientation.

    Quaternion::conjugate

    source
    fn Quaternion::conjugate(self : Quaternion) -> Quaternion

    Quaternion::dot

    source
    fn Quaternion::dot(self : Quaternion, other : Quaternion) -> Double

    Quaternion::forward

    source
    fn Quaternion::forward(self : Quaternion) -> Point3

    Quaternion::from_axis_angle

    source
    fn Quaternion::from_axis_angle(axis : Point3, angle : Double) -> Quaternion

    Quaternion::from_euler

    source
    fn Quaternion::from_euler(pitch : Double, yaw : Double, roll : Double) -> Quaternion

    Quaternion::identity

    source
    fn Quaternion::identity() -> Quaternion

    Quaternion::length

    source
    fn Quaternion::length(self : Quaternion) -> Double

    Quaternion::length_squared

    source
    fn Quaternion::length_squared(self : Quaternion) -> Double

    Quaternion::multiply

    source
    fn Quaternion::multiply(self : Quaternion, other : Quaternion) -> Quaternion

    Quaternion::negated

    source
    fn Quaternion::negated(self : Quaternion) -> Quaternion

    Quaternion::normalized

    source
    fn Quaternion::normalized(self : Quaternion) -> Quaternion

    Quaternion::right

    source
    fn Quaternion::right(self : Quaternion) -> Point3

    Quaternion::rotate

    source
    fn Quaternion::rotate(self : Quaternion, value : Point3) -> Point3

    Quaternion::slerp

    source
    fn Quaternion::slerp(self : Quaternion, other : Quaternion, amount : Double) -> Quaternion

    Quaternion::up

    source
    fn Quaternion::up(self : Quaternion) -> Point3

    Quaternion::w

    source
    fn Quaternion::w(self : Quaternion) -> Double

    Quaternion::x

    source
    fn Quaternion::x(self : Quaternion) -> Double

    Quaternion::y

    source
    fn Quaternion::y(self : Quaternion) -> Double

    Quaternion::z

    source
    fn Quaternion::z(self : Quaternion) -> Double

    RampInterpolation

    source
    pub enum RampInterpolation {
      RampLinear
      RampSmooth
      RampConstant
    } derive(
    Debug    )

    RenderFrame2

    source
    pub struct RenderFrame2 {
      time : Double
      passes : Array[RenderPass2]
      clear_color : Rgba
      visible_count : Int
    } derive(
    Debug    )

    RenderFrame2::clear_color

    source
    fn RenderFrame2::clear_color(self : RenderFrame2) -> Rgba

    RenderFrame2::passes

    source

    RenderFrame2::time

    source
    fn RenderFrame2::time(self : RenderFrame2) -> Double

    RenderFrame2::visible_count

    source
    fn RenderFrame2::visible_count(self : RenderFrame2) -> Int

    RenderLayer2

    source
    pub struct RenderLayer2 {
      id : Int
      name : String
      kind : RenderLayerKind2
      order : Int
      visible : Bool
      opacity : Double
      blend : BlendMode
      bounds : Bounds2D
    } derive(
    Debug    )

    RenderLayer2::blend

    source
    fn RenderLayer2::blend(self : RenderLayer2) -> BlendMode

    RenderLayer2::bounds

    source
    fn RenderLayer2::bounds(self : RenderLayer2) -> Bounds2D

    RenderLayer2::id

    source
    fn RenderLayer2::id(self : RenderLayer2) -> Int

    RenderLayer2::kind

    source

    RenderLayer2::name

    source
    fn RenderLayer2::name(self : RenderLayer2) -> String

    RenderLayer2::opacity

    source
    fn RenderLayer2::opacity(self : RenderLayer2) -> Double

    RenderLayer2::order

    source
    fn RenderLayer2::order(self : RenderLayer2) -> Int

    RenderLayer2::visible

    source
    fn RenderLayer2::visible(self : RenderLayer2) -> Bool

    RenderLayer2::with_blend

    source
    fn RenderLayer2::with_blend(self : RenderLayer2, blend : BlendMode) -> RenderLayer2

    RenderLayer2::with_opacity

    source
    fn RenderLayer2::with_opacity(self : RenderLayer2, opacity : Double) -> RenderLayer2

    RenderLayer2::with_visibility

    source
    fn RenderLayer2::with_visibility(self : RenderLayer2, visible : Bool) -> RenderLayer2

    RenderLayerKind2

    source
    pub enum RenderLayerKind2 {
      BackgroundLayer
      GeometryLayer
      SpriteLayer
      TextLayer
      ParticleLayer
      EffectLayer
    } derive(
    Debug    )

    Render-layer metadata that connects motion sampling to an application renderer without depending on a graphics backend.

    RenderPass2

    source
    pub struct RenderPass2 {
      layer_id : Int
      active : Bool
      opacity : Double
      clip_start : Double
      clip_end : Double
      world_bounds : Bounds2D
    } derive(
    Debug    )

    RenderPass2::active

    source
    fn RenderPass2::active(self : RenderPass2) -> Bool

    RenderPass2::clip_end

    source
    fn RenderPass2::clip_end(self : RenderPass2) -> Double

    RenderPass2::clip_start

    source
    fn RenderPass2::clip_start(self : RenderPass2) -> Double

    RenderPass2::layer_id

    source
    fn RenderPass2::layer_id(self : RenderPass2) -> Int

    RenderPass2::opacity

    source
    fn RenderPass2::opacity(self : RenderPass2) -> Double

    RenderPass2::world_bounds

    source
    fn RenderPass2::world_bounds(self : RenderPass2) -> Bounds2D

    RenderPlan2

    source
    pub struct RenderPlan2 {
      layers : Array[RenderLayer2]
      start : Double
      end : Double
      clear_color : Rgba
    } derive(
    Debug    )

    RenderPlan2::active_layers

    source
    fn RenderPlan2::active_layers(self : RenderPlan2, time : Double) -> Array[RenderLayer2]

    RenderPlan2::add_layer

    source
    fn RenderPlan2::add_layer(self : RenderPlan2, layer : RenderLayer2) -> Bool

    RenderPlan2::bounds

    source
    fn RenderPlan2::bounds(self : RenderPlan2) -> Bounds2D

    RenderPlan2::clear_color

    source
    fn RenderPlan2::clear_color(self : RenderPlan2) -> Rgba

    RenderPlan2::end

    source
    fn RenderPlan2::end(self : RenderPlan2) -> Double

    RenderPlan2::frame

    source
    fn RenderPlan2::frame(self : RenderPlan2, time : Double) -> RenderFrame2

    RenderPlan2::layer

    source
    fn RenderPlan2::layer(self : RenderPlan2, id : Int) -> RenderLayer2?

    RenderPlan2::layers

    source
    fn RenderPlan2::layers(self : RenderPlan2) -> Array[RenderLayer2]

    RenderPlan2::passes

    source
    fn RenderPlan2::passes(self : RenderPlan2, time : Double) -> Array[RenderPass2]

    RenderPlan2::remove_layer

    source
    fn RenderPlan2::remove_layer(self : RenderPlan2, id : Int) -> Bool

    RenderPlan2::shift

    source
    fn RenderPlan2::shift(self : RenderPlan2, delta : Double) -> RenderPlan2

    RenderPlan2::start

    source
    fn RenderPlan2::start(self : RenderPlan2) -> Double

    RenderPlan2::stats

    source

    RenderPlanStats2

    source
    pub struct RenderPlanStats2 {
      layer_count : Int
      visible_count : Int
      total_area : Double
      start : Double
      end : Double
    } derive(
    Debug    )

    RenderPlanStats2::end

    source
    fn RenderPlanStats2::end(self : RenderPlanStats2) -> Double

    RenderPlanStats2::layer_count

    source
    fn RenderPlanStats2::layer_count(self : RenderPlanStats2) -> Int

    RenderPlanStats2::start

    source
    fn RenderPlanStats2::start(self : RenderPlanStats2) -> Double

    RenderPlanStats2::total_area

    source
    fn RenderPlanStats2::total_area(self : RenderPlanStats2) -> Double

    RenderPlanStats2::visible_count

    source
    fn RenderPlanStats2::visible_count(self : RenderPlanStats2) -> Int

    RenderQuality2

    source
    pub enum RenderQuality2 {
      PreviewQuality
      DraftQuality
      FinalQuality
    } derive(
    Debug    )

    RenderQualityMetrics2

    source
    pub struct RenderQualityMetrics2 {
      temporal_error : Double
      spatial_error : Double
      color_error : Double
      dropped_frames : Int
      coverage : Double
    } derive(
    Debug    )

    Quality metrics for comparing preview and final render sample plans.

    RenderQualityMetrics2::color_error

    source
    fn RenderQualityMetrics2::color_error(self : RenderQualityMetrics2) -> Double

    RenderQualityMetrics2::coverage

    source
    fn RenderQualityMetrics2::coverage(self : RenderQualityMetrics2) -> Double

    RenderQualityMetrics2::dropped_frames

    source
    fn RenderQualityMetrics2::dropped_frames(self : RenderQualityMetrics2) -> Int

    RenderQualityMetrics2::passed

    source
    fn RenderQualityMetrics2::passed(self : RenderQualityMetrics2, temporal_limit : Double, spatial_limit : Double, color_limit : Double) -> Bool

    RenderQualityMetrics2::score

    source
    fn RenderQualityMetrics2::score(self : RenderQualityMetrics2) -> Double

    RenderQualityMetrics2::spatial_error

    source
    fn RenderQualityMetrics2::spatial_error(self : RenderQualityMetrics2) -> Double

    RenderQualityMetrics2::temporal_error

    source
    fn RenderQualityMetrics2::temporal_error(self : RenderQualityMetrics2) -> Double

    RetimeMap

    source
    pub struct RetimeMap {
      segments : Array[RetimeSegment]
      input_start : Double
      input_end : Double
      output_start : Double
      output_end : Double
    } derive(
    Debug    )

    RetimeMap::derivative

    source
    fn RetimeMap::derivative(self : RetimeMap, input : Double) -> Double

    RetimeMap::input_duration

    source
    fn RetimeMap::input_duration(self : RetimeMap) -> Double

    RetimeMap::input_end

    source
    fn RetimeMap::input_end(self : RetimeMap) -> Double

    RetimeMap::input_start

    source
    fn RetimeMap::input_start(self : RetimeMap) -> Double

    RetimeMap::length

    source
    fn RetimeMap::length(self : RetimeMap) -> Int

    RetimeMap::map

    source
    fn RetimeMap::map(self : RetimeMap, input : Double) -> Double

    Map a source timestamp to presentation time. Gaps clamp to the adjacent segment, which is deterministic for scrubbing and export.

    RetimeMap::new

    source
    fn RetimeMap::new(segments : Array[RetimeSegment]) -> RetimeMap raise MotionError

    RetimeMap::output_duration

    source
    fn RetimeMap::output_duration(self : RetimeMap) -> Double

    RetimeMap::output_end

    source
    fn RetimeMap::output_end(self : RetimeMap) -> Double

    RetimeMap::output_start

    source
    fn RetimeMap::output_start(self : RetimeMap) -> Double

    RetimeMap::reverse

    source
    fn RetimeMap::reverse(self : RetimeMap) -> RetimeMap raise MotionError

    RetimeMap::sample

    source
    fn RetimeMap::sample(self : RetimeMap, count : Int) -> Array[SamplePoint] raise MotionError

    RetimeMap::scale_output

    source
    fn RetimeMap::scale_output(self : RetimeMap, factor : Double) -> RetimeMap raise MotionError

    RetimeMap::segments

    source
    fn RetimeMap::segments(self : RetimeMap) -> Array[RetimeSegment]

    RetimeMap::shift_output

    source
    fn RetimeMap::shift_output(self : RetimeMap, offset : Double) -> RetimeMap raise MotionError

    RetimeMap::unmap

    source
    fn RetimeMap::unmap(self : RetimeMap, output : Double) -> Double

    RetimeMapBuilder

    source
    pub struct RetimeMapBuilder {
      segments : Array[RetimeSegment]
    } derive(
    Debug    )

    Build a map by appending non-overlapping source and presentation ranges.

    RetimeMapBuilder::add

    source

    RetimeMapBuilder::build

    source

    RetimeMapBuilder::length

    source
    fn RetimeMapBuilder::length(self : RetimeMapBuilder) -> Int

    RetimeMapBuilder::new

    source

    RetimeSegment

    source
    pub struct RetimeSegment {
      input_start : Double
      input_end : Double
      output_start : Double
      output_end : Double
      curve : Curve
    } derive(
    Debug    )

    A monotone time remapping segment. Input and output intervals are kept explicit so media editors can preserve source timestamps while changing presentation speed.

    RetimeSegment::contains_input

    source
    fn RetimeSegment::contains_input(self : RetimeSegment, time : Double) -> Bool

    RetimeSegment::contains_output

    source
    fn RetimeSegment::contains_output(self : RetimeSegment, time : Double) -> Bool

    RetimeSegment::curve

    source
    fn RetimeSegment::curve(self : RetimeSegment) -> Curve

    RetimeSegment::derivative

    source
    fn RetimeSegment::derivative(self : RetimeSegment, input : Double) -> Double

    RetimeSegment::input_duration

    source
    fn RetimeSegment::input_duration(self : RetimeSegment) -> Double

    RetimeSegment::input_end

    source
    fn RetimeSegment::input_end(self : RetimeSegment) -> Double

    RetimeSegment::input_start

    source
    fn RetimeSegment::input_start(self : RetimeSegment) -> Double

    RetimeSegment::map

    source
    fn RetimeSegment::map(self : RetimeSegment, input : Double) -> Double

    RetimeSegment::output_duration

    source
    fn RetimeSegment::output_duration(self : RetimeSegment) -> Double

    RetimeSegment::output_end

    source
    fn RetimeSegment::output_end(self : RetimeSegment) -> Double

    RetimeSegment::output_start

    source
    fn RetimeSegment::output_start(self : RetimeSegment) -> Double

    RetimeSegment::speed

    source
    fn RetimeSegment::speed(self : RetimeSegment) -> Double

    RetimeSegment::unmap

    source
    fn RetimeSegment::unmap(self : RetimeSegment, output : Double) -> Double

    Rgba

    source
    pub(all) struct Rgba {
      r : Double
      g : Double
      b : Double
      a : Double
    } derive(
    Debug    )

    RGBA color stored in the normalized [0, 1] range.

    Rgba::alpha

    source
    fn Rgba::alpha(self : Rgba) -> Double

    Rgba::blue

    source
    fn Rgba::blue(self : Rgba) -> Double

    Rgba::distance

    source
    fn Rgba::distance(self : Rgba, other : Rgba) -> Double

    Rgba::grayscale

    source
    fn Rgba::grayscale(self : Rgba) -> Rgba

    Rgba::green

    source
    fn Rgba::green(self : Rgba) -> Double

    Rgba::lerp_linear

    source
    fn Rgba::lerp_linear(self : Rgba, other : Rgba, ratio : Double) -> Rgba

    Rgba::luminance

    source
    fn Rgba::luminance(self : Rgba) -> Double

    Rgba::over

    source
    fn Rgba::over(self : Rgba, background : Rgba) -> Rgba

    Rgba::premultiplied

    source
    fn Rgba::premultiplied(self : Rgba) -> Rgba

    Rgba::premultiply_over

    source
    fn Rgba::premultiply_over(self : Rgba, background : Rgba) -> Rgba

    Rgba::red

    source
    fn Rgba::red(self : Rgba) -> Double

    Rgba::to_hsv

    source
    fn Rgba::to_hsv(self : Rgba) -> Hsv

    Rgba::to_linear

    source
    fn Rgba::to_linear(self : Rgba) -> Rgba

    Rgba::to_srgb

    source
    fn Rgba::to_srgb(self : Rgba) -> Rgba

    Rgba::unpremultiplied

    source
    fn Rgba::unpremultiplied(self : Rgba) -> Rgba

    Rgba::with_alpha

    source
    fn Rgba::with_alpha(self : Rgba, alpha : Double) -> Rgba

    RgbaKeyframe

    source
    pub struct RgbaKeyframe {
      time : Double
      value : Rgba
      curve : Curve
    } derive(
    Debug    )

    A color keyframe track for gradients, fades, and compositing timelines.

    RgbaTrack

    source
    pub struct RgbaTrack {
      frames : Array[RgbaKeyframe]
      premultiplied : Bool
    } derive(
    Debug    )

    RgbaTrack::duration

    source
    fn RgbaTrack::duration(self : RgbaTrack) -> Double

    RgbaTrack::end_time

    source
    fn RgbaTrack::end_time(self : RgbaTrack) -> Double

    RgbaTrack::keyframes

    source
    fn RgbaTrack::keyframes(self : RgbaTrack) -> Array[RgbaKeyframe]

    RgbaTrack::length

    source
    fn RgbaTrack::length(self : RgbaTrack) -> Int

    RgbaTrack::new

    source
    fn RgbaTrack::new(frames : Array[RgbaKeyframe], premultiplied? : Bool) -> RgbaTrack raise MotionError

    RgbaTrack::sample

    source
    fn RgbaTrack::sample(self : RgbaTrack, time : Double, mode? : Extrapolation) -> Rgba

    RgbaTrack::sample_many

    source
    fn RgbaTrack::sample_many(self : RgbaTrack, count : Int, mode? : Extrapolation) -> Array[Rgba] raise MotionError

    RgbaTrack::start_time

    source
    fn RgbaTrack::start_time(self : RgbaTrack) -> Double

    SampleCacheKey2

    source
    pub struct SampleCacheKey2 {
      track_id : Int
      revision : Int
      samples : Int
      start : Double
      end : Double
    } derive(
    Debug    )

    Reusable sample caches for repeated timeline evaluation. Cache keys are explicit so callers can invalidate only the track or resolution that changed during editing.

    SampleCacheKey2::matches

    source
    fn SampleCacheKey2::matches(self : SampleCacheKey2, other : SampleCacheKey2) -> Bool

    SampleCacheKey2::revision

    source
    fn SampleCacheKey2::revision(self : SampleCacheKey2) -> Int

    SampleCacheKey2::samples

    source
    fn SampleCacheKey2::samples(self : SampleCacheKey2) -> Int

    SampleCacheKey2::track_id

    source
    fn SampleCacheKey2::track_id(self : SampleCacheKey2) -> Int

    SamplePoint

    source
    pub(all) struct SamplePoint {
      time : Double
      value : Double
      frame : Int
    } derive(
    Debug    )

    SamplePoint::frame

    source
    fn SamplePoint::frame(self : SamplePoint) -> Int

    SamplePoint::time

    source
    fn SamplePoint::time(self : SamplePoint) -> Double

    SamplePoint::value

    source
    fn SamplePoint::value(self : SamplePoint) -> Double

    SampleValidationPolicy2

    source
    pub struct SampleValidationPolicy2 {
      tolerance : Double
      endpoint_tolerance : Double
      maximum_gap : Double
      require_monotonic_time : Bool
    } derive(
    Debug    )

    Validation policies for production sample tables.

    SampleValidationPolicy2::endpoint_tolerance

    source
    fn SampleValidationPolicy2::endpoint_tolerance(self : SampleValidationPolicy2) -> Double

    SampleValidationPolicy2::maximum_gap

    source
    fn SampleValidationPolicy2::maximum_gap(self : SampleValidationPolicy2) -> Double

    SampleValidationPolicy2::tolerance

    source
    fn SampleValidationPolicy2::tolerance(self : SampleValidationPolicy2) -> Double

    SampleValidationPolicy2::with_gap

    source

    SampleValidationPolicy2::with_monotonic_time

    source
    fn SampleValidationPolicy2::with_monotonic_time(self : SampleValidationPolicy2, value : Bool) -> SampleValidationPolicy2

    SampleValidationPolicy2::with_tolerance

    source
    fn SampleValidationPolicy2::with_tolerance(self : SampleValidationPolicy2, value : Double) -> SampleValidationPolicy2

    SamplingConfig

    source
    pub struct SamplingConfig {
      start : Double
      end : Double
      frame_rate : Double
      include_end : Bool
    } derive(
    Debug    )

    Deterministic sampling window for rendering or offline export.

    SamplingConfig::end

    source
    fn SamplingConfig::end(self : SamplingConfig) -> Double

    SamplingConfig::frame_count

    source
    fn SamplingConfig::frame_count(self : SamplingConfig) -> Int

    SamplingConfig::frame_rate

    source
    fn SamplingConfig::frame_rate(self : SamplingConfig) -> Double

    SamplingConfig::new

    source
    fn SamplingConfig::new(start : Double, end : Double, frame_rate : Double, include_end? : Bool) -> SamplingConfig raise MotionError

    SamplingConfig::start

    source
    fn SamplingConfig::start(self : SamplingConfig) -> Double

    ScalarBlendLayer

    source
    pub struct ScalarBlendLayer {
      value : Double
      weight : Double
      mode : LayerBlendMode
      priority : Int
    } derive(
    Debug    )

    ScalarBlendLayer::mode

    source

    ScalarBlendLayer::priority

    source
    fn ScalarBlendLayer::priority(self : ScalarBlendLayer) -> Int

    ScalarBlendLayer::value

    source
    fn ScalarBlendLayer::value(self : ScalarBlendLayer) -> Double

    ScalarBlendLayer::weight

    source
    fn ScalarBlendLayer::weight(self : ScalarBlendLayer) -> Double

    ScalarChannel

    source
    pub struct ScalarChannel {
      name : String
      track : ScalarTrack
      enabled : Bool
      weight : Double
      offset : Double
    } derive(
    Debug    )

    A named scalar channel with editor-friendly activation and weighting.

    ScalarChannel::duration

    source
    fn ScalarChannel::duration(self : ScalarChannel) -> Double

    ScalarChannel::enabled

    source
    fn ScalarChannel::enabled(self : ScalarChannel) -> Bool

    ScalarChannel::end_time

    source
    fn ScalarChannel::end_time(self : ScalarChannel) -> Double

    ScalarChannel::name

    source
    fn ScalarChannel::name(self : ScalarChannel) -> String

    ScalarChannel::offset

    source
    fn ScalarChannel::offset(self : ScalarChannel) -> Double

    ScalarChannel::sample

    source
    fn ScalarChannel::sample(self : ScalarChannel, time : Double, mode? : Extrapolation) -> Double

    ScalarChannel::start_time

    source
    fn ScalarChannel::start_time(self : ScalarChannel) -> Double

    ScalarChannel::track

    source

    ScalarChannel::weight

    source
    fn ScalarChannel::weight(self : ScalarChannel) -> Double

    ScalarChannel::with_enabled

    source
    fn ScalarChannel::with_enabled(self : ScalarChannel, enabled : Bool) -> ScalarChannel

    ScalarChannel::with_offset

    source
    fn ScalarChannel::with_offset(self : ScalarChannel, offset : Double) -> ScalarChannel raise MotionError

    ScalarChannel::with_weight

    source
    fn ScalarChannel::with_weight(self : ScalarChannel, weight : Double) -> ScalarChannel raise MotionError

    ScalarSampleCache2

    source
    pub struct ScalarSampleCache2 {
      key : SampleCacheKey2
      times : Array[Double]
      values : Array[Double]
    } derive(
    Debug    )

    ScalarSampleCache2::derivative

    source
    fn ScalarSampleCache2::derivative(self : ScalarSampleCache2, time : Double) -> Double

    ScalarSampleCache2::key

    source

    ScalarSampleCache2::length

    source
    fn ScalarSampleCache2::length(self : ScalarSampleCache2) -> Int

    ScalarSampleCache2::new

    source
    fn ScalarSampleCache2::new(key : SampleCacheKey2, values : Array[Double]) -> ScalarSampleCache2

    ScalarSampleCache2::sample

    source
    fn ScalarSampleCache2::sample(self : ScalarSampleCache2, time : Double) -> Double

    ScalarSampleCache2::times

    source
    fn ScalarSampleCache2::times(self : ScalarSampleCache2) -> Array[Double]

    ScalarSampleCache2::values

    source
    fn ScalarSampleCache2::values(self : ScalarSampleCache2) -> Array[Double]

    ScalarSeries2

    source
    pub struct ScalarSeries2 {
      times : Array[Double]
      values : Array[Double]
    } derive(
    Debug    )

    Batch sampling helpers used by exporters, benchmark harnesses, and analysis tools. The series stores timestamps beside values so non-uniform editorial edits remain observable.

    ScalarSeries2::derivatives

    source
    fn ScalarSeries2::derivatives(self : ScalarSeries2) -> Array[Double]

    ScalarSeries2::duration

    source
    fn ScalarSeries2::duration(self : ScalarSeries2) -> Double

    ScalarSeries2::integral

    source
    fn ScalarSeries2::integral(self : ScalarSeries2) -> Double

    ScalarSeries2::length

    source
    fn ScalarSeries2::length(self : ScalarSeries2) -> Int

    ScalarSeries2::map

    source
    fn ScalarSeries2::map(self : ScalarSeries2, mapper : (Double) -> Double) -> ScalarSeries2

    ScalarSeries2::range

    source
    fn ScalarSeries2::range(self : ScalarSeries2) -> (Double, Double)

    ScalarSeries2::resample

    source
    fn ScalarSeries2::resample(self : ScalarSeries2, count : Int) -> ScalarSeries2

    ScalarSeries2::sample

    source
    fn ScalarSeries2::sample(self : ScalarSeries2, time : Double) -> Double

    ScalarSeries2::times

    source
    fn ScalarSeries2::times(self : ScalarSeries2) -> Array[Double]

    ScalarSeries2::values

    source
    fn ScalarSeries2::values(self : ScalarSeries2) -> Array[Double]

    ScalarTrack

    source
    pub struct ScalarTrack {
      frames : Array[Keyframe]
    } derive(
    Debug    )

    A validated, immutable-at-the-API scalar track.

    ScalarTrack::duration

    source
    fn ScalarTrack::duration(self : ScalarTrack) -> Double

    ScalarTrack::end_time

    source
    fn ScalarTrack::end_time(self : ScalarTrack) -> Double

    ScalarTrack::keyframes

    source
    fn ScalarTrack::keyframes(self : ScalarTrack) -> Array[Keyframe]

    ScalarTrack::length

    source
    fn ScalarTrack::length(self : ScalarTrack) -> Int

    ScalarTrack::map_values

    source
    fn ScalarTrack::map_values(self : ScalarTrack, mapper : (Double) -> Double) -> ScalarTrack raise MotionError

    Transform values without changing timing or curves.

    ScalarTrack::new

    source
    fn ScalarTrack::new(frames : Array[Keyframe]) -> ScalarTrack raise MotionError

    Build a scalar track from strictly increasing keyframes.

    ScalarTrack::sample

    source
    fn ScalarTrack::sample(self : ScalarTrack, time : Double, mode? : Extrapolation) -> Double

    Sample at an arbitrary time using the selected boundary policy.

    ScalarTrack::sample_motion

    source
    fn ScalarTrack::sample_motion(self : ScalarTrack, time : Double, mode? : Extrapolation) -> MotionSample

    ScalarTrack::sample_values

    source
    fn ScalarTrack::sample_values(self : ScalarTrack, times : Array[Double], mode? : Extrapolation) -> Array[Double]

    ScalarTrack::scale_time

    source
    fn ScalarTrack::scale_time(self : ScalarTrack, factor : Double) -> ScalarTrack raise MotionError

    Scale a track's time axis around its first keyframe.

    ScalarTrack::shift

    source
    fn ScalarTrack::shift(self : ScalarTrack, offset : Double) -> ScalarTrack raise MotionError

    Move a track in time while preserving its segment curves.

    ScalarTrack::start_time

    source
    fn ScalarTrack::start_time(self : ScalarTrack) -> Double

    ScalarTrack::trim

    source
    fn ScalarTrack::trim(self : ScalarTrack, start : Double, end : Double) -> ScalarTrack raise MotionError

    Copy a time range, adding interpolated boundary frames when needed.

    ScalarTrack::value_range

    source
    fn ScalarTrack::value_range(self : ScalarTrack, samples_per_segment : Int) -> (Double, Double)

    ScalarTrack::velocity

    source
    fn ScalarTrack::velocity(self : ScalarTrack, time : Double, mode? : Extrapolation) -> Double

    Estimate velocity with a central difference that respects track duration.

    ScalarTrack::with_curve

    source
    fn ScalarTrack::with_curve(self : ScalarTrack, curve : Curve) -> ScalarTrack raise MotionError

    Return a track with a replacement curve on every segment.

    ScalarTrackBundle

    source
    pub struct ScalarTrackBundle {
      channels : Array[ScalarChannel]
      start_time : Double
      end_time : Double
    } derive(
    Debug    )

    A group of synchronized scalar tracks for UI properties, camera channels, or a compact control stream exported to a runtime.

    ScalarTrackBundle::channels

    source

    ScalarTrackBundle::duration

    source
    fn ScalarTrackBundle::duration(self : ScalarTrackBundle) -> Double

    ScalarTrackBundle::end_time

    source
    fn ScalarTrackBundle::end_time(self : ScalarTrackBundle) -> Double

    ScalarTrackBundle::find

    source
    fn ScalarTrackBundle::find(self : ScalarTrackBundle, name : String) -> ScalarChannel?

    ScalarTrackBundle::length

    source
    fn ScalarTrackBundle::length(self : ScalarTrackBundle) -> Int

    ScalarTrackBundle::new

    source

    ScalarTrackBundle::sample

    source
    fn ScalarTrackBundle::sample(self : ScalarTrackBundle, time : Double, mode? : Extrapolation) -> BundleSample

    ScalarTrackBundle::sample_many

    source
    fn ScalarTrackBundle::sample_many(self : ScalarTrackBundle, count : Int, mode? : Extrapolation) -> Array[BundleSample] raise MotionError

    ScalarTrackBundle::set_enabled

    source
    fn ScalarTrackBundle::set_enabled(self : ScalarTrackBundle, name : String, enabled : Bool) -> ScalarTrackBundle raise MotionError

    ScalarTrackBundle::set_weight

    source
    fn ScalarTrackBundle::set_weight(self : ScalarTrackBundle, name : String, weight : Double) -> ScalarTrackBundle raise MotionError

    ScalarTrackBundle::start_time

    source
    fn ScalarTrackBundle::start_time(self : ScalarTrackBundle) -> Double

    ScalarTrackBundle::with_channel

    source

    ScalarTrackBundle::without

    source
    fn ScalarTrackBundle::without(self : ScalarTrackBundle, name : String) -> ScalarTrackBundle raise MotionError

    ScalarTrackBundleBuilder

    source
    pub struct ScalarTrackBundleBuilder {
      channels : Array[ScalarChannel]
    } derive(
    Debug    )

    ScalarTrackBundleBuilder::add

    source

    ScalarTrackBundleBuilder::build

    source

    ScalarTrackBundleBuilder::length

    source

    ScalarTrackBundleBuilder::new

    source

    ScalarTrackBundleBuilder::remove

    source
    fn ScalarTrackBundleBuilder::remove(self : ScalarTrackBundleBuilder, name : String) -> Bool

    SequenceBuilder

    source
    pub struct SequenceBuilder {
      tweens : Array[Tween]
      gap : Double
    }

    A mutable composition helper used by editors and importers.

    SequenceBuilder::add

    source
    fn SequenceBuilder::add(self : SequenceBuilder, tween : Tween) -> Unit

    SequenceBuilder::build

    source

    SequenceBuilder::new

    source
    fn SequenceBuilder::new(gap? : Double) -> SequenceBuilder

    SequenceBuilder::remove_at

    source
    fn SequenceBuilder::remove_at(self : SequenceBuilder, index : Int) -> Tween?

    SequenceSample

    source
    pub(all) struct SequenceSample {
      time : Double
      value : Double
      index : Int
      progress : Double
      state : SequenceState
    } derive(
    Debug    )

    A sample from a TweenSequence, including the active segment index.

    SequenceSample::index

    source
    fn SequenceSample::index(self : SequenceSample) -> Int

    SequenceSample::progress

    source
    fn SequenceSample::progress(self : SequenceSample) -> Double

    SequenceSample::state

    source

    SequenceSample::time

    source
    fn SequenceSample::time(self : SequenceSample) -> Double

    SequenceSample::value

    source
    fn SequenceSample::value(self : SequenceSample) -> Double

    SequenceState

    source
    pub(all) enum SequenceState {
      Before
      Active
      Gap
      After
    } derive(Eq, 
    Debug    )

    Lifecycle state for a serial composition of scalar tweens.

    ShakeFalloff2

    source
    pub enum ShakeFalloff2 {
      ConstantShake
      LinearShake
      SmoothShake
      ExponentialShake(Double)
    } derive(
    Debug    )

    SignalPeak2

    source
    pub struct SignalPeak2 {
      index : Int
      value : Double
      prominence : Double
      width : Int
    } derive(
    Debug    )

    Feature extraction for motion signals and benchmark diagnostics.

    SignalPeak2::index

    source
    fn SignalPeak2::index(self : SignalPeak2) -> Int

    SignalPeak2::prominence

    source
    fn SignalPeak2::prominence(self : SignalPeak2) -> Double

    SignalPeak2::value

    source
    fn SignalPeak2::value(self : SignalPeak2) -> Double

    SignalPeak2::width

    source
    fn SignalPeak2::width(self : SignalPeak2) -> Int

    SoftRange2

    source
    pub struct SoftRange2 {
      minimum : Double
      maximum : Double
      softness : Double
      restitution : Double
    } derive(
    Debug    )

    SoftRange2::contains

    source
    fn SoftRange2::contains(self : SoftRange2, value : Double) -> Bool

    SoftRange2::maximum

    source
    fn SoftRange2::maximum(self : SoftRange2) -> Double

    SoftRange2::minimum

    source
    fn SoftRange2::minimum(self : SoftRange2) -> Double

    SoftRange2::resolve

    source
    fn SoftRange2::resolve(self : SoftRange2, value : Double, velocity : Double) -> (Double, Double, ConstraintStatus2)

    SoftRange2::restitution

    source
    fn SoftRange2::restitution(self : SoftRange2) -> Double

    SoftRange2::softness

    source
    fn SoftRange2::softness(self : SoftRange2) -> Double

    Spline2D

    source
    pub struct Spline2D {
      points : Array[Point2]
      tension : Double
      closed : Bool
    } derive(
    Debug    )

    A Catmull-Rom spline over 2D control points.

    tension=0 is the standard centripetal-free Catmull-Rom form. The closed option connects the last control point back to the first one.

    Spline2D::bounds

    source
    fn Spline2D::bounds(self : Spline2D, samples_per_segment? : Int) -> Bounds2D

    Spline2D::closed

    source
    fn Spline2D::closed(self : Spline2D) -> Bool

    Spline2D::control_points

    source
    fn Spline2D::control_points(self : Spline2D) -> Array[Point2]

    Spline2D::length

    source
    fn Spline2D::length(self : Spline2D, samples_per_segment : Int) -> Double

    Spline2D::new

    source
    fn Spline2D::new(points : Array[Point2], tension? : Double, closed? : Bool) -> Spline2D raise MotionError

    Spline2D::point_count

    source
    fn Spline2D::point_count(self : Spline2D) -> Int

    Spline2D::polyline

    source
    fn Spline2D::polyline(self : Spline2D, samples_per_segment : Int) -> Array[Point2]

    Spline2D::project

    source
    fn Spline2D::project(self : Spline2D, target : Point2, samples_per_segment? : Int) -> SplineProjection

    Find the closest sampled point to a target, returning an approximate normalized parameter and the actual point on the spline.

    Spline2D::sample

    source
    fn Spline2D::sample(self : Spline2D, parameter : Double) -> Point2

    Spline2D::sample_by_distance

    source
    fn Spline2D::sample_by_distance(self : Spline2D, distance : Double, samples_per_segment? : Int) -> Point2

    Spline2D::sample_many

    source
    fn Spline2D::sample_many(self : Spline2D, count : Int) -> Array[Point2] raise MotionError

    Spline2D::segment_count

    source
    fn Spline2D::segment_count(self : Spline2D) -> Int

    Spline2D::speed

    source
    fn Spline2D::speed(self : Spline2D, parameter : Double) -> Double

    Spline2D::tangent

    source
    fn Spline2D::tangent(self : Spline2D, parameter : Double) -> Point2

    Spline2D::tension

    source
    fn Spline2D::tension(self : Spline2D) -> Double

    Spline3D

    source
    pub struct Spline3D {
      points : Array[Point3]
      tension : Double
      closed : Bool
    } derive(
    Debug    )

    A Catmull-Rom spline over 3D control points for camera and scene motion.

    Spline3D::closed

    source
    fn Spline3D::closed(self : Spline3D) -> Bool

    Spline3D::control_points

    source
    fn Spline3D::control_points(self : Spline3D) -> Array[Point3]

    Spline3D::length

    source
    fn Spline3D::length(self : Spline3D, samples_per_segment : Int) -> Double

    Spline3D::new

    source
    fn Spline3D::new(points : Array[Point3], tension? : Double, closed? : Bool) -> Spline3D raise MotionError

    Spline3D::point_count

    source
    fn Spline3D::point_count(self : Spline3D) -> Int

    Spline3D::polyline

    source
    fn Spline3D::polyline(self : Spline3D, samples_per_segment : Int) -> Array[Point3]

    Spline3D::sample

    source
    fn Spline3D::sample(self : Spline3D, parameter : Double) -> Point3

    Spline3D::sample_by_distance

    source
    fn Spline3D::sample_by_distance(self : Spline3D, distance : Double, samples_per_segment? : Int) -> Point3

    Spline3D::sample_many

    source
    fn Spline3D::sample_many(self : Spline3D, count : Int) -> Array[Point3] raise MotionError

    Spline3D::segment_count

    source
    fn Spline3D::segment_count(self : Spline3D) -> Int

    Spline3D::speed

    source
    fn Spline3D::speed(self : Spline3D, parameter : Double) -> Double

    Spline3D::tangent

    source
    fn Spline3D::tangent(self : Spline3D, parameter : Double) -> Point3

    Spline3D::tension

    source
    fn Spline3D::tension(self : Spline3D) -> Double

    SplineProjection

    source
    pub(all) struct SplineProjection {
      parameter : Double
      distance : Double
      value : Point2
      error : Double
    } derive(
    Debug    )

    A normalized projection on a spline, useful for path-following cameras.

    SplineProjection::distance

    source
    fn SplineProjection::distance(self : SplineProjection) -> Double

    SplineProjection::error

    source
    fn SplineProjection::error(self : SplineProjection) -> Double

    SplineProjection::parameter

    source
    fn SplineProjection::parameter(self : SplineProjection) -> Double

    SplineProjection::value

    source

    SpringSpec

    source
    pub struct SpringSpec {
      stiffness : Double
      damping : Double
      mass : Double
      initial_velocity : Double
    } derive(
    Debug    )

    Physical parameters for a damped spring response.

    SpringSpec::damping_ratio

    source
    fn SpringSpec::damping_ratio(self : SpringSpec) -> Double

    SpringSpec::is_settled

    source
    fn SpringSpec::is_settled(self : SpringSpec, start : Double, end : Double, time : Double, tolerance? : Double) -> Bool

    SpringSpec::natural_frequency

    source
    fn SpringSpec::natural_frequency(self : SpringSpec) -> Double

    SpringSpec::sample

    source
    fn SpringSpec::sample(self : SpringSpec, start : Double, end : Double, time : Double) -> MotionSample

    SpringSpec::sample_many

    source
    fn SpringSpec::sample_many(self : SpringSpec, start : Double, end : Double, duration : Double, count : Int) -> Array[MotionSample] raise MotionError

    SpringSpec::settle_time

    source
    fn SpringSpec::settle_time(self : SpringSpec, tolerance? : Double) -> Double

    SpringSpec::value_at

    source
    fn SpringSpec::value_at(self : SpringSpec, start : Double, end : Double, time : Double) -> Double

    Spring position for a unit step from start to end.

    SpringSpec::velocity_at

    source
    fn SpringSpec::velocity_at(self : SpringSpec, start : Double, end : Double, time : Double) -> Double

    Tempo

    source
    pub struct Tempo {
      beats_per_minute : Double
      beat_offset : Double
    } derive(
    Debug    )

    Beat-based timing helper for music and rhythm-driven interactions.

    Tempo::beat_duration

    source
    fn Tempo::beat_duration(self : Tempo) -> Double

    Tempo::beats_to_seconds

    source
    fn Tempo::beats_to_seconds(self : Tempo, beats : Double) -> Double

    Tempo::new

    source
    fn Tempo::new(bpm : Double, beat_offset? : Double) -> Tempo raise MotionError

    Tempo::seconds_to_beats

    source
    fn Tempo::seconds_to_beats(self : Tempo, seconds : Double) -> Double

    TempoPoint2

    source
    pub struct TempoPoint2 {
      beat : Double
      bpm : Double
    } derive(
    Debug    )

    A tempo change in an editorial timeline. Beats are represented as a continuous Double so a video frame can land between integer beat markers.

    TempoPoint2::beat

    source
    fn TempoPoint2::beat(self : TempoPoint2) -> Double

    TempoPoint2::bpm

    source
    fn TempoPoint2::bpm(self : TempoPoint2) -> Double

    TempoTimeline

    source
    pub struct TempoTimeline {
      points : Array[TempoPoint2]
      origin_seconds : Double
    } derive(
    Debug    )

    TempoTimeline::beat_to_seconds

    source
    fn TempoTimeline::beat_to_seconds(self : TempoTimeline, beat : Double) -> Double

    TempoTimeline::bpm_at_seconds

    source
    fn TempoTimeline::bpm_at_seconds(self : TempoTimeline, seconds : Double) -> Double

    TempoTimeline::length

    source
    fn TempoTimeline::length(self : TempoTimeline) -> Int

    TempoTimeline::new

    source
    fn TempoTimeline::new(points : Array[TempoPoint2], origin_seconds? : Double) -> TempoTimeline

    TempoTimeline::points

    source

    TempoTimeline::quantize_beat

    source
    fn TempoTimeline::quantize_beat(_self : TempoTimeline, beat : Double, subdivision : Int) -> Double

    TempoTimeline::seconds_to_beat

    source
    fn TempoTimeline::seconds_to_beat(self : TempoTimeline, seconds : Double) -> Double

    TimeSignature2

    source
    pub struct TimeSignature2 {
      numerator : Int
      denominator : Int
    } derive(
    Debug    )

    TimeSignature2::bar_beats

    source
    fn TimeSignature2::bar_beats(self : TimeSignature2) -> Double

    TimeSignature2::beat_in_bar

    source
    fn TimeSignature2::beat_in_bar(self : TimeSignature2, beat : Double) -> Double

    TimeSignature2::denominator

    source
    fn TimeSignature2::denominator(self : TimeSignature2) -> Int

    TimeSignature2::numerator

    source
    fn TimeSignature2::numerator(self : TimeSignature2) -> Int

    TimeWarp

    source
    pub struct TimeWarp {
      curve : Curve
      start : Double
      end : Double
      speed : Double
    } derive(
    Debug    )

    A normalized time remapping used by editors and media exporters.

    TimeWarp::curve

    source
    fn TimeWarp::curve(self : TimeWarp) -> Curve

    TimeWarp::duration

    source
    fn TimeWarp::duration(self : TimeWarp) -> Double

    TimeWarp::map

    source
    fn TimeWarp::map(self : TimeWarp, time : Double) -> Double

    TimeWarp::new

    source
    fn TimeWarp::new(curve : Curve, start : Double, end : Double, speed? : Double) -> TimeWarp raise MotionError

    TimeWarp::unmap

    source
    fn TimeWarp::unmap(self : TimeWarp, mapped_time : Double) -> Double

    Invert a timing curve with a fixed bisection budget.

    Timecode2

    source
    pub struct Timecode2 {
      hours : Int
      minutes : Int
      seconds : Int
      frames : Int
      frame_rate : Double
    } derive(
    Debug    )

    Timecode2::frame_index

    source
    fn Timecode2::frame_index(self : Timecode2) -> Int

    Timecode2::frame_rate

    source
    fn Timecode2::frame_rate(self : Timecode2) -> Double

    Timecode2::frames

    source
    fn Timecode2::frames(self : Timecode2) -> Int

    Timecode2::hours

    source
    fn Timecode2::hours(self : Timecode2) -> Int

    Timecode2::minutes

    source
    fn Timecode2::minutes(self : Timecode2) -> Int

    Timecode2::seconds

    source
    fn Timecode2::seconds(self : Timecode2) -> Int

    Timecode2::to_seconds

    source
    fn Timecode2::to_seconds(self : Timecode2) -> Double

    Timeline

    source
    pub struct Timeline {
      slots : Array[TrackSlot]
    } derive(
    Debug    )

    A deterministic collection of named scalar tracks.

    Timeline::add

    source
    fn Timeline::add(self : Timeline, slot : TrackSlot) -> Unit

    Timeline::duration

    source
    fn Timeline::duration(self : Timeline) -> Double

    Timeline::new

    source
    fn Timeline::new() -> Timeline

    Timeline::remove

    source
    fn Timeline::remove(self : Timeline, name : String) -> Bool

    Timeline::sample

    source
    fn Timeline::sample(self : Timeline, time : Double, mode? : Extrapolation) -> Array[TimelineValue]

    Sample every enabled track at a timeline coordinate.

    Timeline::sample_window

    source
    fn Timeline::sample_window(self : Timeline, config : SamplingConfig, mode? : Extrapolation) -> Array[Array[TimelineValue]]

    Sample a timeline on a deterministic export grid.

    Timeline::set_enabled

    source
    fn Timeline::set_enabled(self : Timeline, name : String, enabled : Bool) -> Bool

    Timeline::track_count

    source
    fn Timeline::track_count(self : Timeline) -> Int

    Timeline::tracks

    source
    fn Timeline::tracks(self : Timeline) -> Array[TrackSlot]

    TimelineEdgeKind

    source
    pub enum TimelineEdgeKind {
      StartAfterEnd
      StartAfterStart
      EndWithEnd
      OffsetLink(Double)
    } derive(
    Debug    )

    TimelineEvaluation2

    source
    pub struct TimelineEvaluation2 {
      context : EvaluationContext2
      active_nodes : Array[TimelineGraphNode]
      render_frame : RenderFrame2
      events : Array[MotionEvent2]
    } derive(
    Debug    )

    TimelineEvaluation2::active_nodes

    source

    TimelineEvaluation2::context

    source

    TimelineEvaluation2::events

    source

    TimelineEvaluation2::render_frame

    source

    TimelineEvaluator2

    source
    pub struct TimelineEvaluator2 {
      graph : TimelineGraph
      render_plan : RenderPlan2
      event_queue : MotionEventQueue2
      previous_time : Double
    } derive(
    Debug    )

    TimelineEvaluator2::active_count

    source
    fn TimelineEvaluator2::active_count(self : TimelineEvaluator2, time : Double) -> Int

    TimelineEvaluator2::add_event

    source
    fn TimelineEvaluator2::add_event(self : TimelineEvaluator2, event : MotionEvent2) -> Unit

    TimelineEvaluator2::evaluate

    source
    fn TimelineEvaluator2::evaluate(self : TimelineEvaluator2, time : Double, frame : Int) -> TimelineEvaluation2

    TimelineEvaluator2::evaluate_schedule

    source
    fn TimelineEvaluator2::evaluate_schedule(self : TimelineEvaluator2, schedule : FrameSchedule2) -> Array[TimelineEvaluation2]

    TimelineEvaluator2::graph

    source

    TimelineEvaluator2::queue

    source

    TimelineEvaluator2::render_plan

    source

    TimelineEvaluator2::seek

    source
    fn TimelineEvaluator2::seek(self : TimelineEvaluator2, time : Double) -> Unit

    TimelineGraph

    source
    pub struct TimelineGraph {
      nodes : Array[TimelineGraphNode]
      edges : Array[TimelineGraphEdge]
    } derive(
    Debug    )

    TimelineGraph::active_at

    source
    fn TimelineGraph::active_at(self : TimelineGraph, time : Double) -> Array[TimelineGraphNode]

    TimelineGraph::add_edge

    source

    TimelineGraph::add_node

    source
    fn TimelineGraph::add_node(self : TimelineGraph, node : TimelineGraphNode) -> Bool

    TimelineGraph::edge_count

    source
    fn TimelineGraph::edge_count(self : TimelineGraph) -> Int

    TimelineGraph::edges

    source

    TimelineGraph::has_cycle

    source
    fn TimelineGraph::has_cycle(self : TimelineGraph) -> Bool

    TimelineGraph::node_count

    source
    fn TimelineGraph::node_count(self : TimelineGraph) -> Int

    TimelineGraph::nodes

    source

    TimelineGraph::resolve

    source

    TimelineGraph::sample

    source
    fn TimelineGraph::sample(self : TimelineGraph, time : Double) -> TimelineGraphSample

    TimelineGraph::shift

    source
    fn TimelineGraph::shift(self : TimelineGraph, delta : Double) -> TimelineGraph

    TimelineGraph::time_range

    source
    fn TimelineGraph::time_range(self : TimelineGraph) -> (Double, Double)

    TimelineGraph::topological_order

    source
    fn TimelineGraph::topological_order(self : TimelineGraph) -> Array[Int]

    TimelineGraphEdge

    source
    pub struct TimelineGraphEdge {
      from : Int
      to : Int
      kind : TimelineEdgeKind
    } derive(
    Debug    )

    TimelineGraphEdge::from

    source
    fn TimelineGraphEdge::from(self : TimelineGraphEdge) -> Int

    TimelineGraphEdge::kind

    source

    TimelineGraphEdge::to

    source
    fn TimelineGraphEdge::to(self : TimelineGraphEdge) -> Int

    TimelineGraphNode

    source
    pub struct TimelineGraphNode {
      id : Int
      name : String
      start : Double
      duration : Double
      enabled : Bool
    } derive(
    Debug    )

    A dependency graph for arranging independent motion lanes in a composition. Nodes carry timing only; payloads can remain in application code and be sampled through the returned schedule.

    TimelineGraphNode::duration

    source
    fn TimelineGraphNode::duration(self : TimelineGraphNode) -> Double

    TimelineGraphNode::enabled

    source
    fn TimelineGraphNode::enabled(self : TimelineGraphNode) -> Bool

    TimelineGraphNode::end

    source
    fn TimelineGraphNode::end(self : TimelineGraphNode) -> Double

    TimelineGraphNode::id

    source
    fn TimelineGraphNode::id(self : TimelineGraphNode) -> Int

    TimelineGraphNode::name

    source
    fn TimelineGraphNode::name(self : TimelineGraphNode) -> String

    TimelineGraphNode::start

    source
    fn TimelineGraphNode::start(self : TimelineGraphNode) -> Double

    TimelineGraphNode::with_enabled

    source
    fn TimelineGraphNode::with_enabled(self : TimelineGraphNode, enabled : Bool) -> TimelineGraphNode

    TimelineGraphNode::with_start

    source
    fn TimelineGraphNode::with_start(self : TimelineGraphNode, start : Double) -> TimelineGraphNode

    TimelineGraphSample

    source
    pub struct TimelineGraphSample {
      time : Double
      active_ids : Array[Int]
      progress : Array[Double]
    } derive(
    Debug    )

    TimelineGraphSample::active_ids

    source
    fn TimelineGraphSample::active_ids(self : TimelineGraphSample) -> Array[Int]

    TimelineGraphSample::progress

    source
    fn TimelineGraphSample::progress(self : TimelineGraphSample) -> Array[Double]

    TimelineGraphSample::time

    source
    fn TimelineGraphSample::time(self : TimelineGraphSample) -> Double

    TimelineValue

    source
    pub(all) struct TimelineValue {
      name : String
      value : Double
    } derive(
    Debug    )

    TimelineValue::name

    source
    fn TimelineValue::name(self : TimelineValue) -> String

    TimelineValue::value

    source
    fn TimelineValue::value(self : TimelineValue) -> Double

    ToneMapping

    source
    pub enum ToneMapping {
      ClampTone
      Reinhard
      Exposure(Double)
      Filmic
    } derive(
    Debug    )

    TrackBuilder

    source
    pub struct TrackBuilder {
      frames : Array[Keyframe]
    }

    A mutable builder useful for editors that add frames interactively.

    TrackBuilder::add

    source
    fn TrackBuilder::add(self : TrackBuilder, frame : Keyframe) -> Unit

    TrackBuilder::build

    source

    TrackBuilder::new

    source

    TrackBuilder::remove_at

    source
    fn TrackBuilder::remove_at(self : TrackBuilder, index : Int) -> Keyframe?

    TrackBuilder::replace

    source
    fn TrackBuilder::replace(self : TrackBuilder, index : Int, frame : Keyframe) -> Bool

    TrackSlot

    source
    pub struct TrackSlot {
      name : String
      track : ScalarTrack
      offset : Double
      enabled : Bool
    } derive(
    Debug    )

    A named scalar track placed on a shared media timeline.

    TrackSlot::enabled

    source
    fn TrackSlot::enabled(self : TrackSlot) -> Bool

    TrackSlot::name

    source
    fn TrackSlot::name(self : TrackSlot) -> String

    TrackSlot::offset

    source
    fn TrackSlot::offset(self : TrackSlot) -> Double

    TrackSlot::track

    source
    fn TrackSlot::track(self : TrackSlot) -> ScalarTrack

    Transform2D

    source
    pub(all) struct Transform2D {
      position : Point2
      scale : Point2
      rotation : Double
      skew : Double
    } derive(
    Debug    )

    2D affine transform represented as translation, scale, rotation and skew.

    Transform2D::position

    source
    fn Transform2D::position(self : Transform2D) -> Point2

    Transform2D::rotation

    source
    fn Transform2D::rotation(self : Transform2D) -> Double

    Transform2D::scale

    source
    fn Transform2D::scale(self : Transform2D) -> Point2

    Transform2D::skew

    source
    fn Transform2D::skew(self : Transform2D) -> Double

    Transform2Sample

    source
    pub struct Transform2Sample {
      time : Double
      value : Transform2D
      matrix : Affine2D
    } derive(
    Debug    )

    Transform2Sample::matrix

    source

    Transform2Sample::time

    source
    fn Transform2Sample::time(self : Transform2Sample) -> Double

    Transform2Sample::value

    source

    Transform3BlendLayer

    source
    pub struct Transform3BlendLayer {
      value : Transform3D
      weight : Double
      priority : Int
    } derive(
    Debug    )

    Transform3BlendLayer::priority

    source
    fn Transform3BlendLayer::priority(self : Transform3BlendLayer) -> Int

    Transform3BlendLayer::value

    source

    Transform3BlendLayer::weight

    source
    fn Transform3BlendLayer::weight(self : Transform3BlendLayer) -> Double

    Transform3D

    source
    pub(all) struct Transform3D {
      position : Point3
      rotation : Quaternion
      scale : Point3
    } derive(
    Debug    )

    A compact affine transform for scene graphs and camera rigs.

    Transform3D::apply

    source
    fn Transform3D::apply(self : Transform3D, value : Point3) -> Point3

    Transform3D::around

    source
    fn Transform3D::around(self : Transform3D, pivot : Point3) -> Transform3D

    Transform3D::combine

    source
    fn Transform3D::combine(self : Transform3D, child : Transform3D) -> Transform3D

    Transform3D::identity

    source
    fn Transform3D::identity() -> Transform3D

    Transform3D::inverse

    source
    fn Transform3D::inverse(self : Transform3D) -> Transform3D

    Transform3D::is_identity

    source
    fn Transform3D::is_identity(self : Transform3D) -> Bool

    Transform3D::lerp

    source
    fn Transform3D::lerp(self : Transform3D, other : Transform3D, amount : Double) -> Transform3D

    Transform3D::matrix

    source
    fn Transform3D::matrix(self : Transform3D) -> Matrix4

    Transform3D::position

    source
    fn Transform3D::position(self : Transform3D) -> Point3

    Transform3D::rotation

    source
    fn Transform3D::rotation(self : Transform3D) -> Quaternion

    Transform3D::scale

    source
    fn Transform3D::scale(self : Transform3D) -> Point3

    Transform3D::scaled

    source
    fn Transform3D::scaled(self : Transform3D, multiplier : Point3) -> Transform3D

    Transform3D::translated

    source
    fn Transform3D::translated(self : Transform3D, offset : Point3) -> Transform3D

    Transform3D::with_position

    source
    fn Transform3D::with_position(self : Transform3D, position : Point3) -> Transform3D

    Transform3D::with_rotation

    source
    fn Transform3D::with_rotation(self : Transform3D, rotation : Quaternion) -> Transform3D

    Transform3D::with_scale

    source
    fn Transform3D::with_scale(self : Transform3D, scale : Point3) -> Transform3D

    Transform3Delta

    source
    pub struct Transform3Delta {
      translation : Point3
      rotation : Quaternion
      scale : Point3
    } derive(
    Debug    )

    Spatial interpolation helpers for camera rigs and scene objects.

    Transform3Delta::rotation

    source

    Transform3Delta::scale

    source

    Transform3Delta::translation

    source
    fn Transform3Delta::translation(self : Transform3Delta) -> Point3

    Transform3Keyframe

    source
    pub struct Transform3Keyframe {
      time : Double
      value : Transform3D
      curve : Curve
    } derive(
    Debug    )

    A keyframe for a 3D transform track.

    Transform3Keyframe::curve

    source

    Transform3Keyframe::time

    source
    fn Transform3Keyframe::time(self : Transform3Keyframe) -> Double

    Transform3Keyframe::value

    source

    Transform3Track

    source
    pub struct Transform3Track {
      frames : Array[Transform3Keyframe]
    } derive(
    Debug    )

    Interpolates translation, scale, and rotation independently.

    Transform3Track::duration

    source
    fn Transform3Track::duration(self : Transform3Track) -> Double

    Transform3Track::end_time

    source
    fn Transform3Track::end_time(self : Transform3Track) -> Double

    Transform3Track::keyframes

    source

    Transform3Track::length

    source
    fn Transform3Track::length(self : Transform3Track) -> Int

    Transform3Track::map_values

    source
    fn Transform3Track::map_values(self : Transform3Track, mapper : (Transform3D) -> Transform3D) -> Transform3Track raise MotionError

    Transform3Track::new

    source

    Transform3Track::sample

    source
    fn Transform3Track::sample(self : Transform3Track, time : Double, mode? : Extrapolation) -> Transform3D

    Transform3Track::sample_many

    source
    fn Transform3Track::sample_many(self : Transform3Track, count : Int, mode? : Extrapolation) -> Array[Transform3D] raise MotionError

    Transform3Track::scale_time

    source
    fn Transform3Track::scale_time(self : Transform3Track, factor : Double) -> Transform3Track raise MotionError

    Transform3Track::shift

    source
    fn Transform3Track::shift(self : Transform3Track, offset : Double) -> Transform3Track raise MotionError

    Transform3Track::start_time

    source
    fn Transform3Track::start_time(self : Transform3Track) -> Double

    Transform3Track::velocity

    source
    fn Transform3Track::velocity(self : Transform3Track, time : Double) -> Point3

    TransformKeyframe

    source
    pub struct TransformKeyframe {
      time : Double
      value : Transform2D
      curve : Curve
    } derive(
    Debug    )

    A transform track that interpolates translation, scale, rotation, and skew.

    TransformTrack

    source
    pub struct TransformTrack {
      frames : Array[TransformKeyframe]
      shortest_rotation : Bool
    } derive(
    Debug    )

    TransformTrack::duration

    source
    fn TransformTrack::duration(self : TransformTrack) -> Double

    TransformTrack::end_time

    source
    fn TransformTrack::end_time(self : TransformTrack) -> Double

    TransformTrack::keyframes

    source

    TransformTrack::length

    source
    fn TransformTrack::length(self : TransformTrack) -> Int

    TransformTrack::new

    source
    fn TransformTrack::new(frames : Array[TransformKeyframe], shortest_rotation? : Bool) -> TransformTrack raise MotionError

    TransformTrack::sample

    source
    fn TransformTrack::sample(self : TransformTrack, time : Double, mode? : Extrapolation) -> Transform2D

    TransformTrack::sample_many

    source
    fn TransformTrack::sample_many(self : TransformTrack, count : Int, mode? : Extrapolation) -> Array[Transform2D] raise MotionError

    TransformTrack::start_time

    source
    fn TransformTrack::start_time(self : TransformTrack) -> Double

    TransportFrame

    source
    pub struct TransportFrame {
      index : Int
      time : Double
      normalized : Double
      marker_hits : Array[MarkerHit]
    } derive(
    Debug    )

    A fixed-rate export iterator that emits frame times and marker events.

    TransportFrame::index

    source
    fn TransportFrame::index(self : TransportFrame) -> Int

    TransportFrame::marker_hits

    source
    fn TransportFrame::marker_hits(self : TransportFrame) -> Array[MarkerHit]

    TransportFrame::normalized

    source
    fn TransportFrame::normalized(self : TransportFrame) -> Double

    TransportFrame::time

    source
    fn TransportFrame::time(self : TransportFrame) -> Double

    TransportRange

    source
    pub struct TransportRange {
      start : Double
      end : Double
    } derive(
    Debug    )

    A transport window with explicit in/out points for media scrubbing.

    TransportRange::clamp

    source
    fn TransportRange::clamp(self : TransportRange, time : Double) -> Double

    TransportRange::contains

    source
    fn TransportRange::contains(self : TransportRange, time : Double) -> Bool

    TransportRange::duration

    source
    fn TransportRange::duration(self : TransportRange) -> Double

    TransportRange::end

    source
    fn TransportRange::end(self : TransportRange) -> Double

    TransportRange::normalized

    source
    fn TransportRange::normalized(self : TransportRange, time : Double) -> Double

    TransportRange::start

    source
    fn TransportRange::start(self : TransportRange) -> Double

    TransportStatus

    source
    pub(all) enum TransportStatus {
      Stopped
      Playing
      Paused
      Finished
    } derive(Eq, 
    Debug    )

    Tween

    source
    pub struct Tween {
      from : Double
      to : Double
      duration : Double
      delay : Double
      repeat_count : Int
      mode : Extrapolation
      curve : Curve
    } derive(
    Debug    )

    A scalar tween with delay, repeats, and optional ping-pong direction.

    Tween::delay

    source
    fn Tween::delay(self : Tween) -> Double

    Tween::duration

    source
    fn Tween::duration(self : Tween) -> Double

    Tween::from

    source
    fn Tween::from(self : Tween) -> Double

    Tween::new

    source
    fn Tween::new(from : Double, to : Double, duration : Double, delay? : Double, repeat_count? : Int, mode? : Extrapolation, curve? : Curve) -> Tween raise MotionError

    Tween::repeat_count

    source
    fn Tween::repeat_count(self : Tween) -> Int

    Tween::sample

    source
    fn Tween::sample(self : Tween, time : Double) -> TweenSample

    Sample a tween at wall-clock time. Time and duration use the same units.

    Tween::sample_many

    source
    fn Tween::sample_many(self : Tween, count : Int) -> Array[TweenSample] raise MotionError

    Tween::sample_motion

    source
    fn Tween::sample_motion(self : Tween, time : Double) -> MotionSample

    Tween::to

    source
    fn Tween::to(self : Tween) -> Double

    Tween::total_duration

    source
    fn Tween::total_duration(self : Tween) -> Double

    Tween::value_at

    source
    fn Tween::value_at(self : Tween, time : Double) -> Double

    Tween::velocity_at

    source
    fn Tween::velocity_at(self : Tween, time : Double) -> Double

    TweenSample

    source
    pub(all) struct TweenSample {
      time : Double
      value : Double
      progress : Double
      cycle : Int
      state : TweenState
    } derive(
    Debug    )

    A value sample with enough metadata for a renderer or UI state machine.

    TweenSample::cycle

    source
    fn TweenSample::cycle(self : TweenSample) -> Int

    TweenSample::progress

    source
    fn TweenSample::progress(self : TweenSample) -> Double

    TweenSample::state

    source
    fn TweenSample::state(self : TweenSample) -> TweenState

    TweenSample::value

    source
    fn TweenSample::value(self : TweenSample) -> Double

    TweenSequence

    source
    pub struct TweenSequence {
      tweens : Array[Tween]
      gap : Double
    } derive(
    Debug    )

    A serial composition of Tweens with optional gaps between segments.

    TweenSequence::duration

    source
    fn TweenSequence::duration(self : TweenSequence) -> Double

    TweenSequence::gap

    source
    fn TweenSequence::gap(self : TweenSequence) -> Double

    TweenSequence::length

    source
    fn TweenSequence::length(self : TweenSequence) -> Int

    TweenSequence::new

    source
    fn TweenSequence::new(tweens : Array[Tween], gap? : Double) -> TweenSequence raise MotionError

    TweenSequence::sample

    source
    fn TweenSequence::sample(self : TweenSequence, time : Double) -> SequenceSample

    Sample the sequence in wall-clock time. A gap holds the previous value.

    TweenSequence::sample_many

    source
    fn TweenSequence::sample_many(self : TweenSequence, count : Int) -> Array[SequenceSample] raise MotionError

    TweenSequence::tweens

    source
    fn TweenSequence::tweens(self : TweenSequence) -> Array[Tween]

    TweenSequence::value_at

    source
    fn TweenSequence::value_at(self : TweenSequence, time : Double) -> Double

    TweenState

    source
    pub(all) enum TweenState {
      Before
      Active
      After
    } derive(Eq, 
    Debug    )

    Lifecycle state of a tween sample.

    ValidationBundle2

    source
    pub struct ValidationBundle2 {
      reports : Array[DiagnosticReport2]
      summary : DiagnosticSummary2
    } derive(
    Debug    )

    ValidationBundle2::passed

    source
    fn ValidationBundle2::passed(self : ValidationBundle2) -> Bool

    ValidationBundle2::reports

    source

    ValidationBundle2::summary

    source

    VectorField2

    source
    pub struct VectorField2 {
      mode : VectorFieldMode2
      scale : Double
      falloff : Double
      bounds : Bounds2D?
    } derive(
    Debug    )

    VectorField2::integrate

    source
    fn VectorField2::integrate(self : VectorField2, particle : FieldParticle2, start : Double, end : Double, steps : Int, drag : Double) -> Array[Point2]

    VectorField2::mode

    source

    VectorField2::sample

    source
    fn VectorField2::sample(self : VectorField2, position : Point2, time : Double) -> Point2

    VectorField2::step

    source
    fn VectorField2::step(self : VectorField2, particle : FieldParticle2, time : Double, dt : Double, drag : Double) -> FieldParticle2

    VectorField2::with_bounds

    source
    fn VectorField2::with_bounds(self : VectorField2, bounds : Bounds2D) -> VectorField2

    VectorField2::with_falloff

    source
    fn VectorField2::with_falloff(self : VectorField2, falloff : Double) -> VectorField2

    VectorField2::with_scale

    source
    fn VectorField2::with_scale(self : VectorField2, scale : Double) -> VectorField2

    VectorFieldMode2

    source
    pub enum VectorFieldMode2 {
      UniformField(Point2)
      RadialField(Point2, Double)
      VortexField(Point2, Double)
      NoiseField(NoiseSource2, Double)
    } derive(
    Debug    )

    Continuous vector fields for particles, brush strokes, and procedural camera offsets. A field owns its evaluator so integration stays backend independent.

    Viewport

    source
    pub struct Viewport {
      width : Double
      height : Double
      pixel_ratio : Double
    } derive(
    Debug    )

    A viewport in physical pixels. The camera keeps this separate from the animation timeline so a composition can be rendered at several sizes.

    Viewport::aspect

    source
    fn Viewport::aspect(self : Viewport) -> Double

    Viewport::center

    source
    fn Viewport::center(self : Viewport) -> Point2

    Viewport::height

    source
    fn Viewport::height(self : Viewport) -> Double

    Viewport::physical_height

    source
    fn Viewport::physical_height(self : Viewport) -> Double

    Viewport::physical_width

    source
    fn Viewport::physical_width(self : Viewport) -> Double

    Viewport::pixel_ratio

    source
    fn Viewport::pixel_ratio(self : Viewport) -> Double

    Viewport::width

    source
    fn Viewport::width(self : Viewport) -> Double

    adaptive_sample

    source
    fn adaptive_sample(func : (Double) -> Double, start : Double, end : Double, config : AdaptiveSamplingConfig) -> AdaptiveSampleResult raise MotionError

    Recursively sample a scalar curve where curvature exceeds a tolerance.

    adaptive_sample_tween

    source
    fn adaptive_sample_tween(tween : Tween, start : Double, end : Double, config : AdaptiveSamplingConfig) -> AdaptiveSampleResult raise MotionError

    advect_points2

    source
    fn advect_points2(field : VectorField2, points : Array[Point2], time : Double, dt : Double) -> Array[Point2]

    affine2d_from_transform

    source
    fn affine2d_from_transform(value : Transform2D) -> Affine2D

    affine2d_identity

    source
    fn affine2d_identity() -> Affine2D

    affine2d_rotation

    source
    fn affine2d_rotation(angle : Double) -> Affine2D

    affine2d_scale

    source
    fn affine2d_scale(value : Point2) -> Affine2D

    affine2d_skew

    source
    fn affine2d_skew(skew : Double) -> Affine2D

    affine2d_translation

    source
    fn affine2d_translation(value : Point2) -> Affine2D

    all_easings

    source
    fn all_easings() -> Array[EasingId]

    Enumerate the built-ins in a stable order for editors and documentation.

    analyze_bezier

    source
    fn analyze_bezier(curve : Bezier, samples : Int) -> CurveReport

    analyze_curve

    source
    fn analyze_curve(curve : Curve, samples : Int) -> CurveStatistics

    analyze_easing

    source
    fn analyze_easing(func : (Double) -> Double, samples : Int) -> CurveReport

    Inspect an arbitrary easing function using a fixed normalized grid.

    analyze_easing_id

    source
    fn analyze_easing_id(id : EasingId, samples : Int) -> CurveReport

    analyze_path2d

    source
    fn analyze_path2d(path : Path2D, count : Int) -> Path2DMetric2

    analyze_point_series2

    source
    fn analyze_point_series2(series : PointSeries2, target : Point2, tolerance : Double) -> MotionMetrics2

    analyze_samples

    source
    fn analyze_samples(samples : Array[SamplePoint]) -> Array[CurveAnalysisPoint]

    apply_camera_post

    source
    fn apply_camera_post(camera : CameraRig, settings : CameraPostSettings2) -> CameraRig

    apply_groove

    source
    fn apply_groove(beat : Double, pattern : GroovePattern) -> Double

    apply_shake_falloff

    source
    fn apply_shake_falloff(value : Point2, mode : ShakeFalloff2, ratio : Double) -> Point2

    apply_transform3_delta

    source
    fn apply_transform3_delta(value : Transform3D, delta : Transform3Delta, weight : Double) -> Transform3D

    aspect_ratio2

    source
    fn aspect_ratio2(width : Int, height : Int) -> Double

    back_in

    source
    fn back_in(t : Double, overshoot? : Double) -> Double

    Back easing with configurable overshoot.

    back_in_out

    source
    fn back_in_out(t : Double, overshoot? : Double) -> Double

    back_out

    source
    fn back_out(t : Double, overshoot? : Double) -> Double

    beat_cue

    source
    fn beat_cue(beat : Double, label : String, duration? : Double, strength? : Double) -> BeatCue

    beat_grid

    source
    fn beat_grid(tempo : TempoTimeline, signature : TimeSignature2) -> BeatGrid

    bezier_clamped

    source
    fn bezier_clamped(x1 : Double, y1 : Double, x2 : Double, y2 : Double) -> Bezier

    Construct a curve while clamping its x controls to the CSS-valid range.

    blend

    source
    fn blend(first : (Double) -> Double, second : (Double) -> Double, amount~ : Double) -> ((Double) -> Double)

    Blend two curves with an amount in the closed interval [0, 1].

    blend_bundles

    source
    fn blend_bundles(first : ScalarTrackBundle, second : ScalarTrackBundle, amount : Double) -> ScalarTrackBundle raise MotionError

    Blend two bundles by channel name. Missing channels are carried through from the bundle that contains them.

    blend_color_layers

    source
    fn blend_color_layers(layers : Array[ColorBlendLayer], fallback : Rgba) -> Rgba

    blend_mask2d

    source
    fn blend_mask2d(values : Array[Double], default_weight? : Double) -> BlendMask2D

    blend_mode_name

    source
    fn blend_mode_name(mode : BlendMode) -> String

    blend_modes

    source
    fn blend_modes() -> Array[BlendMode]

    blend_point2_layers

    source
    fn blend_point2_layers(layers : Array[Point2BlendLayer], fallback : Point2) -> Point2

    blend_point3_layers

    source
    fn blend_point3_layers(layers : Array[Point3BlendLayer], fallback : Point3) -> Point3

    blend_rgba

    source
    fn blend_rgba(base : Rgba, source : Rgba, mode : BlendMode) -> Rgba

    blend_scalar_layers

    source
    fn blend_scalar_layers(layers : Array[ScalarBlendLayer], fallback : Double) -> Double

    blend_transform3_layers

    source
    fn blend_transform3_layers(layers : Array[Transform3BlendLayer], fallback : Transform3D) -> Transform3D

    blend_values

    source
    fn blend_values(first : Array[Double], second : Array[Double], amount : Double) -> Array[Double]

    bounce_in

    source
    fn bounce_in(t : Double) -> Double

    bounce_in_out

    source
    fn bounce_in_out(t : Double) -> Double

    bounce_out

    source
    fn bounce_out(t : Double) -> Double

    Piecewise quadratic bounce used for UI and game motion.

    bounds2d

    source
    fn bounds2d(minimum : Point2, maximum : Point2) -> Bounds2D

    bounds3d

    source
    fn bounds3d(minimum : Point3, maximum : Point3) -> Bounds3D

    build_envelope

    source
    fn build_envelope(curves : Array[Curve], samples : Int) -> CurveEnvelope

    build_event_window

    source
    fn build_event_window(queue : MotionEventQueue2, previous : Double, current : Double) -> EventWindow2

    build_path_frame

    source
    fn build_path_frame(sample : PathSample3D, up : Point3) -> PathFrame3D

    build_path_metric_profile

    source
    fn build_path_metric_profile(path : Path3D, count : Int) -> PathMetricProfile3D

    cache_pool2

    source
    fn cache_pool2(capacity? : Int) -> CachePool2

    camera_center_of_bounds

    source
    fn camera_center_of_bounds(bounds : Bounds3D) -> Point3

    camera_depth_of

    source
    fn camera_depth_of(camera : CameraRig, point : Point3) -> Double

    camera_focus_weight

    source
    fn camera_focus_weight(camera : CameraRig, point : Point3, focus : Double, falloff : Double) -> Double

    camera_framing2

    source
    fn camera_framing2(center : Point3, radius : Double, policy : FramingPolicy2, margin? : Double) -> CameraFraming2

    camera_framing_error

    source
    fn camera_framing_error(camera : CameraRig, bounds : Bounds3D, margin : Double) -> Double

    camera_keyframe

    source
    fn camera_keyframe(time : Double, pose : CameraPose, lens : CameraLens, curve? : Curve) -> CameraKeyframe raise MotionError

    camera_motion_delta

    source
    fn camera_motion_delta(first : CameraRig, second : CameraRig) -> (Double, Double)

    camera_pose

    source
    fn camera_pose(position : Point3, target : Point3, up? : Point3, roll? : Double) -> CameraPose

    camera_post_settings2

    source
    fn camera_post_settings2() -> CameraPostSettings2

    camera_radius_of_bounds

    source
    fn camera_radius_of_bounds(bounds : Bounds3D) -> Double

    camera_rig

    source
    fn camera_rig(pose : CameraPose, lens : CameraLens, viewport : Viewport) -> CameraRig

    catmull_rom

    source
    fn catmull_rom(previous : Double, start : Double, end : Double, next : Double, t : Double, tension? : Double) -> Double

    Catmull-Rom interpolation across four scalar samples.

    catmull_rom_array

    source
    fn catmull_rom_array(values : Array[Double], position : Double) -> Double

    Cubic interpolation over a value array using clamped endpoint samples.

    catmull_rom_point2

    source
    fn catmull_rom_point2(previous : Point2, start : Point2, end : Point2, next : Point2, t : Double, tension? : Double) -> Point2

    catmull_rom_point3

    source
    fn catmull_rom_point3(previous : Point3, start : Point3, end : Point3, next : Point3, t : Double, tension? : Double) -> Point3

    circ_in

    source
    fn circ_in(t : Double) -> Double

    circ_in_out

    source
    fn circ_in_out(t : Double) -> Double

    circ_out

    source
    fn circ_out(t : Double) -> Double

    clamp01

    source
    fn clamp01(value : Double) -> Double

    clamp_values

    source
    fn clamp_values(values : Array[Double], bounds : MotionBounds) -> Array[Double]

    classify_monotonicity

    source
    fn classify_monotonicity(samples : Array[SamplePoint], tolerance? : Double) -> CurveMonotonicity

    cleanup_samples

    source
    fn cleanup_samples(values : Array[Double], tolerance : Double) -> (Array[Double], KeyframeCleanupReport)

    color_blend_layer

    source
    fn color_blend_layer(value : Rgba, weight : Double, mode? : BlendMode, priority? : Int) -> ColorBlendLayer

    color_matrix_brightness

    source
    fn color_matrix_brightness(value : Double) -> ColorMatrix

    color_matrix_contrast

    source
    fn color_matrix_contrast(value : Double) -> ColorMatrix

    color_matrix_identity

    source
    fn color_matrix_identity() -> ColorMatrix

    color_matrix_saturation

    source
    fn color_matrix_saturation(value : Double) -> ColorMatrix

    color_ramp_stop

    source
    fn color_ramp_stop(position : Double, color : Rgba) -> ColorRampStop

    color_series2

    source
    fn color_series2(times : Array[Double], values : Array[Rgba]) -> ColorSeries2

    compare_curves

    source
    fn compare_curves(first : Curve, second : Curve, samples : Int) -> CurveComparison

    compare_motion_metrics2

    source
    fn compare_motion_metrics2(first : MotionMetrics2, second : MotionMetrics2) -> Array[Double]

    compose

    source
    fn compose(outer : (Double) -> Double, inner : (Double) -> Double) -> ((Double) -> Double)

    Compose two curves. outer(inner(t)) is evaluated without intermediate arrays.

    compose_curve_pipeline

    source
    fn compose_curve_pipeline(first : CurvePipeline2, second : CurvePipeline2) -> CurvePipeline2

    compose_retime

    source
    fn compose_retime(first : RetimeMap, second : RetimeMap, samples_per_segment? : Int) -> RetimeMap raise MotionError

    constrain_point2_step

    source
    fn constrain_point2_step(target : Point2, current : Point2, velocity : Point2, acceleration : Point2, dt : Double, limit : MotionLimitProfile2) -> Point2ConstraintResult

    constrain_point3_step

    source
    fn constrain_point3_step(target : Point3, current : Point3, velocity : Point3, acceleration : Point3, dt : Double, limit : MotionLimitProfile2) -> Point3ConstraintResult

    constrain_scalar_step

    source
    fn constrain_scalar_step(target : Double, current : Double, velocity : Double, acceleration : Double, dt : Double, limit : MotionLimitProfile2) -> ConstraintResult2

    constraint_solve_config

    source
    fn constraint_solve_config(frame_rate : Double, limits : MotionLimitProfile2) -> ConstraintSolveConfig

    constraint_statuses2

    source
    fn constraint_statuses2() -> Array[ConstraintStatus2]

    convex_hull

    source
    fn convex_hull(points : Array[Point2]) -> Polygon2D

    convolve_signal

    source
    fn convolve_signal(signal : MotionSignal, kernel : Array[Double]) -> MotionSignal

    Convolve a signal with a finite kernel, using edge replication.

    critically_damped_step

    source
    fn critically_damped_step(current : Double, target : Double, velocity : Double, response : Double, delta_time : Double) -> (Double, Double)

    cubic_in

    source
    fn cubic_in(t : Double) -> Double

    Cubic acceleration.

    cubic_in_out

    source
    fn cubic_in_out(t : Double) -> Double

    Cubic acceleration followed by deceleration.

    cubic_out

    source
    fn cubic_out(t : Double) -> Double

    Cubic deceleration.

    cubic_path2d

    source
    fn cubic_path2d(start : Point2, control_start : Point2, control_end : Point2, end : Point2) -> CubicPath2D

    cubic_path3d

    source
    fn cubic_path3d(start : Point3, control_start : Point3, control_end : Point3, end : Point3) -> CubicPath3D

    cumulative_integral

    source
    fn cumulative_integral(signal : MotionSignal) -> MotionSignal

    curve_feature_value

    source
    fn curve_feature_value(curve : Curve, feature : CurveFeature, samples : Int) -> Double

    curve_features

    source
    fn curve_features() -> Array[CurveFeature]

    curve_invariants_pass

    source
    fn curve_invariants_pass(report : CurveInvariantReport2, tolerance : Double) -> Bool

    curve_lipschitz_bound

    source
    fn curve_lipschitz_bound(curve : Curve, samples : Int) -> Double

    curve_lookup

    source
    fn curve_lookup(func : (Double) -> Double, start : Double, end : Double, count : Int) -> Array[SamplePoint] raise MotionError

    Generate a lookup table with an explicit endpoint policy.

    curve_lut_bank

    source
    fn curve_lut_bank() -> CurveLutBank

    curve_lut_builder

    source
    fn curve_lut_builder(curve : Curve) -> CurveLutBuilder

    curve_maximum

    source
    fn curve_maximum(samples : Array[SamplePoint]) -> SamplePoint?

    curve_minimum

    source
    fn curve_minimum(samples : Array[SamplePoint]) -> SamplePoint?

    curve_minimum_time

    source
    fn curve_minimum_time(curve : Curve, samples : Int) -> Double

    curve_peak_time

    source
    fn curve_peak_time(curve : Curve, samples : Int) -> Double

    curve_pipeline2

    source
    fn curve_pipeline2(curve : Curve) -> CurvePipeline2

    curve_pipeline_error

    source
    fn curve_pipeline_error(pipeline : CurvePipeline2, table : CurveLookupTable, samples : Int) -> Double

    curve_remap2

    source
    fn curve_remap2(input_min : Double, input_max : Double, output_min : Double, output_max : Double) -> CurveRemap2

    curve_stages2

    source
    fn curve_stages2() -> Array[CurveStage2]

    curve_total_variation2

    source
    fn curve_total_variation2(curve : Curve, samples : Int) -> Double

    damp_to_range

    source
    fn damp_to_range(value : Double, minimum : Double, maximum : Double, strength : Double) -> Double

    decimate_samples

    source
    fn decimate_samples(samples : Array[SamplePoint], stride : Int) -> Array[SamplePoint]

    Downsample a sample array by keeping every nth frame and preserving the end.

    derivative_of

    source
    fn derivative_of(func : (Double) -> Double, t : Double, step? : Double) -> Double

    Numerically estimate a first derivative without allocating a sample buffer.

    deterministic_jitter

    source
    fn deterministic_jitter(seed : Int, index : Int) -> Double

    diagnostic_code_name2

    source
    fn diagnostic_code_name2(code : DiagnosticCode2) -> String

    diagnostic_codes2

    source
    fn diagnostic_codes2() -> Array[DiagnosticCode2]

    diagnostic_report2

    source
    fn diagnostic_report2(name : String) -> DiagnosticReport2

    diagnostic_severities2

    source
    fn diagnostic_severities2() -> Array[DiagnosticSeverity2]

    diagnostic_severity_name2

    source
    fn diagnostic_severity_name2(severity : DiagnosticSeverity2) -> String

    differentiate

    source
    fn differentiate(values : Array[Double], step : Double) -> Array[Double]

    First difference of a sampled signal with an explicit time step.

    differentiate_signal

    source
    fn differentiate_signal(signal : MotionSignal) -> MotionSignal

    Differentiate a signal using central differences in the interior.

    easing

    source
    fn easing(id : EasingId) -> ((Double) -> Double)

    Return a first-class easing function for use in a sampler or a custom blend.

    elastic_in

    source
    fn elastic_in(t : Double, amplitude? : Double, period? : Double) -> Double

    Elastic acceleration. Amplitude and period are normalized motion controls.

    elastic_in_out

    source
    fn elastic_in_out(t : Double, amplitude? : Double, period? : Double) -> Double

    elastic_out

    source
    fn elastic_out(t : Double, amplitude? : Double, period? : Double) -> Double

    enforce_monotonic

    source
    fn enforce_monotonic(values : Array[Double], increasing : Bool) -> Array[Double]

    enforce_range

    source
    fn enforce_range(values : Array[Double], minimum : Double, maximum : Double) -> Array[Double]

    estimate_compressed_bytes

    source
    fn estimate_compressed_bytes(frame_count : Int, width : Int, height : Int, bits_per_pixel : Double, compression : Double) -> Int

    estimate_settling_time

    source
    fn estimate_settling_time(curve : Curve, tolerance : Double, samples : Int) -> Double

    estimate_zero_crossings

    source
    fn estimate_zero_crossings(curve : Curve, samples : Int) -> Int

    evaluate_color_track

    source
    fn evaluate_color_track(track : RgbaTrack, schedule : FrameSchedule2) -> ColorSeries2

    evaluate_point2_track

    source
    fn evaluate_point2_track(track : Point2Track, schedule : FrameSchedule2) -> PointSeries2

    evaluate_render_quality

    source
    fn evaluate_render_quality(expected : Array[Double], actual : Array[Double], expected_colors : Array[Rgba], actual_colors : Array[Rgba]) -> RenderQualityMetrics2

    evaluate_scalar_track

    source
    fn evaluate_scalar_track(track : ScalarTrack, schedule : FrameSchedule2) -> ScalarSeries2

    evaluation_context2

    source
    fn evaluation_context2(time : Double, frame : Int, normalized : Double, delta : Double, direction : Int) -> EvaluationContext2

    evaluation_progress

    source
    fn evaluation_progress(values : Array[TimelineEvaluation2]) -> Array[Double]

    evaluation_times

    source
    fn evaluation_times(values : Array[TimelineEvaluation2]) -> Array[Double]

    event_queue_duration

    source
    fn event_queue_duration(queue : MotionEventQueue2) -> Double

    event_times

    source
    fn event_times(events : Array[MotionEvent2]) -> Array[Double]

    expo_in

    source
    fn expo_in(t : Double) -> Double

    expo_in_out

    source
    fn expo_in_out(t : Double) -> Double

    expo_out

    source
    fn expo_out(t : Double) -> Double

    exponential_smooth2

    source
    fn exponential_smooth2(values : Array[Double], factor : Double) -> Array[Double]

    export_chunk_count

    source
    fn export_chunk_count(schedule : FrameSchedule2, chunk_size : Int) -> Int

    export_duration_for_frames

    source
    fn export_duration_for_frames(frame_count : Int, frame_rate : Double) -> Double

    export_entry_checksum

    source
    fn export_entry_checksum(values : Array[Double]) -> Int

    export_formats2

    source
    fn export_formats2() -> Array[ExportFormat2]

    export_frame_index

    source
    fn export_frame_index(schedule : FrameSchedule2, time : Double) -> Int

    export_manifest2

    source
    fn export_manifest2(settings : ExportSettings2) -> ExportManifest2

    export_manifest_entry2

    source
    fn export_manifest_entry2(id : Int, name : String, start : Double, end : Double, frame_count : Int) -> ExportManifestEntry2

    export_settings2

    source
    fn export_settings2(format : ExportFormat2, width : Int, height : Int, frame_rate : Double) -> ExportSettings2

    export_time_for_frame

    source
    fn export_time_for_frame(schedule : FrameSchedule2, frame : Int) -> Double

    field_curl2

    source
    fn field_curl2(field : VectorField2, position : Point2, time : Double, epsilon? : Double) -> Double

    field_divergence2

    source
    fn field_divergence2(field : VectorField2, position : Point2, time : Double, epsilon? : Double) -> Double

    field_particle2

    source
    fn field_particle2(position : Point2, velocity : Point2, lifetime : Double) -> FieldParticle2

    filter_events_by_kind

    source
    fn filter_events_by_kind(events : Array[MotionEvent2], kind : MotionEventKind2) -> Array[MotionEvent2]

    find_signal_peaks2

    source
    fn find_signal_peaks2(values : Array[Double], threshold : Double, minimum_distance : Int) -> Array[SignalPeak2]

    first_crossing

    source
    fn first_crossing(samples : Array[SamplePoint], target : Double) -> Double?

    Find the first time at which a sorted curve reaches a target value.

    fit_dimensions2

    source
    fn fit_dimensions2(width : Int, height : Int, maximum : Int) -> (Int, Int)

    frame_budget2

    source
    fn frame_budget2(schedule : FrameSchedule2, bytes_per_frame : Int, throughput : Double) -> FrameBudget2

    frame_channels2

    source
    fn frame_channels2() -> Array[FrameChannel2]

    frame_schedule2

    source
    fn frame_schedule2(start : Double, end : Double, frame_rate : Double, first_frame? : Int) -> FrameSchedule2

    framing_policies2

    source
    fn framing_policies2() -> Array[FramingPolicy2]

    gradient_stop

    source
    fn gradient_stop(position : Double, color : Rgba, curve? : Curve) -> GradientStop raise MotionError

    graph_build_statuses

    source
    fn graph_build_statuses() -> Array[GraphBuildStatus]

    groove_patterns

    source
    fn groove_patterns() -> Array[GroovePattern]

    hermite

    source
    fn hermite(start : Double, end : Double, tangent_start : Double, tangent_end : Double, t : Double) -> Double

    Cubic Hermite interpolation. Tangents use the same units as values.

    hsv

    source
    fn hsv(hue~ : Double, saturation~ : Double, value~ : Double, alpha? : Double) -> Hsv

    inspect_colors

    source
    fn inspect_colors(name : String, colors : Array[Rgba]) -> DiagnosticReport2

    inspect_curve_endpoints

    source
    fn inspect_curve_endpoints(name : String, curve : Curve, tolerance : Double) -> DiagnosticReport2

    inspect_curve_invariants

    source
    fn inspect_curve_invariants(curve : Curve, samples : Int) -> CurveInvariantReport2

    inspect_frame_indices

    source
    fn inspect_frame_indices(schedule : FrameSchedule2, indices : Array[Int]) -> FrameDropReport2

    inspect_motion_limits

    source
    fn inspect_motion_limits(name : String, samples : Array[Double], frame_rate : Double, maximum_velocity : Double) -> DiagnosticReport2

    inspect_scalar_values

    source
    fn inspect_scalar_values(name : String, values : Array[Double], tolerance : Double) -> DiagnosticReport2

    integrate_analyzed_curve

    source
    fn integrate_analyzed_curve(samples : Array[SamplePoint]) -> Double

    Estimate the signed area under a curve using the trapezoidal rule.

    integrate_curve

    source
    fn integrate_curve(func : (Double) -> Double, samples : Int) -> Double

    Integrate a normalized curve with the trapezoid rule.

    integrate_samples

    source
    fn integrate_samples(samples : Array[SamplePoint]) -> Double

    Approximate the integral of a sampled scalar signal with trapezoids.

    integrate_signal

    source
    fn integrate_signal(signal : MotionSignal) -> Double

    interpolate_angle

    source
    fn interpolate_angle(start : Double, end : Double, t : Double) -> Double

    Interpolate an angle in radians along the shortest path.

    interpolate_hsv

    source
    fn interpolate_hsv(start : Hsv, end : Hsv, t : Double) -> Hsv

    interpolate_point2

    source
    fn interpolate_point2(start : Point2, end : Point2, t : Double) -> Point2

    interpolate_point3

    source
    fn interpolate_point3(start : Point3, end : Point3, t : Double) -> Point3

    interpolate_rgba

    source
    fn interpolate_rgba(start : Rgba, end : Rgba, t : Double, premultiplied? : Bool) -> Rgba

    Interpolate straight in RGBA space, optionally preserving premultiplied alpha.

    interpolate_rgba_hsv

    source
    fn interpolate_rgba_hsv(start : Rgba, end : Rgba, t : Double) -> Rgba

    interpolate_samples

    source
    fn interpolate_samples(samples : Array[AdaptiveSamplePoint], time : Double) -> Double

    Linear interpolation over a sorted adaptive sample.

    interpolate_scalar

    source
    fn interpolate_scalar(start : Double, end : Double, t : Double) -> Double

    Scalar interpolation primitive.

    interpolate_transform

    source
    fn interpolate_transform(start : Transform2D, end : Transform2D, t : Double, shortest_rotation? : Bool) -> Transform2D

    jitter_sequence2

    source
    fn jitter_sequence2(seed : Int, amplitude : Point2) -> JitterSequence2

    join_styles2d

    source
    fn join_styles2d() -> Array[JoinStyle2D]

    keyframe

    source
    fn keyframe(time : Double, value : Double, curve? : Curve) -> Keyframe raise MotionError

    layer_blend_modes

    source
    fn layer_blend_modes() -> Array[LayerBlendMode]

    linear

    source
    fn linear(t : Double) -> Double

    Linear interpolation with no acceleration.

    local_maxima

    source
    fn local_maxima(samples : Array[SamplePoint], prominence : Double) -> Array[SamplePoint] raise MotionError

    Keep local maxima with a configurable minimum prominence.

    lookup_value

    source
    fn lookup_value(samples : Array[SamplePoint], time : Double) -> Double

    Evaluate a table with linear interpolation and clamped boundaries.

    low_pass_signal

    source
    fn low_pass_signal(signal : MotionSignal, alpha : Double) -> MotionSignal

    Apply a first-order exponential low-pass filter.

    map_curve_range

    source
    fn map_curve_range(samples : Array[SamplePoint], output_min : Double, output_max : Double) -> Array[SamplePoint]

    Compose a source curve with an output range.

    marker

    source
    fn marker(time : Double, name : String, payload? : String) -> MotionMarker raise MotionError

    marker_cursor

    source
    fn marker_cursor(timeline : MarkerTimeline, start_time? : Double) -> MarkerCursor

    marker_sequence

    source
    fn marker_sequence(names : Array[String], start : Double, interval : Double) -> MarkerTimeline raise MotionError

    Build a timeline from a regular sequence of marker names.

    maximum_sample_error

    source
    fn maximum_sample_error(first : Array[SamplePoint], second : Array[SamplePoint]) -> Double

    Return the largest absolute error between two aligned sample arrays.

    mean

    source
    fn mean(values : Array[Double]) -> Double

    media_asset2

    source
    fn media_asset2(id : Int, name : String, kind : MediaKind2, start : Double, duration : Double, bounds : Bounds2D) -> MediaAsset2

    media_catalog2

    source
    fn media_catalog2() -> MediaCatalog2

    media_kinds2

    source
    fn media_kinds2() -> Array[MediaKind2]

    median

    source
    fn median(values : Array[Double]) -> Double

    median_filter2

    source
    fn median_filter2(values : Array[Double], radius : Int) -> Array[Double]

    metric_within_budget2

    source
    fn metric_within_budget2(metrics : MotionMetrics2, maximum_speed : Double, maximum_acceleration : Double) -> Bool

    mirror

    source
    fn mirror(ease : (Double) -> Double) -> ((Double) -> Double)

    Reflect a curve around the center point, useful for reversible UI motion.

    monotone_envelope

    source
    fn monotone_envelope(values : Array[Double]) -> Array[Double]

    Clamp a signal to a monotone non-decreasing envelope.

    monotonic_project

    source
    fn monotonic_project(values : Array[Double], increasing : Bool) -> Array[Double]

    motion_budget2

    source
    fn motion_budget2(maximum_speed : Double, maximum_acceleration : Double, maximum_path_length : Double) -> MotionBudget2

    motion_clip

    source
    fn motion_clip(name : String, track : ScalarTrack, markers? : MarkerTimeline, loop_mode? : ClipLoopMode) -> MotionClip raise MotionError

    motion_event2

    source
    fn motion_event2(time : Double, id : Int, label : String, kind : MotionEventKind2, payload? : Double) -> MotionEvent2

    motion_event_kinds2

    source
    fn motion_event_kinds2() -> Array[MotionEventKind2]

    motion_event_queue2

    source
    fn motion_event_queue2() -> MotionEventQueue2

    motion_limit_profile2

    source
    fn motion_limit_profile2(maximum_velocity? : Double, maximum_acceleration? : Double, maximum_jerk? : Double, tolerance? : Double, iterations? : Int) -> MotionLimitProfile2

    motion_profile

    source
    fn motion_profile(func : (Double) -> Double, samples : Int) -> Array[MotionSample] raise MotionError

    Produce value, velocity, and acceleration samples for a normalized curve.

    motion_report2

    source
    fn motion_report2(name : String, metrics : Array[Double], budget : MotionBudget2, quality : RenderQualityMetrics2) -> MotionReport2

    motion_state

    source
    fn motion_state(name : String, value : Double) -> MotionStateNode raise MotionError

    motion_transition

    source
    fn motion_transition(from : String, to : String, duration : Double, curve? : Curve) -> MotionStateTransition raise MotionError

    moving_average

    source
    fn moving_average(values : Array[Double], window : Int) -> Array[Double]

    Moving-average smoothing for an already sampled scalar signal.

    moving_average2

    source
    fn moving_average2(values : Array[Double], radius : Int) -> Array[Double]

    next_event_time

    source
    fn next_event_time(events : Array[MotionEvent2], after : Double) -> Double?

    noise_source2

    source
    fn noise_source2(seed : Int) -> NoiseSource2

    normalize_samples

    source
    fn normalize_samples(values : Array[Double]) -> Array[Double]

    Normalize a signal to [0, 1]. Constant signals map to zero.

    normalize_signal

    source
    fn normalize_signal(signal : MotionSignal) -> MotionSignal

    normalize_weights

    source
    fn normalize_weights(weights : Array[Double]) -> Array[Double]

    offset_path2d_samples

    source
    fn offset_path2d_samples(path : Path2D, count : Int, offset : Double) -> Array[Point2]

    offset_polyline2d

    source
    fn offset_polyline2d(line : Polyline2D, distance : Double) -> Polyline2D

    orthographic_lens

    source
    fn orthographic_lens(height : Double, near_plane? : Double, far_plane? : Double) -> CameraLens

    palette2

    source
    fn palette2(name : String, colors : Array[Rgba]) -> Palette2

    palette_average

    source
    fn palette_average(colors : Array[Rgba]) -> Rgba

    palette_gradient2

    source
    fn palette_gradient2(start : Rgba, end : Rgba, count : Int) -> Palette2

    palette_lerp

    source
    fn palette_lerp(palette : Array[Rgba], ratio : Double) -> Rgba

    palette_nearest

    source
    fn palette_nearest(palette : Array[Rgba], color : Rgba) -> Rgba

    palette_variance

    source
    fn palette_variance(colors : Array[Rgba]) -> Double

    path2d_arc_parameters

    source
    fn path2d_arc_parameters(path : Path2D, count : Int) -> Array[Double]

    path2d_closest_parameter

    source
    fn path2d_closest_parameter(path : Path2D, target : Point2, samples : Int) -> Double

    path2d_curvature_estimate

    source
    fn path2d_curvature_estimate(path : Path2D, parameter : Double, epsilon? : Double) -> Double

    path2d_curvature_profile

    source
    fn path2d_curvature_profile(path : Path2D, count : Int) -> Array[Double]

    path2d_distance_to_segment

    source
    fn path2d_distance_to_segment(path : Path2D, target : Point2, samples : Int) -> Double

    path2d_is_degenerate

    source
    fn path2d_is_degenerate(path : Path2D, tolerance : Double) -> Bool

    path2d_motion_length

    source
    fn path2d_motion_length(path : Path2D, start : Double, end : Double, samples : Int) -> Double

    path2d_normals

    source
    fn path2d_normals(path : Path2D, count : Int) -> Array[Point2]

    path2d_resample_uniform

    source
    fn path2d_resample_uniform(path : Path2D, count : Int) -> Path2DMetric2

    path2d_sample_by_distance_batch

    source
    fn path2d_sample_by_distance_batch(path : Path2D, distances : Array[Double]) -> Array[Point2]

    path2d_split_samples

    source
    fn path2d_split_samples(path : Path2D, parameters : Array[Double]) -> Array[Point2]

    path2d_tangent_batch

    source
    fn path2d_tangent_batch(path : Path2D, parameters : Array[Double]) -> Array[Point2]

    path_builder2d

    source
    fn path_builder2d(start : Point2) -> PathBuilder2D

    path_builder3d

    source
    fn path_builder3d(start : Point3) -> PathBuilder3D

    path_chord_error

    source
    fn path_chord_error(path : Path3D, samples : Int) -> Double

    path_cubic

    source
    fn path_cubic(start : Point2, control_start : Point2, control_end : Point2, end : Point2) -> PathSegment2D

    path_cubic3d

    source
    fn path_cubic3d(start : Point3, control_start : Point3, control_end : Point3, end : Point3) -> PathSegment3D

    path_is_closed

    source
    fn path_is_closed(path : Path3D, tolerance : Double) -> Bool

    path_line

    source
    fn path_line(start : Point2, end : Point2) -> PathSegment2D

    path_line3d

    source
    fn path_line3d(start : Point3, end : Point3) -> PathSegment3D

    path_speed_at

    source
    fn path_speed_at(path : Path3D, parameter : Double) -> Double

    path_speed_profile

    source
    fn path_speed_profile(path : Path3D, count : Int) -> Array[Double]

    peak_index

    source
    fn peak_index(values : Array[Double]) -> Int?

    percentile

    source
    fn percentile(values : Array[Double], ratio : Double) -> Double

    Compute a percentile value from a copied and sorted scalar array.

    perspective_lens

    source
    fn perspective_lens(field_of_view : Double, near_plane? : Double, far_plane? : Double) -> CameraLens

    point2

    source
    fn point2(x~ : Double, y~ : Double) -> Point2

    point2_angle

    source
    fn point2_angle(first : Point2, second : Point2) -> Double

    point2_blend_layer

    source
    fn point2_blend_layer(value : Point2, weight : Double, mode? : LayerBlendMode, priority? : Int) -> Point2BlendLayer

    point2_cross

    source
    fn point2_cross(first : Point2, second : Point2) -> Double

    point2_dot

    source
    fn point2_dot(first : Point2, second : Point2) -> Double

    Dot product for planar tangent and normal calculations.

    point2_from_polar

    source
    fn point2_from_polar(radius : Double, angle : Double) -> Point2

    point2_keyframe

    source
    fn point2_keyframe(time : Double, value~ : Point2, curve? : Curve) -> Point2Keyframe raise MotionError

    point2_length

    source
    fn point2_length(value : Point2) -> Double

    point2_lerp_clamped

    source
    fn point2_lerp_clamped(first : Point2, second : Point2, ratio : Double) -> Point2

    point2_normal

    source
    fn point2_normal(value : Point2) -> Point2

    point2_normalized

    source
    fn point2_normalized(value : Point2) -> Point2

    point2_reflect

    source
    fn point2_reflect(value : Point2, normal : Point2) -> Point2

    point3

    source
    fn point3(x~ : Double, y~ : Double, z~ : Double) -> Point3

    point3_blend_layer

    source
    fn point3_blend_layer(value : Point3, weight : Double, mode? : LayerBlendMode, priority? : Int) -> Point3BlendLayer

    point3_cross

    source
    fn point3_cross(first : Point3, second : Point3) -> Point3

    point3_distance

    source
    fn point3_distance(first : Point3, second : Point3) -> Double

    point3_dot

    source
    fn point3_dot(first : Point3, second : Point3) -> Double

    point3_keyframe

    source
    fn point3_keyframe(time : Double, value~ : Point3, curve? : Curve) -> Point3Keyframe raise MotionError

    point3_length

    source
    fn point3_length(value : Point3) -> Double

    point3_lerp_clamped

    source
    fn point3_lerp_clamped(first : Point3, second : Point3, ratio : Double) -> Point3

    point3_normalized

    source
    fn point3_normalized(value : Point3) -> Point3

    point_series2

    source
    fn point_series2(times : Array[Double], values : Array[Point2]) -> PointSeries2

    polygon2d

    source
    fn polygon2d(vertices : Array[Point2]) -> Polygon2D

    polygon2d_from_bounds

    source
    fn polygon2d_from_bounds(bounds : Bounds2D) -> Polygon2D

    polygon2d_rotate

    source
    fn polygon2d_rotate(polygon : Polygon2D, angle : Double, origin? : Point2) -> Polygon2D

    polygon2d_scale

    source
    fn polygon2d_scale(polygon : Polygon2D, scale : Point2, origin? : Point2) -> Polygon2D

    polygon2d_translate

    source
    fn polygon2d_translate(polygon : Polygon2D, offset : Point2) -> Polygon2D

    polyline2d

    source
    fn polyline2d(points : Array[Point2], closed? : Bool) -> Polyline2D

    polynomial_in

    source
    fn polynomial_in(t : Double, exponent~ : Double) -> Double

    Polynomial easing with a caller-selected exponent.

    polynomial_in_out

    source
    fn polynomial_in_out(t : Double, exponent~ : Double) -> Double

    polynomial_out

    source
    fn polynomial_out(t : Double, exponent~ : Double) -> Double

    procedural_motion2

    source
    fn procedural_motion2(base : Point2, velocity : Point2, jitter : JitterSequence2, envelope : Curve) -> ProceduralMotion2

    project_bounds3d

    source
    fn project_bounds3d(camera : CameraRig, bounds : Bounds3D) -> Bounds2D

    project_safe

    source
    fn project_safe(camera : CameraRig, point : Point3, margin : Double) -> (Point2, Bool)

    project_samples2

    source
    fn project_samples2(camera : CameraRig, points : Array[Point3]) -> Array[ProjectionSample2]

    project_to_range

    source
    fn project_to_range(value : Double, minimum : Double, maximum : Double) -> Double

    quad_in

    source
    fn quad_in(t : Double) -> Double

    Quadratic acceleration.

    quad_in_out

    source
    fn quad_in_out(t : Double) -> Double

    Quadratic acceleration followed by deceleration.

    quad_out

    source
    fn quad_out(t : Double) -> Double

    Quadratic deceleration.

    quality_budget2

    source
    fn quality_budget2(temporal_limit : Double, spatial_limit : Double, color_limit : Double, minimum_coverage : Double) -> QualityBudget2

    quality_budget_limits2

    source
    fn quality_budget_limits2(budget : QualityBudget2) -> Array[Double]

    quality_sample_count2

    source
    fn quality_sample_count2(quality : RenderQuality2) -> Int

    quantize_colors2

    source
    fn quantize_colors2(palette : Palette2, colors : Array[Rgba]) -> Array[PaletteQuantization2]

    quantize_to_grid

    source
    fn quantize_to_grid(time : Double, step : Double) -> Double

    quart_in

    source
    fn quart_in(t : Double) -> Double

    Quartic acceleration.

    quart_in_out

    source
    fn quart_in_out(t : Double) -> Double

    Quartic acceleration followed by deceleration.

    quart_out

    source
    fn quart_out(t : Double) -> Double

    Quartic deceleration.

    quaternion

    source
    fn quaternion(x~ : Double, y~ : Double, z~ : Double, w~ : Double) -> Quaternion

    quint_in

    source
    fn quint_in(t : Double) -> Double

    Quintic acceleration.

    quint_in_out

    source
    fn quint_in_out(t : Double) -> Double

    Quintic acceleration followed by deceleration.

    quint_out

    source
    fn quint_out(t : Double) -> Double

    Quintic deceleration.

    ramp_interpolations

    source
    fn ramp_interpolations() -> Array[RampInterpolation]

    remap_curve_values

    source
    fn remap_curve_values(values : Array[Double], remap : CurveRemap2) -> Array[Double]

    remap_times

    source
    fn remap_times(times : Array[Double], warp : TimeWarp) -> Array[Double]

    remap_value

    source
    fn remap_value(value : Double, source_min : Double, source_max : Double, target_min : Double, target_max : Double) -> Double

    render_layer2

    source
    fn render_layer2(id : Int, name : String, kind : RenderLayerKind2, order : Int, bounds : Bounds2D) -> RenderLayer2

    render_layer_kinds2

    source
    fn render_layer_kinds2() -> Array[RenderLayerKind2]

    render_plan2

    source
    fn render_plan2(start : Double, end : Double, clear_color : Rgba) -> RenderPlan2

    render_qualities2

    source
    fn render_qualities2() -> Array[RenderQuality2]

    reprojection_error

    source
    fn reprojection_error(camera : CameraRig, world : Point3) -> Double

    resample_adaptive

    source
    fn resample_adaptive(result : AdaptiveSampleResult, count : Int) -> Array[SamplePoint] raise MotionError

    Resample an adaptive result at a fixed number of output points.

    resample_constrained_signal

    source
    fn resample_constrained_signal(values : Array[Double], count : Int) -> Array[Double]

    resample_signal

    source
    fn resample_signal(signal : MotionSignal, step : Double) -> MotionSignal raise MotionError

    Resample at a new step while preserving the signal's time span.

    rescale_time

    source
    fn rescale_time(samples : Array[SamplePoint], start : Double, end : Double) -> Array[SamplePoint]

    retime_linear

    source
    fn retime_linear(input_start : Double, input_end : Double, output_start : Double, output_end : Double) -> RetimeMap raise MotionError

    retime_segment

    source
    fn retime_segment(input_start : Double, input_end : Double, output_start : Double, output_end : Double, curve? : Curve) -> RetimeSegment raise MotionError

    reverse_samples

    source
    fn reverse_samples(samples : Array[SamplePoint]) -> Array[SamplePoint]

    Reverse the time direction while preserving the original sample order in the returned array, making it convenient for playback direction toggles.

    rgba

    source
    fn rgba(r~ : Double, g~ : Double, b~ : Double, a? : Double) -> Rgba

    rgba_keyframe

    source
    fn rgba_keyframe(time : Double, value~ : Rgba, curve? : Curve) -> RgbaKeyframe raise MotionError

    rms

    source
    fn rms(values : Array[Double]) -> Double

    sample_cache_key2

    source
    fn sample_cache_key2(track_id : Int, revision : Int, samples : Int, start : Double, end : Double) -> SampleCacheKey2

    sample_curve_batch

    source
    fn sample_curve_batch(curve : Curve, count : Int) -> ScalarSeries2

    sample_function

    source
    fn sample_function(func : (Double) -> Double, start : Double, end : Double, count : Int) -> Array[SamplePoint] raise MotionError

    Sample a function on a uniform grid. This is useful for waveform and curve previews.

    sample_lut_batch

    source
    fn sample_lut_batch(table : CurveLookupTable, count : Int) -> ScalarSeries2

    sample_path3d

    source
    fn sample_path3d(path : Path3D, parameter : Double) -> PathSample3D

    sample_path3d_by_distance

    source
    fn sample_path3d_by_distance(path : Path3D, distance : Double) -> PathSample3D

    sample_track

    source
    fn sample_track(track : ScalarTrack, config : SamplingConfig, mode? : Extrapolation) -> Array[SamplePoint]

    sample_tween

    source
    fn sample_tween(tween : Tween, config : SamplingConfig) -> Array[SamplePoint]

    sample_validation_policy2

    source
    fn sample_validation_policy2() -> SampleValidationPolicy2

    scalar_blend_layer

    source
    fn scalar_blend_layer(value : Double, weight : Double, mode? : LayerBlendMode, priority? : Int) -> ScalarBlendLayer

    scalar_channel

    source
    fn scalar_channel(name : String, track : ScalarTrack, enabled? : Bool, weight? : Double, offset? : Double) -> ScalarChannel raise MotionError

    scalar_series2

    source
    fn scalar_series2(times : Array[Double], values : Array[Double]) -> ScalarSeries2

    scale_markers

    source
    fn scale_markers(timeline : MarkerTimeline, factor : Double) -> MarkerTimeline raise MotionError

    Return a copy with marker times scaled around the origin.

    screen_safe_bounds

    source
    fn screen_safe_bounds(viewport : Viewport, margin : Double) -> Bounds2D

    screen_safe_contains

    source
    fn screen_safe_contains(viewport : Viewport, point : Point2, margin : Double) -> Bool

    sequence_item

    source
    fn sequence_item(clip : MotionClip, start : Double, weight? : Double) -> ClipSequenceItem raise MotionError

    shake_falloff_value

    source
    fn shake_falloff_value(mode : ShakeFalloff2, ratio : Double) -> Double

    shake_falloffs2

    source
    fn shake_falloffs2() -> Array[ShakeFalloff2]

    shift_markers

    source
    fn shift_markers(timeline : MarkerTimeline, offset : Double) -> MarkerTimeline raise MotionError

    Return a copy with all marker times shifted by an offset.

    signal_autocorrelation2

    source
    fn signal_autocorrelation2(values : Array[Double], lag : Int) -> Double

    signal_derivative2

    source
    fn signal_derivative2(values : Array[Double], frame_rate : Double) -> Array[Double]

    signal_energy

    source
    fn signal_energy(signal : MotionSignal) -> Double

    signal_envelope2

    source
    fn signal_envelope2(values : Array[Double], radius : Int) -> (Array[Double], Array[Double])

    signal_integrate2

    source
    fn signal_integrate2(values : Array[Double], frame_rate : Double, initial : Double) -> Array[Double]

    signal_maximum

    source
    fn signal_maximum(signal : MotionSignal) -> Double?

    signal_mean2

    source
    fn signal_mean2(values : Array[Double]) -> Double

    signal_minimum

    source
    fn signal_minimum(signal : MotionSignal) -> Double?

    signal_normalize2

    source
    fn signal_normalize2(values : Array[Double]) -> Array[Double]

    signal_residual2

    source
    fn signal_residual2(values : Array[Double], smooth_radius : Int) -> Array[Double]

    signal_rms

    source
    fn signal_rms(signal : MotionSignal) -> Double

    signal_rms2

    source
    fn signal_rms2(values : Array[Double]) -> Double

    signal_to_samples

    source
    fn signal_to_samples(signal : MotionSignal) -> Array[SamplePoint]

    signal_variance2

    source
    fn signal_variance2(values : Array[Double]) -> Double

    simplify_samples

    source
    fn simplify_samples(samples : Array[SamplePoint], tolerance : Double) -> Array[SamplePoint] raise MotionError

    Remove samples that are within a scalar tolerance of their chord.

    sine_in

    source
    fn sine_in(t : Double) -> Double

    Sine acceleration.

    sine_in_out

    source
    fn sine_in_out(t : Double) -> Double

    Sine acceleration followed by deceleration.

    sine_out

    source
    fn sine_out(t : Double) -> Double

    Sine deceleration.

    smooth_damp

    source
    fn smooth_damp(current : Double, target : Double, velocity : Double, smooth_time : Double, delta_time : Double) -> (Double, Double)

    smooth_signal

    source
    fn smooth_signal(signal : MotionSignal, radius : Int) -> MotionSignal

    Create a centered moving average; edge windows are shortened rather than padded, avoiding artificial impulses at clip boundaries.

    soft_limit

    source
    fn soft_limit(value : Double, minimum : Double, maximum : Double, softness : Double) -> Double

    Apply a soft saturation instead of a hard clamp near both bounds.

    soft_range2

    source
    fn soft_range2(minimum : Double, maximum : Double, softness? : Double, restitution? : Double) -> SoftRange2

    solve_constrained_points2

    source
    fn solve_constrained_points2(values : Array[Point2], config : ConstraintSolveConfig) -> Array[Point2]

    solve_constrained_points3

    source
    fn solve_constrained_points3(values : Array[Point3], config : ConstraintSolveConfig) -> Array[Point3]

    solve_constrained_signal

    source
    fn solve_constrained_signal(values : Array[Double], config : ConstraintSolveConfig) -> ConstraintSolveResult

    solve_distance_constraint

    source
    fn solve_distance_constraint(current : Point3, target : Point3, distance : Double) -> Point3

    solve_orthographic_height

    source
    fn solve_orthographic_height(camera : CameraRig, bounds : Bounds3D, margin : Double) -> Double

    split_export_chunks

    source
    fn split_export_chunks(schedule : FrameSchedule2, chunk_size : Int, bytes_per_frame : Int) -> Array[ExportChunk2]

    spring_spec

    source
    fn spring_spec(stiffness : Double, damping : Double, mass? : Double, initial_velocity? : Double) -> SpringSpec raise MotionError

    stagger

    source
    fn stagger(count : Int, delay : Double, interval : Double) -> Array[Double]

    standard_deviation

    source
    fn standard_deviation(values : Array[Double]) -> Double

    summarize_diagnostics

    source
    fn summarize_diagnostics(reports : Array[DiagnosticReport2]) -> DiagnosticSummary2

    summarize_evaluations

    source
    fn summarize_evaluations(values : Array[TimelineEvaluation2]) -> EvaluationStats2

    tempo_point2

    source
    fn tempo_point2(beat : Double, bpm : Double) -> TempoPoint2

    threshold_crossings

    source
    fn threshold_crossings(samples : Array[SamplePoint], threshold : Double) -> Array[Double] raise MotionError

    Find crossings of a scalar threshold, using linear interpolation in each span.

    time_signature2

    source
    fn time_signature2(numerator : Int, denominator : Int) -> TimeSignature2

    timecode2

    source
    fn timecode2(seconds : Double, frame_rate : Double) -> Timecode2

    timeline_edge_kinds

    source
    fn timeline_edge_kinds() -> Array[TimelineEdgeKind]

    timeline_evaluator2

    source
    fn timeline_evaluator2(graph : TimelineGraph, render_plan : RenderPlan2) -> TimelineEvaluator2

    timeline_graph

    source
    fn timeline_graph() -> TimelineGraph

    timeline_graph_edge

    source
    fn timeline_graph_edge(from : Int, to : Int, kind : TimelineEdgeKind) -> TimelineGraphEdge

    timeline_graph_node

    source
    fn timeline_graph_node(id : Int, name : String, start : Double, duration : Double) -> TimelineGraphNode

    tone_map

    source
    fn tone_map(color : Rgba, mode : ToneMapping) -> Rgba

    tone_mapping_presets

    source
    fn tone_mapping_presets() -> Array[ToneMapping]

    total_variation

    source
    fn total_variation(samples : Array[SamplePoint]) -> Double

    Estimate total variation, which is useful for quantizing a motion signal.

    track_slot

    source
    fn track_slot(name : String, track : ScalarTrack, offset? : Double, enabled? : Bool) -> TrackSlot

    transform2_sample

    source
    fn transform2_sample(time : Double, value : Transform2D) -> Transform2Sample

    transform2d

    source
    fn transform2d(position~ : Point2, scale~ : Point2, rotation~ : Double, skew? : Double) -> Transform2D

    transform2d_apply

    source
    fn transform2d_apply(value : Transform2D, point : Point2) -> Point2

    transform2d_from_affine

    source
    fn transform2d_from_affine(value : Affine2D) -> Transform2D

    transform3_axes

    source
    fn transform3_axes(value : Transform3D) -> (Point3, Point3, Point3)

    transform3_blend_layer

    source
    fn transform3_blend_layer(value : Transform3D, weight : Double, priority? : Int) -> Transform3BlendLayer

    transform3_clamp_scale

    source
    fn transform3_clamp_scale(value : Transform3D, minimum : Point3, maximum : Point3) -> Transform3D

    transform3_delta

    source
    fn transform3_delta(first : Transform3D, second : Transform3D) -> Transform3Delta

    transform3_distance

    source
    fn transform3_distance(first : Transform3D, second : Transform3D) -> Double

    transform3_keyframe

    source
    fn transform3_keyframe(time : Double, value~ : Transform3D, curve? : Curve) -> Transform3Keyframe raise MotionError

    transform3_local_point

    source
    fn transform3_local_point(value : Transform3D, point : Point3) -> Point3

    transform3_look_at

    source
    fn transform3_look_at(position : Point3, target : Point3, up : Point3) -> Transform3D

    transform3_track_error

    source
    fn transform3_track_error(track : Transform3Track, samples : Int) -> Double raise MotionError

    transform3_world_point

    source
    fn transform3_world_point(value : Transform3D, point : Point3) -> Point3

    transform3d

    source
    fn transform3d(position~ : Point3, rotation~ : Quaternion, scale~ : Point3) -> Transform3D

    transform3d_average

    source
    fn transform3d_average(values : Array[Transform3D], weights : Array[Double]) -> Transform3D

    transform_keyframe

    source
    fn transform_keyframe(time : Double, value~ : Transform2D, curve? : Curve) -> TransformKeyframe raise MotionError

    transport_frame_count

    source
    fn transport_frame_count(range : TransportRange, frame_rate : Double) -> Int

    transport_frames

    source
    fn transport_frames(range : TransportRange, frame_rate : Double, markers? : MarkerTimeline) -> Array[TransportFrame] raise MotionError

    transport_progress

    source
    fn transport_progress(range : TransportRange, time : Double) -> Double

    transport_range

    source
    fn transport_range(start : Double, end : Double) -> TransportRange raise MotionError

    transport_time_at_frame

    source
    fn transport_time_at_frame(range : TransportRange, frame_rate : Double, frame : Int) -> Double

    validate_export_dimensions

    source
    fn validate_export_dimensions(width : Int, height : Int, maximum : Int) -> Bool

    validate_lut2

    source
    fn validate_lut2(name : String, table : CurveLookupTable, curve : Curve, policy : SampleValidationPolicy2) -> DiagnosticReport2

    validate_sample_times2

    source
    fn validate_sample_times2(name : String, times : Array[Double], policy : SampleValidationPolicy2) -> DiagnosticReport2

    validate_sample_values2

    source
    fn validate_sample_values2(name : String, values : Array[Double], policy : SampleValidationPolicy2) -> DiagnosticReport2

    validation_bundle2

    source
    fn validation_bundle2(reports : Array[DiagnosticReport2]) -> ValidationBundle2

    variance

    source
    fn variance(values : Array[Double]) -> Double

    vector_field2

    source
    fn vector_field2(mode : VectorFieldMode2) -> VectorField2

    vector_field_modes2

    source
    fn vector_field_modes2() -> Array[VectorFieldMode2]

    vector_field_value

    source
    fn vector_field_value(mode : VectorFieldMode2, position : Point2, time : Double) -> Point2

    viewport

    source
    fn viewport(width : Double, height : Double, pixel_ratio? : Double) -> Viewport

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io