Struct ActiveEventLoop

pub struct ActiveEventLoop { /* private fields */ }

Target that associates windows with an EventLoop.

This type exists to allow you to create new windows while Winit executes your callback.

Implementations

impl ActiveEventLoop

pub fn create_window( &self, window_attributes: WindowAttributes, ) -> Result<Window, OsError>

Create the window.

Possible causes of error include denied permission, incompatible system, and lack of memory.

Platform-specific

• Web: The window is created but not inserted into the web page automatically. Please see the web platform module for more information.

pub fn create_custom_cursor( &self, custom_cursor: CustomCursorSource, ) -> CustomCursor

Create custom cursor.

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 / Web: Always returns None.

pub fn listen_device_events(&self, allowed: DeviceEvents)

Change if or when DeviceEvents are captured.

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 at runtime to explicitly capture them again.

Platform-specific

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

pub fn system_theme(&self) -> Option<Theme>

Returns the current system theme.

Returns None if it cannot be determined on the current platform.

Platform-specific

• iOS / Android / Wayland / x11 / Orbital: Unsupported.

pub fn set_control_flow(&self, control_flow: ControlFlow)

Sets the ControlFlow.

pub fn control_flow(&self) -> ControlFlow

Gets the current ControlFlow.

pub fn exit(&self)

This exits the event loop.

See LoopExiting.

Examples found in repository

examples/simple.rs (line 96)

fn main() {
    use Action::*;
    let event_loop = EventLoop::new().unwrap();
    event_loop.set_control_flow(ControlFlow::Poll);
    
    let input = { use base_input_codes::*; input_map!(
        (Jump,    Space,  GamepadInput::South),
        (Exit,    Escape, GamepadInput::Start),
        (Left,    ArrowLeft,  KeyA,  LeftStickLeft ),
        (Right,   ArrowRight, KeyD,  LeftStickRight),
        (Forward, ArrowUp,    KeyW,  LeftStickUp   ),
        (Back,    ArrowDown,  KeyS,  LeftStickDown ),
        (LookRight, MouseMoveRight, RightStickRight),
        (LookLeft,  MouseMoveLeft,  RightStickLeft ),
        (LookUp,    MouseMoveUp,    RightStickUp   ),
        (LookDown,  MouseMoveDown,  RightStickDown )
    )};

    struct Graphics {
        program: Program,
        indices: IndexBuffer<u16>,
        vertices: VertexBuffer<Vertex>,
        normals: VertexBuffer<Normal>
    }
    let graphics: Rc<RefCell<Option<Graphics>>> = Rc::new(RefCell::new(None));
    let graphics_setup = graphics.clone();
    
    let draw_parameters = DrawParameters {
        backface_culling: draw_parameters::BackfaceCullingMode::CullClockwise,
        ..params::alias_3d()
    };

    let mut pos = vec3(0.0, 0.0, -30.0);
    let mut rot = vec2(0.0, 0.0);
    let mut gravity = 0.0;

    let mut frame_start = Instant::now();

    thin_engine::builder(input).with_setup(|display, window, _| {
        let _ = window.set_cursor_grab(CursorGrabMode::Confined);
        let _ = window.set_cursor_grab(CursorGrabMode::Locked);
        window.set_cursor_visible(false);
        window.set_title("Walk Test");

        let (indices, vertices, normals) = mesh!(
            display, &teapot::INDICES, &teapot::VERTICES, &teapot::NORMALS
        );
        let program = Program::from_source(
            display, shaders::VERTEX,
            "#version 140
            out vec4 colour;
            in vec3 v_normal;
            uniform vec3 light;
            const vec3 albedo = vec3(0.1, 1.0, 0.3);
            void main(){
                float light_level = dot(light, v_normal);
                colour = vec4(albedo * light_level, 1.0);
            }", None,
        ).unwrap();
        graphics_setup.replace(Some(Graphics { program, indices, vertices, normals }));
    }).with_update(|input, display, _, target, _| {
        let graphics = graphics.borrow();
        let Graphics { vertices, indices, normals, program } = graphics.as_ref().unwrap();
        let delta_time = frame_start.elapsed().as_secs_f32();
        frame_start = Instant::now();

        let mut frame = display.draw();
        let view = Mat4::view_matrix_3d(frame.get_dimensions(), 1.0, 1024.0, 0.1);

        //handle gravity and jump
        gravity += delta_time * 9.5;
        if input.pressed(Jump) { gravity = -10.0 }

        //set camera rotation
        let look_move = input.dir(LookLeft, LookRight, LookUp, LookDown);
        rot += look_move.scale(delta_time * 20.0);
        rot.y = rot.y.clamp(-PI / 2.0, PI / 2.0);
        let rx = Quat::from_y_rot(rot.x);
        let ry = Quat::from_x_rot(rot.y);
        let rot = rx * ry;

        //move player based on view and gravity
        let dir = input.dir_max_len_1(Right, Left, Forward, Back);
        let move_dir = vec3(dir.x, 0.0, dir.y).scale(5.0*delta_time);
        pos += move_dir.transform(&Mat3::from_rot(rx));
        pos.y = (pos.y - gravity * delta_time).max(0.0);

        if input.pressed(Exit) { target.exit() }

        frame.clear_color_and_depth((0.0, 0.0, 0.0, 1.0), 1.0);
        //draw teapot
        frame.draw(
            (vertices, normals), indices,
            program, &uniform! {
                view: view,
                model: Mat4::from_scale(Vec3::splat(0.1)),
                camera: Mat4::from_inverse_transform(pos, Vec3::ONE, rot),
                light: vec3(1.0, -0.9, -1.0).normalise()
            },
            &draw_parameters,
        ).unwrap();

        frame.finish().unwrap();
    }).build(event_loop).unwrap();
}

pub fn exiting(&self) -> bool

Returns if the EventLoop is about to stop.

See exit().

pub fn owned_display_handle(&self) -> OwnedDisplayHandle

Gets a persistent reference to the underlying platform display.

See the OwnedDisplayHandle type for more information.

Trait Implementations

impl ActiveEventLoopExtWayland for ActiveEventLoop

fn is_wayland(&self) -> bool

True if the ActiveEventLoop uses Wayland.

impl ActiveEventLoopExtX11 for ActiveEventLoop

fn is_x11(&self) -> bool

True if the ActiveEventLoop uses X11.

impl Debug for ActiveEventLoop

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

Formats the value using the given formatter.

impl EventLoopExtStartupNotify for ActiveEventLoop

fn read_token_from_env(&self) -> Option<ActivationToken>

Read the token from the environment.

impl GliumEventLoop for ActiveEventLoop

fn build<Picker>( &self, display_builder: DisplayBuilder, template_builder: ConfigTemplateBuilder, config_picker: Picker, ) -> Result<(Option<Window>, Config), Box<dyn Error>>

where Picker: FnOnce(Box<dyn Iterator<Item = Config> + '_>) -> Config,

Calls display_builder.build(self, template_builder, config_picker).

impl HasDisplayHandle for ActiveEventLoop

fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>

Get a handle to the display controller of the windowing system.