Transform Propagation Optimization: Static Subtree Marking

crates/bevy_transform/src/components/transform.rs

@@ -63,7 +63,11 @@ fn assert_is_normalized(message: &str, length_squared: f32) {
 /// [transform_example]: https://github.com/bevyengine/bevy/blob/latest/examples/transforms/transform.rs
 #[derive(Debug, PartialEq, Clone, Copy)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "bevy-support", derive(Component), require(GlobalTransform))]
+#[cfg_attr(
+    feature = "bevy-support",
+    derive(Component),
+    require(GlobalTransform, TransformTreeChanged)
+)]
 #[cfg_attr(
     feature = "bevy_reflect",
     derive(Reflect),
@@ -644,3 +648,20 @@ impl Mul<Vec3> for Transform {
         self.transform_point(value)
     }
 }
+
+/// An optimization for transform propagation. This ZST marker component uses change detection to
+/// mark all entities of the hierarchy as "dirty" if any of their descendants have a changed
+/// `Transform`. If this component is *not* marked `is_changed()`, propagation will halt.
+#[derive(Clone, Copy, Default, PartialEq, Debug)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "bevy-support", derive(Component))]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Component, Default, PartialEq, Debug)
+)]
+#[cfg_attr(
+    all(feature = "bevy_reflect", feature = "serialize"),
+    reflect(Serialize, Deserialize)
+)]
+pub struct TransformTreeChanged;

crates/bevy_transform/src/plugins.rs

@@ -1,6 +1,4 @@
-use crate::systems::{
-    compute_transform_leaves, propagate_parent_transforms, sync_simple_transforms,
-};
+use crate::systems::{mark_dirty_trees, propagate_parent_transforms, sync_simple_transforms};
 use bevy_app::{App, Plugin, PostStartup, PostUpdate};
 use bevy_ecs::schedule::{IntoScheduleConfigs, SystemSet};
 
@@ -17,43 +15,33 @@ pub struct TransformPlugin;
 
 impl Plugin for TransformPlugin {
     fn build(&self, app: &mut App) {
-        // A set for `propagate_transforms` to mark it as ambiguous with `sync_simple_transforms`.
-        // Used instead of the `SystemTypeSet` as that would not allow multiple instances of the system.
-        #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
-        struct PropagateTransformsSet;
-
         #[cfg(feature = "bevy_reflect")]
         app.register_type::<crate::components::Transform>()
+            .register_type::<crate::components::TransformTreeChanged>()
             .register_type::<crate::components::GlobalTransform>();
 
-        app.configure_sets(
-            PostStartup,
-            PropagateTransformsSet.in_set(TransformSystem::TransformPropagate),
-        )
-        // add transform systems to startup so the first update is "correct"
-        .add_systems(
-            PostStartup,
-            (
-                propagate_parent_transforms,
-                (compute_transform_leaves, sync_simple_transforms)
-                    .ambiguous_with(TransformSystem::TransformPropagate),
-            )
-                .chain()
-                .in_set(PropagateTransformsSet),
-        )
-        .configure_sets(
-            PostUpdate,
-            PropagateTransformsSet.in_set(TransformSystem::TransformPropagate),
-        )
-        .add_systems(
-            PostUpdate,
-            (
-                propagate_parent_transforms,
-                (compute_transform_leaves, sync_simple_transforms) // TODO: Adjust the internal parallel queries to make these parallel systems more efficiently share and fill CPU time.
-                    .ambiguous_with(TransformSystem::TransformPropagate),
+        app
+            // add transform systems to startup so the first update is "correct"
+            .add_systems(
+                PostStartup,
+                (
+                    mark_dirty_trees,
+                    propagate_parent_transforms,
+                    sync_simple_transforms,
+                )
+                    .chain()
+                    .in_set(TransformSystem::TransformPropagate),
             )
-                .chain()
-                .in_set(PropagateTransformsSet),
-        );
+            .add_systems(
+                PostUpdate,
+                (
+                    mark_dirty_trees,
+                    propagate_parent_transforms,
+                    // TODO: Adjust the internal parallel queries to make this system more efficiently share and fill CPU time.
+                    sync_simple_transforms,
+                )
+                    .chain()
+                    .in_set(TransformSystem::TransformPropagate),
+            );
     }
 }