@threlte/rapier 3.0.0-next.1 → 3.0.0-next.10

package/dist/lib/applyColliderActiveEvents.js

@@ -1,17 +1,17 @@
 import { ActiveEvents } from '@dimforge/rapier3d-compat';
 export const applyColliderActiveEvents = (collider, colliderEvents = {}, rigidBodyEvents = {}) => {
     let events = 0;
-    if (colliderEvents.collisionenter ||
-        colliderEvents.collisionexit ||
-        rigidBodyEvents.collisionenter ||
-        rigidBodyEvents.collisionexit ||
-        colliderEvents.sensorenter ||
-        colliderEvents.sensorexit ||
-        rigidBodyEvents.sensorenter ||
-        rigidBodyEvents.sensorexit) {
+    if (colliderEvents.oncollisionenter ||
+        colliderEvents.oncollisionexit ||
+        rigidBodyEvents.oncollisionenter ||
+        rigidBodyEvents.oncollisionexit ||
+        colliderEvents.onsensorenter ||
+        colliderEvents.onsensorexit ||
+        rigidBodyEvents.onsensorenter ||
+        rigidBodyEvents.onsensorexit) {
         events = events | ActiveEvents.COLLISION_EVENTS;
     }
-    if (colliderEvents.contact || rigidBodyEvents.contact) {
+    if (colliderEvents.oncontact || rigidBodyEvents.oncontact) {
         events = events | ActiveEvents.CONTACT_FORCE_EVENTS;
     }
     if (events > 0) {

package/dist/lib/createPhysicsStages.d.ts

@@ -0,0 +1,15 @@
+import { type CurrentWritable, type Key, type Stage } from '@threlte/core';
+import type { Framerate } from '../types/types';
+export declare const createPhysicsStages: (framerate: CurrentWritable<Framerate>, simulationOffset: CurrentWritable<number>, updateRigidBodySimulationData: CurrentWritable<boolean>, options?: {
+    simulationStageOptions?: {
+        before?: (Key | Stage) | (Key | Stage)[];
+        after?: (Key | Stage) | (Key | Stage)[];
+    };
+    synchronizationStageOptions?: {
+        before?: (Key | Stage) | (Key | Stage)[];
+        after?: (Key | Stage) | (Key | Stage)[];
+    };
+}) => {
+    simulationStage: Stage;
+    synchronizationStage: Stage;
+};

package/dist/lib/createPhysicsStages.js

@@ -0,0 +1,43 @@
+import { useStage, useThrelte } from '@threlte/core';
+import { simulationKey, synchronizationKey } from './keys';
+export const createPhysicsStages = (framerate, simulationOffset, updateRigidBodySimulationData, options) => {
+    let fixedStepTimeAccumulator = 0;
+    let simulationTime = 0;
+    let lastSimulationTime = 0;
+    const { renderStage } = useThrelte();
+    const simulationStage = useStage(simulationKey, {
+        after: options?.simulationStageOptions?.after,
+        before: options?.simulationStageOptions?.before,
+        callback(delta, runTasks) {
+            if (framerate.current === 'varying') {
+                runTasks();
+            }
+            else {
+                const rate = 1 / framerate.current;
+                simulationTime += delta;
+                fixedStepTimeAccumulator += delta;
+                const iterations = Math.ceil(fixedStepTimeAccumulator / rate);
+                for (let iteration = 0; iteration < iterations; iteration++) {
+                    updateRigidBodySimulationData.set(iteration >= iterations - 2);
+                    runTasks(rate);
+                    fixedStepTimeAccumulator -= rate;
+                    lastSimulationTime += rate;
+                }
+                simulationOffset.set((simulationTime - lastSimulationTime) / rate + 1);
+            }
+        }
+    });
+    const synchronizationStage = useStage(synchronizationKey, {
+        after: options?.synchronizationStageOptions?.after
+            ? Array.isArray(options.synchronizationStageOptions.after)
+                ? [...options.synchronizationStageOptions.after, simulationKey]
+                : [options.synchronizationStageOptions.after, simulationKey]
+            : simulationKey,
+        before: options?.synchronizationStageOptions?.before
+            ? Array.isArray(options.synchronizationStageOptions.before)
+                ? [...options.synchronizationStageOptions.before, renderStage]
+                : [options.synchronizationStageOptions.before, renderStage]
+            : renderStage
+    });
+    return { simulationStage, synchronizationStage };
+};

package/dist/lib/createPhysicsTasks.d.ts

@@ -0,0 +1,19 @@
+import { type World } from '@dimforge/rapier3d-compat';
+import { type CurrentWritable, type Stage } from '@threlte/core';
+import { Object3D, Quaternion, Vector3 } from 'three';
+import type { ColliderEvents, Framerate, RigidBodyEvents } from '../types/types';
+type PhysicsUserData = {
+    currentPosition: Vector3;
+    currentQuaternion: Quaternion;
+    lastPosition: Vector3;
+    lastQuaternion: Quaternion;
+    resetPosition: boolean;
+    resetRotation: boolean;
+};
+export declare const initializeRigidBodyUserData: (obj: Object3D) => PhysicsUserData;
+export declare const setInitialRigidBodyState: (obj: Object3D, initialPosition: Vector3, initialQuaternion: Quaternion) => void;
+export declare const createPhysicsTasks: (world: World, framerate: CurrentWritable<Framerate>, simulationOffset: CurrentWritable<number>, rigidBodyObjects: Map<number, Object3D>, updateRigidBodySimulationData: CurrentWritable<boolean>, colliderEventDispatchers: Map<number, ColliderEvents>, rigidBodyEventDispatchers: Map<number, RigidBodyEvents>, simulationStage: Stage, synchronizationStage: Stage) => {
+    simulationTask: import("@threlte/core").Task;
+    synchronizationTask: import("@threlte/core").Task;
+};
+export {};

package/dist/{hooks/useFrameHandler.js → lib/createPhysicsTasks.js}

@@ -1,21 +1,17 @@
 import { EventQueue } from '@dimforge/rapier3d-compat';
 import { useTask } from '@threlte/core';
-import { derived } from 'svelte/store';
 import { Object3D, Quaternion, Vector3 } from 'three';
+import { simulationKey, synchronizationKey } from './keys';
 const tempObject = new Object3D();
 const tempVector3 = new Vector3();
 const tempQuaternion = new Quaternion();
-const getEventDispatchers = (ctx, collider1, collider2) => {
-    const collider1Events = ctx.colliderEventDispatchers.get(collider1.handle);
-    const collider2Events = ctx.colliderEventDispatchers.get(collider2.handle);
+const getEventDispatchers = (collider1, collider2, colliderEventDispatchers, rigidBodyEventDispatchers) => {
+    const collider1Events = colliderEventDispatchers.get(collider1.handle);
+    const collider2Events = colliderEventDispatchers.get(collider2.handle);
     const rigidBody1 = collider1.parent();
     const rigidBody2 = collider2.parent();
-    const rigidBody1Events = rigidBody1
-        ? ctx.rigidBodyEventDispatchers.get(rigidBody1.handle)
-        : undefined;
-    const rigidBody2Events = rigidBody2
-        ? ctx.rigidBodyEventDispatchers.get(rigidBody2.handle)
-        : undefined;
+    const rigidBody1Events = rigidBody1 ? rigidBodyEventDispatchers.get(rigidBody1.handle) : undefined;
+    const rigidBody2Events = rigidBody2 ? rigidBodyEventDispatchers.get(rigidBody2.handle) : undefined;
     return {
         collider1Events,
         collider2Events,
@@ -23,50 +19,89 @@ const getEventDispatchers = (ctx, collider1, collider2) => {
         rigidBody2Events
     };
 };
-export const useFrameHandler = (ctx, stage) => {
+const objectHasPhysicsUserData = (obj) => {
+    return obj.userData.physics !== undefined;
+};
+export const initializeRigidBodyUserData = (obj) => {
+    const userData = {
+        currentPosition: new Vector3(),
+        currentQuaternion: new Quaternion(),
+        lastPosition: new Vector3(),
+        lastQuaternion: new Quaternion(),
+        resetPosition: false,
+        resetRotation: false
+    };
+    obj.userData.physics = userData;
+    return userData;
+};
+export const setInitialRigidBodyState = (obj, initialPosition, initialQuaternion) => {
+    if (!objectHasPhysicsUserData(obj)) {
+        initializeRigidBodyUserData(obj);
+    }
+    const userData = obj.userData.physics;
+    userData.currentPosition.copy(initialPosition);
+    userData.lastPosition.copy(initialPosition);
+    userData.currentQuaternion.copy(initialQuaternion);
+    userData.lastQuaternion.copy(initialQuaternion);
+};
+export const createPhysicsTasks = (world, framerate, simulationOffset, rigidBodyObjects, updateRigidBodySimulationData, colliderEventDispatchers, rigidBodyEventDispatchers, simulationStage, synchronizationStage) => {
     const eventQueue = new EventQueue(false);
-    const { start, started, stop } = useTask((delta) => {
-        // if (!eventQueue) return
-        const { world } = ctx;
+    const simulation = useTask(simulationKey, (delta) => {
         // Set timestep to current delta, to allow for variable frame rates
         // We cap the delta at 100, so that the physics simulation doesn't get wild
-        world.timestep = Math.min(0.1, delta);
+        if (framerate.current === 'varying') {
+            world.timestep = Math.min(delta, 0.1);
+        }
+        else {
+            world.timestep = delta;
+        }
         world.step(eventQueue);
-        // Update meshes
-        ctx.rigidBodyObjects.forEach((mesh, handle) => {
+        rigidBodyObjects.forEach((mesh, handle) => {
             const rigidBody = world.getRigidBody(handle);
-            if (!rigidBody)
-                return;
-            const events = ctx.rigidBodyEventDispatchers.get(handle);
             if (!rigidBody || !rigidBody.isValid())
                 return;
+            const events = rigidBodyEventDispatchers.get(handle);
             if (events) {
                 if (rigidBody.isSleeping() && !mesh.userData.isSleeping) {
-                    events.sleep?.();
+                    events.onsleep?.();
                 }
                 if (!rigidBody.isSleeping() && mesh.userData.isSleeping) {
-                    events.wake?.();
+                    events.onwake?.();
                 }
                 mesh.userData.isSleeping = rigidBody.isSleeping();
             }
-            if (!rigidBody || rigidBody.isSleeping() || rigidBody.isFixed() || !mesh.parent) {
+            if (rigidBody.isSleeping() || rigidBody.isFixed() || !mesh.parent) {
                 return;
             }
-            // Position
-            const { x, y, z } = rigidBody.translation();
-            tempObject.position.set(x, y, z);
-            // Rotation
-            const rotation = rigidBody.rotation();
-            tempQuaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
-            tempObject.rotation.setFromQuaternion(tempQuaternion);
-            // Scale
-            mesh.getWorldScale(tempVector3);
-            tempObject.scale.copy(tempVector3);
-            tempObject.updateMatrix();
-            tempObject.applyMatrix4(mesh.parent.matrixWorld.clone().invert());
-            tempObject.updateMatrix();
-            mesh.position.setFromMatrixPosition(tempObject.matrix);
-            mesh.rotation.setFromRotationMatrix(tempObject.matrix);
+            if (updateRigidBodySimulationData.current) {
+                const translation = rigidBody.translation();
+                const rotation = rigidBody.rotation();
+                if (objectHasPhysicsUserData(mesh)) {
+                    const userData = mesh.userData.physics;
+                    if (userData.resetPosition) {
+                        userData.resetPosition = false;
+                        userData.lastPosition.set(translation.x, translation.y, translation.z);
+                        userData.currentPosition.set(translation.x, translation.y, translation.z);
+                    }
+                    else {
+                        userData.lastPosition.copy(userData.currentPosition);
+                        userData.currentPosition.set(translation.x, translation.y, translation.z);
+                    }
+                    if (userData.resetRotation) {
+                        userData.resetRotation = false;
+                        userData.lastQuaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
+                        userData.currentQuaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
+                    }
+                    else {
+                        userData.lastQuaternion.copy(userData.currentQuaternion);
+                        userData.currentQuaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
+                    }
+                }
+                else {
+                    initializeRigidBodyUserData(mesh);
+                    setInitialRigidBodyState(mesh, tempVector3.set(translation.x, translation.y, translation.z), tempQuaternion.set(rotation.x, rotation.y, rotation.z, rotation.w));
+                }
+            }
         });
         eventQueue.drainContactForceEvents((e) => {
             const collider1 = world.getCollider(e.collider1());
@@ -75,11 +110,11 @@ export const useFrameHandler = (ctx, stage) => {
             if (!collider1 || !collider2) {
                 return;
             }
-            const { collider1Events, collider2Events, rigidBody1Events, rigidBody2Events } = getEventDispatchers(ctx, collider1, collider2);
+            const { collider1Events, collider2Events, rigidBody1Events, rigidBody2Events } = getEventDispatchers(collider1, collider2, colliderEventDispatchers, rigidBodyEventDispatchers);
             const rigidBody1 = collider1.parent();
             const rigidBody2 = collider2.parent();
             // Collider events
-            collider1Events?.contact?.({
+            collider1Events?.oncontact?.({
                 targetCollider: collider2,
                 targetRigidBody: rigidBody2,
                 maxForceDirection: e.maxForceDirection(),
@@ -87,7 +122,7 @@ export const useFrameHandler = (ctx, stage) => {
                 totalForce: e.totalForce(),
                 totalForceMagnitude: e.totalForceMagnitude()
             });
-            collider2Events?.contact?.({
+            collider2Events?.oncontact?.({
                 targetCollider: collider1,
                 targetRigidBody: rigidBody1,
                 maxForceDirection: e.maxForceDirection(),
@@ -96,7 +131,7 @@ export const useFrameHandler = (ctx, stage) => {
                 totalForceMagnitude: e.totalForceMagnitude()
             });
             // RigidBody Events
-            rigidBody1Events?.contact?.({
+            rigidBody1Events?.oncontact?.({
                 targetCollider: collider2,
                 targetRigidBody: rigidBody2,
                 maxForceDirection: e.maxForceDirection(),
@@ -104,7 +139,7 @@ export const useFrameHandler = (ctx, stage) => {
                 totalForce: e.totalForce(),
                 totalForceMagnitude: e.totalForceMagnitude()
             });
-            rigidBody2Events?.contact?.({
+            rigidBody2Events?.oncontact?.({
                 targetCollider: collider1,
                 targetRigidBody: rigidBody1,
                 maxForceDirection: e.maxForceDirection(),
@@ -121,7 +156,7 @@ export const useFrameHandler = (ctx, stage) => {
             if (!collider1 || !collider2) {
                 return;
             }
-            const { collider1Events, collider2Events, rigidBody1Events, rigidBody2Events } = getEventDispatchers(ctx, collider1, collider2);
+            const { collider1Events, collider2Events, rigidBody1Events, rigidBody2Events } = getEventDispatchers(collider1, collider2, colliderEventDispatchers, rigidBodyEventDispatchers);
             if (!collider1Events && !collider2Events && !rigidBody1Events && !rigidBody2Events) {
                 return;
             }
@@ -132,20 +167,20 @@ export const useFrameHandler = (ctx, stage) => {
                 const isIntersection = world.intersectionPair(collider1, collider2);
                 if (isIntersection) {
                     // Collider Events
-                    collider1Events?.sensorenter?.({
+                    collider1Events?.onsensorenter?.({
                         targetCollider: collider2,
                         targetRigidBody: rigidBody2
                     });
-                    collider2Events?.sensorenter?.({
+                    collider2Events?.onsensorenter?.({
                         targetCollider: collider1,
                         targetRigidBody: rigidBody1
                     });
                     // RigidBody Events
-                    rigidBody1Events?.sensorenter?.({
+                    rigidBody1Events?.onsensorenter?.({
                         targetCollider: collider2,
                         targetRigidBody: rigidBody2
                     });
-                    rigidBody2Events?.sensorenter?.({
+                    rigidBody2Events?.onsensorenter?.({
                         targetCollider: collider1,
                         targetRigidBody: rigidBody1
                     });
@@ -154,26 +189,26 @@ export const useFrameHandler = (ctx, stage) => {
                 }
                 world.contactPair(collider1, collider2, (manifold, flipped) => {
                     // Collider events
-                    collider1Events?.collisionenter?.({
+                    collider1Events?.oncollisionenter?.({
                         flipped,
                         manifold,
                         targetCollider: collider2,
                         targetRigidBody: rigidBody2
                     });
-                    collider2Events?.collisionenter?.({
+                    collider2Events?.oncollisionenter?.({
                         flipped,
                         manifold,
                         targetCollider: collider1,
                         targetRigidBody: rigidBody1
                     });
                     // RigidBody Events
-                    rigidBody1Events?.collisionenter?.({
+                    rigidBody1Events?.oncollisionenter?.({
                         flipped,
                         manifold,
                         targetCollider: collider2,
                         targetRigidBody: rigidBody2
                     });
-                    rigidBody2Events?.collisionenter?.({
+                    rigidBody2Events?.oncollisionenter?.({
                         flipped,
                         manifold,
                         targetCollider: collider1,
@@ -188,20 +223,20 @@ export const useFrameHandler = (ctx, stage) => {
                     collider1.isSensor() ||
                     collider2.isSensor();
                 if (isIntersection) {
-                    collider1Events?.sensorexit?.({
+                    collider1Events?.onsensorexit?.({
                         targetCollider: collider2,
                         targetRigidBody: rigidBody2
                     });
-                    collider2Events?.sensorexit?.({
+                    collider2Events?.onsensorexit?.({
                         targetCollider: collider1,
                         targetRigidBody: rigidBody1
                     });
                     // RigidBody Events
-                    rigidBody1Events?.sensorexit?.({
+                    rigidBody1Events?.onsensorexit?.({
                         targetCollider: collider2,
                         targetRigidBody: rigidBody2
                     });
-                    rigidBody2Events?.sensorexit?.({
+                    rigidBody2Events?.onsensorexit?.({
                         targetCollider: collider1,
                         targetRigidBody: rigidBody1
                     });
@@ -209,28 +244,60 @@ export const useFrameHandler = (ctx, stage) => {
                     return;
                 }
                 // Collider events
-                collider1Events?.collisionexit?.({
+                collider1Events?.oncollisionexit?.({
                     targetCollider: collider2,
                     targetRigidBody: rigidBody2
                 });
-                collider2Events?.collisionexit?.({
+                collider2Events?.oncollisionexit?.({
                     targetCollider: collider1,
                     targetRigidBody: rigidBody1
                 });
                 // RigidBody Events
-                rigidBody1Events?.collisionexit?.({
+                rigidBody1Events?.oncollisionexit?.({
                     targetCollider: collider2,
                     targetRigidBody: rigidBody2
                 });
-                rigidBody2Events?.collisionexit?.({
+                rigidBody2Events?.oncollisionexit?.({
                     targetCollider: collider1,
                     targetRigidBody: rigidBody1
                 });
             }
         });
-    }, { stage });
-    // replacing the original pause and resume functions as well as the paused property
-    ctx.pause = () => stop();
-    ctx.resume = () => start();
-    ctx.paused = derived(started, (started) => !started);
+    }, {
+        stage: simulationStage
+    });
+    const synchronization = useTask(synchronizationKey, () => {
+        rigidBodyObjects.forEach((mesh) => {
+            if (!objectHasPhysicsUserData(mesh))
+                return;
+            const userData = mesh.userData.physics;
+            if (framerate.current === 'varying') {
+                tempObject.position.copy(userData.currentPosition);
+                tempObject.quaternion.copy(userData.currentQuaternion);
+            }
+            else {
+                tempObject.position
+                    .copy(userData.lastPosition)
+                    .lerp(userData.currentPosition, simulationOffset.current);
+                tempObject.quaternion
+                    .copy(userData.lastQuaternion)
+                    .slerp(userData.currentQuaternion, simulationOffset.current);
+            }
+            // Rapier has no concept of scale, so we use the mesh's scale
+            mesh.getWorldScale(tempVector3);
+            tempObject.scale.copy(tempVector3);
+            tempObject.updateMatrix();
+            if (mesh.parent)
+                tempObject.applyMatrix4(mesh.parent.matrixWorld.clone().invert());
+            tempObject.updateMatrix();
+            mesh.position.setFromMatrixPosition(tempObject.matrix);
+            mesh.rotation.setFromRotationMatrix(tempObject.matrix);
+        });
+    }, {
+        stage: synchronizationStage
+    });
+    return {
+        simulationTask: simulation.task,
+        synchronizationTask: synchronization.task
+    };
 };

package/dist/lib/createRapierContext.d.ts

@@ -1,21 +1,15 @@
-/// <reference types="svelte" />
-import type { Collider, RigidBody } from '@dimforge/rapier3d-compat';
 import RAPIER from '@dimforge/rapier3d-compat';
-import type { Object3D } from 'three';
-import type { ColliderEventDispatchers, RigidBodyEventDispatchers } from '../types/types';
-export declare const createRapierContext: (gravity: RAPIER.Vector, rawIntegrationParameters?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawIntegrationParameters | undefined, rawIslands?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawIslandManager | undefined, rawBroadPhase?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawBroadPhase | undefined, rawNarrowPhase?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawNarrowPhase | undefined, rawBodies?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawRigidBodySet | undefined, rawColliders?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawColliderSet | undefined, rawImpulseJoints?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawImpulseJointSet | undefined, rawMultibodyJoints?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawMultibodyJointSet | undefined, rawCCDSolver?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawCCDSolver | undefined, rawQueryPipeline?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawQueryPipeline | undefined, rawPhysicsPipeline?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawPhysicsPipeline | undefined, rawSerializationPipeline?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawSerializationPipeline | undefined, rawDebugRenderPipeline?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawDebugRenderPipeline | undefined) => {
-    rapier: typeof RAPIER;
-    world: RAPIER.World;
-    colliderObjects: Map<number, Object3D<import("three").Object3DEventMap>>;
-    rigidBodyObjects: Map<number, Object3D<import("three").Object3DEventMap>>;
-    rigidBodyEventDispatchers: RigidBodyEventDispatchers;
-    colliderEventDispatchers: ColliderEventDispatchers;
-    addColliderToContext: (collider: Collider, object: Object3D, events: Record<string, (arg: unknown) => void>) => void;
-    removeColliderFromContext: (collider: Collider) => void;
-    addRigidBodyToContext: (rigidBody: RigidBody, object: Object3D, events: Record<string, (arg: unknown) => void>) => void;
-    removeRigidBodyFromContext: (rigidBody: RigidBody) => void;
-    debug: import("svelte/store").Writable<boolean>;
-    pause: () => void;
-    resume: () => void;
-    paused: import("svelte/store").Readable<boolean>;
-};
+import { type Key, type Stage } from '@threlte/core';
+import type { Framerate, RapierContext } from '../types/types';
+export declare const createRapierContext: (worldArgs: [gravity: RAPIER.Vector, rawIntegrationParameters?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawIntegrationParameters | undefined, rawIslands?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawIslandManager | undefined, rawBroadPhase?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawBroadPhase | undefined, rawNarrowPhase?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawNarrowPhase | undefined, rawBodies?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawRigidBodySet | undefined, rawColliders?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawColliderSet | undefined, rawImpulseJoints?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawImpulseJointSet | undefined, rawMultibodyJoints?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawMultibodyJointSet | undefined, rawCCDSolver?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawCCDSolver | undefined, rawQueryPipeline?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawQueryPipeline | undefined, rawPhysicsPipeline?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawPhysicsPipeline | undefined, rawSerializationPipeline?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawSerializationPipeline | undefined, rawDebugRenderPipeline?: import("@dimforge/rapier3d-compat/rapier_wasm3d").RawDebugRenderPipeline | undefined], options: {
+    framerate?: Framerate;
+    autoStart?: boolean;
+    simulationStageOptions?: {
+        before?: (Key | Stage) | (Key | Stage)[];
+        after?: (Key | Stage) | (Key | Stage)[];
+    };
+    synchronizationStageOptions?: {
+        before?: (Key | Stage) | (Key | Stage)[];
+        after?: (Key | Stage) | (Key | Stage)[];
+    };
+}) => RapierContext;

package/dist/lib/createRapierContext.js

@@ -1,7 +1,10 @@
 import RAPIER from '@dimforge/rapier3d-compat';
-import { readable, writable } from 'svelte/store';
-export const createRapierContext = (...args) => {
-    const world = new RAPIER.World(...args);
+import { currentWritable } from '@threlte/core';
+import { derived, writable } from 'svelte/store';
+import { createPhysicsStages } from './createPhysicsStages';
+import { createPhysicsTasks } from './createPhysicsTasks';
+export const createRapierContext = (worldArgs, options) => {
+    const world = new RAPIER.World(...worldArgs);
     const colliderObjects = new Map();
     const rigidBodyObjects = new Map();
     const rigidBodyEventDispatchers = new Map();
@@ -12,9 +15,9 @@ export const createRapierContext = (...args) => {
      * @param object
      * @param eventDispatcher
      */
-    const addColliderToContext = (collider, object, events) => {
+    const addColliderToContext = (collider, object, props) => {
         colliderObjects.set(collider.handle, object);
-        colliderEventDispatchers.set(collider.handle, events);
+        colliderEventDispatchers.set(collider.handle, props);
     };
     /**
      * Removes the collider from the context
@@ -42,11 +45,17 @@ export const createRapierContext = (...args) => {
         rigidBodyObjects.delete(rigidBody.handle);
         rigidBodyEventDispatchers.delete(rigidBody.handle);
     };
-    // Dummy functions, will be replaced by useFrameHandler fn
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    const pause = () => { };
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    const resume = () => { };
+    const framerate = currentWritable(options.framerate ?? 'varying');
+    const simulationOffset = currentWritable(1);
+    const updateRigidBodySimulationData = currentWritable(framerate.current === 'varying');
+    const { simulationStage, synchronizationStage } = createPhysicsStages(framerate, simulationOffset, updateRigidBodySimulationData, options);
+    const autostart = options.autoStart ?? true;
+    const paused = writable(!autostart);
+    if (!autostart) {
+        simulationStage.stop();
+        synchronizationStage.stop();
+    }
+    const { simulationTask, synchronizationTask } = createPhysicsTasks(world, framerate, simulationOffset, rigidBodyObjects, updateRigidBodySimulationData, colliderEventDispatchers, rigidBodyEventDispatchers, simulationStage, synchronizationStage);
     return {
         rapier: RAPIER,
         world,
@@ -59,8 +68,23 @@ export const createRapierContext = (...args) => {
         addRigidBodyToContext,
         removeRigidBodyFromContext,
         debug: writable(false),
-        pause,
-        resume,
-        paused: readable(false)
+        pause: () => {
+            paused.set(true);
+            simulationStage.stop();
+            synchronizationStage.stop();
+        },
+        resume: () => {
+            paused.set(false);
+            simulationStage.start();
+            synchronizationStage.start();
+        },
+        paused: derived(paused, (a) => a),
+        framerate,
+        simulationOffset,
+        simulationStage,
+        synchronizationStage,
+        updateRigidBodySimulationData,
+        simulationTask,
+        synchronizationTask
     };
 };

package/dist/lib/initRapier.svelte.d.ts

@@ -0,0 +1 @@
+export declare const initRapier: () => true | Promise<void>;

package/dist/lib/initRapier.svelte.js

@@ -0,0 +1,16 @@
+import RAPIER from '@dimforge/rapier3d-compat';
+let initialized = false;
+let promise;
+export const initRapier = () => {
+    if (initialized)
+        return true;
+    if (!promise) {
+        promise = new Promise((resolve) => {
+            RAPIER.init().then(() => {
+                initialized = true;
+                resolve();
+            });
+        });
+    }
+    return promise;
+};

package/dist/lib/keys.d.ts

@@ -0,0 +1,2 @@
+export declare const simulationKey: unique symbol;
+export declare const synchronizationKey: unique symbol;

package/dist/lib/keys.js

@@ -0,0 +1,2 @@
+export const simulationKey = Symbol('simulation');
+export const synchronizationKey = Symbol('synchronization');

package/dist/lib/rigidBodyObjectContext.d.ts

@@ -1,2 +1,3 @@
-export declare const useParentRigidbodyObject: () => THREE.Object3D | undefined;
-export declare const setParentRigidbodyObject: (object3d: THREE.Object3D) => void;
+import type { Object3D } from 'three';
+export declare const useParentRigidbodyObject: () => Object3D | undefined;
+export declare const setParentRigidbodyObject: (object3d: Object3D) => void;

package/dist/lib/useCreateEvent.d.ts

@@ -1,3 +1,4 @@
-export declare const useCreateEvent: <T>(events: Record<string, (arg: unknown) => void>) => {
+import type { ColliderEvents } from '../types/types';
+export declare const useCreateEvent: <T>(oncreate?: ColliderEvents['oncreate']) => {
     updateRef: (newRef: T) => void;
 };

package/dist/lib/useCreateEvent.js

@@ -1,7 +1,7 @@
 import { onDestroy } from 'svelte';
-export const useCreateEvent = (events) => {
+export const useCreateEvent = (oncreate) => {
     const cleanupFunctions = [];
-    let ref = undefined;
+    let ref;
     const dispatchCreateEvent = () => {
         // call every cleanup function
         cleanupFunctions.forEach((cleanup) => cleanup());
@@ -13,7 +13,7 @@ export const useCreateEvent = (events) => {
         };
         if (ref === undefined)
             return;
-        events?.create?.({ ref, cleanup });
+        oncreate?.({ ref, cleanup });
     };
     const updateRef = (newRef) => {
         ref = newRef;