spanda 0.8.0

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
122
123
124
125
126
127
128
129
130
131
132
133

//! Motion path demo — animate a point along various path types.
//!
//! Shows PolyPath and CompoundPath with arc-length parameterization,
//! auto-rotate, and start/end offsets.
//!
//! Run with: `cargo run --example motion_path_demo`

use spanda::motion_path::{CompoundPath, PathCommand, PolyPath};

fn main() {
    println!("  ══════════════════════════════════════════════");
    println!("  PolyPath — smooth curve through points");
    println!("  ══════════════════════════════════════════════\n");

    let path = PolyPath::from_points(vec![
        [0.0, 0.0],
        [50.0, 80.0],
        [100.0, 20.0],
        [150.0, 90.0],
        [200.0, 0.0],
    ]);

    println!("  Arc length: {:.1} units\n", path.arc_length());

    // Animate along the path in 20 steps
    let steps = 20;
    for i in 0..=steps {
        let u = i as f32 / steps as f32;
        let pos = path.position(u);
        let rot = path.rotation_deg(u);

        // Visualize x position as a bar
        let bar_x = (pos[0] / 200.0 * 40.0) as usize;
        print!("  u={:.2}  ", u);
        for j in 0..42 {
            if j == bar_x {
                print!("*");
            } else {
                print!(".");
            }
        }
        println!("  ({:6.1}, {:5.1})  rot={:+6.1}deg", pos[0], pos[1], rot);
    }

    // ── PolyPath with offsets ──

    println!("\n  ══════════════════════════════════════════════");
    println!("  PolyPath with start/end offsets (0.25 - 0.75)");
    println!("  ══════════════════════════════════════════════\n");

    let offset_path = PolyPath::from_points(vec![
        [0.0, 0.0],
        [100.0, 0.0],
        [200.0, 0.0],
    ])
    .start_offset(0.25)
    .end_offset(0.75);

    for i in 0..=10 {
        let u = i as f32 / 10.0;
        let pos = offset_path.position(u);
        println!("  u={:.1} => x={:6.1} (range ~50-150)", u, pos[0]);
    }

    // ── CompoundPath ──

    println!("\n  ══════════════════════════════════════════════");
    println!("  CompoundPath — cubic bezier + line segment");
    println!("  ══════════════════════════════════════════════\n");

    let compound = CompoundPath::new(vec![
        PathCommand::MoveTo([0.0, 0.0]),
        PathCommand::CubicTo {
            control1: [33.0, 100.0],
            control2: [66.0, 100.0],
            end: [100.0, 0.0],
        },
        PathCommand::LineTo([200.0, 0.0]),
    ]);

    println!("  Segments: {}  |  Arc length: {:.1}\n", compound.segment_count(), compound.arc_length());

    for i in 0..=steps {
        let u = i as f32 / steps as f32;
        let pos = compound.position(u);
        let rot = compound.rotation_deg(u);

        // Visualize y height (curve goes up then flat)
        let bar_y = (pos[1].max(0.0) / 100.0 * 20.0) as usize;
        print!("  u={:.2}  ", u);
        for j in 0..22 {
            if j == bar_y {
                print!("o");
            } else {
                print!(" ");
            }
        }
        println!("  ({:6.1}, {:5.1})  rot={:+6.1}deg", pos[0], pos[1], rot);
    }

    // ── Tension comparison ──

    println!("\n  ══════════════════════════════════════════════");
    println!("  Tension comparison: 0.0 vs 0.5 vs 1.5");
    println!("  ══════════════════════════════════════════════\n");

    let points = vec![
        [0.0, 0.0],
        [50.0, 100.0],
        [100.0, 0.0],
    ];

    let low = PolyPath::from_points_with_tension(points.clone(), 0.0);
    let mid = PolyPath::from_points(points.clone());
    let high = PolyPath::from_points_with_tension(points, 1.5);

    println!("  {:>5}  {:>12}  {:>12}  {:>12}", "u", "tension=0.0", "tension=0.5", "tension=1.5");
    println!("  {:>5}  {:>12}  {:>12}  {:>12}", "---", "-----------", "-----------", "-----------");

    for i in 0..=10 {
        let u = i as f32 / 10.0;
        let p_low = low.position(u);
        let p_mid = mid.position(u);
        let p_high = high.position(u);
        println!(
            "  {:.1}  ({:5.1},{:5.1})  ({:5.1},{:5.1})  ({:5.1},{:5.1})",
            u,
            p_low[0], p_low[1],
            p_mid[0], p_mid[1],
            p_high[0], p_high[1],
        );
    }
}