bevy_minibuffer_inspector 0.4.0

A minibuffer integration of bevy-inspector-egui
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
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

use crate::{utils::pretty_type_name, InspectorPlugins, Inspectors};
use bevy_app::{PluginGroup, PluginGroupBuilder};
use bevy_ecs::{
    prelude::{On, Res, ResMut, Resource},
    schedule::SystemCondition,
};
use bevy_inspector_egui::quick::ResourceInspectorPlugin;
use bevy_minibuffer::{prelude::*, prompt::PromptState};
use bevy_reflect::Reflect;
use bevy_state::prelude::in_state;

/// ## Adds the 'inspect_resource' act
///
/// This act toggles the visibility of resource inspectors that were added.
///
/// ## Usage
///
/// ```no_run
/// use bevy::prelude::*;
/// use bevy_minibuffer::prelude::*;
/// use bevy_minibuffer_inspector as inspector;
/// #[derive(Resource, Reflect)]
/// struct R1;
/// #[derive(Resource, Reflect)]
/// struct R2;
/// fn plugin(app: &mut App) {
///     app
///         .add_plugins(MinibufferPlugins)
///         .add_acts((
///             BasicActs::default(),
///             inspector::ResourceActs::default()
///                 .add::<R1>()
///                 .add::<R2>()
///         ));
/// }
/// ```
pub struct ResourceActs {
    plugins: InspectorPlugins<Self>,
    acts: Acts,
}

impl ActsPluginGroup for ResourceActs {
    fn acts(&self) -> &Acts {
        &self.acts
    }

    fn acts_mut(&mut self) -> &mut Acts {
        &mut self.acts
    }
}

impl ResourceActs {
    /// Add a resource to the list of resources when prompted.
    pub fn add<R: Resource + Reflect>(mut self) -> Self {
        self.plugins.add_inspector(
            pretty_type_name::<R>(),
            Self::resource_inspector_plugin::<R>,
        );
        self
    }

    fn resource_inspector_plugin<R: Resource + Reflect>(
        index: usize,
        inspector_plugins: &mut InspectorPlugins<Self>,
    ) {
        inspector_plugins.add_plugin(
            ResourceInspectorPlugin::<R>::default().run_if(
                in_state(PromptState::Visible).and(InspectorPlugins::<Self>::visible(index)),
            ),
        );
    }
}

impl Default for ResourceActs {
    fn default() -> Self {
        Self {
            plugins: InspectorPlugins::default(),
            acts: Acts::new([Act::new(inspect_resource)]),
        }
    }
}

fn inspect_resource(resources: Res<Inspectors<ResourceActs>>, mut minibuffer: Minibuffer) {
    if !resources.visible.is_empty() {
        minibuffer
            .prompt_map("resource: ", resources.names.clone())
            .observe(
                |mut trigger: On<Completed<usize>>,
                 mut minibuffer: Minibuffer,
                 mut resources: ResMut<Inspectors<ResourceActs>>| {
                    match trigger.event_mut().state.take_result().unwrap() {
                        Ok(index) => {
                            resources.visible[index] = !resources.visible[index];
                            minibuffer.clear();
                        }
                        Err(e) => {
                            minibuffer.message(format!("{e}"));
                        }
                    }
                },
            );
    } else {
        minibuffer.message("No resource inspectors available.");
    }
}

impl PluginGroup for ResourceActs {
    fn build(self) -> PluginGroupBuilder {
        self.warn_on_unused_acts();
        self.plugins
            .warn_on_empty("No resources registered with `ResourceActs`; consider adding some.");
        self.plugins.build()
    }
}