Struct KeyInputHandler 

pub struct KeyInputHandler {
    pub show_ui: bool,
    /* private fields */
}

Fields

show_ui: bool

Implementations

impl KeyInputHandler

pub fn new() -> Self

pub fn handle_keyboard_input( &mut self, window: &Window, event: &KeyEvent, ) -> bool

Examples found in repository

examples/fluidsim.rs (line 412)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        if self.base.egui_state.on_window_event(core.window(), event).consumed {
            return true;
        }
        if self.base.handle_mouse_input(core, event, false) {
            if let WindowEvent::MouseInput { state, button, .. } = event {
                if *button == winit::event::MouseButton::Left && state.is_pressed() {
                    self.current_color = Self::generate_color();
                }
            }
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            return self.base.key_handler.handle_keyboard_input(core.window(), event);
        }

        false
    }

examples/veridisquo.rs (line 226)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        if self
            .base
            .egui_state
            .on_window_event(core.window(), event)
            .consumed
        {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if event.state == winit::event::ElementState::Pressed {
                if let winit::keyboard::Key::Character(ref s) = event.logical_key {
                    if s.as_str() == "r" || s.as_str() == "R" {
                        self.base.start_time = std::time::Instant::now();
                        // Reset audio stream
                        if let Some(ref mut stream) = self.pcm_stream {
                            let _ = stream.stop();
                            let _ = stream.start();
                        }
                        return true;
                    }
                }
            }
            return self
                .base
                .key_handler
                .handle_keyboard_input(core.window(), event);
        }

        false
    }

examples/blockgame.rs (line 248)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        let ui_handled = self
            .base
            .egui_state
            .on_window_event(core.window(), event)
            .consumed;

        if self.base.handle_mouse_input(core, event, ui_handled) {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if let winit::keyboard::PhysicalKey::Code(key_code) = event.physical_key {
                if event.state == ElementState::Pressed {
                    let camera_speed = 0.5;

                    match key_code {
                        winit::keyboard::KeyCode::KeyQ => {
                            self.game_params.camera_height += camera_speed;
                            return true;
                        }
                        winit::keyboard::KeyCode::KeyE => {
                            self.game_params.camera_height -= camera_speed;
                            return true;
                        }
                        winit::keyboard::KeyCode::KeyW => {
                            self.game_params.camera_angle += 0.1;
                            return true;
                        }
                        winit::keyboard::KeyCode::KeyS => {
                            self.game_params.camera_angle -= 0.1;
                            return true;
                        }
                        _ => {}
                    }
                }
            }
            return self
                .base
                .key_handler
                .handle_keyboard_input(core.window(), event);
        }

        false
    }

examples/synth.rs (line 347)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        if self
            .base
            .egui_state
            .on_window_event(core.window(), event)
            .consumed
        {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if let winit::keyboard::Key::Character(ref s) = event.logical_key {
                if let Some(key_index) = s.chars().next().and_then(|c| c.to_digit(10)) {
                    if (1..=9).contains(&key_index) {
                        let index = (key_index - 1) as usize;

                        let current_time = self.base.controls.get_time(&self.base.start_time);
                        if event.state == winit::event::ElementState::Pressed && !self.keys_held[index] {
                            self.keys_held[index] = true;
                            let has_previous = self.current_params.key_states[index / 4][index % 4] > 0.0;
                            let in_release = self.current_params.key_decay[index / 4][index % 4] > 0.0;
                            if has_previous && in_release {
                                // Retrigger: just cancel the release, note continues from current level
                                self.set_key_release_time(index, 0.0);
                            } else {
                                // Fresh note
                                self.set_key_press_time(index, current_time);
                                self.set_key_release_time(index, 0.0);
                            }
                            self.compute_shader
                                .set_custom_params(self.current_params, &core.queue);
                        } else if event.state == winit::event::ElementState::Released {
                            self.keys_held[index] = false;
                            // Store release time — shader ADSR handles the fade
                            self.set_key_release_time(index, current_time);
                            self.compute_shader
                                .set_custom_params(self.current_params, &core.queue);
                        }
                        return true;
                    }
                }
            }
            return self
                .base
                .key_handler
                .handle_keyboard_input(core.window(), event);
        }

        false
    }

examples/gaussian3d.rs (line 437)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        if self.base.egui_state.on_window_event(core.window(), event).consumed {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if self.base.key_handler.handle_keyboard_input(core.window(), event) {
                return true;
            }
            if let winit::keyboard::Key::Character(ch) = &event.logical_key {
                let key = ch.as_str().to_lowercase();
                match event.state {
                    winit::event::ElementState::Pressed => {
                        if key == "r" {
                            self.camera.reset();
                            self.sorter.force_sort();
                            return true;
                        }
                        if matches!(key.as_str(), "w" | "a" | "s" | "d" | "q" | "e") {
                            self.camera.keys_held.insert(key);
                            return true;
                        }
                    }
                    winit::event::ElementState::Released => {
                        self.camera.keys_held.remove(&key);
                    }
                }
            }
        }

        if let WindowEvent::MouseInput { state, button, .. } = event {
            if *button == winit::event::MouseButton::Left {
                self.camera.is_dragging = *state == winit::event::ElementState::Pressed;
                return true;
            }
        }

        if let WindowEvent::CursorMoved { position, .. } = event {
            let x = position.x as f32;
            let y = position.y as f32;
            if self.camera.is_dragging {
                let dx = x - self.camera.last_mouse[0];
                let dy = y - self.camera.last_mouse[1];
                self.camera.yaw += dx * 0.01;
                self.camera.pitch = (self.camera.pitch + dy * 0.01).clamp(-1.5, 1.5);
            }
            self.camera.last_mouse = [x, y];
            return self.camera.is_dragging;
        }

        if let WindowEvent::MouseWheel { delta, .. } = event {
            let d = match delta {
                winit::event::MouseScrollDelta::LineDelta(_, y) => *y,
                winit::event::MouseScrollDelta::PixelDelta(p) => (p.y as f32 / 100.0).clamp(-3.0, 3.0)};
            let factor = (1.0 + d * 0.1).clamp(0.5, 2.0);
            self.camera.distance = (self.camera.distance * factor).clamp(0.1, 500.0);
            return true;
        }

        if let WindowEvent::DroppedFile(path) = event {
            if path.extension().map(|e| e == "ply").unwrap_or(false) {
                self.load_ply(core, path);
            }
            return true;
        }

        false
    }

examples/mandelbulb.rs (line 666)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        if self
            .base
            .egui_state
            .on_window_event(core.window(), event)
            .consumed
        {
            return true;
        }

        if self.base.handle_mouse_input(core, event, false) {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if let winit::keyboard::Key::Character(ch) = &event.logical_key {
                match ch.as_str() {
                    " " => {
                        if event.state == winit::event::ElementState::Released {
                            self.current_params.accumulate = 1 - self.current_params.accumulate;
                            self.should_reset_accumulation = true;
                            self.compute_shader
                                .set_custom_params(self.current_params, &core.queue);
                            return true;
                        }
                    }
                    "m" | "M" => {
                        if event.state == winit::event::ElementState::Released {
                            self.mouse_enabled = !self.mouse_enabled;
                            self.mouse_initialized = false;
                            return true;
                        }
                    }
                    "w" | "W" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[1] -= 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    "s" | "S" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[1] += 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    "a" | "A" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[0] -= 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    "d" | "D" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[0] += 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    "q" | "Q" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[2] -= 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    "e" | "E" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[2] += 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    _ => {}
                }
            }
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if self
                .base
                .key_handler
                .handle_keyboard_input(core.window(), event)
            {
                return true;
            }
        }

        false
    }

Additional examples can be found in:

• examples/pathtracing.rs

Trait Implementations

impl Default for KeyInputHandler

fn default() -> Self

Returns the “default value” for a type.