How to update the scale field of OrthographicProjection in Bevy 0.8?

[httc-jerry]

I'm new to Bevy and Rust.
I used to create a project with Bevy 0.6 and recently I'm gonna migrate it to Bevy 0.8.
In the past, I had the following code to spawn and update the scale field of OrthographicCameraBundle.

pub fn spawn(mut commands: Commands) {
    let mut camera = OrthographicCameraBundle::new_3d();
    camera.orthographic_projection.scale = 5.0;
    camera.transform = Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y);
    commands.spawn_bundle(camera);
}

pub fn zoom(
    mut mouse_wheel_reader: EventReader<MouseWheel>,
    mut query: Query<(&Camera, &mut OrthographicProjection), With<LookCamera>>,
) {
    for mouse_wheel in mouse_wheel_reader.iter() {
        let (_, mut projection) = query.single_mut();
        let zoom_scalar = 1.0 - constants::ZOOM_SENSITIVITY * mouse_wheel.y;
        let zoomed = projection.scale * zoom_scalar;
        projection.scale = zoomed.max(constants::ZOON_MIN).min(constants::ZOON_MAX);
    }
}

After updating Bevy to 0.8, there is no OrthographicCameraBundle, so I use Camera3dBundle instead:

pub fn spawn(mut commands: Commands) {
    commands
        .spawn_bundle(Camera3dBundle {
            projection: OrthographicProjection {
                scale: 5.0,
                scaling_mode: ScalingMode::FixedVertical(2.0),
                ..default()
            }
            .into(),
            transform: Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
            ..default()
        });
}

However, I found that I no longer can get the OrthographicProjection from the Query.

pub fn zoom(
    mut mouse_wheel_reader: EventReader<MouseWheel>,
    mut query: Query<(&Camera, &mut OrthographicProjection), With<LookCamera>>,
) {
    for mouse_wheel in mouse_wheel_reader.iter() {
        let (_, mut projection) = query.single_mut(); // The "projection" here never have value.
    }
}

I tried to modify the query from the above to this:

mut query: Query<&mut Projection, With<Camera>>

I can get the Projection properly now.
But I don't know how to cast the Projection to OrthographicProjection and update the scale field of it.
I've tried the following way but always get a syntax error:

pub fn zoom(
    mut mouse_wheel_reader: EventReader<MouseWheel>,
    mut query: Query<&mut Projection, With<Camera>>,
) {
    for mouse_wheel in mouse_wheel_reader.iter() {
        if let Ok(mut projection) = query.get_single_mut() {
            // Try to cast the variant
            if let Projection::Orthographic(orthographic) = projection {
              // ^ mismatched types
              // expected struct `bevy::prelude::Mut<'_, Projection, >`
              // found enum `Projection`
            }
        }
    }
}

Is there any correct and better way of doing this?

[MrGVSV]

In your code snippet, projection is actually a Mut<Projection>, so you need to dereference it:

if let Projection::Orthographic(orthographic) = *projection {
  // ...
}

Additionally, Camera3dBundle uses a default projection of Projection::Perspective, so you will either need to manually set the projection to orthographic or use Camera2dBundle instead.

[httc-jerry]

Thanks for your reply!
I spawn the Camera3dBundle and manually set the projection together:

pub fn spawn(mut commands: Commands) {
    commands
        .spawn_bundle(Camera3dBundle {
            // Set OrthographicProjection here
            projection: OrthographicProjection {
                scale: 5.0,
                scaling_mode: ScalingMode::FixedVertical(2.0),
                ..default()
            }
            .into(),
            transform: Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
            ..default()
        });
}

I also tried to deref it, but there is another error on *projection:

if let Projection::Orthographic(orthographic) = *projection {}
//                                                   ^ cannot move out of dereference of `bevy::prelude::Mut<'_, Projection>`

Here is my final solution, it works as expected, but the code looks pretty unintuitive and complicated than the Bevy 0.6 one:

pub fn zoom(
    mut mouse_wheel_reader: EventReader<MouseWheel>,
    mut query: Query<&mut Projection, With<Camera>>,
) {
    for mouse_wheel in mouse_wheel_reader.iter() {
        if let Ok(mut projection) = query.get_single_mut() {
            if let Projection::Orthographic(orthographic) = &*projection {
                //                                            ^ Added the "&*" solved the problem but looks unintuitive.
                let zoom_scalar = 1.0 - constants::ZOOM_SENSITIVITY * mouse_wheel.y;
                let zoomed = orthographic.scale * zoom_scalar;
                let scale = zoomed.max(constants::ZOON_MIN).min(constants::ZOON_MAX);
                *projection = Projection::Orthographic(OrthographicProjection {
                    scale,
                    scaling_mode: ScalingMode::FixedVertical(2.0),
                    ..default()
                });
                // ^ Previously, I can update the "scale" only, but now I need to assign a new OrthographicProjection.
            }
        }
    }
}

[MrGVSV]

Instead of &*projection try &mut *projection or possibly this:

if let Projection::Orthographic(ref mut orthographic) = *projection {
  // ...
}

That should allow you to update the scale directly.

[httc-jerry]

Thank you very much! It works perfectly!
I don't have much experience with programming languages that have pointers & mutable syntax.
This issue is a real headache for me.

Here is the final code:

pub fn zoom(
    mut mouse_wheel_reader: EventReader<MouseWheel>,
    mut query: Query<&mut Projection, With<Camera>>,
) {
    for mouse_wheel in mouse_wheel_reader.iter() {
        if let Ok(mut projection) = query.get_single_mut() {
            if let Projection::Orthographic(projection) = &mut *projection {
                let zoom_scalar = 1.0 - constants::ZOOM_SENSITIVITY * mouse_wheel.y;
                let zoomed = projection.scale * zoom_scalar;
                projection.scale = zoomed.max(constants::ZOON_MIN).min(constants::ZOON_MAX);
            }
        }
    }
}

This also works:

if let Projection::Orthographic(ref mut orthographic) = *projection