bevy_dev 0.7.0

Dev tools for Bevy Engine
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use bevy::{
    prelude::*,
    window::{CursorGrabMode, PrimaryWindow},
};

#[cfg(feature = "ui")]
use super::ui::PreviewCamera;
#[cfg(feature = "ui")]
use crate::ui::popup::{PopupEvent, PopupPosition};

use super::{
    DebugCamera, DebugCameraActive, DebugCameraData, DebugCameraGlobalData,
    DebugCameraLastUsedOriginCameraData,
};

#[allow(clippy::type_complexity)]
pub(super) fn run_if_changed(cameras: Query<(), Changed<DebugCamera>>) -> bool {
    !cameras.is_empty()
}

#[allow(clippy::type_complexity)]
pub(super) fn system(
    mut commands: Commands,
    #[cfg(not(feature = "ui"))] mut cameras: Query<(
        Entity,
        &mut Camera,
        Option<&mut DebugCamera>,
        Option<&DebugCameraData>,
    )>,
    #[cfg(feature = "ui")] mut cameras: Query<
        (
            Entity,
            &mut Camera,
            Option<&mut DebugCamera>,
            Option<&DebugCameraData>,
        ),
        Without<PreviewCamera>,
    >,
    mut global: ResMut<DebugCameraGlobalData>,
    mut window: Query<&mut Window, With<PrimaryWindow>>,
    #[cfg(feature = "ui")] mut popup_event: EventWriter<PopupEvent>,
) {
    let mut is_any_debug_camera_active = false;
    for (entity, mut camera, mut debug_camera, data) in cameras
        .iter_mut()
        .filter(|x| x.2.is_some() && x.3.is_some())
        .map(|x| (x.0, x.1, x.2.unwrap(), x.3.unwrap()))
    {
        let mut commands = commands.get_entity(entity).unwrap();
        if debug_camera.is_changed() && debug_camera.focus {
            commands.insert(DebugCameraActive);
            is_any_debug_camera_active = true;

            // Skip if camera is already active
            if camera.is_active {
                continue;
            }

            // Active debug camera
            camera.is_active = true;

            // Set last used debug camera
            for (i, e) in global.last_used_debug_cameras.iter().enumerate() {
                if *e == entity {
                    global.last_used_debug_cameras.remove(i);
                    break;
                }
            }
            global.last_used_debug_cameras.push(entity);

            // Notify user
            let id = data.id;

            bevy::log::info!("Switched to debug camera #{}", id);
            #[cfg(feature = "ui")]
            popup_event.write(PopupEvent::new(
                PopupPosition::BelowCenter,
                1.0,
                move |ui| {
                    ui.strong(format!("Switched to debug camera #{id}"));
                },
            ));

            continue;
        } else if debug_camera.focus {
            commands.remove::<DebugCameraActive>();

            // Deactive debug camera
            debug_camera.bypass_change_detection().focus = false;
        }

        camera.is_active = false;
    }

    if is_any_debug_camera_active {
        let Ok(mut primary_window) = window.single_mut() else {
            error!("Expected primary window to exist");
            return;
        };

        // Deactive game camera
        for (entity, mut camera, _, _) in cameras
            .iter_mut()
            .filter(|x| x.2.is_none() && x.1.is_active)
        {
            global.last_used_origin_camera = Some(DebugCameraLastUsedOriginCameraData {
                camera: entity,
                cursor: primary_window.cursor_options.clone(),
            });

            camera.is_active = false;
        }

        // Lock cursor
        primary_window.cursor_options.grab_mode = CursorGrabMode::Locked;
        primary_window.cursor_options.visible = false;
    } else {
        // Switch to game camera if no debug camera is active
        if let Some(last) = global.last_used_origin_camera.take() {
            // Activate previous game camera
            if let Ok(mut camera) = cameras.get_mut(last.camera) {
                camera.1.is_active = true;
            }

            // Set cursor
            let Ok(mut primary_window) = window.single_mut() else {
                error!("Expected primary window to exist");
                return;
            };
            primary_window.cursor_options = last.cursor;

            // Notify user
            bevy::log::info!("Switched to game camera");
            #[cfg(feature = "ui")]
            popup_event.write(PopupEvent::new(
                PopupPosition::BelowCenter,
                1.0,
                move |ui| {
                    ui.strong("Switched to game camera");
                },
            ));
        }
    }
}