@threlte/rapier 3.0.0-next.9 → 3.0.0

package/dist/components/RigidBody/types.d.ts

@@ -0,0 +1,85 @@
+import { RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat';
+import { type Snippet } from 'svelte';
+import type { Euler, Vector3 } from 'three';
+import type { RigidBodyTypeString } from '../../lib/parseRigidBodyType';
+import type { CreateEvent, RigidBodyEvents } from '../../types/types';
+export type Boolean3Array = [x: boolean, y: boolean, z: boolean];
+export type RigidBodyProps = CreateEvent<RapierRigidBody> & RigidBodyEvents & {
+    rigidBody?: RapierRigidBody | undefined;
+    /**
+     * Specify the type of this rigid body
+     */
+    type?: RigidBodyTypeString;
+    /** Whether or not this body can sleep.
+     * default: true
+     */
+    canSleep?: boolean;
+    /** The linear velocity of this body.
+     * default: zero velocity
+     */
+    linearVelocity?: Parameters<Vector3['set']>;
+    /** The angular velocity of this body.
+     * Default: zero velocity.
+     */
+    angularVelocity?: Parameters<Euler['set']>;
+    /**
+     * The scaling factor applied to the gravity affecting the rigid-body.
+     * Default: 1.0
+     */
+    gravityScale?: number;
+    /**
+     * Whether or not Continous Collision Detection is enabled for this rigid-body.
+     * https://rapier.rs/docs/user_guides/javascript/rigid_bodies#continuous-collision-detection
+     * @default false
+     */
+    ccd?: boolean;
+    /**
+     * Locks all rotations that would have resulted from forces on the created rigid-body.
+     */
+    lockRotations?: boolean;
+    /**
+     * Locks all translations that would have resulted from forces on the created rigid-body.
+     */
+    lockTranslations?: boolean;
+    /**
+     * Allow rotation of this rigid-body only along specific axes.
+     */
+    enabledRotations?: Boolean3Array;
+    /**
+     * Allow translations of this rigid-body only along specific axes.
+     */
+    enabledTranslations?: Boolean3Array;
+    /**
+     * Dominance is a non-realistic, but sometimes useful, feature.
+     * It can be used to make one rigid-body immune to forces
+     * originating from contacts with some other bodies.
+     *
+     * Number in the range -127 to 127, default is 0
+     */
+    dominance?: number;
+    /**
+     * Damping lets you slow down a rigid-body automatically. This can be used to
+     * achieve a wide variety of effects like fake air friction. Larger values of
+     * damping coefficients lead to a stronger slow-downs. Their default
+     * values are 0.0 (no damping at all).
+     */
+    linearDamping?: number;
+    /**
+     * Damping lets you slow down a rigid-body automatically. This can be used to
+     * achieve a wide variety of effects like fake air friction. Larger values of
+     * damping coefficients lead to a stronger slow-downs. Their default
+     * values are 0.0 (no damping at all).
+     */
+    angularDamping?: number;
+    /**
+     * Set the rigidBody as enabled or disabled.
+     */
+    enabled?: boolean;
+    /**
+     * An arbitrary user-defined object associated with this rigid-body.
+     */
+    userData?: Record<string, any>;
+    children?: Snippet<[{
+        rigidBody: RapierRigidBody;
+    }]>;
+};

package/dist/components/RigidBody/types.js

@@ -0,0 +1,2 @@
+import { RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat';
+import {} from 'svelte';

package/dist/components/World/InnerWorld.svelte.d.ts

@@ -1,15 +1,3 @@
-import { SvelteComponent } from "svelte";
-import type { WorldProps } from './World.svelte';
-declare const __propDef: {
-    props: WorldProps;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type InnerWorldProps = typeof __propDef.props;
-export type InnerWorldEvents = typeof __propDef.events;
-export type InnerWorldSlots = typeof __propDef.slots;
-export default class InnerWorld extends SvelteComponent<InnerWorldProps, InnerWorldEvents, InnerWorldSlots> {
-}
-export {};
+import type { WorldProps } from './types';
+declare const InnerWorld: import("svelte").Component<WorldProps, {}, "">;
+export default InnerWorld;

package/dist/components/World/World.svelte.d.ts

@@ -1,49 +1,3 @@
-import type {
-  RawBroadPhase,
-  RawCCDSolver,
-  RawColliderSet,
-  RawDebugRenderPipeline,
-  RawImpulseJointSet,
-  RawIntegrationParameters,
-  RawIslandManager,
-  RawMultibodyJointSet,
-  RawNarrowPhase,
-  RawPhysicsPipeline,
-  RawQueryPipeline,
-  RawRigidBodySet,
-  RawSerializationPipeline
-} from '@dimforge/rapier3d-compat/raw'
-import { SvelteComponent, type Snippet } from 'svelte'
-import type { Vector3 } from 'three'
-import type { Key, Stage } from '@threlte/core'
-
-export type WorldProps = {
-  framerate?: number | 'varying'
-  autoStart?: boolean
-  gravity?: Parameters<Vector3['set']>
-  rawIntegrationParameters?: RawIntegrationParameters
-  rawIslands?: RawIslandManager
-  rawBroadPhase?: RawBroadPhase
-  rawNarrowPhase?: RawNarrowPhase
-  rawBodies?: RawRigidBodySet
-  rawColliders?: RawColliderSet
-  rawImpulseJoints?: RawImpulseJointSet
-  rawMultibodyJoints?: RawMultibodyJointSet
-  rawCCDSolver?: RawCCDSolver
-  rawQueryPipeline?: RawQueryPipeline
-  rawPhysicsPipeline?: RawPhysicsPipeline
-  rawSerializationPipeline?: RawSerializationPipeline
-  rawDebugRenderPipeline?: RawDebugRenderPipeline
-  simulationStageOptions?: {
-    before?: (Key | Stage) | (Key | Stage)[]
-    after?: (Key | Stage) | (Key | Stage)[]
-  }
-  synchronizationStageOptions?: {
-    before?: (Key | Stage) | (Key | Stage)[]
-    after?: (Key | Stage) | (Key | Stage)[]
-  }
-  children?: Snippet
-  fallback?: Snippet<[error: any]>
-}
-
-export default class World extends SvelteComponent<WorldProps> {}
+import type { WorldProps } from './types';
+declare const World: import("svelte").Component<WorldProps, {}, "">;
+export default World;

package/dist/components/World/types.d.ts

@@ -0,0 +1,32 @@
+import type { RawBroadPhase, RawCCDSolver, RawColliderSet, RawDebugRenderPipeline, RawImpulseJointSet, RawIntegrationParameters, RawIslandManager, RawMultibodyJointSet, RawNarrowPhase, RawPhysicsPipeline, RawQueryPipeline, RawRigidBodySet, RawSerializationPipeline } from '@dimforge/rapier3d-compat/raw';
+import type { Key, Stage } from '@threlte/core';
+import { type Snippet } from 'svelte';
+import type { Vector3 } from 'three';
+export type WorldProps = {
+    framerate?: number | 'varying';
+    autoStart?: boolean;
+    gravity?: Parameters<Vector3['set']>;
+    rawIntegrationParameters?: RawIntegrationParameters;
+    rawIslands?: RawIslandManager;
+    rawBroadPhase?: RawBroadPhase;
+    rawNarrowPhase?: RawNarrowPhase;
+    rawBodies?: RawRigidBodySet;
+    rawColliders?: RawColliderSet;
+    rawImpulseJoints?: RawImpulseJointSet;
+    rawMultibodyJoints?: RawMultibodyJointSet;
+    rawCCDSolver?: RawCCDSolver;
+    rawQueryPipeline?: RawQueryPipeline;
+    rawPhysicsPipeline?: RawPhysicsPipeline;
+    rawSerializationPipeline?: RawSerializationPipeline;
+    rawDebugRenderPipeline?: RawDebugRenderPipeline;
+    simulationStageOptions?: {
+        before?: (Key | Stage) | (Key | Stage)[];
+        after?: (Key | Stage) | (Key | Stage)[];
+    };
+    synchronizationStageOptions?: {
+        before?: (Key | Stage) | (Key | Stage)[];
+        after?: (Key | Stage) | (Key | Stage)[];
+    };
+    children?: Snippet;
+    fallback?: Snippet<[error: any]>;
+};

package/dist/components/World/types.js

@@ -0,0 +1 @@
+import {} from 'svelte';

package/dist/hooks/useFixedJoint.d.ts

@@ -0,0 +1,7 @@
+import type { FixedImpulseJoint } from '@dimforge/rapier3d-compat';
+import { Euler, Vector3 } from 'three';
+export declare const useFixedJoint: (anchorA: Parameters<Vector3["set"]>, frameA: Parameters<Euler["set"]> | Euler, anchorB: Parameters<Vector3["set"]>, frameB: Parameters<Euler["set"]> | Euler) => {
+    joint: import("svelte/store").Writable<FixedImpulseJoint>;
+    rigidBodyA: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+    rigidBodyB: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+};

package/dist/hooks/useJoint.d.ts

@@ -0,0 +1,7 @@
+import { MultibodyJoint, type ImpulseJoint, type RigidBody } from '@dimforge/rapier3d-compat';
+import type { RapierContext } from '../types/types';
+export declare const useJoint: <T extends ImpulseJoint | MultibodyJoint>(initializeJoint: (rigidBodyA: RigidBody, rigidBodyB: RigidBody, ctx: RapierContext) => T) => {
+    joint: import("svelte/store").Writable<T>;
+    rigidBodyA: import("svelte/store").Writable<RigidBody | undefined>;
+    rigidBodyB: import("svelte/store").Writable<RigidBody | undefined>;
+};

package/dist/hooks/usePhysicsTask.d.ts

@@ -0,0 +1,16 @@
+import { type Key, type ThrelteUseTask, type ThrelteUseTaskOptions } from '@threlte/core';
+/**
+ * Adds a handler to the physics simulation. The handler is always executed as
+ * part of the simulation stage and before the simulation task.
+ *
+ * `start` and `stop` functions are returned and the options allow setting the
+ * handler to not start automatically.
+ *
+ * Use the options `after` and `before` to control the order of execution.
+ *
+ * @param {(delta: number) => void} fn callback function
+ * @param {ThrelteUseTaskOptions} options options
+ * @returns {ThrelteUseTask}
+ */
+export declare function usePhysicsTask(fn: (delta: number) => void, options?: ThrelteUseTaskOptions): ThrelteUseTask;
+export declare function usePhysicsTask(key: Key, fn: (delta: number) => void, options?: ThrelteUseTaskOptions): ThrelteUseTask;

package/dist/hooks/usePhysicsTask.js

@@ -0,0 +1,32 @@
+import { useTask } from '@threlte/core';
+import { useRapier } from './useRapier';
+const isKey = (value) => {
+    return typeof value === 'string' || typeof value === 'symbol';
+};
+export function usePhysicsTask(keyOrFn, fnOrOptions, options) {
+    const { simulationTask, simulationStage } = useRapier();
+    let key;
+    let fn;
+    let opts;
+    if (isKey(keyOrFn)) {
+        key = keyOrFn;
+        fn = fnOrOptions;
+        opts = options ?? {};
+    }
+    else {
+        key = Symbol('usePhysicsTask');
+        fn = keyOrFn;
+        opts = (fnOrOptions ?? {});
+    }
+    if (opts.before && Array.isArray(opts.before)) {
+        opts.before.push(simulationTask);
+    }
+    else if (opts.before) {
+        opts.before = [opts.before, simulationTask];
+    }
+    else {
+        opts.before = [simulationTask];
+    }
+    opts.stage = simulationStage;
+    return useTask(key, fn, opts);
+}

package/dist/hooks/usePrismaticJoint.d.ts

@@ -0,0 +1,7 @@
+import type { PrismaticImpulseJoint } from '@dimforge/rapier3d-compat';
+import { Vector3 } from 'three';
+export declare const usePrismaticJoint: (anchorA: Parameters<Vector3["set"]> | Vector3, anchorB: Parameters<Vector3["set"]> | Vector3, axis: Parameters<Vector3["set"]> | Vector3, limits?: [min: number, max: number]) => {
+    joint: import("svelte/store").Writable<PrismaticImpulseJoint>;
+    rigidBodyA: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+    rigidBodyB: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+};

package/dist/hooks/useRevoluteJoint.d.ts

@@ -0,0 +1,7 @@
+import type { RevoluteImpulseJoint } from '@dimforge/rapier3d-compat';
+import { Vector3 } from 'three';
+export declare const useRevoluteJoint: (anchorA: Parameters<Vector3["set"]> | Vector3, anchorB: Parameters<Vector3["set"]> | Vector3, axis: Parameters<Vector3["set"]> | Vector3, limits?: [min: number, max: number]) => {
+    joint: import("svelte/store").Writable<RevoluteImpulseJoint>;
+    rigidBodyA: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+    rigidBodyB: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+};

package/dist/hooks/useRopeJoint.d.ts

@@ -0,0 +1,10 @@
+import type { RopeImpulseJoint } from '@dimforge/rapier3d-compat';
+import { Vector3 } from 'three';
+/**
+ * The rope joint limits the max distance between two bodies.
+ */
+export declare const useRopeJoint: (anchorA: Parameters<Vector3["set"]> | Vector3, anchorB: Parameters<Vector3["set"]> | Vector3, length: number) => {
+    joint: import("svelte/store").Writable<RopeImpulseJoint>;
+    rigidBodyA: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+    rigidBodyB: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+};

package/dist/hooks/useRopeJoint.js

@@ -0,0 +1,14 @@
+import { Vector3 } from 'three';
+import { useJoint } from './useJoint';
+import { isVector3 } from './utils';
+/**
+ * The rope joint limits the max distance between two bodies.
+ */
+export const useRopeJoint = (anchorA, anchorB, length) => {
+    return useJoint((rbA, rbB, { world, rapier }) => {
+        const jaA = isVector3(anchorA) ? anchorA : new Vector3(...anchorA);
+        const jaB = isVector3(anchorB) ? anchorB : new Vector3(...anchorB);
+        const params = rapier.JointData.rope(length, jaA, jaB);
+        return world.createImpulseJoint(params, rbA, rbB, true);
+    });
+};

package/dist/hooks/useSphericalJoint.d.ts

@@ -0,0 +1,7 @@
+import type { SphericalImpulseJoint } from '@dimforge/rapier3d-compat';
+import { Vector3 } from 'three';
+export declare const useSphericalJoint: (anchorA: Parameters<Vector3["set"]> | Vector3, anchorB: Parameters<Vector3["set"]> | Vector3) => {
+    joint: import("svelte/store").Writable<SphericalImpulseJoint>;
+    rigidBodyA: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+    rigidBodyB: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+};

package/dist/hooks/utils.js

@@ -1,6 +1,7 @@
+import { isInstanceOf } from '@threlte/core';
 export const isVector3 = (v) => {
-    return v.isVector3;
+    return isInstanceOf(v, 'Vector3');
 };
 export const isEuler = (v) => {
-    return v.isEuler;
+    return isInstanceOf(v, 'Euler');
 };

package/dist/index.d.ts

@@ -1,18 +1,19 @@
 export { useRapier } from './hooks/useRapier';
 export { useCollisionGroups } from './hooks/useCollisionGroups';
 export { useRigidBody } from './hooks/useRigidBody';
+export { usePhysicsTask } from './hooks/usePhysicsTask';
 export { useRevoluteJoint } from './hooks/useRevoluteJoint';
 export { usePrismaticJoint } from './hooks/usePrismaticJoint';
 export { useFixedJoint } from './hooks/useFixedJoint';
 export { useSphericalJoint } from './hooks/useSphericalJoint';
 export { useJoint } from './hooks/useJoint';
+export { useRopeJoint } from './hooks/useRopeJoint';
 export { default as World } from './components/World/World.svelte';
 export { default as RigidBody } from './components/RigidBody/RigidBody.svelte';
 export { default as Debug } from './components/Debug/Debug.svelte';
-export { default as Collider } from './components/Colliders/Collider.svelte';
-export { default as AutoColliders } from './components/Colliders/AutoColliders.svelte';
+export { default as Collider } from './components/Colliders/Collider/Collider.svelte';
+export { default as AutoColliders } from './components/Colliders/AutoColliders/AutoColliders.svelte';
 export { default as CollisionGroups } from './components/CollisionGroups/CollisionGroups.svelte';
 export { default as Attractor } from './components/Attractor/Attractor.svelte';
 export { computeBitMask } from './lib/computeBitMask';
-export { default as BasicPlayerController } from './recipes/BasicPlayerController.svelte';
-export type { CollisionGroupsBitMask, AutoCollidersShapes, ColliderEventDispatcher, ColliderShapes, RapierContext, RigidBodyEventDispatcher, CollisionEnterEvent, CollisionExitEvent, SensorEnterEvent, SensorExitEvent, ContactEvent, GravityType } from './types/types';
+export type { CollisionGroupsBitMask, AutoCollidersShapes, ColliderShapes, RapierContext, CollisionEnterEvent, CollisionExitEvent, SensorEnterEvent, SensorExitEvent, ContactEvent, GravityType, CreateEvent, Framerate } from './types/types';

package/dist/index.js

@@ -2,21 +2,21 @@
 export { useRapier } from './hooks/useRapier';
 export { useCollisionGroups } from './hooks/useCollisionGroups';
 export { useRigidBody } from './hooks/useRigidBody';
+export { usePhysicsTask } from './hooks/usePhysicsTask';
 // Joints
 export { useRevoluteJoint } from './hooks/useRevoluteJoint';
 export { usePrismaticJoint } from './hooks/usePrismaticJoint';
 export { useFixedJoint } from './hooks/useFixedJoint';
 export { useSphericalJoint } from './hooks/useSphericalJoint';
 export { useJoint } from './hooks/useJoint';
+export { useRopeJoint } from './hooks/useRopeJoint';
 // components
 export { default as World } from './components/World/World.svelte';
 export { default as RigidBody } from './components/RigidBody/RigidBody.svelte';
 export { default as Debug } from './components/Debug/Debug.svelte';
-export { default as Collider } from './components/Colliders/Collider.svelte';
-export { default as AutoColliders } from './components/Colliders/AutoColliders.svelte';
+export { default as Collider } from './components/Colliders/Collider/Collider.svelte';
+export { default as AutoColliders } from './components/Colliders/AutoColliders/AutoColliders.svelte';
 export { default as CollisionGroups } from './components/CollisionGroups/CollisionGroups.svelte';
 export { default as Attractor } from './components/Attractor/Attractor.svelte';
 // lib
 export { computeBitMask } from './lib/computeBitMask';
-// recipes
-export { default as BasicPlayerController } from './recipes/BasicPlayerController.svelte';

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,5 +1,6 @@
-import { ActiveEvents, ColliderDesc } from '@dimforge/rapier3d-compat';
-import { Quaternion, Vector3 } from 'three';
+import { ActiveEvents, Collider, ColliderDesc, RigidBody, World } from '@dimforge/rapier3d-compat';
+import { isInstanceOf } from '@threlte/core';
+import { Mesh, Quaternion, Vector3 } from 'three';
 const offset = new Vector3();
 const worldPosition = new Vector3();
 const worldQuaternion = new Quaternion();
@@ -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/createPhysicsTasks.js

@@ -1,4 +1,4 @@
-import { EventQueue } from '@dimforge/rapier3d-compat';
+import { Collider, EventQueue } from '@dimforge/rapier3d-compat';
 import { useTask } from '@threlte/core';
 import { Object3D, Quaternion, Vector3 } from 'three';
 import { simulationKey, synchronizationKey } from './keys';

package/dist/lib/createRapierContext.d.ts

@@ -1,7 +1,7 @@
 import RAPIER from '@dimforge/rapier3d-compat';
 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: {
+export declare const createRapierContext: (worldArgs: ConstructorParameters<typeof RAPIER.World>, options: {
     framerate?: Framerate;
     autoStart?: boolean;
     simulationStageOptions?: {

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/getWorldTransforms.js

@@ -1,4 +1,4 @@
-import { Euler, Quaternion, Vector3 } from 'three';
+import { Euler, Object3D, Quaternion, Vector3 } from 'three';
 const tempPosition = new Vector3();
 const tempQuaternion = new Quaternion();
 const tempRotation = new Euler();

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,4 +1,3 @@
-/// <reference types="svelte" />
 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';
@@ -6,11 +5,10 @@ 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;

package/dist/types/types.js

@@ -1 +1,2 @@
-export {};
+import { World } from '@dimforge/rapier3d-compat';
+import RAPIER from '@dimforge/rapier3d-compat';

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@threlte/rapier",
-  "version": "3.0.0-next.9",
+  "version": "3.0.0",
   "author": "Grischa Erbe <hello@legrisch.com> (https://legrisch.com)",
   "license": "MIT",
   "description": "Components and hooks to use the Rapier physics engine in Threlte",
   "devDependencies": {
-    "@dimforge/rapier3d-compat": "^0.13.1",
-    "@sveltejs/adapter-auto": "^3.2.0",
-    "@sveltejs/kit": "^2.5.5",
-    "@sveltejs/package": "^2.3.1",
-    "@sveltejs/vite-plugin-svelte": "^3.1.0",
+    "@dimforge/rapier3d-compat": "^0.14.0",
+    "@sveltejs/adapter-auto": "^3.3.1",
+    "@sveltejs/kit": "^2.7.7",
+    "@sveltejs/package": "^2.3.7",
+    "@sveltejs/vite-plugin-svelte": "^4.0.0",
     "@types/node": "^20.12.7",
-    "@types/three": "^0.166.0",
+    "@types/three": "^0.171.0",
     "@typescript-eslint/eslint-plugin": "^7.6.0",
     "@typescript-eslint/parser": "^7.6.0",
     "@yushijinhun/three-minifier-rollup": "^0.4.0",
@@ -22,19 +22,19 @@
     "prettier-plugin-svelte": "^3.2.2",
     "publint": "^0.2.7",
     "rimraf": "^5.0.5",
-    "svelte": "5.0.0-next.181",
+    "svelte": "^5.14.4",
     "svelte-check": "^3.6.9",
     "svelte-preprocess": "^5.1.3",
     "svelte2tsx": "^0.7.6",
-    "three": "^0.166.1",
+    "three": "^0.171.0",
     "tslib": "^2.6.2",
     "type-fest": "^4.15.0",
-    "typescript": "^5.4.5",
+    "typescript": "^5.6.3",
     "vite": "^5.2.8",
-    "@threlte/core": "8.0.0-next.17"
+    "@threlte/core": "8.0.0"
   },
   "peerDependencies": {
-    "@dimforge/rapier3d-compat": ">=0.12",
+    "@dimforge/rapier3d-compat": ">=0.14",
     "svelte": ">=5",
     "three": ">=0.152"
   },