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
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
131
132

mod cursor_icon;
mod frame;
mod settings;

pub(crate) use winit;

pub use cursor_icon::CursorIcon;
pub use frame::Frame;
pub use settings::Settings;

use crate::graphics::gpu::{self, Gpu};
use crate::Result;

/// An open window.
///
/// It is provided as an argument in some methods in [`Game`].
///
/// [`Game`]: ../trait.Game.html
pub struct Window {
    gpu: Gpu,
    surface: gpu::Surface,
    width: f32,
    height: f32,
    is_fullscreen: bool,
    cursor_icon: Option<winit::window::CursorIcon>,
}

impl Window {
    pub(crate) fn new(
        settings: Settings,
        event_loop: &winit::event_loop::EventLoop<()>,
    ) -> Result<Window> {
        let (width, height) = settings.size;
        let is_fullscreen = settings.fullscreen;

        let (gpu, surface) =
            Gpu::for_window(settings.into_builder(event_loop), event_loop)?;

        Ok(Window {
            is_fullscreen,
            gpu,
            surface,
            width: width as f32,
            height: height as f32,
            cursor_icon: Some(winit::window::CursorIcon::Default),
        })
    }

    /// Returns the [`Gpu`] linked to the [`Window`].
    ///
    /// [`Gpu`]: struct.Gpu.html
    /// [`Window`]: struct.Window.html
    pub fn gpu(&mut self) -> &mut Gpu {
        &mut self.gpu
    }

    pub(crate) fn frame(&mut self) -> Frame<'_> {
        Frame::new(self)
    }

    /// Toggles the [`Window`]'s fullscreen state.
    ///
    /// [`Window`]: struct.Window.html
    pub fn toggle_fullscreen(&mut self) {
        let window = self.surface.window();

        let monitor = if self.is_fullscreen {
            None
        } else {
            Some(window.primary_monitor())
        };

        window
            .set_fullscreen(monitor.map(winit::window::Fullscreen::Borderless));

        self.is_fullscreen = !self.is_fullscreen;
    }

    /// Returns the width of the [`Window`].
    ///
    /// [`Window`]: struct.Window.html
    pub fn width(&self) -> f32 {
        self.width
    }

    /// Returns the height of the [`Window`].
    ///
    /// [`Window`]: struct.Window.html
    pub fn height(&self) -> f32 {
        self.height
    }

    pub(crate) fn swap_buffers(&mut self) {
        self.surface.swap_buffers(&mut self.gpu);
    }

    pub(crate) fn request_redraw(&mut self) {
        self.surface.request_redraw();
    }

    pub(crate) fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
        self.surface.resize(&mut self.gpu, new_size);

        self.width = new_size.width as f32;
        self.height = new_size.height as f32;
    }

    pub(crate) fn update_cursor(
        &mut self,
        new_cursor: Option<winit::window::CursorIcon>,
    ) {
        if self.cursor_icon != new_cursor {
            if let Some(cursor_icon) = new_cursor {
                self.surface.window().set_cursor_icon(cursor_icon);
            }
            self.surface
                .window()
                .set_cursor_visible(new_cursor.is_some());
            self.cursor_icon = new_cursor;
        }
    }
}

impl std::fmt::Debug for Window {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Window {{ width: {}, height: {} }}",
            self.width, self.height
        )
    }
}