@downdraft/engine 0.0.0 → 0.1.1

package/libraries/persistence/src/save-worker-proxy.ts

@@ -0,0 +1,127 @@
+// ============================================================================
+// SaveWorkerProxy — ISaveStore implementation that delegates to a dedicated
+// save Web Worker via the engine's RPC layer.
+// ============================================================================
+//
+// The renderer creates this proxy when "worker" mode is selected. The proxy
+// spawns the save worker, calls init(), and forwards all ISaveStore methods
+// via postMessage (with ArrayBuffer transfer for zero-copy blob/thumbnail
+// transfer).
+
+import type {
+    ISaveStore,
+    LoadOptions,
+    LoadResult,
+    SaveGenerationInfo,
+    SaveOptions,
+    SaveResult,
+    SaveSlotInfo,
+    SaveState,
+    SaveWarning,
+} from "@downdraft/engine";
+import { wrap, type WorkerProxy } from "@downdraft/engine/worker/rpc";
+import type { OpfsSaveStoreOptions } from "./opfs-save-store";
+import type { SaveWorkerApi } from "./save-worker";
+
+export interface SaveWorkerProxyOptions {
+  /** Options for the OpfsSaveStore inside the worker. */
+  storeOptions: OpfsSaveStoreOptions;
+  /** Worker URL (if not provided, defaults to ./save-worker.ts). */
+  workerUrl?: URL;
+}
+
+export class SaveWorkerProxy implements ISaveStore {
+  private wp: WorkerProxy<SaveWorkerApi> | null = null;
+  private warningCallbacks: Array<(w: SaveWarning) => void> = [];
+  private initialized = false;
+
+  constructor(private opts: SaveWorkerProxyOptions) {}
+
+  /**
+   * Spawn the worker and initialize the OpfsSaveStore inside it.
+   * Must be called before any save/load operation.
+   */
+  async init(): Promise<void> {
+    if (this.initialized) return;
+
+    // NOTE: `new URL(...)` must be inlined directly inside `new Worker()` —
+    // Vite only bundles worker modules when it sees this exact pattern.
+    // Assigning the URL to a variable first causes Vite to emit the worker
+    // as a raw unbundled asset (bare imports unresolved), breaking prod.
+    const worker = this.opts.workerUrl
+      ? new Worker(this.opts.workerUrl, { type: "module" })
+      : new Worker(new URL("./save-worker.ts", import.meta.url), { type: "module" });
+    this.wp = wrap<SaveWorkerApi>(worker);
+
+    await this.wp.proxy.init(this.opts.storeOptions);
+    this.initialized = true;
+  }
+
+  private ensureInit(): WorkerProxy<SaveWorkerApi> {
+    if (!this.wp || !this.initialized) {
+      throw new Error("SaveWorkerProxy not initialized — call init() first");
+    }
+    return this.wp;
+  }
+
+  async save(slot: string, state: SaveState, opts?: SaveOptions): Promise<SaveResult> {
+    return this.ensureInit().proxy.save(slot, state, opts);
+  }
+
+  async load(slot: string, opts?: LoadOptions): Promise<LoadResult> {
+    return this.ensureInit().proxy.load(slot, opts);
+  }
+
+  async listSaves(): Promise<SaveSlotInfo[]> {
+    return this.ensureInit().proxy.listSaves();
+  }
+
+  async listGenerations(slot: string): Promise<SaveGenerationInfo[]> {
+    return this.ensureInit().proxy.listGenerations(slot);
+  }
+
+  async deleteSave(slot: string): Promise<boolean> {
+    return this.ensureInit().proxy.deleteSave(slot);
+  }
+
+  async deleteGeneration(slot: string, gen: number): Promise<boolean> {
+    return this.ensureInit().proxy.deleteGeneration(slot, gen);
+  }
+
+  async setThumbnail(slot: string, data: ArrayBuffer | Uint8Array): Promise<void> {
+    return this.ensureInit().proxy.setThumbnail(slot, data);
+  }
+
+  async getThumbnail(slot: string): Promise<ArrayBuffer | null> {
+    return this.ensureInit().proxy.getThumbnail(slot);
+  }
+
+  async setProperties(slot: string, props: Record<string, unknown>): Promise<void> {
+    return this.ensureInit().proxy.setProperties(slot, props);
+  }
+
+  async getProperties(slot: string): Promise<Record<string, unknown>> {
+    return this.ensureInit().proxy.getProperties(slot);
+  }
+
+  onWarning(cb: (warning: SaveWarning) => void): () => void {
+    this.warningCallbacks.push(cb);
+    // Note: the worker forwards warnings via events; the proxy would need
+    // to subscribe to events and forward. For now, warnings are logged in
+    // the worker. A future improvement can wire up event forwarding.
+    return () => {
+      const idx = this.warningCallbacks.indexOf(cb);
+      if (idx >= 0) this.warningCallbacks.splice(idx, 1);
+    };
+  }
+
+  /** Terminate the worker and clean up. */
+  async shutdown(): Promise<void> {
+    if (this.wp) {
+      try { await this.wp.proxy.shutdown(); } catch {}
+      this.wp.terminate();
+      this.wp = null;
+    }
+    this.initialized = false;
+  }
+}

package/libraries/persistence/src/save-worker.ts

@@ -0,0 +1,99 @@
+// ============================================================================
+// Save Worker — dedicated Web Worker that owns an OpfsSaveStore instance.
+// ============================================================================
+//
+// The renderer spawns this worker when "worker" mode is selected. The sim
+// worker sends serialized state (as transferable ArrayBuffer) to this worker
+// via a MessageChannel, and this worker writes it to OPFS directly.
+//
+// Uses the engine's RPC layer (expose/exposeEvents) for typed communication.
+
+import { expose } from "@downdraft/engine/worker/rpc";
+import { OpfsSaveStore, type OpfsSaveStoreOptions } from "./opfs-save-store";
+import type {
+  ISaveStore,
+  LoadOptions,
+  LoadResult,
+  SaveGenerationInfo,
+  SaveOptions,
+  SaveResult,
+  SaveSlotInfo,
+  SaveState,
+  SaveWarning,
+} from "@downdraft/engine";
+
+(globalThis as any).__ddThreadTag = "S1";
+
+let store: OpfsSaveStore | null = null;
+
+const api = {
+  async init(opts: OpfsSaveStoreOptions): Promise<void> {
+    store = new OpfsSaveStore(opts);
+    await store.init();
+  },
+
+  async save(slot: string, state: SaveState, opts?: SaveOptions): Promise<SaveResult> {
+    if (!store) throw new Error("Save worker not initialized — call init() first");
+    return store.save(slot, state, opts);
+  },
+
+  async load(slot: string, opts?: LoadOptions): Promise<LoadResult> {
+    if (!store) throw new Error("Save worker not initialized");
+    return store.load(slot, opts);
+  },
+
+  async listSaves(): Promise<SaveSlotInfo[]> {
+    if (!store) throw new Error("Save worker not initialized");
+    return store.listSaves();
+  },
+
+  async listGenerations(slot: string): Promise<SaveGenerationInfo[]> {
+    if (!store) throw new Error("Save worker not initialized");
+    return store.listGenerations(slot);
+  },
+
+  async deleteSave(slot: string): Promise<boolean> {
+    if (!store) throw new Error("Save worker not initialized");
+    return store.deleteSave(slot);
+  },
+
+  async deleteGeneration(slot: string, gen: number): Promise<boolean> {
+    if (!store) throw new Error("Save worker not initialized");
+    return store.deleteGeneration(slot, gen);
+  },
+
+  async setThumbnail(slot: string, data: ArrayBuffer | Uint8Array): Promise<void> {
+    if (!store) throw new Error("Save worker not initialized");
+    return store.setThumbnail(slot, data);
+  },
+
+  async getThumbnail(slot: string): Promise<ArrayBuffer | null> {
+    if (!store) throw new Error("Save worker not initialized");
+    return store.getThumbnail(slot);
+  },
+
+  async setProperties(slot: string, props: Record<string, unknown>): Promise<void> {
+    if (!store) throw new Error("Save worker not initialized");
+    return store.setProperties(slot, props);
+  },
+
+  async getProperties(slot: string): Promise<Record<string, unknown>> {
+    if (!store) throw new Error("Save worker not initialized");
+    return store.getProperties(slot);
+  },
+
+  onWarning(): void {
+    // Warnings are forwarded as events — the proxy sets up the callback
+    // and forwards via exposeEvents. For simplicity, warnings are logged.
+  },
+
+  async shutdown(): Promise<void> {
+    store = null;
+  },
+};
+
+expose(api);
+
+// Also export the type for the proxy side
+export type SaveWorkerApi = typeof api;
+export type { ISaveStore, SaveState, SaveOptions, LoadOptions, SaveResult, LoadResult, SaveSlotInfo, SaveGenerationInfo, SaveWarning };

package/libraries/persistence/src/xxh3-ts.d.ts

@@ -0,0 +1,10 @@
+// Type declaration for xxh3-ts.
+//
+// The package ships .ts source files alongside .js and .d.ts. With
+// moduleResolution "bundler", TypeScript resolves `export * from "./xxh3"` in
+// index.d.ts to xxh3.ts (preferring .ts over .d.ts), which triggers a
+// BigUint64Array<ArrayBufferLike> vs BigUint64Array<ArrayBuffer> error on
+// TS 5.9+. This file is mapped via tsconfig `paths` so TypeScript uses these
+// types instead of following into the package's .ts source. The runtime .js
+// export is correct and Vite resolves the real module through node_modules.
+export declare function XXH3_128(data: Uint8Array, seed?: bigint): bigint;

package/libraries/physics-native/README.md

@@ -0,0 +1,21 @@
+# `@downdraft/engine/libraries/physics-native`
+
+Native physics backend — binds the engine's UniversalPhysicsAPI to the native physics library.
+
+## Install
+
+```sh
+bun add @downdraft/engine/libraries/physics-native
+```
+
+## Key exports
+
+- `Broadphase`
+- `NativePhysicsBackend`
+- `PhysicsNativeAPITok`
+- `PhysicsNativeLib`
+- `detectCollision`
+- `integrate`
+- `resolveContact`
+
+See the [Downdraft engine repository](https://github.com/knackstedt/downdraft) for architecture docs and examples.

package/libraries/physics-native/native/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "downdraft-physics"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "downdraft_physics"
+crate-type = ["cdylib"]
+
+[dependencies]
+rapier3d = "0.19"

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

@@ -0,0 +1,403 @@
+use rapier3d::na::{Quaternion, UnitQuaternion};
+use rapier3d::prelude::*;
+use crate::world::PhysicsWorld;
+
+// ── dd_create_body descriptor layout ─────────────────────────────────────
+// f[0..3]  position xyz        f[3..7]  rotation quat (x,y,z,w)
+// f[7..10] linear velocity     f[10..13] angular velocity
+// f[13]    mass (additional)   f[14]    linear damping
+// f[15]    angular damping     f[16]    gravity scale
+// i[0]     body type: 0=fixed, 1=kinematic(position), 2=dynamic
+// i[1]     flags:
+//   bit0  ccdEnabled
+//   bit1  canSleep (1 = can sleep; mirrors WASM `canSleep === false` opt-out)
+//   bit2  sleeping (start asleep)
+//   bit3..5  locked translations x,y,z
+//   bit6..8  locked rotations x,y,z
+//   bit9   has mass        bit10 has linearDamping
+//   bit11  has angularDamping  bit12 has gravityScale
+pub const BODY_F32_LEN: usize = 17;
+pub const BODY_I32_LEN: usize = 2;
+
+pub fn create_body(
+    realm: &mut PhysicsWorld,
+    body_id: i32,
+    f: &[f32],
+    i: &[i32],
+) -> i32 {
+    let transform = Isometry::from_parts(
+        Translation::new(f[0], f[1], f[2]),
+        UnitQuaternion::from_quaternion(Quaternion::new(f[6], f[3], f[4], f[5])),
+    );
+
+    let body_type = i[0];
+    let flags = i[1];
+    let rb_type = match body_type {
+        0 => RigidBodyType::Fixed,
+        1 => RigidBodyType::KinematicPositionBased,
+        _ => RigidBodyType::Dynamic,
+    };
+
+    let mut builder = RigidBodyBuilder::new(rb_type)
+        .position(transform)
+        .linvel(Vector::new(f[7], f[8], f[9]))
+        .angvel(Vector::new(f[10], f[11], f[12]));
+
+    if flags & (1 << 9) != 0 {
+        builder = builder.additional_mass(f[13]);
+    }
+    if flags & (1 << 10) != 0 {
+        builder = builder.linear_damping(f[14]);
+    }
+    if flags & (1 << 11) != 0 {
+        builder = builder.angular_damping(f[15]);
+    }
+    if flags & (1 << 12) != 0 {
+        builder = builder.gravity_scale(f[16]);
+    }
+    if flags & 1 != 0 {
+        builder = builder.ccd_enabled(true);
+    }
+    if flags & (1 << 1) == 0 {
+        builder = builder.can_sleep(false);
+    }
+    if flags & (1 << 2) != 0 {
+        builder = builder.sleeping(true);
+    }
+    let lock_t = [
+        flags & (1 << 3) != 0,
+        flags & (1 << 4) != 0,
+        flags & (1 << 5) != 0,
+    ];
+    if lock_t.iter().any(|b| *b) {
+        builder = builder.enabled_translations(!lock_t[0], !lock_t[1], !lock_t[2]);
+    }
+    let lock_r = [
+        flags & (1 << 6) != 0,
+        flags & (1 << 7) != 0,
+        flags & (1 << 8) != 0,
+    ];
+    if lock_r.iter().all(|b| *b) {
+        builder = builder.lock_rotations();
+    } else if lock_r.iter().any(|b| *b) {
+        builder = builder.enabled_rotations(!lock_r[0], !lock_r[1], !lock_r[2]);
+    }
+
+    let handle = realm.bodies.insert(builder);
+    realm.body_map.insert(body_id, handle);
+    realm.body_id_by_handle.insert(handle, body_id);
+    0
+}
+
+pub fn destroy_body(realm: &mut PhysicsWorld, body_id: i32) -> i32 {
+    if let Some(handle) = realm.body_map.remove(&body_id) {
+        realm.body_id_by_handle.remove(&handle);
+        // Drop controllers bound to this body so they can't dangle.
+        realm
+            .controller_map
+            .retain(|_, c| c.body != Some(handle));
+        realm.bodies.remove(
+            handle,
+            &mut realm.island_manager,
+            &mut realm.colliders,
+            &mut realm.impulse_joints,
+            &mut realm.multibody_joints,
+            true,
+        );
+    }
+    0
+}
+
+pub fn set_body_type(realm: &mut PhysicsWorld, body_id: i32, body_type: i32) -> i32 {
+    if let Some(&handle) = realm.body_map.get(&body_id) {
+        if let Some(body) = realm.bodies.get_mut(handle) {
+            let rb_type = match body_type {
+                0 => RigidBodyType::Fixed,
+                1 => RigidBodyType::KinematicPositionBased,
+                _ => RigidBodyType::Dynamic,
+            };
+            body.set_body_type(rb_type, true);
+        }
+    }
+    0
+}
+
+fn body<'a>(realm: &'a mut PhysicsWorld, body_id: i32) -> Option<&'a mut RigidBody> {
+    let &handle = realm.body_map.get(&body_id)?;
+    realm.bodies.get_mut(handle)
+}
+
+fn body_ref<'a>(realm: &'a PhysicsWorld, body_id: i32) -> Option<&'a RigidBody> {
+    let &handle = realm.body_map.get(&body_id)?;
+    realm.bodies.get(handle)
+}
+
+pub fn set_translation(realm: &mut PhysicsWorld, body_id: i32, x: f32, y: f32, z: f32, wake: bool) -> i32 {
+    if let Some(b) = body(realm, body_id) {
+        b.set_translation(Vector::new(x, y, z), wake);
+    }
+    0
+}
+
+pub fn set_rotation(realm: &mut PhysicsWorld, body_id: i32, x: f32, y: f32, z: f32, w: f32, wake: bool) -> i32 {
+    if let Some(b) = body(realm, body_id) {
+        b.set_rotation(UnitQuaternion::from_quaternion(Quaternion::new(w, x, y, z)), wake);
+    }
+    0
+}
+
+/// # Safety
+/// `out` must point to at least 3 f32s.
+pub unsafe fn get_translation(realm: &PhysicsWorld, body_id: i32, out: *mut f32) -> i32 {
+    let o = std::slice::from_raw_parts_mut(out, 3);
+    match body_ref(realm, body_id) {
+        Some(b) => {
+            let t = b.translation();
+            o[0] = t.x;
+            o[1] = t.y;
+            o[2] = t.z;
+        }
+        None => {
+            o[0] = 0.0;
+            o[1] = 0.0;
+            o[2] = 0.0;
+        }
+    }
+    0
+}
+
+/// # Safety
+/// `out` must point to at least 4 f32s.
+pub unsafe fn get_rotation(realm: &PhysicsWorld, body_id: i32, out: *mut f32) -> i32 {
+    let o = std::slice::from_raw_parts_mut(out, 4);
+    match body_ref(realm, body_id) {
+        Some(b) => {
+            let r = b.rotation().quaternion();
+            o[0] = r.i;
+            o[1] = r.j;
+            o[2] = r.k;
+            o[3] = r.w;
+        }
+        None => {
+            o[0] = 0.0;
+            o[1] = 0.0;
+            o[2] = 0.0;
+            o[3] = 1.0;
+        }
+    }
+    0
+}
+
+pub fn set_linvel(realm: &mut PhysicsWorld, body_id: i32, x: f32, y: f32, z: f32, wake: bool) -> i32 {
+    if let Some(b) = body(realm, body_id) {
+        b.set_linvel(Vector::new(x, y, z), wake);
+    }
+    0
+}
+
+pub fn set_angvel(realm: &mut PhysicsWorld, body_id: i32, x: f32, y: f32, z: f32, wake: bool) -> i32 {
+    if let Some(b) = body(realm, body_id) {
+        b.set_angvel(Vector::new(x, y, z), wake);
+    }
+    0
+}
+
+/// # Safety
+/// `out` must point to at least 3 f32s.
+pub unsafe fn get_linvel(realm: &PhysicsWorld, body_id: i32, out: *mut f32) -> i32 {
+    let o = std::slice::from_raw_parts_mut(out, 3);
+    match body_ref(realm, body_id) {
+        Some(b) => {
+            let v = b.linvel();
+            o[0] = v.x;
+            o[1] = v.y;
+            o[2] = v.z;
+        }
+        None => {
+            o[0] = 0.0;
+            o[1] = 0.0;
+            o[2] = 0.0;
+        }
+    }
+    0
+}
+
+/// # Safety
+/// `out` must point to at least 3 f32s.
+pub unsafe fn get_angvel(realm: &PhysicsWorld, body_id: i32, out: *mut f32) -> i32 {
+    let o = std::slice::from_raw_parts_mut(out, 3);
+    match body_ref(realm, body_id) {
+        Some(b) => {
+            let v = b.angvel();
+            o[0] = v.x;
+            o[1] = v.y;
+            o[2] = v.z;
+        }
+        None => {
+            o[0] = 0.0;
+            o[1] = 0.0;
+            o[2] = 0.0;
+        }
+    }
+    0
+}
+
+/// # Safety
+/// `out` must point to at least 7 f32s (pos3 + quat4).
+pub unsafe fn get_body_transform(realm: &PhysicsWorld, body_id: i32, out: *mut f32) -> i32 {
+    let o = std::slice::from_raw_parts_mut(out, 7);
+    match body_ref(realm, body_id) {
+        Some(b) => {
+            let t = b.translation();
+            let r = b.rotation().quaternion();
+            o[0] = t.x;
+            o[1] = t.y;
+            o[2] = t.z;
+            o[3] = r.i;
+            o[4] = r.j;
+            o[5] = r.k;
+            o[6] = r.w;
+            1
+        }
+        None => 0,
+    }
+}
+
+pub fn is_sleeping(realm: &PhysicsWorld, body_id: i32) -> i32 {
+    match body_ref(realm, body_id) {
+        Some(b) => b.is_sleeping() as i32,
+        None => 0,
+    }
+}
+
+pub fn wake_up(realm: &mut PhysicsWorld, body_id: i32) -> i32 {
+    if let Some(&handle) = realm.body_map.get(&body_id) {
+        realm.island_manager.wake_up(&mut realm.bodies, handle, true);
+    }
+    0
+}
+
+pub fn set_ccd(realm: &mut PhysicsWorld, body_id: i32, enabled: bool) -> i32 {
+    if let Some(b) = body(realm, body_id) {
+        b.enable_ccd(enabled);
+    }
+    0
+}
+
+// ── Forces / impulses ────────────────────────────────────────────────────
+
+pub fn apply_force(realm: &mut PhysicsWorld, body_id: i32, f: [f32; 3]) -> i32 {
+    if let Some(b) = body(realm, body_id) {
+        b.add_force(Vector::new(f[0], f[1], f[2]), true);
+    }
+    0
+}
+
+pub fn apply_torque(realm: &mut PhysicsWorld, body_id: i32, f: [f32; 3]) -> i32 {
+    if let Some(b) = body(realm, body_id) {
+        b.add_torque(Vector::new(f[0], f[1], f[2]), true);
+    }
+    0
+}
+
+pub fn apply_impulse(realm: &mut PhysicsWorld, body_id: i32, f: [f32; 3]) -> i32 {
+    if let Some(b) = body(realm, body_id) {
+        b.apply_impulse(Vector::new(f[0], f[1], f[2]), true);
+    }
+    0
+}
+
+pub fn apply_torque_impulse(realm: &mut PhysicsWorld, body_id: i32, f: [f32; 3]) -> i32 {
+    if let Some(b) = body(realm, body_id) {
+        b.apply_torque_impulse(Vector::new(f[0], f[1], f[2]), true);
+    }
+    0
+}
+
+pub fn apply_impulse_at_point(
+    realm: &mut PhysicsWorld,
+    body_id: i32,
+    impulse: [f32; 3],
+    point: [f32; 3],
+) -> i32 {
+    if let Some(b) = body(realm, body_id) {
+        b.apply_impulse_at_point(
+            Vector::new(impulse[0], impulse[1], impulse[2]),
+            Point::new(point[0], point[1], point[2]),
+            true,
+        );
+    }
+    0
+}
+
+/// Batched state write — the plan's `applyBodyWrites`.
+/// `states` holds 13 floats per body: [pos3, quat4, linvel3, angvel3].
+///
+/// # Safety
+/// `ids` must point to `count` i32s, `states` to `count * 13` f32s.
+pub unsafe fn apply_body_writes(
+    realm: &mut PhysicsWorld,
+    ids: *const i32,
+    states: *const f32,
+    count: usize,
+    wake: bool,
+) -> i32 {
+    let id_slice = std::slice::from_raw_parts(ids, count);
+    let state_slice = std::slice::from_raw_parts(states, count * 13);
+    for (i, &body_id) in id_slice.iter().enumerate() {
+        let o = i * 13;
+        if let Some(b) = body(realm, body_id) {
+            b.set_translation(
+                Vector::new(state_slice[o], state_slice[o + 1], state_slice[o + 2]),
+                wake,
+            );
+            b.set_rotation(
+                UnitQuaternion::from_quaternion(Quaternion::new(
+                    state_slice[o + 6],
+                    state_slice[o + 3],
+                    state_slice[o + 4],
+                    state_slice[o + 5],
+                )),
+                wake,
+            );
+            b.set_linvel(
+                Vector::new(state_slice[o + 7], state_slice[o + 8], state_slice[o + 9]),
+                wake,
+            );
+            b.set_angvel(
+                Vector::new(state_slice[o + 10], state_slice[o + 11], state_slice[o + 12]),
+                wake,
+            );
+        }
+    }
+    0
+}
+
+/// Batched impulse application — the plan's `applyImpulses`.
+/// `impulses` holds 6 floats per body: [lin3, ang3].
+///
+/// # Safety
+/// `ids` must point to `count` i32s, `impulses` to `count * 6` f32s.
+pub unsafe fn apply_impulses(
+    realm: &mut PhysicsWorld,
+    ids: *const i32,
+    impulses: *const f32,
+    count: usize,
+) -> i32 {
+    let id_slice = std::slice::from_raw_parts(ids, count);
+    let imp_slice = std::slice::from_raw_parts(impulses, count * 6);
+    for (i, &body_id) in id_slice.iter().enumerate() {
+        let o = i * 6;
+        if let Some(b) = body(realm, body_id) {
+            let lin = Vector::new(imp_slice[o], imp_slice[o + 1], imp_slice[o + 2]);
+            let ang = Vector::new(imp_slice[o + 3], imp_slice[o + 4], imp_slice[o + 5]);
+            if lin.norm_squared() > 0.0 {
+                b.apply_impulse(lin, true);
+            }
+            if ang.norm_squared() > 0.0 {
+                b.apply_torque_impulse(ang, true);
+            }
+        }
+    }
+    0
+}