spanda 0.9.3

A general-purpose animation library for Rust — tweening, keyframes, timelines, and physics.
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#![cfg(feature = "palette")]
//! Integration tests for colour interpolation (requires `palette` feature).

use palette::Srgba;
use spanda::colour::{InLab, InLinear, InOklch, lerp_in_lab, lerp_in_oklch};
use spanda::spring::{SpringConfig, SpringN};
use spanda::traits::{Interpolate, Update};
use spanda::tween::Tween;

#[test]
fn tween_srgba_full_lifecycle() {
    let mut t = Tween::new(
        Srgba::new(1.0_f32, 0.0, 0.0, 1.0),
        Srgba::new(0.0, 1.0, 0.0, 1.0),
    )
    .duration(1.0)
    .build();

    for _ in 0..10 {
        t.update(0.1);
    }
    assert!(t.is_complete());
    let v = t.value();
    assert!((v.green - 1.0).abs() < 1e-3);
}

#[test]
fn tween_in_lab_full_lifecycle() {
    let mut t = Tween::new(
        InLab(Srgba::new(1.0, 0.0, 0.0, 1.0)),
        InLab(Srgba::new(0.0, 0.0, 1.0, 1.0)),
    )
    .duration(1.0)
    .build();

    for _ in 0..10 {
        t.update(0.1);
    }
    assert!(t.is_complete());
    let v = t.value();
    assert!((v.0.blue - 1.0).abs() < 1e-2);
}

#[test]
fn tween_in_oklch_full_lifecycle() {
    let mut t = Tween::new(
        InOklch(Srgba::new(1.0, 0.0, 0.0, 1.0)),
        InOklch(Srgba::new(0.0, 1.0, 0.0, 1.0)),
    )
    .duration(1.0)
    .build();

    for _ in 0..10 {
        t.update(0.1);
    }
    assert!(t.is_complete());
}

#[test]
fn tween_in_linear_full_lifecycle() {
    let mut t = Tween::new(
        InLinear(Srgba::new(0.0, 0.0, 0.0, 1.0)),
        InLinear(Srgba::new(1.0, 1.0, 1.0, 1.0)),
    )
    .duration(1.0)
    .build();

    for _ in 0..10 {
        t.update(0.1);
    }
    assert!(t.is_complete());
    let v = t.value();
    assert!((v.0.red - 1.0).abs() < 1e-2);
}

#[test]
fn lab_vs_srgb_midpoint_luminance() {
    let red = Srgba::new(1.0_f32, 0.0, 0.0, 1.0);
    let blue = Srgba::new(0.0, 0.0, 1.0, 1.0);

    let srgb_mid = red.lerp(&blue, 0.5);
    let lab_mid = lerp_in_lab(red, blue, 0.5);

    // Standard luminance coefficients
    let srgb_lum = srgb_mid.red * 0.2126 + srgb_mid.green * 0.7152 + srgb_mid.blue * 0.0722;
    let lab_lum = lab_mid.red * 0.2126 + lab_mid.green * 0.7152 + lab_mid.blue * 0.0722;

    // Lab should produce a brighter midpoint than sRGB for this pair
    assert!(
        lab_lum > srgb_lum * 0.8,
        "Lab should produce brighter mid: lab={lab_lum} srgb={srgb_lum}"
    );
}

#[test]
fn oklch_hue_wrapping() {
    // Red (hue ~30) → Blue (hue ~265) via Oklch
    let red = Srgba::new(1.0_f32, 0.0, 0.0, 1.0);
    let blue = Srgba::new(0.0, 0.0, 1.0, 1.0);
    let mid = lerp_in_oklch(red, blue, 0.5);
    // Mid should be a valid colour (not NaN or out of range after clamping)
    assert!(mid.red >= 0.0 && mid.red <= 1.0);
    assert!(mid.green >= 0.0 && mid.green <= 1.0);
    assert!(mid.blue >= 0.0 && mid.blue <= 1.0);
}

#[test]
fn spring_n_with_srgba_settles() {
    let mut spring = SpringN::new(SpringConfig::stiff(), Srgba::new(0.0_f32, 0.0, 0.0, 1.0));
    spring.set_target(Srgba::new(1.0, 1.0, 1.0, 1.0));

    for _ in 0..1000 {
        spring.update(1.0 / 60.0);
    }

    let pos = spring.position();
    assert!((pos.red - 1.0).abs() < 0.01);
    assert!((pos.green - 1.0).abs() < 0.01);
    assert!((pos.blue - 1.0).abs() < 0.01);
    assert!(spring.is_settled());
}