I'm on windows, and when minimising the game window while the rts camera is active, the game panics, complaining of a call to Result::unwrap on an Err:

Hi again! I'm trying to implement custom controls for my camera and for that I need to know where the camera is pointing at on the ground. My understanding was that the focus or target_focus contain this information, but when reading those properties I'm getting a point high above the ground (large y coordinate), even if I manually set the target focus to be at y = 0.0. It also changes when zoom is changed. I think it basically contains the current camera height. Is this intentional? Could you please advise how to get the coordinates on the ground?

My naive way of doing that is as follows, but it doesn't account for any ground topology.

let ground_focus = camera.focus.translation.xz().extend(0.0).xzy();

Setting the window grab mode to Confined a la

    app.add_plugins(DefaultPlugins.set(WindowPlugin {
        primary_window: Some(Window {
            cursor: Cursor {
                grab_mode: bevy::window::CursorGrabMode::Confined,
                ..default()
            },
            ..default()
        }),
        ..default()
    }));

storing it somewhere to be used during restoration instead of None should fix it

Hello!

Love the crate so far.

I was curious if there was a way to adjust the zoom increments? I can't seem to find any settings that do this.

Sometimes you might want to reset the camera smoothing (e.g. either when you add the RTS camera to your app or to position it manually via code), but there doesn't seem to be a way to do that right now.

Commenting out the following line fixes the first issue though:

The second issue is fixed by my recent PR.

Another question. I hope I don't bother you too much.

In my app I'm importing a "map" from a GLTF asset exported from Blender. It has multiple objects (trees, rocks, etc.) and one that should serve as the ground. It is named "Ground" so I can access it by name in my program. I tried the following:

    let scene = scenes_assets.get_mut(scene_handle.clone()).unwrap();

    let ground = scene
        .world
        .query::<(Entity, &Name)>()
        .iter(&scene.world)
        .filter_map(|(entity, name)| {
            if name.as_str() == "Ground" {
                Some(entity)
            } else {
                None
            }
        })
        .collect_vec();

    for entity in ground {
        scene
            .world
            .entity_mut(entity)
            .insert(Ground)
            .insert(Name::new("Ground"));
    }

This causes a runtime error:

thread 'main' panicked at /home/tad/.cargo/registry/src/index.crates.io-6f17d22bba15001f/bevy_scene-0.13.2/src/scene_spawner.rs:431:35:
scene contains the unregistered type `bevy_rts_camera::Ground`. consider reflecting it with `#[derive(Reflect)]` and registering the type using `app.register_type::<T>()`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Encountered a panic in exclusive system `bevy_scene::scene_spawner::scene_spawner_system`!
Encountered a panic in system `bevy_app::main_schedule::Main::run_main`!

It's a bit strange, since I can add the Ground component to entities spawned in the "main" world (with commands.spawn). It makes me think that I'm doing something wrong. Following the advice from the error message (to derive Reflect on Ground) seems impossible since they are both external to my crate, but I did call app.register_type::<Ground>(), alas with no effect. Any advice?

For reference, here is the code in my program where I want this to work: https://gitlab.com/otterhide/otterhide/-/blob/5ca98f1103d4836f86a3200fe28a28c1fa3fb1cb/src/ground.rs#L86-160

The problem

I'll explain what I want to do:
When focusing on the game's UI, the camera shouldn't react to the player's input. For example, if there's a side panel that the player must click, the camera shouldn't move when approaching the window edge. If there's a list to scroll through, the camera shouldn't zoom when the mouse is over that list.

Possible solution

Provide a resource, for example

#[derive(Resource, Default)]
pub struct SkipMovement;

That you can add when you need to keep the camera still, and then in src/controller.rs

impl Plugin for RtsCameraControlsPlugin {
    fn build(&self, app: &mut App) {
        app.add_plugins(DefaultRaycastingPlugin).add_systems(
            Update,
            (zoom, pan, grab_pan, rotate)
                .run_if(not(resource_exists::<SkipMovement>()))
                .before(RtsCameraSystemSet),
        );
    }
}

That way, while the resource exists, the camera won't react to the player's input, and you can remove the resource when defocusing the UI.

Out of the box, middle mouse click works great when your mouse is connected. When on the laptop trackpad only I don’t think panning has an equivalent action.

It would be cool if you could shift and move two fingers to pan. I think this is what blender does, but any action common to RTS games on laptops would work.