Struct PressedKeys 

pub struct PressedKeys { /* private fields */ }

Contains the keys that have been pressed since the last update.

Implementations

impl PressedKeys

pub fn new() -> Self

Creates a new PressedKeys instance.

pub fn inner(&self) -> &Map<KeyCode, u8, 16>

Returns the raw map of pressed keys.

Examples found in repository

examples/fabrik/main.rs (line 250)

    fn update(&mut self, update_info: UpdateInfo, shared_state: &mut SharedState<()>) {
        let (x, y) = shared_state.mouse_info.last_mouse_pos;
        let mouse_point = Point {
            x: x as f64,
            y: y as f64 * 2.0,
        };

        if shared_state.mouse_pressed.right {
            // if we are not creating a segment but we do already have a last point, connect it immediately
            if let Some(last_point) = self.last_point {
                if self.currently_creating_segment.is_none() {
                    let new_segment = Segment {
                        start: last_point,
                        length: last_point.distance(&mouse_point),
                    };
                    self.segments.push(new_segment);
                    if self.base_anchor.is_none() {
                        self.base_anchor = Some(last_point);
                    }
                    self.last_point = Some(mouse_point);
                }
            }

            if let Some(start_point) = self.currently_creating_segment.take() {
                let length = start_point.distance(&mouse_point);
                self.last_point = Some(mouse_point);
                let new_segment = Segment {
                    start: start_point,
                    length,
                };
                self.segments.push(new_segment);
                if self.base_anchor.is_none() {
                    self.base_anchor = Some(start_point);
                }
            }

            self.currently_creating_segment = Some(mouse_point);
        }

        if shared_state.pressed_keys.inner().contains_key(&KeyCode::Esc) {
            self.currently_creating_segment = None;
        }

        if shared_state.mouse_info.left_mouse_down {
            // set target
            self.target = Some(mouse_point);
            self.currently_creating_segment = None;

            self.forward_reach();
            self.backward_reach();
        }

        shared_state.mouse_events.for_each_linerp_only_fresh(|mi| {
            if mi.middle_mouse_down {
                self.currently_creating_segment = None;
                let mouse_point = Point {
                    x: mi.last_mouse_pos.0 as f64,
                    y: mi.last_mouse_pos.1 as f64 * 2.0,
                };

                if self.base_anchor.is_none() {
                    self.base_anchor = Some(mouse_point);
                }
                let Some(last_point) = self.last_point else {
                    self.last_point = Some(mouse_point);
                    return;
                };

                let new_segment = Segment {
                    start: last_point,
                    length: last_point.distance(&mouse_point),
                };
                self.segments.push(new_segment);
                self.last_point = Some(mouse_point);
            }
        });

        // if shared_state.pressed_keys.did_press_char_ignore_case('f') {
        //     self.forward_reach();
        // }
        // if shared_state.pressed_keys.did_press_char_ignore_case('b') {
        //     self.backward_reach();
        // }

        if shared_state.pressed_keys.did_press_char_ignore_case('c') {
            self.segments.clear();
            self.base_anchor = None;
            self.target = None;
            self.currently_creating_segment = None;
            self.last_point = None;
        }


        // render into half block display
        self.render_to_half_block_display(mouse_point);
    }

pub fn insert(&mut self, key: KeyCode)

Not recommended to use. However, it is useful to hack key actions in other components if the update order is known.

pub fn did_press_char(&self, c: char) -> bool

Returns true if the given key was pressed since the last update.

pub fn did_press_char_ignore_case(&self, c: char) -> bool

Returns true if the given key was pressed since the last update, ignoring case.

Examples found in repository

examples/ui.rs (line 104)

    fn update(&mut self, update_info: UpdateInfo, shared_state: &mut SharedState<()>) {
        if shared_state.pressed_keys.did_press_char_ignore_case(' ') {
            let width = shared_state.display_info.width();
            let height = shared_state.display_info.height();
            
            let anchor_x = rand::random::<usize>() % width;
            let anchor_y = rand::random::<usize>() % height;
            
            shared_state.ui.add_window(anchor_x, anchor_y, Box::new(MyWindow::new()));
        }
    }

examples/boundschecker.rs (line 86)

    fn update(&mut self, _update_info: UpdateInfo, shared_state: &mut SharedState) {
        // was there a mouse down event?
        let pressed = shared_state.mouse_pressed.left;
        if pressed {
            self.first_loc = None;
            self.second_loc = None;

            self.first_loc = Some(shared_state.mouse_info.last_mouse_pos);
        }

        // was there a mouse up event?
        if !shared_state.mouse_info.left_mouse_down
            && self.first_loc.is_some()
            && self.second_loc.is_none()
        {
            // set the second location
            self.second_loc = Some(shared_state.mouse_info.last_mouse_pos);
        }

        // was there a mouse down event for right?
        let pressed = shared_state.mouse_pressed.right;
        if pressed {
            self.sub_first_loc = None;
            self.sub_second_loc = None;

            self.sub_first_loc = Some(shared_state.mouse_info.last_mouse_pos);
        }

        // was there a mouse up event for right?
        if !shared_state.mouse_info.right_mouse_down
            && self.sub_first_loc.is_some()
            && self.sub_second_loc.is_none()
        {
            // set the second location
            self.sub_second_loc = Some(shared_state.mouse_info.last_mouse_pos);
        }

        if shared_state.pressed_keys.did_press_char_ignore_case(' ') {
            self.union_instead_of_subtract = !self.union_instead_of_subtract;
        }
    }

examples/fabrik/main.rs (line 295)

    fn update(&mut self, update_info: UpdateInfo, shared_state: &mut SharedState<()>) {
        let (x, y) = shared_state.mouse_info.last_mouse_pos;
        let mouse_point = Point {
            x: x as f64,
            y: y as f64 * 2.0,
        };

        if shared_state.mouse_pressed.right {
            // if we are not creating a segment but we do already have a last point, connect it immediately
            if let Some(last_point) = self.last_point {
                if self.currently_creating_segment.is_none() {
                    let new_segment = Segment {
                        start: last_point,
                        length: last_point.distance(&mouse_point),
                    };
                    self.segments.push(new_segment);
                    if self.base_anchor.is_none() {
                        self.base_anchor = Some(last_point);
                    }
                    self.last_point = Some(mouse_point);
                }
            }

            if let Some(start_point) = self.currently_creating_segment.take() {
                let length = start_point.distance(&mouse_point);
                self.last_point = Some(mouse_point);
                let new_segment = Segment {
                    start: start_point,
                    length,
                };
                self.segments.push(new_segment);
                if self.base_anchor.is_none() {
                    self.base_anchor = Some(start_point);
                }
            }

            self.currently_creating_segment = Some(mouse_point);
        }

        if shared_state.pressed_keys.inner().contains_key(&KeyCode::Esc) {
            self.currently_creating_segment = None;
        }

        if shared_state.mouse_info.left_mouse_down {
            // set target
            self.target = Some(mouse_point);
            self.currently_creating_segment = None;

            self.forward_reach();
            self.backward_reach();
        }

        shared_state.mouse_events.for_each_linerp_only_fresh(|mi| {
            if mi.middle_mouse_down {
                self.currently_creating_segment = None;
                let mouse_point = Point {
                    x: mi.last_mouse_pos.0 as f64,
                    y: mi.last_mouse_pos.1 as f64 * 2.0,
                };

                if self.base_anchor.is_none() {
                    self.base_anchor = Some(mouse_point);
                }
                let Some(last_point) = self.last_point else {
                    self.last_point = Some(mouse_point);
                    return;
                };

                let new_segment = Segment {
                    start: last_point,
                    length: last_point.distance(&mouse_point),
                };
                self.segments.push(new_segment);
                self.last_point = Some(mouse_point);
            }
        });

        // if shared_state.pressed_keys.did_press_char_ignore_case('f') {
        //     self.forward_reach();
        // }
        // if shared_state.pressed_keys.did_press_char_ignore_case('b') {
        //     self.backward_reach();
        // }

        if shared_state.pressed_keys.did_press_char_ignore_case('c') {
            self.segments.clear();
            self.base_anchor = None;
            self.target = None;
            self.currently_creating_segment = None;
            self.last_point = None;
        }


        // render into half block display
        self.render_to_half_block_display(mouse_point);
    }

examples/circlerasterizer.rs (line 267)

    fn update(&mut self, update_info: UpdateInfo, shared_state: &mut SharedState<()>) {
        if shared_state.pressed_keys.did_press_char_ignore_case('c') {
            self.free_balls.clear();
        }

        if shared_state.mouse_info.left_mouse_down {
            let current_ball = self.current_ball.get_or_insert(Ball {
                x: shared_state.mouse_info.last_mouse_pos.0 as f64,
                y: shared_state.mouse_info.last_mouse_pos.1 as f64,
                radius: self.default_radius,
                mass: self.default_radius * self.default_radius,
                x_vel: 0.0,
                y_vel: 0.0,
            });

            current_ball.x = shared_state.mouse_info.last_mouse_pos.0 as f64;
            current_ball.y = shared_state.mouse_info.last_mouse_pos.1 as f64;
            current_ball.y_vel = 0.0;
            current_ball.x_vel = 0.0;
            if !self.did_hold_last {
                // first time we're holding again, so we clear the samples
                self.center_samples.clear();
            }
            self.did_hold_last = true;
        } else if self.did_hold_last {
            // must have current ball
            let current_ball = self.current_ball.as_mut().unwrap();
            // just released
            self.did_hold_last = false;
            // compute a force based on average velocity over the samples
            let mut sum_x_delta = 0.0;
            let mut sum_y_delta = 0.0;
            for i in 1..self.center_samples.len() {
                let (x1, y1) = self.center_samples[i - 1];
                let (x2, y2) = self.center_samples[i];
                sum_x_delta += x2 - x1;
                sum_y_delta += y2 - y1;
            }
            let delta_length = self.center_samples.len() as f64 / 60.0;
            let avg_x_vel = sum_x_delta / delta_length;
            let avg_y_vel = sum_y_delta / delta_length;
            let strength = 1.0;
            current_ball.x_vel = avg_x_vel * strength;
            current_ball.y_vel = avg_y_vel * strength;
            // release ball
            self.free_balls.push(current_ball.clone());
            self.current_ball = None;
        }

        if let Some(current_ball) = &mut self.current_ball {
            shared_state.debug_info.custom.insert("Circle Radius".to_string(), format!("{:.2}", current_ball.radius));
            shared_state.debug_info.custom.insert("Circle Center".to_string(), format!("({}, {})", current_ball.x, current_ball.y));
        }

        // simple physics
        // but don't update if we're holding LMB
        if !shared_state.mouse_info.left_mouse_down {
            self.current_ball.as_mut().map(|ball| ball.update(update_info.dt, shared_state.display_info.height() as f64));
        }
        // update all other balls
        // for ball in &mut self.free_balls {
        //     ball.update(update_info.dt, shared_state.display_info.height() as f64);
        // }

        update_balls(update_info.dt, &mut self.free_balls, shared_state.display_info.height() as f64, &self.static_collision);

        self.fixed_update_runner.fuel(update_info.dt);
        while self.fixed_update_runner.has_gas() {
            self.fixed_update_runner.consume();
            if let Some(current_ball) = &mut self.current_ball {
                self.center_samples.push((current_ball.x, current_ball.y));
                if self.center_samples.len() > MAX_SAMPLES {
                    self.center_samples.remove(0);
                }
            }
        }

        // update static collision board
        shared_state.mouse_events.for_each_linerp_only_fresh(|mi| {
            if mi.right_mouse_down {
                self.static_collision.set(mi.last_mouse_pos.0, mi.last_mouse_pos.1, true);
            }
        })
    }

examples/circlerasterizer2.rs (line 388)

    fn update(&mut self, update_info: UpdateInfo, shared_state: &mut SharedState<()>) {
        if shared_state.pressed_keys.did_press_char_ignore_case('c') {
            self.free_balls.clear();
        }

        if shared_state.pressed_keys.did_press_char_ignore_case('r') {
            self.static_collision.fill(false);
        }

        if shared_state.mouse_info.left_mouse_down {
            let world_x = shared_state.mouse_info.last_mouse_pos.0 as f64;
            let world_y = shared_state.mouse_info.last_mouse_pos.1 as f64;
            let current_ball = self.current_ball.get_or_insert_with(|| {
                Ball::new(world_x, world_y, self.default_radius)
            });

            current_ball.set_world_x(world_x);
            current_ball.set_world_y(world_y);
            current_ball.x_vel = 0.0;
            if !self.did_hold_last {
                // first time we're holding again, so we clear the samples
                self.center_samples.clear();
            }
            self.did_hold_last = true;
        } else if self.did_hold_last {
            // must have current ball
            let current_ball = self.current_ball.as_mut().unwrap();
            // just released
            self.did_hold_last = false;
            // compute a force based on average velocity over the samples
            let mut sum_x_delta = 0.0;
            let mut sum_y_delta = 0.0;
            for i in 1..self.center_samples.len() {
                let (x1, y1) = self.center_samples[i - 1];
                let (x2, y2) = self.center_samples[i];
                sum_x_delta += x2 - x1;
                sum_y_delta += y2 - y1;
            }
            let delta_length = self.center_samples.len() as f64 / 60.0;
            let avg_x_vel = sum_x_delta / delta_length;
            let avg_y_vel = sum_y_delta / delta_length;
            let strength = 1.0;
            current_ball.x_vel = avg_x_vel * strength;
            current_ball.y_vel = avg_y_vel * strength;
            // release ball
            self.free_balls.push(current_ball.clone());
            self.current_ball = None;
        }

        if let Some(current_ball) = &mut self.current_ball {
            shared_state.debug_info.custom.insert("Circle Radius".to_string(), format!("{:.2}", current_ball.radius));
            shared_state.debug_info.custom.insert("Circle Center (local)".to_string(), format!("({}, {})", current_ball.local_x(), current_ball.local_y()));
            shared_state.debug_info.custom.insert("Circle Center (world)".to_string(), format!("({}, {})", current_ball.world_x(), current_ball.world_y()));
        }

        if let Some(first_ball) = self.free_balls.first() {
            shared_state.debug_info.custom.insert("First Ball Center (local)".to_string(), format!("({:.2}, {:.2})", first_ball.local_x(), first_ball.local_y()));
            shared_state.debug_info.custom.insert("First Ball Center (world)".to_string(), format!("({:.2}, {:.2})", first_ball.world_x(), first_ball.world_y()));
            shared_state.debug_info.custom.insert("First Ball velocity".to_string(), format!("({:.2}, {:.2})", first_ball.x_vel, first_ball.y_vel));

        }

        update_balls(update_info.dt, &mut self.free_balls, shared_state.display_info.height() as f64, &self.static_collision);

        self.fixed_update_runner.fuel(update_info.dt);
        while self.fixed_update_runner.has_gas() {
            self.fixed_update_runner.consume();
            if let Some(current_ball) = &mut self.current_ball {
                self.center_samples.push((current_ball.local_x(), current_ball.local_y()));
                if self.center_samples.len() > MAX_SAMPLES {
                    self.center_samples.remove(0);
                }
            }
        }

        // update static collision board
        shared_state.mouse_events.for_each_linerp_only_fresh(|mi| {
            if mi.right_mouse_down {
                self.static_collision.set(mi.last_mouse_pos.0, mi.last_mouse_pos.1, true);
            }
        })
    }

pub fn did_press(&self, key: KeyCode) -> bool

Returns true if the given key was pressed since the last update.