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

use num_traits::Num;

/// Clamps `val` between `min_val` and `max_val`.
///
/// # Examples
///
/// ```
/// # use tmx_utils::math_utils::clamp;
/// assert_eq!(clamp(3,  0, 2), 2);
/// assert_eq!(clamp(1,  0, 2), 1);
/// assert_eq!(clamp(-1.0, 0.0, 1.0), 0.0);
/// ```
pub fn clamp<T: PartialOrd + Num>(val: T, min_val: T, max_val: T) -> T {
    match val {
        v if v < min_val => min_val,
        v if v > max_val => max_val,
        _ => val,
    }
}

/// Clamps `val` between 0 and 1. Had intended to use `clamp(val, 0, 1)`, but float doesn't implement the Ord trait.
///
/// # Examples
///
/// ```
/// # use tmx_utils::math_utils::clamp01;
/// assert_eq!(clamp01(0.5), 0.5);
/// assert_eq!(clamp01(-1), 0);
/// assert_eq!(clamp01(3), 1);
/// assert_eq!(clamp01(3.0), 1.0);
/// ```
pub fn clamp01<T: PartialOrd + Num>(val: T) -> T {
    let zero = T::zero();
    let one = T::one();

    match val {
        v if v < zero => zero,
        v if v > one => one,
        _ => val,
    }
}

/// Linearly interpolates between `a` and `b` by `t`. Does NOT clamp 't' between 0 and 1, allowing for extrapolation.
///
/// # Examples
///
/// ```
/// # use tmx_utils::math_utils::lerp;
/// assert_eq!(lerp(0, 1, 1), 1);
/// assert_eq!(lerp(0.0, 1.0, 0.5), 0.5);
/// assert_eq!(lerp(0.0, 1.0, 2.0), 2.0);
/// assert_eq!(lerp::<f32>(-1.0, 1.0, 0.5), 0.0); // Can force casting
/// ```
pub fn lerp<T: Num + Copy>(a: T, b: T, t: T) -> T {
    a + (b - a) * t
}

/// Linearly interpolates between `a` and `b` by `t`. Clamps 't' between 0 and 1.
///
/// # Examples
///
/// ```
/// # use tmx_utils::math_utils::lerp_clamped;
/// assert_eq!(lerp_clamped(0, 1, 2), 1);
/// assert_eq!(lerp_clamped(0.0, 1.0, -0.01), 0.0);
/// ```
pub fn lerp_clamped<T: PartialOrd + Num + Copy>(a: T, b: T, t: T) -> T {
    a + (b - a) * clamp01(t)
}