Enum CurrentMotion 

pub enum CurrentMotion {
    Stationary,
    Momentum {
        velocity: Velocity,
        momentum_start: Instant,
    },
    UserControlled {
        anchor: DVec3,
        motion_inputs: MotionInputs,
    },
}

Available on crate features bevy_camera_controller and pan_orbit_camera only.

The current motion state of the camera.

Variants

Stationary

The camera is not moving.

Momentum

The camera is in motion, but not being directly controlled by the user. This happens while the camera has momentum.

Fields

velocity: Velocity

Contains inherited velocity, if any. This will decay based on momentum settings.

momentum_start: Instant

Used to compute how long the camera has been in the momentum state. Useful for debouncing user inputs.

UserControlled

The camera is being directly controlled by the user.

Fields

anchor: DVec3

The point the camera is rotating about, zooming into, or panning with, in view space (relative to the camera).

• Rotation: the direction of the anchor does not change, it is fixed in screenspace.
• Panning: the depth of the anchor does not change, the camera only moves in x and y.
• Zoom: the direction of the anchor does not change, but the length does.

motion_inputs: MotionInputs

Pan and orbit are mutually exclusive, however both can be used with zoom.

Implementations

impl CurrentMotion

pub fn is_moving(&self) -> bool

Returns true if the camera is moving due to inputs or momentum.

pub fn is_user_controlled(&self) -> bool

Returns true if the camera is moving due to user inputs.

pub fn inputs(&self) -> Option<&MotionInputs>

Get the user motion inputs if they exist.

Examples found in repository

examples/camera/pan_orbit_camera_custom_input_plugin.rs (line 91)

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 is_orbiting(&self) -> bool

Returns true if the camera is user controlled and orbiting.

pub fn is_panning(&self) -> bool

Returns true if the camera is user controlled and panning.

pub fn is_zooming_only(&self) -> bool

Returns true if the camera is user controlled and only zooming.

Examples found in repository

examples/camera/pan_orbit_camera_custom_input_plugin.rs (line 85)

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 momentum_duration(&self) -> Option<Duration>

How long has the camera been moving with momentum, without user input? This is equivalent to the amount of time since the last input event ended.

Trait Implementations

impl Clone for CurrentMotion

fn clone(&self) -> CurrentMotion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CurrentMotion

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

Formats the value using the given formatter.

impl Default for CurrentMotion

fn default() -> CurrentMotion

Returns the “default value” for a type.