#[derive(Component)]
struct MyCameraMarker;

fn setup_camera(mut commands: Commands) {
    commands.spawn((
        Camera2dBundle {
            transform: Transform::from_xyz(100.0, 200.0, 0.0),
            ..default()
        },
        MyCameraMarker,
    ));
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, setup_camera)
        .run();
}

fn debug_projection(
    query_camera: Query<&OrthographicProjection, With<MyCameraMarker>>,
) {
    let projection = query_camera.single();
    // ... do something with the projection
}

commands.spawn((
    Camera2dBundle {
        projection: OrthographicProjection {
            // don't forget to set `near` and `far`
            // 别忘了设置`near`和`far`
            near: -1000.0,
            far: 1000.0,
            // ... any other settings you want to change ...
            / /……您还想更改其他设置吗?
            ..default()
        },
        ..default()
    },
    MyCameraMarker,
));

let mut camera_bundle = Camera2dBundle::default();
// change the settings we want to change:
// 更改我们想要更改的设置:
camera_bundle.projection.scale = 2.0;
camera_bundle.transform.rotate_z(30f32.to_radians());
// ...

commands.spawn((
    camera_bundle,
    MyCameraMarker,
));

use bevy::render::camera::ScalingMode;

let mut my_2d_camera_bundle = Camera2dBundle::default();
// For this example, let's make the screen/window height correspond to
// 在这个例子中，让我们将screen/window的高度设置为
// 1600.0 world units. The width will depend on the aspect ratio.
// 1600.0世界单位宽度取决于宽高比。
my_2d_camera_bundle.projection.scaling_mode = ScalingMode::FixedVertical(1600.0);
my_2d_camera_bundle.transform = Transform::from_xyz(100.0, 200.0, 0.0);

commands.spawn((
    my_2d_camera_bundle,
    MyCameraMarker,
));

fn zoom_scale(
    mut query_camera: Query<&mut OrthographicProjection, With<MyCameraMarker>>,
) {
    let mut projection = query_camera.single_mut();
    // zoom in     // 放大
    projection.scale /= 1.25;
    // zoom out     // 缩小
    projection.scale *= 1.25;
}

fn zoom_scalingmode(
    mut query_camera: Query<&mut OrthographicProjection, With<MyCameraMarker>>,
) {
    use bevy::render::camera::ScalingMode;

    let mut projection = query_camera.single_mut();
    // 4 screen pixels to world/game pixel
    // 4个屏幕像素对应世界/游戏像素
    projection.scaling_mode = ScalingMode::WindowSize(4.0);
    // 6 screen pixels to world/game pixel
    // 6个屏幕像素对应世界/游戏像素
    projection.scaling_mode = ScalingMode::WindowSize(6.0);
}

fn main() {
    App::new()
        .add_plugins(
            DefaultPlugins
                .set(ImagePlugin::default_nearest())
        )
        // ...
        .run();
}

fn debug_projection(
    query_camera: Query<&Projection, With<MyCameraMarker>>,
) {
    let projection = query_camera.single();
    match projection {
        Projection::Perspective(persp) => {
            // we have a perspective projection
            // 我们有了一个透视投影
        }
        Projection::Orthographic(ortho) => {
            // we have an orthographic projection
            // 我们有一个正投影
        }
    }
}

commands.spawn((
    Camera3dBundle {
        projection: PerspectiveProjection {
            // We must specify the FOV in radians.
            // 我们必须以弧度指定FOV
            // Rust can convert degrees to radians for us.
            // Rust可以将度数转换为弧度
            fov: 60.0_f32.to_radians(),
            ..default()
        }.into(),
        transform: Transform::from_xyz(10.0, 12.0, 16.0)
            .looking_at(Vec3::ZERO, Vec3::Y),
        ..default()
    },
    MyCameraMarker,
));

​

fn zoom_perspective(
    mut query_camera: Query<&mut Projection, With<MyCameraMarker>>,
) {
    // assume perspective. do nothing if orthographic.
    // 假设透视图如果正字法，什么都不做。
    let Projection::Perspective(persp) = query_camera.single_mut().into_inner() else {
        return;
    };
    // zoom in // 放大
    persp.fov /= 1.25;
    // zoom out  // 缩小
    persp.fov *= 1.25;
}

​

​

use bevy::render::camera::ScalingMode;

commands.spawn((
    Camera3dBundle {
        projection: OrthographicProjection {
            // For this example, let's make the screen/window height
            // 在这个例子中，让我们设定屏幕/窗口的高度
            // correspond to 16.0 world units.
            // 对应16.0个世界单位
            scaling_mode: ScalingMode::FixedVertical(16.0),
            ..default()
        }.into(),
        // the distance doesn't really matter for orthographic,
        // 对于正字法来说，距离并不重要，
        // it should look the same (though it might affect
        // 它看起来应该是一样的(尽管它可能会影响
        // shadows and clipping / culling)
        // 阴影和裁剪/剔除)
        transform: Transform::from_xyz(10.0, 12.0, 16.0)
            .looking_at(Vec3::ZERO, Vec3::Y),
        ..default()
    },
    MyCameraMarker,
));

​

fn zoom_orthographic(
    mut query_camera: Query<&mut Projection, With<MyCameraMarker>>,
) {
    // assume orthographic. do nothing if perspective.
    // 假设正字法。什么都不做，如果透视。
    let Projection::Orthographic(ortho) = query_camera.single_mut().into_inner() else {
        return;
    };
    // zoom in  // 放大
    ortho.scale /= 1.25;
    // zoom out  // 缩小
    ortho.scale *= 1.25;
}

​

Keyboard - Unofficial Bevy Cheat Book

fn keyboard_input(
    keys: Res<Input<KeyCode>>,
) {
    if keys.just_pressed(KeyCode::Space) {
        // Space was pressed
        // 空格被按下
    }
    if keys.just_released(KeyCode::LControl) {
        // Left Ctrl was released
        // 左侧Ctrl被释放
    }
    if keys.pressed(KeyCode::W) {
        // W is being held down
        // W被按住
    }
    // we can check multiple at once with `.any_*`
    if keys.any_pressed([KeyCode::LShift, KeyCode::RShift]) {
        // Either the left or right shift are being held down
        //要么是左移，要么是右移
    }
    if keys.any_just_pressed([KeyCode::Delete, KeyCode::Back]) {
        // Either delete or backspace was just pressed
        // 只是按下了delete或backspace
    }
}

fn keyboard_events(
    mut key_evr: EventReader<KeyboardInput>,
) {
    use bevy::input::ButtonState;

    for ev in key_evr.iter() {
        match ev.state {
            ButtonState::Pressed => {
                println!("Key press: {:?} ({})", ev.key_code, ev.scan_code);
            }
            ButtonState::Released => {
                println!("Key release: {:?} ({})", ev.key_code, ev.scan_code);
            }
        }
    }
}

fn mouse_button_input(
    buttons: Res<Input<MouseButton>>,
) {
    if buttons.just_pressed(MouseButton::Left) {
        // Left button was pressed
        // 左键被按下
    }
    if buttons.just_released(MouseButton::Left) {
        // Left Button was released
        // 左键被释放
    }
    if buttons.pressed(MouseButton::Right) {
        // Right Button is being held down
        // 右键被持续按下
    }
    // we can check multiple at once with `.any_*`
    // 我们可以一次检查多个 `.any_*`
    if buttons.any_just_pressed([MouseButton::Left, MouseButton::Right]) {
        // Either the left or the right button was just pressed
        // 左键或右键刚被按下
    }
}

fn mouse_button_iter(
    buttons: Res<Input<MouseButton>>,
) {
    for button in buttons.get_pressed() {
        println!("{:?} is currently held down", button);
    }
    for button in buttons.get_just_pressed() {
        println!("{:?} was pressed", button);
    }
    for button in buttons.get_just_released() {
        println!("{:?} was released", button);
    }
}

use bevy::input::mouse::MouseButtonInput;

fn mouse_button_events(
    mut mousebtn_evr: EventReader<MouseButtonInput>,
) {
    use bevy::input::ButtonState;

    for ev in mousebtn_evr.iter() {
        match ev.state {
            ButtonState::Pressed => {
                println!("Mouse button press: {:?}", ev.button);
            }
            ButtonState::Released => {
                println!("Mouse button release: {:?}", ev.button);
            }
        }
    }
}

use bevy::input::common_conditions::*;

app.add_systems(Update, (
    handle_middleclick
        .run_if(input_just_pressed(MouseButton::Middle)),
    handle_drag
        .run_if(input_pressed(MouseButton::Left)),
));

use bevy::input::mouse::MouseWheel;

fn scroll_events(
    mut scroll_evr: EventReader<MouseWheel>,
) {
    use bevy::input::mouse::MouseScrollUnit;
    for ev in scroll_evr.iter() {
        match ev.unit {
            MouseScrollUnit::Line => {
                println!("Scroll (line units): vertical: {}, horizontal: {}", ev.y, ev.x);
                //  println!("滚轮滚动（线单位）：垂直：{}, 水平：{}", ev.y, ev.x);
            }
            MouseScrollUnit::Pixel => {
                println!("Scroll (pixel units): vertical: {}, horizontal: {}", ev.y, ev.x);
                //  println!("滚轮滚动（像素单位）：垂直：{}, 水平：{}", ev.y, ev.x);
            }
        }
    }
}

use bevy::input::mouse::MouseMotion;

fn mouse_motion(
    mut motion_evr: EventReader<MouseMotion>,
) {
    for ev in motion_evr.iter() {
        println!("Mouse moved: X: {} px, Y: {} px", ev.delta.x, ev.delta.y);
        //  println!("鼠标移动：X: {} px, Y: {} px", ev.delta.x, ev.delta.y);
    }
}

use bevy::window::PrimaryWindow;

fn cursor_position(
    q_windows: Query<&Window, With<PrimaryWindow>>,
) {
    // Games typically only have one window (the primary window)
    // 游戏通常只有一个窗口（主窗口）
    if let Some(position) = q_windows.single().cursor_position() {
        println!("Cursor is inside the primary window, at {:?}", position);
        //  println!("光标位于主窗口内，在{:?}", position);
    } else {
        println!("Cursor is not in the game window.");
        // println!("光标不在游戏窗口内。");
    }
}

fn cursor_events(
    mut cursor_evr: EventReader<CursorMoved>,
) {
    for ev in cursor_evr.iter() {
        println!(
            "New cursor position: X: {}, Y: {}, in Window ID: {:?}",
            //  "新的光标位置：X: {}, Y: {}, 在窗口ID: {:?}",
            ev.position.x, ev.position.y, ev.window
        );
    }
}

use bevy::input::touchpad::{TouchpadMagnify, TouchpadRotate};

// these only work on macOS
// 这些只在macOS上工作
fn touchpad_gestures(
    mut evr_touchpad_magnify: EventReader<TouchpadMagnify>,
    mut evr_touchpad_rotate: EventReader<TouchpadRotate>,
) {
    for ev_magnify in evr_touchpad_magnify.iter() {
        // Positive numbers are zooming in   // 正数表示放大
        // Negative numbers are zooming out  // 负数表示缩小
        println!("Touchpad zoom by {}", ev_magnify.0);
    }
    for ev_rotate in evr_touchpad_rotate.iter() {
        // Positive numbers are anticlockwise  // 正数表示逆时针
        // Negative numbers are clockwise      // 负数表示顺时针
        println!("Touchpad rotate by {}", ev_rotate.0);
    }
}

Text / Character - Unofficial Bevy Cheat Book

非官方 Bevy 作弊书

9.3 文本/字符输入

相关官方示例： char_input_events、 text_input。

如果您想在 Bevy 应用程序中实现文本输入，请使用此功能（而不是 键盘输入）。这样，一切都会按照用户期望的操作系统运行，包括 Unicode 支持。

Bevy 将为来自操作系统的每个 Unicode 代码点生成一个ReceivedCharacter 事件。

此示例演示如何让用户将文本输入到字符串中（此处存储为本地资源）。

fn text_input(
    mut evr_char: EventReader<ReceivedCharacter>,
    kbd: Res<Input<KeyCode>>,
    mut string: Local<String>,
) {
    if kbd.just_pressed(KeyCode::Return) {
        println!("Text input: {}", &*string);
        string.clear();
    }
    if kbd.just_pressed(KeyCode::Back) {
        string.pop();
    }
    for ev in evr_char.iter() {
        // ignore control (special) characters
        // 忽略控制（特殊）字符
        if !ev.char.is_control() {
            string.push(ev.char);
        }
    }
}

注意：我们使用 Bevy 的常规键盘输入来处理 Enter 和 Backspace 键的按下。当按下这些键时也会发送字符事件（它们会产生特殊的控制字符，如 ASCII 换行符\n），因此，如果我们不希望将它们保存到字符串中，则需要忽略它们。

在您自己的应用程序中，您可能还希望以适合您的 UI 的方式处理箭头键等操作。

输入法支持

Bevy 支持 IME（输入法编辑器），这是人们在具有更复杂文字的语言（如东亚语言）中执行文本输入的方式。但是，它需要您进行一些特殊处理。

IME 通过使用特殊的“缓冲区”来工作，它显示当前正在进行的文本建议，并允许用户在确认之前选择正确的字符。文本建议/自动完成由操作系统提供，但您的应用程序需要向用户显示它们。

如果您希望所有国际用户都能够用他们的语言输入文本（就像他们在操作系统上的其他 GUI 应用程序中通常所做的那样），您应该支持 IME。

为此，每当您希望用户输入文本时，您都需要在窗口上启用“IME 模式”，然后再将其禁用。例如，如果您在玩游戏之前提示用户输入姓名，则您可以在提示处于活动状态时启用 IME 模式。

启用“IME 模式”后，如果用户使用 IME，您将收到 Ime事件，而不是ReceivedCharacter 常规键盘输入。但是，如果用户没有使用 IME，那么即使启用了“IME 模式”，一切也会正常运行。

当用户有正在进行的文本时，您将收到Ime::Preedit事件，告诉您“临时缓冲区”的当前内容以及需要显示的有关光标/突出显示的信息，以便用户可以看到他们正在做什么。

当用户确认他们的输入时，您将收到一个Ime::Commit事件，告诉您用户希望插入到应用程序中的文本。

// for this simple example, we will just enable/disable IME mode on mouse click
// 对于这个简单的例子，我们只需要在鼠标点击时启用/禁用IME模式
fn ime_toggle(
    mousebtn: Res<Input<MouseButton>>,
    mut q_window: Query<&mut Window, With<PrimaryWindow>>,
) {
    if mousebtn.just_pressed(MouseButton::Left) {
        let mut window = q_window.single_mut();

        // toggle "IME mode"
        // 切换"IME模式"
        window.ime_enabled = !window.ime_enabled;

        // We need to tell the OS the on-screen coordinates where the text will
        // 我们需要告诉OS文本在屏幕上的坐标
        // be displayed; for this simple example, let's just use the mouse cursor.
        // 显示;在这个简单的例子中，我们只使用鼠标光标。
        // In a real app, this might be the position of a UI text field, etc.
        // 在实际应用中，这可能是UI文本框的位置等
        window.ime_position = window.cursor_position().unwrap();
    }
}

fn ime_input(
    mut evr_ime: EventReader<Ime>,
) {
    for ev in evr_ime.iter() {
        match ev {
            Ime::Commit { value, .. } => {
                println!("IME confirmed text: {}", value);
                // println!("IME确认文本: {}", value);
            }
            Ime::Preedit { value, cursor, .. } => {
                println!("IME buffer: {:?}, cursor: {:?}", value, cursor);
                // println!("IME缓冲区: {:?}, 光标: {:?}", value, cursor);
            }
            Ime::Enabled { .. } => {
                println!("IME mode enabled!");
                // println!("输入法模式启用！");
            }
            Ime::Disabled { .. } => {
                println!("IME mode disabled!");
                // println!("输入法模式禁用！");
            }
        }
    }
}

为了简洁起见，此示例仅将事件打印到控制台。

在真实的应用程序中，您需要在屏幕上显示“预编辑”文本，并使用不同的格式来显示光标。在“提交”时，您可以将提供的文本附加到您通常接受文本输入的实际字符串中。

非官方 Bevy 作弊书

9.4 游戏手柄（控制器、操纵杆）

相关官方示例： gamepad_input、 gamepad_input_events。

Bevy 支持游戏手柄输入硬件：控制台控制器、操纵杆等。许多不同类型的硬件都应该可以工作，但如果您的设备不受支持，您应该向 gilrs项目提交问题。

游戏手柄 ID

Bevy为每个连接的游戏手柄分配一个唯一的 ID ( Gamepad)。这使您可以将设备与特定玩家关联起来，并区分您的输入来自哪一个。

您可以使用该Gamepads 资源列出当前连接的所有游戏手柄设备的 ID，或检查特定设备的状态。

要检测游戏手柄何时连接或断开连接，您可以使用 GamepadEvent events。

显示如何记住第一个连接的游戏手柄 ID 的示例：

/// Simple resource to store the ID of the connected gamepad.
/// 存储连接手柄ID的简单资源。
/// We need to know which gamepad to use for player input.
/// 我们需要知道使用哪个手柄进行玩家输入。
#[derive(Resource)]
struct MyGamepad(Gamepad);

fn gamepad_connections(
    mut commands: Commands,
    my_gamepad: Option<Res<MyGamepad>>,
    mut gamepad_evr: EventReader<GamepadEvent>,
) {
    for ev in gamepad_evr.iter() {
        // the ID of the gamepad
        // 手柄的ID
        let id = ev.gamepad;
        match &ev.event_type {
            GamepadEventType::Connected(info) => {
                println!("New gamepad connected with ID: {:?}, name: {}", id, info.name);

                // if we don't have any gamepad yet, use this one
                // 如果我们还没有任何手柄，请使用这个
                if my_gamepad.is_none() {
                    commands.insert_resource(MyGamepad(id));
                }
            }
            GamepadEventType::Disconnected => {
                println!("Lost gamepad connection with ID: {:?}", id);

                // if it's the one we previously associated with the player,
                // 如果它是我们之前与玩家关联的那个元素，
                // disassociate it:
                // 解除关联:
                if let Some(MyGamepad(old_id)) = my_gamepad.as_deref() {
                    if *old_id == id {
                        commands.remove_resource::<MyGamepad>();
                    }
                }
            }
            // other events are irrelevant
            // 其他事件不相关
            _ => {}
        }
    }
}

处理游戏手柄输入

 您可以使用Axis<GamepadAxis>(Axis, GamepadAxis).来处理模拟摇杆和触发器。按钮可以用 Input<GamepadButton> (Input, GamepadButton)，类似于鼠标按钮或键盘按键。

请注意， GamepadButton 中按钮的名称与供应商无关（例如South和 East，而不是 X/O 或 A/B）。

fn gamepad_input(
    axes: Res<Axis<GamepadAxis>>,
    buttons: Res<Input<GamepadButton>>,
    my_gamepad: Option<Res<MyGamepad>>,
) {
    let gamepad = if let Some(gp) = my_gamepad {
        // a gamepad is connected, we have the id
        // 手柄已连接，我们有id
        gp.0
    } else {
        // no gamepad is connected
        // 没有连接手柄
        return;
    };

    // The joysticks are represented using a separate axis for X and Y
    // 操纵杆使用单独的X轴和Y轴表示
    let axis_lx = GamepadAxis {
        gamepad, axis_type: GamepadAxisType::LeftStickX
    };
    let axis_ly = GamepadAxis {
        gamepad, axis_type: GamepadAxisType::LeftStickY
    };

    if let (Some(x), Some(y)) = (axes.get(axis_lx), axes.get(axis_ly)) {
        // combine X and Y into one vector
        // 将X和Y合并为一个向量
        let left_stick_pos = Vec2::new(x, y);

        // Example: check if the stick is pushed up
        // 例子:检查操纵杆是否向上推
        if left_stick_pos.length() > 0.9 && left_stick_pos.y > 0.5 {
            // do something
        }
    }

    // In a real game, the buttons would be configurable, but here we hardcode them
    // 在真实的游戏中，按钮是可配置的，但在这里我们对它们进行了硬编码
    let jump_button = GamepadButton {
        gamepad, button_type: GamepadButtonType::South
    };
    let heal_button = GamepadButton {
        gamepad, button_type: GamepadButtonType::East
    };

    if buttons.just_pressed(jump_button) {
        // button just pressed: make the player jump
        // 刚刚按下的按钮:让玩家跳跃
    }

    if buttons.pressed(heal_button) {
        // button being held down: heal the player
        // 按下按钮:治愈玩家
    }
}

您还可以使用 GamepadEvent 事件处理游戏手柄输入：

fn gamepad_input_events(
    my_gamepad: Option<Res<MyGamepad>>,
    mut gamepad_evr: EventReader<GamepadEvent>,
) {
    let gamepad = if let Some(gp) = my_gamepad {
        // a gamepad is connected, we have the id
        // 手柄已连接，我们有id
        gp.0
    } else {
        // no gamepad is connected
        // 没有连接手柄
        return;
    };

    for ev in gamepad_evr.iter() {
        if ev.gamepad != gamepad {
            // event not from our gamepad
            // 事件不是来自我们的手柄
            continue;
        }

        use GamepadEventType::{AxisChanged, ButtonChanged};

        match ev.event_type {
            AxisChanged(GamepadAxisType::RightStickX, x) => {
                // Right Stick moved (X)
                // 右摇杆移动(X)
            }
            AxisChanged(GamepadAxisType::RightStickY, y) => {
                // Right Stick moved (Y)
                // 右摇杆被移动(Y)
            }
            ButtonChanged(GamepadButtonType::DPadDown, val) => {
                // buttons are also reported as analog, so use a threshold
                // 按钮也是模拟按钮，所以请使用阈值
                if val > 0.5 {
                    // button pressed
                    // 按下按钮
                }
            }
            _ => {} // don't care about other inputs
                    // 不用关心其他输入
        }
    }
}

游戏手柄设置

您可以使用 GamepadSettings  资源 来配置各个轴和按钮的死区和其他参数。您可以设置全局默认值，也可以单独设置每个轴/按钮。

下面是一个示例，展示了如何使用自定义设置来配置游戏手柄（不一定是好的设置，请不要盲目复制这些）：

// this should be run once, when the game is starting
// 这应该在游戏开始时运行一次
// (transition entering your in-game state might be a good place to put it)
// (过渡状态可能是放置它的好地方)
fn configure_gamepads(
    my_gamepad: Option<Res<MyGamepad>>,
    mut settings: ResMut<GamepadSettings>,
) {
    let gamepad = if let Some(gp) = my_gamepad {
        // a gamepad is connected, we have the id
        // 手柄已连接，我们有id
        gp.0
    } else {
        // no gamepad is connected
        // 没有连接手柄
        return;
    };

    // add a larger default dead-zone to all axes (ignore small inputs, round to zero)
    // 为所有轴添加一个更大的默认死区(忽略小的输入，四舍五入为零)
    settings.default_axis_settings.set_deadzone_lowerbound(-0.1);
    settings.default_axis_settings.set_deadzone_upperbound(0.1);

    // make the right stick "binary", squash higher values to 1.0 and lower values to 0.0
    // 将右边的值设置为二进制，将较大的值压缩为1.0，较小的值压缩为0.0
    let mut right_stick_settings = AxisSettings::default();
    right_stick_settings.set_deadzone_lowerbound(-0.5);
    right_stick_settings.set_deadzone_upperbound(0.5);
    right_stick_settings.set_livezone_lowerbound(-0.5);
    right_stick_settings.set_livezone_upperbound(0.5);
    // the raw value should change by at least this much,
    // 原始值至少应该改变这么多，
    // for Bevy to register an input event:
    // 让Bevy注册输入事件:
    right_stick_settings.set_threshold(0.01);

    // make the triggers work in big/coarse steps, to get fewer events
    // 让触发器按大/粗的步骤工作，以获得更少的事件
    // reduces noise and precision
    // 降低噪声和精度
    let mut trigger_settings = AxisSettings::default();
    trigger_settings.set_threshold(0.25);

    // set these settings for the gamepad we use for our player
    // 为我们用于玩家的手柄设置这些设置
    settings.axis_settings.insert(
        GamepadAxis { gamepad, axis_type: GamepadAxisType::RightStickX },
        right_stick_settings.clone()
    );
    settings.axis_settings.insert(
        GamepadAxis { gamepad, axis_type: GamepadAxisType::RightStickY },
        right_stick_settings.clone()
    );
    settings.axis_settings.insert(
        GamepadAxis { gamepad, axis_type: GamepadAxisType::LeftZ },
        trigger_settings.clone()
    );
    settings.axis_settings.insert(
        GamepadAxis { gamepad, axis_type: GamepadAxisType::RightZ },
        trigger_settings.clone()
    );

    // for buttons (or axes treated as buttons):
    // 对于按钮(或者作为按钮的轴):
    let mut button_settings = ButtonSettings::default();
    // require them to be pressed almost all the way, to count
    // 几乎在整个过程中都需要按下它们来计数
    button_settings.set_press_threshold(0.9);
    // require them to be released almost all the way, to count
    // 几乎所有的过程中都需要释放它们
    button_settings.set_release_threshold(0.1);

    settings.default_button_settings = button_settings;
}