chore: 添加第三方依赖库

thirdparty/rapier.js/src.ts/pipeline/event_queue.ts

@@ -0,0 +1,158 @@
+import {RawContactForceEvent, RawEventQueue} from "../raw";
+import {RigidBodyHandle} from "../dynamics";
+import {Collider, ColliderHandle} from "../geometry";
+import {Vector, VectorOps} from "../math";
+
+/**
+ * Flags indicating what events are enabled for colliders.
+ */
+export enum ActiveEvents {
+    NONE = 0,
+    /**
+     * Enable collision events.
+     */
+    COLLISION_EVENTS = 0b0001,
+    /**
+     * Enable contact force events.
+     */
+    CONTACT_FORCE_EVENTS = 0b0010,
+}
+
+/**
+ * Event occurring when the sum of the magnitudes of the
+ * contact forces between two colliders exceed a threshold.
+ *
+ * This object should **not** be stored anywhere. Its properties can only be
+ * read from within the closure given to `EventHandler.drainContactForceEvents`.
+ */
+export class TempContactForceEvent {
+    raw: RawContactForceEvent;
+
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    /**
+     * The first collider involved in the contact.
+     */
+    public collider1(): ColliderHandle {
+        return this.raw.collider1();
+    }
+
+    /**
+     * The second collider involved in the contact.
+     */
+    public collider2(): ColliderHandle {
+        return this.raw.collider2();
+    }
+
+    /**
+     * The sum of all the forces between the two colliders.
+     */
+    public totalForce(): Vector {
+        return VectorOps.fromRaw(this.raw.total_force());
+    }
+
+    /**
+     * The sum of the magnitudes of each force between the two colliders.
+     *
+     * Note that this is **not** the same as the magnitude of `self.total_force`.
+     * Here we are summing the magnitude of all the forces, instead of taking
+     * the magnitude of their sum.
+     */
+    public totalForceMagnitude(): number {
+        return this.raw.total_force_magnitude();
+    }
+
+    /**
+     * The world-space (unit) direction of the force with strongest magnitude.
+     */
+    public maxForceDirection(): Vector {
+        return VectorOps.fromRaw(this.raw.max_force_direction());
+    }
+
+    /**
+     * The magnitude of the largest force at a contact point of this contact pair.
+     */
+    public maxForceMagnitude(): number {
+        return this.raw.max_force_magnitude();
+    }
+}
+
+/**
+ * A structure responsible for collecting events generated
+ * by the physics engine.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `eventQueue.free()`
+ * once you are done using it.
+ */
+export class EventQueue {
+    raw: RawEventQueue;
+
+    /**
+     * Creates a new event collector.
+     *
+     * @param autoDrain -setting this to `true` is strongly recommended. If true, the collector will
+     * be automatically drained before each `world.step(collector)`. If false, the collector will
+     * keep all events in memory unless it is manually drained/cleared; this may lead to unbounded use of
+     * RAM if no drain is performed.
+     */
+    constructor(autoDrain: boolean, raw?: RawEventQueue) {
+        this.raw = raw || new RawEventQueue(autoDrain);
+    }
+
+    /**
+     * Release the WASM memory occupied by this event-queue.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    /**
+     * Applies the given javascript closure on each collision event of this collector, then clear
+     * the internal collision event buffer.
+     *
+     * @param f - JavaScript closure applied to each collision event. The
+     * closure must take three arguments: two integers representing the handles of the colliders
+     * involved in the collision, and a boolean indicating if the collision started (true) or stopped
+     * (false).
+     */
+    public drainCollisionEvents(
+        f: (
+            handle1: ColliderHandle,
+            handle2: ColliderHandle,
+            started: boolean,
+        ) => void,
+    ) {
+        this.raw.drainCollisionEvents(f);
+    }
+
+    /**
+     * Applies the given javascript closure on each contact force event of this collector, then clear
+     * the internal collision event buffer.
+     *
+     * @param f - JavaScript closure applied to each collision event. The
+     *            closure must take one `TempContactForceEvent` argument.
+     */
+    public drainContactForceEvents(f: (event: TempContactForceEvent) => void) {
+        let event = new TempContactForceEvent();
+        this.raw.drainContactForceEvents((raw: RawContactForceEvent) => {
+            event.raw = raw;
+            f(event);
+            event.free();
+        });
+    }
+
+    /**
+     * Removes all events contained by this collector
+     */
+    public clear() {
+        this.raw.clear();
+    }
+}