coffee 0.4.1

An opinionated 2D game engine focused on simplicity, explicitness, and type-safety
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

use super::winit;
use crate::input::{self, keyboard, mouse, window};

pub(crate) enum Event {
    CloseRequested,
    Resized(winit::dpi::LogicalSize),
    Input(input::Event),
    CursorMoved(winit::dpi::LogicalPosition),
    Moved(winit::dpi::LogicalPosition),
}

pub struct EventLoop(winit::EventsLoop);

impl EventLoop {
    pub fn new() -> Self {
        Self(winit::EventsLoop::new())
    }

    pub(super) fn raw(&self) -> &winit::EventsLoop {
        &self.0
    }

    pub(crate) fn poll<F>(&mut self, mut f: F)
    where
        F: FnMut(Event),
    {
        self.0.poll_events(|event| {
            match event {
                winit::Event::WindowEvent { event, .. } => match event {
                    winit::WindowEvent::KeyboardInput {
                        input:
                            winit::KeyboardInput {
                                state,
                                virtual_keycode: Some(key_code),
                                ..
                            },
                        ..
                    } => {
                        f(Event::Input(input::Event::Keyboard(
                            keyboard::Event::Input { state, key_code },
                        )));
                    }
                    winit::WindowEvent::ReceivedCharacter(codepoint) => {
                        f(Event::Input(input::Event::Keyboard(
                            keyboard::Event::TextEntered {
                                character: codepoint,
                            },
                        )))
                    }
                    winit::WindowEvent::MouseInput {
                        state, button, ..
                    } => f(Event::Input(input::Event::Mouse(
                        mouse::Event::Input { state, button },
                    ))),
                    winit::WindowEvent::MouseWheel { delta, .. } => match delta
                    {
                        winit::MouseScrollDelta::LineDelta(x, y) => {
                            f(Event::Input(input::Event::Mouse(
                                mouse::Event::WheelScrolled {
                                    delta_x: x,
                                    delta_y: y,
                                },
                            )))
                        }
                        _ => {}
                    },
                    winit::WindowEvent::CursorMoved { position, .. } => {
                        f(Event::CursorMoved(position))
                    }
                    winit::WindowEvent::CursorEntered { .. } => {
                        f(Event::Input(input::Event::Mouse(
                            mouse::Event::CursorEntered,
                        )))
                    }
                    winit::WindowEvent::CursorLeft { .. } => f(Event::Input(
                        input::Event::Mouse(mouse::Event::CursorLeft),
                    )),
                    winit::WindowEvent::CloseRequested { .. } => {
                        f(Event::CloseRequested)
                    }
                    winit::WindowEvent::Resized(logical_size) => {
                        f(Event::Resized(logical_size))
                    }
                    winit::WindowEvent::Focused(focus) => {
                        f(Event::Input(if focus == true {
                            input::Event::Window(window::Event::Focused)
                        } else {
                            input::Event::Window(window::Event::Unfocused)
                        }))
                    }
                    winit::WindowEvent::Moved(position) => {
                        f(Event::Moved(position))
                    }
                    _ => {}
                },
                _ => (),
            };
        });
    }
}