Fix init_physics_transform running twice and breaking scene hierarchies (#873)

# Objective

The `init_physics_transform` hook can fail for scenes, because hierarchies may not be finalized in hooks (see bevyengine/bevy#18671). This normally doesn't actually cause problems, but in a very specific case where an entity has both a `RigidBody` and `Collider` (causing `init_physics_transform` to be called twice) in a hierarchy, and the insertion of one of the components is deferred such that the hierarchy *is* finalized for that one but not the other, the computed global transforms will end up being wrong. Yeah.

## Solution

For now, just avoid calling `init_physics_transform` twice by checking if the entity has a `RigidBody` for colliders.

Additionally, only run `transform_to_position` logic for `Position` and `Rotation` if they were not just added, to avoid using the invalid values. Propagation will fix things up later.

## Testing

The [`physics_avian`](https://github.com/Noxmore/bevy_trenchbroom/tree/main/example/physics_avian) example from bevy_trenchbroom, adding a `RigidBody` for the brushes.

Author: Jondolf

src/collision/collider/backend.rs

@@ -108,47 +108,53 @@ impl<C: ScalableCollider> Plugin for ColliderBackendPlugin<C> {
         let hooks = app.world_mut().register_component_hooks::<C>();
 
         // Initialize missing components for colliders.
-        hooks.on_add(|mut world, ctx| {
-            // Initialize the global physics transform for the collider.
-            init_physics_transform(&mut world, &ctx);
-
-            let scale = world
-                .entity(ctx.entity)
-                .get::<GlobalTransform>()
-                .map(|gt| gt.scale())
-                .unwrap_or_default();
-            #[cfg(feature = "2d")]
-            let scale = scale.xy();
-
-            let mut entity_mut = world.entity_mut(ctx.entity);
-
-            // Make sure the collider is initialized with the correct scale.
-            // This overwrites the scale set by the constructor, but that one is
-            // meant to be only changed after initialization.
-            entity_mut
-                .get_mut::<C>()
-                .unwrap()
-                .set_scale(scale.adjust_precision(), 10);
-
-            let collider = entity_mut.get::<C>().unwrap();
-
-            let density = entity_mut
-                .get::<ColliderDensity>()
-                .copied()
-                .unwrap_or_default();
-
-            let mass_properties = if entity_mut.get::<Sensor>().is_some() {
-                MassProperties::ZERO
-            } else {
-                collider.mass_properties(density.0)
-            };
+        hooks
+            .on_add(|mut world, ctx| {
+                // Initialize the global physics transform for the collider.
+                // Avoid doing this twice for rigid bodies added at the same time.
+                // TODO: The special case for rigid bodies is a bit of a hack here.
+                if !world.entity(ctx.entity).contains::<RigidBody>() {
+                    init_physics_transform(&mut world, &ctx);
+                }
+            })
+            .on_insert(|mut world, ctx| {
+                let scale = world
+                    .entity(ctx.entity)
+                    .get::<GlobalTransform>()
+                    .map(|gt| gt.scale())
+                    .unwrap_or_default();
+                #[cfg(feature = "2d")]
+                let scale = scale.xy();
+
+                let mut entity_mut = world.entity_mut(ctx.entity);
+
+                // Make sure the collider is initialized with the correct scale.
+                // This overwrites the scale set by the constructor, but that one is
+                // meant to be only changed after initialization.
+                entity_mut
+                    .get_mut::<C>()
+                    .unwrap()
+                    .set_scale(scale.adjust_precision(), 10);
+
+                let collider = entity_mut.get::<C>().unwrap();
+
+                let density = entity_mut
+                    .get::<ColliderDensity>()
+                    .copied()
+                    .unwrap_or_default();
+
+                let mass_properties = if entity_mut.get::<Sensor>().is_some() {
+                    MassProperties::ZERO
+                } else {
+                    collider.mass_properties(density.0)
+                };
 
-            if let Some(mut collider_mass_properties) =
-                entity_mut.get_mut::<ColliderMassProperties>()
-            {
-                *collider_mass_properties = ColliderMassProperties::from(mass_properties);
-            }
-        });
+                if let Some(mut collider_mass_properties) =
+                    entity_mut.get_mut::<ColliderMassProperties>()
+                {
+                    *collider_mass_properties = ColliderMassProperties::from(mass_properties);
+                }
+            });
 
         // Register a component hook that removes `ColliderMarker` components
         // and updates rigid bodies when their collider is removed.

src/physics_transform/mod.rs

@@ -207,20 +207,22 @@ pub fn transform_to_position(
         let transform_translation = global_transform.translation.adjust_precision();
         let transform_rotation = Rotation::from(global_transform.rotation.adjust_precision());
 
-        let position_changed = is_changed_after_tick(
-            Ref::from(position.reborrow()),
-            last_physics_tick.0,
-            this_run,
-        );
+        let position_changed = !position.is_added()
+            && is_changed_after_tick(
+                Ref::from(position.reborrow()),
+                last_physics_tick.0,
+                this_run,
+            );
         if !position_changed && position.abs_diff_ne(&transform_translation, distance_tolerance) {
             position.0 = transform_translation;
         }
 
-        let rotation_changed = is_changed_after_tick(
-            Ref::from(rotation.reborrow()),
-            last_physics_tick.0,
-            this_run,
-        );
+        let rotation_changed = !rotation.is_added()
+            && is_changed_after_tick(
+                Ref::from(rotation.reborrow()),
+                last_physics_tick.0,
+                this_run,
+            );
         if !rotation_changed
             && rotation.angle_between(transform_rotation).abs() > rotation_tolerance
         {