use bevy::{app::MainScheduleOrder, ecs::schedule::*, prelude::*};
#[derive(Debug, Hash, PartialEq, Eq, Clone, ScheduleLabel)]
struct DebugSchedule;
#[derive(Default)]
pub struct SteppingPlugin {
schedule_labels: Vec<InternedScheduleLabel>,
top: Val,
left: Val,
}
impl SteppingPlugin {
pub fn add_schedule(mut self, label: impl ScheduleLabel) -> SteppingPlugin {
self.schedule_labels.push(label.intern());
self
}
pub fn at(self, left: Val, top: Val) -> SteppingPlugin {
SteppingPlugin { top, left, ..self }
}
}
impl Plugin for SteppingPlugin {
fn build(&self, app: &mut App) {
app.init_schedule(DebugSchedule);
let mut order = app.world.resource_mut::<MainScheduleOrder>();
order.insert_after(Update, DebugSchedule);
let mut stepping = Stepping::new();
for label in &self.schedule_labels {
stepping.add_schedule(*label);
}
app.insert_resource(stepping);
app.insert_resource(State {
ui_top: self.top,
ui_left: self.left,
systems: Vec::new(),
})
.add_systems(Startup, build_help)
.add_systems(
DebugSchedule,
(
build_ui.run_if(not(initialized)),
handle_input,
update_ui.run_if(initialized),
)
.chain(),
);
}
}
#[derive(Resource, Debug)]
struct State {
systems: Vec<(InternedScheduleLabel, NodeId, usize)>,
ui_top: Val,
ui_left: Val,
}
fn initialized(state: Res<State>) -> bool {
!state.systems.is_empty()
}
const FONT_SIZE: f32 = 20.0;
const FONT_COLOR: Color = Color::rgb(0.2, 0.2, 0.2);
const FONT_BOLD: &str = "fonts/FiraSans-Bold.ttf";
const FONT_MEDIUM: &str = "fonts/FiraMono-Medium.ttf";
#[derive(Component)]
struct SteppingUi;
fn build_ui(
mut commands: Commands,
asset_server: Res<AssetServer>,
schedules: Res<Schedules>,
mut stepping: ResMut<Stepping>,
mut state: ResMut<State>,
) {
let mut text_sections = Vec::new();
let mut always_run = Vec::new();
let Ok(schedule_order) = stepping.schedules() else {
return;
};
for label in schedule_order {
let schedule = schedules.get(*label).unwrap();
text_sections.push(TextSection::new(
format!("{:?}\n", label),
TextStyle {
font: asset_server.load(FONT_BOLD),
font_size: FONT_SIZE,
color: FONT_COLOR,
},
));
let Ok(systems) = schedule.systems() else {
return;
};
for (node_id, system) in systems {
if system.name().starts_with("bevy") {
always_run.push((*label, node_id));
continue;
}
state.systems.push((*label, node_id, text_sections.len()));
text_sections.push(TextSection::new(
" ",
TextStyle {
font: asset_server.load(FONT_MEDIUM),
font_size: FONT_SIZE,
color: FONT_COLOR,
},
));
text_sections.push(TextSection::new(
format!("{}\n", system.name()),
TextStyle {
font: asset_server.load(FONT_MEDIUM),
font_size: FONT_SIZE,
color: FONT_COLOR,
},
));
}
}
for (label, node) in always_run.drain(..) {
stepping.always_run_node(label, node);
}
commands.spawn((
SteppingUi,
TextBundle {
text: Text::from_sections(text_sections),
style: Style {
position_type: PositionType::Absolute,
top: state.ui_top,
left: state.ui_left,
padding: UiRect::all(Val::Px(10.0)),
..default()
},
background_color: BackgroundColor(Color::rgba(1.0, 1.0, 1.0, 0.33)),
visibility: Visibility::Hidden,
..default()
},
));
}
fn build_help(mut commands: Commands, asset_server: Res<AssetServer>) {
commands.spawn((TextBundle::from_sections([TextSection::new(
"Press ` to toggle stepping mode (S: step system, Space: step frame)",
TextStyle {
font: asset_server.load(FONT_MEDIUM),
font_size: 18.0,
color: FONT_COLOR,
},
)])
.with_style(Style {
position_type: PositionType::Absolute,
bottom: Val::Px(5.0),
left: Val::Px(5.0),
..default()
}),));
}
fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut stepping: ResMut<Stepping>) {
if keyboard_input.just_pressed(KeyCode::Slash) {
info!("{:#?}", stepping);
}
if keyboard_input.just_pressed(KeyCode::Backquote) {
if stepping.is_enabled() {
stepping.disable();
debug!("disabled stepping");
} else {
stepping.enable();
debug!("enabled stepping");
}
}
if !stepping.is_enabled() {
return;
}
if keyboard_input.just_pressed(KeyCode::Space) {
debug!("continue");
stepping.continue_frame();
} else if keyboard_input.just_pressed(KeyCode::KeyS) {
debug!("stepping frame");
stepping.step_frame();
}
}
fn update_ui(
mut commands: Commands,
state: Res<State>,
stepping: Res<Stepping>,
mut ui: Query<(Entity, &mut Text, &Visibility), With<SteppingUi>>,
) {
if ui.is_empty() {
return;
}
let (ui, mut text, vis) = ui.single_mut();
match (vis, stepping.is_enabled()) {
(Visibility::Hidden, true) => {
commands.entity(ui).insert(Visibility::Inherited);
}
(Visibility::Hidden, false) | (_, true) => (),
(_, false) => {
commands.entity(ui).insert(Visibility::Hidden);
}
}
if !stepping.is_enabled() {
return;
}
let (cursor_schedule, cursor_system) = match stepping.cursor() {
None => return,
Some(c) => c,
};
for (schedule, system, text_index) in &state.systems {
let mark = if &cursor_schedule == schedule && *system == cursor_system {
"-> "
} else {
" "
};
text.sections[*text_index].value = mark.to_string();
}
}