pittore 0.2.4

Simple toolkit for 2D visualization based on wgpu.
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

use glam::{dvec2, DVec2, Vec2};
use rustc_hash::FxHashSet;
use winit::{
    event::{MouseButton, MouseScrollDelta, WindowEvent},
    keyboard::{KeyCode, PhysicalKey},
};

#[derive(Default)]
pub struct InputState {
    pub event_buffers: Vec<WindowEvent>,

    pub pressed_keys: FxHashSet<KeyCode>,
    pub just_pressed_keys: FxHashSet<KeyCode>,
    pub just_released_keys: FxHashSet<KeyCode>,

    pub cursor_position: Option<DVec2>,
    pub cursor_position_on_click: Option<DVec2>,
    pub pressed_mouse_buttons: FxHashSet<MouseButton>,
    pub clicked_mouse_buttons: FxHashSet<MouseButton>,
    pub mouse_wheel_delta: Option<Vec2>,
    pub mouse_drag_delta: Option<DVec2>,
}

impl InputState {
    pub fn push_event(&mut self, event: WindowEvent) {
        self.event_buffers.push(event);
    }

    pub fn update(&mut self) {
        self.just_pressed_keys.clear();
        self.just_released_keys.clear();
        self.clicked_mouse_buttons.clear();
        self.mouse_wheel_delta = None;
        self.mouse_drag_delta = None;

        for event in &self.event_buffers {
            match event {
                WindowEvent::KeyboardInput { event, .. } => {
                    if !event.repeat {
                        if let PhysicalKey::Code(keycode) = event.physical_key {
                            if event.state.is_pressed() {
                                self.pressed_keys.insert(keycode);
                                self.just_pressed_keys.insert(keycode);
                            } else {
                                self.pressed_keys.remove(&keycode);
                                self.just_released_keys.insert(keycode);
                            }
                        }
                    }
                }
                WindowEvent::CursorMoved { position, .. } => {
                    let previous_position = self.cursor_position;
                    let current_position = dvec2(position.x, position.y);

                    self.cursor_position = Some(current_position);
                    if let Some(previous_position) = previous_position {
                        if !self.pressed_mouse_buttons.is_empty() {
                            self.mouse_drag_delta = Some(current_position - previous_position);
                        }
                    }
                }
                WindowEvent::CursorLeft { .. } => {
                    self.cursor_position = None;
                }
                WindowEvent::MouseInput { state, button, .. } => {
                    if state.is_pressed() {
                        self.pressed_mouse_buttons.insert(*button);
                        self.cursor_position_on_click = self.cursor_position;
                    } else {
                        self.pressed_mouse_buttons.remove(button);
                        if self.cursor_position == self.cursor_position_on_click {
                            self.clicked_mouse_buttons.insert(*button);
                        }
                        self.cursor_position_on_click = None;
                    }
                }
                WindowEvent::MouseWheel { delta, .. } => match delta {
                    MouseScrollDelta::LineDelta(horizontal, vertical) => {
                        *self.mouse_wheel_delta.get_or_insert(Vec2::ZERO) +=
                            Vec2::new(*horizontal, *vertical);
                    }
                    _ => {}
                },
                _ => {}
            }
        }

        self.event_buffers.clear();
    }
}