ferroui-base 0.3.0

The base library of FerroUI: the property system, layout, input, styling, media, text, animation, data binding and the compositor
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

use crate::utilities::{FormatError, SpanStringTokenizer, spring_solver::SpringSolver};
use std::cell::Cell;
use std::str::FromStr;

/// Determines how an animation is used based on spring formula.
pub struct Spring {
    spring_solver: Cell<SpringSolver>,
    mass: Cell<f64>,
    stiffness: Cell<f64>,
    damping: Cell<f64>,
    initial_velocity: Cell<f64>,
    is_dirty: Cell<bool>,
}


/// Compares by identity (reference equality), as the reference type this
/// mirrors.
impl PartialEq for Spring {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        std::ptr::eq(self, other)
    }
}

impl Default for Spring {
    fn default() -> Self {
        Self::new()
    }
}

impl Spring {
    /// Creates a spring with all parameters zero.
    pub fn new() -> Self {
        Self::with_values(0.0, 0.0, 0.0, 0.0)
    }

    /// Creates a spring with the given parameters.
    pub fn with_values(mass: f64, stiffness: f64, damping: f64, initial_velocity: f64) -> Self {
        Self {
            spring_solver: Cell::new(SpringSolver::default()),
            mass: Cell::new(mass),
            stiffness: Cell::new(stiffness),
            damping: Cell::new(damping),
            initial_velocity: Cell::new(initial_velocity),
            is_dirty: Cell::new(true),
        }
    }

    /// Parses a spring from four numbers: mass, stiffness, damping and
    /// initial velocity.
    pub fn parse(value: &str) -> Result<Spring, FormatError> {
        let error = |_| FormatError::from_string(format!("Invalid Spring string: \"{value}\"."));
        let mut tokenizer = SpanStringTokenizer::new(value);
        let result = Spring::with_values(
            tokenizer.read_double().map_err(error)?,
            tokenizer.read_double().map_err(error)?,
            tokenizer.read_double().map_err(error)?,
            tokenizer.read_double().map_err(error)?,
        );
        tokenizer.finish().map_err(error)?;
        Ok(result)
    }

    /// The spring mass.
    pub fn mass(&self) -> f64 {
        self.mass.get()
    }

    pub fn set_mass(&self, value: f64) {
        self.mass.set(value);
        self.is_dirty.set(true);
    }

    /// The spring stiffness.
    pub fn stiffness(&self) -> f64 {
        self.stiffness.get()
    }

    pub fn set_stiffness(&self, value: f64) {
        self.stiffness.set(value);
        self.is_dirty.set(true);
    }

    /// The spring damping.
    pub fn damping(&self) -> f64 {
        self.damping.get()
    }

    pub fn set_damping(&self, value: f64) {
        self.damping.set(value);
        self.is_dirty.set(true);
    }

    /// The spring initial velocity.
    pub fn initial_velocity(&self) -> f64 {
        self.initial_velocity.get()
    }

    pub fn set_initial_velocity(&self, value: f64) {
        self.initial_velocity.set(value);
        self.is_dirty.set(true);
    }

    /// Calculates the spring progress from a linear progress.
    pub fn get_spring_progress(&self, linear_progress: f64) -> f64 {
        if self.is_dirty.get() {
            self.build();
        }

        self.spring_solver.get().solve(linear_progress)
    }

    /// Creates the spring solver.
    fn build(&self) {
        self.spring_solver.set(SpringSolver::new(
            self.mass.get(),
            self.stiffness.get(),
            self.damping.get(),
            self.initial_velocity.get(),
        ));
        self.is_dirty.set(false);
    }
}

impl FromStr for Spring {
    type Err = FormatError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Spring::parse(s)
    }
}