@melonjs/rapier3d-adapter 0.0.0-stage → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (40) hide show
  1. package/CHANGELOG.md +16 -0
  2. package/LICENSE +21 -0
  3. package/README.md +341 -2
  4. package/build/Rapier3dAdapter.d.ts +396 -0
  5. package/build/Rapier3dAdapter.d.ts.map +1 -0
  6. package/build/Simulation.d.ts +35 -0
  7. package/build/Simulation.d.ts.map +1 -0
  8. package/build/bodies/Motion.d.ts +64 -0
  9. package/build/bodies/Motion.d.ts.map +1 -0
  10. package/build/bodies/RuntimeOverrides.d.ts +16 -0
  11. package/build/bodies/RuntimeOverrides.d.ts.map +1 -0
  12. package/build/bodies/helpers.d.ts +30 -0
  13. package/build/bodies/helpers.d.ts.map +1 -0
  14. package/build/bodies/pose.d.ts +34 -0
  15. package/build/bodies/pose.d.ts.map +1 -0
  16. package/build/colliders/CollisionFilters.d.ts +60 -0
  17. package/build/colliders/CollisionFilters.d.ts.map +1 -0
  18. package/build/colliders/footprint.d.ts +22 -0
  19. package/build/colliders/footprint.d.ts.map +1 -0
  20. package/build/colliders/shapes.d.ts +18 -0
  21. package/build/colliders/shapes.d.ts.map +1 -0
  22. package/build/colliders/types.d.ts +48 -0
  23. package/build/colliders/types.d.ts.map +1 -0
  24. package/build/contacts/ContactDispatcher.d.ts +80 -0
  25. package/build/contacts/ContactDispatcher.d.ts.map +1 -0
  26. package/build/index.d.ts +9 -0
  27. package/build/index.d.ts.map +1 -0
  28. package/build/index.js +1942 -0
  29. package/build/index.js.map +7 -0
  30. package/build/joints/Joints.d.ts +51 -0
  31. package/build/joints/Joints.d.ts.map +1 -0
  32. package/build/loader.d.ts +20 -0
  33. package/build/loader.d.ts.map +1 -0
  34. package/build/math/units.d.ts +44 -0
  35. package/build/math/units.d.ts.map +1 -0
  36. package/build/queries/queries.d.ts +40 -0
  37. package/build/queries/queries.d.ts.map +1 -0
  38. package/build/types.d.ts +77 -0
  39. package/build/types.d.ts.map +1 -0
  40. package/package.json +71 -5
@@ -0,0 +1,396 @@
1
+ /**
2
+ * The adapter: the melonJS `PhysicsAdapter` interface on Rapier 3D.
3
+ *
4
+ * It owns the lifecycle (making and freeing the Rapier world, stepping it)
5
+ * and the bodies (making them from a `bodyDef`, removing them), and answers
6
+ * the portable API. The work itself is done by:
7
+ *
8
+ * - `Simulation`: the Rapier world and which body and colliders each
9
+ * renderable has, shared by every part below
10
+ * - `colliders/`: the colliders the 3D shapes become, their collision types
11
+ * and masks, and their footprints
12
+ * - `contacts/`: the collision hooks
13
+ * - `bodies/`: the body's pose on its renderable, its motion, what was set on
14
+ * it at run time, and the helpers on `renderable.body`
15
+ * - `joints/` and `queries/`
16
+ */
17
+ import type * as RAPIER from "@dimforge/rapier3d-compat";
18
+ import { type AdapterCapabilities, type BodyDefinition, type BodyShape, type Bounds, type PhysicsAdapter, type PhysicsBody, Quaternion, type RaycastHit3d, type Rect, type Renderable, type Sphere, Vector2d, Vector3d, type World } from "melonjs";
19
+ import { type Rapier3dAdapterOptions, type Rapier3dJointDefinition, type Vector3Like } from "./types";
20
+ /**
21
+ * melonJS physics adapter for Rapier 3D (https://rapier.rs), compiled to
22
+ * WebAssembly: rigid bodies that move and turn in three dimensions, for a
23
+ * game drawn with `Camera3d`.
24
+ *
25
+ * Bodies are declared as on every adapter, with a `bodyDef`, from the 3D
26
+ * shapes: {@link Box3d}, {@link Sphere}, {@link Capsule3d},
27
+ * {@link ConvexHull3d} and {@link TriangleMesh3d}. Shapes are in the
28
+ * renderable's space, relative to its `pos` (and `depth`), which is where the
29
+ * body sits; each frame the body's position is written back to `pos` /
30
+ * `depth`, and its turn onto `currentTransform`, so a {@link Mesh}, a
31
+ * `Sprite3d` or a `GLTFModel` tumbles as it is simulated.
32
+ *
33
+ * The adapter takes the 3D form of the portable API: `setVelocity`,
34
+ * `applyForce`, `applyImpulse` and `setPosition` take a {@link Vector3d},
35
+ * and `getVelocity3d`, `getRotation` / `setRotation` and
36
+ * `getAngularVelocity3d` read the rest. The 2D calls still work, in the
37
+ * plane of the body: a `Vector2d` leaves the depth as it was.
38
+ *
39
+ * Rapier's WebAssembly has to be compiled before an adapter can be
40
+ * constructed: {@link Rapier3dAdapter.create} does both.
41
+ * @example
42
+ * import { Application, Camera3d } from "melonjs";
43
+ * import { Rapier3dAdapter } from "@melonjs/rapier3d-adapter";
44
+ *
45
+ * const app = new Application(800, 600, {
46
+ * parent: "screen",
47
+ * cameraClass: Camera3d,
48
+ * physic: await Rapier3dAdapter.create(),
49
+ * });
50
+ * @category Plugins
51
+ * @document ../README.md
52
+ */
53
+ export declare class Rapier3dAdapter implements PhysicsAdapter {
54
+ readonly physicLabel = "rapier3d";
55
+ readonly name = "@melonjs/rapier3d-adapter";
56
+ readonly version: string;
57
+ readonly url = "https://www.npmjs.com/package/@melonjs/rapier3d-adapter";
58
+ readonly capabilities: AdapterCapabilities;
59
+ /**
60
+ * World gravity, in pixels per second². Change it at any time; read at
61
+ * every step.
62
+ */
63
+ gravity: Vector3d;
64
+ /**
65
+ * The Rapier module: an escape hatch for what the portable
66
+ * {@link PhysicsAdapter} interface does not cover (other joints, the
67
+ * character controller, native queries). See the README.
68
+ * @see {@link https://rapier.rs/docs/user_guides/javascript/getting_started_js Rapier JavaScript user guide}
69
+ */
70
+ readonly rapier: typeof RAPIER;
71
+ /** Spatial conversion factor between melonJS pixels and Rapier meters. */
72
+ readonly pixelsPerMeter: number;
73
+ /** Back-reference to the owning melonJS world (set in {@link init}). */
74
+ melonWorld: World;
75
+ private readonly subSteps;
76
+ private readonly sim;
77
+ private readonly filters;
78
+ private readonly contacts;
79
+ private readonly motion;
80
+ private readonly joints;
81
+ /** what was set on every collider of a body at run time */
82
+ private readonly overrides;
83
+ /** each body's definition, which `updateShape()` builds from again */
84
+ private readonly defs;
85
+ /** each renderable's transform when its body was made, and its bridge */
86
+ private readonly poses;
87
+ /** the shapes {@link Rapier3dAdapter.getBodyShapes} reports */
88
+ private readonly reportedShapes;
89
+ /**
90
+ * Download and compile Rapier's WebAssembly. Every call returns the same
91
+ * promise, so it can be started early and awaited wherever it is needed;
92
+ * a failed load rejects, and a later call tries again.
93
+ *
94
+ * Rapier is imported with `import()`, so bundlers put it in a chunk of its
95
+ * own, downloaded only when this is called.
96
+ * @returns a promise that resolves once the adapter can be constructed
97
+ * @example
98
+ * const rapierReady = Rapier3dAdapter.load();
99
+ * await loader.preload(assets);
100
+ * await rapierReady;
101
+ * app.world.setAdapter(new Rapier3dAdapter());
102
+ */
103
+ static load(): Promise<void>;
104
+ /**
105
+ * Whether {@link Rapier3dAdapter.load} has finished, so that
106
+ * `new Rapier3dAdapter()` can be called.
107
+ * @returns true once Rapier is compiled
108
+ */
109
+ static get loaded(): boolean;
110
+ /**
111
+ * Create an adapter, the same way for every adapter: wait for
112
+ * {@link Rapier3dAdapter.load}, then construct it.
113
+ * @param options - the constructor's options
114
+ * @returns the new adapter, an instance of the class `create` is called on
115
+ */
116
+ static create<T extends PhysicsAdapter>(this: Pick<typeof Rapier3dAdapter, "load"> & (new (options?: Rapier3dAdapterOptions) => T), options?: Rapier3dAdapterOptions): Promise<T>;
117
+ /**
118
+ * Construct an adapter. Rapier must be loaded first: use
119
+ * {@link Rapier3dAdapter.create}, or await {@link Rapier3dAdapter.load}.
120
+ * @param options - see {@link Rapier3dAdapterOptions}
121
+ */
122
+ constructor(options?: Rapier3dAdapterOptions);
123
+ /** The Rapier world; exposed for advanced use. Made in {@link init}. */
124
+ get world(): RAPIER.World;
125
+ init(world: World): void;
126
+ destroy(): void;
127
+ step(dt: number): void;
128
+ syncFromPhysics(): void;
129
+ addBody(renderable: Renderable, def: BodyDefinition): Rapier3dAdapter.Body;
130
+ removeBody(renderable: Renderable): void;
131
+ /**
132
+ * Give a body new shapes. The body itself stays: its position, turn and
133
+ * velocities, its joints, what was changed on it at run time (static or
134
+ * not, gravity scale, damping, sensor, collision type and mask, bounce,
135
+ * speed cap, Rapier's own settings such as CCD) and the handle on
136
+ * `renderable.body`. Its colliders are replaced, so the pairs touching
137
+ * it end and start again, and its mass is that of the new shapes.
138
+ *
139
+ * A shape this adapter cannot build throws before anything is changed.
140
+ * @param renderable - the body's renderable
141
+ * @param shapes - the new shapes, relative to `pos`
142
+ */
143
+ updateShape(renderable: Renderable, shapes: BodyShape[]): void;
144
+ /**
145
+ * Make a joint between two bodies: what `world.addJoint()` calls, which
146
+ * game code uses instead. A `"hinge"` is a Rapier revolute joint about
147
+ * `axis` (default Z), a `"rope"` a rope joint, a `"weld"` a fixed joint
148
+ * and a `"slider"` a prismatic joint along `axis` (default X). Anchors
149
+ * are in each renderable's own space, relative to its `pos`, in pixels,
150
+ * and the axis in `a`'s; a `z` left out is `0`.
151
+ *
152
+ * The bodies are joined as they stand, however each is turned: a weld
153
+ * and a slider keep the turn between them, and a hinge leaves them only
154
+ * the turn about its axis.
155
+ * @param def - what to join, and how, in pixels and radians
156
+ * @returns the Rapier joint
157
+ */
158
+ addJoint(def: Rapier3dJointDefinition): RAPIER.ImpulseJoint;
159
+ /**
160
+ * Remove a joint {@link Rapier3dAdapter.addJoint} made: what
161
+ * `world.removeJoint()` calls. A joint already gone, with one of its
162
+ * bodies, is ignored.
163
+ * @param joint - the Rapier joint
164
+ */
165
+ removeJoint(joint: RAPIER.ImpulseJoint): void;
166
+ getVelocity(renderable: Renderable, out?: Vector2d): Vector2d;
167
+ /**
168
+ * The body's velocity on all three axes, in pixels per second.
169
+ * @param renderable - the body's renderable
170
+ * @param [out] - the vector to write into
171
+ * @returns the velocity; zero for a renderable with no body here
172
+ */
173
+ getVelocity3d(renderable: Renderable, out?: Vector3d): Vector3d;
174
+ /**
175
+ * Set the body's velocity, in pixels per second. A {@link Vector3d} sets
176
+ * all three axes; a {@link Vector2d} sets x and y and keeps the depth
177
+ * velocity as it was.
178
+ * @param renderable - the body's renderable
179
+ * @param v - the velocity
180
+ */
181
+ setVelocity(renderable: Renderable, v: Vector2d | Vector3d): void;
182
+ /**
183
+ * Push the body for this frame, across every sub-step: it accelerates by
184
+ * `force / mass` pixels per second². A force at `point` (in world pixels)
185
+ * also turns it. A force or point given as a {@link Vector2d} acts in
186
+ * the plane of the body.
187
+ * @param renderable - the body's renderable
188
+ * @param force - the force
189
+ * @param [point] - where it pushes, in world space
190
+ */
191
+ applyForce(renderable: Renderable, force: Vector2d | Vector3d, point?: Vector2d | Vector3d): void;
192
+ /**
193
+ * Strike the body once: its velocity changes by `impulse / mass` pixels
194
+ * per second, at once. An impulse at `point` (in world pixels) also turns
195
+ * it. A {@link Vector2d} strikes in the plane of the body.
196
+ * @param renderable - the body's renderable
197
+ * @param impulse - the impulse
198
+ * @param [point] - where it strikes, in world space
199
+ */
200
+ applyImpulse(renderable: Renderable, impulse: Vector2d | Vector3d, point?: Vector2d | Vector3d): void;
201
+ /**
202
+ * Move the body and its renderable, at once. A {@link Vector3d} sets the
203
+ * depth too; a {@link Vector2d} keeps it. A renderable with no body here
204
+ * is moved all the same, as on every adapter. A coordinate that is not a
205
+ * finite number leaves the body and its renderable where they are.
206
+ * @param renderable - the body's renderable
207
+ * @param p - the new position, in `renderable.pos` space
208
+ */
209
+ setPosition(renderable: Renderable, p: Vector2d | Vector3d): void;
210
+ /**
211
+ * The body's orientation, from the one it had when it was made.
212
+ * @param renderable - the body's renderable
213
+ * @param [out] - the quaternion to write into
214
+ * @returns the orientation; identity for a renderable with no body here
215
+ */
216
+ getRotation(renderable: Renderable, out?: Quaternion): Quaternion;
217
+ /**
218
+ * Turn the body, and its renderable with it, to an orientation, from the
219
+ * one it had when it was made.
220
+ * @param renderable - the body's renderable
221
+ * @param q - the orientation
222
+ */
223
+ setRotation(renderable: Renderable, q: Quaternion): void;
224
+ /**
225
+ * Turn the body to `angle` about Z, the turn a 2D game knows, leaving out
226
+ * any other.
227
+ * @param renderable - the body's renderable
228
+ * @param angle - in radians
229
+ */
230
+ setAngle(renderable: Renderable, angle: number): void;
231
+ /**
232
+ * The body's turn about Z: the angle +X is turned through, seen down Z.
233
+ * @param renderable - the body's renderable
234
+ * @returns in radians; `0` for a renderable with no body here
235
+ */
236
+ getAngle(renderable: Renderable): number;
237
+ /**
238
+ * Set the body's spin, in radians per second: a {@link Vector3d} about
239
+ * each axis, a number about Z, keeping the spin about X and Y.
240
+ * @param renderable - the body's renderable
241
+ * @param omega - the spin
242
+ */
243
+ setAngularVelocity(renderable: Renderable, omega: number | Vector3d): void;
244
+ getAngularVelocity(renderable: Renderable): number;
245
+ /**
246
+ * The body's spin about each axis, in radians per second.
247
+ * @param renderable - the body's renderable
248
+ * @param [out] - the vector to write into
249
+ * @returns the spin; zero for a renderable with no body here
250
+ */
251
+ getAngularVelocity3d(renderable: Renderable, out?: Vector3d): Vector3d;
252
+ /**
253
+ * Twist the body for this frame: a number about Z, a {@link Vector3d}
254
+ * about each axis. In Rapier's own unit (N·m, not scaled by
255
+ * `pixelsPerMeter`), as on the 2D Rapier adapter.
256
+ * @param renderable - the body's renderable
257
+ * @param torque - the torque
258
+ */
259
+ applyTorque(renderable: Renderable, torque: number | Vector3d): void;
260
+ setStatic(renderable: Renderable, isStatic: boolean): void;
261
+ setGravityScale(renderable: Renderable, scale: number): void;
262
+ setSensor(renderable: Renderable, isSensor: boolean): void;
263
+ setFrictionAir(renderable: Renderable, friction: number | {
264
+ x: number;
265
+ y: number;
266
+ }): void;
267
+ /**
268
+ * Cap the body's speed on each axis, in pixels per second. A `z` caps
269
+ * the depth axis too; left out, that axis has no cap.
270
+ * @param renderable - the body's renderable
271
+ * @param limit - the cap
272
+ */
273
+ setMaxVelocity(renderable: Renderable, limit: Vector3Like): void;
274
+ getMaxVelocity(renderable: Renderable): {
275
+ x: number;
276
+ y: number;
277
+ z: number;
278
+ };
279
+ setCollisionType(renderable: Renderable, type: number): void;
280
+ setCollisionMask(renderable: Renderable, mask: number): void;
281
+ /**
282
+ * The body's XY bounds in renderable-local pixels, relative to `pos`: the
283
+ * footprint of its colliders as the body is turned now. Exact for a
284
+ * box, a sphere and a capsule; for a hull or a triangle mesh, that of its
285
+ * bounding box, turned.
286
+ * @param renderable - the renderable whose body bounds to read
287
+ * @param out - destination `Bounds` (filled in place, also returned)
288
+ */
289
+ getBodyAABB(renderable: Renderable, out: Bounds): Bounds | undefined;
290
+ /**
291
+ * The body's collision shapes, as given in its `bodyDef`, relative to
292
+ * `pos` and before the body turns (the turn is
293
+ * {@link Rapier3dAdapter.getRotation}). A shape with `isActive: false`
294
+ * is left out.
295
+ * @param renderable - the renderable whose body shapes to read
296
+ */
297
+ getBodyShapes(renderable: Renderable): readonly BodyShape[];
298
+ /**
299
+ * Whether Rapier has put the body to sleep: a dynamic body at rest, left
300
+ * out of the step until a contact or a write to it (a velocity, a force,
301
+ * an impulse, a position or a rotation, which all wake it) moves it
302
+ * again. `false` for a fixed or kinematic body, and for a renderable this
303
+ * adapter does not know, including every one once it is destroyed.
304
+ * @param renderable - the renderable whose body to read
305
+ * @returns `true` while the body sleeps
306
+ * @example
307
+ * // the shot is over once every block has come to rest
308
+ * const settled = blocks.every((b) => adapter.isSleeping(b));
309
+ */
310
+ isSleeping(renderable: Renderable): boolean;
311
+ isGrounded(renderable: Renderable): boolean;
312
+ /**
313
+ * The first collider a segment meets, from `from` to `to`, in world
314
+ * pixels: the exact shape, not a bounding volume. A shape the ray starts
315
+ * inside is skipped, so a body casting from its own centre does not hit
316
+ * itself. Sensors are hit like any other body.
317
+ * @param from - where the ray starts
318
+ * @param to - where it ends
319
+ * @returns the hit, or `null`
320
+ */
321
+ raycast3d(from: Vector3d, to: Vector3d): RaycastHit3d | null;
322
+ /**
323
+ * The renderables whose colliders' boxes overlap a rectangle in XY, at
324
+ * any depth: the boxes {@link Rapier3dAdapter.getBodyAABB} reports.
325
+ * @param rect - the rectangle, in world pixels
326
+ * @returns the renderables, each once
327
+ */
328
+ queryAABB(rect: Rect): Renderable[];
329
+ /**
330
+ * The renderables whose colliders overlap a sphere: their exact shapes.
331
+ * @param center - the centre in world pixels, or a {@link Sphere}
332
+ * @param [radius] - the radius in pixels, with a centre; none, or less
333
+ * than none, is a point
334
+ * @returns the renderables, each once
335
+ */
336
+ querySphere(center: Vector3d | Sphere, radius?: number): Renderable[];
337
+ /**
338
+ * The gravity in meters per second², for Rapier.
339
+ * @returns the gravity
340
+ */
341
+ private gravityInMeters;
342
+ /**
343
+ * Write a body's place and turn back onto its renderable.
344
+ * @param renderable - the renderable
345
+ * @param body - its body
346
+ */
347
+ private writePose;
348
+ /**
349
+ * Make a body's colliders, with the body definition's material and
350
+ * filter, a shape's own settings over them, and what was set on the
351
+ * whole body at run time over both.
352
+ * @param renderable - the body's renderable
353
+ * @param body - the body
354
+ * @param def - its definition
355
+ * @param parts - the colliders to make
356
+ * @param colliders - the body's list of colliders, added to
357
+ */
358
+ private createColliders;
359
+ /**
360
+ * Tell the pairs touching colliders that are about to go that their
361
+ * contact ended, then forget the colliders.
362
+ * @param colliders - the colliders leaving the world
363
+ */
364
+ private forgetColliders;
365
+ /**
366
+ * Change the collision type and/or mask of every collider of a body, and
367
+ * keep it for the colliders `updateShape()` makes.
368
+ * @param renderable - the body's renderable
369
+ * @param category - the new type, or undefined to keep each collider's
370
+ * @param mask - the new mask, or undefined to keep each collider's
371
+ */
372
+ private setFilter;
373
+ /**
374
+ * What the helpers spliced onto a body act through.
375
+ * @returns the context
376
+ */
377
+ private helperContext;
378
+ }
379
+ /**
380
+ * Namespace-merged with the {@link Rapier3dAdapter} class to expose
381
+ * adapter-owned types alongside the runtime API.
382
+ */
383
+ export declare namespace Rapier3dAdapter {
384
+ /**
385
+ * The body handle attached to `renderable.body` under
386
+ * {@link Rapier3dAdapter}: the Rapier `RigidBody` (with all its native
387
+ * methods: `enableCcd`, `linvel`, `mass`, `sleep`, …) and the portable
388
+ * melonJS helpers spliced onto it.
389
+ *
390
+ * ```ts
391
+ * (this.body as Rapier3dAdapter.Body).enableCcd(true);
392
+ * ```
393
+ */
394
+ type Body = RAPIER.RigidBody & PhysicsBody;
395
+ }
396
+ //# sourceMappingURL=Rapier3dAdapter.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"Rapier3dAdapter.d.ts","sourceRoot":"","sources":["../src/Rapier3dAdapter.ts"],"names":[],"mappings":"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"}
@@ -0,0 +1,35 @@
1
+ /**
2
+ * What every part of the adapter shares: the Rapier module, the units, the
3
+ * Rapier world, and which body and colliders each renderable has.
4
+ */
5
+ import type * as RAPIER from "@dimforge/rapier3d-compat";
6
+ import type { Renderable } from "melonjs";
7
+ import type { ColliderEntry } from "./colliders/types";
8
+ import type { Units } from "./math/units";
9
+ export declare class Simulation {
10
+ readonly rapier: typeof RAPIER;
11
+ readonly units: Units;
12
+ /** The Rapier world: made by {@link open}, freed by {@link close}. */
13
+ world: RAPIER.World;
14
+ /** true between {@link open} and {@link close}: the Rapier world exists */
15
+ alive: boolean;
16
+ /** each renderable's body */
17
+ readonly bodies: Map<Renderable, RAPIER.RigidBody>;
18
+ /** each renderable's colliders, one per active shape */
19
+ readonly collidersOf: Map<Renderable, RAPIER.Collider[]>;
20
+ /** collider handle -> its renderable, shape and box */
21
+ readonly colliders: Map<number, ColliderEntry>;
22
+ /**
23
+ * @param rapier - the loaded Rapier module
24
+ * @param units - the scale between pixels and meters
25
+ */
26
+ constructor(rapier: typeof RAPIER, units: Units);
27
+ /**
28
+ * Make the Rapier world.
29
+ * @param gravity - its gravity, in meters per second²
30
+ */
31
+ open(gravity: RAPIER.Vector): void;
32
+ /** Free the Rapier world, and forget every body and collider. */
33
+ close(): void;
34
+ }
35
+ //# sourceMappingURL=Simulation.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"Simulation.d.ts","sourceRoot":"","sources":["../src/Simulation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C,qBAAa,UAAU;IACtB,QAAQ,CAAC,MAAM,EAAE,OAAO,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,sEAAsE;IACtE,KAAK,EAAG,MAAM,CAAC,KAAK,CAAC;IACrB,2EAA2E;IAC3E,KAAK,UAAS;IAEd,6BAA6B;IAC7B,QAAQ,CAAC,MAAM,oCAA2C;IAC1D,wDAAwD;IACxD,QAAQ,CAAC,WAAW,qCAA4C;IAChE,uDAAuD;IACvD,QAAQ,CAAC,SAAS,6BAAoC;IAEtD;;;OAGG;gBACS,MAAM,EAAE,OAAO,MAAM,EAAE,KAAK,EAAE,KAAK;IAK/C;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM;IAK3B,iEAAiE;IACjE,KAAK;CASL"}
@@ -0,0 +1,64 @@
1
+ /**
2
+ * Moving bodies in pixels: velocities, forces and torques for the frame, and
3
+ * the speed caps (`maxVelocity`) Rapier has no notion of.
4
+ */
5
+ import type * as RAPIER from "@dimforge/rapier3d-compat";
6
+ import type { Renderable } from "melonjs";
7
+ import { type XYZ } from "../math/units";
8
+ import type { Simulation } from "../Simulation";
9
+ import type { Vector3Like } from "../types";
10
+ export declare class Motion {
11
+ /** each body's speed cap, per axis, in pixels per second */
12
+ readonly limits: Map<Renderable, Vector3Like>;
13
+ private readonly sim;
14
+ /** bodies with a force or torque to clear once the frame is stepped */
15
+ private readonly forced;
16
+ /**
17
+ * @param sim - the simulation whose bodies it moves
18
+ */
19
+ constructor(sim: Simulation);
20
+ /**
21
+ * Set a body's velocity in pixels per second; a `z` left out keeps the
22
+ * depth velocity.
23
+ * @param body - the body
24
+ * @param x - along X
25
+ * @param y - along Y
26
+ * @param [z] - along Z
27
+ */
28
+ setVelocity(body: RAPIER.RigidBody, x: number, y: number, z?: number): void;
29
+ /**
30
+ * Add a force for this frame, in pixels: at a world point, it also turns
31
+ * the body. A force or a point with no `z` acts in the plane of the body.
32
+ * @param body - the body
33
+ * @param force - the force
34
+ * @param [point] - where it pushes, in world pixels
35
+ */
36
+ addForce(body: RAPIER.RigidBody, force: Vector3Like, point?: Vector3Like): void;
37
+ /**
38
+ * Add a torque for this frame: a number about Z, a vector about each axis.
39
+ * In Rapier's own unit (N·m), not scaled.
40
+ * @param body - the body
41
+ * @param torque - the torque
42
+ */
43
+ addTorque(body: RAPIER.RigidBody, torque: number | Vector3Like): void;
44
+ /**
45
+ * A world point in meters; one with no depth is in the plane of the body.
46
+ * @param body - the body it acts on
47
+ * @param point - the point in world pixels
48
+ * @returns the point in meters
49
+ */
50
+ pointInMeters(body: RAPIER.RigidBody, point: Vector3Like): XYZ;
51
+ /** A force is for one frame, across every sub-step: clear them all. */
52
+ clearForces(): void;
53
+ /** Hold every capped body to its cap. */
54
+ clampVelocities(): void;
55
+ /**
56
+ * Forget a body that left the world.
57
+ * @param renderable - its renderable
58
+ * @param body - the body
59
+ */
60
+ forget(renderable: Renderable, body: RAPIER.RigidBody): void;
61
+ /** Forget every body. */
62
+ clear(): void;
63
+ }
64
+ //# sourceMappingURL=Motion.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"Motion.d.ts","sourceRoot":"","sources":["../../src/bodies/Motion.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,KAAK,GAAG,EAAO,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,qBAAa,MAAM;IAClB,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,+BAAsC;IACrD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAa;IACjC,uEAAuE;IACvE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;IAEtD;;OAEG;gBACS,GAAG,EAAE,UAAU;IAI3B;;;;;;;OAOG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAY3E;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,WAAW;IAUxE;;;;;OAKG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAUrE;;;;;OAKG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,EAAE,KAAK,EAAE,WAAW,GAAG,GAAG;IAU9D,uEAAuE;IACvE,WAAW,IAAI,IAAI;IAUnB,yCAAyC;IACzC,eAAe,IAAI,IAAI;IAsBvB;;;;OAIG;IACH,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,CAAC,SAAS,GAAG,IAAI;IAK5D,yBAAyB;IACzB,KAAK,IAAI,IAAI;CAIb"}
@@ -0,0 +1,16 @@
1
+ /**
2
+ * What was set on every collider of a body at run time (`setSensor`,
3
+ * `setCollisionType`, `setCollisionMask`, `setBounce`), so that the colliders
4
+ * `updateShape()` makes get it too.
5
+ */
6
+ import type { Renderable } from "melonjs";
7
+ import type { ColliderOverrides } from "../colliders/types";
8
+ export declare class RuntimeOverrides extends Map<Renderable, ColliderOverrides> {
9
+ /**
10
+ * A body's record, to write to.
11
+ * @param renderable - the body's renderable
12
+ * @returns its record, made when there is none
13
+ */
14
+ of(renderable: Renderable): ColliderOverrides;
15
+ }
16
+ //# sourceMappingURL=RuntimeOverrides.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"RuntimeOverrides.d.ts","sourceRoot":"","sources":["../../src/bodies/RuntimeOverrides.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D,qBAAa,gBAAiB,SAAQ,GAAG,CAAC,UAAU,EAAE,iBAAiB,CAAC;IACvE;;;;OAIG;IACH,EAAE,CAAC,UAAU,EAAE,UAAU,GAAG,iBAAiB;CAQ7C"}
@@ -0,0 +1,30 @@
1
+ /**
2
+ * The portable `PhysicsBody` helpers, spliced onto a Rapier body so that
3
+ * `renderable.body.setVelocity(x, y, z)` works as on every adapter. The body
4
+ * stays a real `RAPIER.RigidBody`, with all its own methods.
5
+ */
6
+ import type * as RAPIER from "@dimforge/rapier3d-compat";
7
+ import type { Renderable } from "melonjs";
8
+ import type { CollisionFilters } from "../colliders/CollisionFilters";
9
+ import type { Rapier3dAdapter } from "../Rapier3dAdapter";
10
+ import type { Simulation } from "../Simulation";
11
+ import type { Motion } from "./Motion";
12
+ import type { RuntimeOverrides } from "./RuntimeOverrides";
13
+ /** what the helpers act through */
14
+ export interface HelperContext {
15
+ adapter: Rapier3dAdapter;
16
+ sim: Simulation;
17
+ motion: Motion;
18
+ filters: CollisionFilters;
19
+ overrides: RuntimeOverrides;
20
+ }
21
+ /**
22
+ * Splice the helpers onto a body.
23
+ * @param ctx - what they act through
24
+ * @param renderable - the body's renderable
25
+ * @param body - the Rapier body
26
+ * @param colliders - its colliders: the live list, which `updateShape()`
27
+ * refills in place
28
+ */
29
+ export declare function spliceHelpers(ctx: HelperContext, renderable: Renderable, body: RAPIER.RigidBody, colliders: RAPIER.Collider[]): void;
30
+ //# sourceMappingURL=helpers.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/bodies/helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAe,UAAU,EAAsB,MAAM,SAAS,CAAC;AAC3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,mCAAmC;AACnC,MAAM,WAAW,aAAa;IAC7B,OAAO,EAAE,eAAe,CAAC;IACzB,GAAG,EAAE,UAAU,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,gBAAgB,CAAC;IAC1B,SAAS,EAAE,gBAAgB,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC5B,GAAG,EAAE,aAAa,EAClB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,CAAC,SAAS,EACtB,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,GAC1B,IAAI,CA6GN"}
@@ -0,0 +1,34 @@
1
+ /**
2
+ * Writing a body's place and turn back onto its renderable: its position to
3
+ * `pos` / `depth`, its turn onto `currentTransform`, from the transform the
4
+ * renderable had when the body was made.
5
+ */
6
+ import type * as RAPIER from "@dimforge/rapier3d-compat";
7
+ import { type Matrix3d, type Renderable } from "melonjs";
8
+ import type { Units } from "../math/units";
9
+ /**
10
+ * How a renderable draws its `currentTransform`, so the body's turn can be
11
+ * written onto it: `bridge` is the sign of each axis between the space the
12
+ * transform turns in and the engine's (a {@link Mesh} turns in its source's
13
+ * Y-up space), and `base` the transform it had when the body was made.
14
+ */
15
+ export interface Pose {
16
+ base: Matrix3d;
17
+ bridge: [number, number, number];
18
+ }
19
+ /**
20
+ * A renderable's pose as it stands, to turn from.
21
+ * @param renderable - the renderable a body is made for
22
+ * @returns its pose
23
+ */
24
+ export declare function poseOf(renderable: Renderable): Pose;
25
+ /**
26
+ * Write a body's position onto its renderable's `pos` / `depth` and, given a
27
+ * pose, its turn onto its `currentTransform`.
28
+ * @param renderable - the renderable
29
+ * @param body - its body
30
+ * @param pose - its pose, or undefined to write the position only
31
+ * @param units - the scale between pixels and meters
32
+ */
33
+ export declare function writePose(renderable: Renderable, body: RAPIER.RigidBody, pose: Pose | undefined, units: Units): void;
34
+ //# sourceMappingURL=pose.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"pose.d.ts","sourceRoot":"","sources":["../../src/bodies/pose.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,KAAK,QAAQ,EAAoB,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAC3E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,WAAW,IAAI;IACpB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAKD;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CASnD;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACxB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,CAAC,SAAS,EACtB,IAAI,EAAE,IAAI,GAAG,SAAS,EACtB,KAAK,EAAE,KAAK,GACV,IAAI,CA4BN"}