This PR mostly deals with breaking changes from migrating to bevy version 0.6, as per the Bevy migration guide.

Some callouts:

• Used StorageType::SparseSet for FlyCam, since I expect it to only exist approximately for one entity.
• Added [[example]] sections to the repository config.

Looking up and down (pitch) is a bit slower than left and right (yaw), which feels weird in my experience. It a lot slower the more wide the window (maybe too slow if fullscreen on a 21:9).

I think this is caused by multiplying the sensitivity and delta by the window.height() or * window.width(). After removing this multiplication, I get a consistent sensitivity in all directions. May I ask why this is being done?

Fixes #19

What is the problem?

When closing a Bevy app, the window may be closed but the application is still running. Some bevy_flycam systems try to access the window, and in the process unwrap an Option<&mut Window>. If that Option is None, the application crashes.

What is the solution?

This PR changes those unwrap()s to matching patterns. Now, when a window isn't found, a warning is given instead.

What is the alternative?

This is still proper error handling, but gives unnecessary warnings when closing. There may be a way to use run criteria to stop the systems when AppExit events are sent, but I was unable to get this to work (presumably because of event delays). ~~It would probably be better if Bevy provided an AppState resource from which the global state of the application could be checked and then use that for a run criteria.~~ (Now that I think about it, explicit system ordering may be the solution)

Something like this (I've already got it to work locally): Its using 'static lifetime elision, so that we don't need to store anything in the heap. Changes to lib.rs:

pub struct KeyMap { 
    pub forward: &'static[KeyCode],
    pub backward: &'static[KeyCode],
    pub left: &'static[KeyCode],
    pub right: &'static[KeyCode],
    pub up: &'static[KeyCode],
    pub down: &'static[KeyCode],
}

impl Default for KeyMap {
    fn default() -> Self {
        Self {
            forward: &[KeyCode::W],
            backward: &[KeyCode::S],
            left: &[KeyCode::A],
            right: &[KeyCode::D],
            up: &[KeyCode::Space],
            down: &[KeyCode::LShift],
        }
    }
}

/// Mouse sensitivity and movement speed
pub struct MovementSettings {
    pub sensitivity: f32,
    pub speed: f32,
    pub map: KeyMap,
}

impl Default for MovementSettings {
    fn default() -> Self {
        Self {
            sensitivity: 0.00012,
            speed: 12.,
            map: KeyMap::default()
        }
    }
}

fn validate_key(codes:&'static[KeyCode], key: &KeyCode) -> bool {
    codes.iter().any(|m| m == key)
}

fn player_move(
    keys: Res<Input<KeyCode>>,
    time: Res<Time>,
    windows: Res<Windows>,
    settings: Res<MovementSettings>,
    mut query: Query<(&FlyCam, &mut Transform)>,
) {
    let window = windows.get_primary().unwrap();
    for (_camera, mut transform) in query.iter_mut() {
        let mut velocity = Vec3::ZERO;
        let local_z = transform.local_z();
        let forward = -Vec3::new(local_z.x, 0., local_z.z);
        let right = Vec3::new(local_z.z, 0., -local_z.x);

        for key in keys.get_pressed() {
            if window.cursor_locked() {
				//----- Changes here ------\\
                if validate_key(settings.map.forward,  key) {velocity += forward }
                if validate_key(settings.map.backward, key) {velocity -= forward }
                if validate_key(settings.map.left,     key) {velocity -= right   }
                if validate_key(settings.map.right,    key) {velocity += right   }
                if validate_key(settings.map.up,       key) {velocity += unit_y()}
                if validate_key(settings.map.down,     key) {velocity -= unit_y()}            
            }
        }

        velocity = velocity.normalize();

        if !velocity.is_nan() {
            transform.translation += velocity * time.delta_seconds() * settings.speed
        }
    }
}

Usage (or using default)

.insert_resource(MovementSettings {
    sensitivity: 0.00015, // default: 0.00012
    speed: 12.0, // default: 12.0
    map: KeyMap {
        forward: &[KeyCode::Up, KeyCode::W],
        ..Default::default()
    }
})

The question is: Does it add unnecessary complexity that takes away the simplicity of the library for the benefit of the user? On one hand, it's an opt-in feature and not a breaking feature if you are only using defaults. On the other hand, you still have breaking changes for any have something custom using the lib.

Following queries can be simplified using With filter, since FlyCam is just a marker component.

https://github.com/sburris0/bevy_flycam/blob/100a15d412b2419e463dc73fd0de50ef4b31b97b/src/lib.rs#L59-L62

https://github.com/sburris0/bevy_flycam/blob/100a15d412b2419e463dc73fd0de50ef4b31b97b/src/lib.rs#L94-L97

     mut query: Query<&mut Transform, With<FlyCam>>,
 ) { 
     let window = windows.get_primary().unwrap(); 
     for mut transform in query.iter_mut() { 

Hello again 👋

Figured out how bevy's camera and its camera projection works. So now I was able to implement the zoom functionality correctly so that it works now, yay. 🎉

Don't merge quite yet, I want to hear your opinion. Also, for some reason changing the FOV (the scroll.rs) of the camera doesn't work even though it does change, maybe the fov is only read on initialization?

Thank you for your work on this crate! I found a typo while trying out the example provided in the README.md. let me know if you have any feedback or additional thoughts.

Working on the Bevy 0.8 release of bevy_atmosphere (link to current commit tree). I noticed that when I run my example (cargo run --example cycle --feature dynamic) and close the window, it actually crashes. I get the following error log:

2022-08-03T00:13:27.505579Z  INFO bevy_winit: Skipped event for closed window: WindowId(00000000-0000-0000-0000-000000000000)
2022-08-03T00:13:27.506219Z  INFO bevy_winit: Skipped event for closed window: WindowId(00000000-0000-0000-0000-000000000000)
2022-08-03T00:13:27.509384Z  INFO bevy_winit: Skipped event for closed window: WindowId(00000000-0000-0000-0000-000000000000)
thread 'Compute Task Pool (1)' panicked at 'called `Option::unwrap()` on a `None` value', C:\Users\jonah\.cargo\registry\src\github.com-1ecc6299db9ec823\bevy_flycam-0.8.0\src\lib.rs:118:44
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread 'main' panicked at 'task has failed', C:\Users\jonah\.cargo\registry\src\github.com-1ecc6299db9ec823\async-task-4.3.0\src\task.rs:426:45

The error comes from the following code:

fn cursor_grab(keys: Res<Input<KeyCode>>, mut windows: ResMut<Windows>) {
    let window = windows.get_primary_mut().unwrap();
    if keys.just_pressed(KeyCode::Escape) {
        toggle_grab_cursor(window);
    }
}

I believe changing this to something like the following will fix this:

fn cursor_grab(keys: Res<Input<KeyCode>>, mut windows: ResMut<Windows>) {
    if let Some(window) = windows.get_primary_mut() {
        if keys.just_pressed(KeyCode::Escape) {
            toggle_grab_cursor(window);
        }
    }
}

I can fork and create a PR later, just figured it would be good to make an issue first.

Updated to bevy 0.7.0, which has now been released

• Simplified query as raised in #14 by @tguichaoua, thanks! 🚀
• Updated documentation and added a support section to show how bevy_flycam versions relate to which bevy version

Previously used render feature is a group that contains unneeded stuff, like bevy_ui or bevy_text. Specified features in this PR is the required minimum. You can read more about in in this issue: https://github.com/bevyengine/bevy/issues/4202

wayland and x11 features doesn't affect on anything on platforms other then Linux. x11 feature is even enabled by default in Bevy.

Since the update to bevy 0.9 and the according flycam version 0.9 the cursor grabbing doesn't work anymore. Instead the following error will get logged:

ERROR bevy_winit: Unable to un/grab cursor: the requested operation is not supported by Winit

The cursor is invisible while inside the window but as soon as the cursor leaves the window it appears again. According to https://github.com/bevyengine/bevy/issues/6590 it seems to be that the current mode Confined is only supported by Windows and not macOS, while Locked is only supported by macOS and not Windows.

Fixes issue with first mouse movement resetting the camera rotation. Query the yaw and pitch from the camera before updating the rotation.

This helps with issue #17.

It would be nice, if the initial position and orientation could be set by the user. May be the MovementSettings could become CameraSettings? (And thank you for the crate, it gave me a fast help)

According to the bevy-cheatbook,

• The X axis goes from left to right (+X points right).
• The Y axis goes from bottom to top (+Y points up).
• The Z axis goes from far to near (+Z points towards you, out of the screen).

I noticed, however, while using the flycam that the A & D keys slide the camera on the local X axis, W & D on the Z axis, and Shift & Space on the Y axis. Because of this, I ended up modeling my world in XZY space, which caused problems later down the line for me. Shouldn't Z be treated as the "up and down" axis, rather than Y, for the sake of consistency?