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

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

@@ -1,102 +1,3 @@
-import { RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat'
-import { SvelteComponent, type Snippet } from 'svelte'
-import type { Euler, Vector3 } from 'three'
-import type { RigidBodyTypeString } from '../../lib/parseRigidBodyType'
-import type { RigidBodyEvents } from '../../types/types'
-
-export type Boolean3Array = [x: boolean, y: boolean, z: boolean]
-
-export type RigidBodyProps = {
-  rigidBody?: RapierRigidBody
-
-  /**
-   * 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 }]>
-}
-
-export default class RigidBody extends SvelteComponent<RigidBodyProps & RigidBodyEvents> {}
+import type { RigidBodyProps } from './types';
+declare const RigidBody: import("svelte").Component<RigidBodyProps, {}, "rigidBody">;
+export default RigidBody;

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

@@ -0,0 +1,14 @@
+import type { RigidBody } from '@dimforge/rapier3d-compat';
+import type { Object3D } from 'three';
+export type ExtractMethods<ObjectType> = Pick<ObjectType, {
+    [Method in keyof ObjectType]: ObjectType[Method] extends (...args: any[]) => any ? Method : never;
+}[keyof ObjectType]>;
+/**
+ * When using a fixed framerate, Threlte is interpolating the position and
+ * rotation of RigidBody objects. Sometimes, this is not desirable, especially
+ * when using methods on the rigidbody that teleport the object, e.g. should
+ * lead to a sudden change in translation/rotation such as `rb.setTranslation`.
+ * These methods are overridden to reset the physics simulation position and
+ * rotation to the current object position and rotation.
+ */
+export declare const overrideTeleportMethods: (rb: RigidBody, object: Object3D) => void;

package/dist/components/RigidBody/overrideTeleportMethods.js

@@ -0,0 +1,31 @@
+const overrideMethods = {
+    position: ['setTranslation', 'setNextKinematicTranslation'],
+    rotation: ['setRotation', 'setNextKinematicRotation']
+};
+/**
+ * When using a fixed framerate, Threlte is interpolating the position and
+ * rotation of RigidBody objects. Sometimes, this is not desirable, especially
+ * when using methods on the rigidbody that teleport the object, e.g. should
+ * lead to a sudden change in translation/rotation such as `rb.setTranslation`.
+ * These methods are overridden to reset the physics simulation position and
+ * rotation to the current object position and rotation.
+ */
+export const overrideTeleportMethods = (rb, object) => {
+    const originalMethods = {};
+    overrideMethods.position.forEach((method) => {
+        originalMethods[method] = rb[method].bind(rb);
+        const proxy = (...args) => {
+            object.userData.physics.resetPosition = true;
+            return originalMethods[method](...args);
+        };
+        rb[method] = proxy;
+    });
+    overrideMethods.rotation.forEach((method) => {
+        originalMethods[method] = rb[method].bind(rb);
+        const proxy = (...args) => {
+            object.userData.physics.resetRotation = true;
+            return originalMethods[method](...args);
+        };
+        rb[method] = proxy;
+    });
+};

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 @@
+export {};

package/dist/components/World/InnerWorld.svelte

@@ -1,19 +1,41 @@
 <script lang="ts">import { onDestroy, setContext, tick } from 'svelte';
-import { useFrameHandler } from '../../hooks/useFrameHandler';
 import { createRapierContext } from '../../lib/createRapierContext';
-let { gravity = [0, -9.81, 0], rawIntegrationParameters, rawIslands, rawBroadPhase, rawNarrowPhase, rawBodies, rawColliders, rawImpulseJoints, rawMultibodyJoints, rawCCDSolver, rawQueryPipeline, rawPhysicsPipeline, rawSerializationPipeline, rawDebugRenderPipeline, stage } = $props();
-const rapierContext = createRapierContext({ x: gravity[0], y: gravity[1], z: gravity[2] }, rawIntegrationParameters, rawIslands, rawBroadPhase, rawNarrowPhase, rawBodies, rawColliders, rawImpulseJoints, rawMultibodyJoints, rawCCDSolver, rawQueryPipeline, rawPhysicsPipeline, rawSerializationPipeline, rawDebugRenderPipeline);
+let { gravity = [0, -9.81, 0], rawIntegrationParameters, rawIslands, rawBroadPhase, rawNarrowPhase, rawBodies, rawColliders, rawImpulseJoints, rawMultibodyJoints, rawCCDSolver, rawQueryPipeline, rawPhysicsPipeline, rawSerializationPipeline, rawDebugRenderPipeline, framerate, autoStart = true, simulationStageOptions, synchronizationStageOptions, children } = $props();
+const rapierContext = createRapierContext([
+    { x: gravity[0], y: gravity[1], z: gravity[2] },
+    rawIntegrationParameters,
+    rawIslands,
+    rawBroadPhase,
+    rawNarrowPhase,
+    rawBodies,
+    rawColliders,
+    rawImpulseJoints,
+    rawMultibodyJoints,
+    rawCCDSolver,
+    rawQueryPipeline,
+    rawPhysicsPipeline,
+    rawSerializationPipeline,
+    rawDebugRenderPipeline
+], {
+    framerate,
+    autoStart,
+    simulationStageOptions,
+    synchronizationStageOptions
+});
 setContext('threlte-rapier-context', rapierContext);
 $effect.pre(() => {
     if (gravity !== undefined) {
         rapierContext.world.gravity = { x: gravity[0], y: gravity[1], z: gravity[2] };
     }
 });
-useFrameHandler(rapierContext, stage);
+$effect.pre(() => {
+    if (framerate !== undefined)
+        rapierContext.framerate.set(framerate);
+});
 onDestroy(async () => {
     await tick();
     rapierContext.world.free();
 });
 </script>
 
-<slot />
+{@render children?.()}

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

@@ -1,21 +1,3 @@
-import { SvelteComponent } from "svelte";
-import type { WorldProps } from './World.svelte';
-declare const __propDef: {
-    props: WorldProps & {
-        children?: ((this: void) => typeof import("svelte").SnippetReturn & {
-            _: "functions passed to {@render ...} tags must use the `Snippet` type imported from \"svelte\"";
-        }) | undefined;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-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

@@ -1,60 +1,12 @@
-<script
-  context="module"
-  lang="ts"
->import RAPIER from '@dimforge/rapier3d-compat';
-import { onMount } from 'svelte';
-import { writable } from 'svelte/store';
-/**
- * RAPIER.init() should only be called once
- */
-const initialized = writable(false);
+<script lang="ts">import { initRapier } from '../../lib/initRapier.svelte';
+import InnerWorld from './InnerWorld.svelte';
+let { fallback, children, ...rest } = $props();
 </script>
 
-<script lang="ts">import InnerWorld from './InnerWorld.svelte';
-let { gravity, rawIntegrationParameters, rawIslands, rawBroadPhase, rawNarrowPhase, rawBodies, rawColliders, rawImpulseJoints, rawMultibodyJoints, rawCCDSolver, rawQueryPipeline, rawPhysicsPipeline, rawSerializationPipeline, rawDebugRenderPipeline, 
-/**
- * This is passed to the useTask handler.
- * Use this to control when the rapier physics engine is updating the scene.
- * @default undefined
- */
-stage } = $props();
-let error = $state(false);
-const init = async () => {
-    if ($initialized)
-        return;
-    try {
-        await RAPIER.init();
-        $initialized = true;
-    }
-    catch (e) {
-        error = true;
-    }
-};
-onMount(init);
-</script>
-
-{#if $initialized}
-  <InnerWorld
-    {gravity}
-    {rawIntegrationParameters}
-    {rawIslands}
-    {rawBroadPhase}
-    {rawNarrowPhase}
-    {rawBodies}
-    {rawColliders}
-    {rawImpulseJoints}
-    {rawMultibodyJoints}
-    {rawCCDSolver}
-    {rawQueryPipeline}
-    {rawPhysicsPipeline}
-    {rawSerializationPipeline}
-    {rawDebugRenderPipeline}
-    {stage}
-  >
-    <slot />
+{#await initRapier() then _}
+  <InnerWorld {...rest}>
+    {@render children?.()}
   </InnerWorld>
-{/if}
-
-{#if error}
-  <slot name="fallback" />
-{/if}
+{:catch error}
+  {@render fallback?.(error)}
+{/await}

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

@@ -1,38 +1,3 @@
-import type {
-  RawBroadPhase,
-  RawCCDSolver,
-  RawColliderSet,
-  RawDebugRenderPipeline,
-  RawImpulseJointSet,
-  RawIntegrationParameters,
-  RawIslandManager,
-  RawMultibodyJointSet,
-  RawNarrowPhase,
-  RawPhysicsPipeline,
-  RawQueryPipeline,
-  RawRigidBodySet,
-  RawSerializationPipeline
-} from '@dimforge/rapier3d-compat/raw'
-import { SvelteComponent } from 'svelte'
-import type { Vector3 } from 'three'
-import type { Key, Stage } from '@threlte/core'
-
-export type WorldProps = {
-  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
-  stage?: Key | Stage
-}
-
-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 @@
+export {};

package/dist/hooks/useFixedJoint.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="svelte" />
 import type { FixedImpulseJoint } from '@dimforge/rapier3d-compat';
-import { Euler } from 'three';
-export declare const useFixedJoint: (anchorA: [x: number, y: number, z: number], frameA: Parameters<Euler['set']> | Euler, anchorB: [x: number, y: number, z: number], frameB: Parameters<Euler['set']> | Euler) => {
+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

@@ -1,4 +1,3 @@
-/// <reference types="svelte" />
 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) => {

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

@@ -1,7 +1,6 @@
-/// <reference types="svelte" />
 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]) => {
+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

@@ -1,7 +1,6 @@
-/// <reference types="svelte" />
 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]) => {
+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

@@ -1,7 +1,6 @@
-/// <reference types="svelte" />
 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) => {
+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';