Rapier context as a Component

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## Unreleased
+
+### Changed
+
+- `RapierContext` is now a `Component`
+  - Rapier now supports multiple worlds.
+  - Migration guide: 
+    - `ResMut<mut RapierContext>` -> `DefaultRapierContextAccessMut`
+    - `Res<RapierContext>` -> `DefaultRapierContextAccess`
+    - `ResMut<RapierConfiguration>` -> `DefaultRapierConfigurationMut`
+    - `Res<RapierConfiguration>` -> `DefaultRapierConfiguration`
+
 ## v0.27.0-rc.1 (18 June 2024)
 
 **This is an update to Rapier 0.20 which includes several stability improvements

bevy_rapier2d/examples/player_movement2.rs

@@ -24,7 +24,8 @@ fn main() {
 #[derive(Component)]
 pub struct Player(f32);
 
-pub fn spawn_player(mut commands: Commands, mut rapier_config: ResMut<RapierConfiguration>) {
+pub fn spawn_player(mut commands: Commands, mut rapier_config: Query<&mut RapierConfiguration>) {
+    let mut rapier_config = rapier_config.single_mut();
     // Set gravity to 0.0 and spawn camera.
     rapier_config.gravity = Vec2::ZERO;
     commands.spawn(Camera2dBundle::default());

bevy_rapier2d/examples/testbed2.rs

@@ -147,7 +147,9 @@ fn main() {
             OnExit(Examples::PlayerMovement2),
             (
                 cleanup,
-                |mut rapier_config: ResMut<RapierConfiguration>, ctxt: Res<RapierContext>| {
+                |mut rapier_config: Query<&mut RapierConfiguration>,
+                 ctxt: DefaultRapierContextAccess| {
+                    let mut rapier_config = rapier_config.single_mut();
                     rapier_config.gravity =
                         RapierConfiguration::new(ctxt.integration_parameters.length_unit).gravity;
                 },

bevy_rapier3d/examples/multi_world3.rs

@@ -0,0 +1,120 @@
+use bevy::{input::common_conditions::input_just_pressed, prelude::*};
+use bevy_rapier3d::prelude::*;
+
+const N_WORLDS: usize = 2;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default()
+                .with_default_world(RapierContextInitialization::NoAutomaticRapierContext),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(
+            Startup,
+            ((create_worlds, setup_physics).chain(), setup_graphics),
+        )
+        .add_systems(Update, move_platforms)
+        .add_systems(
+            Update,
+            change_world.run_if(input_just_pressed(KeyCode::KeyC)),
+        )
+        .run();
+}
+
+fn create_worlds(mut commands: Commands) {
+    for i in 0..N_WORLDS {
+        let mut world = commands.spawn((RapierContext::default(), WorldId(i)));
+        if i == 0 {
+            world.insert(DefaultRapierContext);
+        }
+    }
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(0.0, 3.0, -10.0)
+            .looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
+        ..Default::default()
+    });
+}
+
+#[derive(Component)]
+pub struct WorldId(pub usize);
+
+#[derive(Component)]
+struct Platform {
+    starting_y: f32,
+}
+
+fn move_platforms(time: Res<Time>, mut query: Query<(&mut Transform, &Platform)>) {
+    for (mut transform, platform) in query.iter_mut() {
+        transform.translation.y = platform.starting_y + -time.elapsed_seconds().sin();
+    }
+}
+
+/// Demonstrates how easy it is to move one entity to another world.
+fn change_world(
+    query_context: Query<Entity, With<DefaultRapierContext>>,
+    mut query_links: Query<(Entity, &mut RapierContextEntityLink)>,
+) {
+    let default_context = query_context.single();
+    for (e, mut link) in query_links.iter_mut() {
+        if link.0 == default_context {
+            continue;
+        }
+        link.0 = default_context;
+        println!("changing world of {} for world {}", e, link.0);
+    }
+}
+
+pub fn setup_physics(
+    context: Query<(Entity, &WorldId), With<RapierContext>>,
+    mut commands: Commands,
+) {
+    for (context_entity, id) in context.iter() {
+        let id = id.0;
+
+        let color = [
+            Hsla::hsl(220.0, 1.0, 0.3),
+            Hsla::hsl(180.0, 1.0, 0.3),
+            Hsla::hsl(260.0, 1.0, 0.7),
+        ][id % 3];
+
+        /*
+         * Ground
+         */
+        let ground_size = 5.1;
+        let ground_height = 0.1;
+
+        let starting_y = (id as f32) * -0.5 - ground_height;
+
+        let mut platforms = commands.spawn((
+            TransformBundle::from(Transform::from_xyz(0.0, starting_y, 0.0)),
+            Collider::cuboid(ground_size, ground_height, ground_size),
+            ColliderDebugColor(color),
+            RapierContextEntityLink(context_entity),
+        ));
+        if id == 1 {
+            platforms.insert(Platform { starting_y });
+        }
+
+        /*
+         * Create the cube
+         */
+
+        commands.spawn((
+            TransformBundle::from(Transform::from_xyz(0.0, 1.0 + id as f32 * 5.0, 0.0)),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.5, 0.5, 0.5),
+            ColliderDebugColor(color),
+            RapierContextEntityLink(context_entity),
+        ));
+    }
+}

bevy_rapier3d/examples/ray_casting3.rs

@@ -76,7 +76,7 @@ pub fn setup_physics(mut commands: Commands) {
 pub fn cast_ray(
     mut commands: Commands,
     windows: Query<&Window, With<PrimaryWindow>>,
-    rapier_context: Res<RapierContext>,
+    rapier_context: DefaultRapierContextAccessMut,
     cameras: Query<(&Camera, &GlobalTransform)>,
 ) {
     let window = windows.single();

src/pipeline/events.rs

@@ -1,5 +1,5 @@
 use crate::math::{Real, Vect};
-use bevy::prelude::{Entity, Event, EventWriter};
+use bevy::prelude::{Entity, Event};
 use rapier::dynamics::RigidBodySet;
 use rapier::geometry::{
     ColliderHandle, ColliderSet, CollisionEvent as RapierCollisionEvent, CollisionEventFlags,
@@ -55,8 +55,8 @@ pub(crate) struct EventQueue<'a> {
     // Used ot retrieve the entity of colliders that have been removed from the simulation
     // since the last physics step.
     pub deleted_colliders: &'a HashMap<ColliderHandle, Entity>,
-    pub collision_events: RwLock<EventWriter<'a, CollisionEvent>>,
-    pub contact_force_events: RwLock<EventWriter<'a, ContactForceEvent>>,
+    pub collision_events: RwLock<Vec<CollisionEvent>>,
+    pub contact_force_events: RwLock<Vec<ContactForceEvent>>,
 }
 
 impl<'a> EventQueue<'a> {
@@ -91,7 +91,7 @@ impl<'a> EventHandler for EventQueue<'a> {
         };
 
         if let Ok(mut events) = self.collision_events.write() {
-            events.send(event);
+            events.push(event);
         }
     }
 
@@ -115,7 +115,116 @@ impl<'a> EventHandler for EventQueue<'a> {
         };
 
         if let Ok(mut events) = self.contact_force_events.write() {
-            events.send(event);
+            events.push(event);
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use bevy::time::TimePlugin;
+    use systems::tests::HeadlessRenderPlugin;
+
+    use crate::{plugin::*, prelude::*};
+
+    #[cfg(feature = "dim3")]
+    fn cuboid(hx: Real, hy: Real, hz: Real) -> Collider {
+        Collider::cuboid(hx, hy, hz)
+    }
+    #[cfg(feature = "dim2")]
+    fn cuboid(hx: Real, hy: Real, _hz: Real) -> Collider {
+        Collider::cuboid(hx, hy)
+    }
+
+    #[test]
+    pub fn events_received() {
+        return main();
+
+        use bevy::prelude::*;
+
+        #[derive(Resource, Reflect)]
+        pub struct EventsSaver<E: Event> {
+            pub events: Vec<E>,
+        }
+        impl<E: Event> Default for EventsSaver<E> {
+            fn default() -> Self {
+                Self {
+                    events: Default::default(),
+                }
+            }
+        }
+        pub fn save_events<E: Event + Clone>(
+            mut events: EventReader<E>,
+            mut saver: ResMut<EventsSaver<E>>,
+        ) {
+            for event in events.read() {
+                saver.events.push(event.clone());
+            }
+        }
+        fn run_test(app: &mut App) {
+            app.add_systems(PostUpdate, save_events::<CollisionEvent>)
+                .add_systems(PostUpdate, save_events::<ContactForceEvent>)
+                .init_resource::<EventsSaver<CollisionEvent>>()
+                .init_resource::<EventsSaver<ContactForceEvent>>();
+            // while app.plugins_state() == bevy::app::PluginsState::Adding {
+            //     #[cfg(not(target_arch = "wasm32"))]
+            //     bevy::tasks::tick_global_task_pools_on_main_thread();
+            // }
+            // app.finish();
+            // app.cleanup();
+            let mut time = app.world_mut().get_resource_mut::<Time<Virtual>>().unwrap();
+            time.set_relative_speed(1000f32);
+            for _ in 0..300 {
+                // FIXME: advance by set durations to avoid being at the mercy of the CPU.
+                app.update();
+            }
+            let saved_collisions = app
+                .world()
+                .get_resource::<EventsSaver<CollisionEvent>>()
+                .unwrap();
+            assert!(saved_collisions.events.len() > 0);
+            let saved_contact_forces = app
+                .world()
+                .get_resource::<EventsSaver<CollisionEvent>>()
+                .unwrap();
+            assert!(saved_contact_forces.events.len() > 0);
+        }
+
+        /// Adapted from events example
+        fn main() {
+            let mut app = App::new();
+            app.add_plugins((
+                HeadlessRenderPlugin,
+                TransformPlugin,
+                TimePlugin,
+                RapierPhysicsPlugin::<NoUserData>::default(),
+            ))
+            .add_systems(Startup, setup_physics);
+            run_test(&mut app);
+        }
+
+        pub fn setup_physics(mut commands: Commands) {
+            /*
+             * Ground
+             */
+            commands.spawn((
+                TransformBundle::from(Transform::from_xyz(0.0, -1.2, 0.0)),
+                cuboid(4.0, 1.0, 1.0),
+            ));
+
+            commands.spawn((
+                TransformBundle::from(Transform::from_xyz(0.0, 5.0, 0.0)),
+                cuboid(4.0, 1.5, 1.0),
+                Sensor,
+            ));
+
+            commands.spawn((
+                TransformBundle::from(Transform::from_xyz(0.0, 13.0, 0.0)),
+                RigidBody::Dynamic,
+                cuboid(0.5, 0.5, 0.5),
+                ActiveEvents::COLLISION_EVENTS,
+                ContactForceEventThreshold(30.0),
+            ));
         }
     }
 }