Got some semblence of item selection

I have a few options for "next steps" including:
* Figure out bounding boxes using meshes
* Move it into a plugin for re-usability
* Build scene from meshes/nodes for more flexibility
* Move on to something completely different (audio inspector)

I'm inclined to go to audio inspector and then come back to the
mesh/node scene builder.

Cargo.toml

@@ -29,4 +29,13 @@ path = "bin/debug-info.rs"
 
 
 [dependencies]
-bevy = "0.10"
+bevy = "0.11"
+bevy_rapier3d = "*"
+
+# From rapier docs
+[profile.dev.package.bevy_rapier3d]
+opt-level = 3
+
+# From rapier docs
+[profile.release]
+codegen-units = 1

bin/TODO.txt

@@ -0,0 +1,7 @@
+- [x] basic gltf inspector
+  - [x] with animation previews
+  - [ ] inspect specific models
+- [x] basic text inspector
+  - [x] with simple text animation
+- [ ] audio inspector
+- [x] debug info (FPS)

bin/gltf-inspect.rs

@@ -1,6 +1,6 @@
 use bevy::{
     core_pipeline::clear_color::ClearColorConfig,
-    gltf::Gltf,
+    gltf::{Gltf, GltfNode},
     input::{
         keyboard::KeyboardInput,
         mouse::{MouseMotion, MouseWheel},
@@ -13,32 +13,47 @@ use bevy::{
         render_resource::{
             Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
         },
+        view::VisibleEntities,
     },
-    utils::HashSet,
+    window::PrimaryWindow,
 };
+use bevy_rapier3d::{prelude::*, rapier::prelude::RigidBodyType};
+use monologue_trees::{debug::*, text::*};
 
 fn main() {
     App::new()
-        .add_plugins(DefaultPlugins.set(WindowPlugin {
+        .add_plugins((
+            DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "GLTF Inspector".into(),
                     resolution: (640., 480.).into(),
                     ..default()
                 }),
                 ..default()
-        }))
+            }),
+            DebugInfoPlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
         .add_event::<ManageActive>()
-        .add_startup_system(load_models)
+        .add_event::<Selected>()
-        .add_startup_system(spawn_base_scene)
+        .add_systems(PreStartup, load_models)
-        .add_startup_system(spawn_base_ui)
+        .add_systems(Startup, (spawn_base_scene, spawn_base_ui))
-        .add_system(spawn_models)
+        .add_systems(
-        .add_system(spawn_ui)
+            Update,
-        .add_system(control_animation)
+            (
-        .add_system(rotate_model)
+                spawn_models,
-        .add_system(zoom_model)
+                spawn_ui,
-        .add_system(scroll)
+                control_animation,
-        .add_system(select)
+                rotate_model,
-        .add_system(manage_active)
+                zoom_model,
+                scroll,
+                select,
+                manage_active,
+                inspect_nodes,
+                selection,
+            ),
+        )
         .run();
 }
 
@@ -74,9 +89,17 @@ struct Active;
 
 ///
 /// Event for managing which entities are tagged "Active"
-#[derive(Debug)]
+#[derive(Event, Debug)]
 struct ManageActive(Option<Entity>);
 
+///
+/// Event for tracking which entities are selected
+#[derive(Event, Debug)]
+enum Selected {
+    Hovered(Entity),
+    Selected(Entity),
+}
+
 ///
 /// Load all GLTF models on startup
 fn load_models(mut commands: Commands, ass: Res<AssetServer>) {
@@ -110,8 +133,9 @@ fn spawn_base_ui(mut commands: Commands) {
             NodeBundle {
                 style: Style {
                     justify_content: JustifyContent::Center,
-                    size: Size::all(Val::Percent(90.0)),
+                    width: Val::Percent(90.0),
-                    overflow: Overflow::Hidden,
+                    height: Val::Percent(90.0),
+                    overflow: Overflow::clip(),
                     ..default()
                 },
                 ..default()
@@ -125,8 +149,8 @@ fn spawn_base_ui(mut commands: Commands) {
                         flex_wrap: FlexWrap::Wrap,
                         flex_direction: FlexDirection::Row,
                         justify_content: JustifyContent::SpaceAround,
-                        size: Size::AUTO,
+                        width: Val::Auto,
-                        max_size: Size::UNDEFINED,
+                        height: Val::Auto,
                         ..default()
                     },
                     ..default()
@@ -271,6 +295,8 @@ fn spawn_models(
                                 scene: handle.clone(),
                                 ..default()
                             },
+                            RigidBody::KinematicPositionBased,
+                            Collider::cylinder(1.0, 1.0),
                             Inspect,
                         ));
                     });
@@ -306,7 +332,8 @@ fn spawn_ui(
                     .with_children(|parent| {
                         parent.spawn(ImageBundle {
                             style: Style {
-                                size: Size::all(Val::Px(256.0)),
+                                width: Val::Px(256.0),
+                                height: Val::Px(256.0),
                                 padding: UiRect::all(Val::Px(5.0)),
                                 ..default()
                             },
@@ -322,6 +349,15 @@ fn spawn_ui(
     }
 }
 
+fn inspect_nodes(gltfs: Res<Assets<Gltf>>, nodes: Res<Assets<GltfNode>>, mut done: Local<bool>) {
+    if !(*done) {
+        for gltf in gltfs.iter() {
+            // info!("Gltf {:#?}", gltf);
+            *done = true;
+        }
+    }
+}
+
 fn control_animation(
     mut key_evr: EventReader<KeyboardInput>,
     mut active_evr: EventReader<ManageActive>,
@@ -425,7 +461,7 @@ fn zoom_model(
     mut wheel_evr: EventReader<MouseWheel>,
     mut transforms: Query<&mut Transform, (With<Inspect>, With<Active>, Without<Camera>)>,
 ) {
-    if keys.pressed(KeyCode::LShift) {
+    if keys.pressed(KeyCode::ShiftLeft) {
         for ev in wheel_evr.iter() {
             for mut transform in transforms.iter_mut() {
                 let scale = (Vec3::ONE * ev.y) / 100.0;
@@ -444,7 +480,7 @@ fn scroll(
         // Only scroll if scene not selected
         if active.is_empty() {
             for mut s in query.iter_mut() {
-                s.position.top = match s.position.top {
+                s.top = match s.top {
                     Val::Px(current) => Val::Px(current + (ev.y * 5.0)),
                     _ => Val::Px(0.0),
                 };
@@ -471,7 +507,7 @@ fn select(
     mut events: EventWriter<ManageActive>,
 ) {
     for (interaction, selected_preview) in query.iter() {
-        if interaction == &Interaction::Clicked {
+        if interaction == &Interaction::Pressed {
             // Hide UI
             let mut ui_vis = selection_ui.single_mut();
             *ui_vis = Visibility::Hidden;
@@ -537,25 +573,23 @@ fn manage_active(
     mut events: EventReader<ManageActive>,
     query: Query<&Children>,
     current: Query<Entity, With<Active>>,
+    names: Query<&Name>,
 ) {
-    for event in events.iter() {
+    for ManageActive(inner) in events.iter() {
-        info!("Setting active: {:?}", event);
+        info!("Setting active: {:?}", inner);
-        match event {
+        match inner {
-            ManageActive(None) => {
+            None => {
                 for entity in current.iter() {
                     if let Some(mut entity_commands) = commands.get_entity(entity) {
                         entity_commands.remove::<Active>();
+                        entity_commands.remove::<ColliderDebugColor>();
                     }
                 }
             }
-            ManageActive(Some(entity)) => {
+            Some(entity) => {
                 for child in query.iter_descendants(*entity) {
                     if let Some(mut child_commands) = commands.get_entity(child) {
-                        // info!(
+                        // info!("Name: {:?}", names.get(child));
-                        //     "Active entity components: {:?} {:?}",
-                        //     child,
-                        //     names.get(child)
-                        // );
                         // child_commands.log_components();
                         child_commands.insert(Active);
                     }
@@ -564,3 +598,36 @@ fn manage_active(
         }
     }
 }
+
+fn selection(
+    mut commands: Commands,
+    windows: Query<&Window, With<PrimaryWindow>>,
+    mut mouse_events: EventReader<MouseMotion>,
+    camera_q: Query<(&Camera, &GlobalTransform, &VisibleEntities), With<Active>>,
+    rapier_context: Res<RapierContext>,
+) {
+    if !mouse_events.is_empty() {
+        let window = windows.single();
+        for _ in mouse_events.iter() {
+            if let Some(cursor) = window.cursor_position() {
+                for (camera, camera_t, visible_entities) in camera_q.iter() {
+                    if let Some(ray) = camera.viewport_to_world(camera_t, cursor) {
+                        if let Some((entity, toi)) = rapier_context.cast_ray(
+                            ray.origin,
+                            ray.direction,
+                            f32::MAX,
+                            true,
+                            QueryFilter::new()
+                                .predicate(&|entity| visible_entities.entities.contains(&entity)),
+                        ) {
+                            if let Some(mut cmds) = commands.get_entity(entity) {
+                                info!("hit! ({:?}@{})", entity, toi);
+                                cmds.insert(ColliderDebugColor(Color::BLUE));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

bin/text-inspect.rs

@@ -1,5 +1,3 @@
-use std::time::Duration;
-
 use bevy::prelude::*;
 
 use monologue_trees::{debug::*, text::*};
@@ -14,23 +12,30 @@ const LOREM: [&str; 5] = [
 
 fn main() {
     App::new()
-        .add_plugins(DefaultPlugins.set(WindowPlugin {
+        .add_plugins((
+            DefaultPlugins.set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "Text Inspect".into(),
                     resolution: (640., 480.).into(),
                     ..default()
                 }),
                 ..default()
-        }))
+            }),
-        .add_plugin(DebugInfoPlugin)
+            DebugInfoPlugin,
-        .add_plugin(AnimatedTextPlugin)
+            AnimatedTextPlugin,
-        .add_startup_system(load_fonts)
+        ))
-        .add_startup_system(init_ui)
+        .add_systems(PreStartup, load_fonts)
-        .add_system(manage_buttons)
+        .add_systems(Startup, init_ui)
-        .add_system(manage_animation_button)
+        .add_systems(
-        .add_system(manage_fonts)
+            Update,
-        .add_system(mouse_cursor)
+            (
-        .add_system(manage_animation)
+                manage_buttons,
+                manage_animation_button,
+                manage_fonts,
+                mouse_cursor,
+                manage_animation,
+            ),
+        )
         .run();
 }
 
@@ -65,7 +70,8 @@ fn init_ui(mut commands: Commands) {
     commands
         .spawn(NodeBundle {
             style: Style {
-                size: Size::all(Val::Percent(100.0)),
+                width: Val::Percent(100.0),
+                height: Val::Percent(100.0),
                 ..default()
             },
             background_color: BackgroundColor(Color::BLACK),
@@ -77,10 +83,7 @@ fn init_ui(mut commands: Commands) {
                     style: Style {
                         flex_direction: FlexDirection::Column,
                         align_items: AlignItems::Center,
-                        size: Size {
                         width: Val::Px(200.0),
-                            height: Val::Undefined,
-                        },
                         align_content: AlignContent::SpaceEvenly,
                         ..default()
                     },
@@ -108,14 +111,11 @@ fn init_ui(mut commands: Commands) {
                             ..default()
                         },
                         style: Style {
-                            size: Size {
                             width: Val::Px(400.0),
                             ..default()
                         },
                         ..default()
                     },
-                        ..default()
-                    },
                     animated_text: AnimatedText::new(TextAnimationType::Typing(12.0)),
                 },
                 PreviewText,
@@ -127,17 +127,11 @@ fn init_ui(mut commands: Commands) {
                         style: Style {
                             align_self: AlignSelf::FlexEnd,
                             position_type: PositionType::Absolute,
-                            position: UiRect {
                             bottom: Val::Px(5.0),
                             left: Val::Px(5.0),
-                                ..default()
-                            },
-                            size: Size {
                             width: Val::Px(200.0),
                             ..default()
                         },
-                            ..default()
-                        },
                         background_color: BackgroundColor(Color::default().with_a(0.0)),
                         ..default()
                     },
@@ -187,8 +181,8 @@ fn manage_buttons(
                     .split("/")
                     .last()
                     .expect("Extracting filename")
-                    .strip_suffix(".otf")
+                    .trim_end_matches(".otf")
-                    .expect("Stripping prefix");
+                    .trim_end_matches(".ttf");
 
                 let style = TextStyle {
                     font: font.clone(),
@@ -226,7 +220,7 @@ fn manage_fonts(
 ) {
     for (i, f) in interaction.iter() {
         match (i, f) {
-            (Interaction::Clicked, FontButton(font)) => {
+            (Interaction::Pressed, FontButton(font)) => {
                 texts.single_mut().sections.iter_mut().for_each(|section| {
                     section.style.font = font.clone();
                 });
@@ -242,7 +236,7 @@ fn manage_animation_button(
 ) {
     for (i, f) in interaction.iter() {
         match (i, f) {
-            (Interaction::Clicked, FontButton(font)) => {
+            (Interaction::Pressed, FontButton(font)) => {
                 animation_button
                     .single_mut()
                     .sections
@@ -262,7 +256,7 @@ fn mouse_cursor(
         let mut window = windows.single_mut();
 
         window.cursor.icon = match interaction {
-            Interaction::Hovered | Interaction::Clicked => CursorIcon::Hand,
+            Interaction::Hovered | Interaction::Pressed => CursorIcon::Hand,
             Interaction::None => CursorIcon::Arrow,
         }
     }
@@ -270,15 +264,17 @@ fn mouse_cursor(
 
 fn manage_animation(
     mut animated_texts: Query<&mut AnimatedText, With<PreviewText>>,
-    interactions: Query<&Interaction, (Changed<Interaction>, With<FontButton>)>,
+    interactions: Query<&Interaction, (Changed<Interaction>, With<AnimationButton>)>,
 ) {
     for interaction in interactions.iter() {
         match interaction {
-            Interaction::Clicked => {
+            Interaction::Pressed => {
-                let mut preview = animated_texts
+                info!("toggling animation");
+
+                let mut anim = animated_texts
                     .get_single_mut()
                     .expect("Loading animated text");
-                preview.play();
+                anim.toggle();
             }
             _ => (),
         }

src/debug.rs

@@ -10,9 +10,8 @@ pub struct DebugInfoPlugin;
 
 impl Plugin for DebugInfoPlugin {
     fn build(&self, app: &mut App) {
-        app.add_startup_system(init)
+        app.add_systems(Startup, init)
-            .add_system(toggle)
+            .add_systems(Update, (toggle, update));
-            .add_system(update);
     }
 }
 
@@ -34,13 +33,10 @@ fn init(mut commands: Commands, server: Res<AssetServer>) {
                 visibility: Visibility::Hidden,
                 style: Style {
                     position_type: PositionType::Absolute,
-                    position: UiRect {
                     top: Val::Px(0.0),
                     left: Val::Px(0.0),
                     ..default()
                 },
-                    ..default()
-                },
                 background_color: BackgroundColor(Color::GRAY),
                 z_index: ZIndex::Global(999),
                 ..default()

src/text.rs

@@ -17,7 +17,7 @@ pub struct AnimatedTextPlugin;
 
 impl Plugin for AnimatedTextPlugin {
     fn build(&self, app: &mut App) {
-        app.add_system(manage_texts).add_system(animate_texts);
+        app.add_systems(Update, (manage_texts, animate_texts));
     }
 }
 
@@ -59,6 +59,14 @@ impl AnimatedText {
         self.animation_status = TextAnimationStatus::Stopped;
         self.animation_duration = None;
     }
+
+    pub fn toggle(&mut self) {
+        use TextAnimationStatus::*;
+        self.animation_status = match self.animation_status {
+            Playing => Stopped,
+            Stopped => Playing,
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -68,9 +76,9 @@ pub enum TextAnimationType {
 
 #[derive(Default, Debug)]
 enum TextAnimationStatus {
+    Playing,
     #[default]
     Stopped,
-    Playing,
 }
 
 /// Manage individual text entities
@@ -121,22 +129,41 @@ fn animate_texts(mut query: Query<(&mut Text, &mut AnimatedText)>, time: Res<Tim
                 Some(TextAnimationType::Typing(seconds)) => {
                     animated_text.animation_duration = match animated_text.animation_duration {
                         None | Some(Duration::ZERO) => {
+                            // Set sections to alpha 0 before animation begins
+                            text.sections.iter_mut().for_each(|section| {
+                                section.style.color.set_a(0.0);
+                            });
                             // We have just (re)started the animation, so set the duration to full
                             Some(Duration::from_secs_f32(seconds))
                         }
                         // FIXME: Why can't mutate inner on animation_duration?
                         Some(inner) => {
                             {
-                                let percentage = 1.0 - (inner.as_secs_f32()) - seconds;
+                                // how far into the animation are we?
-
+                                let percentage = 1.0 - (inner.as_secs_f32() / seconds);
-                                let len_total = text
+
-                                    .sections
+                                // Find the total number of characters to be processed
-                                    .iter()
+                                // let len_total = text
-                                    .fold(0, |acc, curr| acc + curr.value.len());
+                                //     .sections
-
+                                //     .iter()
+                                //     .fold(0, |acc, curr| acc + curr.value.len());
+                                // Backup version:
+                                let len_total = text.sections.len();
+
+                                // Find the farthest character into the string to show
                                 let target = (len_total as f32 * percentage) as usize;
 
-                                for mut section in text.sections.iter_mut() {}
+                                // Assign all segments an alpha of 0 or 1.
+                                // TODO: Incremental updates only: Start at target, work backward
+                                // until you get to one with alpha 1 and then break
+                                text.sections
+                                    .iter_mut()
+                                    .take(target)
+                                    .rev()
+                                    .take_while(|section| section.style.color.a() != 1.0)
+                                    .for_each(|section| {
+                                        section.style.color.set_a(1.0);
+                                    });
                             }
 
                             // We are continuing the animation, so decrement the remaining duration
@@ -148,51 +175,3 @@ fn animate_texts(mut query: Query<(&mut Text, &mut AnimatedText)>, time: Res<Tim
         }
     }
 }
-
-// PERF: Why does this slow down immediatly?
-// if *duration > Duration::ZERO {
-//     *duration = duration.saturating_sub(time.delta());
-//
-//     let percentage = 1.0 - (duration.as_secs_f32() / 30.0);
-//
-//     let mut text = texts.single_mut();
-//
-//     let len_total = desired.iter().fold(0, |acc, curr| acc + curr.len());
-//     let mut len_total = ((len_total as f32 * percentage) as usize).min(len_total as usize);
-//
-//     for (section, desired) in text.sections.iter_mut().zip(desired.iter()) {
-//         // This section is empty, initialize with capacity
-//         if len_total == 0 {
-//             break;
-//
-//         // Total amount of remaining text is greater than this section
-//         // Set this text block to the full section
-//         } else if len_total >= desirted.len() {
-//             // info!("len_total >= desired.len()");
-//             len_total -= desired.len();
-//             if section.value.len() != desired.len() {
-//                 // info!("value != desired");
-//                 section.value = desired.clone();
-//             }
-//
-//         // Total remaining text is less than this section
-//         // Set to a sub-string of text
-//         } else if len_total < desired.len() {
-//             // info!("len total < desired len");
-//             // Difference between current value and desired length
-//             let diff = desired
-//                 .split_at(section.value.len())
-//                 .1
-//                 .split_at(len_total - section.value.len())
-//                 .0
-//                 .into();
-//             // info!("adding value {}", diff);
-//             section.value.push_str(diff);
-//             len_total = 0;
-//
-//         // Undefined behavior
-//         } else {
-//             info!("Unexpected text animation situation");
-//         }
-//     }
-// }

tmp

@@ -0,0 +1,14 @@
+    if *duration > Duration::ZERO {
+        let mut text = texts.single_mut();
+        let total_sections = text.sections.len();
+
+        *duration = duration.saturating_sub(time.delta());
+
+        for (idx, section) in text.sections.iter_mut().enumerate() {
+            let ratio = ((idx + 1) as f32) / (total_sections as f32);
+            let cursor = 1.0 - ((*duration).as_secs_f32() / 30.0);
+            let alpha = if cursor > ratio { 1.0 } else { 0.0 };
+            section.style.color.set_a(alpha);
+        }
+    }
+