@threlte/rapier 0.0.2 → 0.2.0

package/dist/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @threlte/extras
 
+## 0.2.0
+
+### Minor Changes
+
+- 73b533d: Added contact force events and streamlined event management
+
+### Patch Changes
+
+- 7d46de2: sensors need events too!
+
+## 0.1.0
+
+### Minor Changes
+
+- c272617: Hooks added to add Joints, Collider and AutoColliders now accepts density, mass or massProperties, documentation for joints hooks added, "Basic Vehicle Controller" Recipe added.
+
+## 0.0.3
+
+### Patch Changes
+
+- cd6dac6: cleaned up dead code in RigidBody component
+
 ## 0.0.2
 
 ### Patch Changes

package/dist/components/Colliders/AutoColliders.svelte

@@ -1,26 +1,30 @@
 <script>import { ActiveCollisionTypes, ActiveEvents, CoefficientCombineRule } from '@dimforge/rapier3d-compat';
 import { SceneGraphObject } from '@threlte/core';
 import { createEventDispatcher, onDestroy, onMount } from 'svelte';
-import { Object3D, Vector3 } from 'three';
+import { Object3D } from 'three';
 import { useCollisionGroups } from '../../hooks/useCollisionGroups';
+import { useHasEventListeners } from '../../hooks/useHasEventListener';
 import { useRapier } from '../../hooks/useRapier';
 import { useRigidBody } from '../../hooks/useRigidBody';
+import { applyColliderActiveEvents } from '../../lib/applyColliderActiveEvents';
 import { applyTransforms } from '../../lib/applyTransforms';
 import { createCollidersFromChildren } from '../../lib/createCollidersFromChildren';
 import { positionToVector3 } from '../../lib/positionToVector3';
+import { rotationToQuaternion } from '../../lib/rotationToQuaternion';
 export let shape = 'convexHull';
 export let position = undefined;
 export let rotation = undefined;
 export let scale = undefined;
 export let lookAt = undefined;
-export let mass = undefined;
-export let centerOfMass = undefined;
-export let principalAngularInertia = undefined;
 export let restitution = undefined;
 export let restitutionCombineRule = undefined;
 export let friction = undefined;
 export let frictionCombineRule = undefined;
 export let sensor = undefined;
+export let contactForceEventThreshold = undefined;
+export let density = undefined;
+export let mass = undefined;
+export let massProperties = undefined;
 const object = new Object3D();
 /**
  * Immediately apply transforms
@@ -32,28 +36,29 @@ const { world, addColliderToContext, removeColliderFromContext } = useRapier();
 export let colliders = [];
 const collisionGroups = useCollisionGroups();
 const dispatcher = createEventDispatcher();
+const { hasEventListeners: colliderHasEventListeners } = useHasEventListeners();
 onMount(() => {
-    colliders = createCollidersFromChildren(object, shape, world, rigidBody);
+    colliders = createCollidersFromChildren(object, shape ?? 'convexHull', world, rigidBody);
     colliders.forEach((c) => addColliderToContext(c, object, dispatcher));
     collisionGroups.registerColliders(colliders);
 });
 $: {
     if (colliders.length > 0) {
         colliders.forEach((collider) => {
-            collider.setActiveEvents(ActiveEvents.COLLISION_EVENTS);
+            applyColliderActiveEvents(collider, colliderHasEventListeners, rigidBody?.userData?.hasEventListeners);
             collider.setActiveCollisionTypes(ActiveCollisionTypes.ALL);
             collider.setRestitution(restitution ?? 0);
             collider.setRestitutionCombineRule(restitutionCombineRule ?? CoefficientCombineRule.Average);
             collider.setFriction(friction ?? 0.7);
             collider.setFrictionCombineRule(frictionCombineRule ?? CoefficientCombineRule.Average);
             collider.setSensor(sensor ?? false);
-            const { x: cmx, y: cmy, z: cmz } = positionToVector3(centerOfMass) || new Vector3();
-            const { x: pix, y: piy, z: piz } = positionToVector3(principalAngularInertia) ||
-                new Vector3(mass ?? 1 * 0.2, mass ?? 1 * 0.2, mass ?? 1 * 0.2);
-            if (mass || centerOfMass || principalAngularInertia) {
-                collider.setDensity(0);
-                collider.setMassProperties(mass ?? 1, { x: cmx, y: cmy, z: cmz }, { x: pix, y: piy, z: piz }, { x: 0, y: 0, z: 0, w: 1 });
-            }
+            collider.setContactForceEventThreshold(contactForceEventThreshold ?? 0);
+            if (density)
+                collider.setDensity(density);
+            if (mass)
+                collider.setMass(mass);
+            if (massProperties)
+                collider.setMassProperties(massProperties.mass, positionToVector3(massProperties.centerOfMass), positionToVector3(massProperties.principalAngularInertia), rotationToQuaternion(massProperties.angularInertiaLocalFrame));
         });
     }
 }

package/dist/components/Colliders/Collider.svelte

@@ -1,13 +1,16 @@
 <script>import { ActiveCollisionTypes, ActiveEvents, CoefficientCombineRule, Collider, ColliderDesc } from '@dimforge/rapier3d-compat';
 import { SceneGraphObject, TransformableObject, useFrame } from '@threlte/core';
-import { createEventDispatcher, onDestroy, onMount } from 'svelte';
+import { createEventDispatcher, onDestroy, onMount, tick } from 'svelte';
 import { Object3D, Quaternion, Vector3 } from 'three';
 import { useCollisionGroups } from '../../hooks/useCollisionGroups';
+import { useHasEventListeners } from '../../hooks/useHasEventListener';
 import { useRapier } from '../../hooks/useRapier';
 import { useRigidBody } from '../../hooks/useRigidBody';
+import { applyColliderActiveEvents } from '../../lib/applyColliderActiveEvents';
 import { applyTransforms } from '../../lib/applyTransforms';
 import { getWorldPosition, getWorldQuaternion } from '../../lib/getWorldTransforms';
 import { positionToVector3 } from '../../lib/positionToVector3';
+import { rotationToQuaternion } from '../../lib/rotationToQuaternion';
 import { scaleColliderArgs } from '../../lib/scaleColliderArgs';
 export let shape;
 export let args;
@@ -15,14 +18,15 @@ export let position = undefined;
 export let rotation = undefined;
 export let scale = undefined;
 export let lookAt = undefined;
-export let mass = undefined;
-export let centerOfMass = undefined;
-export let principalAngularInertia = undefined;
 export let restitution = undefined;
 export let restitutionCombineRule = undefined;
 export let friction = undefined;
 export let frictionCombineRule = undefined;
 export let sensor = undefined;
+export let contactForceEventThreshold = undefined;
+export let density = undefined;
+export let mass = undefined;
+export let massProperties = undefined;
 const object = new Object3D();
 /**
  * Immediately apply transforms
@@ -40,7 +44,8 @@ const dispatcher = createEventDispatcher();
  * Actual collider setup happens onMount as only then
  * the transforms are finished.
  */
-onMount(() => {
+onMount(async () => {
+    await tick();
     const scale = object.getWorldScale(new Vector3());
     const scaledArgs = scaleColliderArgs(shape, args, scale);
     // @ts-ignore
@@ -64,30 +69,36 @@ onMount(() => {
                 rigidBodyWorldQuatInversed.invert();
             }
         });
-        collider.setTranslationWrtParent(object.getWorldPosition(new Vector3()).sub(rigidBodyWorldPos));
-        collider.setRotationWrtParent(object.getWorldQuaternion(new Quaternion()).premultiply(rigidBodyWorldQuatInversed));
+        const worldPosition = object.getWorldPosition(new Vector3()).sub(rigidBodyWorldPos);
+        const worldRotation = object
+            .getWorldQuaternion(new Quaternion())
+            .premultiply(rigidBodyWorldQuatInversed);
+        collider.setTranslationWrtParent(worldPosition);
+        collider.setRotationWrtParent(worldRotation);
     }
     else {
         collider.setTranslation(object.getWorldPosition(new Vector3()));
         collider.setRotation(object.getWorldQuaternion(new Quaternion()));
     }
 });
+const { hasEventListeners: colliderHasEventListeners } = useHasEventListeners();
 $: {
     if (collider) {
-        collider.setActiveEvents(ActiveEvents.COLLISION_EVENTS);
+        applyColliderActiveEvents(collider, colliderHasEventListeners, rigidBody?.userData?.hasEventListeners);
         collider.setActiveCollisionTypes(ActiveCollisionTypes.ALL);
         collider.setRestitution(restitution ?? 0);
+        collider.setContactForceEventThreshold(1);
         collider.setRestitutionCombineRule(restitutionCombineRule ?? CoefficientCombineRule.Average);
         collider.setFriction(friction ?? 0.7);
         collider.setFrictionCombineRule(frictionCombineRule ?? CoefficientCombineRule.Average);
         collider.setSensor(sensor ?? false);
-        const { x: cmx, y: cmy, z: cmz } = positionToVector3(centerOfMass) || new Vector3();
-        const { x: pix, y: piy, z: piz } = positionToVector3(principalAngularInertia) ||
-            new Vector3(mass ?? 1 * 0.2, mass ?? 1 * 0.2, mass ?? 1 * 0.2);
-        if (mass || centerOfMass || principalAngularInertia) {
-            collider.setDensity(0);
-            collider.setMassProperties(mass ?? 1, { x: cmx, y: cmy, z: cmz }, { x: pix, y: piy, z: piz }, { x: 0, y: 0, z: 0, w: 1 });
-        }
+        collider.setContactForceEventThreshold(contactForceEventThreshold ?? 0);
+        if (density)
+            collider.setDensity(density);
+        if (mass)
+            collider.setMass(mass);
+        if (massProperties)
+            collider.setMassProperties(massProperties.mass, positionToVector3(massProperties.centerOfMass), positionToVector3(massProperties.principalAngularInertia), rotationToQuaternion(massProperties.angularInertiaLocalFrame));
     }
 }
 useFrame(() => {

package/dist/components/Colliders/Collider.svelte.d.ts

@@ -1,32 +1,116 @@
 import { SvelteComponentTyped } from "svelte";
-import { CoefficientCombineRule, Collider, ColliderDesc } from '@dimforge/rapier3d-compat';
-import type { ColliderEventMap } from '../../types/types';
-declare class __sveltets_Render<Shape extends 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh', Args extends Parameters<typeof ColliderDesc[Shape]>> {
+import { CoefficientCombineRule, Collider, ColliderDesc, type RigidBody } from '@dimforge/rapier3d-compat';
+import { type Position, type Rotation } from '@threlte/core';
+declare class __sveltets_Render<Shape extends 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh', Args extends Parameters<typeof ColliderDesc[Shape]>, Density extends number | undefined, Mass extends Density extends undefined ? number | undefined : undefined, MassProperties extends Density extends undefined ? Mass extends undefined ? {
+    mass: number;
+    centerOfMass: Position;
+    principalAngularInertia: Position;
+    angularInertiaLocalFrame: Rotation;
+} : undefined : undefined> {
     props(): {
         shape: Shape;
         args: Args;
-        position?: import("@threlte/core").Position | undefined;
-        rotation?: import("@threlte/core").Rotation | undefined;
+        position?: Position | undefined;
+        rotation?: Rotation | undefined;
         scale?: import("@threlte/core").Scale | undefined;
         lookAt?: import("@threlte/core").LookAt | undefined;
-        mass?: number | undefined;
-        centerOfMass?: import("@threlte/core").Position | undefined;
-        principalAngularInertia?: import("@threlte/core").Position | undefined;
         restitution?: number | undefined;
         restitutionCombineRule?: CoefficientCombineRule | undefined;
         friction?: number | undefined;
         frictionCombineRule?: CoefficientCombineRule | undefined;
         sensor?: boolean | undefined;
         collider?: Collider | undefined;
+        contactForceEventThreshold?: number | undefined;
+        density?: Density | undefined;
+    } | {
+        shape: Shape;
+        args: Args;
+        position?: Position | undefined;
+        rotation?: Rotation | undefined;
+        scale?: import("@threlte/core").Scale | undefined;
+        lookAt?: import("@threlte/core").LookAt | undefined;
+        restitution?: number | undefined;
+        restitutionCombineRule?: CoefficientCombineRule | undefined;
+        friction?: number | undefined;
+        frictionCombineRule?: CoefficientCombineRule | undefined;
+        sensor?: boolean | undefined;
+        collider?: Collider | undefined;
+        contactForceEventThreshold?: number | undefined;
+        mass?: Mass | undefined;
+    } | {
+        shape: Shape;
+        args: Args;
+        position?: Position | undefined;
+        rotation?: Rotation | undefined;
+        scale?: import("@threlte/core").Scale | undefined;
+        lookAt?: import("@threlte/core").LookAt | undefined;
+        restitution?: number | undefined;
+        restitutionCombineRule?: CoefficientCombineRule | undefined;
+        friction?: number | undefined;
+        frictionCombineRule?: CoefficientCombineRule | undefined;
+        sensor?: boolean | undefined;
+        collider?: Collider | undefined;
+        contactForceEventThreshold?: number | undefined;
+        mass?: Mass | undefined;
+        massProperties?: MassProperties | undefined;
+    };
+    events(): {
+        collisionenter: CustomEvent<{
+            targetCollider: Collider;
+            targetRigidBody: RigidBody | null;
+            manifold: import("@dimforge/rapier3d-compat").TempContactManifold;
+            flipped: boolean;
+        }>;
+        collisionexit: CustomEvent<{
+            targetCollider: Collider;
+            targetRigidBody: RigidBody | null;
+        }>;
+        sensorenter: CustomEvent<{
+            targetCollider: Collider;
+            targetRigidBody: RigidBody | null;
+        }>;
+        sensorexit: CustomEvent<{
+            targetCollider: Collider;
+            targetRigidBody: RigidBody | null;
+        }>;
+        contact: CustomEvent<{
+            targetCollider: Collider;
+            targetRigidBody: RigidBody | null;
+            manifold: import("@dimforge/rapier3d-compat").TempContactManifold;
+            flipped: boolean;
+            maxForceDirection: import("@dimforge/rapier3d-compat").Vector;
+            maxForceMagnitude: number;
+            totalForce: import("@dimforge/rapier3d-compat").Vector;
+            totalForceMagnitude: number;
+        }>;
     };
-    events(): ColliderEventMap;
     slots(): {
         default: {};
     };
 }
-export declare type ColliderProps<Shape extends 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh', Args extends Parameters<typeof ColliderDesc[Shape]>> = ReturnType<__sveltets_Render<Shape, Args>['props']>;
-export declare type ColliderEvents<Shape extends 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh', Args extends Parameters<typeof ColliderDesc[Shape]>> = ReturnType<__sveltets_Render<Shape, Args>['events']>;
-export declare type ColliderSlots<Shape extends 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh', Args extends Parameters<typeof ColliderDesc[Shape]>> = ReturnType<__sveltets_Render<Shape, Args>['slots']>;
-export default class Collider<Shape extends 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh', Args extends Parameters<typeof ColliderDesc[Shape]>> extends SvelteComponentTyped<ColliderProps<Shape, Args>, ColliderEvents<Shape, Args>, ColliderSlots<Shape, Args>> {
+export declare type ColliderProps<Shape extends 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh', Args extends Parameters<typeof ColliderDesc[Shape]>, Density extends number | undefined, Mass extends Density extends undefined ? number | undefined : undefined, MassProperties extends Density extends undefined ? Mass extends undefined ? {
+    mass: number;
+    centerOfMass: Position;
+    principalAngularInertia: Position;
+    angularInertiaLocalFrame: Rotation;
+} : undefined : undefined> = ReturnType<__sveltets_Render<Shape, Args, Density, Mass, MassProperties>['props']>;
+export declare type ColliderEvents<Shape extends 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh', Args extends Parameters<typeof ColliderDesc[Shape]>, Density extends number | undefined, Mass extends Density extends undefined ? number | undefined : undefined, MassProperties extends Density extends undefined ? Mass extends undefined ? {
+    mass: number;
+    centerOfMass: Position;
+    principalAngularInertia: Position;
+    angularInertiaLocalFrame: Rotation;
+} : undefined : undefined> = ReturnType<__sveltets_Render<Shape, Args, Density, Mass, MassProperties>['events']>;
+export declare type ColliderSlots<Shape extends 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh', Args extends Parameters<typeof ColliderDesc[Shape]>, Density extends number | undefined, Mass extends Density extends undefined ? number | undefined : undefined, MassProperties extends Density extends undefined ? Mass extends undefined ? {
+    mass: number;
+    centerOfMass: Position;
+    principalAngularInertia: Position;
+    angularInertiaLocalFrame: Rotation;
+} : undefined : undefined> = ReturnType<__sveltets_Render<Shape, Args, Density, Mass, MassProperties>['slots']>;
+export default class Collider<Shape extends 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh', Args extends Parameters<typeof ColliderDesc[Shape]>, Density extends number | undefined, Mass extends Density extends undefined ? number | undefined : undefined, MassProperties extends Density extends undefined ? Mass extends undefined ? {
+    mass: number;
+    centerOfMass: Position;
+    principalAngularInertia: Position;
+    angularInertiaLocalFrame: Rotation;
+} : undefined : undefined> extends SvelteComponentTyped<ColliderProps<Shape, Args, Density, Mass, MassProperties>, ColliderEvents<Shape, Args, Density, Mass, MassProperties>, ColliderSlots<Shape, Args, Density, Mass, MassProperties>> {
 }
 export {};

package/dist/components/Joints/RevoluteJoint.svelte

@@ -0,0 +1,5 @@
+<script>import { useRevoluteJoint } from '../../hooks/useRevoluteJoint';
+export const { joint, rigidBodyA, rigidBodyB } = useRevoluteJoint();
+</script>
+
+<slot {rigidBodyA} {rigidBodyB} />

package/dist/components/Joints/RevoluteJoint.svelte.d.ts

@@ -0,0 +1,23 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        joint?: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RevoluteImpulseJoint> | undefined;
+        rigidBodyA?: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined> | undefined;
+        rigidBodyB?: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined> | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {
+            rigidBodyA: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+            rigidBodyB: import("svelte/store").Writable<import("@dimforge/rapier3d-compat").RigidBody | undefined>;
+        };
+    };
+};
+export declare type RevoluteJointProps = typeof __propDef.props;
+export declare type RevoluteJointEvents = typeof __propDef.events;
+export declare type RevoluteJointSlots = typeof __propDef.slots;
+export default class RevoluteJoint extends SvelteComponentTyped<RevoluteJointProps, RevoluteJointEvents, RevoluteJointSlots> {
+}
+export {};

package/dist/components/RigidBody/RigidBody.svelte

@@ -1,6 +1,7 @@
 <script>import { LayerableObject, SceneGraphObject } from '@threlte/core';
 import { createEventDispatcher, onDestroy, setContext, tick } from 'svelte';
 import { Object3D, Vector3 } from 'three';
+import { useHasEventListeners } from '../../hooks/useHasEventListener';
 import { useRapier } from '../../hooks/useRapier';
 import { applyTransforms } from '../../lib/applyTransforms';
 import { getWorldPosition, getWorldQuaternion, getWorldScale } from '../../lib/getWorldTransforms';
@@ -8,6 +9,7 @@ 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 type = 'dynamic';
 export let canSleep = true;
 export let linearVelocity = {};
@@ -53,17 +55,18 @@ applyTransforms(object, position, rotation, scale, lookAt);
  * the world position to the RigidBody
  */
 object.updateWorldMatrix(true, false);
-const worldPosition = getWorldPosition(object);
-const worldRotation = getWorldQuaternion(object);
-const parentWorldScale = object.parent?.getWorldScale(new Vector3()) || new Vector3(1, 1, 1);
 /**
  * RigidBody Description
  */
 const desc = new rapier.RigidBodyDesc(parseRigidBodyType(type)).setCanSleep(canSleep);
 /**
- * RigidBody init
+ * Export the rigidBody only after positional initialization
  */
-export const rigidBody = world.createRigidBody(desc);
+export let rigidBody = undefined;
+/**
+ * Temporary RigidBody init
+ */
+const rigidBodyTemp = world.createRigidBody(desc);
 /**
  * Apply transforms after the parent component added "object" to itself
  */
@@ -75,44 +78,58 @@ const initPosition = async () => {
     const parentWorldScale = object.parent ? getWorldScale(object.parent) : new Vector3(1, 1, 1);
     const worldPosition = getWorldPosition(object).multiply(parentWorldScale);
     const worldQuaternion = getWorldQuaternion(object);
-    rigidBody.setTranslation(worldPosition, true);
-    rigidBody.setRotation(worldQuaternion, true);
+    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();
 /**
  * Will come in handy in the future for joints
  */
-object.userData.rigidBody = rigidBody;
+object.userData.rigidBody = rigidBodyTemp;
 /**
  * Reactive RigidBody properties
  */
 $: {
-    rigidBody.setBodyType(parseRigidBodyType(type));
-    rigidBody.setLinvel(positionToVector3(linearVelocity), true);
-    rigidBody.setAngvel(rotationToEuler(angularVelocity), true);
-    rigidBody.setGravityScale(gravityScale, true);
-    rigidBody.enableCcd(ccd);
-    rigidBody.setDominanceGroup(dominance);
-    rigidBody.lockRotations(lockRotations, true);
-    rigidBody.lockTranslations(lockTranslations, true);
-    rigidBody.setEnabledRotations(...enabledRotations, true);
-    rigidBody.setEnabledTranslations(...enabledTranslations, true);
+    rigidBodyTemp.setBodyType(parseRigidBodyType(type));
+    rigidBodyTemp.setLinvel(positionToVector3(linearVelocity), true);
+    rigidBodyTemp.setAngvel(rotationToEuler(angularVelocity), true);
+    rigidBodyTemp.setGravityScale(gravityScale, true);
+    rigidBodyTemp.enableCcd(ccd);
+    rigidBodyTemp.setDominanceGroup(dominance);
+    rigidBodyTemp.lockRotations(lockRotations, true);
+    rigidBodyTemp.lockTranslations(lockTranslations, true);
+    rigidBodyTemp.setEnabledRotations(...enabledRotations, true);
+    rigidBodyTemp.setEnabledTranslations(...enabledTranslations, true);
 }
+/**
+ * Add userData to the rigidBody
+ */
+const { hasEventListeners } = useHasEventListeners();
+rigidBodyTemp.userData = {
+    hasEventListeners
+};
 /**
  * Setting the RigidBody context so that colliders can
  * hook onto.
  */
-setContext('threlte-rapier-rigidbody', rigidBody);
+setContext('threlte-rapier-rigidbody', rigidBodyTemp);
 /**
  * Add the mesh to the context
  */
-addRigidBodyToContext(rigidBody, object, dispatcher);
+addRigidBodyToContext(rigidBodyTemp, object, dispatcher);
 /**
  * cleanup
  */
 onDestroy(() => {
-    removeRigidBodyFromContext(rigidBody);
-    world.removeRigidBody(rigidBody);
+    removeRigidBodyFromContext(rigidBodyTemp);
+    world.removeRigidBody(rigidBodyTemp);
 });
 </script>
 

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

@@ -1,8 +1,9 @@
 import { SvelteComponentTyped } from "svelte";
+import type { RigidBody } from '@dimforge/rapier3d-compat';
 import type { RigidBodyProperties } from '../../types/components';
-import type { RigidBodyEventMap } from '../../types/types';
 declare const __propDef: {
     props: {
+        debug?: boolean | undefined;
         type?: import("../../lib/parseRigidBodyType").RigidBodyTypeString | undefined;
         canSleep?: boolean | undefined;
         linearVelocity?: import("@threlte/core").Position | undefined;
@@ -19,21 +20,49 @@ declare const __propDef: {
         enabledTranslations?: import("../../types/components").Boolean3Array | undefined;
         dominance?: number | undefined;
         /**
-           * RigidBody init
-           */ rigidBody?: import("@dimforge/rapier3d-compat").RigidBody | undefined;
+           * Export the rigidBody only after positional initialization
+           */ rigidBody?: RigidBody | undefined;
     };
     slots: {
         default: {};
     };
-    getters: {
-        rigidBody: import("@dimforge/rapier3d-compat").RigidBody;
+    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;
+            manifold: import("@dimforge/rapier3d-compat").TempContactManifold;
+            flipped: boolean;
+            maxForceDirection: import("@dimforge/rapier3d-compat").Vector;
+            maxForceMagnitude: number;
+            totalForce: import("@dimforge/rapier3d-compat").Vector;
+            totalForceMagnitude: number;
+        }>;
+        sleep: CustomEvent<void>;
+        wake: CustomEvent<void>;
     };
-    events: RigidBodyEventMap;
 };
 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> {
-    get rigidBody(): import("@dimforge/rapier3d-compat").RigidBody;
 }
 export {};

package/dist/hooks/useFixedJoint.d.ts

@@ -0,0 +1,7 @@
+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) => {
+    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

@@ -0,0 +1,10 @@
+import { positionToVector3 } from '../lib/positionToVector3';
+import { rotationToQuaternion } from '../lib/rotationToQuaternion';
+import { useJoint } from './useJoint';
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export const useFixedJoint = (anchorA, frameA, anchorB, frameB) => {
+    return useJoint((rbA, rbB, { world, rapier }) => {
+        const params = rapier.JointData.fixed(positionToVector3(anchorA), rotationToQuaternion(frameA), positionToVector3(anchorB), rotationToQuaternion(frameB));
+        return world.createImpulseJoint(params, rbA, rbB, true);
+    });
+};

package/dist/hooks/useFrameHandler.js

@@ -1,9 +1,27 @@
-import { EventQueue } from '@dimforge/rapier3d-compat';
+import { Collider, EventQueue } from '@dimforge/rapier3d-compat';
 import { useFrame } from '@threlte/core';
 import { Object3D, Quaternion, Vector3 } from 'three';
 const tempObject = new Object3D();
 const tempVector3 = new Vector3();
 const tempQuaternion = new Quaternion();
+const getEventDispatchers = (ctx, collider1, collider2) => {
+    const colliderDispatcher1 = ctx.colliderEventDispatchers.get(collider1.handle);
+    const colliderDispatcher2 = ctx.colliderEventDispatchers.get(collider2.handle);
+    const rigidBody1 = collider1.parent();
+    const rigidBody2 = collider2.parent();
+    const rigidBodyDispatcher1 = rigidBody1
+        ? ctx.rigidBodyEventDispatchers.get(rigidBody1.handle)
+        : undefined;
+    const rigidBodyDispatcher2 = rigidBody2
+        ? ctx.rigidBodyEventDispatchers.get(rigidBody2.handle)
+        : undefined;
+    return {
+        colliderDispatcher1,
+        colliderDispatcher2,
+        rigidBodyDispatcher1,
+        rigidBodyDispatcher2
+    };
+};
 export const useFrameHandler = (ctx) => {
     const eventQueue = new EventQueue(false);
     let time = performance.now();
@@ -52,6 +70,61 @@ export const useFrameHandler = (ctx) => {
             mesh.position.setFromMatrixPosition(tempObject.matrix);
             mesh.rotation.setFromRotationMatrix(tempObject.matrix);
         });
+        eventQueue.drainContactForceEvents((e) => {
+            const collider1 = world.getCollider(e.collider1());
+            const collider2 = world.getCollider(e.collider2());
+            // Sanity check
+            if (!collider1 || !collider2) {
+                return;
+            }
+            const { colliderDispatcher1, colliderDispatcher2, rigidBodyDispatcher1, rigidBodyDispatcher2 } = getEventDispatchers(ctx, collider1, collider2);
+            const rigidBody1 = collider1.parent();
+            const rigidBody2 = collider2.parent();
+            world.contactPair(collider1, collider2, (manifold, flipped) => {
+                // Collider events
+                colliderDispatcher1?.('contact', {
+                    flipped,
+                    manifold,
+                    targetCollider: collider2,
+                    targetRigidBody: rigidBody2,
+                    maxForceDirection: e.maxForceDirection(),
+                    maxForceMagnitude: e.maxForceMagnitude(),
+                    totalForce: e.totalForce(),
+                    totalForceMagnitude: e.totalForceMagnitude()
+                });
+                colliderDispatcher2?.('contact', {
+                    flipped,
+                    manifold,
+                    targetCollider: collider1,
+                    targetRigidBody: rigidBody1,
+                    maxForceDirection: e.maxForceDirection(),
+                    maxForceMagnitude: e.maxForceMagnitude(),
+                    totalForce: e.totalForce(),
+                    totalForceMagnitude: e.totalForceMagnitude()
+                });
+                // RigidBody Events
+                rigidBodyDispatcher1?.('contact', {
+                    flipped,
+                    manifold,
+                    targetCollider: collider2,
+                    targetRigidBody: rigidBody2,
+                    maxForceDirection: e.maxForceDirection(),
+                    maxForceMagnitude: e.maxForceMagnitude(),
+                    totalForce: e.totalForce(),
+                    totalForceMagnitude: e.totalForceMagnitude()
+                });
+                rigidBodyDispatcher2?.('contact', {
+                    flipped,
+                    manifold,
+                    targetCollider: collider1,
+                    targetRigidBody: rigidBody1,
+                    maxForceDirection: e.maxForceDirection(),
+                    maxForceMagnitude: e.maxForceMagnitude(),
+                    totalForce: e.totalForce(),
+                    totalForceMagnitude: e.totalForceMagnitude()
+                });
+            });
+        });
         // Collision events
         eventQueue.drainCollisionEvents((handle1, handle2, started) => {
             const collider1 = world.getCollider(handle1);
@@ -60,16 +133,9 @@ export const useFrameHandler = (ctx) => {
             if (!collider1 || !collider2) {
                 return;
             }
-            const colliderDispatcher1 = ctx.colliderEventDispatchers.get(collider1.handle);
-            const colliderDispatcher2 = ctx.colliderEventDispatchers.get(collider2.handle);
+            const { colliderDispatcher1, colliderDispatcher2, rigidBodyDispatcher1, rigidBodyDispatcher2 } = getEventDispatchers(ctx, collider1, collider2);
             const rigidBody1 = collider1.parent();
             const rigidBody2 = collider2.parent();
-            const rigidBodyDispatcher1 = rigidBody1
-                ? ctx.rigidBodyEventDispatchers.get(rigidBody1.handle)
-                : undefined;
-            const rigidBodyDispatcher2 = rigidBody2
-                ? ctx.rigidBodyEventDispatchers.get(rigidBody2.handle)
-                : undefined;
             if (started) {
                 // intersections are triggered by sensors
                 const isIntersection = world.intersectionPair(collider1, collider2);

package/dist/hooks/useHasEventListener.d.ts

@@ -0,0 +1,3 @@
+export declare const useHasEventListeners: <T extends (type: any) => any = any>() => {
+    hasEventListeners: (type: Parameters<T>[0]) => boolean;
+};

package/dist/hooks/useHasEventListener.js

@@ -0,0 +1,11 @@
+import { get_current_component } from 'svelte/internal';
+export const useHasEventListeners = () => {
+    const component = get_current_component();
+    const hasEventListeners = (type) => {
+        const callbacks = component.$$.callbacks;
+        return type in callbacks && callbacks[type].length > 0;
+    };
+    return {
+        hasEventListeners
+    };
+};

package/dist/hooks/useJoint.d.ts

@@ -0,0 +1,7 @@
+import type { ImpulseJoint, RigidBody } from '@dimforge/rapier3d-compat';
+import type { RapierContext } from '../types/types';
+export declare const useJoint: <T extends ImpulseJoint>(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/useJoint.js

@@ -0,0 +1,31 @@
+import { onDestroy } from 'svelte';
+import { derived, get, writable } from 'svelte/store';
+import { useRapier } from './useRapier';
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export const useJoint = (initializeJoint) => {
+    const rigidBodyA = writable(undefined);
+    const rigidBodyB = writable(undefined);
+    const ctx = useRapier();
+    const bodies = derived([rigidBodyA, rigidBodyB], ([rbA, rbB]) => {
+        if (!!rbA && !!rbB) {
+            return [rbA, rbB];
+        }
+    });
+    const joint = writable(undefined);
+    const unsubscribeBodies = bodies.subscribe((bodies) => {
+        if (bodies)
+            joint.set(initializeJoint(...bodies, ctx));
+    });
+    onDestroy(() => {
+        unsubscribeBodies();
+        const j = get(joint);
+        if (!j)
+            return;
+        ctx.world.removeImpulseJoint(j, true);
+    });
+    return {
+        joint,
+        rigidBodyA,
+        rigidBodyB
+    };
+};

package/dist/hooks/usePrismaticJoint.d.ts

@@ -0,0 +1,7 @@
+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]) => {
+    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

@@ -0,0 +1,13 @@
+import { positionToVector3 } from '../lib/positionToVector3';
+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());
+        if (limits) {
+            params.limitsEnabled = true;
+            params.limits = limits;
+        }
+        return world.createImpulseJoint(params, rbA, rbB, true);
+    });
+};

package/dist/hooks/useRevoluteJoint.d.ts

@@ -0,0 +1,7 @@
+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]) => {
+    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

@@ -0,0 +1,13 @@
+import { positionToVector3 } from '../lib/positionToVector3';
+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());
+        if (limits) {
+            params.limitsEnabled = true;
+            params.limits = limits;
+        }
+        return world.createImpulseJoint(params, rbA, rbB, true);
+    });
+};

package/dist/hooks/useRigidBody.d.ts

@@ -1,2 +1,2 @@
 import type { RigidBodyContext } from '../types/types';
-export declare const useRigidBody: () => RigidBodyContext;
+export declare const useRigidBody: () => RigidBodyContext | undefined;

package/dist/hooks/useSphericalJoint.d.ts

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

@@ -0,0 +1,11 @@
+import { navigating } from '$app/stores';
+import { positionToVector3 } from '../lib/positionToVector3';
+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));
+        return world.createImpulseJoint(params, rbA, rbB, true);
+    });
+};
+navigating;

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 export { useRapier } from './hooks/useRapier';
 export { useCollisionGroups } from './hooks/useCollisionGroups';
 export { useRigidBody } from './hooks/useRigidBody';
+export { useRevoluteJoint } from './hooks/useRevoluteJoint';
+export { usePrismaticJoint } from './hooks/usePrismaticJoint';
+export { useFixedJoint } from './hooks/useFixedJoint';
+export { useSphericalJoint } from './hooks/useSphericalJoint';
 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';
@@ -8,5 +12,5 @@ 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 BasicPlayerController } from './recipes/BasicPlayerController.svelte';
-export type { AutoCollidersProperties, ColliderProperties, Boolean3Array, RigidBodyProperties, WorldProperties } from './types/components';
+export type { AutoCollidersProperties, Boolean3Array, RigidBodyProperties, WorldProperties } from './types/components';
 export type { CollisionGroupsBitMask, AutoCollidersShapes, ColliderEventDispatcher, ColliderShapes, RapierContext, RigidBodyEventDispatcher } from './types/types';

package/dist/index.js

@@ -2,6 +2,11 @@
 export { useRapier } from './hooks/useRapier';
 export { useCollisionGroups } from './hooks/useCollisionGroups';
 export { useRigidBody } from './hooks/useRigidBody';
+// Joints
+export { useRevoluteJoint } from './hooks/useRevoluteJoint';
+export { usePrismaticJoint } from './hooks/usePrismaticJoint';
+export { useFixedJoint } from './hooks/useFixedJoint';
+export { useSphericalJoint } from './hooks/useSphericalJoint';
 // components
 export { default as World } from './components/World/World.svelte';
 export { default as RigidBody } from './components/RigidBody/RigidBody.svelte';

package/dist/lib/applyColliderActiveEvents.d.ts

@@ -0,0 +1,4 @@
+import { type Collider } from '@dimforge/rapier3d-compat';
+import type { useHasEventListeners } from '../hooks/useHasEventListener';
+import type { ColliderEventDispatcher, RigidBodyEventDispatcher } from '../types/types';
+export declare const applyColliderActiveEvents: (collider: Collider, colliderHasEventListeners: ReturnType<typeof useHasEventListeners<ColliderEventDispatcher>>['hasEventListeners'], rigidBodyHasEventListeners?: ReturnType<typeof useHasEventListeners<RigidBodyEventDispatcher>>['hasEventListeners']) => void;

package/dist/lib/applyColliderActiveEvents.js

@@ -0,0 +1,20 @@
+import { ActiveEvents } from '@dimforge/rapier3d-compat';
+export const applyColliderActiveEvents = (collider, colliderHasEventListeners, rigidBodyHasEventListeners) => {
+    let events = 0;
+    if (colliderHasEventListeners('collisionenter') ||
+        colliderHasEventListeners('collisionexit') ||
+        rigidBodyHasEventListeners?.('collisionenter') ||
+        rigidBodyHasEventListeners?.('collisionexit') ||
+        colliderHasEventListeners('sensorenter') ||
+        colliderHasEventListeners('sensorexit') ||
+        rigidBodyHasEventListeners?.('sensorenter') ||
+        rigidBodyHasEventListeners?.('sensorexit')) {
+        events = events | ActiveEvents.COLLISION_EVENTS;
+    }
+    if (colliderHasEventListeners('contact') || rigidBodyHasEventListeners?.('contact')) {
+        events = events | ActiveEvents.CONTACT_FORCE_EVENTS;
+    }
+    if (events > 0) {
+        collider.setActiveEvents(events);
+    }
+};

package/dist/types/components.d.ts

@@ -72,6 +72,7 @@ export declare type ColliderProperties<Shape extends ColliderShapes> = Omit<Tran
      * More info https://rapier.rs/docs/user_guides/javascript/colliders#mass-properties
      */
     mass?: number;
+    density?: number;
     /**
      * The center of mass of this rigid body
      */

package/dist/types/types.d.ts

@@ -1,7 +1,8 @@
 import type { createEventDispatcher } from 'svelte';
-import type { RigidBody, RigidBodyHandle, TempContactManifold, ColliderHandle, Collider } from '@dimforge/rapier3d-compat';
+import type { RigidBody, RigidBodyHandle, TempContactManifold, ColliderHandle, Collider, Vector } from '@dimforge/rapier3d-compat';
 import type { createRapierContext } from '../lib/createRapierContext';
 import type { Writable } from 'svelte/store';
+import type { useHasEventListeners } from '../hooks/useHasEventListener';
 export declare type ColliderShapes = 'ball' | 'capsule' | 'segment' | 'triangle' | 'roundTriangle' | 'polyline' | 'trimesh' | 'cuboid' | 'roundCuboid' | 'heightfield' | 'cylinder' | 'roundCylinder' | 'cone' | 'roundCone' | 'convexHull' | 'convexMesh' | 'roundConvexHull' | 'roundConvexMesh';
 export declare type AutoCollidersShapes = 'cuboid' | 'ball' | 'trimesh' | 'convexHull' | 'capsule';
 export declare type ColliderEventMap = {
@@ -23,6 +24,16 @@ export declare type ColliderEventMap = {
         targetCollider: Collider;
         targetRigidBody: RigidBody | null;
     };
+    contact: {
+        targetCollider: Collider;
+        targetRigidBody: RigidBody | null;
+        manifold: TempContactManifold;
+        flipped: boolean;
+        maxForceDirection: Vector;
+        maxForceMagnitude: number;
+        totalForce: Vector;
+        totalForceMagnitude: number;
+    };
 };
 export declare type RigidBodyEventMap = ColliderEventMap & {
     sleep: void;
@@ -34,5 +45,11 @@ export declare type RigidBodyEventDispatchers = Map<RigidBodyHandle, RigidBodyEv
 export declare type ColliderEventDispatchers = Map<ColliderHandle, ColliderEventDispatcher>;
 export declare type RapierContext = ReturnType<typeof createRapierContext>;
 export declare type CollisionGroupsContext = Writable<number> | undefined;
-export declare type RigidBodyContext = RigidBody;
+export declare type RigidBodyUserData = {
+    hasEventListeners?: ReturnType<typeof useHasEventListeners<RigidBodyEventDispatcher>>['hasEventListeners'];
+};
+export declare type ThrelteRigidBody = RigidBody & {
+    userData?: RigidBodyUserData;
+};
+export declare type RigidBodyContext = ThrelteRigidBody;
 export declare type CollisionGroupsBitMask = (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15)[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@threlte/rapier",
-  "version": "0.0.2",
+  "version": "0.2.0",
   "author": "Grischa Erbe <hello@legrisch.com> (https://legrisch.com)",
   "license": "MIT",
   "devDependencies": {
@@ -8,7 +8,7 @@
     "@sveltejs/adapter-auto": "next",
     "@sveltejs/adapter-static": "^1.0.0-next.29",
     "@sveltejs/kit": "next",
-    "@threlte/core": "4.2.0",
+    "@threlte/core": "4.3.2",
     "@types/node": "^18.0.3",
     "@types/three": "^0.140.0",
     "@typescript-eslint/eslint-plugin": "^4.31.1",

package/dist/components/Colliders/AutoColliders.svelte.d.ts

@@ -1,33 +0,0 @@
-import { SvelteComponentTyped } from "svelte";
-import { type Collider } from '@dimforge/rapier3d-compat';
-import type { AutoCollidersProperties } from '../../types/components';
-import type { ColliderEventMap } from '../../types/types';
-declare const __propDef: {
-    props: {
-        shape?: import("../../types/types").AutoCollidersShapes | undefined;
-        position?: AutoCollidersProperties['position'];
-        rotation?: AutoCollidersProperties['rotation'];
-        scale?: AutoCollidersProperties['scale'];
-        lookAt?: AutoCollidersProperties['lookAt'];
-        mass?: AutoCollidersProperties['mass'];
-        centerOfMass?: AutoCollidersProperties['centerOfMass'];
-        principalAngularInertia?: AutoCollidersProperties['principalAngularInertia'];
-        restitution?: AutoCollidersProperties['restitution'];
-        restitutionCombineRule?: AutoCollidersProperties['restitutionCombineRule'];
-        friction?: AutoCollidersProperties['friction'];
-        frictionCombineRule?: AutoCollidersProperties['frictionCombineRule'];
-        sensor?: AutoCollidersProperties['sensor'];
-        colliders?: Collider[] | undefined;
-    };
-    slots: {
-        default: {};
-    };
-    getters: {};
-    events: ColliderEventMap;
-};
-export declare type AutoCollidersProps = typeof __propDef.props;
-export declare type AutoCollidersEvents = typeof __propDef.events;
-export declare type AutoCollidersSlots = typeof __propDef.slots;
-export default class AutoColliders extends SvelteComponentTyped<AutoCollidersProps, AutoCollidersEvents, AutoCollidersSlots> {
-}
-export {};