kaffee 0.2.0

Small 2D framework
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

//! This module contains the necessary types for setting up a `kaffee` application.
//!
//! # Example
//!
//! The following example demonstrates the setup of an application:
//!
//! ```
//! use kaffee::prelude::*;
//!
//! struct GameState;
//!
//! impl EventHandler for GameState {
//!     fn init(&mut self, r: &mut RenderContext) {}
//!     fn update(&mut self, dt: f32) {}
//!     fn redraw(&mut self, r: &mut RenderContext) {}
//! }
//!
//! fn main() {
//!     pollster::block_on(App::run(
//!         &Settings::default(),
//!         GameState {}
//!     ))
//! }
//! ```
//!

use winit::{
    dpi::LogicalSize,
    event::{Event, WindowEvent},
    event_loop::{ControlFlow, EventLoop},
    window::WindowBuilder,
};

use crate::{event::EventHandler, gfx::RenderContext};

/// Specifies the settings with which an application will be created.
#[derive(Debug, Clone)]
pub struct Settings {
    pub title: String,
    pub width: u16,
    pub height: u16,
    pub resizable: bool,
}

impl Default for Settings {
    fn default() -> Self {
        Self {
            title: "kaffee".into(),
            width: 1024,
            height: 768,
            resizable: false,
        }
    }
}

/// A `kaffee` application.
pub struct App;

impl App {
    /// The entry point for every application built with `kaffee`.
    pub async fn run<H>(settings: &Settings, mut event_handler: H) -> !
    where
        H: 'static + EventHandler,
    {
        env_logger::init();
        let event_loop = EventLoop::new();

        let window = WindowBuilder::new()
            .with_title(&settings.title)
            .with_inner_size(LogicalSize::new(settings.width, settings.height))
            .with_resizable(settings.resizable)
            .build(&event_loop)
            .expect("Failed to create window with given settings");

        let mut render_context = RenderContext::new(&window)
            .await
            .expect("Failed to initialize render context");

        event_handler.init(&mut render_context);

        event_loop.run(move |event, _, control_flow| {
            *control_flow = ControlFlow::Poll;

            match event {
                Event::LoopDestroyed => {
                    return;
                }
                Event::RedrawRequested(_) => {
                    event_handler.update(1.);
                    event_handler.redraw(&mut render_context);
                }
                Event::WindowEvent { ref event, .. } => match event {
                    WindowEvent::CloseRequested => {
                        *control_flow = ControlFlow::Exit;
                    }
                    _ => (),
                },
                _ => (),
            }
        })
    }
}