@threlte/rapier 0.5.0 → 1.0.0-next.0

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

@@ -1,60 +1,6 @@
-import { SvelteComponentTyped } from "svelte";
-declare const __propDef: {
-    props: {
-        color?: import("three").ColorRepresentation | undefined;
-        linewidth?: number | undefined;
-        linecap?: string | undefined;
-        linejoin?: string | undefined;
-        alphaTest?: number | undefined;
-        alphaToCoverage?: boolean | undefined;
-        blendDst?: import("three").BlendingDstFactor | undefined;
-        blendDstAlpha?: number | undefined;
-        blendEquation?: import("three").BlendingEquation | undefined;
-        blendEquationAlpha?: number | undefined;
-        blending?: import("three").Blending | undefined;
-        blendSrc?: import("three").BlendingDstFactor | import("three").BlendingSrcFactor | undefined;
-        blendSrcAlpha?: number | undefined;
-        clipIntersection?: boolean | undefined;
-        clippingPlanes?: import("three").Plane[] | undefined;
-        clipShadows?: boolean | undefined;
-        colorWrite?: boolean | undefined;
-        defines?: any;
-        depthFunc?: import("three").DepthModes | undefined;
-        depthTest?: boolean | undefined;
-        depthWrite?: boolean | undefined;
-        name?: string | undefined;
-        opacity?: number | undefined;
-        polygonOffset?: boolean | undefined;
-        polygonOffsetFactor?: number | undefined;
-        polygonOffsetUnits?: number | undefined;
-        precision?: "highp" | "mediump" | "lowp" | null | undefined;
-        premultipliedAlpha?: boolean | undefined;
-        dithering?: boolean | undefined;
-        side?: import("three").Side | undefined;
-        shadowSide?: import("three").Side | undefined;
-        toneMapped?: boolean | undefined;
-        transparent?: boolean | undefined;
-        vertexColors?: boolean | undefined;
-        visible?: boolean | undefined;
-        format?: import("three").PixelFormat | undefined;
-        stencilWrite?: boolean | undefined;
-        stencilFunc?: import("three").StencilFunc | undefined;
-        stencilRef?: number | undefined;
-        stencilWriteMask?: number | undefined;
-        stencilFuncMask?: number | undefined;
-        stencilFail?: import("three").StencilOp | undefined;
-        stencilZFail?: import("three").StencilOp | undefined;
-        stencilZPass?: import("three").StencilOp | undefined;
-        userData?: any;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export declare type DebugProps = typeof __propDef.props;
-export declare type DebugEvents = typeof __propDef.events;
-export declare type DebugSlots = typeof __propDef.slots;
-export default class Debug extends SvelteComponentTyped<DebugProps, DebugEvents, DebugSlots> {
-}
-export {};
+import { SvelteComponentTyped } from 'svelte'
+import type { LineBasicMaterialParameters } from 'three'
+
+export type DebugProps = LineBasicMaterialParameters
+
+export default class Debug extends SvelteComponentTyped<DebugProps> {}

package/dist/components/RigidBody/RigidBody.svelte

@@ -1,4 +1,4 @@
-<script>import { LayerableObject, SceneGraphObject } from '@threlte/core';
+<script>import { SceneGraphObject } from '@threlte/core';
 import { createEventDispatcher, onDestroy, setContext, tick } from 'svelte';
 import { Object3D, Vector3 } from 'three';
 import { useHasEventListeners } from '../../hooks/useHasEventListener';
@@ -6,35 +6,23 @@ import { useRapier } from '../../hooks/useRapier';
 import { applyTransforms } from '../../lib/applyTransforms';
 import { getWorldPosition, getWorldQuaternion, getWorldScale } from '../../lib/getWorldTransforms';
 import { parseRigidBodyType } from '../../lib/parseRigidBodyType';
-import { positionToVector3 } from '../../lib/positionToVector3';
-import { rotationToEuler } from '../../lib/rotationToEuler';
 const { world, rapier, addRigidBodyToContext, removeRigidBodyFromContext } = useRapier();
-export let debug = false;
+export let position = undefined;
+export let rotation = undefined;
+export let scale = undefined;
+export let linearVelocity = undefined;
+export let angularVelocity = undefined;
 export let type = 'dynamic';
 export let canSleep = true;
-export let linearVelocity = {};
-export let angularVelocity = {};
 export let gravityScale = 1;
 export let ccd = false;
 export let angularDamping = 0;
 export let linearDamping = 0;
 export let lockRotations = false;
 export let lockTranslations = false;
-export let enabledRotations = [
-    true,
-    true,
-    true
-];
-export let enabledTranslations = [
-    true,
-    true,
-    true
-];
+export let enabledRotations = [true, true, true];
+export let enabledTranslations = [true, true, true];
 export let dominance = 0;
-export let position = undefined;
-export let rotation = undefined;
-export let scale = undefined;
-export let lookAt = undefined;
 const dispatcher = createEventDispatcher();
 const object = new Object3D();
 /**
@@ -51,7 +39,7 @@ object.userData.isSleeping = false;
  * This is a one-off operation as RigidBodies should
  * not be moved around after initialization.
  */
-applyTransforms(object, position, rotation, scale, lookAt);
+applyTransforms(object, position, rotation, scale);
 /**
  * Update the world matrix of the object before applying
  * the world position to the RigidBody
@@ -74,7 +62,7 @@ const rigidBodyTemp = world.createRigidBody(desc);
  */
 const initPosition = async () => {
     await tick();
-    applyTransforms(object, position, rotation, scale, lookAt);
+    applyTransforms(object, position, rotation, scale);
     object.updateMatrix();
     object.updateWorldMatrix(true, false);
     const parentWorldScale = object.parent ? getWorldScale(object.parent) : new Vector3(1, 1, 1);
@@ -82,12 +70,6 @@ const initPosition = async () => {
     const worldQuaternion = getWorldQuaternion(object);
     rigidBodyTemp.setTranslation(worldPosition, true);
     rigidBodyTemp.setRotation(worldQuaternion, true);
-    if (debug) {
-        console.log('worldPosition', worldPosition);
-        console.log('worldQuaternion', worldQuaternion);
-    }
-    if (debug)
-        console.log(JSON.stringify(desc, null, 2));
     rigidBody = rigidBodyTemp;
 };
 initPosition();
@@ -100,8 +82,10 @@ object.userData.rigidBody = rigidBodyTemp;
  */
 $: {
     rigidBodyTemp.setBodyType(parseRigidBodyType(type));
-    rigidBodyTemp.setLinvel(positionToVector3(linearVelocity), true);
-    rigidBodyTemp.setAngvel(rotationToEuler(angularVelocity), true);
+    if (linearVelocity)
+        rigidBodyTemp.setLinvel({ x: linearVelocity[0], y: linearVelocity[1], z: linearVelocity[2] }, true);
+    if (angularVelocity)
+        rigidBodyTemp.setAngvel({ x: angularVelocity[0], y: angularVelocity[1], z: angularVelocity[2] }, true);
     rigidBodyTemp.setGravityScale(gravityScale, true);
     rigidBodyTemp.enableCcd(ccd);
     rigidBodyTemp.setDominanceGroup(dominance);
@@ -140,5 +124,3 @@ onDestroy(() => {
 <SceneGraphObject {object}>
   <slot />
 </SceneGraphObject>
-
-<LayerableObject {object} />

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

@@ -1,68 +1,94 @@
-import { SvelteComponentTyped } from "svelte";
-import type { RigidBody } from '@dimforge/rapier3d-compat';
-import type { RigidBodyProperties } from '../../types/components';
-declare const __propDef: {
-    props: {
-        debug?: boolean | undefined;
-        type?: import("../../lib/parseRigidBodyType").RigidBodyTypeString | undefined;
-        canSleep?: boolean | undefined;
-        linearVelocity?: import("@threlte/core").Position | undefined;
-        angularVelocity?: import("@threlte/core").Rotation | undefined;
-        gravityScale?: number | undefined;
-        ccd?: boolean | undefined;
-        angularDamping?: number | undefined;
-        linearDamping?: number | undefined;
-        lockRotations?: boolean | undefined;
-        lockTranslations?: boolean | undefined;
-        enabledRotations?: import("../../types/components").Boolean3Array | undefined;
-        enabledTranslations?: import("../../types/components").Boolean3Array | undefined;
-        dominance?: number | undefined;
-        position?: RigidBodyProperties['position'];
-        rotation?: RigidBodyProperties['rotation'];
-        scale?: RigidBodyProperties['scale'];
-        lookAt?: RigidBodyProperties['lookAt'];
-        /**
-           * Export the rigidBody only after positional initialization
-           */ rigidBody?: RigidBody | undefined;
-    };
-    slots: {
-        default: {};
-    };
-    getters: {};
-    events: {
-        collisionenter: CustomEvent<{
-            targetCollider: import("@dimforge/rapier3d-compat").Collider;
-            targetRigidBody: RigidBody | null;
-            manifold: import("@dimforge/rapier3d-compat").TempContactManifold;
-            flipped: boolean;
-        }>;
-        collisionexit: CustomEvent<{
-            targetCollider: import("@dimforge/rapier3d-compat").Collider;
-            targetRigidBody: RigidBody | null;
-        }>;
-        sensorenter: CustomEvent<{
-            targetCollider: import("@dimforge/rapier3d-compat").Collider;
-            targetRigidBody: RigidBody | null;
-        }>;
-        sensorexit: CustomEvent<{
-            targetCollider: import("@dimforge/rapier3d-compat").Collider;
-            targetRigidBody: RigidBody | null;
-        }>;
-        contact: CustomEvent<{
-            targetCollider: import("@dimforge/rapier3d-compat").Collider;
-            targetRigidBody: RigidBody | null;
-            maxForceDirection: import("@dimforge/rapier3d-compat").Vector;
-            maxForceMagnitude: number;
-            totalForce: import("@dimforge/rapier3d-compat").Vector;
-            totalForceMagnitude: number;
-        }>;
-        sleep: CustomEvent<void>;
-        wake: CustomEvent<void>;
-    };
-};
-export declare type RigidBodyProps = typeof __propDef.props;
-export declare type RigidBodyEvents = typeof __propDef.events;
-export declare type RigidBodySlots = typeof __propDef.slots;
-export default class RigidBody extends SvelteComponentTyped<RigidBodyProps, RigidBodyEvents, RigidBodySlots> {
+import { RigidBody as RapierRigidBody } from '@dimforge/rapier3d-compat'
+import { SvelteComponentTyped } from 'svelte'
+import type { Euler, Vector3 } from 'three'
+import type { RigidBodyTypeString } from '../../lib/parseRigidBodyType'
+
+export type Boolean3Array = [x: boolean, y: boolean, z: boolean]
+
+export type RigidBodyProps = {
+  rigidBody?: RapierRigidBody
+
+  position?: Parameters<Vector3['set']>
+  rotation?: Parameters<Euler['set']>
+  scale?: Parameters<Vector3['set']>
+
+  /**
+   * 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 rotation 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
 }
-export {};
+
+export default class RigidBody extends SvelteComponentTyped<RigidBodyProps> {}

package/dist/components/World/InnerWorld.svelte

@@ -1,10 +1,12 @@
-<script context="module">import { onDestroy, setContext, tick } from 'svelte';
+<script
+  context="module"
+ 
+>import { onDestroy, setContext, tick } from 'svelte';
 import { useFrameHandler } from '../../hooks/useFrameHandler';
 import { createRapierContext } from '../../lib/createRapierContext';
 </script>
 
-<script>import { positionToVector3 } from '../../lib/positionToVector3';
-export let gravity = { y: -9.81 };
+<script>export let gravity = [0, -9.81, 0];
 export let rawIntegrationParameters = undefined;
 export let rawIslands = undefined;
 export let rawBroadPhase = undefined;
@@ -18,10 +20,11 @@ export let rawQueryPipeline = undefined;
 export let rawPhysicsPipeline = undefined;
 export let rawSerializationPipeline = undefined;
 export let rawDebugRenderPipeline = undefined;
-const rapierContext = createRapierContext(positionToVector3(gravity), rawIntegrationParameters, rawIslands, rawBroadPhase, rawNarrowPhase, rawBodies, rawColliders, rawImpulseJoints, rawMultibodyJoints, rawCCDSolver, rawQueryPipeline, rawPhysicsPipeline, rawSerializationPipeline, rawDebugRenderPipeline);
+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);
 setContext('threlte-rapier-context', rapierContext);
-$: if (gravity !== undefined)
-    rapierContext.world.gravity = positionToVector3(gravity);
+$: if (gravity !== undefined) {
+    rapierContext.world.gravity = { x: gravity[0], y: gravity[1], z: gravity[2] };
+}
 useFrameHandler(rapierContext);
 onDestroy(async () => {
     await tick();

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

@@ -1,21 +1,20 @@
 import { SvelteComponentTyped } from "svelte";
-import type { InnerWorldProperties } from '../../types/components';
 declare const __propDef: {
     props: {
-        gravity?: InnerWorldProperties['gravity'];
-        rawIntegrationParameters?: InnerWorldProperties['rawIntegrationParameters'];
-        rawIslands?: InnerWorldProperties['rawIslands'];
-        rawBroadPhase?: InnerWorldProperties['rawBroadPhase'];
-        rawNarrowPhase?: InnerWorldProperties['rawNarrowPhase'];
-        rawBodies?: InnerWorldProperties['rawBodies'];
-        rawColliders?: InnerWorldProperties['rawColliders'];
-        rawImpulseJoints?: InnerWorldProperties['rawImpulseJoints'];
-        rawMultibodyJoints?: InnerWorldProperties['rawMultibodyJoints'];
-        rawCCDSolver?: InnerWorldProperties['rawCCDSolver'];
-        rawQueryPipeline?: InnerWorldProperties['rawQueryPipeline'];
-        rawPhysicsPipeline?: InnerWorldProperties['rawPhysicsPipeline'];
-        rawSerializationPipeline?: InnerWorldProperties['rawSerializationPipeline'];
-        rawDebugRenderPipeline?: InnerWorldProperties['rawDebugRenderPipeline'];
+        gravity?: [x: number, y: number, z: number] | undefined;
+        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;
     };
     events: {
         [evt: string]: CustomEvent<any>;

package/dist/components/World/World.svelte

@@ -1,13 +1,17 @@
-<script context="module">import RAPIER from '@dimforge/rapier3d-compat';
+<script
+  context="module"
+ 
+>import RAPIER from '@dimforge/rapier3d-compat';
 import { onMount } from 'svelte';
 import { writable } from 'svelte/store';
 /**
  * RAPIER.init() should only be called once
  */
-let initialized = writable(false);
+const initialized = writable(false);
 </script>
 
 <script>import InnerWorld from './InnerWorld.svelte';
+// self
 export let gravity = undefined;
 export let rawIntegrationParameters = undefined;
 export let rawIslands = undefined;

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

@@ -1,33 +1,36 @@
-import { SvelteComponentTyped } from "svelte";
-import type { WorldProperties } from '../../types/components';
-declare const __propDef: {
-    props: {
-        gravity?: WorldProperties['gravity'];
-        rawIntegrationParameters?: WorldProperties['rawIntegrationParameters'];
-        rawIslands?: WorldProperties['rawIslands'];
-        rawBroadPhase?: WorldProperties['rawBroadPhase'];
-        rawNarrowPhase?: WorldProperties['rawNarrowPhase'];
-        rawBodies?: WorldProperties['rawBodies'];
-        rawColliders?: WorldProperties['rawColliders'];
-        rawImpulseJoints?: WorldProperties['rawImpulseJoints'];
-        rawMultibodyJoints?: WorldProperties['rawMultibodyJoints'];
-        rawCCDSolver?: WorldProperties['rawCCDSolver'];
-        rawQueryPipeline?: WorldProperties['rawQueryPipeline'];
-        rawPhysicsPipeline?: WorldProperties['rawPhysicsPipeline'];
-        rawSerializationPipeline?: WorldProperties['rawSerializationPipeline'];
-        rawDebugRenderPipeline?: WorldProperties['rawDebugRenderPipeline'];
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-        fallback: {};
-    };
-};
-export declare type WorldProps = typeof __propDef.props;
-export declare type WorldEvents = typeof __propDef.events;
-export declare type WorldSlots = typeof __propDef.slots;
-export default class World extends SvelteComponentTyped<WorldProps, WorldEvents, WorldSlots> {
+import type {
+  RawBroadPhase,
+  RawCCDSolver,
+  RawColliderSet,
+  RawDebugRenderPipeline,
+  RawImpulseJointSet,
+  RawIntegrationParameters,
+  RawIslandManager,
+  RawMultibodyJointSet,
+  RawNarrowPhase,
+  RawPhysicsPipeline,
+  RawQueryPipeline,
+  RawRigidBodySet,
+  RawSerializationPipeline
+} from '@dimforge/rapier3d-compat/raw'
+import { SvelteComponentTyped } from 'svelte'
+import type { Vector3 } from 'three'
+
+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
 }
-export {};
+
+export default class World extends SvelteComponentTyped<WorldProps> {}

package/dist/hooks/useFixedJoint.d.ts

@@ -1,6 +1,6 @@
 import type { FixedImpulseJoint } from '@dimforge/rapier3d-compat';
-import type { Position, Rotation } from '@threlte/core';
-export declare const useFixedJoint: (anchorA: Position, frameA: Rotation, anchorB: Position, frameB: Rotation) => {
+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) => {
     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/useFixedJoint.js

@@ -1,10 +1,13 @@
-import { positionToVector3 } from '../lib/positionToVector3';
-import { rotationToQuaternion } from '../lib/rotationToQuaternion';
+import { Euler, Quaternion, Vector3 } from 'three';
 import { useJoint } from './useJoint';
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export const useFixedJoint = (anchorA, frameA, anchorB, frameB) => {
+    const jaA = anchorA instanceof Vector3 ? anchorA : new Vector3(...anchorA);
+    const jfA = new Quaternion().setFromEuler(frameA instanceof Euler ? frameA : new Euler(...frameA));
+    const jaB = anchorB instanceof Vector3 ? anchorB : new Vector3(...anchorB);
+    const jfB = new Quaternion().setFromEuler(frameB instanceof Euler ? frameB : new Euler(...frameB));
     return useJoint((rbA, rbB, { world, rapier }) => {
-        const params = rapier.JointData.fixed(positionToVector3(anchorA), rotationToQuaternion(frameA), positionToVector3(anchorB), rotationToQuaternion(frameB));
+        const params = rapier.JointData.fixed(jaA, jfA, jaB, jfB);
         return world.createImpulseJoint(params, rbA, rbB, true);
     });
 };

package/dist/hooks/usePrismaticJoint.d.ts

@@ -1,6 +1,6 @@
 import type { PrismaticImpulseJoint } from '@dimforge/rapier3d-compat';
-import type { Position } from '@threlte/core';
-export declare const usePrismaticJoint: (anchorA: Position, anchorB: Position, axis: Position, limits?: [min: number, max: number]) => {
+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/usePrismaticJoint.js

@@ -1,9 +1,12 @@
-import { positionToVector3 } from '../lib/positionToVector3';
+import { Vector3 } from 'three';
 import { useJoint } from './useJoint';
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export const usePrismaticJoint = (anchorA, anchorB, axis, limits) => {
     return useJoint((rbA, rbB, { world, rapier }) => {
-        const params = rapier.JointData.prismatic(positionToVector3(anchorA), positionToVector3(anchorB), positionToVector3(axis).normalize());
+        const jaA = anchorA instanceof Vector3 ? anchorA : new Vector3(...anchorA);
+        const jaB = anchorB instanceof Vector3 ? anchorB : new Vector3(...anchorB);
+        const jAxis = (axis instanceof Vector3 ? axis : new Vector3(...axis)).normalize();
+        const params = rapier.JointData.prismatic(jaA, jaB, jAxis);
         if (limits) {
             params.limitsEnabled = true;
             params.limits = limits;

package/dist/hooks/useRevoluteJoint.d.ts

@@ -1,6 +1,6 @@
 import type { RevoluteImpulseJoint } from '@dimforge/rapier3d-compat';
-import type { Position } from '@threlte/core';
-export declare const useRevoluteJoint: (anchorA: Position, anchorB: Position, axis: Position, limits?: [min: number, max: number]) => {
+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/useRevoluteJoint.js

@@ -1,9 +1,12 @@
-import { positionToVector3 } from '../lib/positionToVector3';
+import { Vector3 } from 'three';
 import { useJoint } from './useJoint';
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export const useRevoluteJoint = (anchorA, anchorB, axis, limits) => {
     return useJoint((rbA, rbB, { world, rapier }) => {
-        const params = rapier.JointData.revolute(positionToVector3(anchorA), positionToVector3(anchorB), positionToVector3(axis).normalize());
+        const jaA = anchorA instanceof Vector3 ? anchorA : new Vector3(...anchorA);
+        const jaB = anchorB instanceof Vector3 ? anchorB : new Vector3(...anchorB);
+        const jAxis = (axis instanceof Vector3 ? axis : new Vector3(...axis)).normalize();
+        const params = rapier.JointData.revolute(jaA, jaB, jAxis);
         if (limits) {
             params.limitsEnabled = true;
             params.limits = limits;

package/dist/hooks/useSphericalJoint.d.ts

@@ -1,6 +1,6 @@
 import type { SphericalImpulseJoint } from '@dimforge/rapier3d-compat';
-import type { Position } from '@threlte/core';
-export declare const useSphericalJoint: (anchorA: Position, anchorB: Position) => {
+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/useSphericalJoint.js

@@ -1,9 +1,11 @@
-import { positionToVector3 } from '../lib/positionToVector3';
+import { Vector3 } from 'three';
 import { useJoint } from './useJoint';
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export const useSphericalJoint = (anchorA, anchorB) => {
     return useJoint((rbA, rbB, { world, rapier }) => {
-        const params = rapier.JointData.spherical(positionToVector3(anchorA), positionToVector3(anchorB));
+        const jaA = anchorA instanceof Vector3 ? anchorA : new Vector3(...anchorA);
+        const jaB = anchorB instanceof Vector3 ? anchorB : new Vector3(...anchorB);
+        const params = rapier.JointData.spherical(jaA, jaB);
         return world.createImpulseJoint(params, rbA, rbB, true);
     });
 };

package/dist/index.d.ts

@@ -14,5 +14,5 @@ export { default as AutoColliders } from './components/Colliders/AutoColliders.s
 export { default as CollisionGroups } from './components/CollisionGroups/CollisionGroups.svelte';
 export { default as Attractor } from './components/Attractor/Attractor.svelte';
 export { default as BasicPlayerController } from './recipes/BasicPlayerController.svelte';
-export type { AutoCollidersProperties, Boolean3Array, RigidBodyProperties, WorldProperties, AttractorProperties } from './types/components';
+export type { AutoCollidersProperties, AttractorProperties } from './types/components';
 export type { CollisionGroupsBitMask, AutoCollidersShapes, ColliderEventDispatcher, ColliderShapes, RapierContext, RigidBodyEventDispatcher, CollisionEnterEvent, CollisionExitEvent, SensorEnterEvent, SensorExitEvent, ContactEvent } from './types/types';

package/dist/lib/applyTransforms.d.ts

@@ -1,3 +1,2 @@
-import type { Position, Rotation, Scale, LookAt } from '@threlte/core';
-import { Object3D } from 'three';
-export declare const applyTransforms: (object: Object3D, position?: Position, rotation?: Rotation, scale?: Scale, lookAt?: LookAt) => void;
+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;