aalo 0.3.0

aka bevy-inspector-haalka, a bevy_ui-native inspector for Bevy
Documentation 
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

//! register custom frontends for any type

mod utils;
use utils::*;

use aalo::prelude::*;
use bevy::{
    ecs::{lifecycle::HookContext, world::DeferredWorld},
    prelude::*,
};

fn main() {
    register_frontend("bool", custom_bool_frontend);
    register_frontend("custom::CustomBoolComponent", custom_bool_frontend);
    let mut app = App::new();
    app.add_plugins(DefaultPlugins.set(example_window_plugin()))
        .add_plugins(
            AaloPlugin::new()
                .world()
                .with_inspector(|inspector| inspector.jump_to(("entity", "custom bool field", "boolcomponent", ".0"))),
        )
        .add_systems(Startup, setup)
        .register_type::<BoolComponent>()
        .register_type::<CustomBoolComponent>();
    #[cfg(feature = "debug")]
    app.add_plugins(haalka::utils::DebugUiPlugin);
    app.run();
}

#[derive(Component, Reflect, Default)]
struct BoolComponent(bool);

#[derive(Component, Reflect, Default)]
struct CustomBoolComponent(bool);

fn init_custom_bool_frontend(mut world: DeferredWorld, HookContext { entity, .. }: HookContext) {
    let mut commands = world.commands();
    let text = commands.spawn_empty().id();
    let system = commands.register_system(
        move |In(reflect): In<Box<dyn PartialReflect>>, mut commands: Commands| {
            let cur_option = reflect
                .try_downcast_ref::<bool>()
                .copied()
                .or_else(|| CustomBoolComponent::from_reflect(reflect.as_ref()).map(|CustomBoolComponent(cur)| cur));
            if let Some(cur) = cur_option {
                commands.entity(text).insert(Text(cur.to_string()));
            }
        },
    );
    commands
        .entity(entity)
        .add_child(text)
        .insert(FieldListener::new(system))
        .observe(
            move |click: On<Pointer<Click>>, texts: Query<&Text>, mut field: TargetField| {
                if let Ok(Text(text)) = texts.get(text) {
                    let cur = match text.as_str() {
                        "true" => true,
                        "false" => false,
                        _ => return,
                    };
                    // one of these will silently error depending on if it's the field or component
                    // target, we just do both here for the convenience of using the same frontend
                    field.update(click.entity, (!cur).to_dynamic());
                    field.update(click.entity, CustomBoolComponent(!cur).to_dynamic());
                }
            },
        );
}

#[derive(Component)]
#[require(Node)]
#[component(on_add = init_custom_bool_frontend)]
struct CustomBoolFrontend;

fn custom_bool_frontend() -> impl Bundle {
    CustomBoolFrontend
}

fn setup(mut commands: Commands) {
    commands.spawn((Name::new("custom bool field"), BoolComponent::default()));
    commands.spawn((Name::new("custom bool component"), CustomBoolComponent::default()));
    commands.spawn((Camera2d, IsDefaultUiCamera));
}