motionloom 0.1.0

MotionLoom DSL parser and renderer for video effects, scene graphs, motion graphics, and world graphs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

// =========================================
// =========================================
// crates/motionloom/src/keyframe.rs

use std::time::Duration;

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct ScalarKeyframe {
    pub time: Duration,
    pub value: f32,
}

pub fn index_at(keys: &[ScalarKeyframe], t: Duration, epsilon: Duration) -> Option<usize> {
    keys.iter().position(|k| {
        if k.time >= t {
            k.time - t <= epsilon
        } else {
            t - k.time <= epsilon
        }
    })
}

pub fn set_or_insert(keys: &mut Vec<ScalarKeyframe>, t: Duration, value: f32, epsilon: Duration) {
    if let Some(idx) = index_at(keys, t, epsilon) {
        keys[idx].value = value;
    } else {
        keys.push(ScalarKeyframe { time: t, value });
        keys.sort_by_key(|k| k.time);
    }
}

pub fn sample_linear(keys: &[ScalarKeyframe], t: Duration, fallback: f32) -> f32 {
    if keys.is_empty() {
        return fallback;
    }

    let first = &keys[0];
    if t <= first.time {
        return first.value;
    }

    let last = keys.last().expect("keys is not empty");
    if t >= last.time {
        return last.value;
    }

    for window in keys.windows(2) {
        let a = &window[0];
        let b = &window[1];
        if t >= a.time && t <= b.time {
            let span = (b.time - a.time).as_secs_f32().max(0.0001);
            let local = (t - a.time).as_secs_f32();
            let frac = (local / span).clamp(0.0, 1.0);
            return a.value + (b.value - a.value) * frac;
        }
    }

    fallback
}