@downdraft/engine 0.0.0 → 0.1.0

package/libraries/physics-native/native/src/character.rs

@@ -0,0 +1,226 @@
+use rapier3d::control::{
+    CharacterAutostep, CharacterCollision, CharacterLength, KinematicCharacterController,
+};
+use rapier3d::na::{Quaternion, UnitQuaternion};
+use rapier3d::prelude::*;
+use crate::world::{CharController, PhysicsWorld};
+
+// ── dd_char_create descriptor layout ─────────────────────────────────────
+// f: [offset, radius, halfHeight, maxSlope, minSlopeSlide, snapToGround,
+//     autostepMinW, autostepMaxH, posX, posY, posZ]
+// i: [slide, autostepEnabled, applyImpulses, parentless, collGroups, bodyId]
+pub const CHAR_F32_LEN: usize = 11;
+pub const CHAR_I32_LEN: usize = 6;
+
+/// # Safety
+/// `f`/`i` must point to CHAR_F32_LEN / CHAR_I32_LEN elements.
+pub unsafe fn create(
+    realm: &mut PhysicsWorld,
+    ctrl_id: i32,
+    f: *const f32,
+    i: *const i32,
+) -> i32 {
+    let f = std::slice::from_raw_parts(f, CHAR_F32_LEN);
+    let i = std::slice::from_raw_parts(i, CHAR_I32_LEN);
+
+    let controller = KinematicCharacterController {
+        // WASM parity: world.createCharacterController(desc.offset[1]) uses an
+        // absolute gap offset (padding), not capsule half-height.
+        offset: CharacterLength::Absolute(f[0]),
+        slide: i[0] != 0,
+        autostep: if i[1] != 0 {
+            Some(CharacterAutostep {
+                min_width: CharacterLength::Relative(f[6]),
+                max_height: CharacterLength::Absolute(f[7]),
+                include_dynamic_bodies: false,
+            })
+        } else {
+            None
+        },
+        max_slope_climb_angle: f[3],
+        min_slope_slide_angle: f[4],
+        snap_to_ground: if f[5] > 0.0 {
+            Some(CharacterLength::Absolute(f[5]))
+        } else {
+            None
+        },
+        ..Default::default()
+    };
+    // Not part of move_shape in 0.22 — applied via solve_character_collision_impulses.
+    let apply_impulses = i[2] != 0;
+
+    let entry = if i[3] != 0 {
+        // Parentless capsule collider (no rigid body).
+        let mut builder = ColliderBuilder::capsule_y(f[2], f[1]);
+        if i[4] != 0 {
+            builder = builder.collision_groups(InteractionGroups::new(
+                Group::from_bits_truncate((i[4] as u32) >> 16),
+                Group::from_bits_truncate((i[4] as u32) & 0xffff),
+            ));
+        }
+        let mut collider = builder.build();
+        collider.set_position(Isometry::from_parts(
+            Translation::new(f[8], f[9], f[10]),
+            UnitQuaternion::from_quaternion(Quaternion::identity()),
+        ));
+        let handle = realm.colliders.insert(collider);
+        CharController {
+            controller,
+            body: None,
+            collider: Some(handle),
+        }
+    } else {
+        let body_id = i[5];
+        let Some(&body_handle) = realm.body_map.get(&body_id) else {
+            return -1;
+        };
+        CharController {
+            controller,
+            body: Some(body_handle),
+            collider: None,
+        }
+    };
+    realm.controller_map.insert(ctrl_id, entry);
+    if apply_impulses {
+        realm.impulse_controllers.insert(ctrl_id);
+    }
+    0
+}
+
+pub fn destroy(realm: &mut PhysicsWorld, ctrl_id: i32) -> i32 {
+    if let Some(entry) = realm.controller_map.remove(&ctrl_id) {
+        if let Some(ch) = entry.collider {
+            realm.colliders.remove(
+                ch,
+                &mut realm.island_manager,
+                &mut realm.bodies,
+                true,
+            );
+        }
+    }
+    realm.impulse_controllers.remove(&ctrl_id);
+    0
+}
+
+pub fn set_collider_position(
+    realm: &mut PhysicsWorld,
+    ctrl_id: i32,
+    x: f32,
+    y: f32,
+    z: f32,
+) -> i32 {
+    if let Some(entry) = realm.controller_map.get(&ctrl_id) {
+        if let Some(ch) = entry.collider {
+            if let Some(c) = realm.colliders.get_mut(ch) {
+                c.set_translation(Vector::new(x, y, z));
+            }
+        }
+    }
+    0
+}
+
+/// Compute the character's movement against the world.
+/// out_f: [grounded, ex, ey, ez, sliding]
+/// out_i: [groundBodyId, collBody0, collBody1, ...] (up to max_coll hits)
+/// Returns the number of colliding-body ids written to out_i[1..], or
+/// -1 when the controller/collider is missing.
+///
+/// # Safety
+/// `out_f` ≥ 5 f32s, `out_i` ≥ (1 + max_coll) i32s.
+pub unsafe fn char_move(
+    realm: &mut PhysicsWorld,
+    ctrl_id: i32,
+    dx: f32,
+    dy: f32,
+    dz: f32,
+    _dt: f32,
+    out_f: *mut f32,
+    out_i: *mut i32,
+    max_coll: usize,
+) -> i32 {
+    let ff = std::slice::from_raw_parts_mut(out_f, 5);
+    let ii = std::slice::from_raw_parts_mut(out_i, 1 + max_coll);
+    ii[0] = -1;
+
+    let Some(entry) = realm.controller_map.get(&ctrl_id) else {
+        return -1;
+    };
+    let collider_handle = match entry.collider {
+        Some(h) => h,
+        None => match entry.body.and_then(|bh| realm.bodies.get(bh)) {
+            Some(b) => match b.colliders().first() {
+                Some(&h) => h,
+                None => return -1,
+            },
+            None => return -1,
+        },
+    };
+    let Some(collider) = realm.colliders.get(collider_handle) else {
+        return -1;
+    };
+    let shape = collider.shape();
+    let pos = *collider.position();
+
+    // Queries must work without a preceding step — refresh the pipeline.
+    realm.query_pipeline.update(&realm.bodies, &realm.colliders);
+    let mut collisions: Vec<CharacterCollision> = Vec::new();
+    let controller = &entry.controller;
+    // WASM parity: computeColliderMovement uses the world's integration dt.
+    let effective = controller.move_shape(
+        realm.integration_params.dt,
+        &realm.bodies,
+        &realm.colliders,
+        &realm.query_pipeline,
+        &*shape,
+        &pos,
+        Vector::new(dx, dy, dz),
+        QueryFilter::default().exclude_collider(collider_handle),
+        |c| collisions.push(c),
+    );
+
+    ff[0] = effective.grounded as i32 as f32;
+    ff[1] = effective.translation.x;
+    ff[2] = effective.translation.y;
+    ff[3] = effective.translation.z;
+    ff[4] = effective.is_sliding_down_slope as i32 as f32;
+
+    let mut n = 0usize;
+    for c in &collisions {
+        if n >= max_coll {
+            break;
+        }
+        let body_id = realm
+            .colliders
+            .get(c.handle)
+            .and_then(|col| col.parent())
+            .and_then(|h| realm.body_id_by_handle.get(&h).copied())
+            .unwrap_or(-1);
+        ii[1 + n] = body_id;
+        if effective.grounded && ii[0] < 0 && body_id >= 0 {
+            ii[0] = body_id;
+        }
+        n += 1;
+    }
+
+    if realm.impulse_controllers.contains(&ctrl_id) {
+        let mass = entry
+            .body
+            .and_then(|bh| realm.bodies.get(bh))
+            .map(|b| b.mass())
+            .unwrap_or(1.0);
+        for collision in &collisions {
+            controller.solve_character_collision_impulses(
+                realm.integration_params.dt,
+                &mut realm.bodies,
+                &realm.colliders,
+                &realm.query_pipeline,
+                &*shape,
+                mass,
+                collision,
+                QueryFilter::default().exclude_collider(collider_handle),
+            );
+        }
+    }
+
+    n as i32
+}

package/libraries/physics-native/native/src/collider.rs

@@ -0,0 +1,299 @@
+use rapier3d::na::{DMatrix, Quaternion, UnitQuaternion, Vector3};
+use rapier3d::prelude::*;
+use crate::world::PhysicsWorld;
+
+// ── dd_add_collider descriptor layout ────────────────────────────────────
+// meta (i32):
+//   [0] shape: 0=ball, 1=cuboid, 2=capsule, 3=convex, 4=trimesh, 5=heightfield
+//   [1] sensor (0/1)
+//   [2] collision_groups (packed u32: memberships<<16 | filter)
+//   [3] solver_groups   (packed u32)
+//   [4] n_verts   (convex/trimesh: vertex count; heightfield: nrows*ncols)
+//   [5] n_indices (trimesh: index count)
+//   [6] flags: bit0 hasFriction, bit1 hasRestitution, bit2 hasDensity,
+//        bit3 hasTranslation, bit4 hasRotation,
+//        bit5 hasCollisionGroups, bit6 hasSolverGroups
+//   [7] heightfield nrows   [8] heightfield ncols
+// f (f32):
+//   [0..4]  shape params — ball: r | cuboid: hx,hy,hz | capsule: hh,r |
+//           heightfield: scale xyz | convex/trimesh: unused
+//   [4] friction   [5] restitution   [6] density
+//   [7..10]  translation (wrt parent)
+//   [10..14] rotation quat (x,y,z,w)
+pub const COLLIDER_I32_LEN: usize = 9;
+pub const COLLIDER_F32_LEN: usize = 14;
+
+fn interaction_groups(packed: u32) -> InteractionGroups {
+    InteractionGroups::new(
+        Group::from_bits_truncate(packed >> 16),
+        Group::from_bits_truncate(packed & 0xffff),
+    )
+}
+
+fn build_collider(
+    meta: &[i32],
+    f: &[f32],
+    verts: &[f32],
+    indices: &[u32],
+) -> Option<Collider> {
+    let shape = meta[0];
+    let mut builder = match shape {
+        0 => ColliderBuilder::ball(f[0]),
+        1 => ColliderBuilder::cuboid(f[0], f[1], f[2]),
+        2 => ColliderBuilder::capsule_y(f[0], f[1]),
+        3 => {
+            let n = meta[4].max(0) as usize;
+            if n == 0 || verts.len() < n * 3 {
+                return None;
+            }
+            let points: Vec<Point<f32>> = (0..n)
+                .map(|i| Point::new(verts[i * 3], verts[i * 3 + 1], verts[i * 3 + 2]))
+                .collect();
+            match ColliderBuilder::convex_hull(&points) {
+                Some(b) => b,
+                None => ColliderBuilder::ball(0.5), // degenerate hull fallback (WASM parity)
+            }
+        }
+        4 => {
+            let nv = meta[4].max(0) as usize;
+            let ni = meta[5].max(0) as usize;
+            if nv == 0 || ni == 0 || verts.len() < nv * 3 || indices.len() < ni {
+                return None;
+            }
+            let points: Vec<Point<f32>> = (0..nv)
+                .map(|i| Point::new(verts[i * 3], verts[i * 3 + 1], verts[i * 3 + 2]))
+                .collect();
+            let tris: Vec<[u32; 3]> = (0..ni / 3)
+                .map(|i| [indices[i * 3], indices[i * 3 + 1], indices[i * 3 + 2]])
+                .collect();
+            ColliderBuilder::trimesh(points, tris)
+        }
+        5 => {
+            let nrows = meta[7].max(0) as usize;
+            let ncols = meta[8].max(0) as usize;
+            if nrows == 0 || ncols == 0 || verts.len() < nrows * ncols {
+                return None;
+            }
+            let heights = DMatrix::from_row_slice(nrows, ncols, &verts[..nrows * ncols]);
+            ColliderBuilder::heightfield(heights, Vector3::new(f[0], f[1], f[2]))
+        }
+        _ => return None,
+    };
+
+    let flags = meta[6];
+    if flags & (1 << 0) != 0 {
+        builder = builder.friction(f[4]);
+    }
+    if flags & (1 << 1) != 0 {
+        builder = builder.restitution(f[5]);
+    }
+    if flags & (1 << 2) != 0 {
+        builder = builder.density(f[6]);
+    }
+    if meta[1] != 0 {
+        builder = builder.sensor(true);
+    }
+    if flags & (1 << 5) != 0 {
+        builder = builder.collision_groups(interaction_groups(meta[2] as u32));
+    }
+    if flags & (1 << 6) != 0 {
+        builder = builder.solver_groups(interaction_groups(meta[3] as u32));
+    }
+
+    let mut collider = builder.build();
+    if flags & ((1 << 3) | (1 << 4)) != 0 {
+        let t = if flags & (1 << 3) != 0 {
+            Translation::new(f[7], f[8], f[9])
+        } else {
+            Translation::identity()
+        };
+        let r = if flags & (1 << 4) != 0 {
+            UnitQuaternion::from_quaternion(Quaternion::new(f[13], f[10], f[11], f[12]))
+        } else {
+            UnitQuaternion::identity()
+        };
+        collider.set_position_wrt_parent(Isometry::from_parts(t, r));
+    }
+    Some(collider)
+}
+
+/// # Safety
+/// `meta`/`f`/`verts`/`indices` must describe the layouts documented above.
+pub unsafe fn add_collider(
+    realm: &mut PhysicsWorld,
+    body_id: i32,
+    collider_id: i32,
+    meta: *const i32,
+    f: *const f32,
+    verts: *const f32,
+    indices: *const u32,
+) -> i32 {
+    let meta = std::slice::from_raw_parts(meta, COLLIDER_I32_LEN);
+    let f = std::slice::from_raw_parts(f, COLLIDER_F32_LEN);
+    // Heightfield heights are a scalar grid (nrows*ncols floats); every other
+    // vertex-taking shape uses xyz triples.
+    let n_verts = if meta[0] == 5 {
+        meta[4].max(0) as usize
+    } else {
+        (meta[4].max(0) as usize) * 3
+    };
+    let n_indices = meta[5].max(0) as usize;
+    let verts = if verts.is_null() {
+        &[]
+    } else {
+        std::slice::from_raw_parts(verts, n_verts)
+    };
+    let indices = if indices.is_null() {
+        &[]
+    } else {
+        std::slice::from_raw_parts(indices, n_indices)
+    };
+
+    let Some(&body_handle) = realm.body_map.get(&body_id) else {
+        return -1;
+    };
+    let Some(collider) = build_collider(meta, f, verts, indices) else {
+        return -1;
+    };
+    let handle = realm
+        .colliders
+        .insert_with_parent(collider, body_handle, &mut realm.bodies);
+    realm.collider_map.insert(collider_id, handle);
+    0
+}
+
+/// # Safety
+/// `verts`/`indices` describe a trimesh (matches the WASM swapColliderShapeRaw).
+pub unsafe fn swap_collider_shape(
+    realm: &mut PhysicsWorld,
+    collider_id: i32,
+    verts: *const f32,
+    n_verts: usize,
+    indices: *const u32,
+    n_indices: usize,
+) -> i32 {
+    let Some(&handle) = realm.collider_map.get(&collider_id) else {
+        return 0;
+    };
+    let Some(collider) = realm.colliders.get_mut(handle) else {
+        return 0;
+    };
+    let vs = std::slice::from_raw_parts(verts, n_verts * 3);
+    let is = std::slice::from_raw_parts(indices, n_indices);
+    let points: Vec<Point<f32>> = (0..n_verts)
+        .map(|i| Point::new(vs[i * 3], vs[i * 3 + 1], vs[i * 3 + 2]))
+        .collect();
+    let tris: Vec<[u32; 3]> = (0..n_indices / 3)
+        .map(|i| [is[i * 3], is[i * 3 + 1], is[i * 3 + 2]])
+        .collect();
+    collider.set_shape(SharedShape::trimesh(points, tris));
+    1
+}
+
+pub fn remove_collider(realm: &mut PhysicsWorld, collider_id: i32) -> i32 {
+    if let Some(handle) = realm.collider_map.remove(&collider_id) {
+        realm.colliders.remove(
+            handle,
+            &mut realm.island_manager,
+            &mut realm.bodies,
+            true,
+        );
+    }
+    0
+}
+
+pub fn set_collider_position(realm: &mut PhysicsWorld, collider_id: i32, x: f32, y: f32, z: f32) -> i32 {
+    if let Some(&handle) = realm.collider_map.get(&collider_id) {
+        if let Some(c) = realm.colliders.get_mut(handle) {
+            c.set_translation(Vector::new(x, y, z));
+        }
+    }
+    0
+}
+
+/// # Safety
+/// `out` must point to at least 3 f32s.
+pub unsafe fn get_collider_position(realm: &PhysicsWorld, collider_id: i32, out: *mut f32) -> i32 {
+    let o = std::slice::from_raw_parts_mut(out, 3);
+    match realm
+        .collider_map
+        .get(&collider_id)
+        .and_then(|&h| realm.colliders.get(h))
+    {
+        Some(c) => {
+            let t = c.translation();
+            o[0] = t.x;
+            o[1] = t.y;
+            o[2] = t.z;
+            1
+        }
+        None => {
+            o[0] = 0.0;
+            o[1] = 0.0;
+            o[2] = 0.0;
+            0
+        }
+    }
+}
+
+/// Rapier `ShapeType` discriminant for the live collider (-1 if absent).
+///
+/// The value is translated to the @dimforge/rapier3d-compat JS enum so
+/// callers see identical numbers across WASM and native backends. The two
+/// differ: native parry3d orders Segment, Triangle, TriMesh, Polyline,
+/// HalfSpace mid-enum (HalfSpace=7, ConvexPolyhedron=10), while the WASM
+/// bindings move HalfSpace to 17 and order the mid-enum Segment, Polyline,
+/// Triangle, TriMesh (ConvexPolyhedron=9).
+pub fn collider_shape_type(realm: &PhysicsWorld, collider_id: i32) -> i32 {
+    use rapier3d::parry::shape::ShapeType as T;
+    realm
+        .collider_map
+        .get(&collider_id)
+        .and_then(|&h| realm.colliders.get(h))
+        .map(|c| match c.shape().shape_type() {
+            T::Segment => 3,
+            T::Polyline => 4,
+            T::Triangle => 5,
+            T::TriMesh => 6,
+            T::HeightField => 7,
+            T::Compound => 8,
+            T::ConvexPolyhedron => 9,
+            T::Cylinder => 10,
+            T::Cone => 11,
+            T::RoundCuboid => 12,
+            T::RoundTriangle => 13,
+            T::RoundCylinder => 14,
+            T::RoundCone => 15,
+            T::RoundConvexPolyhedron => 16,
+            T::HalfSpace => 17,
+            // Ball=0, Cuboid=1, Capsule=2 line up; Custom has no JS analog.
+            T::Ball | T::Cuboid | T::Capsule => c.shape().shape_type() as i32,
+            _ => -1,
+        })
+        .unwrap_or(-1)
+}
+
+/// Number of live colliders attached to the body (-1 if body absent).
+pub fn collider_count(realm: &PhysicsWorld, body_id: i32) -> i32 {
+    realm
+        .body_map
+        .get(&body_id)
+        .and_then(|&h| realm.bodies.get(h))
+        .map(|b| b.colliders().len() as i32)
+        .unwrap_or(-1)
+}
+
+/// Whether a convex hull can be built from `verts` (n*3 floats).
+///
+/// # Safety
+/// `verts` must point to `n_verts * 3` f32s.
+pub unsafe fn test_convex_hull(verts: *const f32, n_verts: usize) -> i32 {
+    if verts.is_null() || n_verts == 0 {
+        return 0;
+    }
+    let vs = std::slice::from_raw_parts(verts, n_verts * 3);
+    let points: Vec<Point<f32>> = (0..n_verts)
+        .map(|i| Point::new(vs[i * 3], vs[i * 3 + 1], vs[i * 3 + 2]))
+        .collect();
+    SharedShape::convex_hull(&points).is_some() as i32
+}

package/libraries/physics-native/native/src/joint.rs

@@ -0,0 +1,81 @@
+use rapier3d::na::{Quaternion, Unit, UnitQuaternion};
+use rapier3d::prelude::*;
+use crate::world::PhysicsWorld;
+
+// ── dd_create_joint descriptor layout ────────────────────────────────────
+// jtype: 0=fixed, 1=spherical ("cone-twist" in the JS API), 2=revolute,
+//        3=prismatic
+// f: [anchorA xyz, anchorB xyz, axis xyz, limit_min, limit_max,
+//     frameA quat xyzw, frameB quat xyzw]
+pub const JOINT_F32_LEN: usize = 19;
+
+/// # Safety
+/// `f` must point to JOINT_F32_LEN f32s.
+pub unsafe fn create_joint(
+    realm: &mut PhysicsWorld,
+    joint_id: i32,
+    parent_body_id: i32,
+    child_body_id: i32,
+    jtype: i32,
+    f: *const f32,
+) -> i32 {
+    let f = std::slice::from_raw_parts(f, JOINT_F32_LEN);
+    let Some(&parent) = realm.body_map.get(&parent_body_id) else {
+        return -1;
+    };
+    let Some(&child) = realm.body_map.get(&child_body_id) else {
+        return -1;
+    };
+
+    let anchor_a = Point::new(f[0], f[1], f[2]);
+    let anchor_b = Point::new(f[3], f[4], f[5]);
+    let axis_v = vector![f[6], f[7], f[8]];
+    let frame_a = UnitQuaternion::from_quaternion(Quaternion::new(f[14], f[11], f[12], f[13]));
+    let frame_b = UnitQuaternion::from_quaternion(Quaternion::new(f[18], f[15], f[16], f[17]));
+
+    let data: GenericJoint = match jtype {
+        0 => {
+            let mut j = FixedJoint::new();
+            j.set_local_frame1(Isometry::from_parts(Translation::from(anchor_a.coords), frame_a));
+            j.set_local_frame2(Isometry::from_parts(Translation::from(anchor_b.coords), frame_b));
+            j.into()
+        }
+        1 => {
+            let mut j = SphericalJoint::new();
+            j.set_local_anchor1(anchor_a);
+            j.set_local_anchor2(anchor_b);
+            j.into()
+        }
+        2 => {
+            let axis = Unit::try_new(axis_v, 1.0e-6)
+                .unwrap_or_else(|| Unit::new_unchecked(vector![0.0, 1.0, 0.0]));
+            let mut j = RevoluteJoint::new(axis);
+            j.set_local_anchor1(anchor_a);
+            j.set_local_anchor2(anchor_b);
+            if f[9] != 0.0 || f[10] != 0.0 {
+                j.set_limits([f[9], f[10]]);
+            }
+            j.into()
+        }
+        _ => {
+            let axis = Unit::try_new(axis_v, 1.0e-6)
+                .unwrap_or_else(|| Unit::new_unchecked(vector![0.0, 1.0, 0.0]));
+            let mut j = PrismaticJoint::new(axis);
+            j.set_local_anchor1(anchor_a);
+            j.set_local_anchor2(anchor_b);
+            j.set_limits([f[9], f[10]]);
+            j.into()
+        }
+    };
+
+    let handle = realm.impulse_joints.insert(parent, child, data, true);
+    realm.joint_map.insert(joint_id, handle);
+    0
+}
+
+pub fn destroy_joint(realm: &mut PhysicsWorld, joint_id: i32) -> i32 {
+    if let Some(handle) = realm.joint_map.remove(&joint_id) {
+        realm.impulse_joints.remove(handle, true);
+    }
+    0
+}