tge 0.0.4

A lightweight cross-platform 2D game framework written in pure Rust and based on OpenGL 3.3+.
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

use crate::math::Vector;
use crate::window::{LogicalPosition, LogicalSize};
use crate::keyboard::{KeyCode, ModifiersState};
use crate::mouse::MouseButton;
use crate::gamepad::{GamepadButton, GamepadAxis, GamepadId};
use winit::event::ElementState;

#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
pub(crate) enum KeyState {
    Down,
    Hold,
    Up,
    Idle,
}

#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
pub enum KeyAction {
    Down,
    Up,
}

impl From<ElementState> for KeyAction {
    fn from(state: ElementState) -> Self {
        match state {
            ElementState::Pressed => Self::Down,
            ElementState::Released => Self::Up,
        }
    }
}

impl Into<KeyState> for KeyAction {
    fn into(self) -> KeyState {
        match self {
            Self::Down => KeyState::Down,
            Self::Up => KeyState::Up,
        }
    }
}

#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
pub enum TouchPhase {
    Start,
    Move,
    End,
    Cancel,
}

impl From<winit::event::TouchPhase> for TouchPhase {
    fn from(phase: winit::event::TouchPhase) -> Self {
        match phase {
            winit::event::TouchPhase::Started => Self::Start,
            winit::event::TouchPhase::Moved => Self::Move,
            winit::event::TouchPhase::Ended => Self::End,
            winit::event::TouchPhase::Cancelled => Self::Cancel,
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum Event {
    AppSuspend,
    AppResume,
    WindowClose,
    WindowResize(LogicalSize),
    WindowMove(LogicalPosition),
    WindowFocusChange(bool),
    ReceiveChar(char),
    KeyboardInput {
        key: KeyCode,
        action: KeyAction,
        repeated: bool,
    },
    ModifiersChange(ModifiersState),
    MouseMove(LogicalPosition),
    MouseEnterWindow,
    MouseLeaveWindow,
    MouseWheelScroll(Vector),
    MouseInput {
        button: MouseButton,
        action: KeyAction,
    },
    Touch {
        id: u64,
        phase: TouchPhase,
        position: LogicalPosition,
    },
    TouchpadScroll {
        delta: Vector,
        phase: TouchPhase,
    },
    TouchpadPress {
        pressure: f32,
        click_stage: i64,
    },
    GamepadConnect(GamepadId),
    GamepadDisconnect(GamepadId),
    GamepadButtonInput {
        id: GamepadId,
        button: GamepadButton,
        action: KeyAction,
    },
    GamepadButtonChange {
        id: GamepadId,
        button: GamepadButton,
        value: f32,
    },
    GamepadAxisChange {
        id: GamepadId,
        axis: GamepadAxis,
        value: f32,
    },
}