From f86556f115dd61a45e4f2d8724ec798964fe1126 Mon Sep 17 00:00:00 2001
From: CptPotato <3957610+CptPotato@users.noreply.github.com>
Date: Thu, 10 Mar 2022 10:48:56 +0100
Subject: [PATCH 1/4] add transform_hierarchy example create example folder for
 stress tests

---
 Cargo.toml                                   |   6 +
 examples/README.md                           |   7 +
 examples/stress_tests/transform_hierarchy.rs | 500 +++++++++++++++++++
 3 files changed, 513 insertions(+)
 create mode 100644 examples/stress_tests/transform_hierarchy.rs

diff --git a/Cargo.toml b/Cargo.toml
index 5efa16115826e..32841e9bbf113 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -562,3 +562,9 @@ icon = "@mipmap/ic_launcher"
 build_targets = ["aarch64-linux-android", "armv7-linux-androideabi"]
 min_sdk_version = 16
 target_sdk_version = 29
+
+# Stress Tests
+[[example]]
+name = "transform_hierarchy"
+path = "examples/stress_tests/transform_hierarchy.rs"
+
diff --git a/examples/README.md b/examples/README.md
index 53d276d646d81..cc8a20ea16a2a 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -65,6 +65,7 @@ git checkout v0.4.0
   - [WASM](#wasm)
     - [Setup](#setup-2)
     - [Build & Run](#build--run-2)
+- [Stree Tests](#stress-tests)
 
 # The Bare Minimum
 
@@ -408,3 +409,9 @@ ruby -run -ehttpd examples/wasm
 To load assets, they need to be available in the folder examples/wasm/assets. Cloning this
 repository will set it up as a symlink on Linux and macOS, but you will need to manually move
 the assets on Windows.
+
+# Stress Tests
+
+Example | File | Description
+--- | --- | ---
+`transform_hierarchy.rs` | [`stress_tests/transform_hierarchy.rs`](./stress_tests/transform_hierarchy.rs) | Configurable test for hierarchy and transform propagation performance
diff --git a/examples/stress_tests/transform_hierarchy.rs b/examples/stress_tests/transform_hierarchy.rs
new file mode 100644
index 0000000000000..5bcf32512fedd
--- /dev/null
+++ b/examples/stress_tests/transform_hierarchy.rs
@@ -0,0 +1,500 @@
+//! hierarchy and transform propagation stress test
+//! set the test parameters inside [main]
+
+use bevy::{
+    prelude::*,
+    sprite::{MaterialMesh2dBundle, Mesh2dHandle},
+};
+use rand::Rng;
+
+fn main() {
+    let cfg = Cfg {
+        test_case: TestCase::NonUniformTree {
+            depth: 18,
+            branch_width: 8,
+        },
+        update_filter: UpdateFilter {
+            probability: 0.5,
+            ..default()
+        },
+        visuals: Visuals {
+            visible_nodes: VisibleNodes::None,
+            unique_meshes: false,
+            unique_materials: false,
+        },
+    };
+
+    App::new()
+        .insert_resource(ClearColor(Color::BLACK))
+        .insert_resource(cfg)
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup)
+        .add_system(update)
+        .run()
+}
+
+/// test configuration
+struct Cfg {
+    /// which test case should be inserted
+    test_case: TestCase,
+    /// which entities should be updated
+    update_filter: UpdateFilter,
+    /// which entities should be displayed
+    visuals: Visuals,
+}
+
+#[allow(unused)]
+enum TestCase {
+    /// a uniform tree, exponentially growing with depth
+    Tree {
+        /// total depth
+        depth: u32,
+        /// number of children per node
+        branch_width: u32,
+    },
+    /// a non uniform tree (one side is deeper than the other)
+    /// creates significantly less nodes than `TestCase::Tree` with the same parameters
+    NonUniformTree {
+        /// the maximum depth
+        depth: u32,
+        /// max number of children per node
+        branch_width: u32,
+    },
+    /// one or multiple humanoid rigs
+    Humanoids {
+        /// number of active instances (uses the specified [UpdateFilter])
+        active: u32,
+        /// numer of inactive instances (always inactive)
+        inactive: u32,
+    },
+}
+
+/// restrict which nodes are updated
+struct UpdateFilter {
+    /// starting depth (inclusive)
+    min_depth: u32,
+    /// end depth (inclusive)
+    max_depth: u32,
+    /// probability (evaluated at insertion time, not during update)
+    probability: f32,
+}
+
+impl Default for UpdateFilter {
+    fn default() -> Self {
+        Self {
+            min_depth: 0,
+            max_depth: u32::MAX,
+            probability: f32::MAX,
+        }
+    }
+}
+
+/// visibility of nodes
+#[allow(unused)]
+#[derive(PartialEq)]
+enum VisibleNodes {
+    /// draw nothing
+    None,
+    /// draw only leaves
+    Leaves,
+    /// draw all nodes
+    All,
+}
+
+/// visual configuration
+struct Visuals {
+    /// visibility of nodes
+    visible_nodes: VisibleNodes,
+    /// insert a unique mesh for each node, otherwise share the same mesh
+    unique_meshes: bool,
+    /// insert a unique material for each node, otherwise share the same material
+    unique_materials: bool,
+}
+
+// update component with some per-component value
+#[derive(Component)]
+struct Update(f32);
+
+// update positions system
+fn update(time: Res<Time>, mut query: Query<(&mut Transform, &mut Update)>) {
+    for (mut t, mut u) in query.iter_mut() {
+        u.0 += time.delta_seconds() * 0.1;
+        set_translation(&mut t.translation, u.0);
+    }
+}
+
+fn set_translation(translation: &mut Vec3, a: f32) {
+    translation.x = a.cos() * 32.0;
+    translation.y = a.sin() * 32.0;
+}
+
+fn setup(
+    mut commands: Commands,
+    cfg: Res<Cfg>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    let mut cam = OrthographicCameraBundle::new_2d();
+    cam.transform.translation.z = 100.0;
+    commands.spawn_bundle(cam);
+
+    let result = match cfg.test_case {
+        TestCase::Tree {
+            depth,
+            branch_width,
+        } => {
+            let tree = gen_tree(depth, branch_width);
+            spawn_tree(
+                &tree,
+                &mut commands,
+                &mut *meshes,
+                &mut *materials,
+                &cfg.update_filter,
+                &cfg.visuals,
+                default(),
+            )
+        }
+        TestCase::NonUniformTree {
+            depth,
+            branch_width,
+        } => {
+            let tree = gen_non_uniform_tree(depth, branch_width);
+            spawn_tree(
+                &tree,
+                &mut commands,
+                &mut *meshes,
+                &mut *materials,
+                &cfg.update_filter,
+                &cfg.visuals,
+                default(),
+            )
+        }
+        TestCase::Humanoids { active, inactive } => {
+            let mut result = InsertResult::default();
+            let mut rng = rand::thread_rng();
+
+            for _ in 0..active {
+                result.combine(spawn_tree(
+                    &HUMANOID_RIG,
+                    &mut commands,
+                    &mut *meshes,
+                    &mut *materials,
+                    &cfg.update_filter,
+                    &cfg.visuals,
+                    Transform::from_xyz(
+                        rng.gen::<f32>() * 500.0 - 250.0,
+                        rng.gen::<f32>() * 500.0 - 250.0,
+                        0.0,
+                    ),
+                ));
+            }
+
+            for _ in 0..inactive {
+                result.combine(spawn_tree(
+                    &HUMANOID_RIG,
+                    &mut commands,
+                    &mut *meshes,
+                    &mut *materials,
+                    &UpdateFilter {
+                        // disable by setting update probability
+                        probability: -1.0,
+                        ..cfg.update_filter
+                    },
+                    &cfg.visuals,
+                    Transform::from_xyz(
+                        rng.gen::<f32>() * 500.0 - 250.0,
+                        rng.gen::<f32>() * 500.0 - 250.0,
+                        0.0,
+                    ),
+                ));
+            }
+
+            result
+        }
+    };
+
+    println!("{:#?}", result);
+}
+
+#[derive(Default, Debug)]
+struct InsertResult {
+    /// total number of nodes inserted
+    inserted_nodes: usize,
+    /// number of nodes that get moved each frame
+    active_nodes: usize,
+    /// number of nodes that get rendered
+    drawn_nodes: usize,
+    /// maximum depth of the hierarchy tree
+    maximum_depth: usize,
+}
+
+impl InsertResult {
+    fn combine(&mut self, rhs: Self) -> &mut Self {
+        self.inserted_nodes += rhs.inserted_nodes;
+        self.active_nodes += rhs.active_nodes;
+        self.drawn_nodes += rhs.drawn_nodes;
+        self.maximum_depth = self.maximum_depth.max(rhs.maximum_depth);
+        self
+    }
+}
+
+// spawns a tree defined by a parent map (excluding root)
+// the parent map must be ordered (parent must exist before child)
+fn spawn_tree(
+    parent_map: &[usize],
+    commands: &mut Commands,
+    meshes: &mut Assets<Mesh>,
+    materials: &mut Assets<ColorMaterial>,
+    update_filter: &UpdateFilter,
+    visuals: &Visuals,
+    root_transform: Transform,
+) -> InsertResult {
+    // total count (# of nodes + root)
+    let count = parent_map.len() + 1;
+
+    #[derive(Default, Clone, Copy)]
+    struct NodeInfo {
+        child_count: u32,
+        depth: u32,
+    }
+
+    // node index -> entity lookup list
+    let mut ents: Vec<Entity> = Vec::with_capacity(count);
+    let mut node_info: Vec<NodeInfo> = vec![default(); count];
+    for (i, &parent_idx) in parent_map.iter().enumerate() {
+        // assert spawn order (parent must be processed before child)
+        assert!(parent_idx <= i, "invalid spawn order");
+        node_info[parent_idx].child_count += 1;
+    }
+
+    let mut create_mesh = || -> Mesh2dHandle {
+        meshes
+            .add(Mesh::from(shape::Quad {
+                size: Vec2::splat(8.0),
+                flip: false,
+            }))
+            .into()
+    };
+    let mut create_material =
+        |color: Color| -> Handle<ColorMaterial> { materials.add(ColorMaterial::from(color)) };
+
+    let default_mesh = create_mesh();
+    let default_material = create_material(Color::WHITE);
+    let default_material_update = create_material(Color::RED);
+
+    // insert root
+    ents.push(
+        commands
+            .spawn()
+            .insert(root_transform)
+            .insert(GlobalTransform::default())
+            .id(),
+    );
+
+    let mut result = InsertResult::default();
+    let mut rng = rand::thread_rng();
+    // used to count through the number of children (used only for visual layout)
+    let mut child_idx: Vec<u16> = vec![0; count];
+
+    // insert children
+    for (current_idx, &parent_idx) in parent_map.iter().enumerate() {
+        let current_idx = current_idx + 1;
+
+        // separation factor to visually separate children (0..1)
+        let sep = child_idx[parent_idx] as f32 / node_info[parent_idx].child_count as f32;
+        child_idx[parent_idx] += 1;
+
+        // calculate and set depth
+        // this works because it's guaranteed that we have already iterated over the parent
+        let depth = node_info[parent_idx].depth + 1;
+        let info = &mut node_info[current_idx];
+        info.depth = depth;
+
+        // update max depth of tree
+        result.maximum_depth = result.maximum_depth.max(depth.try_into().unwrap());
+
+        // insert child
+        let child_entity = {
+            let mut cmd = commands.spawn();
+
+            // check whether or not to update this node
+            let update = (update_filter.probability >= 1.0
+                || rng.gen::<f32>() <= update_filter.probability)
+                && (depth >= update_filter.min_depth && depth <= update_filter.max_depth);
+
+            // check whether or not to draw this node
+            let draw = visuals.visible_nodes == VisibleNodes::All
+                || (visuals.visible_nodes == VisibleNodes::Leaves && info.child_count == 0);
+
+            if update {
+                cmd.insert(Update(sep));
+                result.active_nodes += 1;
+            }
+
+            let transform = {
+                let mut translation = Vec3::ZERO;
+                // use the same placement fn as the `update` system
+                // this way the entities won't be all at (0, 0, 0) when they don't have an `Update` component
+                set_translation(&mut translation, sep);
+                Transform::from_translation(translation)
+            };
+
+            if draw {
+                result.drawn_nodes += 1;
+
+                let mesh = if visuals.unique_meshes {
+                    create_mesh()
+                } else {
+                    default_mesh.clone()
+                };
+
+                let material = if visuals.unique_materials {
+                    create_material(if update { Color::RED } else { Color::WHITE })
+                } else {
+                    if update {
+                        default_material_update.clone()
+                    } else {
+                        default_material.clone()
+                    }
+                };
+
+                let mut bundle = MaterialMesh2dBundle {
+                    mesh,
+                    material,
+                    transform,
+                    ..default()
+                };
+
+                set_translation(&mut bundle.transform.translation, sep);
+                cmd.insert_bundle(bundle);
+            } else {
+                // only insert the components necessary for the transform propagation
+                cmd.insert(transform).insert(GlobalTransform::default());
+            }
+
+            cmd.id()
+        };
+
+        commands
+            .get_or_spawn(ents[parent_idx])
+            .add_child(child_entity);
+
+        ents.push(child_entity);
+    }
+
+    result.inserted_nodes = ents.len();
+    result
+}
+
+/// generate a tree `depth` levels deep, where each node has `branch_width` children
+fn gen_tree(depth: u32, branch_width: u32) -> Vec<usize> {
+    // calculate total count
+    let mut count: usize = 0;
+    for i in 0..(depth - 1) {
+        count += TryInto::<usize>::try_into(branch_width.pow(i)).unwrap();
+    }
+
+    // the tree is built using this pattern:
+    // 0, 0, 0, ... 1, 1, 1, ... 2, 2, 2, ... (count - 1)
+    (0..count)
+        .flat_map(|i| std::iter::repeat(i).take(branch_width.try_into().unwrap()))
+        .collect()
+}
+
+/// recursive part of [gen_non_uniform_tree]
+fn add_children_non_uniform(
+    tree: &mut Vec<usize>,
+    parent: usize,
+    mut curr_depth: u32,
+    max_branch_width: u32,
+) {
+    for _ in 0..max_branch_width {
+        tree.push(parent);
+
+        curr_depth = curr_depth.checked_sub(1).unwrap();
+        if curr_depth == 0 {
+            return;
+        }
+        add_children_non_uniform(tree, tree.len(), curr_depth, max_branch_width);
+    }
+}
+
+/// generate a tree that has more nodes on one side that the other
+/// the deepest hierarchy path is `max_depth` and the widest branches have `max_branch_width` children
+fn gen_non_uniform_tree(max_depth: u32, max_branch_width: u32) -> Vec<usize> {
+    let mut tree = Vec::new();
+    add_children_non_uniform(&mut tree, 0, max_depth, max_branch_width);
+    tree
+}
+
+// parent map for a decently complex humanoid rig (based on mixamo rig)
+const HUMANOID_RIG: [usize; 67] = [
+    // (0: root)
+    0,  // 1: hips
+    1,  // 2: spine
+    2,  // 3: spine 1
+    3,  // 4: spine 2
+    4,  // 5: neck
+    5,  // 6: head
+    6,  // 7: head top
+    6,  // 8: left eye
+    6,  // 9: right eye
+    4,  // 10: left shoulder
+    10, // 11: left arm
+    11, // 12: left forearm
+    12, // 13: left hand
+    13, // 14: left hand thumb 1
+    14, // 15: left hand thumb 2
+    15, // 16: left hand thumb 3
+    16, // 17: left hand thumb 4
+    13, // 18: left hand index 1
+    18, // 19: left hand index 2
+    19, // 20: left hand index 3
+    20, // 21: left hand index 4
+    13, // 22: left hand middle 1
+    22, // 23: left hand middle 2
+    23, // 24: left hand middle 3
+    24, // 25: left hand middle 4
+    13, // 26: left hand ring 1
+    26, // 27: left hand ring 2
+    27, // 28: left hand ring 3
+    28, // 29: left hand ring 4
+    13, // 30: left hand pinky 1
+    30, // 31: left hand pinky 2
+    31, // 32: left hand pinky 3
+    32, // 33: left hand pinky 4
+    4,  // 34: right shoulder
+    34, // 35: right arm
+    35, // 36: right forearm
+    36, // 37: right hand
+    37, // 38: right hand thumb 1
+    38, // 39: right hand thumb 2
+    39, // 40: right hand thumb 3
+    40, // 41: right hand thumb 4
+    37, // 42: right hand index 1
+    42, // 43: right hand index 2
+    43, // 44: right hand index 3
+    44, // 45: right hand index 4
+    37, // 46: right hand middle 1
+    46, // 47: right hand middle 2
+    47, // 48: right hand middle 3
+    48, // 49: right hand middle 4
+    37, // 50: right hand ring 1
+    50, // 51: right hand ring 2
+    51, // 52: right hand ring 3
+    52, // 53: right hand ring 4
+    37, // 54: right hand pinky 1
+    54, // 55: right hand pinky 2
+    55, // 56: right hand pinky 3
+    56, // 57: right hand pinky 4
+    1,  // 58: left upper leg
+    58, // 59: left leg
+    59, // 60: left foot
+    60, // 61: left toe base
+    61, // 62: left toe end
+    1,  // 63: right upper leg
+    63, // 64: right leg
+    64, // 65: right foot
+    65, // 66: right toe base
+    66, // 67: right toe end
+];

From 60df84e290e5a302b43296afb53cf1d986b69d00 Mon Sep 17 00:00:00 2001
From: CptPotato <3957610+CptPotato@users.noreply.github.com>
Date: Mon, 14 Mar 2022 21:24:45 +0100
Subject: [PATCH 2/4] fix CI, small cleanup

---
 examples/stress_tests/transform_hierarchy.rs | 75 +++++++++++---------
 1 file changed, 41 insertions(+), 34 deletions(-)

diff --git a/examples/stress_tests/transform_hierarchy.rs b/examples/stress_tests/transform_hierarchy.rs
index 5bcf32512fedd..b65bd732bdae8 100644
--- a/examples/stress_tests/transform_hierarchy.rs
+++ b/examples/stress_tests/transform_hierarchy.rs
@@ -1,5 +1,5 @@
 //! hierarchy and transform propagation stress test
-//! set the test parameters inside [main]
+//! set the test parameters (cfg) inside [`main`]
 
 use bevy::{
     prelude::*,
@@ -24,6 +24,8 @@ fn main() {
         },
     };
 
+    println!("\n{:#?}", cfg);
+
     App::new()
         .insert_resource(ClearColor(Color::BLACK))
         .insert_resource(cfg)
@@ -34,6 +36,7 @@ fn main() {
 }
 
 /// test configuration
+#[derive(Debug)]
 struct Cfg {
     /// which test case should be inserted
     test_case: TestCase,
@@ -44,6 +47,7 @@ struct Cfg {
 }
 
 #[allow(unused)]
+#[derive(Debug)]
 enum TestCase {
     /// a uniform tree, exponentially growing with depth
     Tree {
@@ -62,20 +66,22 @@ enum TestCase {
     },
     /// one or multiple humanoid rigs
     Humanoids {
-        /// number of active instances (uses the specified [UpdateFilter])
+        /// number of active instances (uses the specified [`UpdateFilter`])
         active: u32,
-        /// numer of inactive instances (always inactive)
+        /// number of inactive instances (always inactive)
         inactive: u32,
     },
 }
 
-/// restrict which nodes are updated
+/// a filter to restrict which nodes are updated
+#[derive(Debug)]
 struct UpdateFilter {
     /// starting depth (inclusive)
     min_depth: u32,
     /// end depth (inclusive)
     max_depth: u32,
-    /// probability (evaluated at insertion time, not during update)
+    /// probability of a node to get updated (evaluated at insertion time, not during update)
+    /// 0 (never) .. 1 (always)
     probability: f32,
 }
 
@@ -89,9 +95,20 @@ impl Default for UpdateFilter {
     }
 }
 
+/// visual configuration
+#[derive(Debug)]
+struct Visuals {
+    /// visibility of nodes
+    visible_nodes: VisibleNodes,
+    /// insert a unique mesh for each node, otherwise share the same mesh
+    unique_meshes: bool,
+    /// insert a unique material for each node, otherwise share the same material
+    unique_materials: bool,
+}
+
 /// visibility of nodes
 #[allow(unused)]
-#[derive(PartialEq)]
+#[derive(PartialEq, Debug)]
 enum VisibleNodes {
     /// draw nothing
     None,
@@ -101,21 +118,11 @@ enum VisibleNodes {
     All,
 }
 
-/// visual configuration
-struct Visuals {
-    /// visibility of nodes
-    visible_nodes: VisibleNodes,
-    /// insert a unique mesh for each node, otherwise share the same mesh
-    unique_meshes: bool,
-    /// insert a unique material for each node, otherwise share the same material
-    unique_materials: bool,
-}
-
-// update component with some per-component value
+/// update component with some per-component value
 #[derive(Component)]
 struct Update(f32);
 
-// update positions system
+/// update positions system
 fn update(time: Res<Time>, mut query: Query<(&mut Transform, &mut Update)>) {
     for (mut t, mut u) in query.iter_mut() {
         u.0 += time.delta_seconds() * 0.1;
@@ -123,6 +130,7 @@ fn update(time: Res<Time>, mut query: Query<(&mut Transform, &mut Update)>) {
     }
 }
 
+/// set translation based on the angle `a`
 fn set_translation(translation: &mut Vec3, a: f32) {
     translation.x = a.cos() * 32.0;
     translation.y = a.sin() * 32.0;
@@ -196,7 +204,7 @@ fn setup(
                     &mut *meshes,
                     &mut *materials,
                     &UpdateFilter {
-                        // disable by setting update probability
+                        // force inactive by setting the probability < 0
                         probability: -1.0,
                         ..cfg.update_filter
                     },
@@ -213,14 +221,15 @@ fn setup(
         }
     };
 
-    println!("{:#?}", result);
+    println!("\n{:#?}", result);
 }
 
+/// overview of the inserted hierarchy
 #[derive(Default, Debug)]
 struct InsertResult {
     /// total number of nodes inserted
     inserted_nodes: usize,
-    /// number of nodes that get moved each frame
+    /// number of nodes that get updated each frame
     active_nodes: usize,
     /// number of nodes that get rendered
     drawn_nodes: usize,
@@ -238,8 +247,8 @@ impl InsertResult {
     }
 }
 
-// spawns a tree defined by a parent map (excluding root)
-// the parent map must be ordered (parent must exist before child)
+/// spawns a tree defined by a parent map (excluding root)
+/// the parent map must be ordered (parent must exist before child)
 fn spawn_tree(
     parent_map: &[usize],
     commands: &mut Commands,
@@ -318,8 +327,7 @@ fn spawn_tree(
             let mut cmd = commands.spawn();
 
             // check whether or not to update this node
-            let update = (update_filter.probability >= 1.0
-                || rng.gen::<f32>() <= update_filter.probability)
+            let update = (rng.gen::<f32>() <= update_filter.probability)
                 && (depth >= update_filter.min_depth && depth <= update_filter.max_depth);
 
             // check whether or not to draw this node
@@ -348,14 +356,13 @@ fn spawn_tree(
                     default_mesh.clone()
                 };
 
+                // material: red (entities with `Update` component) or white (entities without `Update`)
                 let material = if visuals.unique_materials {
                     create_material(if update { Color::RED } else { Color::WHITE })
+                } else if update {
+                    default_material_update.clone()
                 } else {
-                    if update {
-                        default_material_update.clone()
-                    } else {
-                        default_material.clone()
-                    }
+                    default_material.clone()
                 };
 
                 let mut bundle = MaterialMesh2dBundle {
@@ -364,8 +371,8 @@ fn spawn_tree(
                     transform,
                     ..default()
                 };
-
                 set_translation(&mut bundle.transform.translation, sep);
+
                 cmd.insert_bundle(bundle);
             } else {
                 // only insert the components necessary for the transform propagation
@@ -388,7 +395,7 @@ fn spawn_tree(
 
 /// generate a tree `depth` levels deep, where each node has `branch_width` children
 fn gen_tree(depth: u32, branch_width: u32) -> Vec<usize> {
-    // calculate total count
+    // calculate the total count of branches
     let mut count: usize = 0;
     for i in 0..(depth - 1) {
         count += TryInto::<usize>::try_into(branch_width.pow(i)).unwrap();
@@ -401,7 +408,7 @@ fn gen_tree(depth: u32, branch_width: u32) -> Vec<usize> {
         .collect()
 }
 
-/// recursive part of [gen_non_uniform_tree]
+/// recursive part of [`gen_non_uniform_tree`]
 fn add_children_non_uniform(
     tree: &mut Vec<usize>,
     parent: usize,
@@ -427,7 +434,7 @@ fn gen_non_uniform_tree(max_depth: u32, max_branch_width: u32) -> Vec<usize> {
     tree
 }
 
-// parent map for a decently complex humanoid rig (based on mixamo rig)
+/// parent map for a decently complex humanoid rig (based on mixamo rig)
 const HUMANOID_RIG: [usize; 67] = [
     // (0: root)
     0,  // 1: hips

From 615457fa53c40abfb5bac231004aa6934352bfe8 Mon Sep 17 00:00:00 2001
From: CptPotato <3957610+CptPotato@users.noreply.github.com>
Date: Sun, 20 Mar 2022 18:38:24 +0100
Subject: [PATCH 3/4] add test cases + ci fixes

---
 examples/README.md                           |   6 +-
 examples/stress_tests/transform_hierarchy.rs | 281 +++++++++++++++++--
 2 files changed, 266 insertions(+), 21 deletions(-)

diff --git a/examples/README.md b/examples/README.md
index cc8a20ea16a2a..5d2d92c00f4c5 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -65,7 +65,7 @@ git checkout v0.4.0
   - [WASM](#wasm)
     - [Setup](#setup-2)
     - [Build & Run](#build--run-2)
-- [Stree Tests](#stress-tests)
+- [Stress Tests](#stress-tests)
 
 # The Bare Minimum
 
@@ -412,6 +412,8 @@ the assets on Windows.
 
 # Stress Tests
 
+These examples are used to test the performance and stability of various parts of the engine in an isolated way.
+
 Example | File | Description
 --- | --- | ---
-`transform_hierarchy.rs` | [`stress_tests/transform_hierarchy.rs`](./stress_tests/transform_hierarchy.rs) | Configurable test for hierarchy and transform propagation performance
+`transform_hierarchy.rs` | [`stress_tests/transform_hierarchy.rs`](./stress_tests/transform_hierarchy.rs) | Various test cases for hierarchy and transform propagation performance
diff --git a/examples/stress_tests/transform_hierarchy.rs b/examples/stress_tests/transform_hierarchy.rs
index b65bd732bdae8..183b9a77fd0ae 100644
--- a/examples/stress_tests/transform_hierarchy.rs
+++ b/examples/stress_tests/transform_hierarchy.rs
@@ -1,5 +1,24 @@
-//! hierarchy and transform propagation stress test
-//! set the test parameters (cfg) inside [`main`]
+//! Hierarchy and transform propagation stress test.
+//!
+//! Running this example:
+//!
+//! ```
+//! cargo r --release --example transform_hierarchy -- <configuration name>
+//! ```
+//!
+//! | Configuration        | Description                                                       |
+//! | -------------------- | ----------------------------------------------------------------- |
+//! | `large_tree`         | A fairly wide and deep tree.                                      |
+//! | `wide_tree`          | A shallow but very wide tree.                                     |
+//! | `deep_tree`          | A deep but not very wide tree.                                    |
+//! | `chain`              | A chain. 2500 levels deep.                                        |
+//! | `update_leaves`      | Same as `large_tree`, but only leaves are updated.                |
+//! | `update_shallow`     | Same as `large_tree`, but only the first few levels are updated.  |
+//! | `humanoids_active`   | 4000 active humanoid rigs.                                        |
+//! | `humanoids_inactive` | 4000 humanoid rigs. Only 10 are active.                           |
+//! | `humanoids_mixed`    | 2000 inactive and 2000 active humanoid rigs.                      |
+//! | `drawing`            | A rendering-heavy configuration. Meshes and materials are shared. |
+//! | `drawing_unique`     | Same as `drawing`, but all meshes and materials are unique.       |
 
 use bevy::{
     prelude::*,
@@ -7,21 +26,245 @@ use bevy::{
 };
 use rand::Rng;
 
-fn main() {
-    let cfg = Cfg {
-        test_case: TestCase::NonUniformTree {
-            depth: 18,
-            branch_width: 8,
+/// pre-defined test configurations with name
+const CONFIGS: [(&str, Cfg); 11] = [
+    (
+        "large_tree",
+        Cfg {
+            test_case: TestCase::NonUniformTree {
+                depth: 18,
+                branch_width: 8,
+            },
+            update_filter: UpdateFilter {
+                probability: 0.5,
+                min_depth: 0,
+                max_depth: u32::MAX,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::None,
+                unique_meshes: false,
+                unique_materials: false,
+            },
+        },
+    ),
+    (
+        "wide_tree",
+        Cfg {
+            test_case: TestCase::Tree {
+                depth: 3,
+                branch_width: 500,
+            },
+            update_filter: UpdateFilter {
+                probability: 0.5,
+                min_depth: 0,
+                max_depth: u32::MAX,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::None,
+                unique_meshes: false,
+                unique_materials: false,
+            },
+        },
+    ),
+    (
+        "deep_tree",
+        Cfg {
+            test_case: TestCase::NonUniformTree {
+                depth: 25,
+                branch_width: 2,
+            },
+            update_filter: UpdateFilter {
+                probability: 0.5,
+                min_depth: 0,
+                max_depth: u32::MAX,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::None,
+                unique_meshes: false,
+                unique_materials: false,
+            },
+        },
+    ),
+    (
+        "chain",
+        Cfg {
+            test_case: TestCase::Tree {
+                depth: 2500,
+                branch_width: 1,
+            },
+            update_filter: UpdateFilter {
+                probability: 0.5,
+                min_depth: 0,
+                max_depth: u32::MAX,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::None,
+                unique_meshes: false,
+                unique_materials: false,
+            },
+        },
+    ),
+    (
+        "update_leaves",
+        Cfg {
+            test_case: TestCase::Tree {
+                depth: 18,
+                branch_width: 2,
+            },
+            update_filter: UpdateFilter {
+                probability: 0.5,
+                min_depth: 17,
+                max_depth: u32::MAX,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::None,
+                unique_meshes: false,
+                unique_materials: false,
+            },
+        },
+    ),
+    (
+        "update_shallow",
+        Cfg {
+            test_case: TestCase::Tree {
+                depth: 18,
+                branch_width: 2,
+            },
+            update_filter: UpdateFilter {
+                probability: 0.5,
+                min_depth: 0,
+                max_depth: 8,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::None,
+                unique_meshes: false,
+                unique_materials: false,
+            },
+        },
+    ),
+    (
+        "humanoids_active",
+        Cfg {
+            test_case: TestCase::Humanoids {
+                active: 4000,
+                inactive: 0,
+            },
+            update_filter: UpdateFilter {
+                probability: 1.0,
+                min_depth: 0,
+                max_depth: u32::MAX,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::None,
+                unique_meshes: false,
+                unique_materials: false,
+            },
+        },
+    ),
+    (
+        "humanoids_inactive",
+        Cfg {
+            test_case: TestCase::Humanoids {
+                active: 10,
+                inactive: 3990,
+            },
+            update_filter: UpdateFilter {
+                probability: 1.0,
+                min_depth: 0,
+                max_depth: u32::MAX,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::None,
+                unique_meshes: false,
+                unique_materials: false,
+            },
+        },
+    ),
+    (
+        "humanoids_mixed",
+        Cfg {
+            test_case: TestCase::Humanoids {
+                active: 2000,
+                inactive: 2000,
+            },
+            update_filter: UpdateFilter {
+                probability: 1.0,
+                min_depth: 0,
+                max_depth: u32::MAX,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::None,
+                unique_meshes: false,
+                unique_materials: false,
+            },
+        },
+    ),
+    (
+        "drawing",
+        Cfg {
+            test_case: TestCase::Humanoids {
+                active: 150,
+                inactive: 500,
+            },
+            update_filter: UpdateFilter {
+                probability: 1.0,
+                min_depth: 0,
+                max_depth: u32::MAX,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::All,
+                unique_meshes: false,
+                unique_materials: false,
+            },
         },
-        update_filter: UpdateFilter {
-            probability: 0.5,
-            ..default()
+    ),
+    (
+        "drawing_unique",
+        Cfg {
+            test_case: TestCase::Humanoids {
+                active: 150,
+                inactive: 500,
+            },
+            update_filter: UpdateFilter {
+                probability: 1.0,
+                min_depth: 0,
+                max_depth: u32::MAX,
+            },
+            visuals: Visuals {
+                visible_nodes: VisibleNodes::All,
+                unique_meshes: true,
+                unique_materials: true,
+            },
         },
-        visuals: Visuals {
-            visible_nodes: VisibleNodes::None,
-            unique_meshes: false,
-            unique_materials: false,
+    ),
+];
+
+fn print_available_configs() {
+    println!("available configurations:");
+    for (name, _) in CONFIGS {
+        println!("  {name}");
+    }
+}
+
+fn main() {
+    // parse arg and find test configuration
+    let cfg: Cfg = match std::env::args().nth(1) {
+        Some(arg) => match CONFIGS.iter().find(|(name, _)| *name == arg) {
+            Some((name, cfg)) => {
+                println!("test configuration: {name}");
+                cfg.clone()
+            }
+            None => {
+                println!("test configuration \"{arg}\" not found.\n");
+                print_available_configs();
+                return;
+            }
         },
+        None => {
+            println!("missing argument: <test configuration>\n");
+            print_available_configs();
+            return;
+        }
     };
 
     println!("\n{:#?}", cfg);
@@ -36,7 +279,7 @@ fn main() {
 }
 
 /// test configuration
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct Cfg {
     /// which test case should be inserted
     test_case: TestCase,
@@ -47,7 +290,7 @@ struct Cfg {
 }
 
 #[allow(unused)]
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 enum TestCase {
     /// a uniform tree, exponentially growing with depth
     Tree {
@@ -74,7 +317,7 @@ enum TestCase {
 }
 
 /// a filter to restrict which nodes are updated
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct UpdateFilter {
     /// starting depth (inclusive)
     min_depth: u32,
@@ -96,7 +339,7 @@ impl Default for UpdateFilter {
 }
 
 /// visual configuration
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct Visuals {
     /// visibility of nodes
     visible_nodes: VisibleNodes,
@@ -108,7 +351,7 @@ struct Visuals {
 
 /// visibility of nodes
 #[allow(unused)]
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Debug, Clone)]
 enum VisibleNodes {
     /// draw nothing
     None,

From 8ae7e5ed00e996e984ea5020b3fbb6e3d1ca0d6e Mon Sep 17 00:00:00 2001
From: CptPotato <3957610+CptPotato@users.noreply.github.com>
Date: Mon, 21 Mar 2022 15:12:13 +0100
Subject: [PATCH 4/4] remove drawing related code, some cleanups

---
 examples/README.md                           |   6 +
 examples/stress_tests/transform_hierarchy.rs | 228 +------------------
 2 files changed, 18 insertions(+), 216 deletions(-)

diff --git a/examples/README.md b/examples/README.md
index 5d2d92c00f4c5..21b9c50c6c8f9 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -414,6 +414,12 @@ the assets on Windows.
 
 These examples are used to test the performance and stability of various parts of the engine in an isolated way.
 
+Due to the focus on performance it's recommended to run the stress tests in release mode:
+
+```sh
+cargo run --release --example <example name>
+```
+
 Example | File | Description
 --- | --- | ---
 `transform_hierarchy.rs` | [`stress_tests/transform_hierarchy.rs`](./stress_tests/transform_hierarchy.rs) | Various test cases for hierarchy and transform propagation performance
diff --git a/examples/stress_tests/transform_hierarchy.rs b/examples/stress_tests/transform_hierarchy.rs
index 183b9a77fd0ae..360f992f129f6 100644
--- a/examples/stress_tests/transform_hierarchy.rs
+++ b/examples/stress_tests/transform_hierarchy.rs
@@ -16,18 +16,13 @@
 //! | `update_shallow`     | Same as `large_tree`, but only the first few levels are updated.  |
 //! | `humanoids_active`   | 4000 active humanoid rigs.                                        |
 //! | `humanoids_inactive` | 4000 humanoid rigs. Only 10 are active.                           |
-//! | `humanoids_mixed`    | 2000 inactive and 2000 active humanoid rigs.                      |
-//! | `drawing`            | A rendering-heavy configuration. Meshes and materials are shared. |
-//! | `drawing_unique`     | Same as `drawing`, but all meshes and materials are unique.       |
-
-use bevy::{
-    prelude::*,
-    sprite::{MaterialMesh2dBundle, Mesh2dHandle},
-};
+//! | `humanoids_mixed`    | 2000 active and 2000 inactive humanoid rigs.                      |
+
+use bevy::prelude::*;
 use rand::Rng;
 
 /// pre-defined test configurations with name
-const CONFIGS: [(&str, Cfg); 11] = [
+const CONFIGS: [(&str, Cfg); 9] = [
     (
         "large_tree",
         Cfg {
@@ -40,11 +35,6 @@ const CONFIGS: [(&str, Cfg); 11] = [
                 min_depth: 0,
                 max_depth: u32::MAX,
             },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::None,
-                unique_meshes: false,
-                unique_materials: false,
-            },
         },
     ),
     (
@@ -59,11 +49,6 @@ const CONFIGS: [(&str, Cfg); 11] = [
                 min_depth: 0,
                 max_depth: u32::MAX,
             },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::None,
-                unique_meshes: false,
-                unique_materials: false,
-            },
         },
     ),
     (
@@ -78,11 +63,6 @@ const CONFIGS: [(&str, Cfg); 11] = [
                 min_depth: 0,
                 max_depth: u32::MAX,
             },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::None,
-                unique_meshes: false,
-                unique_materials: false,
-            },
         },
     ),
     (
@@ -97,11 +77,6 @@ const CONFIGS: [(&str, Cfg); 11] = [
                 min_depth: 0,
                 max_depth: u32::MAX,
             },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::None,
-                unique_meshes: false,
-                unique_materials: false,
-            },
         },
     ),
     (
@@ -116,11 +91,6 @@ const CONFIGS: [(&str, Cfg); 11] = [
                 min_depth: 17,
                 max_depth: u32::MAX,
             },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::None,
-                unique_meshes: false,
-                unique_materials: false,
-            },
         },
     ),
     (
@@ -135,11 +105,6 @@ const CONFIGS: [(&str, Cfg); 11] = [
                 min_depth: 0,
                 max_depth: 8,
             },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::None,
-                unique_meshes: false,
-                unique_materials: false,
-            },
         },
     ),
     (
@@ -154,11 +119,6 @@ const CONFIGS: [(&str, Cfg); 11] = [
                 min_depth: 0,
                 max_depth: u32::MAX,
             },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::None,
-                unique_meshes: false,
-                unique_materials: false,
-            },
         },
     ),
     (
@@ -173,11 +133,6 @@ const CONFIGS: [(&str, Cfg); 11] = [
                 min_depth: 0,
                 max_depth: u32::MAX,
             },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::None,
-                unique_meshes: false,
-                unique_materials: false,
-            },
         },
     ),
     (
@@ -192,49 +147,6 @@ const CONFIGS: [(&str, Cfg); 11] = [
                 min_depth: 0,
                 max_depth: u32::MAX,
             },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::None,
-                unique_meshes: false,
-                unique_materials: false,
-            },
-        },
-    ),
-    (
-        "drawing",
-        Cfg {
-            test_case: TestCase::Humanoids {
-                active: 150,
-                inactive: 500,
-            },
-            update_filter: UpdateFilter {
-                probability: 1.0,
-                min_depth: 0,
-                max_depth: u32::MAX,
-            },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::All,
-                unique_meshes: false,
-                unique_materials: false,
-            },
-        },
-    ),
-    (
-        "drawing_unique",
-        Cfg {
-            test_case: TestCase::Humanoids {
-                active: 150,
-                inactive: 500,
-            },
-            update_filter: UpdateFilter {
-                probability: 1.0,
-                min_depth: 0,
-                max_depth: u32::MAX,
-            },
-            visuals: Visuals {
-                visible_nodes: VisibleNodes::All,
-                unique_meshes: true,
-                unique_materials: true,
-            },
         },
     ),
 ];
@@ -247,7 +159,7 @@ fn print_available_configs() {
 }
 
 fn main() {
-    // parse arg and find test configuration
+    // parse cli argument and find the selected test configuration
     let cfg: Cfg = match std::env::args().nth(1) {
         Some(arg) => match CONFIGS.iter().find(|(name, _)| *name == arg) {
             Some((name, cfg)) => {
@@ -270,9 +182,9 @@ fn main() {
     println!("\n{:#?}", cfg);
 
     App::new()
-        .insert_resource(ClearColor(Color::BLACK))
         .insert_resource(cfg)
-        .add_plugins(DefaultPlugins)
+        .add_plugins(MinimalPlugins)
+        .add_plugin(TransformPlugin::default())
         .add_startup_system(setup)
         .add_system(update)
         .run()
@@ -285,8 +197,6 @@ struct Cfg {
     test_case: TestCase,
     /// which entities should be updated
     update_filter: UpdateFilter,
-    /// which entities should be displayed
-    visuals: Visuals,
 }
 
 #[allow(unused)]
@@ -328,39 +238,6 @@ struct UpdateFilter {
     probability: f32,
 }
 
-impl Default for UpdateFilter {
-    fn default() -> Self {
-        Self {
-            min_depth: 0,
-            max_depth: u32::MAX,
-            probability: f32::MAX,
-        }
-    }
-}
-
-/// visual configuration
-#[derive(Debug, Clone)]
-struct Visuals {
-    /// visibility of nodes
-    visible_nodes: VisibleNodes,
-    /// insert a unique mesh for each node, otherwise share the same mesh
-    unique_meshes: bool,
-    /// insert a unique material for each node, otherwise share the same material
-    unique_materials: bool,
-}
-
-/// visibility of nodes
-#[allow(unused)]
-#[derive(PartialEq, Debug, Clone)]
-enum VisibleNodes {
-    /// draw nothing
-    None,
-    /// draw only leaves
-    Leaves,
-    /// draw all nodes
-    All,
-}
-
 /// update component with some per-component value
 #[derive(Component)]
 struct Update(f32);
@@ -379,12 +256,7 @@ fn set_translation(translation: &mut Vec3, a: f32) {
     translation.y = a.sin() * 32.0;
 }
 
-fn setup(
-    mut commands: Commands,
-    cfg: Res<Cfg>,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-) {
+fn setup(mut commands: Commands, cfg: Res<Cfg>) {
     let mut cam = OrthographicCameraBundle::new_2d();
     cam.transform.translation.z = 100.0;
     commands.spawn_bundle(cam);
@@ -395,30 +267,14 @@ fn setup(
             branch_width,
         } => {
             let tree = gen_tree(depth, branch_width);
-            spawn_tree(
-                &tree,
-                &mut commands,
-                &mut *meshes,
-                &mut *materials,
-                &cfg.update_filter,
-                &cfg.visuals,
-                default(),
-            )
+            spawn_tree(&tree, &mut commands, &cfg.update_filter, default())
         }
         TestCase::NonUniformTree {
             depth,
             branch_width,
         } => {
             let tree = gen_non_uniform_tree(depth, branch_width);
-            spawn_tree(
-                &tree,
-                &mut commands,
-                &mut *meshes,
-                &mut *materials,
-                &cfg.update_filter,
-                &cfg.visuals,
-                default(),
-            )
+            spawn_tree(&tree, &mut commands, &cfg.update_filter, default())
         }
         TestCase::Humanoids { active, inactive } => {
             let mut result = InsertResult::default();
@@ -428,10 +284,7 @@ fn setup(
                 result.combine(spawn_tree(
                     &HUMANOID_RIG,
                     &mut commands,
-                    &mut *meshes,
-                    &mut *materials,
                     &cfg.update_filter,
-                    &cfg.visuals,
                     Transform::from_xyz(
                         rng.gen::<f32>() * 500.0 - 250.0,
                         rng.gen::<f32>() * 500.0 - 250.0,
@@ -444,14 +297,11 @@ fn setup(
                 result.combine(spawn_tree(
                     &HUMANOID_RIG,
                     &mut commands,
-                    &mut *meshes,
-                    &mut *materials,
                     &UpdateFilter {
                         // force inactive by setting the probability < 0
                         probability: -1.0,
                         ..cfg.update_filter
                     },
-                    &cfg.visuals,
                     Transform::from_xyz(
                         rng.gen::<f32>() * 500.0 - 250.0,
                         rng.gen::<f32>() * 500.0 - 250.0,
@@ -474,8 +324,6 @@ struct InsertResult {
     inserted_nodes: usize,
     /// number of nodes that get updated each frame
     active_nodes: usize,
-    /// number of nodes that get rendered
-    drawn_nodes: usize,
     /// maximum depth of the hierarchy tree
     maximum_depth: usize,
 }
@@ -484,7 +332,6 @@ impl InsertResult {
     fn combine(&mut self, rhs: Self) -> &mut Self {
         self.inserted_nodes += rhs.inserted_nodes;
         self.active_nodes += rhs.active_nodes;
-        self.drawn_nodes += rhs.drawn_nodes;
         self.maximum_depth = self.maximum_depth.max(rhs.maximum_depth);
         self
     }
@@ -495,10 +342,7 @@ impl InsertResult {
 fn spawn_tree(
     parent_map: &[usize],
     commands: &mut Commands,
-    meshes: &mut Assets<Mesh>,
-    materials: &mut Assets<ColorMaterial>,
     update_filter: &UpdateFilter,
-    visuals: &Visuals,
     root_transform: Transform,
 ) -> InsertResult {
     // total count (# of nodes + root)
@@ -519,21 +363,6 @@ fn spawn_tree(
         node_info[parent_idx].child_count += 1;
     }
 
-    let mut create_mesh = || -> Mesh2dHandle {
-        meshes
-            .add(Mesh::from(shape::Quad {
-                size: Vec2::splat(8.0),
-                flip: false,
-            }))
-            .into()
-    };
-    let mut create_material =
-        |color: Color| -> Handle<ColorMaterial> { materials.add(ColorMaterial::from(color)) };
-
-    let default_mesh = create_mesh();
-    let default_material = create_material(Color::WHITE);
-    let default_material_update = create_material(Color::RED);
-
     // insert root
     ents.push(
         commands
@@ -573,10 +402,6 @@ fn spawn_tree(
             let update = (rng.gen::<f32>() <= update_filter.probability)
                 && (depth >= update_filter.min_depth && depth <= update_filter.max_depth);
 
-            // check whether or not to draw this node
-            let draw = visuals.visible_nodes == VisibleNodes::All
-                || (visuals.visible_nodes == VisibleNodes::Leaves && info.child_count == 0);
-
             if update {
                 cmd.insert(Update(sep));
                 result.active_nodes += 1;
@@ -590,37 +415,8 @@ fn spawn_tree(
                 Transform::from_translation(translation)
             };
 
-            if draw {
-                result.drawn_nodes += 1;
-
-                let mesh = if visuals.unique_meshes {
-                    create_mesh()
-                } else {
-                    default_mesh.clone()
-                };
-
-                // material: red (entities with `Update` component) or white (entities without `Update`)
-                let material = if visuals.unique_materials {
-                    create_material(if update { Color::RED } else { Color::WHITE })
-                } else if update {
-                    default_material_update.clone()
-                } else {
-                    default_material.clone()
-                };
-
-                let mut bundle = MaterialMesh2dBundle {
-                    mesh,
-                    material,
-                    transform,
-                    ..default()
-                };
-                set_translation(&mut bundle.transform.translation, sep);
-
-                cmd.insert_bundle(bundle);
-            } else {
-                // only insert the components necessary for the transform propagation
-                cmd.insert(transform).insert(GlobalTransform::default());
-            }
+            // only insert the components necessary for the transform propagation
+            cmd.insert(transform).insert(GlobalTransform::default());
 
             cmd.id()
         };