animato-path 1.5.1

Bezier curves, motion paths, CatmullRom splines, and SVG path parsing for Animato.
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
134
135
136
137
138
139

//! Internal math helpers for `animato-path`.

use core::f32::consts::PI;

#[cfg(feature = "std")]
#[inline]
pub(crate) fn sqrt(x: f32) -> f32 {
    x.sqrt()
}

#[cfg(not(feature = "std"))]
#[inline]
pub(crate) fn sqrt(x: f32) -> f32 {
    libm::sqrtf(x)
}

#[cfg(all(feature = "std", any(feature = "std", feature = "alloc")))]
#[inline]
pub(crate) fn sin(x: f32) -> f32 {
    x.sin()
}

#[cfg(all(not(feature = "std"), any(feature = "std", feature = "alloc")))]
#[inline]
pub(crate) fn sin(x: f32) -> f32 {
    libm::sinf(x)
}

#[cfg(all(feature = "std", any(feature = "std", feature = "alloc")))]
#[inline]
pub(crate) fn cos(x: f32) -> f32 {
    x.cos()
}

#[cfg(all(not(feature = "std"), any(feature = "std", feature = "alloc")))]
#[inline]
pub(crate) fn cos(x: f32) -> f32 {
    libm::cosf(x)
}

#[cfg(feature = "std")]
#[inline]
pub(crate) fn atan2(y: f32, x: f32) -> f32 {
    y.atan2(x)
}

#[cfg(not(feature = "std"))]
#[inline]
pub(crate) fn atan2(y: f32, x: f32) -> f32 {
    libm::atan2f(y, x)
}

#[cfg(any(feature = "std", feature = "alloc"))]
#[inline]
pub(crate) fn deg_to_rad(deg: f32) -> f32 {
    deg * PI / 180.0
}

#[inline]
pub(crate) fn rad_to_deg(rad: f32) -> f32 {
    rad * 180.0 / PI
}

#[inline]
pub(crate) fn clamp01(t: f32) -> f32 {
    if t.is_nan() { 0.0 } else { t.clamp(0.0, 1.0) }
}

#[inline]
pub(crate) fn add(a: [f32; 2], b: [f32; 2]) -> [f32; 2] {
    [a[0] + b[0], a[1] + b[1]]
}

#[inline]
pub(crate) fn sub(a: [f32; 2], b: [f32; 2]) -> [f32; 2] {
    [a[0] - b[0], a[1] - b[1]]
}

#[inline]
pub(crate) fn scale(v: [f32; 2], s: f32) -> [f32; 2] {
    [v[0] * s, v[1] * s]
}

#[inline]
pub(crate) fn dot(a: [f32; 2], b: [f32; 2]) -> f32 {
    a[0] * b[0] + a[1] * b[1]
}

#[inline]
pub(crate) fn length(v: [f32; 2]) -> f32 {
    sqrt(dot(v, v))
}

#[inline]
pub(crate) fn distance(a: [f32; 2], b: [f32; 2]) -> f32 {
    length(sub(b, a))
}

#[inline]
pub(crate) fn normalize(v: [f32; 2]) -> [f32; 2] {
    let len = length(v);
    if len <= f32::EPSILON {
        [0.0, 0.0]
    } else {
        [v[0] / len, v[1] / len]
    }
}

#[inline]
pub(crate) fn lerp(a: f32, b: f32, t: f32) -> f32 {
    a + (b - a) * t
}

#[inline]
pub(crate) fn lerp_point(a: [f32; 2], b: [f32; 2], t: f32) -> [f32; 2] {
    [lerp(a[0], b[0], t), lerp(a[1], b[1], t)]
}

#[inline]
pub(crate) fn rotation_deg(tangent: [f32; 2]) -> f32 {
    if tangent == [0.0, 0.0] {
        0.0
    } else {
        rad_to_deg(atan2(tangent[1], tangent[0]))
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
#[inline]
pub(crate) fn angle_between(u: [f32; 2], v: [f32; 2]) -> f32 {
    let sign = if u[0] * v[1] - u[1] * v[0] < 0.0 {
        -1.0
    } else {
        1.0
    };
    let denom = (length(u) * length(v)).max(f32::EPSILON);
    let value = (dot(u, v) / denom).clamp(-1.0, 1.0);
    sign * atan2(sqrt((1.0 - value * value).max(0.0)), value)
}