geng-utils 0.3.0

A collection of utilities for Geng engine.
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

use geng::prelude::*;

/// A value bounded by a closed interval.
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct Bounded<T> {
    value: T,
    min: T,
    max: T,
}

impl<T: PartialOrd + Copy> Bounded<T> {
    /// Construct a new value bounded by the given `range`.
    pub fn new(value: T, range: std::ops::RangeInclusive<T>) -> Self {
        Self {
            value,
            min: *range.start(),
            max: *range.end(),
        }
        .normalized()
    }

    pub fn value(&self) -> T {
        self.value
    }

    pub fn min(&self) -> T {
        self.min
    }

    pub fn max(&self) -> T {
        self.max
    }

    pub fn map<U>(&mut self, f: impl Fn(T) -> U) -> Bounded<U> {
        Bounded {
            value: f(self.value),
            min: f(self.min),
            max: f(self.max),
        }
    }

    fn normalized(self) -> Self {
        let value = self.value.clamp_range(self.min..=self.max);
        Self { value, ..self }
    }

    /// Whether the value is at a maximum.
    pub fn is_max(&self) -> bool {
        self.value >= self.max
    }

    /// Whether the value is at a minimum.
    pub fn is_min(&self) -> bool {
        self.value <= self.min
    }

    /// Whether the value is above minimum.
    pub fn is_above_min(&self) -> bool {
        self.value > self.min
    }
}

impl<T: UNum> Bounded<T> {
    /// Construct a new non-negative value with max set to be the initial value.
    pub fn new_max(value: T) -> Self {
        Self::new(value, T::ZERO..=value)
    }

    /// Construct a new non-negative value with a given max and initial value set to zero.
    pub fn new_zero(max: T) -> Self {
        Self::new(T::ZERO, T::ZERO..=max)
    }

    /// Changes the value by a `delta`, but keeps it in the interval.
    pub fn change(&mut self, delta: T) {
        self.value += delta;
        *self = self.normalized();
    }

    /// Sets the value after clamping it by the bounds.
    pub fn set(&mut self, value: T) {
        self.value = value;
        *self = self.normalized();
    }
}

impl<T: Float> Bounded<T> {
    /// Returns a number in range 0..=1 representing the value in the interval
    /// where `0 = min`, and `1 = max`.
    pub fn get_ratio(&self) -> T {
        let len = self.max - self.min;
        if len.approx_eq(&T::ZERO) {
            T::ZERO
        } else {
            (self.value - self.min) / len
        }
    }

    pub fn set_ratio(&mut self, ratio: T) {
        self.value = ratio.clamp_range(T::ZERO..=T::ONE) * (self.max - self.min) + self.min;
    }
}

#[test]
fn test_bounded() {
    let mut bounded = Bounded::new(0.0, 0.0..=10.0);
    assert_eq!(bounded.value(), 0.0);

    bounded.change(5.0);
    assert_eq!(bounded.value(), 5.0);

    bounded.change(6.0);
    assert_eq!(bounded.value(), 10.0);

    bounded.change(-11.0);
    assert_eq!(bounded.value(), 0.0);
}