feat(engine): add world UI view

4 files changed, 1552 insertions, 0 deletions

diff --git a/engine/res/ui/delete.png b/engine/res/ui/delete.png
new file mode 100644
index 0000000..f85ba1c
--- /dev/null
+++ b/engine/res/ui/delete.png
diff --git a/engine/src/ui.rs b/engine/src/ui.rs
index 939c408..626c810 100644
--- a/engine/src/ui.rs
+++ b/engine/src/ui.rs
@@ -1 +1,2 @@
 pub mod dear_imgui;
+pub mod view;
diff --git a/engine/src/ui/view.rs b/engine/src/ui/view.rs
new file mode 100644
index 0000000..ed714d6
--- /dev/null
+++ b/engine/src/ui/view.rs
@@ -0,0 +1 @@
+pub mod world;
diff --git a/engine/src/ui/view/world.rs b/engine/src/ui/view/world.rs
new file mode 100644
index 0000000..9803328
--- /dev/null
+++ b/engine/src/ui/view/world.rs
@@ -0,0 +1,1550 @@
+use std::any::{Any, TypeId};
+use std::borrow::Cow;
+use std::io::Cursor;
+
+use crate::ecs::actions::Actions;
+use crate::ecs::component::local::Local;
+use crate::ecs::component::{Info as ComponentInfo, Parts as ComponentParts};
+use crate::ecs::entity::{Handle as EntityHandle, Name as EntityName};
+use crate::ecs::sole::Single;
+use crate::ecs::uid::Uid;
+use crate::ecs::util::Either;
+use crate::ecs::{Component, Query, World};
+use crate::image::{Format as ImageFormat, Image};
+use crate::reflection::{
+    Enum as EnumReflection,
+    LiteralType,
+    Type as TypeReflection,
+    Visibility,
+};
+use crate::ui::dear_imgui::{
+    bindings as dear_imgui_bindings,
+    Context as DearImguiContext,
+};
+
+const BUTTON_RED_NORMAL: [f32; 4] = [124.0, 52.0, 39.0, 255.0];
+const BUTTON_RED_HOVERED: [f32; 4] = [181.0, 76.0, 57.0, 255.0];
+const BUTTON_RED_ACTIVE: [f32; 4] = [162.0, 68.0, 51.0, 255.0];
+
+#[derive(Component)]
+pub struct State
+{
+    spawning_entity: Option<Uid>,
+    add_component_popup_state: Option<AddComponentPopupState>,
+    despawn_icon_tex: Option<dear_imgui_bindings::OwnedTextureData>,
+}
+
+impl Default for State
+{
+    fn default() -> Self
+    {
+        Self {
+            spawning_entity: None,
+            add_component_popup_state: None,
+            despawn_icon_tex: None,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct AddComponentPopupState
+{
+    popup_name: String,
+    target_entity_id: Uid,
+    search_text: String,
+    searched_components: Vec<(Uid, ComponentInfo, ComponentUserCreatable)>,
+    searchable_components: Vec<(Uid, ComponentInfo, ComponentUserCreatable)>,
+    selected_search_result: i32,
+    new_component: Option<(Box<dyn Any>, ComponentInfo, Uid)>,
+}
+
+pub fn show(
+    query: Query<()>,
+    mut dear_imgui_context: Single<DearImguiContext>,
+    mut state: Local<State>,
+    world: &World,
+    mut actions: Actions,
+) -> Result<(), crate::Error>
+{
+    let dear_imgui_context = dear_imgui_context.get_mut()?;
+
+    let State {
+        spawning_entity,
+        add_component_popup_state,
+        despawn_icon_tex,
+    } = &mut *state;
+
+    let despawn_icon_tex = despawn_icon_tex
+        .get_or_insert_with(|| create_despawn_icon_texture(dear_imgui_context));
+
+    let Some(frame) = dear_imgui_context.frame() else {
+        return Ok(());
+    };
+
+    frame
+        .window("World")
+        .size([600.0, 400.0], dear_imgui_bindings::Condition::Once)
+        .build(|| {
+            create_spawn_button_widgets(
+                frame,
+                spawning_entity,
+                add_component_popup_state,
+                world,
+                &mut actions,
+            );
+
+            frame.spacing();
+            frame.spacing();
+
+            for ent_handle in &query.into_flexible_query() {
+                create_entity_widgets(
+                    frame,
+                    add_component_popup_state,
+                    despawn_icon_tex,
+                    &ent_handle,
+                    world,
+                    &mut actions,
+                );
+            }
+
+            if let Some(popup_state) = add_component_popup_state {
+                if show_add_component_popup(frame, popup_state, &mut actions) {
+                    *add_component_popup_state = None;
+                }
+            }
+        });
+
+    Ok(())
+}
+
+fn create_despawn_icon_texture(
+    dear_imgui_context: &mut DearImguiContext,
+) -> dear_imgui_bindings::OwnedTextureData
+{
+    let despawn_icon_image = Image::from_reader(
+        Cursor::new(include_bytes!("../../../res/ui/delete.png")),
+        ImageFormat::Png,
+    )
+    .unwrap()
+    .into_rgba8();
+
+    let mut despawn_icon_tex = dear_imgui_bindings::OwnedTextureData::new();
+
+    despawn_icon_tex.create(
+        dear_imgui_bindings::TextureFormat::RGBA32,
+        despawn_icon_image.dimensions().width,
+        despawn_icon_image.dimensions().height,
+    );
+
+    despawn_icon_tex.set_data(despawn_icon_image.as_bytes());
+
+    despawn_icon_tex.set_status(dear_imgui_bindings::TextureStatus::WantCreate);
+
+    dear_imgui_context.register_texture(&mut despawn_icon_tex);
+
+    despawn_icon_tex
+}
+
+fn create_spawn_button_widgets(
+    frame: &dear_imgui_bindings::Ui,
+    spawning_entity: &mut Option<Uid>,
+    add_component_popup_state: &mut Option<AddComponentPopupState>,
+    world: &World,
+    actions: &mut Actions,
+)
+{
+    let _disabled_token = frame.begin_disabled_with_cond(spawning_entity.is_some());
+
+    if frame.button("Spawn") {
+        let new_ent_id = actions.spawn(());
+
+        *spawning_entity = Some(new_ent_id);
+    }
+
+    if let Some(spawning_ent) = &spawning_entity {
+        if let Some(spawned_ent) = world.get_entity(*spawning_ent) {
+            *spawning_entity = None;
+
+            let spawned_ent_title = create_entity_title(&spawned_ent);
+
+            enter_add_component_popup_state(
+                add_component_popup_state,
+                &spawned_ent,
+                &spawned_ent_title,
+                world,
+            );
+        }
+    }
+}
+
+fn create_entity_widgets(
+    frame: &dear_imgui_bindings::Ui,
+    add_component_popup_state: &mut Option<AddComponentPopupState>,
+    despawn_icon_tex: &mut dear_imgui_bindings::OwnedTextureData,
+    ent_handle: &EntityHandle,
+    world: &World,
+    actions: &mut Actions,
+)
+{
+    if ent_handle.component_ids().next().is_some()
+        && !ent_handle.component_ids().any(|comp_id| {
+            world.get_entity(comp_id).is_some_and(|comp_ent| {
+                comp_ent
+                    .get::<ComponentInfo>()
+                    .is_some_and(|comp_info| comp_info.type_reflection.is_some())
+            })
+        })
+    {
+        return;
+    }
+
+    let ent_title = create_entity_title(&ent_handle);
+
+    let mut is_open = false;
+
+    frame
+        .table(&format!("ent_{}_table", ent_handle.uid()))
+        .headers(false)
+        .sizing_policy(dear_imgui_bindings::TableSizingPolicy::FixedFit)
+        .columns([
+            dear_imgui_bindings::TableColumnSetup::new("a")
+                .fixed_width(frame.content_region_avail_width() * 0.8),
+            dear_imgui_bindings::TableColumnSetup::new("b"),
+            dear_imgui_bindings::TableColumnSetup::new("c"),
+        ])
+        .build(|frame| {
+            frame.table_next_row();
+
+            frame.table_next_column();
+
+            is_open = frame
+                .collapsing_header(&ent_title, dear_imgui_bindings::TreeNodeFlags::NONE);
+
+            frame.table_next_column();
+
+            create_add_component_button_widget(
+                frame,
+                &ent_handle,
+                &ent_title,
+                add_component_popup_state,
+                world,
+            );
+
+            frame.table_next_column();
+
+            create_despawn_button_widget(frame, despawn_icon_tex, ent_handle, actions);
+        });
+
+    if is_open {
+        for component_id in ent_handle.component_ids() {
+            create_component_widgets(frame, ent_handle, component_id, world, actions);
+        }
+    }
+}
+
+fn create_component_widgets(
+    frame: &dear_imgui_bindings::Ui,
+    ent_handle: &EntityHandle,
+    component_id: Uid,
+    world: &World,
+    actions: &mut Actions,
+)
+{
+    let Some(component_info) = world
+        .get_entity(component_id)
+        .and_then(|comp_ent| comp_ent.get::<ComponentInfo>())
+    else {
+        return;
+    };
+
+    let Some(component_type) = component_info.type_reflection else {
+        return;
+    };
+
+    let Some(mut component) = ent_handle.get_any_by_id_mut(component_id) else {
+        unreachable!();
+    };
+
+    {
+        let _color_token = frame.push_style_color(
+            dear_imgui_bindings::StyleColor::Button,
+            BUTTON_RED_NORMAL.map(|num| num / 255.0),
+        );
+
+        let _color_token_b = frame.push_style_color(
+            dear_imgui_bindings::StyleColor::ButtonHovered,
+            BUTTON_RED_HOVERED.map(|num| num / 255.0),
+        );
+
+        let _color_token_c = frame.push_style_color(
+            dear_imgui_bindings::StyleColor::ButtonActive,
+            BUTTON_RED_ACTIVE.map(|num| num / 255.0),
+        );
+
+        if frame.small_button(format!(
+            "X##world_view_entity_{}_remove_component_button_{}",
+            ent_handle.uid(),
+            component_info.name
+        )) {
+            actions.remove_components(ent_handle.uid(), [component_id]);
+        }
+    }
+
+    frame.same_line();
+
+    let mut component_changed = false;
+
+    add_item_to_frame(
+        frame,
+        ItemRef::Mutable(&mut *component),
+        &mut component_changed,
+        ItemInfo {
+            item_title: component_info.name,
+            item_tag: &format!(
+                "world_view_entity_{}_component_{}",
+                ent_handle.uid(),
+                component_info.name,
+            ),
+            item_type_name: None,
+            item_type: ItemType::Reflected(component_type),
+            item_is_read_only: false,
+        },
+        &[],
+    );
+
+    frame.spacing();
+
+    if component_changed {
+        component.set_changed();
+    }
+}
+
+fn create_add_component_button_widget(
+    frame: &dear_imgui_bindings::Ui,
+    ent_handle: &EntityHandle,
+    ent_title: &str,
+    add_component_popup_state: &mut Option<AddComponentPopupState>,
+    world: &World,
+)
+{
+    let _color_token = frame.push_style_color(
+        dear_imgui_bindings::StyleColor::Button,
+        [49.0, 89.0, 28.0, 255.0].map(|num| num / 255.0),
+    );
+
+    let _color_token_b = frame.push_style_color(
+        dear_imgui_bindings::StyleColor::ButtonHovered,
+        [100.0, 181.0, 57.0, 255.0].map(|num| num / 255.0),
+    );
+
+    let _color_token_c = frame.push_style_color(
+        dear_imgui_bindings::StyleColor::ButtonActive,
+        [90.0, 162.0, 51.0, 255.0].map(|num| num / 255.0),
+    );
+
+    let is_button_clicked = frame.button(format!(
+        "+##add_component_to_entity_button_{}",
+        ent_handle.uid()
+    ));
+
+    if add_component_popup_state
+        .as_ref()
+        .is_some_and(|add_component_popup_state| {
+            add_component_popup_state.target_entity_id != ent_handle.uid()
+        })
+    {
+        return;
+    }
+
+    if is_button_clicked {
+        enter_add_component_popup_state(
+            add_component_popup_state,
+            ent_handle,
+            ent_title,
+            world,
+        );
+    }
+}
+
+fn create_despawn_button_widget(
+    frame: &dear_imgui_bindings::Ui,
+    despawn_icon_tex: &mut dear_imgui_bindings::OwnedTextureData,
+    ent_handle: &EntityHandle,
+    actions: &mut Actions,
+)
+{
+    let _color_token = frame.push_style_color(
+        dear_imgui_bindings::StyleColor::Button,
+        BUTTON_RED_NORMAL.map(|num| num / 255.0),
+    );
+
+    let _color_token_b = frame.push_style_color(
+        dear_imgui_bindings::StyleColor::ButtonHovered,
+        BUTTON_RED_HOVERED.map(|num| num / 255.0),
+    );
+
+    let _color_token_c = frame.push_style_color(
+        dear_imgui_bindings::StyleColor::ButtonActive,
+        BUTTON_RED_ACTIVE.map(|num| num / 255.0),
+    );
+
+    if frame
+        .image_button_config(
+            &format!("ent_{}_despawn_button", ent_handle.uid()),
+            despawn_icon_tex.as_mut(),
+            [14.0, 14.0],
+        )
+        .build()
+    {
+        actions.despawn(ent_handle.uid());
+    }
+}
+
+fn enter_add_component_popup_state(
+    add_component_popup_state: &mut Option<AddComponentPopupState>,
+    ent_handle: &EntityHandle,
+    ent_title: &str,
+    world: &World,
+)
+{
+    let popup_name = format!("Add component to {ent_title}");
+
+    let mut searchable_components = world
+        .query::<(&ComponentInfo,), ()>()
+        .iter_with_euids()
+        .map(|(id, (component_info,))| {
+            let user_creatable = if component_info.type_reflection.is_none() {
+                ComponentUserCreatable::No { reason: "no type reflection" }
+            } else if component_info
+                .type_reflection
+                .is_some_and(|ty| !ty.has_default_value())
+            {
+                ComponentUserCreatable::No { reason: "no default value" }
+            } else if !get_whole_type_is_user_editable(
+                component_info.type_reflection,
+                component_info.ty_id,
+            ) {
+                ComponentUserCreatable::No {
+                    reason: "whole component is not user editable",
+                }
+            } else {
+                ComponentUserCreatable::Yes
+            };
+
+            (id, component_info.clone(), user_creatable)
+        })
+        .collect::<Vec<_>>();
+
+    searchable_components.sort_by_key(|(_, _, user_creatable)| *user_creatable);
+
+    *add_component_popup_state = Some(AddComponentPopupState {
+        popup_name: popup_name.clone(),
+        target_entity_id: ent_handle.uid(),
+        search_text: String::with_capacity(20),
+        searched_components: searchable_components.clone(),
+        searchable_components,
+        selected_search_result: -1,
+        new_component: None,
+    });
+}
+
+fn show_add_component_popup(
+    frame: &dear_imgui_bindings::Ui,
+    add_component_popup_state: &mut AddComponentPopupState,
+    actions: &mut Actions,
+) -> bool
+{
+    frame.open_popup(&add_component_popup_state.popup_name);
+
+    let mut is_opened = true;
+
+    let should_close = frame.modal_popup_with_opened(
+        &add_component_popup_state.popup_name,
+        &mut is_opened,
+        || {
+            frame.set_window_size([700.0, 600.0]);
+
+            frame.spacing();
+            frame.spacing();
+
+            frame.text("Search:");
+            frame.same_line();
+
+            if frame
+                .input_text(
+                    "##add_component_popup_search_input",
+                    &mut add_component_popup_state.search_text,
+                )
+                .build()
+            {
+                add_component_popup_state.searched_components = add_component_popup_state
+                    .searchable_components
+                    .iter()
+                    .cloned()
+                    .filter(|(_, searchable_comp_info, _)| {
+                        searchable_comp_info
+                            .name
+                            .contains(&add_component_popup_state.search_text)
+                    })
+                    .collect();
+
+                add_component_popup_state.selected_search_result = -1;
+            }
+
+            frame.spacing();
+            frame.spacing();
+
+            let _item_width_token = frame.push_item_width(-1.0);
+
+            if frame
+                .list_box_config("##add_component_popup_search_results")
+                .build_extended(
+                    frame,
+                    &mut add_component_popup_state.selected_search_result,
+                    &add_component_popup_state.searched_components,
+                    &|(_, comp_info, comp_user_creatable)| ListBoxItem {
+                        label: comp_info.name.into(),
+                        disabled: matches!(
+                            comp_user_creatable,
+                            ComponentUserCreatable::No { .. }
+                        ),
+                        hover_tooltip: match comp_user_creatable {
+                            ComponentUserCreatable::Yes => None,
+                            ComponentUserCreatable::No { reason } => Some(
+                                format!("Component cannot be selected: {reason}").into(),
+                            ),
+                        },
+                    },
+                )
+            {
+                let (selected_comp_id, selected_comp_info, _) = add_component_popup_state
+                    .searched_components
+                    [add_component_popup_state.selected_search_result as usize]
+                    .clone();
+
+                let Some(selected_component_type) = selected_comp_info.type_reflection
+                else {
+                    unreachable!();
+                };
+
+                let Some(selected_comp_default_value) =
+                    selected_component_type.default_value()
+                else {
+                    unreachable!(); // Only components with default values are selectable
+                };
+
+                add_component_popup_state.new_component = Some((
+                    selected_comp_default_value,
+                    selected_comp_info,
+                    selected_comp_id,
+                ));
+            }
+
+            frame.spacing();
+            frame.spacing();
+            frame.spacing();
+
+            if let Some((new_component, new_component_info, _)) =
+                add_component_popup_state.new_component.as_mut()
+            {
+                let mut component_changed = false;
+
+                let Some(new_component_type) = new_component_info.type_reflection else {
+                    unreachable!();
+                };
+
+                add_item_to_frame(
+                    frame,
+                    ItemRef::Mutable(&mut **new_component),
+                    &mut component_changed,
+                    ItemInfo {
+                        item_title: new_component_info.name,
+                        item_tag: &format!(
+                            "add_component_popup_component_{}",
+                            new_component_info.name,
+                        ),
+                        item_type_name: None,
+                        item_type: ItemType::Reflected(new_component_type),
+                        item_is_read_only: false,
+                    },
+                    &[],
+                );
+
+                frame.spacing();
+                frame.spacing();
+                frame.spacing();
+            }
+
+            let _disabled = frame.begin_disabled_with_cond(
+                add_component_popup_state.new_component.is_none(),
+            );
+
+            let add_text_size = frame.current_font().calc_text_size(
+                frame.clone_style().font_size_base(),
+                frame.content_region_avail_width(),
+                0.0,
+                "Add",
+            );
+
+            if frame.button_with_size(
+                "Add##add_component_popup_add_button",
+                [add_text_size[0] * 2.0, add_text_size[1] * 2.0],
+            ) {
+                if let Some((new_component_data, new_component_info, new_component_id)) =
+                    add_component_popup_state.new_component.take()
+                {
+                    actions.add_components(
+                        add_component_popup_state.target_entity_id,
+                        [ComponentParts::builder()
+                            .name(new_component_info.name)
+                            .type_reflection(new_component_info.type_reflection)
+                            .build_with_any_data(new_component_id, new_component_data)],
+                    );
+
+                    return true;
+                }
+            }
+
+            false
+        },
+    );
+
+    if let Some(true) = should_close {
+        return true;
+    }
+
+    if !is_opened {
+        return true;
+    }
+
+    false
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ComponentUserCreatable
+{
+    Yes,
+    No
+    {
+        reason: &'static str,
+    },
+}
+
+struct ItemInfo<'a>
+{
+    item_title: &'a str,
+    item_tag: &'a str,
+    item_type_name: Option<&'static str>,
+    item_type: ItemType,
+    item_is_read_only: bool,
+}
+
+enum ItemType
+{
+    Reflected(&'static TypeReflection),
+    String,
+    CowStr,
+}
+
+fn get_item_type(ty: Option<&'static TypeReflection>, type_id: TypeId)
+    -> Option<ItemType>
+{
+    if let Some(ty) = ty {
+        Some(ItemType::Reflected(ty))
+    } else if type_id == TypeId::of::<String>() {
+        Some(ItemType::String)
+    } else if type_id == TypeId::of::<Cow<'static, str>>() {
+        Some(ItemType::CowStr)
+    } else {
+        None
+    }
+}
+
+enum ItemRef<'item>
+{
+    Mutable(&'item mut dyn Any),
+    Immutable(&'item dyn Any),
+}
+
+impl AsRef<dyn Any> for ItemRef<'_>
+{
+    fn as_ref(&self) -> &dyn Any
+    {
+        match self {
+            Self::Mutable(item) => &**item,
+            Self::Immutable(item) => *item,
+        }
+    }
+}
+
+fn add_item_to_frame<'a>(
+    frame: &dear_imgui_bindings::Ui,
+    mut item: ItemRef<'_>,
+    data_changed: &mut bool,
+    ItemInfo {
+        item_title,
+        item_tag,
+        item_type_name,
+        item_type,
+        item_is_read_only,
+    }: ItemInfo<'a>,
+    prev_item_tags: &[&'a str],
+)
+{
+    if !matches!(item_type, ItemType::Reflected(TypeReflection::Reference(_))) {
+        frame.text(&item_title);
+
+        if let Some(item_type_name) = item_type_name {
+            if frame.is_item_hovered() {
+                frame.tooltip_text(item_type_name);
+            }
+        }
+    }
+
+    let _disabled = frame.begin_disabled_with_cond(
+        !matches!(
+            item_type,
+            ItemType::Reflected(
+                TypeReflection::Struct(_)
+                    | TypeReflection::Enum(EnumReflection { is_unit_only: false, .. })
+                    | TypeReflection::Array(_)
+                    | TypeReflection::Slice(_)
+            )
+        ) && item_is_read_only,
+    );
+
+    match item_type {
+        ItemType::Reflected(TypeReflection::Struct(struct_reflection)) => {
+            frame.indent();
+
+            let mut prev_item_tags = prev_item_tags.to_vec();
+
+            prev_item_tags.push(item_tag.as_ref());
+
+            for (field_index, field) in struct_reflection.fields.iter().enumerate() {
+                let field_name = field
+                    .name
+                    .map(Cow::Borrowed)
+                    .unwrap_or_else(|| field_index.to_string().into());
+
+                let Some(field_item_type) =
+                    get_item_type(field.type_reflection(), field.type_id)
+                else {
+                    continue;
+                };
+
+                let Ok(field_item) = (match &mut item {
+                    ItemRef::Mutable(item) => {
+                        (struct_reflection.try_get_field_mut)(*item, field_index)
+                            .map(ItemRef::Mutable)
+                    }
+                    ItemRef::Immutable(item) => {
+                        (struct_reflection.try_get_field)(*item, field_index)
+                            .map(ItemRef::Immutable)
+                    }
+                }) else {
+                    unreachable!();
+                };
+
+                add_item_to_frame(
+                    frame,
+                    field_item,
+                    data_changed,
+                    ItemInfo {
+                        item_title: field_name.as_ref(),
+                        item_tag: field_name.as_ref(),
+                        item_type_name: Some(field.type_name()),
+                        item_type: field_item_type,
+                        item_is_read_only: item_is_read_only
+                            || matches!(
+                                field.visibility,
+                                Visibility::Private | Visibility::PubScoped(_)
+                            ),
+                    },
+                    &prev_item_tags,
+                );
+            }
+
+            frame.unindent();
+        }
+        ItemType::Reflected(TypeReflection::Enum(enum_type)) => {
+            if enum_type.is_unit_only {
+                frame.same_line();
+            } else {
+                frame.indent();
+            }
+
+            create_enum_widgets(
+                frame,
+                &mut item,
+                data_changed,
+                item_tag,
+                item_is_read_only,
+                enum_type,
+                prev_item_tags,
+            );
+
+            if !enum_type.is_unit_only {
+                frame.unindent();
+            }
+        }
+        ItemType::Reflected(TypeReflection::Literal(literal_reflection)) => {
+            frame.same_line();
+
+            match literal_reflection.ty {
+                LiteralType::U8 => create_scalar_item_input::<u8>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::I8 => create_scalar_item_input::<i8>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::U16 => create_scalar_item_input::<u16>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::I16 => create_scalar_item_input::<i16>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::U32 => create_scalar_item_input::<u32>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::I32 => create_scalar_item_input::<i32>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::U64 => create_scalar_item_input::<u64>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::I64 => create_scalar_item_input::<i64>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::F32 => create_scalar_item_input::<f32>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::F64 => create_scalar_item_input::<f64>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::Usize => create_scalar_item_input::<usize>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::Isize => create_scalar_item_input::<isize>(
+                    frame,
+                    &mut item,
+                    data_changed,
+                    &item_tag,
+                    &prev_item_tags,
+                ),
+                LiteralType::U128 => {
+                    let item = match item {
+                        ItemRef::Mutable(item) => {
+                            let Some(item) = (*item).downcast_mut::<u128>() else {
+                                unreachable!();
+                            };
+
+                            item
+                        }
+                        ItemRef::Immutable(item) => {
+                            let Some(item) = (*item).downcast_ref::<u128>() else {
+                                unreachable!();
+                            };
+
+                            &mut item.clone()
+                        }
+                    };
+
+                    frame.text(item.to_string());
+                }
+                LiteralType::I128 => {
+                    let item = match item {
+                        ItemRef::Mutable(item) => {
+                            let Some(item) = (*item).downcast_mut::<i128>() else {
+                                unreachable!();
+                            };
+
+                            item
+                        }
+                        ItemRef::Immutable(item) => {
+                            let Some(item) = (*item).downcast_ref::<i128>() else {
+                                unreachable!();
+                            };
+
+                            &mut item.clone()
+                        }
+                    };
+
+                    frame.text(item.to_string());
+                }
+                LiteralType::Bool => {
+                    let item = match item {
+                        ItemRef::Mutable(item) => {
+                            let Some(item) = (*item).downcast_mut::<bool>() else {
+                                unreachable!();
+                            };
+
+                            item
+                        }
+                        ItemRef::Immutable(item) => {
+                            let Some(item) = (*item).downcast_ref::<bool>() else {
+                                unreachable!();
+                            };
+
+                            &mut item.clone()
+                        }
+                    };
+
+                    if frame.checkbox(
+                        create_item_label(&item_tag, "value_input", &prev_item_tags),
+                        item,
+                    ) {
+                        *data_changed = true;
+                    }
+                }
+                LiteralType::Str => {
+                    let item = match item {
+                        ItemRef::Mutable(item) => {
+                            let Some(item) = (*item).downcast_ref::<&'static str>()
+                            else {
+                                unreachable!();
+                            };
+
+                            *item
+                        }
+                        ItemRef::Immutable(item) => {
+                            let Some(item) = (*item).downcast_ref::<&'static str>()
+                            else {
+                                unreachable!();
+                            };
+
+                            *item
+                        }
+                    };
+
+                    frame.text(item);
+                }
+                _ => unimplemented!(),
+            }
+        }
+        ItemType::Reflected(TypeReflection::Array(array_type)) => {
+            frame.indent();
+
+            let mut prev_item_tags = prev_item_tags.to_vec();
+
+            prev_item_tags.push(item_tag);
+
+            for array_item_index in 0..array_type.length {
+                let array_item_name = array_item_index.to_string();
+
+                let Ok(item_item) = (match &mut item {
+                    ItemRef::Mutable(item) => {
+                        (array_type.try_get_item_mut)(*item, array_item_index)
+                            .map(ItemRef::Mutable)
+                    }
+                    ItemRef::Immutable(item) => {
+                        (array_type.try_get_item)(*item, array_item_index)
+                            .map(ItemRef::Immutable)
+                    }
+                }) else {
+                    unreachable!();
+                };
+
+                add_item_to_frame(
+                    frame,
+                    item_item,
+                    data_changed,
+                    ItemInfo {
+                        item_title: array_item_name.as_ref(),
+                        item_tag: array_item_name.as_ref(),
+                        item_type_name: Some(array_type.item_type_name()),
+                        item_type: ItemType::Reflected(array_type.item_type),
+                        item_is_read_only,
+                    },
+                    &prev_item_tags,
+                );
+            }
+
+            frame.unindent();
+        }
+        ItemType::Reflected(TypeReflection::Slice(slice_type)) => {
+            frame.indent();
+
+            let mut prev_item_tags = prev_item_tags.to_vec();
+
+            prev_item_tags.push(item_tag);
+
+            let Some(len) = (slice_type.try_get_len)(item.as_ref()) else {
+                unreachable!();
+            };
+
+            for index in 0..len {
+                let item_name = index.to_string();
+
+                let Ok(item_item) = (slice_type.try_get_item)(item.as_ref(), index)
+                else {
+                    unreachable!();
+                };
+
+                let mut slice_item_changed = false;
+
+                add_item_to_frame(
+                    frame,
+                    ItemRef::Immutable(item_item),
+                    &mut slice_item_changed,
+                    ItemInfo {
+                        item_title: &item_name,
+                        item_tag: &item_name,
+                        item_type_name: Some(slice_type.item_type_name()),
+                        item_type: ItemType::Reflected(slice_type.item_type),
+                        item_is_read_only: true,
+                    },
+                    &prev_item_tags,
+                );
+
+                assert!(!slice_item_changed);
+            }
+
+            frame.unindent();
+        }
+        ItemType::Reflected(TypeReflection::Reference(ref_type)) => {
+            let mut derefed_changed = false;
+
+            let Some(derefed_item) = (ref_type.try_deref)(item.as_ref()) else {
+                unreachable!();
+            };
+
+            add_item_to_frame(
+                frame,
+                ItemRef::Immutable(derefed_item),
+                &mut derefed_changed,
+                ItemInfo {
+                    item_title,
+                    item_tag: "derefed".into(),
+                    item_type_name,
+                    item_type: ItemType::Reflected(ref_type.ty),
+                    item_is_read_only: true,
+                },
+                prev_item_tags,
+            );
+
+            assert!(!derefed_changed);
+        }
+        ItemType::String => {
+            frame.same_line();
+
+            let item = match item {
+                ItemRef::Mutable(item) => {
+                    let Some(item) = (*item).downcast_mut::<String>() else {
+                        unreachable!();
+                    };
+
+                    item
+                }
+                ItemRef::Immutable(item) => {
+                    let Some(item) = (*item).downcast_ref::<String>() else {
+                        unreachable!();
+                    };
+
+                    &mut item.clone()
+                }
+            };
+
+            if frame
+                .input_text(
+                    create_item_label(&item_tag, "value_input", &prev_item_tags),
+                    item,
+                )
+                .build()
+            {
+                *data_changed = true;
+            }
+        }
+        ItemType::CowStr => {
+            frame.same_line();
+
+            let item = match item {
+                ItemRef::Mutable(item) => {
+                    let Some(item) = (*item).downcast_mut::<Cow<'static, str>>() else {
+                        unreachable!();
+                    };
+
+                    item
+                }
+                ItemRef::Immutable(item) => {
+                    let Some(item) = (*item).downcast_ref::<Cow<'static, str>>() else {
+                        unreachable!();
+                    };
+
+                    &mut item.clone()
+                }
+            };
+
+            if frame
+                .input_text(
+                    create_item_label(&item_tag, "value_input", &prev_item_tags),
+                    item.to_mut(),
+                )
+                .build()
+            {
+                *data_changed = true;
+            }
+        }
+        ItemType::Reflected(_) => unimplemented!(),
+    }
+}
+
+fn create_scalar_item_input<Scalar>(
+    frame: &dear_imgui_bindings::Ui,
+    item: &mut ItemRef<'_>,
+    data_changed: &mut bool,
+    item_tag: &str,
+    prev_item_tags: &[&str],
+) where
+    Scalar: dear_imgui_bindings::internal::DataTypeKind + Clone + 'static,
+{
+    let item = match item {
+        ItemRef::Mutable(item) => {
+            let Some(item) = (*item).downcast_mut::<Scalar>() else {
+                unreachable!();
+            };
+
+            item
+        }
+        ItemRef::Immutable(item) => {
+            let Some(item) = (*item).downcast_ref::<Scalar>() else {
+                unreachable!();
+            };
+
+            &mut item.clone()
+        }
+    };
+
+    if frame
+        .input_scalar(
+            create_item_label(item_tag, "value_input", &prev_item_tags),
+            item,
+        )
+        .build()
+    {
+        *data_changed = true;
+    }
+}
+
+fn create_enum_widgets(
+    frame: &dear_imgui_bindings::Ui,
+    item: &mut ItemRef<'_>,
+    data_changed: &mut bool,
+    item_tag: &str,
+    item_is_read_only: bool,
+    enum_type: &EnumReflection,
+    prev_item_tags: &[&str],
+)
+{
+    let Some(mut curr_variant_index) = (enum_type.get_variant_index)(item.as_ref())
+    else {
+        unreachable!();
+    };
+
+    if create_combo_box(
+        frame,
+        create_item_label(&item_tag, "variant_select", &prev_item_tags),
+        &mut curr_variant_index,
+        enum_type.variants,
+        |variant| {
+            let disabled = variant.fields.as_ref().and_then(|fields| {
+                fields.fields().iter().find_map(|field| {
+                    let field_name = match field.name {
+                        Some(field_name) => Either::A(field_name),
+                        None => Either::B(field.index),
+                    };
+
+                    let Some(field_type) = field.type_reflection() else {
+                        return Some((field_name, "has no type reflection"));
+                    };
+
+                    if !field_type.has_default_value() {
+                        return Some((field_name, "has no default value"));
+                    }
+
+                    None
+                })
+            });
+
+            ComboBoxItem {
+                label: variant.name.into(),
+                disabled: disabled.is_some(),
+                hover_tooltip: disabled.map(|(bad_field_name, bad_field_reason)| {
+                    format!(
+                        "Variant cannot be selected since field {} {}",
+                        bad_field_name, bad_field_reason
+                    )
+                    .into()
+                }),
+            }
+        },
+    ) {
+        'used: {
+            let ItemRef::Mutable(item) = item else {
+                break 'used;
+            };
+
+            let new_variant = &enum_type.variants[curr_variant_index];
+
+            let Ok(()) = (new_variant.try_write_new_to)(
+                *item,
+                &mut new_variant
+                    .fields
+                    .iter()
+                    .map(|fields| fields.fields())
+                    .flatten()
+                    .map(|field| {
+                        let Some(field_type) = field.type_reflection() else {
+                            // Variants with any field that is missing type reflection is
+                            // disabled so that the user cannot select it
+                            unreachable!();
+                        };
+
+                        let Some(default_value) = field_type.default_value() else {
+                            unreachable!();
+                        };
+
+                        default_value
+                    }),
+            ) else {
+                unreachable!();
+            };
+
+            *data_changed = true;
+        }
+    }
+
+    let mut prev_item_tags = prev_item_tags.to_vec();
+
+    prev_item_tags.push(item_tag);
+
+    let curr_variant = &enum_type.variants[curr_variant_index];
+
+    if let Some(curr_variant_fields) = &curr_variant.fields {
+        for (field_index, field) in curr_variant_fields.fields().iter().enumerate() {
+            let Some(field_item_type) =
+                get_item_type(field.type_reflection(), field.type_id)
+            else {
+                continue;
+            };
+
+            let field_name: Cow<str> = match field.name {
+                Some(field_name) => field_name.into(),
+                None => field_index.to_string().into(),
+            };
+
+            let Ok(field_item) = (match item {
+                ItemRef::Mutable(item) => {
+                    (curr_variant.try_get_field_mut)(*item, field_index)
+                        .map(ItemRef::Mutable)
+                }
+                ItemRef::Immutable(item) => {
+                    (curr_variant.try_get_field)(*item, field_index)
+                        .map(ItemRef::Immutable)
+                }
+            }) else {
+                unreachable!();
+            };
+
+            add_item_to_frame(
+                frame,
+                field_item,
+                data_changed,
+                ItemInfo {
+                    item_title: field_name.as_ref(),
+                    item_tag: field_name.as_ref(),
+                    item_type_name: Some(field.type_name()),
+                    item_type: field_item_type,
+                    item_is_read_only: item_is_read_only,
+                },
+                &prev_item_tags,
+            );
+        }
+    };
+}
+
+fn create_item_label(item_tag: &str, value_name: &str, prev_item_tags: &[&str])
+    -> String
+{
+    let mut item_label = String::with_capacity(
+        2 + item_tag.len()
+            + prev_item_tags.len()
+            + prev_item_tags.iter().max().unwrap_or(&"".into()).len(),
+    );
+
+    item_label.push_str("##");
+
+    for prev_item_tag in prev_item_tags {
+        item_label.push('/');
+        item_label.push_str(prev_item_tag);
+    }
+
+    item_label.push('/');
+    item_label.push_str(item_tag);
+    item_label.push(':');
+    item_label.push_str(value_name);
+
+    item_label
+}
+
+fn get_whole_type_is_user_editable(
+    ty: Option<&'static TypeReflection>,
+    type_id: TypeId,
+) -> bool
+{
+    let Some(item_type) = get_item_type(ty, type_id) else {
+        return false;
+    };
+
+    match item_type {
+        ItemType::Reflected(TypeReflection::Struct(struct_ty)) => {
+            for field in struct_ty.fields {
+                if matches!(
+                    field.visibility,
+                    Visibility::Private | Visibility::PubScoped(_)
+                ) {
+                    continue;
+                }
+
+                if !get_whole_type_is_user_editable(
+                    field.type_reflection(),
+                    field.type_id,
+                ) {
+                    return false;
+                }
+            }
+
+            true
+        }
+        ItemType::Reflected(TypeReflection::Enum(enum_ty)) => {
+            enum_ty.variants.iter().any(|variant| {
+                for field in variant.fields.iter().flat_map(|fields| fields.fields()) {
+                    if !get_whole_type_is_user_editable(
+                        field.type_reflection(),
+                        field.type_id,
+                    ) {
+                        return false;
+                    }
+                }
+
+                true
+            })
+        }
+        ItemType::Reflected(
+            TypeReflection::Slice(_)
+            | TypeReflection::Array(_)
+            | TypeReflection::Literal(_),
+        )
+        | ItemType::String
+        | ItemType::CowStr => true,
+        ItemType::Reflected(_) => unimplemented!(),
+    }
+}
+
+struct ComboBoxItem<'b>
+{
+    label: Cow<'b, str>,
+    disabled: bool,
+    hover_tooltip: Option<Cow<'b, str>>,
+}
+
+fn create_combo_box<Item, ItemFn>(
+    frame: &dear_imgui_bindings::Ui,
+    label: impl AsRef<str>,
+    current_item: &mut usize,
+    items: &[Item],
+    item_fn: ItemFn,
+) -> bool
+where
+    for<'b> ItemFn: Fn(&'b Item) -> ComboBoxItem<'b>,
+{
+    let item_fn = &item_fn;
+
+    let mut result = false;
+
+    let preview_label = items.get(*current_item).map(|item| item_fn(item).label);
+
+    if let Some(combo_token) = frame.begin_combo(
+        label,
+        preview_label
+            .as_ref()
+            .map(|preview_label| preview_label.as_ref())
+            .unwrap_or(""),
+    ) {
+        for (idx, item) in items.iter().enumerate() {
+            let is_selected = idx == *current_item;
+
+            if is_selected {
+                frame.set_item_default_focus();
+            }
+
+            let ComboBoxItem {
+                label: item_label,
+                disabled: item_disabled,
+                hover_tooltip: item_hover_tooltip,
+            } = item_fn(item);
+
+            let disabled_token = frame.begin_disabled_with_cond(item_disabled);
+
+            let clicked = frame.selectable(item_label.as_ref());
+
+            if clicked {
+                *current_item = idx;
+                result = true;
+            }
+
+            disabled_token.end();
+
+            if let Some(item_hover_tooltip) = item_hover_tooltip {
+                if frame.is_item_hovered_with_flags(
+                    dear_imgui_bindings::ItemHoveredFlags::ALLOW_WHEN_DISABLED,
+                ) {
+                    frame.tooltip_text(item_hover_tooltip.as_ref());
+                }
+            }
+        }
+
+        combo_token.end();
+    }
+
+    result
+}
+
+struct ListBoxItem<'b>
+{
+    label: Cow<'b, str>,
+    disabled: bool,
+    hover_tooltip: Option<Cow<'b, str>>,
+}
+
+trait ListBoxExt
+{
+    fn build_extended<Item, ItemFn>(
+        self,
+        ui: &dear_imgui_bindings::Ui,
+        current_item: &mut i32,
+        items: &[Item],
+        item_fn: &ItemFn,
+    ) -> bool
+    where
+        for<'b> ItemFn: Fn(&'b Item) -> ListBoxItem<'b>;
+}
+
+impl<Label> ListBoxExt for dear_imgui_bindings::ListBox<Label>
+where
+    Label: AsRef<str>,
+{
+    fn build_extended<Item, ItemFn>(
+        self,
+        ui: &dear_imgui_bindings::Ui,
+        current_item: &mut i32,
+        items: &[Item],
+        item_fn: &ItemFn,
+    ) -> bool
+    where
+        for<'b> ItemFn: Fn(&'b Item) -> ListBoxItem<'b>,
+    {
+        let mut result = false;
+
+        let lb = self;
+
+        if let Some(_cb) = lb.begin(ui) {
+            for (idx, item) in items.iter().enumerate() {
+                if idx > i32::MAX as usize {
+                    break;
+                }
+
+                let idx_i32 = idx as i32;
+
+                let ListBoxItem {
+                    label: item_label,
+                    disabled: item_disabled,
+                    hover_tooltip: item_hover_tooltip,
+                } = item_fn(item);
+
+                let is_selected = idx_i32 == *current_item;
+
+                let disabled_token = ui.begin_disabled_with_cond(item_disabled);
+
+                if ui
+                    .selectable_config(&item_label)
+                    .selected(is_selected)
+                    .build()
+                {
+                    *current_item = idx_i32;
+                    result = true;
+                }
+
+                disabled_token.end();
+
+                if let Some(item_hover_tooltip) = item_hover_tooltip {
+                    if ui.is_item_hovered_with_flags(
+                        dear_imgui_bindings::ItemHoveredFlags::ALLOW_WHEN_DISABLED,
+                    ) {
+                        ui.tooltip_text(item_hover_tooltip.as_ref());
+                    }
+                }
+            }
+        }
+
+        result
+    }
+}
+
+fn create_entity_title(ent_handle: &EntityHandle) -> String
+{
+    let ent_name = ent_handle.get::<EntityName>();
+
+    format!(
+        "{} ({})",
+        ent_name
+            .as_ref()
+            .map(|ent_name| ent_name.name.as_ref())
+            .unwrap_or("<unnamed>"),
+        ent_handle.uid()
+    )
+}