rasmusgo/parent hierarchy 2

benchmarks/stress-test/src/lib.rs

@@ -20,7 +20,6 @@ use hotham::{
     systems::{
         animation_system, debug::debug_system, grabbing_system, hands_system, physics_system,
         rendering::rendering_system, skinning::skinning_system, update_global_transform_system,
-        update_global_transform_with_parent_system,
     },
     xr, Engine, HothamResult, TickData,
 };
@@ -250,7 +249,6 @@ fn tick(tick_props: &mut TickProps, tick_data: TickData) {
 
         animation_system(engine);
         update_global_transform_system(engine);
-        update_global_transform_with_parent_system(engine);
         skinning_system(engine);
     }
 

examples/complex-scene/src/lib.rs

@@ -11,7 +11,7 @@ use hotham::{
     systems::{
         animation_system, debug::debug_system, grabbing_system, hands::add_hand, hands_system,
         physics_system, rendering::rendering_system, skinning::skinning_system,
-        update_global_transform_system, update_global_transform_with_parent_system,
+        update_global_transform_system,
     },
     xr, Engine, HothamResult, TickData,
 };
@@ -45,7 +45,6 @@ fn tick(tick_data: TickData, engine: &mut Engine, state: &mut State) {
         animation_system(engine);
         navigation_system(engine, state);
         update_global_transform_system(engine);
-        update_global_transform_with_parent_system(engine);
         skinning_system(engine);
         debug_system(engine);
     }

examples/crab-saber/src/lib.rs

@@ -8,7 +8,6 @@ use hotham::{
     systems::{
         audio_system, draw_gui_system, haptics_system, physics_system, pointers_system,
         rendering_system, update_global_transform_system,
-        update_global_transform_with_parent_system,
     },
     xr::{self, SessionState},
     Engine, HothamResult, TickData,
@@ -51,7 +50,6 @@ fn tick(tick_data: TickData, engine: &mut Engine, game_context: &mut GameContext
         game_system(engine, game_context);
 
         // Update world
-        update_global_transform_with_parent_system(engine);
         update_global_transform_system(engine);
 
         // Sync world with output contexts

examples/custom-rendering/src/lib.rs

@@ -15,7 +15,6 @@ use hotham::{
     systems::{
         animation_system, debug::debug_system, grabbing_system, hands::add_hand, hands_system,
         physics_system, skinning::skinning_system, update_global_transform_system,
-        update_global_transform_with_parent_system,
     },
     util::u8_to_u32,
     xr, Engine, HothamResult, TickData,
@@ -64,7 +63,6 @@ fn tick(
         animation_system(engine);
         navigation_system(engine, state);
         update_global_transform_system(engine);
-        update_global_transform_with_parent_system(engine);
         skinning_system(engine);
         debug_system(engine);
     }

examples/simple-scene/src/lib.rs

@@ -10,7 +10,7 @@ use hotham::{
     systems::{
         animation_system, debug::debug_system, grabbing_system, hands::add_hand, hands_system,
         physics_system, rendering::rendering_system, skinning::skinning_system,
-        update_global_transform_system, update_global_transform_with_parent_system,
+        update_global_transform_system,
     },
     xr, Engine, HothamResult, TickData,
 };
@@ -48,7 +48,6 @@ fn tick(tick_data: TickData, engine: &mut Engine, _state: &mut State) {
         physics_system(engine);
         animation_system(engine);
         update_global_transform_system(engine);
-        update_global_transform_with_parent_system(engine);
         skinning_system(engine);
         debug_system(engine);
     }
@@ -87,7 +86,6 @@ fn init(engine: &mut Engine) -> Result<(), hotham::HothamError> {
 
     // Update global transforms from local transforms before physics_system gets confused
     update_global_transform_system(engine);
-    update_global_transform_with_parent_system(engine);
 
     Ok(())
 }

hotham/src/systems/draw_gui.rs

@@ -81,7 +81,6 @@ mod tests {
         systems::{
             rendering::rendering_system_inner,
             update_global_transform::update_global_transform_system_inner,
-            update_global_transform_with_parent::update_global_transform_with_parent_system_inner,
         },
         util::save_image_to_disk,
         COLOR_FORMAT,
@@ -177,9 +176,6 @@ mod tests {
         // Update transforms, etc.
         update_global_transform_system_inner(world);
 
-        // Update parent transform matrix
-        update_global_transform_with_parent_system_inner(world);
-
         // Render
         render_context.begin_frame(vulkan_context);
 

hotham/src/systems/mod.rs

@@ -11,7 +11,6 @@ pub mod pointers;
 pub mod rendering;
 pub mod skinning;
 pub mod update_global_transform;
-pub mod update_global_transform_with_parent;
 
 pub use animation::animation_system;
 pub use audio::audio_system;
@@ -24,4 +23,3 @@ pub use pointers::pointers_system;
 pub use rendering::rendering_system;
 pub use skinning::skinning_system;
 pub use update_global_transform::update_global_transform_system;
-pub use update_global_transform_with_parent::update_global_transform_with_parent_system;

hotham/src/systems/rendering.rs

@@ -297,10 +297,7 @@ mod tests {
         components::{stage::Stage, LocalTransform},
         contexts::RenderContext,
         rendering::{image::Image, light::Light, scene_data},
-        systems::{
-            update_global_transform::update_global_transform_system_inner,
-            update_global_transform_with_parent::update_global_transform_with_parent_system_inner,
-        },
+        systems::update_global_transform::update_global_transform_system_inner,
         util::{affine_from_posef, posef_from_affine, save_image_to_disk},
     };
     use glam::{Quat, Vec3};
@@ -584,7 +581,6 @@ mod tests {
         render_context.scene_data.params.x = debug_ibl_intensity;
         render_context.scene_data.lights[0] = light.clone();
         update_global_transform_system_inner(world);
-        update_global_transform_with_parent_system_inner(world);
         rendering_system_inner(world, vulkan_context, render_context, views, 0);
         render_context.end_frame(vulkan_context);
     }

hotham/src/systems/update_global_transform.rs

@@ -1,32 +1,198 @@
 use crate::{
-    components::{GlobalTransform, LocalTransform},
+    components::{GlobalTransform, LocalTransform, Parent},
     Engine,
 };
 use hecs::World;
 
-/// Update global transform matrix system
-/// Walks through each LocalTransform and applies it to a 4x4 matrix used by the vertex shader
+/// Update global transform system
+/// Updates [`GlobalTransform`] based on [`LocalTransform`] and the hierarchy of [`Parent`]s.
 pub fn update_global_transform_system(engine: &mut Engine) {
     let world = &mut engine.world;
     update_global_transform_system_inner(world);
 }
 
 pub(crate) fn update_global_transform_system_inner(world: &mut World) {
-    for (_, (local_transform, global_transform)) in
-        world.query_mut::<(&LocalTransform, &mut GlobalTransform)>()
+    // Update GlobalTransform of roots
+    for (_, (local_transform, global_transform)) in world
+        .query_mut::<(&LocalTransform, &mut GlobalTransform)>()
+        .without::<&Parent>()
     {
         global_transform.0 = local_transform.to_affine();
     }
+
+    // Construct a view for efficient random access into the set of all entities that have
+    // parents. Views allow work like dynamic borrow checking or component storage look-up to be
+    // done once rather than per-entity as in `World::get`.
+    let mut parents = world.query::<(&Parent, &LocalTransform)>();
+    let parents = parents.view();
+
+    // View of entities that don't have parents, i.e. roots of the transform hierarchy
+    let mut roots = world.query::<&GlobalTransform>().without::<&Parent>();
+    let roots = roots.view();
+
+    // This query can coexist with the `roots` view without illegal aliasing of `GlobalTransform`
+    // references because the inclusion of `&Parent` in the query, and its exclusion from the view,
+    // guarantees that they will never overlap. Similarly, it can coexist with `parents` because
+    // that view does not reference `GlobalTransform`s at all.
+    for (_entity, (parent, local_transform, global_transform)) in world
+        .query::<(&Parent, &LocalTransform, &mut GlobalTransform)>()
+        .iter()
+    {
+        // Walk the hierarchy from this entity to the root, accumulating the entity's absolute
+        // transform. This does a small amount of redundant work for intermediate levels of deeper
+        // hierarchies, but unlike a top-down traversal, avoids tracking entity child lists and is
+        // cache-friendly.
+        let mut relative = local_transform.to_affine();
+        let mut ancestor = parent.0;
+        while let Some((next, next_local)) = parents.get(ancestor) {
+            relative = next_local.to_affine() * relative;
+            ancestor = next.0;
+        }
+        // The `while` loop terminates when `ancestor` cannot be found in `parents`, i.e. when it
+        // does not have a `Parent` component, and is therefore necessarily a root.
+        global_transform.0 = roots.get(ancestor).unwrap().0 * relative;
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::components::LocalTransform;
-    use approx::assert_relative_eq;
+    use std::collections::HashMap;
+
+    use approx::{assert_relative_eq, relative_eq};
     use glam::{Affine3A, EulerRot, Quat};
+    use hecs::Entity;
+
+    use crate::components::Info;
 
     use super::*;
 
+    #[test]
+    pub fn test_transform_system() {
+        let mut world = World::new();
+        let parent_local_transform = LocalTransform {
+            translation: [1.0, 1.0, 100.0].into(),
+            ..Default::default()
+        };
+        let parent_global_transform =
+            GlobalTransform(Affine3A::from_translation([1.0, 1.0, 100.0].into()));
+
+        let parent = world.spawn((parent_local_transform, parent_global_transform));
+        let child = world.spawn((
+            parent_local_transform,
+            parent_global_transform,
+            Parent(parent),
+        ));
+        let grandchild = world.spawn((
+            parent_local_transform,
+            parent_global_transform,
+            Parent(child),
+        ));
+
+        update_global_transform_system_inner(&mut world);
+
+        {
+            let global_transform = world.get::<&GlobalTransform>(grandchild).unwrap();
+            let expected_matrix = Affine3A::from_translation([3.0, 3.0, 300.0].into());
+            assert_relative_eq!(global_transform.0, expected_matrix);
+        }
+
+        {
+            let global_transform = world.get::<&GlobalTransform>(child).unwrap();
+            let expected_matrix = Affine3A::from_translation([2.0, 2.0, 200.0].into());
+            assert_relative_eq!(global_transform.0, expected_matrix);
+        }
+    }
+
+    #[test]
+    pub fn test_transform_system_extensive() {
+        let mut world = World::new();
+        let mut hierarchy: HashMap<usize, Vec<usize>> = HashMap::new();
+        let mut node_entity: HashMap<usize, Entity> = HashMap::new();
+        let mut entity_node: HashMap<Entity, usize> = HashMap::new();
+        hierarchy.insert(0, vec![1, 2, 3, 4]);
+        hierarchy.insert(1, vec![5, 6, 7, 8]);
+        hierarchy.insert(2, vec![9, 10, 11, 12]);
+        hierarchy.insert(3, vec![13, 14, 15, 16]);
+        hierarchy.insert(5, vec![17, 18, 19, 20]);
+        hierarchy.insert(14, vec![21, 22, 23, 24]);
+        hierarchy.insert(22, vec![25, 26, 27, 28]);
+        hierarchy.insert(17, vec![29, 30, 31, 32]);
+
+        for n in 0..=32 {
+            let info = Info {
+                name: format!("Node {n}"),
+                node_id: n,
+            };
+            let local_transform = LocalTransform {
+                translation: [1.0, 1.0, 1.0].into(),
+                ..Default::default()
+            };
+            let matrix = GlobalTransform::default();
+            let entity = world.spawn((info, local_transform, matrix));
+            node_entity.insert(n, entity);
+            entity_node.insert(entity, n);
+        }
+
+        for (parent, children) in hierarchy.iter() {
+            let parent_entity = node_entity.get(parent).unwrap();
+            let parent = Parent(*parent_entity);
+            for node_id in children {
+                let entity = node_entity.get(node_id).unwrap();
+                world.insert_one(*entity, parent).unwrap();
+            }
+        }
+
+        let root_entity = node_entity.get(&0).unwrap();
+        {
+            let mut local_transform = world.get::<&mut LocalTransform>(*root_entity).unwrap();
+            local_transform.translation = [100.0, 100.0, 100.0].into();
+        }
+        update_global_transform_system_inner(&mut world);
+
+        for (_, (global_transform, parent, info)) in
+            world.query::<(&GlobalTransform, &Parent, &Info)>().iter()
+        {
+            let mut depth = 1;
+
+            let mut parent_entity = parent.0;
+            let mut parent_matrices = vec![];
+            loop {
+                let parent_global_transform = world.get::<&GlobalTransform>(parent_entity).unwrap();
+                parent_matrices.push(parent_global_transform.0);
+
+                // Walk up the tree until we find the root.
+                if let Ok(grand_parent) = world.get::<&Parent>(parent_entity) {
+                    depth += 1;
+                    parent_entity = grand_parent.0;
+                } else {
+                    let expected_matrix = get_expected_matrix(depth);
+                    if !relative_eq!(expected_matrix, global_transform.0) {
+                        panic!(
+                            "[Node {}] - {:?} did not equal {expected_matrix:?} at depth {depth}",
+                            info.node_id, global_transform.0
+                        );
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    fn get_expected_matrix(depth: usize) -> Affine3A {
+        let mut transform = Affine3A::from_translation([100.0, 100.0, 100.0].into());
+        for _ in 0..depth {
+            transform = transform * Affine3A::from_translation([1.0, 1.0, 1.0].into());
+        }
+        transform
+    }
+
+    #[test]
+    pub fn test_entities_without_transforms() {
+        let mut world = World::new();
+        world.spawn((0,));
+        update_global_transform_system_inner(&mut world);
+    }
+
     #[test]
     pub fn test_update_global_transform_system() {
         let mut world = World::new();