Struct bevy_inspector_egui::egui_reflect_inspector::InspectorUi

pub struct InspectorUi<'a, 'c> {
    pub type_registry: &'a TypeRegistry,
    pub context: &'a mut Context<'c>,
    pub short_circuit: ShortCircuitFn,
    pub short_circuit_readonly: fn(_: &mut InspectorUi<'_, '_>, value: &dyn Reflect, ui: &mut Ui, id: Id, options: &dyn Any) -> Option<()>,
    pub short_circuit_many: ShortCircuitFnMany,
}

Fields

type_registry: &'a TypeRegistry

Reference to the TypeRegistry

context: &'a mut Context<'c>

Context with additional data that can be used to display values

short_circuit: ShortCircuitFn

Function which will be executed for every field recursively, which can be used to skip regular traversal. This can be used to recognize Handle<T> types and display them as their actual value instead.

short_circuit_readonly: fn(_: &mut InspectorUi<'_, '_>, value: &dyn Reflect, ui: &mut Ui, id: Id, options: &dyn Any) -> Option<()>

Same as short_circuit, but for read only usage.

short_circuit_many: ShortCircuitFnMany

Implementations

impl<'a, 'c> InspectorUi<'a, 'c>

pub fn for_bevy(
    type_registry: &'a TypeRegistry,
    context: &'a mut Context<'c>
) -> InspectorUi<'a, 'c>

InspectorUi with short circuiting methods able to display bevy_asset Handles

Examples found in repository

src/bevy_inspector/mod.rs (line 72)

pub fn ui_for_value(value: &mut dyn Reflect, world: &mut World, ui: &mut egui::Ui) -> bool {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let mut cx = Context {
        world: Some(RestrictedWorldView::new(world)),
    };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);
    env.ui_for_reflect(value, ui)
}

/// Display `Entities`, `Resources` and `Assets` using their respective functions inside headers
pub fn ui_for_world(world: &mut World, ui: &mut egui::Ui) {
    egui::CollapsingHeader::new("Entities")
        .default_open(true)
        .show(ui, |ui| {
            ui_for_world_entities(world, ui);
        });
    egui::CollapsingHeader::new("Resources").show(ui, |ui| {
        ui_for_resources(world, ui);
    });
    egui::CollapsingHeader::new("Assets").show(ui, |ui| {
        ui_for_all_assets(world, ui);
    });
}

/// Display all reflectable resources in the world
pub fn ui_for_resources(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let mut resources: Vec<_> = type_registry
        .iter()
        .filter(|registration| registration.data::<ReflectResource>().is_some())
        .map(|registration| (registration.short_name().to_owned(), registration.type_id()))
        .collect();
    resources.sort_by(|(name_a, ..), (name_b, ..)| name_a.cmp(name_b));
    for (name, type_id) in resources {
        ui.collapsing(&name, |ui| {
            by_type_id::ui_for_resource(world, type_id, ui, &name, &type_registry);
        });
    }
}

/// Display the resource `R`
pub fn ui_for_resource<R: Resource + Reflect>(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    // create a context with access to the world except for the `R` resource
    let Some((mut resource, world)) = RestrictedWorldView::new(world).split_off_resource_typed::<R>() else {
        errors::resource_does_not_exist(ui, &pretty_type_name::<R>());
        return;
    };
    let mut cx = Context { world: Some(world) };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);

    if env.ui_for_reflect(resource.bypass_change_detection(), ui) {
        resource.set_changed();
    }
}

/// Display all reflectable assets
pub fn ui_for_all_assets(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let mut assets: Vec<_> = type_registry
        .iter()
        .filter(|registration| registration.data::<ReflectAsset>().is_some())
        .map(|registration| (registration.short_name().to_owned(), registration.type_id()))
        .collect();
    assets.sort_by(|(name_a, ..), (name_b, ..)| name_a.cmp(name_b));
    for (name, type_id) in assets {
        ui.collapsing(&name, |ui| {
            by_type_id::ui_for_assets(world, type_id, ui, &type_registry);
        });
    }
}

/// Display all assets of the specified asset type `A`
pub fn ui_for_assets<A: Asset + Reflect>(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    // create a context with access to the world except for the `R` resource
    let Some((mut assets, world)) = RestrictedWorldView::new(world).split_off_resource_typed::<Assets<A>>() else {
        errors::resource_does_not_exist(ui, &pretty_type_name::<Assets<A>>());
        return;
    };
    let mut cx = Context { world: Some(world) };

    for (handle_id, asset) in assets.iter_mut() {
        let id = egui::Id::new(handle_id);

        egui::CollapsingHeader::new(format!("Handle({id:?})"))
            .id_source(id)
            .show(ui, |ui| {
                let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);
                env.ui_for_reflect_with_options(asset, ui, id, &());
            });
    }
}

/// Display state `T` and change state on edit
pub fn ui_for_state<T: StateData + Reflect>(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    // create a context with access to the world except for the `State<T>` resource
    let Some((mut state, world)) = RestrictedWorldView::new(world).split_off_resource_typed::<State<T>>() else {
        errors::state_does_not_exist(ui, &pretty_type_name::<T>());
        return;
    };
    let mut cx = Context { world: Some(world) };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);

    let mut current = state.current().clone();

    let changed = env.ui_for_reflect(&mut current, ui);
    if changed {
        if let Err(e) = state.set(current) {
            ui.label(format!("{e:?}"));
        }
    }
}

/// Display all entities and their components
pub fn ui_for_world_entities(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let mut root_entities = world.query_filtered::<Entity, Without<Parent>>();
    let mut entities = root_entities.iter(world).collect::<Vec<_>>();
    entities.sort();

    let id = egui::Id::new("world ui");
    for entity in entities {
        ui_for_entity_inner(world, entity, ui, id.with(entity), &type_registry, true);
    }
}

/// Display the given entity with all its components and children
pub fn ui_for_entity(world: &mut World, entity: Entity, ui: &mut egui::Ui, in_header: bool) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    ui_for_entity_inner(
        world,
        entity,
        ui,
        egui::Id::new(entity),
        &type_registry,
        in_header,
    )
}

fn ui_for_entity_inner(
    world: &mut World,
    entity: Entity,
    ui: &mut egui::Ui,
    id: egui::Id,
    type_registry: &TypeRegistry,
    in_header: bool,
) {
    let entity_name = guess_entity_name::entity_name(world, type_registry, entity);

    let mut inner = |ui: &mut egui::Ui| {
        ui_for_entity_components(world, entity, ui, id, type_registry);

        let children = world
            .get::<Children>(entity)
            .map(|children| children.iter().copied().collect::<Vec<_>>());
        if let Some(children) = children {
            if !children.is_empty() {
                ui.label("Children");
                for &child in children.iter() {
                    let id = id.with(child);
                    ui_for_entity_inner(world, child, ui, id, type_registry, true);
                }
            }
        }
    };

    if in_header {
        egui::CollapsingHeader::new(entity_name)
            .id_source(id)
            .show(ui, |ui| {
                inner(ui);
            });
    } else {
        ui.label(entity_name);
        inner(ui);
    }
}

/// Display the components of the given entity
fn ui_for_entity_components(
    world: &mut World,
    entity: Entity,
    ui: &mut egui::Ui,
    id: egui::Id,
    type_registry: &TypeRegistry,
) {
    let entity_ref = match world.get_entity(entity) {
        Some(entity) => entity,
        None => {
            errors::entity_does_not_exist(ui, entity);
            return;
        }
    };
    let components = components_of_entity(entity_ref, world);

    for (name, component_id, component_type_id, size) in components {
        let id = id.with(component_id);
        egui::CollapsingHeader::new(&name)
            .id_source(id)
            .show(ui, |ui| {
                if size == 0 {
                    return;
                }
                let Some(component_type_id) = component_type_id else {
                    return errors::error_message_no_type_id(ui, &name);
                };

                // create a context with access to the world except for the currently viewed component
                let mut world = RestrictedWorldView::new(world);
                let (mut component_view, world) =
                    world.split_off_component((entity, component_type_id));
                let mut cx = Context { world: Some(world) };

                let (value, set_changed) = match component_view.get_entity_component_reflect(
                    entity,
                    component_type_id,
                    type_registry,
                ) {
                    Ok(value) => value,
                    Err(e) => return show_error(e, ui, &name),
                };

                let changed = InspectorUi::for_bevy(type_registry, &mut cx)
                    .ui_for_reflect_with_options(value, ui, id.with(component_id), &());

                if changed {
                    set_changed();
                }
            });
    }
}

fn components_of_entity(
    entity_ref: EntityRef,
    world: &World,
) -> Vec<(String, ComponentId, Option<TypeId>, usize)> {
    let archetype = entity_ref.archetype();
    let mut components: Vec<_> = archetype
        .components()
        .map(|component_id| {
            let info = world.components().get_info(component_id).unwrap();
            let name = pretty_type_name::pretty_type_name_str(info.name());

            (name, component_id, info.type_id(), info.layout().size())
        })
        .collect();
    components.sort_by(|(name_a, ..), (name_b, ..)| name_a.cmp(name_b));
    components
}

/// Display the given entity with all its components and children
pub fn ui_for_entities_shared_components(
    world: &mut World,
    entities: &[Entity],
    ui: &mut egui::Ui,
) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let Some(&first) = entities.first() else { return };

    let Some(entity_ref) = world.get_entity(first) else {
        return errors::entity_does_not_exist(ui, first);
    };

    let mut components = components_of_entity(entity_ref, world);

    for &entity in entities.iter().skip(1) {
        components.retain(|(_, id, _, _)| {
            world
                .get_entity(entity)
                .map_or(true, |entity| entity.contains_id(*id))
        })
    }

    let (resources_view, components_view) = RestrictedWorldView::resources_components(world);
    let mut cx = Context {
        world: Some(resources_view),
    };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);

    let id = egui::Id::null();
    for (name, component_id, component_type_id, size) in components {
        let id = id.with(component_id);
        egui::CollapsingHeader::new(&name)
            .id_source(id)
            .show(ui, |ui| {
                if size == 0 {
                    return;
                }
                let Some(component_type_id) = component_type_id else {
                    return errors::error_message_no_type_id(ui, &name);
                };

                let mut values = Vec::with_capacity(entities.len());
                let mut mark_changeds = Vec::with_capacity(entities.len());

                for (i, &entity) in entities.iter().enumerate() {
                    // skip duplicate entities
                    if entities[0..i].contains(&entity) {
                        continue;
                    };

                    // SAFETY: entities are distinct, env has a context with just resources
                    match unsafe {
                        components_view.get_entity_component_reflect_unchecked(
                            entity,
                            component_type_id,
                            &type_registry,
                        )
                    } {
                        Ok((value, mark_changed)) => {
                            values.push(value);
                            mark_changeds.push(mark_changed);
                        }
                        Err(error) => {
                            errors::show_error(error, ui, &name);
                            return;
                        }
                    }
                }

                let changed = env.ui_for_reflect_many_with_options(
                    component_type_id,
                    &name,
                    ui,
                    id.with(component_id),
                    &(),
                    values.as_mut_slice(),
                    &|a| a,
                );
                if changed {
                    mark_changeds.into_iter().for_each(|f| f());
                }
            });
    }
}

pub mod by_type_id {
    use std::any::TypeId;

    use bevy_asset::{HandleUntyped, ReflectAsset, ReflectHandle};
    use bevy_ecs::prelude::*;
    use bevy_reflect::TypeRegistry;

    use crate::{
        egui_reflect_inspector::{Context, InspectorUi},
        restricted_world_view::RestrictedWorldView,
    };

    use super::errors::{self, name_of_type};

    /// Display the resource with the given [`TypeId`]
    pub fn ui_for_resource(
        world: &mut World,
        resource_type_id: TypeId,
        ui: &mut egui::Ui,
        name_of_type: &str,
        type_registry: &TypeRegistry,
    ) {
        // create a context with access to the world except for the current resource
        let mut world = RestrictedWorldView::new(world);
        let (mut resource_view, world) = world.split_off_resource(resource_type_id);
        let mut cx = Context { world: Some(world) };
        let mut env = InspectorUi::for_bevy(type_registry, &mut cx);

        let (resource, set_changed) =
            match resource_view.get_resource_reflect_mut_by_id(resource_type_id, type_registry) {
                Ok(resource) => resource,
                Err(err) => return errors::show_error(err, ui, name_of_type),
            };

        let changed = env.ui_for_reflect(resource, ui);
        if changed {
            set_changed();
        }
    }

    /// Display all assets of the given asset [`TypeId`]
    pub fn ui_for_assets(
        world: &mut World,
        asset_type_id: TypeId,
        ui: &mut egui::Ui,
        type_registry: &TypeRegistry,
    ) {
        let Some(registration) = type_registry.get(asset_type_id) else {
        return crate::egui_reflect_inspector::errors::error_message_not_in_type_registry(ui, &name_of_type(asset_type_id, type_registry));
    };
        let Some(reflect_asset) = registration.data::<ReflectAsset>() else {
        return errors::no_type_data(ui, &name_of_type(asset_type_id, type_registry), "ReflectAsset");
    };
        let Some(reflect_handle) = type_registry.get_type_data::<ReflectHandle>(reflect_asset.handle_type_id()) else {
        return errors::no_type_data(ui, &name_of_type(reflect_asset.handle_type_id(), type_registry), "ReflectHandle");
    };

        let mut ids: Vec<_> = reflect_asset.ids(world).collect();
        ids.sort();

        // Create a context with access to the entire world. Displaying the `Handle<T>` will short circuit into
        // displaying the T with a world view excluding Assets<T>.
        let world = RestrictedWorldView::new(world);
        let mut cx = Context { world: Some(world) };

        for handle_id in ids {
            let id = egui::Id::new(handle_id);
            let mut handle = reflect_handle.typed(HandleUntyped::weak(handle_id));

            egui::CollapsingHeader::new(format!("Handle({id:?})"))
                .id_source(id)
                .show(ui, |ui| {
                    let mut env = InspectorUi::for_bevy(type_registry, &mut cx);
                    env.ui_for_reflect_with_options(&mut *handle, ui, id, &());
                });
        }
    }

impl<'a, 'c> InspectorUi<'a, 'c>

pub fn new(
    type_registry: &'a TypeRegistry,
    context: &'a mut Context<'c>,
    short_circuit: Option<ShortCircuitFn>,
    short_circuit_readonly: Option<fn(_: &mut InspectorUi<'_, '_>, value: &dyn Reflect, ui: &mut Ui, id: Id, options: &dyn Any) -> Option<()>>,
    short_circuit_many: Option<ShortCircuitFnMany>
) -> Self

Examples found in repository

src/egui_reflect_inspector/mod.rs (line 173)

    pub fn new_no_short_circuit(
        type_registry: &'a TypeRegistry,
        context: &'a mut Context<'c>,
    ) -> Self {
        InspectorUi::new(type_registry, context, None, None, None)
    }

src/bevy_inspector/mod.rs (lines 506-512)

    pub fn for_bevy(
        type_registry: &'a TypeRegistry,
        context: &'a mut Context<'c>,
    ) -> InspectorUi<'a, 'c> {
        InspectorUi::new(
            type_registry,
            context,
            Some(short_circuit::short_circuit),
            Some(short_circuit::short_circuit_readonly),
            Some(short_circuit::short_circuit_many),
        )
    }

pub fn new_no_short_circuit(
    type_registry: &'a TypeRegistry,
    context: &'a mut Context<'c>
) -> Self

Examples found in repository

src/egui_reflect_inspector/mod.rs (line 81)

pub fn ui_for_value(
    value: &mut dyn Reflect,
    ui: &mut egui::Ui,
    type_registry: &TypeRegistry,
) -> bool {
    InspectorUi::new_no_short_circuit(type_registry, &mut Context::default())
        .ui_for_reflect(value, ui)
}

#[derive(Default)]
pub struct Context<'a> {
    pub world: Option<RestrictedWorldView<'a>>,
}

pub fn ui_for_reflect_no_context(
    value: &mut dyn Reflect,
    ui: &mut egui::Ui,
    type_registry: &TypeRegistry,
) -> bool {
    let mut context = Context::default();
    InspectorUi::new_no_short_circuit(type_registry, &mut context).ui_for_reflect(value, ui)
}
pub fn ui_for_reflect_readonly_no_context(
    value: &mut dyn Reflect,
    ui: &mut egui::Ui,
    type_registry: &TypeRegistry,
) {
    let mut context = Context::default();
    InspectorUi::new_no_short_circuit(type_registry, &mut context)
        .ui_for_reflect_readonly(value, ui);
}

impl InspectorUi<'_, '_>

pub fn ui_for_reflect(&mut self, value: &mut dyn Reflect, ui: &mut Ui) -> bool

Draws the inspector UI for the given value.

Examples found in repository

src/inspector_egui_impls/glam_impls.rs (line 207)

        fn ui(&mut self, ui: &mut egui::Ui, mut env: InspectorUi<'_, '_>) -> bool {
            env.ui_for_reflect(&mut self.0, ui)
        }
    }

    impl RotationEdit for YawPitchRoll {
        fn from_quat(quat: Quat) -> Self {
            YawPitchRoll(quat.to_euler(EulerRot::YXZ))
        }

        fn to_quat(self) -> Quat {
            let (y, p, r) = self.0;
            Quat::from_euler(EulerRot::YXZ, y, p, r)
        }

        fn ui(&mut self, ui: &mut egui::Ui, _env: InspectorUi<'_, '_>) -> bool {
            let (yaw, pitch, roll) = &mut self.0;

            let mut changed = false;
            ui.vertical(|ui| {
                egui::Grid::new("ypr grid").show(ui, |ui| {
                    ui.label("Yaw");
                    changed |= ui.drag_angle(yaw).changed();
                    ui.end_row();
                    ui.label("Pitch").changed();
                    changed |= ui.drag_angle(pitch).changed();
                    ui.end_row();
                    ui.label("Roll");
                    changed |= ui.drag_angle(roll).changed();
                    ui.end_row();
                });
            });
            changed
        }
    }

    impl RotationEdit for AxisAngle {
        fn from_quat(quat: Quat) -> Self {
            AxisAngle(quat.to_axis_angle())
        }

        fn to_quat(self) -> Quat {
            let (axis, angle) = self.0;
            let axis = axis.normalize();
            if axis.is_nan() {
                Quat::IDENTITY
            } else {
                Quat::from_axis_angle(axis.normalize(), angle)
            }
        }

        fn ui(&mut self, ui: &mut egui::Ui, mut env: InspectorUi<'_, '_>) -> bool {
            let (axis, angle) = &mut self.0;

            let mut changed = false;
            ui.vertical(|ui| {
                egui::Grid::new("axis-angle quat").show(ui, |ui| {
                    ui.label("Axis");
                    changed |= env.ui_for_reflect(axis, ui);
                    ui.end_row();
                    ui.label("Angle");
                    changed |= ui.drag_angle(angle).changed();
                    ui.end_row();
                });
            });
            changed
        }
    }

    fn quat_ui_kind<T: Send + Sync + 'static + Copy + RotationEdit>(
        val: &mut Quat,
        ui: &mut egui::Ui,
        env: InspectorUi<'_, '_>,
    ) -> bool {
        let id = ui.id();
        let mut intermediate = *ui
            .memory()
            .data
            .get_temp_mut_or_insert_with(id, || T::from_quat(*val));

        let externally_changed = !intermediate.to_quat().abs_diff_eq(*val, std::f32::EPSILON);
        if externally_changed {
            intermediate = T::from_quat(*val);
        }

        let changed = intermediate.ui(ui, env);

        if changed || externally_changed {
            *val = intermediate.to_quat();
            ui.memory().data.insert_temp(id, intermediate);
        }

        changed
    }

    pub fn quat_ui(
        value: &mut dyn Any,
        ui: &mut egui::Ui,
        options: &dyn Any,
        mut env: InspectorUi<'_, '_>,
    ) -> bool {
        let value = value.downcast_mut::<Quat>().unwrap();

        let options = options
            .downcast_ref::<QuatOptions>()
            .cloned()
            .unwrap_or_default();

        ui.vertical(|ui| match options.display {
            QuatDisplay::Raw => {
                let mut vec4 = Vec4::from(*value);
                let changed = env.ui_for_reflect(&mut vec4, ui);
                if changed {
                    *value = Quat::from_vec4(vec4).normalize();
                }
                changed
            }
            QuatDisplay::Euler => quat_ui_kind::<Euler>(value, ui, env),
            QuatDisplay::YawPitchRoll => quat_ui_kind::<YawPitchRoll>(value, ui, env),
            QuatDisplay::AxisAngle => quat_ui_kind::<AxisAngle>(value, ui, env),
        })
        .inner
    }

src/egui_reflect_inspector/mod.rs (line 82)

pub fn ui_for_value(
    value: &mut dyn Reflect,
    ui: &mut egui::Ui,
    type_registry: &TypeRegistry,
) -> bool {
    InspectorUi::new_no_short_circuit(type_registry, &mut Context::default())
        .ui_for_reflect(value, ui)
}

#[derive(Default)]
pub struct Context<'a> {
    pub world: Option<RestrictedWorldView<'a>>,
}

pub fn ui_for_reflect_no_context(
    value: &mut dyn Reflect,
    ui: &mut egui::Ui,
    type_registry: &TypeRegistry,
) -> bool {
    let mut context = Context::default();
    InspectorUi::new_no_short_circuit(type_registry, &mut context).ui_for_reflect(value, ui)
}

src/bevy_inspector/mod.rs (line 73)

pub fn ui_for_value(value: &mut dyn Reflect, world: &mut World, ui: &mut egui::Ui) -> bool {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let mut cx = Context {
        world: Some(RestrictedWorldView::new(world)),
    };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);
    env.ui_for_reflect(value, ui)
}

/// Display `Entities`, `Resources` and `Assets` using their respective functions inside headers
pub fn ui_for_world(world: &mut World, ui: &mut egui::Ui) {
    egui::CollapsingHeader::new("Entities")
        .default_open(true)
        .show(ui, |ui| {
            ui_for_world_entities(world, ui);
        });
    egui::CollapsingHeader::new("Resources").show(ui, |ui| {
        ui_for_resources(world, ui);
    });
    egui::CollapsingHeader::new("Assets").show(ui, |ui| {
        ui_for_all_assets(world, ui);
    });
}

/// Display all reflectable resources in the world
pub fn ui_for_resources(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let mut resources: Vec<_> = type_registry
        .iter()
        .filter(|registration| registration.data::<ReflectResource>().is_some())
        .map(|registration| (registration.short_name().to_owned(), registration.type_id()))
        .collect();
    resources.sort_by(|(name_a, ..), (name_b, ..)| name_a.cmp(name_b));
    for (name, type_id) in resources {
        ui.collapsing(&name, |ui| {
            by_type_id::ui_for_resource(world, type_id, ui, &name, &type_registry);
        });
    }
}

/// Display the resource `R`
pub fn ui_for_resource<R: Resource + Reflect>(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    // create a context with access to the world except for the `R` resource
    let Some((mut resource, world)) = RestrictedWorldView::new(world).split_off_resource_typed::<R>() else {
        errors::resource_does_not_exist(ui, &pretty_type_name::<R>());
        return;
    };
    let mut cx = Context { world: Some(world) };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);

    if env.ui_for_reflect(resource.bypass_change_detection(), ui) {
        resource.set_changed();
    }
}

/// Display all reflectable assets
pub fn ui_for_all_assets(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let mut assets: Vec<_> = type_registry
        .iter()
        .filter(|registration| registration.data::<ReflectAsset>().is_some())
        .map(|registration| (registration.short_name().to_owned(), registration.type_id()))
        .collect();
    assets.sort_by(|(name_a, ..), (name_b, ..)| name_a.cmp(name_b));
    for (name, type_id) in assets {
        ui.collapsing(&name, |ui| {
            by_type_id::ui_for_assets(world, type_id, ui, &type_registry);
        });
    }
}

/// Display all assets of the specified asset type `A`
pub fn ui_for_assets<A: Asset + Reflect>(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    // create a context with access to the world except for the `R` resource
    let Some((mut assets, world)) = RestrictedWorldView::new(world).split_off_resource_typed::<Assets<A>>() else {
        errors::resource_does_not_exist(ui, &pretty_type_name::<Assets<A>>());
        return;
    };
    let mut cx = Context { world: Some(world) };

    for (handle_id, asset) in assets.iter_mut() {
        let id = egui::Id::new(handle_id);

        egui::CollapsingHeader::new(format!("Handle({id:?})"))
            .id_source(id)
            .show(ui, |ui| {
                let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);
                env.ui_for_reflect_with_options(asset, ui, id, &());
            });
    }
}

/// Display state `T` and change state on edit
pub fn ui_for_state<T: StateData + Reflect>(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    // create a context with access to the world except for the `State<T>` resource
    let Some((mut state, world)) = RestrictedWorldView::new(world).split_off_resource_typed::<State<T>>() else {
        errors::state_does_not_exist(ui, &pretty_type_name::<T>());
        return;
    };
    let mut cx = Context { world: Some(world) };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);

    let mut current = state.current().clone();

    let changed = env.ui_for_reflect(&mut current, ui);
    if changed {
        if let Err(e) = state.set(current) {
            ui.label(format!("{e:?}"));
        }
    }
}

/// Display all entities and their components
pub fn ui_for_world_entities(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let mut root_entities = world.query_filtered::<Entity, Without<Parent>>();
    let mut entities = root_entities.iter(world).collect::<Vec<_>>();
    entities.sort();

    let id = egui::Id::new("world ui");
    for entity in entities {
        ui_for_entity_inner(world, entity, ui, id.with(entity), &type_registry, true);
    }
}

/// Display the given entity with all its components and children
pub fn ui_for_entity(world: &mut World, entity: Entity, ui: &mut egui::Ui, in_header: bool) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    ui_for_entity_inner(
        world,
        entity,
        ui,
        egui::Id::new(entity),
        &type_registry,
        in_header,
    )
}

fn ui_for_entity_inner(
    world: &mut World,
    entity: Entity,
    ui: &mut egui::Ui,
    id: egui::Id,
    type_registry: &TypeRegistry,
    in_header: bool,
) {
    let entity_name = guess_entity_name::entity_name(world, type_registry, entity);

    let mut inner = |ui: &mut egui::Ui| {
        ui_for_entity_components(world, entity, ui, id, type_registry);

        let children = world
            .get::<Children>(entity)
            .map(|children| children.iter().copied().collect::<Vec<_>>());
        if let Some(children) = children {
            if !children.is_empty() {
                ui.label("Children");
                for &child in children.iter() {
                    let id = id.with(child);
                    ui_for_entity_inner(world, child, ui, id, type_registry, true);
                }
            }
        }
    };

    if in_header {
        egui::CollapsingHeader::new(entity_name)
            .id_source(id)
            .show(ui, |ui| {
                inner(ui);
            });
    } else {
        ui.label(entity_name);
        inner(ui);
    }
}

/// Display the components of the given entity
fn ui_for_entity_components(
    world: &mut World,
    entity: Entity,
    ui: &mut egui::Ui,
    id: egui::Id,
    type_registry: &TypeRegistry,
) {
    let entity_ref = match world.get_entity(entity) {
        Some(entity) => entity,
        None => {
            errors::entity_does_not_exist(ui, entity);
            return;
        }
    };
    let components = components_of_entity(entity_ref, world);

    for (name, component_id, component_type_id, size) in components {
        let id = id.with(component_id);
        egui::CollapsingHeader::new(&name)
            .id_source(id)
            .show(ui, |ui| {
                if size == 0 {
                    return;
                }
                let Some(component_type_id) = component_type_id else {
                    return errors::error_message_no_type_id(ui, &name);
                };

                // create a context with access to the world except for the currently viewed component
                let mut world = RestrictedWorldView::new(world);
                let (mut component_view, world) =
                    world.split_off_component((entity, component_type_id));
                let mut cx = Context { world: Some(world) };

                let (value, set_changed) = match component_view.get_entity_component_reflect(
                    entity,
                    component_type_id,
                    type_registry,
                ) {
                    Ok(value) => value,
                    Err(e) => return show_error(e, ui, &name),
                };

                let changed = InspectorUi::for_bevy(type_registry, &mut cx)
                    .ui_for_reflect_with_options(value, ui, id.with(component_id), &());

                if changed {
                    set_changed();
                }
            });
    }
}

fn components_of_entity(
    entity_ref: EntityRef,
    world: &World,
) -> Vec<(String, ComponentId, Option<TypeId>, usize)> {
    let archetype = entity_ref.archetype();
    let mut components: Vec<_> = archetype
        .components()
        .map(|component_id| {
            let info = world.components().get_info(component_id).unwrap();
            let name = pretty_type_name::pretty_type_name_str(info.name());

            (name, component_id, info.type_id(), info.layout().size())
        })
        .collect();
    components.sort_by(|(name_a, ..), (name_b, ..)| name_a.cmp(name_b));
    components
}

/// Display the given entity with all its components and children
pub fn ui_for_entities_shared_components(
    world: &mut World,
    entities: &[Entity],
    ui: &mut egui::Ui,
) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let Some(&first) = entities.first() else { return };

    let Some(entity_ref) = world.get_entity(first) else {
        return errors::entity_does_not_exist(ui, first);
    };

    let mut components = components_of_entity(entity_ref, world);

    for &entity in entities.iter().skip(1) {
        components.retain(|(_, id, _, _)| {
            world
                .get_entity(entity)
                .map_or(true, |entity| entity.contains_id(*id))
        })
    }

    let (resources_view, components_view) = RestrictedWorldView::resources_components(world);
    let mut cx = Context {
        world: Some(resources_view),
    };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);

    let id = egui::Id::null();
    for (name, component_id, component_type_id, size) in components {
        let id = id.with(component_id);
        egui::CollapsingHeader::new(&name)
            .id_source(id)
            .show(ui, |ui| {
                if size == 0 {
                    return;
                }
                let Some(component_type_id) = component_type_id else {
                    return errors::error_message_no_type_id(ui, &name);
                };

                let mut values = Vec::with_capacity(entities.len());
                let mut mark_changeds = Vec::with_capacity(entities.len());

                for (i, &entity) in entities.iter().enumerate() {
                    // skip duplicate entities
                    if entities[0..i].contains(&entity) {
                        continue;
                    };

                    // SAFETY: entities are distinct, env has a context with just resources
                    match unsafe {
                        components_view.get_entity_component_reflect_unchecked(
                            entity,
                            component_type_id,
                            &type_registry,
                        )
                    } {
                        Ok((value, mark_changed)) => {
                            values.push(value);
                            mark_changeds.push(mark_changed);
                        }
                        Err(error) => {
                            errors::show_error(error, ui, &name);
                            return;
                        }
                    }
                }

                let changed = env.ui_for_reflect_many_with_options(
                    component_type_id,
                    &name,
                    ui,
                    id.with(component_id),
                    &(),
                    values.as_mut_slice(),
                    &|a| a,
                );
                if changed {
                    mark_changeds.into_iter().for_each(|f| f());
                }
            });
    }
}

pub mod by_type_id {
    use std::any::TypeId;

    use bevy_asset::{HandleUntyped, ReflectAsset, ReflectHandle};
    use bevy_ecs::prelude::*;
    use bevy_reflect::TypeRegistry;

    use crate::{
        egui_reflect_inspector::{Context, InspectorUi},
        restricted_world_view::RestrictedWorldView,
    };

    use super::errors::{self, name_of_type};

    /// Display the resource with the given [`TypeId`]
    pub fn ui_for_resource(
        world: &mut World,
        resource_type_id: TypeId,
        ui: &mut egui::Ui,
        name_of_type: &str,
        type_registry: &TypeRegistry,
    ) {
        // create a context with access to the world except for the current resource
        let mut world = RestrictedWorldView::new(world);
        let (mut resource_view, world) = world.split_off_resource(resource_type_id);
        let mut cx = Context { world: Some(world) };
        let mut env = InspectorUi::for_bevy(type_registry, &mut cx);

        let (resource, set_changed) =
            match resource_view.get_resource_reflect_mut_by_id(resource_type_id, type_registry) {
                Ok(resource) => resource,
                Err(err) => return errors::show_error(err, ui, name_of_type),
            };

        let changed = env.ui_for_reflect(resource, ui);
        if changed {
            set_changed();
        }
    }

pub fn ui_for_reflect_readonly(&mut self, value: &dyn Reflect, ui: &mut Ui)

Draws the inspector UI for the given value in a read-only way.

Examples found in repository

src/egui_reflect_inspector/mod.rs (line 105)

pub fn ui_for_reflect_readonly_no_context(
    value: &mut dyn Reflect,
    ui: &mut egui::Ui,
    type_registry: &TypeRegistry,
) {
    let mut context = Context::default();
    InspectorUi::new_no_short_circuit(type_registry, &mut context)
        .ui_for_reflect_readonly(value, ui);
}

pub fn ui_for_reflect_with_options(
    &mut self,
    value: &mut dyn Reflect,
    ui: &mut Ui,
    id: Id,
    options: &dyn Any
) -> bool

Draws the inspector UI for the given value with some options.

The options can be InspectorOptions for structs or enums with nested options for their fields, or other structs like NumberOptions which are interpreted by leaf types like f32 or Vec3,

Examples found in repository

src/egui_reflect_inspector/mod.rs (line 180)

    pub fn ui_for_reflect(&mut self, value: &mut dyn Reflect, ui: &mut egui::Ui) -> bool {
        self.ui_for_reflect_with_options(value, ui, egui::Id::null(), &())
    }

    /// Draws the inspector UI for the given value in a read-only way.
    pub fn ui_for_reflect_readonly(&mut self, value: &dyn Reflect, ui: &mut egui::Ui) {
        self.ui_for_reflect_readonly_with_options(value, ui, egui::Id::null(), &());
    }

    /// Draws the inspector UI for the given value with some options.
    ///
    /// The options can be [`struct@InspectorOptions`] for structs or enums with nested options for their fields,
    /// or other structs like [`NumberOptions`](crate::inspector_options::std_options::NumberOptions) which are interpreted
    /// by leaf types like `f32` or `Vec3`,
    pub fn ui_for_reflect_with_options(
        &mut self,
        value: &mut dyn Reflect,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        let mut options = options;
        if options.is::<()>() {
            if let Some(data) = self
                .type_registry
                .get_type_data::<ReflectInspectorOptions>(Any::type_id(value))
            {
                options = &data.0;
            }
        }

        if let Some(s) = self
            .type_registry
            .get_type_data::<InspectorEguiImpl>(Any::type_id(value))
        {
            return s.execute(value.as_any_mut(), ui, options, self.reborrow());
        }

        if let Some(changed) = (self.short_circuit)(self, value, ui, id, options) {
            return changed;
        }

        match value.reflect_mut() {
            bevy_reflect::ReflectMut::Struct(value) => self.ui_for_struct(value, ui, id, options),
            bevy_reflect::ReflectMut::TupleStruct(value) => {
                self.ui_for_tuple_struct(value, ui, id, options)
            }
            bevy_reflect::ReflectMut::Tuple(value) => self.ui_for_tuple(value, ui, id, options),
            bevy_reflect::ReflectMut::List(value) => self.ui_for_list(value, ui, id, options),
            bevy_reflect::ReflectMut::Array(value) => self.ui_for_array(value, ui, id, options),
            bevy_reflect::ReflectMut::Map(value) => self.ui_for_reflect_map(value, ui, id, options),
            bevy_reflect::ReflectMut::Enum(value) => self.ui_for_enum(value, ui, id, options),
            bevy_reflect::ReflectMut::Value(value) => self.ui_for_value(value, ui, id, options),
        }
    }

    /// Draws the inspector UI for the given value with some options in a read-only way.
    ///
    /// The options can be [`struct@InspectorOptions`] for structs or enums with nested options for their fields,
    /// or other structs like [`NumberOptions`](crate::inspector_options::std_options::NumberOptions) which are interpreted
    /// by leaf types like `f32` or `Vec3`,
    pub fn ui_for_reflect_readonly_with_options(
        &mut self,
        value: &dyn Reflect,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        let mut options = options;
        if options.is::<()>() {
            if let Some(data) = self
                .type_registry
                .get_type_data::<ReflectInspectorOptions>(Any::type_id(value))
            {
                options = &data.0;
            }
        }

        if let Some(s) = self
            .type_registry
            .get_type_data::<InspectorEguiImpl>(Any::type_id(value))
        {
            s.execute_readonly(value.as_any(), ui, options, self.reborrow());
            return;
        }

        if let Some(()) = (self.short_circuit_readonly)(self, value, ui, id, options) {
            return;
        }

        match value.reflect_ref() {
            bevy_reflect::ReflectRef::Struct(value) => {
                self.ui_for_struct_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::TupleStruct(value) => {
                self.ui_for_tuple_struct_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Tuple(value) => {
                self.ui_for_tuple_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::List(value) => {
                self.ui_for_list_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Array(value) => {
                self.ui_for_array_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Map(value) => {
                self.ui_for_reflect_map_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Enum(value) => {
                self.ui_for_enum_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Value(value) => {
                self.ui_for_value_readonly(value, ui, id, options)
            }
        }
    }

    pub fn ui_for_reflect_many_with_options(
        &mut self,
        type_id: TypeId,
        name: &str,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: &dyn Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        let Some(registration) = self.type_registry.get(type_id) else {
            error_message_not_in_type_registry(ui, name);
            return false;
        };
        let info = registration.type_info();

        let mut options = options;
        if options.is::<()>() {
            if let Some(data) = self
                .type_registry
                .get_type_data::<ReflectInspectorOptions>(type_id)
            {
                options = &data.0;
            }
        }

        if let Some(s) = self
            .type_registry
            .get_type_data::<InspectorEguiImpl>(type_id)
        {
            return s.execute_many(ui, options, self.reborrow(), values, projector);
        }

        if let Some(changed) =
            (self.short_circuit_many)(self, type_id, name, ui, id, options, values, projector)
        {
            return changed;
        }

        match info {
            TypeInfo::Struct(info) => {
                self.ui_for_struct_many(info, ui, id, options, values, projector)
            }
            TypeInfo::TupleStruct(info) => {
                self.ui_for_tuple_struct_many(info, ui, id, options, values, projector)
            }
            TypeInfo::Tuple(info) => {
                self.ui_for_tuple_many(info, ui, id, options, values, projector)
            }
            TypeInfo::List(info) => self.ui_for_list_many(info, ui, id, options, values, projector),
            TypeInfo::Array(info) => {
                error_message_no_multiedit(
                    ui,
                    &pretty_type_name::pretty_type_name_str(info.type_name()),
                );
                false
            }
            TypeInfo::Map(info) => {
                error_message_no_multiedit(
                    ui,
                    &pretty_type_name::pretty_type_name_str(info.type_name()),
                );
                false
            }
            TypeInfo::Enum(info) => self.ui_for_enum_many(info, ui, id, options, values, projector),
            TypeInfo::Value(info) => self.ui_for_value_many(info, ui, id, options),
            TypeInfo::Dynamic(_) => {
                error_message_no_multiedit(
                    ui,
                    &pretty_type_name::pretty_type_name_str(info.type_name()),
                );
                false
            }
        }
    }
}

impl InspectorUi<'_, '_> {
    fn ui_for_struct(
        &mut self,
        value: &mut dyn Struct,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        maybe_grid(value.field_len(), ui, id, |ui, label| {
            (0..value.field_len())
                .map(|i| {
                    if label {
                        ui.label(value.name_at(i).unwrap());
                    }
                    let field = value.field_at_mut(i).unwrap();
                    let changed = self.ui_for_reflect_with_options(
                        field,
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_struct_readonly(
        &mut self,
        value: &dyn Struct,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        maybe_grid_readonly(value.field_len(), ui, id, |ui, label| {
            for i in 0..value.field_len() {
                if label {
                    ui.label(value.name_at(i).unwrap());
                }
                let field = value.field_at(i).unwrap();
                self.ui_for_reflect_readonly_with_options(
                    field,
                    ui,
                    id.with(i),
                    inspector_options_struct_field(options, i),
                );
                ui.end_row();
            }
        })
    }

    fn ui_for_struct_many(
        &mut self,
        info: &StructInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        maybe_grid(info.field_len(), ui, id, |ui, label| {
            info.iter()
                .enumerate()
                .map(|(i, field)| {
                    if label {
                        ui.label(field.name());
                    }
                    let changed = self.ui_for_reflect_many_with_options(
                        field.type_id(),
                        field.type_name(),
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                        values,
                        &|a| match projector(a).reflect_mut() {
                            bevy_reflect::ReflectMut::Struct(strukt) => {
                                strukt.field_at_mut(i).unwrap()
                            }
                            _ => unreachable!(),
                        },
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple_struct(
        &mut self,
        value: &mut dyn TupleStruct,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        maybe_grid(value.field_len(), ui, id, |ui, label| {
            (0..value.field_len())
                .map(|i| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let field = value.field_mut(i).unwrap();
                    let changed = self.ui_for_reflect_with_options(
                        field,
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple_struct_readonly(
        &mut self,
        value: &dyn TupleStruct,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        maybe_grid_readonly(value.field_len(), ui, id, |ui, label| {
            for i in 0..value.field_len() {
                if label {
                    ui.label(i.to_string());
                }
                let field = value.field(i).unwrap();
                self.ui_for_reflect_readonly_with_options(
                    field,
                    ui,
                    id.with(i),
                    inspector_options_struct_field(options, i),
                );
                ui.end_row();
            }
        })
    }

    fn ui_for_tuple_struct_many(
        &mut self,
        info: &TupleStructInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        maybe_grid(info.field_len(), ui, id, |ui, label| {
            info.iter()
                .enumerate()
                .map(|(i, field)| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let changed = self.ui_for_reflect_many_with_options(
                        field.type_id(),
                        field.type_name(),
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                        values,
                        &|a| match projector(a).reflect_mut() {
                            bevy_reflect::ReflectMut::TupleStruct(strukt) => {
                                strukt.field_mut(i).unwrap()
                            }
                            _ => unreachable!(),
                        },
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple(
        &mut self,
        value: &mut dyn Tuple,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        maybe_grid(value.field_len(), ui, id, |ui, label| {
            (0..value.field_len())
                .map(|i| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let field = value.field_mut(i).unwrap();
                    let changed = self.ui_for_reflect_with_options(
                        field,
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple_readonly(
        &mut self,
        value: &dyn Tuple,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        maybe_grid_readonly(value.field_len(), ui, id, |ui, label| {
            for i in 0..value.field_len() {
                if label {
                    ui.label(i.to_string());
                }
                let field = value.field(i).unwrap();
                self.ui_for_reflect_readonly_with_options(
                    field,
                    ui,
                    id.with(i),
                    inspector_options_struct_field(options, i),
                );
                ui.end_row();
            }
        });
    }

    fn ui_for_tuple_many(
        &mut self,
        info: &TupleInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        maybe_grid(info.field_len(), ui, id, |ui, label| {
            info.iter()
                .enumerate()
                .map(|(i, field)| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let changed = self.ui_for_reflect_many_with_options(
                        field.type_id(),
                        field.type_name(),
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                        values,
                        &|a| match projector(a).reflect_mut() {
                            bevy_reflect::ReflectMut::Tuple(strukt) => strukt.field_mut(i).unwrap(),
                            _ => unreachable!(),
                        },
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_list(
        &mut self,
        list: &mut dyn List,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        let mut changed = false;

        ui.vertical(|ui| {
            // let mut to_delete = None;

            let len = list.len();
            for i in 0..len {
                let val = list.get_mut(i).unwrap();
                ui.horizontal(|ui| {
                    /*if utils::ui::label_button(ui, "✖", egui::Color32::RED) {
                        to_delete = Some(i);
                    }*/
                    changed |= self.ui_for_reflect_with_options(val, ui, id.with(i), options);
                });

                if i != len - 1 {
                    ui.separator();
                }
            }

            if len > 0 {
                ui.vertical_centered_justified(|ui| {
                    if ui.button("+").clicked() {
                        let last_element = list.get(len - 1).unwrap().clone_value();
                        list.push(last_element);

                        changed = true;
                    }
                });
            }

            /*if let Some(_) = to_delete {
                changed = true;
            }*/
        });

        changed
    }

    fn ui_for_list_readonly(
        &mut self,
        list: &dyn List,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        ui.vertical(|ui| {
            let len = list.len();
            for i in 0..len {
                let val = list.get(i).unwrap();
                ui.horizontal(|ui| {
                    self.ui_for_reflect_readonly_with_options(val, ui, id.with(i), options)
                });

                if i != len - 1 {
                    ui.separator();
                }
            }
        });
    }

    fn ui_for_list_many(
        &mut self,
        info: &ListInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        let mut changed = false;

        let add_button = |ui: &mut egui::Ui, values: &mut [&mut dyn Reflect]| {
            ui.vertical_centered_justified(|ui| {
                if ui.button("+").clicked() {
                    for list in values.iter_mut() {
                        let list = match projector(*list).reflect_mut() {
                            bevy_reflect::ReflectMut::List(list) => list,
                            _ => unreachable!(),
                        };
                        let last_element = list.get(list.len() - 1).unwrap().clone_value();
                        list.push(last_element);
                    }
                    true
                } else {
                    false
                }
            })
            .inner
        };

        let same_len =
            iter_all_eq(
                values
                    .iter_mut()
                    .map(|value| match projector(*value).reflect_mut() {
                        bevy_reflect::ReflectMut::List(l) => l.len(),
                        _ => unreachable!(),
                    }),
            );

        match same_len {
            Some(len) => {
                ui.vertical(|ui| {
                    // let mut to_delete = None;

                    for i in 0..len {
                        let mut items_at_i: Vec<&mut dyn Reflect> = values
                            .iter_mut()
                            .map(|value| match projector(*value).reflect_mut() {
                                bevy_reflect::ReflectMut::List(list) => list.get_mut(i).unwrap(),
                                _ => unreachable!(),
                            })
                            .collect();

                        ui.horizontal(|ui| {
                            changed |= self.ui_for_reflect_many_with_options(
                                info.item_type_id(),
                                info.item_type_name(),
                                ui,
                                id.with(i),
                                options,
                                items_at_i.as_mut_slice(),
                                &|a| a,
                            );

                            /*if utils::ui::label_button(ui, "✖", egui::Color32::RED) {
                                to_delete = Some(i);
                            }*/
                        });

                        if i != len - 1 {
                            ui.separator();
                        }
                    }

                    if len > 0 {
                        add_button(ui, values);
                    }

                    /*if let Some(_) = to_delete {
                        changed = true;
                    }*/
                });
            }
            None => {
                ui.label("lists have different sizes, cannot multiedit");
            }
        }

        changed
    }

    fn ui_for_reflect_map(
        &mut self,
        map: &mut dyn Map,
        ui: &mut egui::Ui,
        id: egui::Id,
        _options: &dyn Any,
    ) -> bool {
        let changed = false;
        egui::Grid::new(id).show(ui, |ui| {
            for (i, (key, value)) in map.iter().enumerate() {
                self.ui_for_reflect_readonly_with_options(key, ui, id.with(i), &());
                // TODO: iterate over values mutably
                self.ui_for_reflect_readonly_with_options(value, ui, id.with(i), &());
                ui.end_row();
            }
        });

        changed
    }

    fn ui_for_reflect_map_readonly(
        &mut self,
        map: &dyn Map,
        ui: &mut egui::Ui,
        id: egui::Id,
        _options: &dyn Any,
    ) {
        egui::Grid::new(id).show(ui, |ui| {
            for (i, (key, value)) in map.iter().enumerate() {
                self.ui_for_reflect_readonly_with_options(key, ui, id.with(i), &());
                self.ui_for_reflect_readonly_with_options(value, ui, id.with(i), &());
                ui.end_row();
            }
        });
    }

    fn ui_for_array(
        &mut self,
        _value: &mut dyn Array,
        ui: &mut egui::Ui,
        _id: egui::Id,
        _options: &dyn Any,
    ) -> bool {
        ui.label("Array not yet implemented");
        false
    }

    fn ui_for_array_readonly(
        &mut self,
        _value: &dyn Array,
        ui: &mut egui::Ui,
        _id: egui::Id,
        _options: &dyn Any,
    ) {
        ui.label("Array not yet implemented");
    }

    fn ui_for_enum(
        &mut self,
        value: &mut dyn Enum,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        let type_info = value.get_type_info();
        let type_info = match type_info {
            TypeInfo::Enum(info) => info,
            _ => unreachable!("invalid reflect impl: type info mismatch"),
        };

        let mut changed = false;

        ui.vertical(|ui| {
            let changed_variant =
                self.ui_for_enum_variant_select(id, ui, value.variant_index(), type_info);
            if let Some((_new_variant, dynamic_enum)) = changed_variant {
                changed = true;
                value.apply(&dynamic_enum);
            }
            let variant_idx = value.variant_index();

            let always_show_label = matches!(value.variant_type(), VariantType::Struct);
            changed |= maybe_grid_always_show_label(
                value.field_len(),
                ui,
                id,
                always_show_label,
                |ui, label| {
                    (0..value.field_len())
                        .map(|i| {
                            if label {
                                if let Some(name) = value.name_at(i) {
                                    ui.label(name);
                                } else {
                                    ui.label(i.to_string());
                                }
                            }
                            let field_value = value
                                .field_at_mut(i)
                                .expect("invalid reflect impl: field len");
                            let changed = self.ui_for_reflect_with_options(
                                field_value,
                                ui,
                                id.with(i),
                                inspector_options_enum_variant_field(
                                    options,
                                    type_info.variant_names()[variant_idx].into(),
                                    i,
                                ),
                            );
                            ui.end_row();
                            changed
                        })
                        .fold(false, or)
                },
            );
        });

        changed
    }

src/inspector_egui_impls/std_impls.rs (line 239)

pub fn duration_ui(
    value: &mut dyn Any,
    ui: &mut egui::Ui,
    _: &dyn Any,
    mut env: InspectorUi<'_, '_>,
) -> bool {
    let value = value.downcast_mut::<Duration>().unwrap();
    let mut seconds = value.as_secs_f64();
    let options = NumberOptions {
        min: Some(0.0f64),
        suffix: "s".to_string(),
        ..Default::default()
    };

    let changed = env.ui_for_reflect_with_options(&mut seconds, ui, egui::Id::new(0), &options);
    if changed {
        *value = Duration::from_secs_f64(seconds);
    }
    changed
}

src/bevy_inspector/mod.rs (line 164)

pub fn ui_for_assets<A: Asset + Reflect>(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    // create a context with access to the world except for the `R` resource
    let Some((mut assets, world)) = RestrictedWorldView::new(world).split_off_resource_typed::<Assets<A>>() else {
        errors::resource_does_not_exist(ui, &pretty_type_name::<Assets<A>>());
        return;
    };
    let mut cx = Context { world: Some(world) };

    for (handle_id, asset) in assets.iter_mut() {
        let id = egui::Id::new(handle_id);

        egui::CollapsingHeader::new(format!("Handle({id:?})"))
            .id_source(id)
            .show(ui, |ui| {
                let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);
                env.ui_for_reflect_with_options(asset, ui, id, &());
            });
    }
}

/// Display state `T` and change state on edit
pub fn ui_for_state<T: StateData + Reflect>(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    // create a context with access to the world except for the `State<T>` resource
    let Some((mut state, world)) = RestrictedWorldView::new(world).split_off_resource_typed::<State<T>>() else {
        errors::state_does_not_exist(ui, &pretty_type_name::<T>());
        return;
    };
    let mut cx = Context { world: Some(world) };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);

    let mut current = state.current().clone();

    let changed = env.ui_for_reflect(&mut current, ui);
    if changed {
        if let Err(e) = state.set(current) {
            ui.label(format!("{e:?}"));
        }
    }
}

/// Display all entities and their components
pub fn ui_for_world_entities(world: &mut World, ui: &mut egui::Ui) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let mut root_entities = world.query_filtered::<Entity, Without<Parent>>();
    let mut entities = root_entities.iter(world).collect::<Vec<_>>();
    entities.sort();

    let id = egui::Id::new("world ui");
    for entity in entities {
        ui_for_entity_inner(world, entity, ui, id.with(entity), &type_registry, true);
    }
}

/// Display the given entity with all its components and children
pub fn ui_for_entity(world: &mut World, entity: Entity, ui: &mut egui::Ui, in_header: bool) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    ui_for_entity_inner(
        world,
        entity,
        ui,
        egui::Id::new(entity),
        &type_registry,
        in_header,
    )
}

fn ui_for_entity_inner(
    world: &mut World,
    entity: Entity,
    ui: &mut egui::Ui,
    id: egui::Id,
    type_registry: &TypeRegistry,
    in_header: bool,
) {
    let entity_name = guess_entity_name::entity_name(world, type_registry, entity);

    let mut inner = |ui: &mut egui::Ui| {
        ui_for_entity_components(world, entity, ui, id, type_registry);

        let children = world
            .get::<Children>(entity)
            .map(|children| children.iter().copied().collect::<Vec<_>>());
        if let Some(children) = children {
            if !children.is_empty() {
                ui.label("Children");
                for &child in children.iter() {
                    let id = id.with(child);
                    ui_for_entity_inner(world, child, ui, id, type_registry, true);
                }
            }
        }
    };

    if in_header {
        egui::CollapsingHeader::new(entity_name)
            .id_source(id)
            .show(ui, |ui| {
                inner(ui);
            });
    } else {
        ui.label(entity_name);
        inner(ui);
    }
}

/// Display the components of the given entity
fn ui_for_entity_components(
    world: &mut World,
    entity: Entity,
    ui: &mut egui::Ui,
    id: egui::Id,
    type_registry: &TypeRegistry,
) {
    let entity_ref = match world.get_entity(entity) {
        Some(entity) => entity,
        None => {
            errors::entity_does_not_exist(ui, entity);
            return;
        }
    };
    let components = components_of_entity(entity_ref, world);

    for (name, component_id, component_type_id, size) in components {
        let id = id.with(component_id);
        egui::CollapsingHeader::new(&name)
            .id_source(id)
            .show(ui, |ui| {
                if size == 0 {
                    return;
                }
                let Some(component_type_id) = component_type_id else {
                    return errors::error_message_no_type_id(ui, &name);
                };

                // create a context with access to the world except for the currently viewed component
                let mut world = RestrictedWorldView::new(world);
                let (mut component_view, world) =
                    world.split_off_component((entity, component_type_id));
                let mut cx = Context { world: Some(world) };

                let (value, set_changed) = match component_view.get_entity_component_reflect(
                    entity,
                    component_type_id,
                    type_registry,
                ) {
                    Ok(value) => value,
                    Err(e) => return show_error(e, ui, &name),
                };

                let changed = InspectorUi::for_bevy(type_registry, &mut cx)
                    .ui_for_reflect_with_options(value, ui, id.with(component_id), &());

                if changed {
                    set_changed();
                }
            });
    }
}

fn components_of_entity(
    entity_ref: EntityRef,
    world: &World,
) -> Vec<(String, ComponentId, Option<TypeId>, usize)> {
    let archetype = entity_ref.archetype();
    let mut components: Vec<_> = archetype
        .components()
        .map(|component_id| {
            let info = world.components().get_info(component_id).unwrap();
            let name = pretty_type_name::pretty_type_name_str(info.name());

            (name, component_id, info.type_id(), info.layout().size())
        })
        .collect();
    components.sort_by(|(name_a, ..), (name_b, ..)| name_a.cmp(name_b));
    components
}

/// Display the given entity with all its components and children
pub fn ui_for_entities_shared_components(
    world: &mut World,
    entities: &[Entity],
    ui: &mut egui::Ui,
) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let Some(&first) = entities.first() else { return };

    let Some(entity_ref) = world.get_entity(first) else {
        return errors::entity_does_not_exist(ui, first);
    };

    let mut components = components_of_entity(entity_ref, world);

    for &entity in entities.iter().skip(1) {
        components.retain(|(_, id, _, _)| {
            world
                .get_entity(entity)
                .map_or(true, |entity| entity.contains_id(*id))
        })
    }

    let (resources_view, components_view) = RestrictedWorldView::resources_components(world);
    let mut cx = Context {
        world: Some(resources_view),
    };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);

    let id = egui::Id::null();
    for (name, component_id, component_type_id, size) in components {
        let id = id.with(component_id);
        egui::CollapsingHeader::new(&name)
            .id_source(id)
            .show(ui, |ui| {
                if size == 0 {
                    return;
                }
                let Some(component_type_id) = component_type_id else {
                    return errors::error_message_no_type_id(ui, &name);
                };

                let mut values = Vec::with_capacity(entities.len());
                let mut mark_changeds = Vec::with_capacity(entities.len());

                for (i, &entity) in entities.iter().enumerate() {
                    // skip duplicate entities
                    if entities[0..i].contains(&entity) {
                        continue;
                    };

                    // SAFETY: entities are distinct, env has a context with just resources
                    match unsafe {
                        components_view.get_entity_component_reflect_unchecked(
                            entity,
                            component_type_id,
                            &type_registry,
                        )
                    } {
                        Ok((value, mark_changed)) => {
                            values.push(value);
                            mark_changeds.push(mark_changed);
                        }
                        Err(error) => {
                            errors::show_error(error, ui, &name);
                            return;
                        }
                    }
                }

                let changed = env.ui_for_reflect_many_with_options(
                    component_type_id,
                    &name,
                    ui,
                    id.with(component_id),
                    &(),
                    values.as_mut_slice(),
                    &|a| a,
                );
                if changed {
                    mark_changeds.into_iter().for_each(|f| f());
                }
            });
    }
}

pub mod by_type_id {
    use std::any::TypeId;

    use bevy_asset::{HandleUntyped, ReflectAsset, ReflectHandle};
    use bevy_ecs::prelude::*;
    use bevy_reflect::TypeRegistry;

    use crate::{
        egui_reflect_inspector::{Context, InspectorUi},
        restricted_world_view::RestrictedWorldView,
    };

    use super::errors::{self, name_of_type};

    /// Display the resource with the given [`TypeId`]
    pub fn ui_for_resource(
        world: &mut World,
        resource_type_id: TypeId,
        ui: &mut egui::Ui,
        name_of_type: &str,
        type_registry: &TypeRegistry,
    ) {
        // create a context with access to the world except for the current resource
        let mut world = RestrictedWorldView::new(world);
        let (mut resource_view, world) = world.split_off_resource(resource_type_id);
        let mut cx = Context { world: Some(world) };
        let mut env = InspectorUi::for_bevy(type_registry, &mut cx);

        let (resource, set_changed) =
            match resource_view.get_resource_reflect_mut_by_id(resource_type_id, type_registry) {
                Ok(resource) => resource,
                Err(err) => return errors::show_error(err, ui, name_of_type),
            };

        let changed = env.ui_for_reflect(resource, ui);
        if changed {
            set_changed();
        }
    }

    /// Display all assets of the given asset [`TypeId`]
    pub fn ui_for_assets(
        world: &mut World,
        asset_type_id: TypeId,
        ui: &mut egui::Ui,
        type_registry: &TypeRegistry,
    ) {
        let Some(registration) = type_registry.get(asset_type_id) else {
        return crate::egui_reflect_inspector::errors::error_message_not_in_type_registry(ui, &name_of_type(asset_type_id, type_registry));
    };
        let Some(reflect_asset) = registration.data::<ReflectAsset>() else {
        return errors::no_type_data(ui, &name_of_type(asset_type_id, type_registry), "ReflectAsset");
    };
        let Some(reflect_handle) = type_registry.get_type_data::<ReflectHandle>(reflect_asset.handle_type_id()) else {
        return errors::no_type_data(ui, &name_of_type(reflect_asset.handle_type_id(), type_registry), "ReflectHandle");
    };

        let mut ids: Vec<_> = reflect_asset.ids(world).collect();
        ids.sort();

        // Create a context with access to the entire world. Displaying the `Handle<T>` will short circuit into
        // displaying the T with a world view excluding Assets<T>.
        let world = RestrictedWorldView::new(world);
        let mut cx = Context { world: Some(world) };

        for handle_id in ids {
            let id = egui::Id::new(handle_id);
            let mut handle = reflect_handle.typed(HandleUntyped::weak(handle_id));

            egui::CollapsingHeader::new(format!("Handle({id:?})"))
                .id_source(id)
                .show(ui, |ui| {
                    let mut env = InspectorUi::for_bevy(type_registry, &mut cx);
                    env.ui_for_reflect_with_options(&mut *handle, ui, id, &());
                });
        }
    }
}

impl<'a, 'c> InspectorUi<'a, 'c> {
    /// [`InspectorUi`] with short circuiting methods able to display `bevy_asset` [`Handle`](bevy_asset::Handle)s
    pub fn for_bevy(
        type_registry: &'a TypeRegistry,
        context: &'a mut Context<'c>,
    ) -> InspectorUi<'a, 'c> {
        InspectorUi::new(
            type_registry,
            context,
            Some(short_circuit::short_circuit),
            Some(short_circuit::short_circuit_readonly),
            Some(short_circuit::short_circuit_many),
        )
    }
}

/// Short circuiting methods for the [`InspectorUi`] to enable it to display [`Handle`](bevy_asset::Handle)s
pub mod short_circuit {
    use std::any::{Any, TypeId};

    use bevy_asset::ReflectAsset;
    use bevy_reflect::Reflect;

    use crate::egui_reflect_inspector::{Context, InspectorUi};

    use super::errors::{self, name_of_type};

    pub fn short_circuit(
        env: &mut InspectorUi,
        value: &mut dyn Reflect,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> Option<bool> {
        if let Some(reflect_handle) = env
            .type_registry
            .get_type_data::<bevy_asset::ReflectHandle>(Any::type_id(value))
        {
            let handle = reflect_handle
                .downcast_handle_untyped(value.as_any())
                .unwrap();
            let handle_id = handle.id;
            let Some(reflect_asset) = env
            .type_registry
            .get_type_data::<ReflectAsset>(reflect_handle.asset_type_id())
            else {
                errors::no_type_data(ui, &name_of_type(reflect_handle.asset_type_id(), env.type_registry), "ReflectAsset");
                return Some(false);
            };

            let Some(world) = &mut env.context.world else {
                errors::no_world_in_context(ui, value.type_name());
                return Some(false);
            };

            let (assets_view, world) =
                world.split_off_resource(reflect_asset.assets_resource_type_id());

            let asset_value = {
                // SAFETY: the following code only accesses a resources it has access to, `Assets<T>`
                // The world borrow is then immediately discarded and not live while the other part of the world is continued to be used
                let interior_mutable_world = unsafe { assets_view.get() };
                assert!(
                    assets_view.allows_access_to_resource(reflect_asset.assets_resource_type_id())
                );
                let asset_value =
                // SAFETY: the world allows mutable access to `Assets<T>`
                unsafe { reflect_asset.get_unchecked_mut(interior_mutable_world, handle) };
                match asset_value {
                    Some(value) => value,
                    None => {
                        errors::dead_asset_handle(ui, handle_id);
                        return Some(false);
                    }
                }
            };

            let mut restricted_env = InspectorUi {
                type_registry: env.type_registry,
                context: &mut Context { world: Some(world) },
                short_circuit: env.short_circuit,
                short_circuit_readonly: env.short_circuit_readonly,
                short_circuit_many: env.short_circuit_many,
            };
            return Some(restricted_env.ui_for_reflect_with_options(
                asset_value,
                ui,
                id.with("asset"),
                options,
            ));
        }

        None
    }

pub fn ui_for_reflect_readonly_with_options(
    &mut self,
    value: &dyn Reflect,
    ui: &mut Ui,
    id: Id,
    options: &dyn Any
)

Draws the inspector UI for the given value with some options in a read-only way.

The options can be InspectorOptions for structs or enums with nested options for their fields, or other structs like NumberOptions which are interpreted by leaf types like f32 or Vec3,

Examples found in repository

src/egui_reflect_inspector/mod.rs (line 185)

    pub fn ui_for_reflect_readonly(&mut self, value: &dyn Reflect, ui: &mut egui::Ui) {
        self.ui_for_reflect_readonly_with_options(value, ui, egui::Id::null(), &());
    }

    /// Draws the inspector UI for the given value with some options.
    ///
    /// The options can be [`struct@InspectorOptions`] for structs or enums with nested options for their fields,
    /// or other structs like [`NumberOptions`](crate::inspector_options::std_options::NumberOptions) which are interpreted
    /// by leaf types like `f32` or `Vec3`,
    pub fn ui_for_reflect_with_options(
        &mut self,
        value: &mut dyn Reflect,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        let mut options = options;
        if options.is::<()>() {
            if let Some(data) = self
                .type_registry
                .get_type_data::<ReflectInspectorOptions>(Any::type_id(value))
            {
                options = &data.0;
            }
        }

        if let Some(s) = self
            .type_registry
            .get_type_data::<InspectorEguiImpl>(Any::type_id(value))
        {
            return s.execute(value.as_any_mut(), ui, options, self.reborrow());
        }

        if let Some(changed) = (self.short_circuit)(self, value, ui, id, options) {
            return changed;
        }

        match value.reflect_mut() {
            bevy_reflect::ReflectMut::Struct(value) => self.ui_for_struct(value, ui, id, options),
            bevy_reflect::ReflectMut::TupleStruct(value) => {
                self.ui_for_tuple_struct(value, ui, id, options)
            }
            bevy_reflect::ReflectMut::Tuple(value) => self.ui_for_tuple(value, ui, id, options),
            bevy_reflect::ReflectMut::List(value) => self.ui_for_list(value, ui, id, options),
            bevy_reflect::ReflectMut::Array(value) => self.ui_for_array(value, ui, id, options),
            bevy_reflect::ReflectMut::Map(value) => self.ui_for_reflect_map(value, ui, id, options),
            bevy_reflect::ReflectMut::Enum(value) => self.ui_for_enum(value, ui, id, options),
            bevy_reflect::ReflectMut::Value(value) => self.ui_for_value(value, ui, id, options),
        }
    }

    /// Draws the inspector UI for the given value with some options in a read-only way.
    ///
    /// The options can be [`struct@InspectorOptions`] for structs or enums with nested options for their fields,
    /// or other structs like [`NumberOptions`](crate::inspector_options::std_options::NumberOptions) which are interpreted
    /// by leaf types like `f32` or `Vec3`,
    pub fn ui_for_reflect_readonly_with_options(
        &mut self,
        value: &dyn Reflect,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        let mut options = options;
        if options.is::<()>() {
            if let Some(data) = self
                .type_registry
                .get_type_data::<ReflectInspectorOptions>(Any::type_id(value))
            {
                options = &data.0;
            }
        }

        if let Some(s) = self
            .type_registry
            .get_type_data::<InspectorEguiImpl>(Any::type_id(value))
        {
            s.execute_readonly(value.as_any(), ui, options, self.reborrow());
            return;
        }

        if let Some(()) = (self.short_circuit_readonly)(self, value, ui, id, options) {
            return;
        }

        match value.reflect_ref() {
            bevy_reflect::ReflectRef::Struct(value) => {
                self.ui_for_struct_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::TupleStruct(value) => {
                self.ui_for_tuple_struct_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Tuple(value) => {
                self.ui_for_tuple_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::List(value) => {
                self.ui_for_list_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Array(value) => {
                self.ui_for_array_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Map(value) => {
                self.ui_for_reflect_map_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Enum(value) => {
                self.ui_for_enum_readonly(value, ui, id, options)
            }
            bevy_reflect::ReflectRef::Value(value) => {
                self.ui_for_value_readonly(value, ui, id, options)
            }
        }
    }

    pub fn ui_for_reflect_many_with_options(
        &mut self,
        type_id: TypeId,
        name: &str,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: &dyn Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        let Some(registration) = self.type_registry.get(type_id) else {
            error_message_not_in_type_registry(ui, name);
            return false;
        };
        let info = registration.type_info();

        let mut options = options;
        if options.is::<()>() {
            if let Some(data) = self
                .type_registry
                .get_type_data::<ReflectInspectorOptions>(type_id)
            {
                options = &data.0;
            }
        }

        if let Some(s) = self
            .type_registry
            .get_type_data::<InspectorEguiImpl>(type_id)
        {
            return s.execute_many(ui, options, self.reborrow(), values, projector);
        }

        if let Some(changed) =
            (self.short_circuit_many)(self, type_id, name, ui, id, options, values, projector)
        {
            return changed;
        }

        match info {
            TypeInfo::Struct(info) => {
                self.ui_for_struct_many(info, ui, id, options, values, projector)
            }
            TypeInfo::TupleStruct(info) => {
                self.ui_for_tuple_struct_many(info, ui, id, options, values, projector)
            }
            TypeInfo::Tuple(info) => {
                self.ui_for_tuple_many(info, ui, id, options, values, projector)
            }
            TypeInfo::List(info) => self.ui_for_list_many(info, ui, id, options, values, projector),
            TypeInfo::Array(info) => {
                error_message_no_multiedit(
                    ui,
                    &pretty_type_name::pretty_type_name_str(info.type_name()),
                );
                false
            }
            TypeInfo::Map(info) => {
                error_message_no_multiedit(
                    ui,
                    &pretty_type_name::pretty_type_name_str(info.type_name()),
                );
                false
            }
            TypeInfo::Enum(info) => self.ui_for_enum_many(info, ui, id, options, values, projector),
            TypeInfo::Value(info) => self.ui_for_value_many(info, ui, id, options),
            TypeInfo::Dynamic(_) => {
                error_message_no_multiedit(
                    ui,
                    &pretty_type_name::pretty_type_name_str(info.type_name()),
                );
                false
            }
        }
    }
}

impl InspectorUi<'_, '_> {
    fn ui_for_struct(
        &mut self,
        value: &mut dyn Struct,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        maybe_grid(value.field_len(), ui, id, |ui, label| {
            (0..value.field_len())
                .map(|i| {
                    if label {
                        ui.label(value.name_at(i).unwrap());
                    }
                    let field = value.field_at_mut(i).unwrap();
                    let changed = self.ui_for_reflect_with_options(
                        field,
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_struct_readonly(
        &mut self,
        value: &dyn Struct,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        maybe_grid_readonly(value.field_len(), ui, id, |ui, label| {
            for i in 0..value.field_len() {
                if label {
                    ui.label(value.name_at(i).unwrap());
                }
                let field = value.field_at(i).unwrap();
                self.ui_for_reflect_readonly_with_options(
                    field,
                    ui,
                    id.with(i),
                    inspector_options_struct_field(options, i),
                );
                ui.end_row();
            }
        })
    }

    fn ui_for_struct_many(
        &mut self,
        info: &StructInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        maybe_grid(info.field_len(), ui, id, |ui, label| {
            info.iter()
                .enumerate()
                .map(|(i, field)| {
                    if label {
                        ui.label(field.name());
                    }
                    let changed = self.ui_for_reflect_many_with_options(
                        field.type_id(),
                        field.type_name(),
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                        values,
                        &|a| match projector(a).reflect_mut() {
                            bevy_reflect::ReflectMut::Struct(strukt) => {
                                strukt.field_at_mut(i).unwrap()
                            }
                            _ => unreachable!(),
                        },
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple_struct(
        &mut self,
        value: &mut dyn TupleStruct,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        maybe_grid(value.field_len(), ui, id, |ui, label| {
            (0..value.field_len())
                .map(|i| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let field = value.field_mut(i).unwrap();
                    let changed = self.ui_for_reflect_with_options(
                        field,
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple_struct_readonly(
        &mut self,
        value: &dyn TupleStruct,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        maybe_grid_readonly(value.field_len(), ui, id, |ui, label| {
            for i in 0..value.field_len() {
                if label {
                    ui.label(i.to_string());
                }
                let field = value.field(i).unwrap();
                self.ui_for_reflect_readonly_with_options(
                    field,
                    ui,
                    id.with(i),
                    inspector_options_struct_field(options, i),
                );
                ui.end_row();
            }
        })
    }

    fn ui_for_tuple_struct_many(
        &mut self,
        info: &TupleStructInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        maybe_grid(info.field_len(), ui, id, |ui, label| {
            info.iter()
                .enumerate()
                .map(|(i, field)| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let changed = self.ui_for_reflect_many_with_options(
                        field.type_id(),
                        field.type_name(),
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                        values,
                        &|a| match projector(a).reflect_mut() {
                            bevy_reflect::ReflectMut::TupleStruct(strukt) => {
                                strukt.field_mut(i).unwrap()
                            }
                            _ => unreachable!(),
                        },
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple(
        &mut self,
        value: &mut dyn Tuple,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        maybe_grid(value.field_len(), ui, id, |ui, label| {
            (0..value.field_len())
                .map(|i| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let field = value.field_mut(i).unwrap();
                    let changed = self.ui_for_reflect_with_options(
                        field,
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple_readonly(
        &mut self,
        value: &dyn Tuple,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        maybe_grid_readonly(value.field_len(), ui, id, |ui, label| {
            for i in 0..value.field_len() {
                if label {
                    ui.label(i.to_string());
                }
                let field = value.field(i).unwrap();
                self.ui_for_reflect_readonly_with_options(
                    field,
                    ui,
                    id.with(i),
                    inspector_options_struct_field(options, i),
                );
                ui.end_row();
            }
        });
    }

    fn ui_for_tuple_many(
        &mut self,
        info: &TupleInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        maybe_grid(info.field_len(), ui, id, |ui, label| {
            info.iter()
                .enumerate()
                .map(|(i, field)| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let changed = self.ui_for_reflect_many_with_options(
                        field.type_id(),
                        field.type_name(),
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                        values,
                        &|a| match projector(a).reflect_mut() {
                            bevy_reflect::ReflectMut::Tuple(strukt) => strukt.field_mut(i).unwrap(),
                            _ => unreachable!(),
                        },
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_list(
        &mut self,
        list: &mut dyn List,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        let mut changed = false;

        ui.vertical(|ui| {
            // let mut to_delete = None;

            let len = list.len();
            for i in 0..len {
                let val = list.get_mut(i).unwrap();
                ui.horizontal(|ui| {
                    /*if utils::ui::label_button(ui, "✖", egui::Color32::RED) {
                        to_delete = Some(i);
                    }*/
                    changed |= self.ui_for_reflect_with_options(val, ui, id.with(i), options);
                });

                if i != len - 1 {
                    ui.separator();
                }
            }

            if len > 0 {
                ui.vertical_centered_justified(|ui| {
                    if ui.button("+").clicked() {
                        let last_element = list.get(len - 1).unwrap().clone_value();
                        list.push(last_element);

                        changed = true;
                    }
                });
            }

            /*if let Some(_) = to_delete {
                changed = true;
            }*/
        });

        changed
    }

    fn ui_for_list_readonly(
        &mut self,
        list: &dyn List,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        ui.vertical(|ui| {
            let len = list.len();
            for i in 0..len {
                let val = list.get(i).unwrap();
                ui.horizontal(|ui| {
                    self.ui_for_reflect_readonly_with_options(val, ui, id.with(i), options)
                });

                if i != len - 1 {
                    ui.separator();
                }
            }
        });
    }

    fn ui_for_list_many(
        &mut self,
        info: &ListInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        let mut changed = false;

        let add_button = |ui: &mut egui::Ui, values: &mut [&mut dyn Reflect]| {
            ui.vertical_centered_justified(|ui| {
                if ui.button("+").clicked() {
                    for list in values.iter_mut() {
                        let list = match projector(*list).reflect_mut() {
                            bevy_reflect::ReflectMut::List(list) => list,
                            _ => unreachable!(),
                        };
                        let last_element = list.get(list.len() - 1).unwrap().clone_value();
                        list.push(last_element);
                    }
                    true
                } else {
                    false
                }
            })
            .inner
        };

        let same_len =
            iter_all_eq(
                values
                    .iter_mut()
                    .map(|value| match projector(*value).reflect_mut() {
                        bevy_reflect::ReflectMut::List(l) => l.len(),
                        _ => unreachable!(),
                    }),
            );

        match same_len {
            Some(len) => {
                ui.vertical(|ui| {
                    // let mut to_delete = None;

                    for i in 0..len {
                        let mut items_at_i: Vec<&mut dyn Reflect> = values
                            .iter_mut()
                            .map(|value| match projector(*value).reflect_mut() {
                                bevy_reflect::ReflectMut::List(list) => list.get_mut(i).unwrap(),
                                _ => unreachable!(),
                            })
                            .collect();

                        ui.horizontal(|ui| {
                            changed |= self.ui_for_reflect_many_with_options(
                                info.item_type_id(),
                                info.item_type_name(),
                                ui,
                                id.with(i),
                                options,
                                items_at_i.as_mut_slice(),
                                &|a| a,
                            );

                            /*if utils::ui::label_button(ui, "✖", egui::Color32::RED) {
                                to_delete = Some(i);
                            }*/
                        });

                        if i != len - 1 {
                            ui.separator();
                        }
                    }

                    if len > 0 {
                        add_button(ui, values);
                    }

                    /*if let Some(_) = to_delete {
                        changed = true;
                    }*/
                });
            }
            None => {
                ui.label("lists have different sizes, cannot multiedit");
            }
        }

        changed
    }

    fn ui_for_reflect_map(
        &mut self,
        map: &mut dyn Map,
        ui: &mut egui::Ui,
        id: egui::Id,
        _options: &dyn Any,
    ) -> bool {
        let changed = false;
        egui::Grid::new(id).show(ui, |ui| {
            for (i, (key, value)) in map.iter().enumerate() {
                self.ui_for_reflect_readonly_with_options(key, ui, id.with(i), &());
                // TODO: iterate over values mutably
                self.ui_for_reflect_readonly_with_options(value, ui, id.with(i), &());
                ui.end_row();
            }
        });

        changed
    }

    fn ui_for_reflect_map_readonly(
        &mut self,
        map: &dyn Map,
        ui: &mut egui::Ui,
        id: egui::Id,
        _options: &dyn Any,
    ) {
        egui::Grid::new(id).show(ui, |ui| {
            for (i, (key, value)) in map.iter().enumerate() {
                self.ui_for_reflect_readonly_with_options(key, ui, id.with(i), &());
                self.ui_for_reflect_readonly_with_options(value, ui, id.with(i), &());
                ui.end_row();
            }
        });
    }

    fn ui_for_array(
        &mut self,
        _value: &mut dyn Array,
        ui: &mut egui::Ui,
        _id: egui::Id,
        _options: &dyn Any,
    ) -> bool {
        ui.label("Array not yet implemented");
        false
    }

    fn ui_for_array_readonly(
        &mut self,
        _value: &dyn Array,
        ui: &mut egui::Ui,
        _id: egui::Id,
        _options: &dyn Any,
    ) {
        ui.label("Array not yet implemented");
    }

    fn ui_for_enum(
        &mut self,
        value: &mut dyn Enum,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        let type_info = value.get_type_info();
        let type_info = match type_info {
            TypeInfo::Enum(info) => info,
            _ => unreachable!("invalid reflect impl: type info mismatch"),
        };

        let mut changed = false;

        ui.vertical(|ui| {
            let changed_variant =
                self.ui_for_enum_variant_select(id, ui, value.variant_index(), type_info);
            if let Some((_new_variant, dynamic_enum)) = changed_variant {
                changed = true;
                value.apply(&dynamic_enum);
            }
            let variant_idx = value.variant_index();

            let always_show_label = matches!(value.variant_type(), VariantType::Struct);
            changed |= maybe_grid_always_show_label(
                value.field_len(),
                ui,
                id,
                always_show_label,
                |ui, label| {
                    (0..value.field_len())
                        .map(|i| {
                            if label {
                                if let Some(name) = value.name_at(i) {
                                    ui.label(name);
                                } else {
                                    ui.label(i.to_string());
                                }
                            }
                            let field_value = value
                                .field_at_mut(i)
                                .expect("invalid reflect impl: field len");
                            let changed = self.ui_for_reflect_with_options(
                                field_value,
                                ui,
                                id.with(i),
                                inspector_options_enum_variant_field(
                                    options,
                                    type_info.variant_names()[variant_idx].into(),
                                    i,
                                ),
                            );
                            ui.end_row();
                            changed
                        })
                        .fold(false, or)
                },
            );
        });

        changed
    }

    fn ui_for_enum_many(
        &mut self,
        info: &EnumInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        let mut changed = false;

        let same_variant =
            iter_all_eq(
                values
                    .iter_mut()
                    .map(|value| match projector(*value).reflect_mut() {
                        bevy_reflect::ReflectMut::Enum(info) => info.variant_index(),
                        _ => unreachable!(),
                    }),
            );

        if let Some(variant_idx) = same_variant {
            let mut variant = info.variant_at(variant_idx).unwrap();

            ui.vertical(|ui| {
                let variant_changed = self.ui_for_enum_variant_select(id, ui, variant_idx, info);
                if let Some((new_variant_idx, dynamic_enum)) = variant_changed {
                    changed = true;
                    variant = info.variant_at(new_variant_idx).unwrap();

                    for value in values.iter_mut() {
                        let value = projector(*value);
                        value.apply(&dynamic_enum);
                    }
                }

                let field_len = match variant {
                    VariantInfo::Struct(info) => info.field_len(),
                    VariantInfo::Tuple(info) => info.field_len(),
                    VariantInfo::Unit(_) => 0,
                };

                let always_show_label = matches!(variant, VariantInfo::Struct(_));
                changed |= maybe_grid_always_show_label(
                    field_len,
                    ui,
                    id,
                    always_show_label,
                    |ui, label| {
                        let handle = |(field_index, field_name, field_type_id, field_type_name)| {
                            if label {
                                ui.label(field_name);
                            }

                            let mut variants_across: Vec<&mut dyn Reflect> = values
                                .iter_mut()
                                .map(|value| match projector(*value).reflect_mut() {
                                    bevy_reflect::ReflectMut::Enum(value) => {
                                        value.field_at_mut(field_index).unwrap()
                                    }
                                    _ => unreachable!(),
                                })
                                .collect();

                            self.ui_for_reflect_many_with_options(
                                field_type_id,
                                field_type_name,
                                ui,
                                id.with(field_index),
                                inspector_options_enum_variant_field(
                                    options,
                                    variant.name().into(),
                                    field_index,
                                ),
                                variants_across.as_mut_slice(),
                                &|a| a,
                            );

                            ui.end_row();

                            false
                        };

                        match variant {
                            VariantInfo::Struct(info) => info
                                .iter()
                                .enumerate()
                                .map(|(i, field)| {
                                    (
                                        i,
                                        Cow::Borrowed(field.name()),
                                        field.type_id(),
                                        field.type_name(),
                                    )
                                })
                                .map(handle)
                                .fold(false, or),
                            VariantInfo::Tuple(info) => info
                                .iter()
                                .enumerate()
                                .map(|(i, field)| {
                                    (
                                        i,
                                        Cow::Owned(i.to_string()),
                                        field.type_id(),
                                        field.type_name(),
                                    )
                                })
                                .map(handle)
                                .fold(false, or),
                            VariantInfo::Unit(_) => false,
                        }
                    },
                );
            });
        } else {
            ui.label("enums have different selected variants, cannot multiedit");
        }

        changed
    }

    fn ui_for_enum_variant_select(
        &mut self,
        id: egui::Id,
        ui: &mut egui::Ui,
        active_variant_idx: usize,
        info: &bevy_reflect::EnumInfo,
    ) -> Option<(usize, DynamicEnum)> {
        let mut changed_variant = None;

        ui.horizontal(|ui| {
            let mut unconstructable_variants = Vec::new();
            egui::ComboBox::new(id.with("select"), "")
                .selected_text(info.variant_names()[active_variant_idx])
                .show_ui(ui, |ui| {
                    for (i, variant) in info.iter().enumerate() {
                        let variant_name = variant.name();
                        let is_active_variant = i == active_variant_idx;

                        let variant_is_constructable =
                            is_variant_constructable(self.type_registry, variant);
                        if !variant_is_constructable && !is_active_variant {
                            unconstructable_variants.push(variant_name);
                        }
                        ui.add_enabled_ui(variant_is_constructable, |ui| {
                            if ui
                                .selectable_label(is_active_variant, variant_name)
                                .clicked()
                            {
                                if let Ok(dynamic_enum) =
                                    self.construct_default_variant(variant, ui, info.type_name())
                                {
                                    changed_variant = Some((i, dynamic_enum));
                                };
                            }
                        });
                    }

                    false
                });
            if !unconstructable_variants.is_empty() {
                errors::error_message_unconstructable_variants(
                    ui,
                    info.type_name(),
                    &unconstructable_variants,
                );
            }
        });

        changed_variant
    }

    fn ui_for_enum_readonly(
        &mut self,
        value: &dyn Enum,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        ui.vertical(|ui| {
            let active_variant = value.variant_name();
            ui.add_enabled_ui(false, |ui| {
                egui::ComboBox::new(id, "")
                    .selected_text(active_variant)
                    .show_ui(ui, |_| {})
            });

            maybe_grid_readonly(value.field_len(), ui, id, |ui, label| {
                for i in 0..value.field_len() {
                    if label {
                        if let Some(name) = value.name_at(i) {
                            ui.label(name);
                        } else {
                            ui.label(i.to_string());
                        }
                    }
                    let field_value = value.field_at(i).expect("invalid reflect impl: field len");
                    self.ui_for_reflect_readonly_with_options(
                        field_value,
                        ui,
                        id.with(i),
                        inspector_options_enum_variant_field(
                            options,
                            active_variant.to_owned().into(),
                            i,
                        ),
                    );
                    ui.end_row();
                }
            });
        });
    }

src/inspector_egui_impls/std_impls.rs (line 258)

pub fn duration_ui_readonly(
    value: &dyn Any,
    ui: &mut egui::Ui,
    _: &dyn Any,
    mut env: InspectorUi<'_, '_>,
) {
    let value = value.downcast_ref::<Duration>().unwrap();
    let seconds = value.as_secs_f64();
    let options = NumberOptions {
        min: Some(0.0f64),
        suffix: "s".to_string(),
        ..Default::default()
    };
    env.ui_for_reflect_readonly_with_options(&seconds, ui, egui::Id::new(0), &options);
}

src/bevy_inspector/mod.rs (lines 736-741)

    pub fn short_circuit_readonly(
        env: &mut InspectorUi,
        value: &dyn Reflect,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> Option<()> {
        if let Some(reflect_handle) = env
            .type_registry
            .get_type_data::<bevy_asset::ReflectHandle>(Any::type_id(value))
        {
            let handle = reflect_handle
                .downcast_handle_untyped(value.as_any())
                .unwrap();
            let handle_id = handle.id;
            let Some(reflect_asset) = env
            .type_registry
            .get_type_data::<ReflectAsset>(reflect_handle.asset_type_id())
            else {
                errors::no_type_data(ui, &name_of_type(reflect_handle.asset_type_id(), env.type_registry), "ReflectAsset");
                return Some(());
            };

            let Some(world) = &mut env.context.world else {
                errors::no_world_in_context(ui, value.type_name());
                return Some(());
            };

            let (assets_view, world) =
                world.split_off_resource(reflect_asset.assets_resource_type_id());

            let asset_value = {
                // SAFETY: the following code only accesses a resources it has access to, `Assets<T>`
                let interior_mutable_world = unsafe { assets_view.get() };
                assert!(
                    assets_view.allows_access_to_resource(reflect_asset.assets_resource_type_id())
                );
                let asset_value = reflect_asset.get(interior_mutable_world, handle);
                match asset_value {
                    Some(value) => value,
                    None => {
                        errors::dead_asset_handle(ui, handle_id);
                        return Some(());
                    }
                }
            };

            let mut restricted_env = InspectorUi {
                type_registry: env.type_registry,
                context: &mut Context { world: Some(world) },
                short_circuit: env.short_circuit,
                short_circuit_readonly: env.short_circuit_readonly,
                short_circuit_many: env.short_circuit_many,
            };
            restricted_env.ui_for_reflect_readonly_with_options(
                asset_value,
                ui,
                id.with("asset"),
                options,
            );
            return Some(());
        }

        None
    }

pub fn ui_for_reflect_many_with_options(
    &mut self,
    type_id: TypeId,
    name: &str,
    ui: &mut Ui,
    id: Id,
    options: &dyn Any,
    values: &mut [&mut dyn Reflect],
    projector: &dyn Fn(&mut dyn Reflect) -> &mut dyn Reflect
) -> bool

Examples found in repository

src/egui_reflect_inspector/mod.rs (lines 442-455)

    fn ui_for_struct_many(
        &mut self,
        info: &StructInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        maybe_grid(info.field_len(), ui, id, |ui, label| {
            info.iter()
                .enumerate()
                .map(|(i, field)| {
                    if label {
                        ui.label(field.name());
                    }
                    let changed = self.ui_for_reflect_many_with_options(
                        field.type_id(),
                        field.type_name(),
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                        values,
                        &|a| match projector(a).reflect_mut() {
                            bevy_reflect::ReflectMut::Struct(strukt) => {
                                strukt.field_at_mut(i).unwrap()
                            }
                            _ => unreachable!(),
                        },
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple_struct(
        &mut self,
        value: &mut dyn TupleStruct,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        maybe_grid(value.field_len(), ui, id, |ui, label| {
            (0..value.field_len())
                .map(|i| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let field = value.field_mut(i).unwrap();
                    let changed = self.ui_for_reflect_with_options(
                        field,
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple_struct_readonly(
        &mut self,
        value: &dyn TupleStruct,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        maybe_grid_readonly(value.field_len(), ui, id, |ui, label| {
            for i in 0..value.field_len() {
                if label {
                    ui.label(i.to_string());
                }
                let field = value.field(i).unwrap();
                self.ui_for_reflect_readonly_with_options(
                    field,
                    ui,
                    id.with(i),
                    inspector_options_struct_field(options, i),
                );
                ui.end_row();
            }
        })
    }

    fn ui_for_tuple_struct_many(
        &mut self,
        info: &TupleStructInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        maybe_grid(info.field_len(), ui, id, |ui, label| {
            info.iter()
                .enumerate()
                .map(|(i, field)| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let changed = self.ui_for_reflect_many_with_options(
                        field.type_id(),
                        field.type_name(),
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                        values,
                        &|a| match projector(a).reflect_mut() {
                            bevy_reflect::ReflectMut::TupleStruct(strukt) => {
                                strukt.field_mut(i).unwrap()
                            }
                            _ => unreachable!(),
                        },
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple(
        &mut self,
        value: &mut dyn Tuple,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        maybe_grid(value.field_len(), ui, id, |ui, label| {
            (0..value.field_len())
                .map(|i| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let field = value.field_mut(i).unwrap();
                    let changed = self.ui_for_reflect_with_options(
                        field,
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_tuple_readonly(
        &mut self,
        value: &dyn Tuple,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        maybe_grid_readonly(value.field_len(), ui, id, |ui, label| {
            for i in 0..value.field_len() {
                if label {
                    ui.label(i.to_string());
                }
                let field = value.field(i).unwrap();
                self.ui_for_reflect_readonly_with_options(
                    field,
                    ui,
                    id.with(i),
                    inspector_options_struct_field(options, i),
                );
                ui.end_row();
            }
        });
    }

    fn ui_for_tuple_many(
        &mut self,
        info: &TupleInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        maybe_grid(info.field_len(), ui, id, |ui, label| {
            info.iter()
                .enumerate()
                .map(|(i, field)| {
                    if label {
                        ui.label(i.to_string());
                    }
                    let changed = self.ui_for_reflect_many_with_options(
                        field.type_id(),
                        field.type_name(),
                        ui,
                        id.with(i),
                        inspector_options_struct_field(options, i),
                        values,
                        &|a| match projector(a).reflect_mut() {
                            bevy_reflect::ReflectMut::Tuple(strukt) => strukt.field_mut(i).unwrap(),
                            _ => unreachable!(),
                        },
                    );
                    ui.end_row();
                    changed
                })
                .fold(false, or)
        })
    }

    fn ui_for_list(
        &mut self,
        list: &mut dyn List,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        let mut changed = false;

        ui.vertical(|ui| {
            // let mut to_delete = None;

            let len = list.len();
            for i in 0..len {
                let val = list.get_mut(i).unwrap();
                ui.horizontal(|ui| {
                    /*if utils::ui::label_button(ui, "✖", egui::Color32::RED) {
                        to_delete = Some(i);
                    }*/
                    changed |= self.ui_for_reflect_with_options(val, ui, id.with(i), options);
                });

                if i != len - 1 {
                    ui.separator();
                }
            }

            if len > 0 {
                ui.vertical_centered_justified(|ui| {
                    if ui.button("+").clicked() {
                        let last_element = list.get(len - 1).unwrap().clone_value();
                        list.push(last_element);

                        changed = true;
                    }
                });
            }

            /*if let Some(_) = to_delete {
                changed = true;
            }*/
        });

        changed
    }

    fn ui_for_list_readonly(
        &mut self,
        list: &dyn List,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) {
        ui.vertical(|ui| {
            let len = list.len();
            for i in 0..len {
                let val = list.get(i).unwrap();
                ui.horizontal(|ui| {
                    self.ui_for_reflect_readonly_with_options(val, ui, id.with(i), options)
                });

                if i != len - 1 {
                    ui.separator();
                }
            }
        });
    }

    fn ui_for_list_many(
        &mut self,
        info: &ListInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        let mut changed = false;

        let add_button = |ui: &mut egui::Ui, values: &mut [&mut dyn Reflect]| {
            ui.vertical_centered_justified(|ui| {
                if ui.button("+").clicked() {
                    for list in values.iter_mut() {
                        let list = match projector(*list).reflect_mut() {
                            bevy_reflect::ReflectMut::List(list) => list,
                            _ => unreachable!(),
                        };
                        let last_element = list.get(list.len() - 1).unwrap().clone_value();
                        list.push(last_element);
                    }
                    true
                } else {
                    false
                }
            })
            .inner
        };

        let same_len =
            iter_all_eq(
                values
                    .iter_mut()
                    .map(|value| match projector(*value).reflect_mut() {
                        bevy_reflect::ReflectMut::List(l) => l.len(),
                        _ => unreachable!(),
                    }),
            );

        match same_len {
            Some(len) => {
                ui.vertical(|ui| {
                    // let mut to_delete = None;

                    for i in 0..len {
                        let mut items_at_i: Vec<&mut dyn Reflect> = values
                            .iter_mut()
                            .map(|value| match projector(*value).reflect_mut() {
                                bevy_reflect::ReflectMut::List(list) => list.get_mut(i).unwrap(),
                                _ => unreachable!(),
                            })
                            .collect();

                        ui.horizontal(|ui| {
                            changed |= self.ui_for_reflect_many_with_options(
                                info.item_type_id(),
                                info.item_type_name(),
                                ui,
                                id.with(i),
                                options,
                                items_at_i.as_mut_slice(),
                                &|a| a,
                            );

                            /*if utils::ui::label_button(ui, "✖", egui::Color32::RED) {
                                to_delete = Some(i);
                            }*/
                        });

                        if i != len - 1 {
                            ui.separator();
                        }
                    }

                    if len > 0 {
                        add_button(ui, values);
                    }

                    /*if let Some(_) = to_delete {
                        changed = true;
                    }*/
                });
            }
            None => {
                ui.label("lists have different sizes, cannot multiedit");
            }
        }

        changed
    }

    fn ui_for_reflect_map(
        &mut self,
        map: &mut dyn Map,
        ui: &mut egui::Ui,
        id: egui::Id,
        _options: &dyn Any,
    ) -> bool {
        let changed = false;
        egui::Grid::new(id).show(ui, |ui| {
            for (i, (key, value)) in map.iter().enumerate() {
                self.ui_for_reflect_readonly_with_options(key, ui, id.with(i), &());
                // TODO: iterate over values mutably
                self.ui_for_reflect_readonly_with_options(value, ui, id.with(i), &());
                ui.end_row();
            }
        });

        changed
    }

    fn ui_for_reflect_map_readonly(
        &mut self,
        map: &dyn Map,
        ui: &mut egui::Ui,
        id: egui::Id,
        _options: &dyn Any,
    ) {
        egui::Grid::new(id).show(ui, |ui| {
            for (i, (key, value)) in map.iter().enumerate() {
                self.ui_for_reflect_readonly_with_options(key, ui, id.with(i), &());
                self.ui_for_reflect_readonly_with_options(value, ui, id.with(i), &());
                ui.end_row();
            }
        });
    }

    fn ui_for_array(
        &mut self,
        _value: &mut dyn Array,
        ui: &mut egui::Ui,
        _id: egui::Id,
        _options: &dyn Any,
    ) -> bool {
        ui.label("Array not yet implemented");
        false
    }

    fn ui_for_array_readonly(
        &mut self,
        _value: &dyn Array,
        ui: &mut egui::Ui,
        _id: egui::Id,
        _options: &dyn Any,
    ) {
        ui.label("Array not yet implemented");
    }

    fn ui_for_enum(
        &mut self,
        value: &mut dyn Enum,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> bool {
        let type_info = value.get_type_info();
        let type_info = match type_info {
            TypeInfo::Enum(info) => info,
            _ => unreachable!("invalid reflect impl: type info mismatch"),
        };

        let mut changed = false;

        ui.vertical(|ui| {
            let changed_variant =
                self.ui_for_enum_variant_select(id, ui, value.variant_index(), type_info);
            if let Some((_new_variant, dynamic_enum)) = changed_variant {
                changed = true;
                value.apply(&dynamic_enum);
            }
            let variant_idx = value.variant_index();

            let always_show_label = matches!(value.variant_type(), VariantType::Struct);
            changed |= maybe_grid_always_show_label(
                value.field_len(),
                ui,
                id,
                always_show_label,
                |ui, label| {
                    (0..value.field_len())
                        .map(|i| {
                            if label {
                                if let Some(name) = value.name_at(i) {
                                    ui.label(name);
                                } else {
                                    ui.label(i.to_string());
                                }
                            }
                            let field_value = value
                                .field_at_mut(i)
                                .expect("invalid reflect impl: field len");
                            let changed = self.ui_for_reflect_with_options(
                                field_value,
                                ui,
                                id.with(i),
                                inspector_options_enum_variant_field(
                                    options,
                                    type_info.variant_names()[variant_idx].into(),
                                    i,
                                ),
                            );
                            ui.end_row();
                            changed
                        })
                        .fold(false, or)
                },
            );
        });

        changed
    }

    fn ui_for_enum_many(
        &mut self,
        info: &EnumInfo,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: impl Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> bool {
        let mut changed = false;

        let same_variant =
            iter_all_eq(
                values
                    .iter_mut()
                    .map(|value| match projector(*value).reflect_mut() {
                        bevy_reflect::ReflectMut::Enum(info) => info.variant_index(),
                        _ => unreachable!(),
                    }),
            );

        if let Some(variant_idx) = same_variant {
            let mut variant = info.variant_at(variant_idx).unwrap();

            ui.vertical(|ui| {
                let variant_changed = self.ui_for_enum_variant_select(id, ui, variant_idx, info);
                if let Some((new_variant_idx, dynamic_enum)) = variant_changed {
                    changed = true;
                    variant = info.variant_at(new_variant_idx).unwrap();

                    for value in values.iter_mut() {
                        let value = projector(*value);
                        value.apply(&dynamic_enum);
                    }
                }

                let field_len = match variant {
                    VariantInfo::Struct(info) => info.field_len(),
                    VariantInfo::Tuple(info) => info.field_len(),
                    VariantInfo::Unit(_) => 0,
                };

                let always_show_label = matches!(variant, VariantInfo::Struct(_));
                changed |= maybe_grid_always_show_label(
                    field_len,
                    ui,
                    id,
                    always_show_label,
                    |ui, label| {
                        let handle = |(field_index, field_name, field_type_id, field_type_name)| {
                            if label {
                                ui.label(field_name);
                            }

                            let mut variants_across: Vec<&mut dyn Reflect> = values
                                .iter_mut()
                                .map(|value| match projector(*value).reflect_mut() {
                                    bevy_reflect::ReflectMut::Enum(value) => {
                                        value.field_at_mut(field_index).unwrap()
                                    }
                                    _ => unreachable!(),
                                })
                                .collect();

                            self.ui_for_reflect_many_with_options(
                                field_type_id,
                                field_type_name,
                                ui,
                                id.with(field_index),
                                inspector_options_enum_variant_field(
                                    options,
                                    variant.name().into(),
                                    field_index,
                                ),
                                variants_across.as_mut_slice(),
                                &|a| a,
                            );

                            ui.end_row();

                            false
                        };

                        match variant {
                            VariantInfo::Struct(info) => info
                                .iter()
                                .enumerate()
                                .map(|(i, field)| {
                                    (
                                        i,
                                        Cow::Borrowed(field.name()),
                                        field.type_id(),
                                        field.type_name(),
                                    )
                                })
                                .map(handle)
                                .fold(false, or),
                            VariantInfo::Tuple(info) => info
                                .iter()
                                .enumerate()
                                .map(|(i, field)| {
                                    (
                                        i,
                                        Cow::Owned(i.to_string()),
                                        field.type_id(),
                                        field.type_name(),
                                    )
                                })
                                .map(handle)
                                .fold(false, or),
                            VariantInfo::Unit(_) => false,
                        }
                    },
                );
            });
        } else {
            ui.label("enums have different selected variants, cannot multiedit");
        }

        changed
    }

src/bevy_inspector/mod.rs (lines 405-413)

pub fn ui_for_entities_shared_components(
    world: &mut World,
    entities: &[Entity],
    ui: &mut egui::Ui,
) {
    let type_registry = world.resource::<AppTypeRegistry>().0.clone();
    let type_registry = type_registry.read();

    let Some(&first) = entities.first() else { return };

    let Some(entity_ref) = world.get_entity(first) else {
        return errors::entity_does_not_exist(ui, first);
    };

    let mut components = components_of_entity(entity_ref, world);

    for &entity in entities.iter().skip(1) {
        components.retain(|(_, id, _, _)| {
            world
                .get_entity(entity)
                .map_or(true, |entity| entity.contains_id(*id))
        })
    }

    let (resources_view, components_view) = RestrictedWorldView::resources_components(world);
    let mut cx = Context {
        world: Some(resources_view),
    };
    let mut env = InspectorUi::for_bevy(&type_registry, &mut cx);

    let id = egui::Id::null();
    for (name, component_id, component_type_id, size) in components {
        let id = id.with(component_id);
        egui::CollapsingHeader::new(&name)
            .id_source(id)
            .show(ui, |ui| {
                if size == 0 {
                    return;
                }
                let Some(component_type_id) = component_type_id else {
                    return errors::error_message_no_type_id(ui, &name);
                };

                let mut values = Vec::with_capacity(entities.len());
                let mut mark_changeds = Vec::with_capacity(entities.len());

                for (i, &entity) in entities.iter().enumerate() {
                    // skip duplicate entities
                    if entities[0..i].contains(&entity) {
                        continue;
                    };

                    // SAFETY: entities are distinct, env has a context with just resources
                    match unsafe {
                        components_view.get_entity_component_reflect_unchecked(
                            entity,
                            component_type_id,
                            &type_registry,
                        )
                    } {
                        Ok((value, mark_changed)) => {
                            values.push(value);
                            mark_changeds.push(mark_changed);
                        }
                        Err(error) => {
                            errors::show_error(error, ui, &name);
                            return;
                        }
                    }
                }

                let changed = env.ui_for_reflect_many_with_options(
                    component_type_id,
                    &name,
                    ui,
                    id.with(component_id),
                    &(),
                    values.as_mut_slice(),
                    &|a| a,
                );
                if changed {
                    mark_changeds.into_iter().for_each(|f| f());
                }
            });
    }
}

pub mod by_type_id {
    use std::any::TypeId;

    use bevy_asset::{HandleUntyped, ReflectAsset, ReflectHandle};
    use bevy_ecs::prelude::*;
    use bevy_reflect::TypeRegistry;

    use crate::{
        egui_reflect_inspector::{Context, InspectorUi},
        restricted_world_view::RestrictedWorldView,
    };

    use super::errors::{self, name_of_type};

    /// Display the resource with the given [`TypeId`]
    pub fn ui_for_resource(
        world: &mut World,
        resource_type_id: TypeId,
        ui: &mut egui::Ui,
        name_of_type: &str,
        type_registry: &TypeRegistry,
    ) {
        // create a context with access to the world except for the current resource
        let mut world = RestrictedWorldView::new(world);
        let (mut resource_view, world) = world.split_off_resource(resource_type_id);
        let mut cx = Context { world: Some(world) };
        let mut env = InspectorUi::for_bevy(type_registry, &mut cx);

        let (resource, set_changed) =
            match resource_view.get_resource_reflect_mut_by_id(resource_type_id, type_registry) {
                Ok(resource) => resource,
                Err(err) => return errors::show_error(err, ui, name_of_type),
            };

        let changed = env.ui_for_reflect(resource, ui);
        if changed {
            set_changed();
        }
    }

    /// Display all assets of the given asset [`TypeId`]
    pub fn ui_for_assets(
        world: &mut World,
        asset_type_id: TypeId,
        ui: &mut egui::Ui,
        type_registry: &TypeRegistry,
    ) {
        let Some(registration) = type_registry.get(asset_type_id) else {
        return crate::egui_reflect_inspector::errors::error_message_not_in_type_registry(ui, &name_of_type(asset_type_id, type_registry));
    };
        let Some(reflect_asset) = registration.data::<ReflectAsset>() else {
        return errors::no_type_data(ui, &name_of_type(asset_type_id, type_registry), "ReflectAsset");
    };
        let Some(reflect_handle) = type_registry.get_type_data::<ReflectHandle>(reflect_asset.handle_type_id()) else {
        return errors::no_type_data(ui, &name_of_type(reflect_asset.handle_type_id(), type_registry), "ReflectHandle");
    };

        let mut ids: Vec<_> = reflect_asset.ids(world).collect();
        ids.sort();

        // Create a context with access to the entire world. Displaying the `Handle<T>` will short circuit into
        // displaying the T with a world view excluding Assets<T>.
        let world = RestrictedWorldView::new(world);
        let mut cx = Context { world: Some(world) };

        for handle_id in ids {
            let id = egui::Id::new(handle_id);
            let mut handle = reflect_handle.typed(HandleUntyped::weak(handle_id));

            egui::CollapsingHeader::new(format!("Handle({id:?})"))
                .id_source(id)
                .show(ui, |ui| {
                    let mut env = InspectorUi::for_bevy(type_registry, &mut cx);
                    env.ui_for_reflect_with_options(&mut *handle, ui, id, &());
                });
        }
    }
}

impl<'a, 'c> InspectorUi<'a, 'c> {
    /// [`InspectorUi`] with short circuiting methods able to display `bevy_asset` [`Handle`](bevy_asset::Handle)s
    pub fn for_bevy(
        type_registry: &'a TypeRegistry,
        context: &'a mut Context<'c>,
    ) -> InspectorUi<'a, 'c> {
        InspectorUi::new(
            type_registry,
            context,
            Some(short_circuit::short_circuit),
            Some(short_circuit::short_circuit_readonly),
            Some(short_circuit::short_circuit_many),
        )
    }
}

/// Short circuiting methods for the [`InspectorUi`] to enable it to display [`Handle`](bevy_asset::Handle)s
pub mod short_circuit {
    use std::any::{Any, TypeId};

    use bevy_asset::ReflectAsset;
    use bevy_reflect::Reflect;

    use crate::egui_reflect_inspector::{Context, InspectorUi};

    use super::errors::{self, name_of_type};

    pub fn short_circuit(
        env: &mut InspectorUi,
        value: &mut dyn Reflect,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
    ) -> Option<bool> {
        if let Some(reflect_handle) = env
            .type_registry
            .get_type_data::<bevy_asset::ReflectHandle>(Any::type_id(value))
        {
            let handle = reflect_handle
                .downcast_handle_untyped(value.as_any())
                .unwrap();
            let handle_id = handle.id;
            let Some(reflect_asset) = env
            .type_registry
            .get_type_data::<ReflectAsset>(reflect_handle.asset_type_id())
            else {
                errors::no_type_data(ui, &name_of_type(reflect_handle.asset_type_id(), env.type_registry), "ReflectAsset");
                return Some(false);
            };

            let Some(world) = &mut env.context.world else {
                errors::no_world_in_context(ui, value.type_name());
                return Some(false);
            };

            let (assets_view, world) =
                world.split_off_resource(reflect_asset.assets_resource_type_id());

            let asset_value = {
                // SAFETY: the following code only accesses a resources it has access to, `Assets<T>`
                // The world borrow is then immediately discarded and not live while the other part of the world is continued to be used
                let interior_mutable_world = unsafe { assets_view.get() };
                assert!(
                    assets_view.allows_access_to_resource(reflect_asset.assets_resource_type_id())
                );
                let asset_value =
                // SAFETY: the world allows mutable access to `Assets<T>`
                unsafe { reflect_asset.get_unchecked_mut(interior_mutable_world, handle) };
                match asset_value {
                    Some(value) => value,
                    None => {
                        errors::dead_asset_handle(ui, handle_id);
                        return Some(false);
                    }
                }
            };

            let mut restricted_env = InspectorUi {
                type_registry: env.type_registry,
                context: &mut Context { world: Some(world) },
                short_circuit: env.short_circuit,
                short_circuit_readonly: env.short_circuit_readonly,
                short_circuit_many: env.short_circuit_many,
            };
            return Some(restricted_env.ui_for_reflect_with_options(
                asset_value,
                ui,
                id.with("asset"),
                options,
            ));
        }

        None
    }

    pub fn short_circuit_many(
        env: &mut InspectorUi,
        type_id: TypeId,
        type_name: &str,
        ui: &mut egui::Ui,
        id: egui::Id,
        options: &dyn Any,
        values: &mut [&mut dyn Reflect],
        projector: &dyn Fn(&mut dyn Reflect) -> &mut dyn Reflect,
    ) -> Option<bool> {
        if let Some(reflect_handle) = env
            .type_registry
            .get_type_data::<bevy_asset::ReflectHandle>(type_id)
        {
            let Some(reflect_asset) = env
                .type_registry
                .get_type_data::<ReflectAsset>(reflect_handle.asset_type_id())
            else {
                errors::no_type_data(ui, &name_of_type(reflect_handle.asset_type_id(), env.type_registry), "ReflectAsset");
                return Some(false);
            };

            let Some(world) = &mut env.context.world else {
                errors::no_world_in_context(ui, type_name);
                return Some(false);
            };

            let (assets_view, world) =
                world.split_off_resource(reflect_asset.assets_resource_type_id());

            let mut new_values = Vec::with_capacity(values.len());
            let mut used_handles = Vec::with_capacity(values.len());

            for value in values {
                let handle = projector(*value);
                let handle = reflect_handle
                    .downcast_handle_untyped(handle.as_any())
                    .unwrap();
                let handle_id = handle.id;

                if used_handles.contains(&handle_id) {
                    continue;
                };
                used_handles.push(handle.id);

                let asset_value = {
                    // SAFETY: the following code only accesses a resources it has access to, `Assets<T>`
                    // The world borrow is then immediately discarded and not live while the other part of the world is continued to be used
                    let interior_mutable_world = unsafe { assets_view.get() };
                    assert!(assets_view
                        .allows_access_to_resource(reflect_asset.assets_resource_type_id()));
                    let asset_value =
                        // SAFETY: the world allows mutable access to `Assets<T>` 
                        unsafe { reflect_asset.get_unchecked_mut(interior_mutable_world, handle) };
                    match asset_value {
                        Some(value) => value,
                        None => {
                            errors::dead_asset_handle(ui, handle_id);
                            return Some(false);
                        }
                    }
                };

                new_values.push(asset_value);
            }

            let mut restricted_env = InspectorUi {
                type_registry: env.type_registry,
                context: &mut Context { world: Some(world) },
                short_circuit: env.short_circuit,
                short_circuit_readonly: env.short_circuit_readonly,
                short_circuit_many: env.short_circuit_many,
            };
            return Some(restricted_env.ui_for_reflect_many_with_options(
                reflect_handle.asset_type_id(),
                "",
                ui,
                id.with("asset"),
                options,
                new_values.as_mut_slice(),
                &|a| a,
            ));
        }

        None
    }