@threlte/rapier 3.0.0-next.2 → 3.0.0-next.20

package/dist/lib/applyColliderActiveEvents.d.ts

@@ -1,3 +1,3 @@
-import type { ColliderEvents, RigidBodyEvents } from '../types/types';
 import { type Collider } from '@dimforge/rapier3d-compat';
+import type { ColliderEvents, RigidBodyEvents } from '../types/types';
 export declare const applyColliderActiveEvents: (collider: Collider, colliderEvents?: ColliderEvents, rigidBodyEvents?: RigidBodyEvents) => void;

package/dist/lib/applyTransforms.d.ts

@@ -1,2 +1,2 @@
 import type { Euler, Object3D, Vector3 } from 'three';
-export declare const applyTransforms: (object: Object3D, position?: Parameters<Vector3['set']>, rotation?: Parameters<Euler['set']>, scale?: Parameters<Vector3['set']>) => void;
+export declare const applyTransforms: (object: Object3D, position?: Parameters<Vector3["set"]>, rotation?: Parameters<Euler["set"]>, scale?: Parameters<Vector3["set"]>) => void;

package/dist/lib/createCollidersFromChildren.d.ts

@@ -1,4 +1,4 @@
-import { Collider, World, RigidBody } from '@dimforge/rapier3d-compat';
+import { Collider, RigidBody, World } from '@dimforge/rapier3d-compat';
 import { type Object3D } from 'three';
 import type { AutoCollidersShapes } from '../types/types';
 /**

package/dist/lib/createCollidersFromChildren.js

@@ -1,4 +1,5 @@
 import { ActiveEvents, ColliderDesc } from '@dimforge/rapier3d-compat';
+import { isInstanceOf } from '@threlte/core';
 import { Quaternion, Vector3 } from 'three';
 const offset = new Vector3();
 const worldPosition = new Vector3();
@@ -33,7 +34,7 @@ export const createCollidersFromChildren = (object, collidersType, world, rigidB
     rigidBodyParentObject?.getWorldPosition(rigidBodyWorldPos);
     rigidBodyParentObject?.getWorldQuaternion(rigidBodyWorldQuatInversed).invert();
     object.traverse((child) => {
-        if ('isMesh' in child) {
+        if (isInstanceOf(child, 'Mesh')) {
             const { geometry } = child;
             const worldPos = child.getWorldPosition(worldPosition);
             const translation = worldPos.sub(rigidBodyWorldPos);
@@ -62,7 +63,14 @@ export const createCollidersFromChildren = (object, collidersType, world, rigidB
                     break;
                 case 'trimesh':
                     {
-                        description = ColliderDesc.trimesh(new Float32Array(geometry.attributes.position.array), new Uint32Array(geometry.index?.array ?? []));
+                        const scaleX = scale.x;
+                        const vertices = new Float32Array(geometry.attributes.position.array);
+                        if (scaleX !== 1) {
+                            for (let i = 0; i < vertices.length; i++) {
+                                vertices[i] *= scaleX;
+                            }
+                        }
+                        description = ColliderDesc.trimesh(vertices, new Uint32Array(geometry.index?.array ?? []));
                     }
                     break;
                 case 'capsule':
@@ -77,7 +85,14 @@ export const createCollidersFromChildren = (object, collidersType, world, rigidB
                     break;
                 case 'convexHull':
                     {
-                        description = ColliderDesc.convexHull(new Float32Array(geometry.attributes.position.array));
+                        const scaleX = scale.x;
+                        const vertices = new Float32Array(geometry.attributes.position.array);
+                        if (scaleX !== 1) {
+                            for (let i = 0; i < vertices.length; i++) {
+                                vertices[i] *= scaleX;
+                            }
+                        }
+                        description = ColliderDesc.convexHull(vertices);
                     }
                     break;
             }

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,21 +19,48 @@ 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 || !rigidBody.isValid())
                 return;
-            const events = ctx.rigidBodyEventDispatchers.get(handle);
+            const events = rigidBodyEventDispatchers.get(handle);
             if (events) {
                 if (rigidBody.isSleeping() && !mesh.userData.isSleeping) {
                     events.onsleep?.();
@@ -50,21 +73,35 @@ export const useFrameHandler = (ctx, stage) => {
             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());
@@ -73,7 +110,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);
             const rigidBody1 = collider1.parent();
             const rigidBody2 = collider2.parent();
             // Collider events
@@ -119,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;
             }
@@ -226,9 +263,41 @@ export const useFrameHandler = (ctx, stage) => {
                 });
             }
         });
-    }, { 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 { ColliderEvents, RigidBodyEvents } 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: Map<number, RigidBodyEvents>;
-    colliderEventDispatchers: Map<number, ColliderEvents>;
-    addColliderToContext: (collider: Collider, object: Object3D, props: ColliderEvents) => void;
-    removeColliderFromContext: (collider: Collider) => void;
-    addRigidBodyToContext: (rigidBody: RigidBody, object: Object3D, events: RigidBodyEvents) => 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: ConstructorParameters<typeof RAPIER.World>, 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();
@@ -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/eulerToQuaternion.d.ts

@@ -1,7 +1,7 @@
-import { Quaternion } from 'three';
+import { Euler, Quaternion } from 'three';
 /**
  * Sets the values of a temporary Euler and returns the quaternion from that
  * @param values
  * @returns
  */
-export declare const eulerToQuaternion: (values: [x: number, y: number, z: number, order?: import("three").EulerOrder | undefined]) => Quaternion;
+export declare const eulerToQuaternion: (values: Parameters<Euler["set"]>) => Quaternion;

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/useCreateEvent.d.ts

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

package/dist/lib/useCreateEvent.js

@@ -7,13 +7,11 @@ export const useCreateEvent = (oncreate) => {
         cleanupFunctions.forEach((cleanup) => cleanup());
         // clear the cleanup functions array
         cleanupFunctions.length = 0;
-        const cleanup = (callback) => {
-            // add cleanup function to array
-            cleanupFunctions.push(callback);
-        };
         if (ref === undefined)
             return;
-        oncreate?.({ ref, cleanup });
+        const cleanup = oncreate?.(ref);
+        if (cleanup)
+            cleanupFunctions.push(cleanup);
     };
     const updateRef = (newRef) => {
         ref = newRef;

package/dist/types/types.d.ts

@@ -1,14 +1,14 @@
-/// <reference types="svelte" />
-import type { Collider, RigidBody, TempContactManifold, Vector } from '@dimforge/rapier3d-compat';
-import type { Writable } from 'svelte/store';
-import type { createRapierContext } from '../lib/createRapierContext';
+import { World, type Collider, type RigidBody, type TempContactManifold, type Vector } from '@dimforge/rapier3d-compat';
+import RAPIER from '@dimforge/rapier3d-compat';
+import type { CurrentWritable, Stage, Task } from '@threlte/core';
+import type { Readable, Writable } from 'svelte/store';
+import type { Object3D } from 'three';
 export type ColliderShapes = 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh';
 export type AutoCollidersShapes = 'cuboid' | 'ball' | 'trimesh' | 'convexHull' | 'capsule';
+export type CreateEvent<T> = {
+    oncreate?: (ref: T) => void | (() => void);
+};
 export type ColliderEvents = {
-    oncreate?: (event: {
-        ref: Collider;
-        cleanup: (callback: () => void) => void;
-    }) => void;
     oncollisionenter?: (event: {
         targetCollider: Collider;
         targetRigidBody: RigidBody | null;
@@ -45,7 +45,6 @@ export type RigidBodyEvents = ColliderEvents & {
     onsleep?: () => void;
     onwake?: () => void;
 };
-export type RapierContext = ReturnType<typeof createRapierContext>;
 export type CollisionGroupsContext = Writable<number> | undefined;
 export type RigidBodyUserData = {
     events?: RigidBodyEvents;
@@ -59,3 +58,31 @@ export type CollisionGroupsBitMask = (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
  * Used in the <Attractor> component
  */
 export type GravityType = 'static' | 'linear' | 'newtonian';
+export type Framerate = number | 'varying';
+export type RapierContext = {
+    rapier: typeof RAPIER;
+    world: World;
+    colliderObjects: Map<number, Object3D>;
+    rigidBodyObjects: Map<number, Object3D>;
+    rigidBodyEventDispatchers: Map<number, RigidBodyEvents>;
+    colliderEventDispatchers: Map<number, ColliderEvents>;
+    addColliderToContext: (collider: Collider, object: Object3D, props: ColliderEvents) => void;
+    removeColliderFromContext: (collider: Collider) => void;
+    addRigidBodyToContext: (rigidBody: RigidBody, object: Object3D, events: RigidBodyEvents) => void;
+    removeRigidBodyFromContext: (rigidBody: RigidBody) => void;
+    debug: Writable<boolean>;
+    pause: () => void;
+    resume: () => void;
+    paused: Readable<boolean>;
+    framerate: CurrentWritable<Framerate>;
+    simulationStage: Stage;
+    simulationTask: Task;
+    synchronizationStage: Stage;
+    synchronizationTask: Task;
+    /**
+     * This number tells us how far we're off in the simulation stage as opposed
+     * to the render stage
+     */
+    simulationOffset: CurrentWritable<number>;
+    updateRigidBodySimulationData: CurrentWritable<boolean>;
+};