fluffl 0.0.5

A cross-platform multimedia layer that exposes opengl,sockets,and audio utilities for desktop and browser
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

use std::hash::Hash;

use super::*;

#[derive(Copy, Clone, Default)]
pub struct TouchStats {
    pub prev_pos: [f32; 2],
    pub displacement: [f32; 2],
}
impl TouchStats {
    pub fn initial_stats(pos: [f32; 2]) -> Self {
        Self {
            prev_pos: pos,
            displacement: [0.0; 2],
        }
    }
}

#[derive(Default)]
pub struct TouchTracker<ID> {
    table: HashMap<ID, TouchStats>,
}

impl<ID> std::ops::Deref for TouchTracker<ID> {
    type Target = HashMap<ID, TouchStats>;
    fn deref(&self) -> &Self::Target {
        &self.table
    }
}
impl<ID> std::ops::DerefMut for TouchTracker<ID> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.table
    }
}

impl<ID> TouchTracker<ID>
where
    ID: Copy + Clone + PartialEq + Eq + Hash,
{
    pub fn new() -> Self {
        Self {
            table: HashMap::new(),
        }
    }

    /// # Description
    /// Tracks a position displacement
    /// # returns
    /// - touch displacement of `id`
    pub fn get_touch_displacement(&mut self, id: ID, new_pos: [f32; 2]) -> [f32; 2] {
        let touch_table = self;
        let updated_stats = touch_table
            .table
            .entry(id)
            .and_modify(|stats| {
                let old_pos = stats.prev_pos;
                let disp = [new_pos[0] - old_pos[0], new_pos[1] - old_pos[1]];
                stats.displacement = disp;
                stats.prev_pos = new_pos;
            })
            .or_insert_with(|| TouchStats::initial_stats(new_pos));

        updated_stats.displacement
    }
}