Struct EventLoop 

pub struct EventLoop<T>
where
    T: 'static,
{ /* private fields */ }

Provides a way to retrieve events from the system and from the windows that were registered to the events loop.

An EventLoop can be seen more or less as a “context”. Calling EventLoop::new initializes everything that will be required to create windows. For example on Linux creating an event loop opens a connection to the X or Wayland server.

To wake up an EventLoop from a another thread, see the EventLoopProxy docs.

Note that this cannot be shared across threads (due to platform-dependant logic forbidding it), as such it is neither Send nor Sync. If you need cross-thread access, the Window created from this can be sent to an other thread, and the EventLoopProxy allows you to wake up an EventLoop from another thread.

Implementations

impl EventLoop<()>

pub fn new() -> EventLoop<()>

Alias for EventLoopBuilder::new().build().

Examples found in repository

examples/scene_example.rs (line 20)

fn example() {
    let el = EventLoop::new();
    let (vk, window) = Vk::new(&el);
    window.set_cursor_grab(winit::window::CursorGrabMode::Confined).unwrap();
    window.set_cursor_visible(false);
    window.set_title("CHAOS-VK");
    window.set_window_icon({
        let w = 8;
        let h = 8;

        Some(Icon::from_rgba(
            (0..w*h*4).map(|_| rand_betw(0, 255)).collect(), 
            w, 
            h
        ).unwrap())
    });
    window.set_theme(Some(Theme::Dark));
    window.set_inner_size(PhysicalSize::new(1200, 900));
    let size = window.inner_size();

    
    let mut presenter = Presenter::new(vk.clone(), window.clone());
    let mut renderer = Renderer::new();
    let mut imgui = ImGui::new(vk.clone(), &presenter);

    renderer.camera.proj = Mat4::perspective_lh(
        80.0f32.to_radians(), 
        size.width as f32 / size.height as f32, 0.1, 1000.0
    );

    let vs = shaders::vs::load(vk.device.clone()).unwrap();
    let fs = shaders::fs::load(vk.device.clone()).unwrap();

    let rp = render_pass_with_depth(vk.clone(), Some(presenter.swapchain.clone()));

    let pipeline = instancing_pipeline(vk.clone(), vs.clone(), fs.clone(), rp.clone(), Viewport {
        offset: [0.0, 0.0],
        extent: size.into(),
        depth_range: 0.0..=1.0,
    });

    presenter.window_resized = true;
    presenter.recreate(vk.clone(), rp.clone(), window.clone());

    let sphere = sphere(5, 1.0);
    renderer.meshes.push(Mesh::new(vk.clone(), &sphere.vertices, &sphere.indices));

    let mut cursor_x = 0.0;
    let mut cursor_y = 0.0;

    let data = (0..250).map(|_| { PosInstanceData {
            ofs: [rand_betw(-100.0, 100.0), rand_betw(-10.0, 10.0), rand_betw(-100.0, 100.0)]
        }
    }).collect::<Vec<PosInstanceData>>();
    renderer.meshes[0].instances = data.clone();
    let instance_buffer = VkIterBuffer::vertex(vk.allocators.clone(), data);
    renderer.meshes[0].ibo = instance_buffer;

    let mut dt = 0.0;

    el.run(move |event, _target, control_flow| {
        control_flow.set_poll();

        match event {
            Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
                control_flow.set_exit();
            },
            Event::WindowEvent { event, .. } => {
                renderer.camera.input(&event);

                match event {
                    WindowEvent::KeyboardInput { input, .. } => {
                        if input.virtual_keycode == Some(VirtualKeyCode::Escape) {
                            control_flow.set_exit();
                        }

                        if input.modifiers.ctrl() && input.virtual_keycode == Some(VirtualKeyCode::S) {
                            Scene::write("assets/scene.cf", &renderer).expect("Failed to write scene");
                        }

                        if input.modifiers.ctrl() && input.virtual_keycode == Some(VirtualKeyCode::L) {
                            Scene::read("assets/scene.cf", &mut renderer, vk.clone()).expect("Failed to load scene");
                        }

                       window.set_cursor_visible(input.modifiers.alt());
                    },

                    WindowEvent::CursorMoved { position, .. } => {
                        imgui.on_mouse_move(position.x as f32, position.y as f32);
                    }

                    WindowEvent::MouseInput { button, state, .. } => {
                        imgui.on_mouse_click(button, state);
                    }

                    WindowEvent::MouseWheel { delta: MouseScrollDelta::PixelDelta(pos), .. } => {
                        imgui.on_mouse_scroll(pos.x as f32, pos.y as f32);
                    }

                    _ => ()
                }
            }

            Event::DeviceEvent {
                event: DeviceEvent::Text { codepoint }, ..
            } => {
                dbg!(codepoint);
            }

            Event::DeviceEvent { event: DeviceEvent::MouseMotion { delta },.. } => {
                cursor_x += delta.0 as f32;
                cursor_y += delta.1 as f32;

                renderer.camera.mouse_callback(cursor_x, cursor_y);
            }

            Event::MainEventsCleared => {
                let now = std::time::Instant::now();
                
                let frame = imgui.frame(&window);
                frame.text("hello, world!");
                frame.text(format!("dt:{:.1}", dt*1000.0));
                
                presenter.recreate(vk.clone(), rp.clone(), window.clone());

                renderer.update(dt);
                presenter.cmd_bufs = get_cmd_bufs(
                    vk.clone(), 
                    &renderer,
                    &mut imgui,
                    &presenter, 
                    pipeline.clone()
                );
                
                presenter.present(vk.clone());
                
                sleep(Duration::from_millis(16).saturating_sub(Duration::from_millis((dt * 1000.0) as u64)));
                dt = now.elapsed().as_secs_f32();
            }

            Event::LoopDestroyed => {println!("EXIT");}
            _ => {}
        }
    });
}

impl<T> EventLoop<T>

pub fn with_user_event() -> EventLoop<T>

👎Deprecated: Use EventLoopBuilder::<T>::with_user_event().build() instead.

pub fn run<F>(self, event_handler: F) -> !

where F: 'static + FnMut(Event<'_, T>, &EventLoopWindowTarget<T>, &mut ControlFlow),

Hijacks the calling thread and initializes the winit event loop with the provided closure. Since the closure is 'static, it must be a move closure if it needs to access any data from the calling context.

See the ControlFlow docs for information on how changes to &mut ControlFlow impact the event loop’s behavior.

Any values not passed to this function will not be dropped.

Platform-specific

• X11 / Wayland: The program terminates with exit code 1 if the display server disconnects.

Examples found in repository

examples/scene_example.rs (lines 79-162)

fn example() {
    let el = EventLoop::new();
    let (vk, window) = Vk::new(&el);
    window.set_cursor_grab(winit::window::CursorGrabMode::Confined).unwrap();
    window.set_cursor_visible(false);
    window.set_title("CHAOS-VK");
    window.set_window_icon({
        let w = 8;
        let h = 8;

        Some(Icon::from_rgba(
            (0..w*h*4).map(|_| rand_betw(0, 255)).collect(), 
            w, 
            h
        ).unwrap())
    });
    window.set_theme(Some(Theme::Dark));
    window.set_inner_size(PhysicalSize::new(1200, 900));
    let size = window.inner_size();

    
    let mut presenter = Presenter::new(vk.clone(), window.clone());
    let mut renderer = Renderer::new();
    let mut imgui = ImGui::new(vk.clone(), &presenter);

    renderer.camera.proj = Mat4::perspective_lh(
        80.0f32.to_radians(), 
        size.width as f32 / size.height as f32, 0.1, 1000.0
    );

    let vs = shaders::vs::load(vk.device.clone()).unwrap();
    let fs = shaders::fs::load(vk.device.clone()).unwrap();

    let rp = render_pass_with_depth(vk.clone(), Some(presenter.swapchain.clone()));

    let pipeline = instancing_pipeline(vk.clone(), vs.clone(), fs.clone(), rp.clone(), Viewport {
        offset: [0.0, 0.0],
        extent: size.into(),
        depth_range: 0.0..=1.0,
    });

    presenter.window_resized = true;
    presenter.recreate(vk.clone(), rp.clone(), window.clone());

    let sphere = sphere(5, 1.0);
    renderer.meshes.push(Mesh::new(vk.clone(), &sphere.vertices, &sphere.indices));

    let mut cursor_x = 0.0;
    let mut cursor_y = 0.0;

    let data = (0..250).map(|_| { PosInstanceData {
            ofs: [rand_betw(-100.0, 100.0), rand_betw(-10.0, 10.0), rand_betw(-100.0, 100.0)]
        }
    }).collect::<Vec<PosInstanceData>>();
    renderer.meshes[0].instances = data.clone();
    let instance_buffer = VkIterBuffer::vertex(vk.allocators.clone(), data);
    renderer.meshes[0].ibo = instance_buffer;

    let mut dt = 0.0;

    el.run(move |event, _target, control_flow| {
        control_flow.set_poll();

        match event {
            Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
                control_flow.set_exit();
            },
            Event::WindowEvent { event, .. } => {
                renderer.camera.input(&event);

                match event {
                    WindowEvent::KeyboardInput { input, .. } => {
                        if input.virtual_keycode == Some(VirtualKeyCode::Escape) {
                            control_flow.set_exit();
                        }

                        if input.modifiers.ctrl() && input.virtual_keycode == Some(VirtualKeyCode::S) {
                            Scene::write("assets/scene.cf", &renderer).expect("Failed to write scene");
                        }

                        if input.modifiers.ctrl() && input.virtual_keycode == Some(VirtualKeyCode::L) {
                            Scene::read("assets/scene.cf", &mut renderer, vk.clone()).expect("Failed to load scene");
                        }

                       window.set_cursor_visible(input.modifiers.alt());
                    },

                    WindowEvent::CursorMoved { position, .. } => {
                        imgui.on_mouse_move(position.x as f32, position.y as f32);
                    }

                    WindowEvent::MouseInput { button, state, .. } => {
                        imgui.on_mouse_click(button, state);
                    }

                    WindowEvent::MouseWheel { delta: MouseScrollDelta::PixelDelta(pos), .. } => {
                        imgui.on_mouse_scroll(pos.x as f32, pos.y as f32);
                    }

                    _ => ()
                }
            }

            Event::DeviceEvent {
                event: DeviceEvent::Text { codepoint }, ..
            } => {
                dbg!(codepoint);
            }

            Event::DeviceEvent { event: DeviceEvent::MouseMotion { delta },.. } => {
                cursor_x += delta.0 as f32;
                cursor_y += delta.1 as f32;

                renderer.camera.mouse_callback(cursor_x, cursor_y);
            }

            Event::MainEventsCleared => {
                let now = std::time::Instant::now();
                
                let frame = imgui.frame(&window);
                frame.text("hello, world!");
                frame.text(format!("dt:{:.1}", dt*1000.0));
                
                presenter.recreate(vk.clone(), rp.clone(), window.clone());

                renderer.update(dt);
                presenter.cmd_bufs = get_cmd_bufs(
                    vk.clone(), 
                    &renderer,
                    &mut imgui,
                    &presenter, 
                    pipeline.clone()
                );
                
                presenter.present(vk.clone());
                
                sleep(Duration::from_millis(16).saturating_sub(Duration::from_millis((dt * 1000.0) as u64)));
                dt = now.elapsed().as_secs_f32();
            }

            Event::LoopDestroyed => {println!("EXIT");}
            _ => {}
        }
    });
}

pub fn create_proxy(&self) -> EventLoopProxy<T>

Creates an EventLoopProxy that can be used to dispatch user events to the main event loop.

Methods from Deref<Target = EventLoopWindowTarget<T>>

pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle>

Returns the list of all the monitors available on the system.

pub fn primary_monitor(&self) -> Option<MonitorHandle>

Returns the primary monitor of the system.

Returns None if it can’t identify any monitor as a primary one.

Platform-specific

Wayland: Always returns None.

pub fn set_device_event_filter(&self, _filter: DeviceEventFilter)

Change DeviceEvent filter mode.

Since the DeviceEvent capture can lead to high CPU usage for unfocused windows, winit will ignore them by default for unfocused windows on Linux/BSD. This method allows changing this filter at runtime to explicitly capture them again.

Platform-specific

• Wayland / macOS / iOS / Android / Web / Orbital: Unsupported.

Trait Implementations

impl<T> Debug for EventLoop<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for EventLoop<()>

fn default() -> EventLoop<()>

Returns the “default value” for a type.

impl<T> Deref for EventLoop<T>

type Target = EventLoopWindowTarget<T>

The resulting type after dereferencing.

fn deref(&self) -> &EventLoopWindowTarget<T>

Dereferences the value.

impl<T> EventLoopExtRunReturn for EventLoop<T>

type UserEvent = T

A type provided by the user that can be passed through Event::UserEvent.

fn run_return<F>(&mut self, event_handler: F) -> i32

where F: FnMut(Event<'_, <EventLoop<T> as EventLoopExtRunReturn>::UserEvent>, &EventLoopWindowTarget<<EventLoop<T> as EventLoopExtRunReturn>::UserEvent>, &mut ControlFlow),

Initializes the winit event loop.

impl<T> HasRawDisplayHandle for EventLoop<T>

fn raw_display_handle(&self) -> RawDisplayHandle

Returns a raw_window_handle::RawDisplayHandle for the event loop.