### Setup with WorldInspectorPlugin

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/README.md

Demonstrates the basic setup for using bevy-inspector-egui with the `WorldInspectorPlugin` for automatic world inspection. Requires registering types with `InspectorOptions`.

```rust
use bevy::prelude::*;
use bevy_inspector_egui::prelude::*;
use bevy_inspector_egui::quick::WorldInspectorPlugin;

#[derive(Reflect, Resource, Default, InspectorOptions)]
#[reflect(Resource, InspectorOptions)]
struct GameConfig {
    #[inspector(min = 0.0, max = 1.0)]
    volume: f32,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(EguiPlugin::default())
        
        // Register type with options
        .init_resource::<GameConfig>()
        .register_type::<GameConfig>()
        
        // Add quick plugin (auto-adds DefaultInspectorConfigPlugin)
        .add_plugins(WorldInspectorPlugin::new())
        
        .run();
}
```

--------------------------------

### Minimal Configuration Setup

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Set up bevy-inspector-egui with minimal configuration, including only the 'documentation' feature and disabling default features.

```toml
[dependencies.bevy-inspector-egui]
default-features = false
features = ["documentation"]

```

--------------------------------

### Full Bevy Inspector Egui Initialization

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/core-plugin.md

This snippet shows the complete setup for Bevy Inspector Egui, including core Bevy plugins, Egui integration, inspector setup, type registration, and basic game systems. Ensure all necessary plugins and types are registered for a functional inspector.

```rust
use bevy::prelude::*;
use bevy_egui::EguiPlugin;
use bevy_inspector_egui::quick::WorldInspectorPlugin;
use bevy_inspector_egui::prelude::*;

#[derive(Reflect, Resource, Default, InspectorOptions)]
#[reflect(Resource, InspectorOptions)]
struct GameSettings {
    #[inspector(min = 0.0, max = 1.0)]
    volume: f32,
}

fn main() {
    App::new()
        // Step 1: Core Bevy
        .add_plugins(DefaultPlugins)
        
        // Step 2: Egui integration
        .add_plugins(EguiPlugin::default())
        
        // Step 3: Inspector setup
        .add_plugins(WorldInspectorPlugin::new())
        // ^ This adds DefaultInspectorConfigPlugin automatically
        
        // Step 4: Type registration
        .init_resource::<GameSettings>()
        .register_type::<GameSettings>()
        
        // Step 5: Game systems
        .add_systems(Startup, setup)
        .add_systems(Update, game_logic)
        
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn(Camera2d::default());
}

fn game_logic(settings: Res<GameSettings>) {
    println!("Volume: {}", settings.volume);
}
```

--------------------------------

### Minimal Bevy Inspector Egui Setup

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/core-plugin.md

Use this minimal setup to quickly add the inspector to your Bevy application. It includes the essential plugins for Bevy, Egui, and the World Inspector.

```rust
App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(EguiPlugin::default())
    .add_plugins(WorldInspectorPlugin::new())
    .run();
```

--------------------------------

### 2D-Only Setup with Documentation

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Configure bevy-inspector-egui for 2D-only inspection, including the 'documentation' feature and disabling default features.

```toml
[dependencies.bevy-inspector-egui]
default-features = false
features = ["2d", "documentation"]

```

--------------------------------

### NumberOptions::with_speed() Example

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-options.md

Demonstrates how to customize the drag sensitivity of a numeric input using the `with_speed` method, applied to a slider in this example.

```rust
let opts = NumberOptions::between(0.0, 100.0)
    .with_speed(0.5);
// Slider with custom drag speed
```

--------------------------------

### Filter Usage Example

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/types.md

Shows how to create and use a Filter to display entities in the inspector, with an example of filtering by name using fuzzy matching.

```rust
use bevy_inspector_egui::bevy_inspector::Filter;

let filter = Filter::from_ui_fuzzy(ui, egui::Id::new("filter"));
// Filter by name: entities match if name contains "Player" (fuzzy)
bevy_inspector::ui_for_entities_filtered(world, ui, true, &filter);
```

--------------------------------

### 3D and Gizmos Setup with Documentation

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Configure bevy-inspector-egui for 3D inspection with gizmos enabled, including the 'documentation' feature and disabling default features.

```toml
[dependencies.bevy-inspector-egui]
default-features = false
features = ["3d", "bevy_gizmos", "documentation"]

```

--------------------------------

### NumberOptions::between() Example

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-options.md

Demonstrates how to use the `between` method to create NumberOptions that render as a slider within a specified range.

```rust
use bevy_inspector_egui::inspector_options::std_options::NumberOptions;

let opts = NumberOptions::between(0.0, 1.0);
// Renders as a slider from 0 to 1
```

--------------------------------

### Example: Inspecting a Custom Resource

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/quick-plugins.md

Demonstrates how to use ResourceInspectorPlugin to display a custom resource 'MyConfig' in an egui window. It includes setting up the Bevy app, initializing the resource, registering its type, and adding the plugin.

```rust
use bevy::prelude::*;
use bevy_inspector_egui::prelude::*;
use bevy_inspector_egui::quick::ResourceInspectorPlugin;

#[derive(Reflect, Resource, Default, InspectorOptions)]
#[reflect(Resource, InspectorOptions)]
struct MyConfig {
    name: String,
    #[inspector(min = 0.0, max = 1.0)]
    volume: f32,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .init_resource::<MyConfig>()
        .register_type::<MyConfig>()
        .add_plugins(ResourceInspectorPlugin::<MyConfig>::default())
        .run();
}
```

--------------------------------

### Manual UI Setup with Bevy Inspector Egui

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/README.md

This snippet shows how to set up a Bevy application to use bevy-inspector-egui for manual UI creation. It includes adding necessary plugins and defining a system to render the inspector UI.

```rust
use bevy::prelude::*;
use bevy_egui::EguiPlugin;
use bevy_inspector_egui::prelude::*;
use std::any::TypeId;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(EguiPlugin::default())
        .add_plugins(bevy_inspector_egui::DefaultInspectorConfigPlugin) // adds default options and `InspectorEguiImpl`s
        .add_systems(EguiPrimaryContextPass, inspector_ui)
        .run();
}

fn inspector_ui(world: &mut World) {
    let Ok(egui_context) = world
        .query_filtered::<&mut EguiContext, With<PrimaryEguiContext>>()
        .get_single(world)
    else {
        return;
    };
    let mut egui_context = egui_context.clone();

    egui::Window::new("UI").show(egui_context.get_mut(), |ui| {
        egui::ScrollArea::vertical().show(ui, |ui| {
            // equivalent to `WorldInspectorPlugin`
            bevy_inspector_egui::bevy_inspector::ui_for_world(world, ui);

            egui::CollapsingHeader::new("Materials").show(ui, |ui| {
                bevy_inspector_egui::bevy_inspector::ui_for_assets::<StandardMaterial>(world, ui);
            });

            ui.heading("Entities");
            bevy_inspector_egui::bevy_inspector::ui_for_world_entities(world, ui);
        });
    });
}
```

--------------------------------

### RangeOptions Usage Example

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/types.md

Demonstrates applying RangeOptions to a Range field to set custom minimum and maximum bounds for the slider.

```rust
use bevy_inspector_egui::prelude::*;

#[derive(Reflect, InspectorOptions)]
struct Spawner {
    #[inspector(start(min = 1.0), end(max = 10.0))]
    spawn_delay: std::ops::Range<f32>,
}
```

--------------------------------

### Minimal Plugin Setup

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/INDEX.md

Use this snippet for the simplest integration of the inspector plugin into your Bevy application. It requires adding `WorldInspectorPlugin::new()` to your app's plugins.

```rust
App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(WorldInspectorPlugin::new())
    .run();
```

--------------------------------

### Complex InspectorOptions Example

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Demonstrates various inspector attributes for numeric fields like min, max, speed, prefix, and suffix.

```rust
use bevy::prelude::*
use bevy_inspector_egui::prelude::*

#[derive(Reflect, InspectorOptions)]
struct GameConfig {
    #[inspector(min = 0.0, max = 1.0)]
    volume: f32,

    #[inspector(min = 10, max = 1000, suffix = "ms")]
    frame_time_limit: u32,

    #[inspector(min = 0.1, speed = 0.1)]
    physics_timestep: f64,

    #[inspector(prefix = "$", min = 0, max = 10000)]
    player_health: i32,
}
```

--------------------------------

### Inspecting Bevy Values with Options

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/docs/MIGRATION_GUIDE_0.15_0.16.md

This example demonstrates how to use `InspectorUi::for_bevy` to create an inspection environment with custom context and options, suitable for Bevy applications. It shows how to pass specific options like `NumberOptions::positive()` and handle potential stateful types.

```rust
let world: &mut World;

let context = Context {
    // can also be None or Context::default()
    world: Some(world.into()),
};
// InspectorUi::new_no_short_circuit can be used if you don't need to be able to resolve bevy_asset handles.
let env = InspectorUi::for_bevy(type_registry, context);

let changed = env.ui_for_reflect_with_options(
    &mut value,
    ui,
    // some types like `Quat`s may store state. If you have display multiple values next to each other, make sure to pass different IDs. Otherwise you can use `egui::Id::null()`.
    egui::Id::new("ui"),
    // whatever options you want to pass. Look at the `inspector_options` docs for more info.
    &NumberOptions::positive(),
);
```

--------------------------------

### Configure ResourceInspectorPlugin

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Use ResourceInspectorPlugin<T> to inspect a specific Bevy resource. This example shows how to inspect a custom GameSettings resource and toggle its visibility with a key press.

```rust
use bevy::prelude::*
use bevy_inspector_egui::quick::ResourceInspectorPlugin;

#[derive(Reflect, Resource, Default)]
struct GameSettings {
    volume: f32,
    difficulty: u32,
}

App::new()
    .init_resource::<GameSettings>()
    .register_type::<GameSettings>()
    .add_plugins(ResourceInspectorPlugin::<GameSettings>::new()
        .run_if(input_toggle_active(KeyCode::Escape)))
```

--------------------------------

### NumberOptions::normalized() Example

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-options.md

Illustrates the use of the `normalized` method to create options for values between 0.0 and 1.0, suitable for properties like opacity or intensity, with a default step speed.

```rust
let opts = NumberOptions::normalized();
// 0.0 to 1.0 with 0.01 step speed (good for opacity/intensity)
```

--------------------------------

### Configure AssetInspectorPlugin for StandardMaterial

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Use AssetInspectorPlugin<A> to inspect specific asset types. This example shows how to add the plugin for StandardMaterial assets.

```rust
use bevy::prelude::*
use bevy_inspector_egui::quick::AssetInspectorPlugin;

App::new()
    .add_plugins(AssetInspectorPlugin::<StandardMaterial>::new())
```

--------------------------------

### NumberOptions::positive() Example

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-options.md

Shows how to use the `positive` method to ensure that a numeric field's value is always non-negative.

```rust
let opts = NumberOptions::positive(); // f32::from_f64(0.0) minimum
// Prevents negative values
```

--------------------------------

### Example Error Message Display

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/errors.md

Illustrates the visual representation of an error message in the UI, featuring an icon and colored text.

```text
⚠️ Resource `MyConfig` not found in the world
```

--------------------------------

### Configure AssetInspectorPlugin for Image Assets

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Use AssetInspectorPlugin<A> to inspect specific asset types. This example shows how to add the plugin for Image assets.

```rust
use bevy::prelude::*
use bevy_inspector_egui::quick::AssetInspectorPlugin;

App::new()
    .add_plugins(AssetInspectorPlugin::<Image>::new())
```

--------------------------------

### Deriving Reflect and InspectorOptions with Attributes

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/docs/MIGRATION_GUIDE_0.15_0.16.md

This example shows the updated way to define struct fields with inspection options like min, max, and step. You must derive `Reflect` and `InspectorOptions`, and register the type with `app.register_type::<MyStruct>()`.

```rust
#[derive(Reflect, InspectorOptions)]
#[reflect(InspectorOptions)]
struct MyStruct {
    #[inspector(min = 0.0, max = 10.0, step = 0.01)]
    value: f32,
}

app.register_type::<MyStruct>();
```

--------------------------------

### Insert Target Field Example

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/types.md

Demonstrates how to use the Target enum with InspectorOptions to apply specific display settings, such as number ranges, to struct fields.

```rust
use bevy_inspector_egui::inspector_options::{InspectorOptions, Target, std_options::NumberOptions};

let mut options = InspectorOptions::new();
let number_opts = NumberOptions::between(0.0, 1.0);
options.insert(Target::Field(0), number_opts);  // apply to first field
```

--------------------------------

### Numeric Field Options Registration

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-options.md

Demonstrates how to register default options for numeric types using Bevy Inspector Egui. Includes examples for creating sliders, setting minimum bounds, enabling positive values, normalizing ranges, and customizing drag sensitivity.

```rust
use bevy_inspector_egui::inspector_options::std_options::*

// Numeric types support:
// - between(min, max) — creates slider options
// - at_least(min) — minimum bound only
// - positive() — 0.0 minimum
// - normalized() — 0.0 to 1.0 with 0.01 speed
// - with_speed(speed) — customize drag sensitivity

let slider = NumberOptions::between(0.0, 100.0);
let positive = NumberOptions::positive();
let normalized = NumberOptions::normalized().with_speed(0.01);
```

--------------------------------

### Add ResourceInspectorPlugin for Custom Resource

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/README.md

Use ResourceInspectorPlugin to display a specific Bevy resource in a window. Ensure the resource is initialized and registered with Bevy's type system. This example shows inspection of a custom `Configuration` resource.

```rust
use bevy::prelude::*;
use bevy_inspector_egui::prelude::*;
use bevy_inspector_egui::quick::ResourceInspectorPlugin;

// `InspectorOptions` are completely optional
#[derive(Reflect, Resource, Default, InspectorOptions)]
#[reflect(Resource, InspectorOptions)]
struct Configuration {
    name: String,
    #[inspector(min = 0.0, max = 1.0)]
    option: f32,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .init_resource::<Configuration>() // `ResourceInspectorPlugin` won't initialize the resource
        .register_type::<Configuration>() // you need to register your type to display it
        .add_plugins(EguiPlugin::default())
        .add_plugins(ResourceInspectorPlugin::<Configuration>::default())
        // also works with built-in resources, as long as they are `Reflect`
        .add_plugins(ResourceInspectorPlugin::<Time>::default())
        .run();
}
```

--------------------------------

### Example Implementation of InspectorPrimitive for ToggleOption

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-egui-impls.md

Demonstrates how to implement the InspectorPrimitive trait for a custom boolean type. This example uses radio buttons for enabling/disabling.

```rust
use bevy::prelude::*;
use bevy_inspector_egui::inspector_egui_impls::InspectorPrimitive;
use bevy_inspector_egui::reflect_inspector::InspectorUi;
use std::any::Any;

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

impl InspectorPrimitive for ToggleOption {
    fn ui(
        &mut self,
        ui: &mut egui::Ui,
        _: &dyn Any,
        _: egui::Id,
        _: InspectorUi<'_, '_>,
    ) -> bool {
        let mut changed = ui.radio_value(&mut self.0, false, "Disabled").changed();
        changed |= ui.radio_value(&mut self.0, true, "Enabled").changed();
        changed
    }

    fn ui_readonly(
        &self,
        ui: &mut egui::Ui,
        _: &dyn Any,
        _: egui::Id,
        _: InspectorUi<'_, '_>,
    ) {
        let mut copy = self.0;
        ui.add_enabled_ui(false, |ui| {
            ui.radio_value(&mut copy, false, "Disabled");
            ui.radio_value(&mut copy, true, "Enabled");
        });
    }
}

fn setup(app: &mut App) {
    app.register_type::<ToggleOption>()
        .register_type_data::<ToggleOption, InspectorEguiImpl>();
}
```

--------------------------------

### RangeOptions

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-options.md

Configuration for `Range<T>` field display, allowing customization of start and end values.

```APIDOC
## Struct RangeOptions<T: InspectorOptionsType>

### Description
Configuration for `Range<T>` field display.

### Fields

- **start** (`T::Options`) - Required - Options for range start value
- **end** (`T::Options`) - Required - Options for range end value

### Usage Example
```rust
use bevy_inspector_egui::prelude::*

#[derive(Reflect, InspectorOptions)]
struct SpawnInterval {
    #[inspector(start(min = 0.1), end(max = 10.0))]
    delay: Range<f32>,
}
```
```

--------------------------------

### Creating and Using a Default Context

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/reflect-inspector.md

Demonstrates how to create a default Context and initialize an InspectorUi. This is useful for setting up the inspector with a basic context.

```rust
use bevy_inspector_egui::reflect_inspector::{InspectorUi, Context};
use bevy_reflect::TypeRegistry;
use bevy_ecs::world::CommandQueue;

let mut context = Context::default(); // empty context
let type_registry = TypeRegistry::default();
let mut inspector = InspectorUi::new_no_short_circuit(&type_registry, &mut context);
```

--------------------------------

### Usage: Conditional Registration

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/core-plugin.md

Illustrates how to conditionally add DefaultInspectorConfigPlugin and WorldInspectorPlugin, for example, only in debug builds.

```rust
use bevy::prelude::*;
use bevy_inspector_egui::DefaultInspectorConfigPlugin;

let mut app = App::new()
    .add_plugins(DefaultPlugins);

if cfg!(debug_assertions) {
    app.add_plugins(DefaultInspectorConfigPlugin)
       .add_plugins(bevy_inspector_egui::quick::WorldInspectorPlugin::new());
}

app.run();
```

--------------------------------

### Manual UI Configuration

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/INDEX.md

This snippet demonstrates how to set up the inspector with manual UI configuration, including adding `EguiPlugin` and `DefaultInspectorConfigPlugin`, and defining systems for the inspector UI.

```rust
App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(EguiPlugin::default())
    .add_plugins(DefaultInspectorConfigPlugin)
    .add_systems(EguiPrimaryContextPass, inspector_ui)
    .run();
```

--------------------------------

### Plugin and Initialization

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/INDEX.md

Details the main plugin for initializing the inspector and common import patterns.

```APIDOC
## Plugin and Initialization

### Description
Details the main plugin for initializing the inspector and common import patterns.

### Master Registration Plugin
- `DefaultInspectorConfigPlugin`: Registers all standard types automatically.
  - It is idempotent and safe to add multiple times.
  - Registers types for standard library, Bevy math, Bevy core, and feature-gated types.

### Common Imports
- `prelude` module: Contains common imports for ease of use.

### Internal Support
- `__macro_exports`: Internal module for macro support.

### Compilation
- Supports feature-conditional compilation for different build configurations.
```

--------------------------------

### Usage with Prelude Imports

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/core-plugin.md

Demonstrates how to use the prelude for convenient access to InspectorOptions and ReflectInspectorOptions.

```rust
use bevy_inspector_egui::prelude::*;

#[derive(Reflect, InspectorOptions)]
#[reflect(InspectorOptions)]
struct Config {
    #[inspector(min = 0.0, max = 1.0)]
    value: f32,
}
```

--------------------------------

### Configure StateInspectorPlugin

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Use StateInspectorPlugin<T> to inspect and mutate Bevy states. This example demonstrates inspecting a custom GameState enum.

```rust
use bevy::prelude::*
use bevy_inspector_egui::quick::StateInspectorPlugin;

#[derive(States, Default, Debug, Clone, Eq, PartialEq, Hash, Reflect)]
enum GameState {
    #[default]
    Menu,
    Playing,
    Paused,
}

App::new()
    .init_state::<GameState>()
    .add_plugins(StateInspectorPlugin::<GameState>::new())
```

--------------------------------

### Feature-Gated Re-exports

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/core-plugin.md

Shows examples of re-exports that are conditionally compiled based on Cargo features, like bevy_egui which requires 'bevy_render'.

```rust
#[cfg(feature = "bevy_render")]
pub use bevy_egui;
```

--------------------------------

### Manual Layout with Inspector UI Functions

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/README.md

Shows how to integrate bevy-inspector-egui into a manual egui window layout using `bevy_inspector::ui_for_world`. This provides more control over the UI structure.

```rust
use bevy_inspector_egui::{bevy_inspector, DefaultInspectorConfigPlugin};

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(EguiPlugin::default())
        .add_plugins(DefaultInspectorConfigPlugin)
        .add_systems(EguiPrimaryContextPass, inspector_ui)
        .run();
}

fn inspector_ui(world: &mut World) {
    let mut ctx = get_egui_context(world);

    egui::Window::new("Inspector").show(ctx.get_mut(), |ui| {
        egui::CollapsingHeader::new("World")
            .default_open(true)
            .show(ui, |ui| {
                bevy_inspector::ui_for_world(world, ui);
            });
    });
}
```

--------------------------------

### ui_for_resources

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Displays all reflectable resources in the Bevy world as collapsible headers within the egui UI context. This function allows for a broad inspection of the game's state.

```APIDOC
## ui_for_resources()

### Description
Display all reflectable resources in the world as collapsible headers.

### Signature
```rust
pub fn ui_for_resources(world: &mut World, ui: &mut egui::Ui)
```

### Parameters
#### Path Parameters
- **world** (`&mut World`) - Required - The Bevy world
- **ui** (`&mut egui::Ui`) - Required - The egui UI context

### Returns
`()` — modifies resources in-place when edited

### Example
```rust
fn resources_panel(world: &mut World, ui: &mut egui::Ui) {
    egui::CollapsingHeader::new("All Resources")
        .default_open(false)
        .show(ui, |ui| {
            bevy_inspector::ui_for_resources(world, ui);
        });
}
```
```

--------------------------------

### RangeOptions Struct

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/types.md

Provides options for controlling the start and end display of Range<T> fields, allowing separate configuration of slider bounds.

```APIDOC
## RangeOptions<T>

Options for `Range<T>` fields, controlling start and end display.

```rust
#[non_exhaustive]
pub struct RangeOptions<T: InspectorOptionsType> {
    pub start: T::Options,
    pub end: T::Options,
}

impl<T: InspectorOptionsType> Clone for RangeOptions<T>
```

### Fields

| Field | Type | Description |
|-------|------|-------------|
| start | `T::Options` | Options for the range start value |
| end | `T::Options` | Options for the range end value |

### Usage

Applied to Range fields to control slider bounds separately:

```rust
use bevy_inspector_egui::prelude::*;

#[derive(Reflect, InspectorOptions)]
struct Spawner {
    #[inspector(start(min = 1.0), end(max = 10.0))]
    spawn_delay: std::ops::Range<f32>,
}
```
```

--------------------------------

### Enable Documentation Feature for Bevy Inspector Egui

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/errors.md

Shows how to enable the 'documentation' feature in Cargo.toml to access detailed type information for debugging.

```toml
[dependencies.bevy-inspector-egui]
features = ["documentation"]
```

--------------------------------

### RangeOptions Struct Definition

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-options.md

Defines configuration options for displaying `Range<T>` fields, specifying separate options for the start and end values.

```rust
pub struct RangeOptions<T: InspectorOptionsType> {
    pub start: T::Options,
    pub end: T::Options,
}
```

--------------------------------

### Initialize and Register Resource

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/errors.md

Ensures a resource is initialized and registered with the application to prevent 'Resource Not Found' errors.

```rust
// Ensure resource is initialized
app.init_resource::<MyResource>()
   .register_type::<MyResource>();
```

--------------------------------

### WorldInspectorPlugin::new

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/quick-plugins.md

Creates a new `WorldInspectorPlugin` with default settings. This plugin displays an egui window containing entities, resources, and assets, and it is shown at all times by default.

```APIDOC
## WorldInspectorPlugin::new

### Description
Creates a new `WorldInspectorPlugin` with default settings. Shows the inspector window at all times.

### Method
`pub fn new() -> Self`

### Parameters
None

### Returns
`WorldInspectorPlugin` - a new plugin instance

### Example
```rust
use bevy::prelude::*
use bevy_inspector_egui::quick::WorldInspectorPlugin
use bevy_inspector_egui::bevy_egui::EguiPlugin

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(EguiPlugin::default())
        .add_plugins(WorldInspectorPlugin::new())
        .run();
}
```
```

--------------------------------

### Conditional Inspector Display

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/core-plugin.md

Control the inspector's visibility using a condition, such as a keybind. This example uses `run_if` with `input_toggle_active` to toggle the inspector on and off with the F12 key.

```rust
App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(EguiPlugin::default())
    .add_plugins(WorldInspectorPlugin::new()
        .run_if(input_toggle_active(KeyCode::F12)))
    .run();
```

--------------------------------

### Module Organization

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/INDEX.md

Illustrates the module structure of the bevy-inspector-egui crate, showing the relationship between different modules and their corresponding documentation files.

```text
crate
├── bevy_inspector          → bevy-inspector.md
├── reflect_inspector       → reflect-inspector.md
├── inspector_egui_impls    → inspector-egui-impls.md
├── inspector_options       → inspector-options.md
├── quick                   → quick-plugins.md
├── DefaultInspectorConfigPlugin → core-plugin.md
├── prelude                 → README.md, core-plugin.md
└── __macro_exports         → core-plugin.md
```

--------------------------------

### Conditionally Show WorldInspectorPlugin

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/quick-plugins.md

Configure the WorldInspectorPlugin to only show when a specific system condition is met. This example uses a key press to toggle the inspector's visibility.

```rust
use bevy::prelude::*;
use bevy_inspector_egui::quick::WorldInspectorPlugin;
use bevy_inspector_egui::bevy_egui::EguiPlugin;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(EguiPlugin::default())
        .add_plugins(WorldInspectorPlugin::new()
            .run_if(input_toggle_active(KeyCode::F12)))
        .run();
}
```

--------------------------------

### Registering Custom Inspector Implementation

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Demonstrates how to register a custom implementation for inspecting a specific type.

```rust
use bevy::prelude::*
use bevy_inspector_egui::inspector_egui_impls::InspectorEguiImpl;

#[derive(Reflect, Default)]
struct CustomType;

fn register(app: &mut App) {
    app.register_type::<CustomType>()
        .register_type_data::<CustomType, InspectorEguiImpl>();
}
```

--------------------------------

### ui_for_world()

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Displays entities, resources, and assets in a single grouped view within the egui UI context. This provides a comprehensive overview of the Bevy world state.

```APIDOC
## ui_for_world()

### Description
Display entities, resources, and assets in a single grouped view.

### Method
Rust Function

### Parameters
#### Path Parameters
- **world** (`&mut World`) - Required - The Bevy world to inspect
- **ui** (`&mut egui::Ui`) - Required - The egui UI context

### Response
#### Success Response
- **return value** (`()`) - no return value; modifies world in-place

### Request Example
```rust
use bevy_inspector_egui::bevy_inspector;
use bevy::prelude::*;
use bevy_egui::{EguiContext, EguiPrimaryContextPass, PrimaryEguiContext};

fn inspector_ui(world: &mut World) {
    let mut egui_context = world
        .query_filtered::<&mut EguiContext, With<PrimaryEguiContext>>()
        .single(world)
        .clone();

    egui::Window::new("Inspector").show(egui_context.get_mut(), |ui| {
        bevy_inspector::ui_for_world(world, ui);
    });
}
```
```

--------------------------------

### ui_for_entity

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Displays all components of a specific Bevy entity.

```APIDOC
## ui_for_entity()

### Description
Display all components of a specific entity.

### Method
Rust Function

### Parameters
#### Path Parameters
- **world** (`&mut World`) - Required - The Bevy world
- **entity** (`Entity`) - Required - The entity to inspect
- **ui** (`&mut egui::Ui`) - Required - The egui UI context

### Returns
`()` — modifies entity components in-place

### Example
```rust
use bevy_inspector_egui::bevy_inspector;
use bevy::prelude::*;

fn inspect_selected_entity(world: &mut World, entity: Entity, ui: &mut egui::Ui) {
    bevy_inspector::ui_for_entity(world, entity, ui);
}
```
```

--------------------------------

### Registering Inspector Options with reflect Attribute

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-options.md

Example of using the reflect attribute with InspectorOptions to register the options in the type registry, enabling integration with Bevy's reflection system.

```rust
#[derive(Reflect, InspectorOptions)]
#[reflect(InspectorOptions)]  // Register options in type registry
struct Data {
    #[inspector(min = 0.0, max = 1.0)]
    value: f32,
}
```

--------------------------------

### Register Default Inspector Config Plugin

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/types.md

This plugin registers default options and UI implementations for various types. It is often added automatically by quick plugins but can be added manually for custom inspector setups.

```rust
pub struct DefaultInspectorConfigPlugin;

impl bevy_app::Plugin for DefaultInspectorConfigPlugin
```

```rust
use bevy::prelude::*;
use bevy_inspector_egui::DefaultInspectorConfigPlugin;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(DefaultInspectorConfigPlugin)  // registers all defaults
        .run();
}
```

--------------------------------

### Applying RangeOptions to a Field

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-options.md

Demonstrates how to use `RangeOptions` with `#[inspector(...)]` attributes to set minimum and maximum values for a `Range<f32>` field.

```rust
use bevy_inspector_egui::prelude::*;

#[derive(Reflect, InspectorOptions)]
struct SpawnInterval {
    #[inspector(start(min = 0.1), end(max = 10.0))]
    delay: Range<f32>,
}
```

--------------------------------

### Registering Custom Types in Bevy

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/README.md

Demonstrates minimal, optional, and derive macro methods for registering custom types with the Bevy application. Use the minimal approach for basic registration, the options approach for custom inspector implementations, and the derive macro for automatic option registration.

```rust
// Minimal
app.register_type::<MyType>();
```

```rust
// With options
app.register_type::<MyType>()
   .register_type_data::<MyType, InspectorEguiImpl>();
```

```rust
// With derive macro
#[derive(Reflect, InspectorOptions)]
#[reflect(InspectorOptions)]
struct MyType { ... }
// Options auto-registered
```

--------------------------------

### Initialize WorldInspectorPlugin

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/quick-plugins.md

Use this snippet to add the WorldInspectorPlugin to your Bevy application. It displays an egui window with entities, resources, and assets.

```rust
use bevy::prelude::*;
use bevy_inspector_egui::quick::WorldInspectorPlugin;
use bevy_inspector_egui::bevy_egui::EguiPlugin;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(EguiPlugin::default())
        .add_plugins(WorldInspectorPlugin::new())
        .run();
}
```

--------------------------------

### Enable Bevy Subsystems for Inspection

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Use this configuration to enable all Bevy subsystems for inspection. This is equivalent to enabling '2d', '3d', and 'bevy_gizmos' features.

```toml
[dependencies.bevy-inspector-egui]
features = ["bevy"]

```

--------------------------------

### Usage: Automatic Registration with WorldInspectorPlugin

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/core-plugin.md

Demonstrates the recommended automatic registration of DefaultInspectorConfigPlugin by adding WorldInspectorPlugin. This is the simplest way to include the inspector.

```rust
use bevy::prelude::*;
use bevy_inspector_egui::quick::WorldInspectorPlugin;

App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(WorldInspectorPlugin::new())  // Adds DefaultInspectorConfigPlugin
    .run();
```

--------------------------------

### Drop-in UI Plugins

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/INDEX.md

Provides several plugins that can be easily added to a Bevy application to enable world inspection functionalities.

```APIDOC
## Drop-in UI Plugins

### Description
Provides several plugins that can be easily added to a Bevy application to enable world inspection functionalities.

### Plugins
- `WorldInspectorPlugin`: Displays the entire world in a window with default dimensions of 320x160.
- `ResourceInspectorPlugin<T>`: Allows for the inspection of a single resource of type `T`.
- `StateInspectorPlugin<T>`: Enables inspection and mutation of a Bevy state of type `T`.
- `AssetInspectorPlugin<A>`: Facilitates the inspection of assets of type `A`.

### Methods
- `.new()`: Creates a new instance of the plugin.
- `.run_if(condition)`: Specifies a condition for when the plugin should run.

### Constants
- `DEFAULT_SIZE`: The default size for the world inspector window.
```

--------------------------------

### ui_for_resource<R>()

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Displays a single resource of a specified type `R` within the egui UI. This is useful for inspecting and potentially modifying a specific resource.

```APIDOC
## ui_for_resource<R>()

### Description
Display a single resource of type `R`.

### Signature
```rust
pub fn ui_for_resource<R: Resource<Mutability = Mutable> + Reflect>(
    world: &mut World,
    ui: &mut egui::Ui
)
```

### Parameters
#### Path Parameters
- **world** (`&mut World`) - Required - The Bevy world
- **ui** (`&mut egui::Ui`) - Required - The egui UI context

### Type Parameters
- `R: Resource<Mutability = Mutable> + Reflect` — The resource type to display

### Returns
`()` — marks resource as changed if modified

### Example
```rust
use bevy::prelude::*;
use bevy_inspector_egui::bevy_inspector;

fn inspect_time(world: &mut World, ui: &mut egui::Ui) {
    bevy_inspector::ui_for_resource::<Time>(world, ui);
}
```
```

--------------------------------

### Create InspectorEguiImpl with Raw Function Pointers

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-egui-impls.md

Constructs an InspectorEguiImpl using provided function pointers for mutable UI, read-only UI, and multi-value editing.

```rust
pub fn new(
    fn_mut: InspectorEguiImplFn,
    fn_readonly: InspectorEguiImplFnReadonly,
    fn_many: InspectorEguiImplFnMany,
) -> Self
```

--------------------------------

### Usage: Manual Registration of DefaultInspectorConfigPlugin

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/core-plugin.md

Shows how to manually add DefaultInspectorConfigPlugin to an application for more explicit control over its inclusion.

```rust
use bevy::prelude::*;
use bevy_inspector_egui::DefaultInspectorConfigPlugin;
use bevy_egui::EguiPlugin;

App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(EguiPlugin::default())
    .add_plugins(DefaultInspectorConfigPlugin)
    .add_systems(Startup, my_setup)
    .run();
```

--------------------------------

### Display Bevy World State in an Egui Window

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Use `ui_for_world` to display entities, resources, and assets in a grouped view within an egui window. This function requires mutable access to the Bevy world and the egui UI context. It modifies the world in-place.

```rust
use bevy_inspector_egui::bevy_inspector;
use bevy::prelude::*;
use bevy_egui::{EguiContext, EguiPrimaryContextPass, PrimaryEguiContext};

fn inspector_ui(world: &mut World) {
    let mut egui_context = world
        .query_filtered::<&mut EguiContext, With<PrimaryEguiContext>>()
        .single(world)
        .clone();

    egui::Window::new("Inspector").show(egui_context.get_mut(), |ui| {
        bevy_inspector::ui_for_world(world, ui);
    });
}
```

--------------------------------

### Display Specific Entity Components

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Use `ui_for_entity` to display all components of a given entity. Requires `bevy_inspector_egui::bevy_inspector` and `bevy::prelude::*`.

```rust
use bevy_inspector_egui::bevy_inspector;
use bevy::prelude::*;

fn inspect_selected_entity(world: &mut World, entity: Entity, ui: &mut egui::Ui) {
    bevy_inspector::ui_for_entity(world, entity, ui);
}
```

--------------------------------

### Basic Type Registration

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Shows how to register a custom struct with Bevy's type registry for inspection.

```rust
use bevy::prelude::*

#[derive(Reflect)]
struct MyData {
    value: f32,
}

fn setup(mut app: &mut App) {
    app.register_type::<MyData>();
}
```

--------------------------------

### InspectorUi::new_no_short_circuit()

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/reflect-inspector.md

Creates an InspectorUi instance without any short-circuiting behavior, simplifying the inspection process.

```APIDOC
## InspectorUi::new_no_short_circuit()

### Description
Creates an InspectorUi without any short-circuiting behavior.

### Method
`new_no_short_circuit`

### Parameters
#### Path Parameters
- **type_registry** (`&'a TypeRegistry`) - Required - Type information
- **context** (`&'a mut Context<'c>`) - Required - Optional world context

### Returns
`InspectorUi<'a, 'c>` — new inspector with no special type handling
```

--------------------------------

### ui_for_entities

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Displays all root entities (those without parents) along with their components in the Bevy world. This function allows for in-place modification of entities and their components.

```APIDOC
## ui_for_entities()

### Description
Displays all root entities (without parents) with their components.

### Method
Rust Function

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **world** (`&mut World`) - Required - The Bevy world
- **ui** (`&mut egui::Ui`) - Required - The egui UI context

### Returns
`()` — modifies entities/components in-place

### Example
```rust
use bevy_inspector_egui::bevy_inspector

fn show_entities(world: &mut World, ui: &mut egui::Ui) {
    bevy_inspector::ui_for_entities(world, ui);
}
```
```

--------------------------------

### UI for Entity with Children

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Displays an entity, its components, and its child hierarchy recursively within the Bevy world and an egui UI context.

```rust
pub fn ui_for_entity_with_children(world: &mut World, entity: Entity, ui: &mut egui::Ui)
```

--------------------------------

### Register Custom Types with Reflection Attributes

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/errors.md

Demonstrates how to use `#[derive(Reflect, Resource)]` and `#[reflect(...)]` attributes for custom types to ensure proper registration with Bevy's reflection system, enabling detailed inspection.

```rust
#[derive(Reflect, Resource)]
#[reflect(Resource, InspectorOptions)]
struct Config {
    #[inspector(min = 0.0, max = 1.0)]
    value: f32,
}
```

--------------------------------

### Enable Bevy 3D Types for Inspection

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Configure your project to inspect Bevy 3D types. This includes features for lights, materials, rendering, and more.

```toml
[dependencies.bevy-inspector-egui]
features = ["3d"]

```

--------------------------------

### Display All Resources in Bevy World

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Use this function to display all reflectable resources within the Bevy world. It's useful for creating a general-purpose resource inspector panel.

```rust
fn resources_panel(world: &mut World, ui: &mut egui::Ui) {
    egui::CollapsingHeader::new("All Resources")
        .default_open(false)
        .show(ui, |ui| {
            bevy_inspector::ui_for_resources(world, ui);
        });
}
```

--------------------------------

### Custom Layout with Manual Inspector

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/core-plugin.md

Integrate the inspector with a custom layout by using `DefaultInspectorConfigPlugin` and defining your own UI systems. This allows for more control over where and how the inspector is displayed.

```rust
App::new()
    .add_plugins(DefaultPlugins)
    .add_plugins(EguiPlugin::default())
    .add_plugins(DefaultInspectorConfigPlugin)
    .add_systems(EguiPrimaryContextPass, my_inspector_ui)
    .run();
```

--------------------------------

### ui_for_assets<A>()

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Displays all assets of a specific type `A`. This function is generic and allows specifying the exact asset type to be inspected, providing a focused view.

```APIDOC
## ui_for_assets<A>()

### Description
Display all assets of a specific type `A`.

### Function Signature
`pub fn ui_for_assets<A: Asset + Reflect>(world: &mut World, ui: &mut egui::Ui)`

### Type Parameters
- `A: Asset + Reflect` — The asset type to display

### Parameters
#### Path Parameters
- **world** (`&mut World`) - Required - The Bevy world
- **ui** (`&mut egui::Ui`) - Required - The egui UI context

### Returns
`()` — modifies assets in-place when edited

### Example
```rust
use bevy::prelude::*;
use bevy_pbr::StandardMaterial;
use bevy_inspector_egui::bevy_inspector;

fn inspect_materials(world: &mut World, ui: &mut egui::Ui) {
    egui::CollapsingHeader::new("Materials").show(ui, |ui| {
        bevy_inspector::ui_for_assets::<StandardMaterial>(world, ui);
    });
}
```
```

--------------------------------

### ui_for_all_assets

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Displays all asset types in a grouped view within the egui UI. This function iterates through all registered asset types in the Bevy world and presents them for inspection.

```APIDOC
## ui_for_all_assets()

### Description
Display all asset types in a grouped view.

### Function Signature
`pub fn ui_for_all_assets(world: &mut World, ui: &mut egui::Ui)`

### Parameters
#### Path Parameters
- **world** (`&mut World`) - Required - The Bevy world
- **ui** (`&mut egui::Ui`) - Required - The egui UI context

### Returns
`()` — modifies assets in-place when edited

### Example
```rust
egui::CollapsingHeader::new("Assets").show(ui, |ui| {
    bevy_inspector::ui_for_all_assets(world, ui);
});
```
```

--------------------------------

### Configure WorldInspectorPlugin to Show on Key Press

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/configuration.md

Configure WorldInspectorPlugin to be toggled by a specific key press. The inspector will only appear when the specified key (e.g., F12) is active.

```rust
use bevy::prelude::*
use bevy_inspector_egui::quick::WorldInspectorPlugin;

// Show when F12 pressed
App::new()
    .add_plugins(WorldInspectorPlugin::new()
        .run_if(input_toggle_active(KeyCode::F12)))
```

--------------------------------

### Integration Points

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Key integration points for using Bevy Inspector Egui, detailing how UI functions interact with the Bevy world and its components.

```APIDOC
## Integration Points

- All UI functions take `&mut World`, allowing full access to world state.
- Call `guess_entity_name()` to get human-readable entity names (includes `Name` component if present).
- Functions create temporary `CommandQueue` instances to safely apply mutations.
- All functions use the world's `AppTypeRegistry` for type information.
- Asset name resolution uses `AssetServer::get_path()` when available.
```

--------------------------------

### Create Filter with Exact Matching UI

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/bevy-inspector.md

Creates a filter instance using a UI for exact matching, including toggles for fuzzy matching and observers.

```rust
pub fn from_ui(ui: &mut egui::Ui, id: egui::Id) -> Self
```

--------------------------------

### Custom Option Type Definition

Source: https://github.com/jakobhellermann/bevy-inspector-egui/blob/main/_autodocs/api-reference/inspector-options.md

Illustrates the creation of a custom option type `MyCustomOptions` for specialized UI rendering within the inspector.

```rust
use bevy_reflect::TypeData;

#[derive(Clone)]
pub struct MyCustomOptions {
    pub enabled: bool,
    pub precision: u32,
}

impl TypeData for MyCustomOptions {}
```