open-standards/wai/wai-vector/src/track.rs

//! Track evaluation (§3.2), on the driver, in `i64`.
//!
//! Linear keys round the exact rational `δ·r/Δ` half up (`R_rat`), so an integer speed
//! with keys on frame ticks lands every frame on the grid. Easing tables interpolate a
//! 17-point Q16 table and round the final product half up. Every value lies between
//! the two keys it interpolates, so an opacity stays in 0..=255 with no clamp, and the
//! interval check (§3.4(a)) may use the keys' range.

use crate::arith::{floor_div, r_half_up, r_rat};
use crate::wvg1::{Key, Table};

/// The value of a track with keys `keys` (at least one, strictly ascending in `t`)
/// at tick `tau`.
pub fn eval(keys: &[Key], tables: &[Table], tau: i64) -> i64 {
    let first = &keys[0];
    let last = &keys[keys.len() - 1];
    if tau <= i64::from(first.t) {
        return i64::from(first.value);
    }
    if tau >= i64::from(last.t) {
        return i64::from(last.value);
    }
    let i = keys.partition_point(|k| i64::from(k.t) <= tau) - 1;
    segment(&keys[i], &keys[i + 1], tables, tau)
}

/// The value between two adjacent keys `a` and `b` at `a.t ≤ tau < b.t`.
pub fn segment(a: &Key, b: &Key, tables: &[Table], tau: i64) -> i64 {
    let dt = i64::from(b.t) - i64::from(a.t);
    let r = tau - i64::from(a.t);
    let v = i64::from(a.value);
    let delta = i64::from(b.value) - v;
    match a.interp {
        0 => v,
        1 => v + r_rat(delta * r, dt),
        j => {
            let e = &tables[j as usize - 2].e;
            let u = floor_div(r << 16, dt);
            let k = (u >> 12) as usize;
            let phi = u & 4095;
            let step = (i64::from(e[k + 1]) - i64::from(e[k])) * phi;
            let ease = i64::from(e[k]) + (step >> 12);
            v + r_half_up(delta * ease, 16)
        }
    }
}