damn thats a lot of commits

Cargo.toml

@@ -13,8 +13,14 @@ keywords = ["liquidfun", "box2d", "physics", "bevy"]
 [dependencies]
 autocxx = "0.26.0"
 bitflags = "2.4.1"
-bevy = "0.12"
-libliquidfun-sys = "0.2.0"
+bevy = "0.14.0"
+libliquidfun-sys = "0.4.0"
+
+bevy-inspector-egui = { version = "0.25.0", optional = true }
 
 [dev-dependencies]
-rand = "0.8"
+rand = "0.8"
+
+[features]
+bevy-inspector-egui = ["dep:bevy-inspector-egui"]
+

README.md

@@ -7,9 +7,9 @@ A Bevy friendly wrapper of Box2D and LiquidFun.
 This crate wraps [libliquidfun-sys](https://github.com/mmatvein/libliquidfun-sys) to integrate Box2D and LiquidFun with the [Bevy game engine](https://github.com/bevyengine/bevy).
 
 ### Remarks
-- The library is not fully featured yet. It has been developed with 'Example Driven Development' so far, which means that the examples showcase _everything_ available at this moment.
-- Feedback on the APIs, usability & overall code quality is very welcome. I am not very accustomed to Rust and it's a learning process.
-- Pull Requests are welcome, but this crate is so early in development that it is important for me to have full and thorough understanding of all the bits that go into it.
+- The library is not fully featured yet. It has been developed with the needs of our game in mind, so the implemented features reflect what we've needed. Early on "Example Driven Development" was used, by porting over regular Box2D examples.
+- Feedback on the APIs, usability & overall code quality is very welcome.
+- Pull Requests are welcome, but this crate is very much a work in progress alongside our game, so we need full ownership of what goes into the codebase.
 
 ### Acknowledgements
 This crate is made possible by excellent prior work by others. Huge thanks go to:

examples/chain.rs

@@ -0,0 +1,109 @@
+extern crate bevy;
+extern crate bevy_liquidfun;
+
+use bevy::prelude::*;
+use bevy_liquidfun::{
+    collision::b2Shape,
+    dynamics::{
+        b2BodyCommands, b2BodyDef, b2BodyType::Dynamic, b2Fixture, b2RevoluteJointDef, b2World, CreateRevoluteJoint
+    },
+    plugins::{LiquidFunDebugDrawPlugin, LiquidFunPlugin},
+    utils::DebugDrawFixtures,
+};
+
+fn main() {
+    App::new()
+        .add_plugins((
+            DefaultPlugins,
+            LiquidFunPlugin::default(),
+            LiquidFunDebugDrawPlugin,
+        ))
+        .add_systems(Startup, setup_camera)
+        .add_systems(Startup, (setup_physics_world, setup_physics_bodies).chain())
+        .run();
+}
+
+fn setup_camera(mut commands: Commands) {
+    commands.spawn(Camera2dBundle {
+        projection: OrthographicProjection {
+            scale: 0.05,
+            far: 1000.,
+            near: -1000.,
+            ..OrthographicProjection::default()
+        },
+        transform: Transform::from_translation(Vec3::new(0., 10., 0.)),
+        ..Camera2dBundle::default()
+    });
+}
+
+fn setup_physics_world(world: &mut World) {
+    let gravity = Vec2::new(0., -9.81);
+    let b2_world = b2World::new(gravity);
+    world.insert_resource(b2_world);
+}
+
+fn setup_physics_bodies(mut commands: Commands) {
+    let ground_fixture = b2Fixture::new(
+        b2Shape::EdgeTwoSided {
+            v1: Vec2::new(-40., 0.),
+            v2: Vec2::new(40., 0.),
+        },
+        0.0,
+    );
+    let ground_entity = commands
+        .spawn_body(&b2BodyDef::default(), ground_fixture)
+        .insert(DebugDrawFixtures::default_static())
+        .id();
+
+    let box_shape = b2Shape::create_box(0.6, 0.125);
+    let box_fixture = b2Fixture {
+        shape: box_shape,
+        density: 20.0,
+        friction: 0.2,
+        ..default()
+    };
+    const Y: f32 = 25.0;
+
+    let mut body_entities = vec![Entity::PLACEHOLDER; 30];
+    for i in 0..30 {
+        let body_def = b2BodyDef {
+            body_type: Dynamic,
+            position: Vec2::new(0.5 + i as f32, Y),
+            ..default()
+        };
+
+        body_entities[i] = commands
+            .spawn_body(&body_def, box_fixture.clone())
+            .insert(DebugDrawFixtures {
+                draw_up_vector: false,
+                draw_right_vector: false,
+                ..DebugDrawFixtures::default_dynamic()
+            })
+            .id();
+    }
+
+    let joint_def = b2RevoluteJointDef {
+        local_anchor_a: Vec2::new(0.5, 0.),
+        local_anchor_b: Vec2::new(-0.5, 0.),
+        ..default()
+    };
+
+    for body_pair in body_entities.windows(2) {
+        let (body_a, body_b) = (body_pair[0], body_pair[1]);
+        commands
+            .spawn_empty()
+            .add(CreateRevoluteJoint::new(body_a, body_b, false, &joint_def));
+    }
+
+    let joint_def = b2RevoluteJointDef {
+        local_anchor_a: Vec2::new(0., Y),
+        ..joint_def
+    };
+
+    commands.spawn_empty().add(CreateRevoluteJoint::new(
+        ground_entity,
+        body_entities[0],
+        true,
+        &joint_def,
+    ));
+}

examples/circle_stack.rs

@@ -2,14 +2,13 @@ extern crate bevy;
 extern crate bevy_liquidfun;
 
 use bevy::prelude::*;
-
-use bevy_liquidfun::dynamics::{b2BodyBundle, b2Fixture, b2FixtureDef};
-use bevy_liquidfun::plugins::{LiquidFunDebugDrawPlugin, LiquidFunPlugin};
-use bevy_liquidfun::utils::DebugDrawFixtures;
 use bevy_liquidfun::{
     collision::b2Shape,
-    dynamics::{b2BodyDef, b2BodyType::Dynamic, b2World},
+    dynamics::{b2BodyCommands, b2BodyDef, b2BodyType::Dynamic, b2Fixture, b2World},
+    plugins::{LiquidFunDebugDrawPlugin, LiquidFunPlugin},
+    utils::DebugDrawFixtures,
 };
+
 fn main() {
     App::new()
         .add_plugins((
@@ -44,42 +43,35 @@ fn setup_camera(mut commands: Commands) {
 fn setup_physics_world(world: &mut World) {
     let gravity = Vec2::new(0., -9.81);
     let b2_world = b2World::new(gravity);
-    world.insert_non_send_resource(b2_world);
+    world.insert_resource(b2_world);
 }
 
 fn setup_physics_bodies(mut commands: Commands) {
     {
-        let ground_entity = commands.spawn(b2BodyBundle::default()).id();
-
-        let shape = b2Shape::EdgeTwoSided {
-            v1: Vec2::new(-40., 0.),
-            v2: Vec2::new(40., 0.),
-        };
-        let fixture_def = b2FixtureDef::new(shape, 0.);
-        commands.spawn((
-            b2Fixture::new(ground_entity, &fixture_def),
-            DebugDrawFixtures::default_static(),
-        ));
+        let fixture = b2Fixture::new(
+            b2Shape::EdgeTwoSided {
+                v1: Vec2::new(-40., 0.),
+                v2: Vec2::new(40., 0.),
+            },
+            0.,
+        );
+        commands
+            .spawn_body(&b2BodyDef::default(), fixture)
+            .insert(DebugDrawFixtures::default_static());
     }
 
     let circle_shape = b2Shape::Circle {
         radius: 1.,
         position: Vec2::ZERO,
     };
-    let fixture_def = b2FixtureDef::new(circle_shape, 1.);
     for i in 0..10 {
         let body_def = b2BodyDef {
             body_type: Dynamic,
             position: Vec2::new(0., 4. + 3. * i as f32),
             ..default()
         };
-        let mut body_bundle = b2BodyBundle::new(&body_def);
-        body_bundle.body.linear_velocity = Vec2::new(0., -50.);
-        let body_entity = commands.spawn(body_bundle).id();
-
-        commands.spawn((
-            b2Fixture::new(body_entity, &fixture_def),
-            DebugDrawFixtures::default_dynamic(),
-        ));
+        commands
+            .spawn_body(&body_def, b2Fixture::new(circle_shape.clone(), 1.))
+            .insert(DebugDrawFixtures::default_dynamic());
     }
 }

examples/collision_processing.rs

@@ -0,0 +1,167 @@
+extern crate bevy;
+extern crate bevy_liquidfun;
+extern crate rand;
+
+use std::ops::RangeInclusive;
+
+use bevy::prelude::*;
+use bevy_liquidfun::{
+    collision::b2Shape,
+    dynamics::{
+        b2BeginContactEvent, b2Body, b2BodyCommands, b2BodyDef, b2BodyType::Dynamic, b2Fixture, b2World
+    },
+    plugins::{LiquidFunDebugDrawPlugin, LiquidFunPlugin},
+    schedule::{PhysicsSchedule, PhysicsUpdateStep},
+    utils::DebugDrawFixtures,
+};
+use rand::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins((
+            DefaultPlugins,
+            LiquidFunPlugin::default(),
+            LiquidFunDebugDrawPlugin,
+        ))
+        .add_systems(Startup, setup_camera)
+        .add_systems(
+            Startup,
+            (setup_physics_world, setup_bodies.after(setup_physics_world)),
+        )
+        .add_systems(
+            PhysicsSchedule,
+            process_collisions.in_set(PhysicsUpdateStep::UserCode),
+        )
+        .run();
+}
+
+fn setup_camera(mut commands: Commands) {
+    commands.spawn(Camera2dBundle {
+        projection: OrthographicProjection {
+            scale: 0.07,
+            far: 1000.,
+            near: -1000.,
+            ..OrthographicProjection::default()
+        },
+        transform: Transform::from_translation(Vec3::new(0., 10., 0.)),
+        ..Camera2dBundle::default()
+    });
+}
+
+fn setup_physics_world(mut commands: Commands) {
+    let gravity = Vec2::new(0., -9.81);
+    let b2_world = b2World::new(gravity);
+    commands.insert_resource(b2_world);
+}
+
+fn setup_bodies(mut commands: Commands) {
+    {
+        let fixture = b2Fixture::new(
+            b2Shape::EdgeTwoSided {
+                v1: Vec2::new(-50., 0.),
+                v2: Vec2::new(50., 0.),
+            },
+            0.,
+        );
+        commands
+            .spawn_body(&b2BodyDef::default(), fixture)
+            .insert(DebugDrawFixtures::default_static());
+    }
+
+    let x_range = -5.0..=5.0;
+    let y_range = 2.0..=35.0;
+    let mut rng = thread_rng();
+
+    // small triangle
+    {
+        let shape = b2Shape::Polygon {
+            vertices: vec![Vec2::new(-1., 0.), Vec2::new(1., 0.), Vec2::new(0., 2.)],
+        };
+        create_body_in_random_position(&mut commands, shape, &x_range, &y_range, &mut rng);
+    }
+
+    // large triangle
+    {
+        let shape = b2Shape::Polygon {
+            vertices: vec![Vec2::new(-2., 0.), Vec2::new(2., 0.), Vec2::new(0., 4.)],
+        };
+        create_body_in_random_position(&mut commands, shape, &x_range, &y_range, &mut rng);
+    }
+
+    // small box
+    {
+        let shape = b2Shape::create_box(1., 0.5);
+        create_body_in_random_position(&mut commands, shape, &x_range, &y_range, &mut rng);
+    }
+
+    // large box
+    {
+        let shape = b2Shape::create_box(2., 1.);
+        create_body_in_random_position(&mut commands, shape, &x_range, &y_range, &mut rng);
+    }
+
+    // small circle
+    {
+        let shape = b2Shape::Circle {
+            radius: 1.,
+            position: Vec2::ZERO,
+        };
+        create_body_in_random_position(&mut commands, shape, &x_range, &y_range, &mut rng);
+    }
+
+    // large circle
+    {
+        let shape = b2Shape::Circle {
+            radius: 2.,
+            position: Vec2::ZERO,
+        };
+
+        create_body_in_random_position(&mut commands, shape, &x_range, &y_range, &mut rng);
+    }
+}
+
+fn create_body_in_random_position(
+    commands: &mut Commands,
+    shape: b2Shape,
+    x_range: &RangeInclusive<f32>,
+    y_range: &RangeInclusive<f32>,
+    rng: &mut ThreadRng,
+) {
+    commands
+        .spawn_body(
+            &b2BodyDef {
+                body_type: Dynamic,
+                position: Vec2::new(
+                    rng.gen_range(x_range.clone()),
+                    rng.gen_range(y_range.clone()),
+                ),
+                ..default()
+            },
+            b2Fixture::new(shape, 1.0),
+        )
+        .insert(DebugDrawFixtures::default_dynamic());
+}
+
+fn process_collisions(
+    mut commands: Commands,
+    bodies: Query<&b2Body>,
+    mut event_reader: EventReader<b2BeginContactEvent>,
+) {
+    for contact_event in event_reader.read() {
+        let contact = contact_event.0;
+        let body_a = bodies.get(contact.body_a);
+        let body_b = bodies.get(contact.body_b);
+        if body_a.is_err() || body_b.is_err() {
+            continue;
+        }
+
+        let (body_a, body_b) = (body_a.unwrap(), body_b.unwrap());
+        if body_a.mass() != 0.0 && body_b.mass() != 0.0 {
+            if body_a.mass() > body_b.mass() {
+                commands.entity(contact.body_b).despawn_recursive();
+            } else {
+                commands.entity(contact.body_a).despawn_recursive();
+            }
+        }
+    }
+}