roast2d_internal 0.3.6

Roast2D internal crate
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

use std::fmt::Debug;

use anyhow::Result;
use glam::UVec2;

use crate::{
    engine::{Engine, Scene},
    platform::platform_run,
    render::ScaleMode,
};

type SetupFn = Box<dyn FnOnce(&mut Engine)>;

pub struct App {
    pub title: String,
    pub window: UVec2,
    pub vsync: bool,
    pub resizable: bool,
    pub fullscreen: bool,
    pub cursor_visible: bool,
    pub(crate) setup: Option<SetupFn>,
    pub(crate) scale_mode: Option<ScaleMode>,
    pub(crate) scene: Option<Box<dyn Scene>>,
}

impl Debug for App {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "App {{ title: {}, window: {:?}, vsync: {}, resizable: {}, fullscreen: {} }}",
            self.title, self.window, self.vsync, self.resizable, self.fullscreen,
        )
    }
}
impl Default for App {
    fn default() -> Self {
        Self {
            title: "Hello Roast2D".to_string(),
            window: UVec2::new(800, 600),
            vsync: true,
            resizable: false,
            fullscreen: false,
            cursor_visible: true,
            setup: None,
            scale_mode: None,
            scene: None,
        }
    }
}

impl App {
    pub fn title(mut self, title: String) -> Self {
        self.title = title;
        self
    }

    pub fn window(mut self, window: UVec2) -> Self {
        self.window = window;
        self
    }

    pub fn vsync(mut self, vsync: bool) -> Self {
        self.vsync = vsync;
        self
    }

    pub fn resizable(mut self, resizable: bool) -> Self {
        self.resizable = resizable;
        self
    }

    pub fn fullscreen(mut self, fullscreen: bool) -> Self {
        self.fullscreen = fullscreen;
        self
    }

    pub fn cursor_visible(mut self, cursor_visible: bool) -> Self {
        self.cursor_visible = cursor_visible;
        self
    }

    /// Set the scale mode for the game
    pub fn scale_mode(mut self, scale_mode: ScaleMode) -> Self {
        self.scale_mode = Some(scale_mode);
        self
    }

    /// Set the initial scene for the game
    pub fn scene<S: Scene + 'static>(mut self, scene: S) -> Self {
        self.scene = Some(Box::new(scene));
        self
    }

    /// Set a custom setup function for additional initialization
    pub fn setup<Setup: FnOnce(&mut Engine) + 'static>(mut self, setup: Setup) -> Self {
        self.setup = Some(Box::new(setup));
        self
    }

    /// Run the game
    pub fn run(self) -> Result<()> {
        platform_run(self)
    }
}