Struct ButtonInput 

pub struct ButtonInput<T>
where
    T: Clone + Eq + Hash + Send + Sync + 'static,
{ /* private fields */ }

A “press-able” input of type T.

Usage

This type can be used as a resource to keep the current state of an input, by reacting to events from the input. For a given input value:

• ButtonInput::pressed will return true between a press and a release event.
• ButtonInput::just_pressed will return true for one frame after a press event.
• ButtonInput::just_released will return true for one frame after a release event.

Multiple systems

In case multiple systems are checking for ButtonInput::just_pressed or ButtonInput::just_released but only one should react, for example when modifying a Resource, you should consider clearing the input state, either by:

• Using ButtonInput::clear_just_pressed or ButtonInput::clear_just_released instead.
• Calling ButtonInput::clear or ButtonInput::reset immediately after the state change.

Performance

For all operations, the following conventions are used:

• n is the number of stored inputs.
• m is the number of input arguments passed to the method.
• *-suffix denotes an amortized cost.
• ~-suffix denotes an expected cost.

See Rust’s std::collections doc on performance for more details on the conventions used here.

ButtonInput operations	Computational complexity
ButtonInput::any_just_pressed	O(m)~
ButtonInput::any_just_released	O(m)~
ButtonInput::any_pressed	O(m)~
ButtonInput::get_just_pressed	O(n)
ButtonInput::get_just_released	O(n)
ButtonInput::get_pressed	O(n)
ButtonInput::just_pressed	O(1)~
ButtonInput::just_released	O(1)~
ButtonInput::pressed	O(1)~
ButtonInput::press	O(1)~*
ButtonInput::release	O(1)~*
ButtonInput::release_all	O(n)~*
ButtonInput::clear_just_pressed	O(1)~
ButtonInput::clear_just_released	O(1)~
ButtonInput::reset_all	O(n)
ButtonInput::clear	O(n)

Window focus

ButtonInput<KeyCode> is tied to window focus. For example, if the user holds a button while the window loses focus, ButtonInput::just_released will be triggered. Similarly if the window regains focus, ButtonInput::just_pressed will be triggered.

ButtonInput<GamepadButton> is independent of window focus.

Examples

Reading and checking against the current set of pressed buttons:

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(
            Update,
            print_mouse.run_if(resource_changed::<ButtonInput<MouseButton>>),
        )
        .add_systems(
            Update,
            print_keyboard.run_if(resource_changed::<ButtonInput<KeyCode>>),
        )
        .run();
}

fn print_mouse(mouse: Res<ButtonInput<MouseButton>>) {
    println!("Mouse: {:?}", mouse.get_pressed().collect::<Vec<_>>());
}

fn print_keyboard(keyboard: Res<ButtonInput<KeyCode>>) {
    if keyboard.any_pressed([KeyCode::ControlLeft, KeyCode::ControlRight])
        && keyboard.any_pressed([KeyCode::AltLeft, KeyCode::AltRight])
        && keyboard.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight])
        && keyboard.any_pressed([KeyCode::SuperLeft, KeyCode::SuperRight])
        && keyboard.pressed(KeyCode::KeyL)
    {
        println!("On Windows this opens LinkedIn.");
    } else {
        println!("keyboard: {:?}", keyboard.get_pressed().collect::<Vec<_>>());
    }
}

Note

When adding this resource for a new input type, you should:

• Call the ButtonInput::press method for each press event.
• Call the ButtonInput::release method for each release event.
• Call the ButtonInput::clear method at each frame start, before processing events.

Note: Calling clear from a ResMut will trigger change detection. It may be preferable to use DetectChangesMut::bypass_change_detection to avoid causing the resource to always be marked as changed.

Implementations

impl<T> ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static,

pub fn press(&mut self, input: T)

Registers a press for the given input.

pub fn pressed(&self, input: T) -> bool

Returns true if the input has been pressed.

Examples found in repository

examples/ecs/extraction.rs (line 107)

fn trigger_extraction(mut writer: MessageWriter<ExtractMessage>, keys: Res<ButtonInput<KeyCode>>) {
    if keys.pressed(KeyCode::Space) {
        writer.write(ExtractMessage);
    }
}

examples/ecs/generic_system.rs (line 78)

fn transition_to_in_game_system(
    mut next_state: ResMut<NextState<AppState>>,
    keyboard_input: Res<ButtonInput<KeyCode>>,
) {
    if keyboard_input.pressed(KeyCode::Space) {
        next_state.set(AppState::InGame);
    }
}

examples/ecs/component_hooks.rs (line 142)

fn trigger_hooks(
    mut commands: Commands,
    keys: Res<ButtonInput<KeyCode>>,
    index: Res<MyComponentIndex>,
) {
    for (key, entity) in index.iter() {
        if !keys.pressed(*key) {
            commands.entity(*entity).remove::<MyComponent>();
        }
    }
    for key in keys.get_just_pressed() {
        commands.spawn(MyComponent(*key));
    }
}

examples/input/mouse_input.rs (line 17)

fn mouse_click_system(mouse_button_input: Res<ButtonInput<MouseButton>>) {
    if mouse_button_input.pressed(MouseButton::Left) {
        info!("left mouse currently pressed");
    }

    if mouse_button_input.just_pressed(MouseButton::Left) {
        info!("left mouse just pressed");
    }

    if mouse_button_input.just_released(MouseButton::Left) {
        info!("left mouse just released");
    }
}

examples/ui/text/ime_support.rs (line 106)

fn text_submission(
    input_focus: Res<InputFocus>,
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut text_input: Query<&mut EditableText>,
    mut text_output: Single<&mut Text, With<TextOutput>>,
) {
    if keyboard_input.just_pressed(KeyCode::Enter)
        && (keyboard_input.pressed(KeyCode::ControlLeft)
            || keyboard_input.pressed(KeyCode::ControlRight))
        && let Some(focused_entity) = input_focus.get()
        && let Ok(mut input) = text_input.get_mut(focused_entity)
    {
        text_output.0 = input.value().to_string();
        input.clear();
    }
}

examples/audio/spatial_audio_2d.rs (line 113)

fn update_listener(
    keyboard: Res<ButtonInput<KeyCode>>,
    time: Res<Time>,
    mut listener: Single<&mut Transform, With<SpatialListener>>,
) {
    let speed = 200.;

    if keyboard.pressed(KeyCode::ArrowRight) {
        listener.translation.x += speed * time.delta_secs();
    }
    if keyboard.pressed(KeyCode::ArrowLeft) {
        listener.translation.x -= speed * time.delta_secs();
    }
    if keyboard.pressed(KeyCode::ArrowUp) {
        listener.translation.y += speed * time.delta_secs();
    }
    if keyboard.pressed(KeyCode::ArrowDown) {
        listener.translation.y -= speed * time.delta_secs();
    }
}

Additional examples can be found in:

• examples/audio/spatial_audio_3d.rs
• examples/3d/lighting.rs
• examples/camera/first_person_view_model.rs
• examples/state/custom_transitions.rs
• examples/state/states.rs
• examples/state/sub_states.rs
• examples/camera/2d_top_down_camera.rs
• examples/3d/rect_light.rs
• examples/3d/depth_of_field.rs
• examples/ui/ui_transform.rs
• examples/showcase/breakout.rs
• examples/state/computed_states.rs
• examples/3d/reflection_probes.rs
• examples/stress_tests/bevymark_3d.rs
• examples/3d/spotlight.rs
• examples/3d/volumetric_fog.rs
• examples/input/keyboard_input.rs
• examples/3d/irradiance_volumes.rs
• examples/3d/generate_custom_mesh.rs
• examples/ui/text/letter_spacing.rs
• examples/ui/images/image_node_resizing.rs
• examples/3d/order_independent_transparency.rs
• examples/camera/free_camera_controller.rs
• examples/stress_tests/bevymark.rs
• examples/3d/mixed_lighting.rs
• examples/3d/solari_reflections.rs
• examples/testbed/full_ui.rs
• examples/gizmos/light_gizmos.rs
• examples/3d/ssr.rs
• examples/2d/rotation.rs
• examples/3d/mirror.rs
• examples/shader_advanced/render_depth_to_texture.rs
• examples/3d/visibility_range.rs
• examples/3d/tonemapping.rs
• examples/3d/auto_exposure.rs
• examples/3d/light_probe_blending.rs
• examples/camera/camera_orbit.rs
• examples/movement/physics_in_fixed_timestep.rs
• examples/showcase/alien_cake_addict.rs
• examples/3d/post_processing.rs
• examples/3d/atmosphere.rs
• examples/3d/blend_modes.rs
• examples/2d/2d_viewport_to_world.rs
• examples/gizmos/2d_gizmos.rs
• examples/gizmos/3d_gizmos.rs
• examples/3d/bloom_3d.rs
• examples/3d/fog.rs
• examples/2d/bloom_2d.rs
• examples/3d/transmission.rs
• examples/reflection/mutation_by_reflection.rs
• examples/ui/text/multiline_text_input.rs

pub fn any_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if any item in inputs has been pressed.

Examples found in repository

examples/input/keyboard_modifiers.rs (line 14)

fn keyboard_input_system(input: Res<ButtonInput<KeyCode>>) {
    let shift = input.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight]);
    let ctrl = input.any_pressed([KeyCode::ControlLeft, KeyCode::ControlRight]);

    if ctrl && shift && input.just_pressed(KeyCode::KeyA) {
        info!("Just pressed Ctrl + Shift + A!");
    }
}

examples/ui/scroll_and_overflow/scroll.rs (line 40)

fn send_scroll_events(
    mut mouse_wheel_reader: MessageReader<MouseWheel>,
    hover_map: Res<HoverMap>,
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut commands: Commands,
) {
    for mouse_wheel in mouse_wheel_reader.read() {
        let mut delta = -Vec2::new(mouse_wheel.x, mouse_wheel.y);

        if mouse_wheel.unit == MouseScrollUnit::Line {
            delta *= LINE_HEIGHT;
        }

        if keyboard_input.any_pressed([KeyCode::ControlLeft, KeyCode::ControlRight]) {
            std::mem::swap(&mut delta.x, &mut delta.y);
        }

        for pointer_map in hover_map.values() {
            for entity in pointer_map.keys().copied() {
                commands.trigger(Scroll { entity, delta });
            }
        }
    }
}

examples/3d/fog.rs (line 253)

fn update_system(
    camera: Single<(&mut DistanceFog, &mut Transform)>,
    mut text: Single<&mut Text>,
    time: Res<Time>,
    keycode: Res<ButtonInput<KeyCode>>,
) {
    let now = time.elapsed_secs();
    let delta = time.delta_secs();

    let (mut fog, mut transform) = camera.into_inner();

    // Orbit camera around pyramid
    let orbit_scale = 8.0 + ops::sin(now / 10.0) * 7.0;
    *transform = Transform::from_xyz(
        ops::cos(now / 5.0) * orbit_scale,
        12.0 - orbit_scale / 2.0,
        ops::sin(now / 5.0) * orbit_scale,
    )
    .looking_at(Vec3::ZERO, Vec3::Y);

    // Fog Information
    text.0 = format!("Fog Falloff: {:?}\nFog Color: {:?}", fog.falloff, fog.color);

    // Fog Falloff Mode Switching
    text.push_str("\n\n1 / 2 / 3 - Fog Falloff Mode");

    if keycode.pressed(KeyCode::Digit1) {
        if let FogFalloff::Linear { .. } = fog.falloff {
            // No change
        } else {
            fog.falloff = FogFalloff::Linear {
                start: 5.0,
                end: 20.0,
            };
        };
    }

    if keycode.pressed(KeyCode::Digit2) {
        if let FogFalloff::Exponential { .. } = fog.falloff {
            // No change
        } else if let FogFalloff::ExponentialSquared { density } = fog.falloff {
            fog.falloff = FogFalloff::Exponential { density };
        } else {
            fog.falloff = FogFalloff::Exponential { density: 0.07 };
        };
    }

    if keycode.pressed(KeyCode::Digit3) {
        if let FogFalloff::Exponential { density } = fog.falloff {
            fog.falloff = FogFalloff::ExponentialSquared { density };
        } else if let FogFalloff::ExponentialSquared { .. } = fog.falloff {
            // No change
        } else {
            fog.falloff = FogFalloff::ExponentialSquared { density: 0.07 };
        };
    }

    // Linear Fog Controls
    if let FogFalloff::Linear { start, end } = &mut fog.falloff {
        text.push_str("\nA / S - Move Start Distance\nZ / X - Move End Distance");

        if keycode.pressed(KeyCode::KeyA) {
            *start -= delta * 3.0;
        }
        if keycode.pressed(KeyCode::KeyS) {
            *start += delta * 3.0;
        }
        if keycode.pressed(KeyCode::KeyZ) {
            *end -= delta * 3.0;
        }
        if keycode.pressed(KeyCode::KeyX) {
            *end += delta * 3.0;
        }
    }

    // Exponential Fog Controls
    if let FogFalloff::Exponential { density } = &mut fog.falloff {
        text.push_str("\nA / S - Change Density");

        if keycode.pressed(KeyCode::KeyA) {
            *density -= delta * 0.5 * *density;
            if *density < 0.0 {
                *density = 0.0;
            }
        }
        if keycode.pressed(KeyCode::KeyS) {
            *density += delta * 0.5 * *density;
        }
    }

    // ExponentialSquared Fog Controls
    if let FogFalloff::ExponentialSquared { density } = &mut fog.falloff {
        text.push_str("\nA / S - Change Density");

        if keycode.pressed(KeyCode::KeyA) {
            *density -= delta * 0.5 * *density;
            if *density < 0.0 {
                *density = 0.0;
            }
        }
        if keycode.pressed(KeyCode::KeyS) {
            *density += delta * 0.5 * *density;
        }
    }

    // RGBA Controls
    text.push_str("\n\n- / = - Red\n[ / ] - Green\n; / ' - Blue\n. / ? - Alpha");

    // We're performing various operations in the sRGB color space,
    // so we convert the fog color to sRGB here, then modify it,
    // and finally when we're done we can convert it back and set it.
    let mut fog_color = Srgba::from(fog.color);
    if keycode.pressed(KeyCode::Minus) {
        fog_color.red = (fog_color.red - 0.1 * delta).max(0.0);
    }

    if keycode.any_pressed([KeyCode::Equal, KeyCode::NumpadEqual]) {
        fog_color.red = (fog_color.red + 0.1 * delta).min(1.0);
    }

    if keycode.pressed(KeyCode::BracketLeft) {
        fog_color.green = (fog_color.green - 0.1 * delta).max(0.0);
    }

    if keycode.pressed(KeyCode::BracketRight) {
        fog_color.green = (fog_color.green + 0.1 * delta).min(1.0);
    }

    if keycode.pressed(KeyCode::Semicolon) {
        fog_color.blue = (fog_color.blue - 0.1 * delta).max(0.0);
    }

    if keycode.pressed(KeyCode::Quote) {
        fog_color.blue = (fog_color.blue + 0.1 * delta).min(1.0);
    }

    if keycode.pressed(KeyCode::Period) {
        fog_color.alpha = (fog_color.alpha - 0.1 * delta).max(0.0);
    }

    if keycode.pressed(KeyCode::Slash) {
        fog_color.alpha = (fog_color.alpha + 0.1 * delta).min(1.0);
    }

    fog.color = Color::from(fog_color);
}

pub fn all_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if all items in inputs have been pressed.

pub fn release(&mut self, input: T)

Registers a release for the given input.

pub fn release_all(&mut self)

Registers a release for all currently pressed inputs.

pub fn just_pressed(&self, input: T) -> bool

Returns true if the input has been pressed during the current frame.

Note: This function does not imply information regarding the current state of ButtonInput::pressed or ButtonInput::just_released.

Examples found in repository

examples/app/logs.rs (line 34)

fn panic_on_p(keys: Res<ButtonInput<KeyCode>>) {
    if keys.just_pressed(KeyCode::KeyP) {
        panic!("P pressed, panicking");
    }
}

examples/3d/solari_reflections.rs (line 618)

fn pause_scene(key_input: Res<ButtonInput<KeyCode>>, mut state: ResMut<DemoState>) {
    if key_input.just_pressed(KeyCode::Space) {
        state.paused = !state.paused;
    }
}

fn set_metallic(material: &mut StandardMaterial, metallic: bool) {
    material.metallic = if metallic { 1.0 } else { 0.0 };
    material.base_color = if metallic {
        METALLIC_BASE_COLOR
    } else {
        DIELECTRIC_BASE_COLOR
    };
}

fn toggle_metallic(
    key_input: Res<ButtonInput<KeyCode>>,
    mut state: ResMut<DemoState>,
    test_material: Res<TestMaterial>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    if key_input.just_pressed(KeyCode::Digit1) {
        state.metallic = !state.metallic;
        set_metallic(
            &mut materials.get_mut(&test_material.0).unwrap(),
            state.metallic,
        );
    }
}

fn toggle_mirror_motion(key_input: Res<ButtonInput<KeyCode>>, mut state: ResMut<DemoState>) {
    if key_input.just_pressed(KeyCode::Digit8) {
        state.pan_mirror = !state.pan_mirror;
    }
    if key_input.just_pressed(KeyCode::Digit9) {
        state.slide_mirror = !state.slide_mirror;
    }
}

fn toggle_pathtracer(
    key_input: Res<ButtonInput<KeyCode>>,
    camera: Single<(Entity, Has<Pathtracer>), With<Camera3d>>,
    mut commands: Commands,
) {
    if key_input.just_pressed(KeyCode::KeyP) {
        let (entity, pathtracing) = *camera;
        let mut camera = commands.entity(entity);

        if pathtracing {
            camera.remove_with_requires::<Pathtracer>();
            camera.insert(SolariLighting::default());
        } else {
            camera.remove_with_requires::<SolariLighting>();
            camera.insert(Pathtracer::default());

            #[cfg(all(feature = "dlss", not(feature = "force_disable_dlss")))]
            camera.remove::<(Dlss<DlssRayReconstructionFeature>, TemporalJitter, MipBias)>();
        }
    }
}

fn reset_pathtracer(state: Res<DemoState>, pathtracer: Option<Single<&mut Pathtracer>>) {
    if let Some(mut pathtracer) = pathtracer
        && state.is_changed()
    {
        pathtracer.reset = true;
    }
}

fn select_preset(
    key_input: Res<ButtonInput<KeyCode>>,
    slider: Single<Entity, With<RoughnessSlider>>,
    test_material: Res<TestMaterial>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut commands: Commands,
) {
    for (key, _, roughness) in MATERIAL_PRESETS {
        if key_input.just_pressed(key) {
            materials
                .get_mut(&test_material.0)
                .unwrap()
                .perceptual_roughness = roughness;

            commands.entity(*slider).insert(SliderValue(roughness));
        }
    }
}

examples/window/clear_color.rs (line 21)

fn change_clear_color(input: Res<ButtonInput<KeyCode>>, mut clear_color: ResMut<ClearColor>) {
    if input.just_pressed(KeyCode::Space) {
        clear_color.0 = PURPLE.into();
    }
}

examples/showcase/alien_cake_addict.rs (line 386)

fn game_over_keyboard(
    mut next_state: ResMut<NextState<GameState>>,
    keyboard_input: Res<ButtonInput<KeyCode>>,
) {
    if keyboard_input.just_pressed(KeyCode::Space) {
        next_state.set(GameState::Playing);
    }
}

examples/3d/solari.rs (line 481)

fn toggle_restir(
    key_input: Res<ButtonInput<KeyCode>>,
    mut solari_lighting: Single<&mut SolariLighting>,
) {
    if key_input.just_pressed(KeyCode::KeyR) {
        solari_lighting.restir = !solari_lighting.restir;
    }
}

fn pause_scene(mut time: ResMut<Time<Virtual>>, key_input: Res<ButtonInput<KeyCode>>) {
    if key_input.just_pressed(KeyCode::Space) {
        time.toggle();
    }
}

#[derive(Resource)]
struct RobotLightMaterial(Handle<StandardMaterial>);

fn toggle_lights(
    key_input: Res<ButtonInput<KeyCode>>,
    robot_light_material: Option<Res<RobotLightMaterial>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    directional_light: Query<Entity, With<DirectionalLight>>,
    mut commands: Commands,
) {
    if key_input.just_pressed(KeyCode::Digit1) {
        if let Ok(directional_light) = directional_light.single() {
            commands.entity(directional_light).despawn();
        } else {
            commands.spawn((
                DirectionalLight {
                    illuminance: light_consts::lux::FULL_DAYLIGHT,
                    shadow_maps_enabled: false, // Solari replaces shadow mapping
                    ..default()
                },
                Transform::from_rotation(Quat::from_xyzw(
                    -0.13334629,
                    -0.86597735,
                    -0.3586996,
                    0.3219264,
                )),
            ));
        }
    }

    if key_input.just_pressed(KeyCode::Digit2)
        && let Some(robot_light_material) = robot_light_material
    {
        let mut material = materials.get_mut(&robot_light_material.0).unwrap();
        if material.emissive == LinearRgba::BLACK {
            material.emissive = LinearRgba::from(Color::srgb(0.941, 0.714, 0.043)) * 1_000_000.0;
        } else {
            material.emissive = LinearRgba::BLACK;
        }
    }
}

examples/3d/3d_shapes.rs (line 265)

fn toggle_wireframe(
    mut wireframe_config: ResMut<WireframeConfig>,
    keyboard: Res<ButtonInput<KeyCode>>,
) {
    if keyboard.just_pressed(KeyCode::Space) {
        wireframe_config.global = !wireframe_config.global;
    }
}

Additional examples can be found in:

• examples/ui/window_fallthrough.rs
• examples/testbed/2d.rs
• examples/testbed/3d.rs
• examples/testbed/ui.rs
• examples/ecs/hierarchy.rs
• examples/audio/audio_control.rs
• examples/ecs/observers.rs
• examples/3d/rect_light.rs
• examples/audio/play_sound_effect.rs
• examples/window/scale_factor_override.rs
• examples/input/keyboard_modifiers.rs
• examples/ui/images/ui_texture_atlas.rs
• examples/window/monitor_info.rs
• examples/state/sub_states.rs
• examples/window/screenshot.rs
• examples/stress_tests/many_gizmos.rs
• examples/3d/atmospheric_fog.rs
• examples/window/window_settings.rs
• examples/3d/depth_of_field.rs
• examples/state/computed_states.rs
• examples/input/mouse_input.rs
• examples/ecs/one_shot_systems.rs
• examples/ecs/run_conditions.rs
• examples/input/mouse_grab.rs
• examples/math/bounding_2d.rs
• examples/shader/gpu_readback.rs
• examples/reflection/mutation_by_reflection.rs
• examples/audio/pitch.rs
• examples/app/settings.rs
• examples/ecs/entity_disabling.rs
• examples/ui/text/text_input.rs
• examples/ui/ui_scaling.rs
• examples/window/window_resizing.rs
• examples/dev_tools/infinite_grid.rs
• examples/ui/scroll_and_overflow/overflow_debug.rs
• examples/window/low_power.rs
• examples/ui/text/ime_support.rs
• examples/camera/pan_orbit_camera_cad.rs
• examples/ui/widgets/standard_widgets_observers.rs
• examples/shader_advanced/fullscreen_material.rs
• examples/ui/navigation/directional_navigation.rs
• examples/ui/navigation/directional_navigation_overrides.rs
• examples/showcase/loading_screen.rs
• examples/audio/spatial_audio_2d.rs
• examples/3d/tonemapping.rs
• examples/ui/widgets/standard_widgets.rs
• examples/3d/shadow_caster_receiver.rs
• examples/audio/spatial_audio_3d.rs
• examples/camera/projection_zoom.rs
• examples/showcase/stepping.rs
• examples/math/cubic_splines.rs
• examples/3d/shadow_biases.rs
• examples/window/custom_cursor_image.rs
• examples/window/window_drag_move.rs
• examples/3d/irradiance_volumes.rs
• examples/transforms/align.rs
• examples/testbed/full_ui.rs
• examples/input/keyboard_input.rs
• examples/shader/shader_prepass.rs
• examples/ui/text/multiple_text_inputs.rs
• examples/3d/generate_custom_mesh.rs
• examples/3d/parallax_mapping.rs
• examples/dev_tools/fps_overlay.rs
• examples/ecs/fallible_params.rs
• examples/3d/motion_blur.rs
• examples/3d/order_independent_transparency.rs
• examples/camera/free_camera_controller.rs
• examples/ui/text/letter_spacing.rs
• examples/3d/lighting.rs
• examples/app/render_recovery.rs
• examples/gizmos/light_gizmos.rs
• examples/3d/visibility_range.rs
• examples/3d/volumetric_fog.rs
• examples/stress_tests/many_foxes.rs
• examples/3d/auto_exposure.rs
• examples/3d/post_processing.rs
• examples/diagnostics/log_diagnostics.rs
• examples/3d/reflection_probes.rs
• examples/3d/atmosphere.rs
• examples/3d/wireframe.rs
• examples/3d/blend_modes.rs
• examples/math/random_sampling.rs
• examples/3d/anisotropy.rs
• examples/3d/deferred_rendering.rs
• examples/animation/animated_mesh_control.rs
• examples/camera/pan_orbit_camera_custom_input_plugin.rs
• examples/gizmos/2d_gizmos.rs
• examples/gizmos/3d_gizmos.rs
• examples/3d/ssao.rs
• examples/3d/bloom_3d.rs
• examples/2d/bloom_2d.rs
• examples/3d/anti_aliasing.rs
• examples/3d/transmission.rs

pub fn any_just_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if any item in inputs has been pressed during the current frame.

pub fn clear_just_pressed(&mut self, input: T) -> bool

Clears the just_pressed state of the input and returns true if the input has just been pressed.

Future calls to ButtonInput::just_pressed for the given input will return false until a new press event occurs.

pub fn just_released(&self, input: T) -> bool

Returns true if the input has been released during the current frame.

Note: This function does not imply information regarding the current state of ButtonInput::pressed or ButtonInput::just_pressed.

Examples found in repository

examples/input/mouse_input.rs (line 25)

fn mouse_click_system(mouse_button_input: Res<ButtonInput<MouseButton>>) {
    if mouse_button_input.pressed(MouseButton::Left) {
        info!("left mouse currently pressed");
    }

    if mouse_button_input.just_pressed(MouseButton::Left) {
        info!("left mouse just pressed");
    }

    if mouse_button_input.just_released(MouseButton::Left) {
        info!("left mouse just released");
    }
}

examples/stress_tests/bevymark_3d.rs (line 314)

fn mouse_handler(
    mut commands: Commands,
    args: Res<Args>,
    time: Res<Time>,
    mouse_button_input: Res<ButtonInput<MouseButton>>,
    cube_resources: ResMut<CubeResources>,
    mut counter: ResMut<BevyCounter>,
    mut rng: Local<Option<ChaCha8Rng>>,
    mut wave: Local<usize>,
) {
    if rng.is_none() {
        *rng = Some(ChaCha8Rng::seed_from_u64(42));
    }
    let rng = rng.as_mut().unwrap();

    if mouse_button_input.just_released(MouseButton::Left) {
        counter.color = Color::linear_rgb(rng.random(), rng.random(), rng.random());
    }

    if mouse_button_input.pressed(MouseButton::Left) {
        let spawn_count = (CUBES_PER_SECOND as f64 * time.delta_secs_f64()) as usize;
        spawn_cubes(
            &mut commands,
            args.into_inner(),
            &mut counter,
            spawn_count,
            cube_resources.into_inner(),
            None,
            *wave,
        );
        *wave += 1;
    }
}

examples/input/keyboard_input.rs (line 26)

fn keyboard_input_system(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    key_input: Res<ButtonInput<Key>>,
) {
    // KeyCode is used when you want the key location across different keyboard layouts
    // See https://w3c.github.io/uievents-code/#code-value-tables for the locations
    if keyboard_input.pressed(KeyCode::KeyA) {
        info!("'A' currently pressed");
    }

    if keyboard_input.just_pressed(KeyCode::KeyA) {
        info!("'A' just pressed");
    }
    if keyboard_input.just_released(KeyCode::KeyA) {
        info!("'A' just released");
    }

    // Key is used when you want a specific key, no matter where it is located.
    // This is useful for symbols that have a specific connotation, e.g. '?' for
    // a help menu or '+'/'-' for zoom
    let key = Key::Character("?".into());
    if key_input.pressed(key.clone()) {
        info!("'?' currently pressed");
    }
    if key_input.just_pressed(key.clone()) {
        info!("'?' just pressed");
    }
    if key_input.just_released(key) {
        info!("'?' just released");
    }
}

examples/dev_tools/fps_overlay.rs (line 100)

fn customize_config(input: Res<ButtonInput<KeyCode>>, mut overlay: ResMut<FpsOverlayConfig>) {
    if input.just_pressed(KeyCode::Digit1) {
        // Changing resource will affect overlay
        if overlay.text_color == OverlayColor::GREEN {
            overlay.text_color = OverlayColor::RED;
        } else {
            overlay.text_color = OverlayColor::GREEN;
        }
    }

    // The font size only adjustable when using `Px` units
    if let FontSize::Px(mut px_font_size) = overlay.text_config.font_size {
        if input.just_pressed(KeyCode::Digit2) {
            px_font_size = (px_font_size - 2.).max(2.);
        }
        if input.just_pressed(KeyCode::Digit3) {
            px_font_size += 2.;
        }
        if FontSize::Px(px_font_size) != overlay.text_config.font_size {
            overlay.text_config.font_size = FontSize::Px(px_font_size);
        }
    }

    if input.just_pressed(KeyCode::Digit4) {
        overlay.enabled = !overlay.enabled;
    }
    if input.just_released(KeyCode::Digit5) {
        overlay.frame_time_graph_config.enabled = !overlay.frame_time_graph_config.enabled;
    }
}

examples/stress_tests/bevymark.rs (line 343)

fn mouse_handler(
    mut commands: Commands,
    args: Res<Args>,
    time: Res<Time>,
    mouse_button_input: Res<ButtonInput<MouseButton>>,
    window: Query<&Window>,
    bird_resources: ResMut<BirdResources>,
    mut counter: ResMut<BevyCounter>,
    mut rng: Local<Option<ChaCha8Rng>>,
    mut wave: Local<usize>,
) {
    let Ok(window) = window.single() else {
        return;
    };

    if rng.is_none() {
        // We're seeding the PRNG here to make this example deterministic for testing purposes.
        // This isn't strictly required in practical use unless you need your app to be deterministic.
        *rng = Some(ChaCha8Rng::seed_from_u64(500));
    }
    let rng = rng.as_mut().unwrap();

    if mouse_button_input.just_released(MouseButton::Left) {
        counter.color = Color::linear_rgb(rng.random(), rng.random(), rng.random());
    }

    if mouse_button_input.pressed(MouseButton::Left) {
        let spawn_count = (BIRDS_PER_SECOND as f64 * time.delta_secs_f64()) as usize;
        spawn_birds(
            &mut commands,
            args.into_inner(),
            &window.resolution,
            &mut counter,
            spawn_count,
            bird_resources.into_inner(),
            None,
            *wave,
        );
        *wave += 1;
    }
}

pub fn any_just_released(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if any item in inputs has just been released.

Examples found in repository

examples/camera/pan_orbit_camera_custom_input_plugin.rs (line 97)

pub fn custom_camera_inputs(
    pointers: Query<(&PointerId, &PointerLocation)>,
    pointer_map: Res<CameraPointerMap>,
    mut controller: MessageWriter<PanOrbitCameraInputMessage>,
    mut mouse_wheel: MessageReader<MouseWheel>,
    mouse_input: Res<ButtonInput<MouseButton>>,
    cameras: Query<(Entity, &Camera, &RenderTarget, &PanOrbitCamera)>,
    primary_window: Query<Entity, With<PrimaryWindow>>,
) {
    let orbit_start = MouseButton::Right;
    let pan_start = MouseButton::Left;
    let zoom_stop = 0.0;

    if let Some(&camera) = pointer_map.get(&PointerId::Mouse) {
        let camera_query = cameras.get(camera).ok();
        let is_in_zoom_mode = camera_query
            .map(|(.., editor_cam)| editor_cam.current_motion.is_zooming_only())
            .unwrap_or_default();
        let zoom_amount_abs = camera_query
            .and_then(|(.., editor_cam)| {
                editor_cam
                    .current_motion
                    .inputs()
                    .map(|inputs| inputs.zoom_velocity_abs(editor_cam.smoothing.zoom.mul_f32(2.0)))
            })
            .unwrap_or(0.0);
        let should_zoom_end = is_in_zoom_mode && zoom_amount_abs <= zoom_stop;

        if mouse_input.any_just_released([orbit_start, pan_start]) || should_zoom_end {
            controller.write(PanOrbitCameraInputMessage::End { camera });
        }
    }

    for (&pointer, pointer_location) in pointers
        .iter()
        .filter_map(|(id, loc)| loc.location().map(|loc| (id, loc)))
    {
        match pointer {
            PointerId::Mouse => {
                let Some((camera, ..)) = cameras.iter().find(|(_, camera, render_target, _)| {
                    pointer_location.is_in_viewport(camera, render_target, &primary_window)
                }) else {
                    continue; // Pointer must be in viewport to start a motion.
                };

                if mouse_input.just_pressed(orbit_start) {
                    controller.write(PanOrbitCameraInputMessage::Start {
                        kind: MotionKind::OrbitZoom,
                        camera,
                        pointer,
                    });
                } else if mouse_input.just_pressed(pan_start) {
                    controller.write(PanOrbitCameraInputMessage::Start {
                        kind: MotionKind::PanZoom,
                        camera,
                        pointer,
                    });
                } else if mouse_wheel.read().map(|mw| mw.y.abs()).sum::<f32>() > 0.0 {
                    // Note we can't just check if the mouse wheel inputs are empty, we need to
                    // check if the y value abs greater than zero, otherwise we get a bunch of false
                    // positives, which can cause issues with figuring out what the user is trying
                    // to do.
                    controller.write(PanOrbitCameraInputMessage::Start {
                        kind: MotionKind::Zoom,
                        camera,
                        pointer,
                    });
                }
            }
            PointerId::Touch(_) | PointerId::Custom(_) => continue,
        }
    }

    // This must be cleared manually because reading these inputs is conditional - we are not
    // guaranteed to be flushing the events every frame.
    mouse_wheel.clear();
}

pub fn all_just_released(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if all items in inputs have just been released.

pub fn all_just_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool

Returns true if all items in inputs have been just pressed.

pub fn clear_just_released(&mut self, input: T) -> bool

Clears the just_released state of the input and returns true if the input has just been released.

Future calls to ButtonInput::just_released for the given input will return false until a new release event occurs.

pub fn reset(&mut self, input: T)

Clears the pressed, just_pressed and just_released data of the input.

pub fn reset_all(&mut self)

Clears the pressed, just_pressed, and just_released data for every input.

See also ButtonInput::clear for simulating elapsed time steps.

pub fn clear(&mut self)

Clears the just pressed and just released data for every input.

See also ButtonInput::reset_all for a full reset.

pub fn get_pressed(&self) -> impl ExactSizeIterator

An iterator visiting every pressed input in arbitrary order.

pub fn get_just_pressed(&self) -> impl ExactSizeIterator

An iterator visiting every just pressed input in arbitrary order.

Note: Returned elements do not imply information regarding the current state of ButtonInput::pressed or ButtonInput::just_released.

Examples found in repository

examples/ecs/component_hooks.rs (line 146)

fn trigger_hooks(
    mut commands: Commands,
    keys: Res<ButtonInput<KeyCode>>,
    index: Res<MyComponentIndex>,
) {
    for (key, entity) in index.iter() {
        if !keys.pressed(*key) {
            commands.entity(*entity).remove::<MyComponent>();
        }
    }
    for key in keys.get_just_pressed() {
        commands.spawn(MyComponent(*key));
    }
}

pub fn get_just_released(&self) -> impl ExactSizeIterator

An iterator visiting every just released input in arbitrary order.

Note: Returned elements do not imply information regarding the current state of ButtonInput::pressed or ButtonInput::just_pressed.

Trait Implementations

impl<T> Clone for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static,

fn clone(&self) -> ButtonInput<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Component for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static, ButtonInput<T>: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::SparseSet

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<ButtonInput<T>>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

const HAS_SUMMARY_TICK: bool = false

Set this constant to true if the component should track a summary tick.

impl<T> Debug for ButtonInput<T>

where T: Debug + Clone + Eq + Hash + Send + Sync + 'static,

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

Formats the value using the given formatter.

impl<T> Default for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static,

fn default() -> ButtonInput<T>

Returns the “default value” for a type.

impl<T> FromArg for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

type This<'from_arg> = ButtonInput<T>

The type to convert into.

fn from_arg( arg: Arg<'_>, ) -> Result<<ButtonInput<T> as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl<T> FromReflect for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<ButtonInput<T>>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl<T> GetOwnership for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn ownership() -> Ownership

Returns the ownership of Self.

impl<T> GetTypeRegistration for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl<T> IntoReturn for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_return<'into_return>(self) -> Return<'into_return>

where ButtonInput<T>: 'into_return,

Converts Self into a Return value.

impl<T> PartialReflect for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<ButtonInput<T>>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<ButtonInput<T>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<ButtonInput<T>>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Result<Box<dyn PartialReflect>, ReflectCloneError>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl<T> Reflect for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_any(self: Box<ButtonInput<T>>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<ButtonInput<T>>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl<T> Resource for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static, ButtonInput<T>: Send + Sync + 'static,

impl<T> Struct for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> Result<DynamicStruct, ReflectCloneError>

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl<T> TypePath for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl<T> Typed for ButtonInput<T>

where T: Clone + Eq + Hash + Send + Sync + 'static + TypePath, ButtonInput<T>: Any + Send + Sync, HashSet<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.