feat: add Rapier 3D physics engine integration

Integrates rapier3d v0.32 behind an optional "physics" feature flag.
Provides rigid body dynamics, colliders, joints, raycasting, collision
events, and automatic scene node transform sync across all 7 platforms
(macOS, iOS, tvOS, Windows, Linux, Android, Web/WASM).

Author: proggeramlug

native/android/src/lib.rs

@@ -1125,3 +1125,299 @@ pub extern "C" fn bloom_commit_music(staging_handle: f64) -> f64 {
 pub extern "C" fn bloom_run_game(_callback: extern "C" fn(f64)) {
     // No-op on native. The TypeScript runGame() helper provides the while loop.
 }
+
+
+// ============================================================
+// Physics (Rapier 3D)
+// ============================================================
+
+#[cfg(feature = "physics")]
+use bloom_shared::physics::PhysicsWorld;
+
+#[cfg(feature = "physics")]
+fn physics() -> &'static mut PhysicsWorld {
+    engine().physics.as_mut().expect("Physics world not created. Call bloom_physics_create_world first.")
+}
+
+#[no_mangle]
+pub extern "C" fn bloom_physics_create_world(gx: f64, gy: f64, gz: f64) {
+    #[cfg(feature = "physics")]
+    { engine().physics = Some(PhysicsWorld::new(gx as f32, gy as f32, gz as f32)); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_set_gravity(gx: f64, gy: f64, gz: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.set_gravity(gx as f32, gy as f32, gz as f32); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_set_timestep(dt: f64, max_substeps: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.set_timestep(dt, max_substeps as u32); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_create_body(body_type: f64, px: f64, py: f64, pz: f64, rx: f64, ry: f64, rz: f64, rw: f64) -> f64 {
+    #[cfg(feature = "physics")]
+    { return physics().create_body(body_type, px, py, pz, rx, ry, rz, rw); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_destroy_body(handle: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.destroy_body(handle); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_set_body_enabled(handle: f64, enabled: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.set_body_enabled(handle, enabled != 0.0); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_set_body_ccd(handle: f64, enabled: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.set_body_ccd(handle, enabled != 0.0); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_set_body_gravity_scale(handle: f64, scale: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.set_body_gravity_scale(handle, scale as f32); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_set_kinematic_target(handle: f64, px: f64, py: f64, pz: f64, rx: f64, ry: f64, rz: f64, rw: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.set_kinematic_target(handle, px, py, pz, rx, ry, rz, rw); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_lock_rotations(handle: f64, lock_x: f64, lock_y: f64, lock_z: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.lock_rotations(handle, lock_x != 0.0, lock_y != 0.0, lock_z != 0.0); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_add_box_collider(body: f64, hx: f64, hy: f64, hz: f64) -> f64 {
+    #[cfg(feature = "physics")]
+    { return physics().add_box_collider(body, hx as f32, hy as f32, hz as f32); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_add_sphere_collider(body: f64, radius: f64) -> f64 {
+    #[cfg(feature = "physics")]
+    { return physics().add_sphere_collider(body, radius as f32); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_add_capsule_collider(body: f64, half_height: f64, radius: f64) -> f64 {
+    #[cfg(feature = "physics")]
+    { return physics().add_capsule_collider(body, half_height as f32, radius as f32); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_add_cylinder_collider(body: f64, half_height: f64, radius: f64) -> f64 {
+    #[cfg(feature = "physics")]
+    { return physics().add_cylinder_collider(body, half_height as f32, radius as f32); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_set_collider_properties(collider: f64, friction: f64, restitution: f64, density: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.set_collider_properties(collider, friction as f32, restitution as f32, density as f32); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_apply_force(body: f64, fx: f64, fy: f64, fz: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.apply_force(body, fx as f32, fy as f32, fz as f32); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_apply_impulse(body: f64, ix: f64, iy: f64, iz: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.apply_impulse(body, ix as f32, iy as f32, iz as f32); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_apply_torque(body: f64, tx: f64, ty: f64, tz: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.apply_torque(body, tx as f32, ty as f32, tz as f32); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_apply_torque_impulse(body: f64, tx: f64, ty: f64, tz: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.apply_torque_impulse(body, tx as f32, ty as f32, tz as f32); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_set_linear_velocity(body: f64, vx: f64, vy: f64, vz: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.set_linear_velocity(body, vx as f32, vy as f32, vz as f32); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_set_angular_velocity(body: f64, vx: f64, vy: f64, vz: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.set_angular_velocity(body, vx as f32, vy as f32, vz as f32); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_step(delta_time: f64) {
+    #[cfg(feature = "physics")]
+    {
+        let eng = engine();
+        let (physics, scene) = (&mut eng.physics, &mut eng.scene);
+        if let Some(phys) = physics.as_mut() { phys.step(delta_time); phys.sync_transforms(scene); }
+    }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_sync_transforms() {
+    #[cfg(feature = "physics")]
+    {
+        let eng = engine();
+        let (physics, scene) = (&mut eng.physics, &mut eng.scene);
+        if let Some(phys) = physics.as_mut() { phys.sync_transforms(scene); }
+    }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_body_position_x(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_body_position_x(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_body_position_y(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_body_position_y(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_body_position_z(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_body_position_z(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_body_rotation_x(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_body_rotation_x(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_body_rotation_y(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_body_rotation_y(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_body_rotation_z(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_body_rotation_z(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_body_rotation_w(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_body_rotation_w(body); }
+    #[cfg(not(feature = "physics"))] 1.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_linear_velocity_x(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_linear_velocity_x(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_linear_velocity_y(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_linear_velocity_y(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_linear_velocity_z(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_linear_velocity_z(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_angular_velocity_x(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_angular_velocity_x(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_angular_velocity_y(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_angular_velocity_y(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_angular_velocity_z(body: f64) -> f64 {
+    #[cfg(feature = "physics")] { return physics().get_angular_velocity_z(body); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_raycast(ox: f64, oy: f64, oz: f64, dx: f64, dy: f64, dz: f64, max_dist: f64) -> f64 {
+    #[cfg(feature = "physics")]
+    { if physics().raycast(ox, oy, oz, dx, dy, dz, max_dist) { return 1.0; } else { return 0.0; } }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_ray_hit_body() -> f64 {
+    #[cfg(feature = "physics")] { return physics().last_ray_hit.as_ref().map_or(0.0, |h| h.body_handle); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_ray_hit_distance() -> f64 {
+    #[cfg(feature = "physics")] { return physics().last_ray_hit.as_ref().map_or(0.0, |h| h.distance); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_ray_hit_x() -> f64 {
+    #[cfg(feature = "physics")] { return physics().last_ray_hit.as_ref().map_or(0.0, |h| h.point[0]); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_ray_hit_y() -> f64 {
+    #[cfg(feature = "physics")] { return physics().last_ray_hit.as_ref().map_or(0.0, |h| h.point[1]); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_ray_hit_z() -> f64 {
+    #[cfg(feature = "physics")] { return physics().last_ray_hit.as_ref().map_or(0.0, |h| h.point[2]); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_collision_count() -> f64 {
+    #[cfg(feature = "physics")] { return physics().collision_events.len() as f64; }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_collision_event(index: f64) -> f64 {
+    #[cfg(feature = "physics")]
+    {
+        let phys = physics();
+        let i = index as usize;
+        if i < phys.collision_events.len() {
+            let evt = &phys.collision_events[i];
+            phys.last_collision_read = (evt.body_a, evt.body_b, evt.started);
+            return evt.body_a;
+        }
+        return 0.0;
+    }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_collision_body_b() -> f64 {
+    #[cfg(feature = "physics")] { return physics().last_collision_read.1; }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_get_collision_started() -> f64 {
+    #[cfg(feature = "physics")] { return if physics().last_collision_read.2 { 1.0 } else { 0.0 }; }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_attach_scene_node(body: f64, scene_node: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.attach_scene_node(body, scene_node); }
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_create_fixed_joint(body_a: f64, body_b: f64, ax: f64, ay: f64, az: f64, bx: f64, by: f64, bz: f64) -> f64 {
+    #[cfg(feature = "physics")]
+    { return physics().create_fixed_joint(body_a, body_b, ax as f32, ay as f32, az as f32, bx as f32, by as f32, bz as f32); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_create_revolute_joint(body_a: f64, body_b: f64, ax: f64, ay: f64, az: f64, axis_x: f64, axis_y: f64, axis_z: f64) -> f64 {
+    #[cfg(feature = "physics")]
+    { return physics().create_revolute_joint(body_a, body_b, ax as f32, ay as f32, az as f32, axis_x as f32, axis_y as f32, axis_z as f32); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_create_prismatic_joint(body_a: f64, body_b: f64, ax: f64, ay: f64, az: f64, axis_x: f64, axis_y: f64, axis_z: f64) -> f64 {
+    #[cfg(feature = "physics")]
+    { return physics().create_prismatic_joint(body_a, body_b, ax as f32, ay as f32, az as f32, axis_x as f32, axis_y as f32, axis_z as f32); }
+    #[cfg(not(feature = "physics"))] 0.0
+}
+#[no_mangle]
+pub extern "C" fn bloom_physics_destroy_joint(handle: f64) {
+    #[cfg(feature = "physics")]
+    if let Some(phys) = engine().physics.as_mut() { phys.destroy_joint(handle); }
+}