devotee 0.1.47

Visualization engine
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
133
134
135
136
137
138
139

use devotee_backend::winit::dpi::{PhysicalPosition, PhysicalSize};
use devotee_backend::winit::event_loop::EventLoop;
#[cfg(target_arch = "wasm32")]
use devotee_backend::winit::platform::web::WindowExtWebSys;
use devotee_backend::winit::window::{Fullscreen, Window as WinitWindow, WindowBuilder};
use devotee_backend::{Backend, BackendImage};

use super::{Config, Setup};
use crate::util::vector::Vector;
use crate::visual::color::Converter;
use crate::visual::Image;

pub use devotee_backend::winit;

pub(super) type WindowCommand = Box<dyn FnOnce(&mut Window)>;

/// The application window.
pub struct Window {
    window: WinitWindow,
    resolution: Vector<u32>,
    background: u32,
}

impl Window {
    pub(super) fn with_setup<Cfg>(event_loop: &EventLoop<()>, setup: &Setup<Cfg>) -> Option<Self>
    where
        Cfg: Config,
        Cfg::RenderTarget: Image,
        Cfg::Converter: Converter,
    {
        let resolution = Vector::new(
            setup.render_target.width() as u32,
            setup.render_target.height() as u32,
        );
        if resolution.x() == 0 || resolution.y() == 0 {
            return None;
        }
        if setup.scale == 0 {
            return None;
        }
        let window_size = resolution * setup.scale;

        let window = {
            let builder = WindowBuilder::new()
                .with_min_inner_size(PhysicalSize::new(resolution.x(), resolution.y()))
                .with_inner_size(PhysicalSize::new(window_size.x(), window_size.y()))
                .with_fullscreen(if setup.fullscreen {
                    Some(Fullscreen::Borderless(None))
                } else {
                    None
                })
                .with_title(&setup.title);
            builder.build(event_loop).ok()?
        };
        window.set_cursor_visible(false);
        #[cfg(target_arch = "wasm32")]
        {
            let document = web_sys::window()?.document()?;
            if let Some(canvas_holder) =
                document.get_element_by_id(setup.element_id.unwrap_or("devoteeCanvasHolder"))
            {
                let _ = canvas_holder.append_child(&web_sys::Element::from(window.canvas()));
            } else {
                let _ = document
                    .body()?
                    .append_child(&web_sys::Element::from(window.canvas()));
            }
        }

        let background = Cfg::converter().convert(&Cfg::background_color());

        Some(Window {
            window,
            resolution,
            background,
        })
    }

    pub(super) fn request_redraw(&self) {
        self.window.request_redraw();
    }

    pub(super) fn inner(&self) -> &WinitWindow {
        &self.window
    }

    /// Get window pixel resolution.
    pub fn resolution(&self) -> Vector<u32> {
        self.resolution
    }

    /// Set window to fullscreen mode.
    pub fn set_fullscreen(&mut self, fullscreen: bool) {
        if fullscreen {
            self.window
                .set_fullscreen(Some(Fullscreen::Borderless(None)));
        } else {
            self.window.set_fullscreen(None);
        }
    }

    /// Check if the window is in fullscreen mode.
    pub fn is_fullscreen(&self) -> bool {
        self.window.fullscreen().is_some()
    }

    pub(super) fn apply(&mut self, commands: &mut Vec<WindowCommand>) {
        for command in commands.drain(..) {
            command(self)
        }
    }

    pub(super) fn draw_image<'a, P: 'a, I, Bck>(
        &self,
        back: &mut Bck,
        image: &'a dyn BackendImage<'a, P, Iterator = I>,
        converter: &dyn Converter<Palette = P>,
    ) -> Option<()>
    where
        I: Iterator<Item = &'a P>,
        Bck: Backend,
    {
        back.draw_image(image, converter, &self.window, self.background)
    }

    /// Recalculate raw window position into camera-related.
    pub fn window_pos_to_inner<Bck>(
        &self,
        back: &Bck,
        position: PhysicalPosition<f64>,
    ) -> Result<Vector<i32>, Vector<i32>>
    where
        Bck: Backend,
    {
        back.window_pos_to_inner(position, &self.window, self.resolution.split())
            .map(Into::into)
            .map_err(Into::into)
    }
}