Thanks for the great crate. I am currently facing an issue while trying to inspect rapier2D-specific components such as RigidBodyPosition or ColliderType. The message Inspectable has not been defined for this component is shown, even though:

• I am compiling with the rapier2d feature set:

bevy-inspector-egui = { version="0.6.1", features=["rapier2d"]}

• I am using the WorldInspectorPlugin

app.add_plugin(WorldInspectorPlugin::new());

Is there anything I am missing in order to get this going?

Hi!

I wanted to suggest adding an immutable variant of Inspectable trait, which would allow only viewing values (or probably just another trait function).

There are some resources, particular components or their fields in my game, that I would like to be able to view, but prohibit myself from editing. Is it something that you could consider supporting?

Btw, this is a really awesome crate, thanks for developing it. :)

Issue

I have a type Spawner which derives Reflect. But when used as a field in a component, the world inspector complains it's not registered:

I even tried to explicitly register the Option<T> itself, without much luck:

app.register_type::<ParticleEffect>();
app.register_type::<Spawner>();
app.register_type::<Option<Spawner>>();

Context

The component ParticleEffect is defined here:

https://github.com/djeedai/bevy_hanabi/blob/451bd340333c2b02c4bf4b073a09834d4f242654/src/lib.rs#L237-L256

And the Spawner is here:

https://github.com/djeedai/bevy_hanabi/blob/451bd340333c2b02c4bf4b073a09834d4f242654/src/spawn.rs#L69-L99

Registration happens here in case that's relevant (the committed version doesn't contain the local changes mentioned above):

https://github.com/djeedai/bevy_hanabi/blob/451bd340333c2b02c4bf4b073a09834d4f242654/src/plugin.rs#L71-L72

Repro

git clone https://github.com/djeedai/bevy_hanabi.git
cd bevy_hanabi
cargo r --example gradient --no-default-features --features="bevy/bevy_winit bevy/bevy_pbr bevy/png 3d"

Expand the "effect" entity, it contains a ParticleEffect component with a spawner: Option<Spawner> field.

Hi! I have a player component with a direction and is_moving properties:

#[derive(Component)]
pub struct Player {
    direction: Direction,
    is_moving: bool,
}

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

But when trying to use the inspector I can't watch to player direction or is_moving propertires. What should I do?

Would it be reasonable to have Inspectable implemented for HashMaps where the key and value are both inspectable, similar to how it's done for Vec and Tuples?

How would I disable the yellow highlighting on some components? It appears this is a change detection indicator but it results in a lot of flashing components in my game.

bevy_dock just released a new version with egui = "0.20.0" and inspector became incompatible with it :disappointed:. This PR is simple cargo upgrade on the rework branch.

Is there a way to access InspectorWindows and say control when a window is open, currently forking and making it public, and adding want I need. Am I missing something?

Still new to bevy and egui, and first time using bevy-inspector-egui. Really a pleasure to use though =-)

Trying to run any of the examples gives me a linking error:

error: linking with `cc` failed: exit status: 1
...
 = note: /usr/bin/ld: cannot find -lxcb-render
          /usr/bin/ld: cannot find -lxcb-shape
          /usr/bin/ld: cannot find -lxcb-xfixes
          collect2: error: ld returned 1 exit status

I'm running on Ubuntu 20.04.2 LTS Rust version stable-x86_64-unknown-linux-gnu - rustc 1.54.0

Thanks in advance for your help.

This doesn't appear to be possible currently. Code similar to:

#[derive(Inspectable)]
enum GameState { Menu, InGame }

#[derive(Inspectable)]
struct Root {
    game_state: ResourceInspector<State<GameState>>,
}

makes rustc complain about State not implementing Inspectable. If adding such impl doesn't work, introducing a dedicated StateInspector could work equally well.

(Bonus point for support iyes_loopless states, too ;-) )

It seems like the integration needs to be updated for rapier 0.13. Also, how are you supposed to run the example? The crate was commented out of the cargo workspace.

For example:

#[derive(Reflect, InspectorOptions]
struct MyAbility {
    #[inspector(min = 0, max = 10)]
    max_charges: u8,
    #[inspector(min = 0, max = self.max_charges)]
    current_charges: u8,
}

In the previous version this worked fine.

For InNewWindow<T> struct fields, the corresponding WindowAttributes declare an inner_attributes value that can be set to the attributes of T. However, there is no example for doing this when deriving Inspectable through the proc-macro (#[derive(Inspectable)]) which is an issue because it doesn't follow the conventional syntax.

Typically (c.f. popular crates like serde), when #[foo] attributes support nested values, they do so using a function-like syntax, e.g.:

#[serde(rename(serialize = "ser_name"))]

One would expect #[inspectable] to do likewise:

    #[inspectable(
        label = "Player",
        title = "Player", title_bar, resizable, scrollable,
        inner_attributes(despawnable = false),
    )]
    player: InNewWindow<InspectorQuerySingle<Entity, With<Player>>>,

Unfortunately, that's not supported. I did some digging into the proc-macro code for the attribute and found that the way to make it work is to explicitly create the value for inner_attributes and assign to it:

#[inspectable(/* ... */ inner_attributes = EntityAttributes{despawnable: false})]

This is quite unusual; normally, users don't have to explicitly provide values of the crate's own types when using a #[derive] macro.

I'd suggest providing an example of this atypical use of inner_attributes. or changing it to follow de-facto conventions of the Rust ecosystem.

Is there a way we can force it to not have such narrow text areas? At the moment it seems to wrap at a line length of 7 chars or so.

egui_ctx.ctx_mut().set_style(egui::Style {
        wrap:Some(false),
        spacing: Spacing {
            text_edit_width: 1000.,
            ..default()
        },
        ..default()
    });

I tried the above but it seemed to make no effect. Other things are wider so it could use up more space if it wanted to but it chooses not to. Being able to set min / max text width as an attribute would be good.