Method window_event

crates/blue_engine_core/src/window.rs:121–187

(
        &mut self,
        event_loop: &winit::event_loop::ActiveEventLoop,
        _window_id: winit::window::WindowId,
        event: WindowEvent,
    )

    }

    fn window_event(
        &mut self,
        event_loop: &winit::event_loop::ActiveEventLoop,
        _window_id: winit::window::WindowId,
        event: WindowEvent,
    ) {
        self.simple_input.process_window_event(&event);
        let mut events = std::mem::take(&mut self.signals.events);
        events.iter_mut().for_each(|i| {
            i.1.window_events(self, &event);
        });
        std::mem::swap(&mut self.signals.events, &mut events);

        match event {
            WindowEvent::CloseRequested => {
                event_loop.exit();
                std::process::exit(0);
            }
            WindowEvent::Resized(size) => {
                let size = (size.width, size.height);
                self.renderer.resize(size);
                self.camera.set_resolution(size);
                self.camera.update_view_projection(&mut self.renderer);
            }
            WindowEvent::RedrawRequested => {
                if self.window.should_close {
                    event_loop.exit();
                }

                if let Some(window_ref) = self.window.as_ref() {
                    let size = window_ref.inner_size();
                    let size = (size.width, size.height);
                    if let Ok(Some((mut encoder, view, frame, headless_output))) =
                        self.renderer.pre_render(&self.objects, size, &self.camera)
                    {
                        let mut events = std::mem::take(&mut self.signals.events);
                        events.iter_mut().for_each(|i| {
                            i.1.frame(self, &mut encoder, &view);
                        });
                        std::mem::swap(&mut self.signals.events, &mut events);

                        for camera_value in self.camera.values_mut() {
                            camera_value.update_view_projection(&mut self.renderer);
                        }
                        self.objects.iter_mut().for_each(|i| {
                            if i.1.changed {
                                i.1.update(&mut self.renderer);
                            }
                        });

                        let mut update_function = self.update_loop.take();
                        if let Some(ref mut update_function) = update_function {
                            update_function(self);
                        }
                        self.update_loop = update_function;

                        self.renderer.render(encoder, frame, headless_output);
                    }