@threlte/rapier 0.5.0 → 1.0.0-next.1

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

@@ -1,68 +1,95 @@
-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
+
+  /**
+   * 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
+
+  /**
+   * Set the rigidBody as enabled or disabled.
+   */
+  enabled?: boolean
 }
-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,11 +20,13 @@ 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);
+export let order = undefined;
+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);
-useFrameHandler(rapierContext);
+$: if (gravity !== undefined) {
+    rapierContext.world.gravity = { x: gravity[0], y: gravity[1], z: gravity[2] };
+}
+useFrameHandler(rapierContext, order);
 onDestroy(async () => {
     await tick();
     rapierContext.world.free();

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

@@ -1,21 +1,21 @@
 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;
+        order?: number | 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;
@@ -22,6 +26,12 @@ export let rawQueryPipeline = undefined;
 export let rawPhysicsPipeline = undefined;
 export let rawSerializationPipeline = undefined;
 export let rawDebugRenderPipeline = undefined;
+/**
+* The property order is passed to the useFrame handler.
+* Use this to control when the rapier physics engine is updating the scene.
+* @default undefined
+*/
+export let order = undefined;
 let error = false;
 const init = async () => {
     if ($initialized)
@@ -53,6 +63,7 @@ onMount(init);
     {rawPhysicsPipeline}
     {rawSerializationPipeline}
     {rawDebugRenderPipeline}
+		{order}
   >
     <slot />
   </InnerWorld>

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

@@ -1,33 +1,37 @@
-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
+  order?: number
 }
-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/useFrameHandler.d.ts

@@ -1,2 +1,2 @@
 import type { RapierContext } from '../types/types';
-export declare const useFrameHandler: (ctx: RapierContext) => void;
+export declare const useFrameHandler: (ctx: RapierContext, order?: number) => void;

package/dist/hooks/useFrameHandler.js

@@ -1,5 +1,6 @@
 import { Collider, EventQueue } from '@dimforge/rapier3d-compat';
 import { useFrame } from '@threlte/core';
+import { derived } from 'svelte/store';
 import { Object3D, Quaternion, Vector3 } from 'three';
 const tempObject = new Object3D();
 const tempVector3 = new Vector3();
@@ -22,17 +23,14 @@ const getEventDispatchers = (ctx, collider1, collider2) => {
         rigidBodyDispatcher2
     };
 };
-export const useFrameHandler = (ctx) => {
+export const useFrameHandler = (ctx, order) => {
     const eventQueue = new EventQueue(false);
-    let time = performance.now();
-    useFrame(() => {
+    const { start, started, stop } = useFrame((_, delta) => {
         // if (!eventQueue) return
         const { world } = ctx;
         // 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
-        const now = performance.now();
-        const delta = Math.min(100, now - time);
-        world.timestep = delta / 1000;
+        world.timestep = Math.min(0.1, delta);
         world.step(eventQueue);
         // Update meshes
         ctx.rigidBodyObjects.forEach((mesh, handle) => {
@@ -227,6 +225,9 @@ export const useFrameHandler = (ctx) => {
                 });
             }
         });
-        time = now;
-    });
+    }, { order });
+    // 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);
 };

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

@@ -13,6 +13,7 @@ export { default as Collider } from './components/Colliders/Collider.svelte';
 export { default as AutoColliders } from './components/Colliders/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 { 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/index.js

@@ -16,5 +16,7 @@ export { default as Collider } from './components/Colliders/Collider.svelte';
 export { default as AutoColliders } from './components/Colliders/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,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;

package/dist/lib/applyTransforms.js

@@ -1,17 +1,8 @@
-import { Object3D, Vector3 } from 'three';
-import { positionToVector3 } from './positionToVector3';
-import { rotationToEuler } from './rotationToEuler';
-import { scaleToVector3 } from './scaleToVector3';
-export const applyTransforms = (object, position, rotation, scale, lookAt) => {
-    object.position.copy(positionToVector3(position));
-    if (lookAt instanceof Object3D) {
-        object.lookAt(lookAt.getWorldPosition(new Vector3()));
-    }
-    else if (lookAt) {
-        object.lookAt(positionToVector3(lookAt));
-    }
-    else {
-        object.rotation.copy(rotationToEuler(rotation));
-    }
-    object.scale.copy(scaleToVector3(scale));
+export const applyTransforms = (object, position, rotation, scale) => {
+    if (position)
+        object.position.set(...position);
+    if (rotation)
+        object.rotation.set(...rotation);
+    if (scale)
+        object.scale.set(...scale);
 };

package/dist/lib/computeBitMask.d.ts

@@ -0,0 +1,5 @@
+declare type N = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
+export declare type Groups = N[];
+export declare type MembershipsAndFilter = N[];
+export declare const computeBitMask: (groups: Groups, filter: MembershipsAndFilter, memberships: MembershipsAndFilter) => number;
+export {};

package/dist/lib/computeBitMask.js

@@ -0,0 +1,20 @@
+export const computeBitMask = (groups, filter, memberships) => {
+    if (groups !== undefined) {
+        // groups is setting the filter and memberships at once
+        const g = groups;
+        const mask = g.reduce((acc, f) => {
+            return acc | (1 << f);
+        }, 0) |
+            g.reduce((acc, m) => {
+                return acc | (1 << (m + 16));
+            }, 0);
+        return mask;
+    }
+    const mask = memberships.reduce((acc, f) => {
+        return acc | (1 << f);
+    }, 0) |
+        filter.reduce((acc, m) => {
+            return acc | (1 << (m + 16));
+        }, 0);
+    return mask;
+};

package/dist/lib/createRapierContext.d.ts

@@ -14,4 +14,7 @@ export declare const createRapierContext: (gravity: RAPIER.Vector, rawIntegratio
     addRigidBodyToContext: (rigidBody: RigidBody, object: Object3D, eventDispatcher: RigidBodyEventDispatcher) => void;
     removeRigidBodyFromContext: (rigidBody: RigidBody) => void;
     debug: import("svelte/store").Writable<boolean>;
+    pause: () => void;
+    resume: () => void;
+    paused: import("svelte/store").Readable<boolean>;
 };

package/dist/lib/createRapierContext.js

@@ -1,5 +1,6 @@
 import RAPIER from '@dimforge/rapier3d-compat';
-import { writable } from 'svelte/store';
+import { currentWritable } from '@threlte/core';
+import { readable, writable } from 'svelte/store';
 export const createRapierContext = (...args) => {
     const world = new RAPIER.World(...args);
     const colliderObjects = new Map();
@@ -42,6 +43,11 @@ 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 = () => { };
     return {
         rapier: RAPIER,
         world,
@@ -54,5 +60,8 @@ export const createRapierContext = (...args) => {
         addRigidBodyToContext,
         removeRigidBodyFromContext,
         debug: writable(false),
+        pause,
+        resume,
+        paused: readable(false)
     };
 };