@threlte/rapier 0.0.1

package/dist/components/RigidBody/RigidBody.svelte

@@ -0,0 +1,111 @@
+<script>import { LayerableObject, SceneGraphObject } from '@threlte/core';
+import { createEventDispatcher, onDestroy, setContext } from 'svelte';
+import { Object3D, Vector3 } from 'three';
+import { useRapier } from '../../hooks/useRapier';
+import { applyTransforms } from '../../lib/applyTransforms';
+import { getWorldPosition, getWorldQuaternion } 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 type = 'dynamic';
+export let canSleep = true;
+export let linearVelocity = {};
+export let angularVelocity = {};
+export let gravityScale = 1;
+export let ccd = false;
+export let position = undefined;
+export let rotation = undefined;
+export let scale = undefined;
+export let lookAt = undefined;
+export let lockRotations = false;
+export let lockTranslations = false;
+export let enabledRotations = [
+    true,
+    true,
+    true
+];
+export let enabledTranslations = [
+    true,
+    true,
+    true
+];
+export let dominance = 0;
+const dispatcher = createEventDispatcher();
+const object = new Object3D();
+/**
+ * Used to traverseAncestors to restore transform
+ */
+object.userData.isRigidBody = true;
+/**
+ * isSleeping used for events "sleep" and "wake" in `useFrameHandler`
+ */
+object.userData.isSleeping = false;
+/**
+ * Immediately apply transforms to get the objects
+ * world position to apply to the RigidBody.
+ * This is a one-off operation as RigidBodies should
+ * not be moved around after initialization.
+ */
+applyTransforms(object, position, rotation, scale, lookAt);
+/**
+ * Update the world matrix of the object before applying
+ * 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)
+    .setTranslation(worldPosition.x * parentWorldScale.x, worldPosition.y * parentWorldScale.y, worldPosition.z * parentWorldScale.z)
+    .setRotation({ x: worldRotation.x, y: worldRotation.y, z: worldRotation.z, w: worldRotation.w });
+/**
+ * RigidBody init
+ */
+export const rigidBody = world.createRigidBody(desc);
+/**
+ * Will come in handy in the future for joints
+ */
+object.userData.rigidBody = rigidBody;
+/**
+ * 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);
+}
+/**
+ * Setting the RigidBody context so that colliders can
+ * hook onto.
+ */
+setContext('threlte-rapier-rigidbody', rigidBody);
+/**
+ * Add the mesh to the context
+ */
+addRigidBodyToContext(rigidBody, object, dispatcher);
+/**
+ * cleanup
+ */
+onDestroy(() => {
+    removeRigidBodyFromContext(rigidBody);
+    world.removeRigidBody(rigidBody);
+});
+</script>
+
+<SceneGraphObject {object}>
+  <slot />
+</SceneGraphObject>
+
+<LayerableObject {object} />

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

@@ -0,0 +1,39 @@
+import { SvelteComponentTyped } from "svelte";
+import type { RigidBodyProperties } from '../../types/components';
+import type { RigidBodyEventMap } from '../../types/types';
+declare const __propDef: {
+    props: {
+        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;
+        position?: RigidBodyProperties['position'];
+        rotation?: RigidBodyProperties['rotation'];
+        scale?: RigidBodyProperties['scale'];
+        lookAt?: RigidBodyProperties['lookAt'];
+        lockRotations?: boolean | undefined;
+        lockTranslations?: boolean | undefined;
+        enabledRotations?: import("../../types/components").Boolean3Array | undefined;
+        enabledTranslations?: import("../../types/components").Boolean3Array | undefined;
+        dominance?: number | undefined;
+        /**
+           * RigidBody init
+           */ rigidBody?: import("@dimforge/rapier3d-compat").RigidBody | undefined;
+    };
+    slots: {
+        default: {};
+    };
+    getters: {
+        rigidBody: import("@dimforge/rapier3d-compat").RigidBody;
+    };
+    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/components/World/InnerWorld.svelte

@@ -0,0 +1,32 @@
+<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 };
+export let rawIntegrationParameters = undefined;
+export let rawIslands = undefined;
+export let rawBroadPhase = undefined;
+export let rawNarrowPhase = undefined;
+export let rawBodies = undefined;
+export let rawColliders = undefined;
+export let rawImpulseJoints = undefined;
+export let rawMultibodyJoints = undefined;
+export let rawCCDSolver = undefined;
+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);
+setContext('threlte-rapier-context', rapierContext);
+$: if (gravity !== undefined)
+    rapierContext.world.gravity = positionToVector3(gravity);
+useFrameHandler(rapierContext);
+onDestroy(async () => {
+    await tick();
+    rapierContext.world.free();
+});
+</script>
+
+<slot />

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

@@ -0,0 +1,32 @@
+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'];
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type InnerWorldProps = typeof __propDef.props;
+export declare type InnerWorldEvents = typeof __propDef.events;
+export declare type InnerWorldSlots = typeof __propDef.slots;
+export default class InnerWorld extends SvelteComponentTyped<InnerWorldProps, InnerWorldEvents, InnerWorldSlots> {
+}
+export {};

package/dist/components/World/World.svelte

@@ -0,0 +1,63 @@
+<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);
+</script>
+
+<script>import InnerWorld from './InnerWorld.svelte';
+export let gravity = undefined;
+export let rawIntegrationParameters = undefined;
+export let rawIslands = undefined;
+export let rawBroadPhase = undefined;
+export let rawNarrowPhase = undefined;
+export let rawBodies = undefined;
+export let rawColliders = undefined;
+export let rawImpulseJoints = undefined;
+export let rawMultibodyJoints = undefined;
+export let rawCCDSolver = undefined;
+export let rawQueryPipeline = undefined;
+export let rawPhysicsPipeline = undefined;
+export let rawSerializationPipeline = undefined;
+export let rawDebugRenderPipeline = undefined;
+let error = false;
+const init = async () => {
+    if ($initialized)
+        return;
+    try {
+        await RAPIER.init();
+        $initialized = true;
+    }
+    catch (e) {
+        error = true;
+    }
+};
+onMount(init);
+</script>
+
+{#if $initialized}
+  <InnerWorld
+    {gravity}
+    {rawIntegrationParameters}
+    {rawIslands}
+    {rawBroadPhase}
+    {rawNarrowPhase}
+    {rawBodies}
+    {rawColliders}
+    {rawImpulseJoints}
+    {rawMultibodyJoints}
+    {rawCCDSolver}
+    {rawQueryPipeline}
+    {rawPhysicsPipeline}
+    {rawSerializationPipeline}
+    {rawDebugRenderPipeline}
+  >
+    <slot />
+  </InnerWorld>
+{/if}
+
+{#if error}
+  <slot name="fallback" />
+{/if}

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

@@ -0,0 +1,33 @@
+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> {
+}
+export {};

package/dist/hooks/useCollisionGroups.d.ts

@@ -0,0 +1,5 @@
+import type { Collider } from '@dimforge/rapier3d-compat';
+export declare const useCollisionGroups: () => {
+    registerColliders: (colliders: Collider[]) => void;
+    removeColliders: (colliders: Collider[]) => void;
+};

package/dist/hooks/useCollisionGroups.js

@@ -0,0 +1,52 @@
+import { getContext, onDestroy } from 'svelte';
+import { get } from 'svelte/store';
+const applyBitMask = (collidersMap, bitMask) => {
+    collidersMap.forEach((c) => {
+        if (c && c.collider && c.collider.isValid()) {
+            c.collider.setCollisionGroups(bitMask);
+        }
+    });
+};
+export const useCollisionGroups = () => {
+    const collidersMap = new Map();
+    const bitMaskStore = getContext('threlte-rapier-collision-group');
+    if (!bitMaskStore)
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            registerColliders: (colliders) => { },
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            removeColliders: (colliders) => { }
+        };
+    let bitMask = get(bitMaskStore);
+    const unsubscribe = bitMaskStore.subscribe((newBitMask) => {
+        bitMask = newBitMask;
+        applyBitMask(collidersMap, newBitMask);
+    });
+    onDestroy(unsubscribe);
+    const registerColliders = (colliders) => {
+        colliders.forEach((c) => {
+            if (!collidersMap.has(c.handle)) {
+                collidersMap.set(c.handle, {
+                    collider: c,
+                    initialCollisionGroup: c.collisionGroups()
+                });
+            }
+        });
+        applyBitMask(collidersMap, bitMask);
+    };
+    const removeColliders = (colliders) => {
+        colliders.forEach((c) => {
+            const mapItem = collidersMap.get(c.handle);
+            if (mapItem) {
+                if (c && c.isValid()) {
+                    c.setCollisionGroups(mapItem.initialCollisionGroup);
+                }
+            }
+            collidersMap.delete(c.handle);
+        });
+    };
+    return {
+        registerColliders,
+        removeColliders
+    };
+};

package/dist/hooks/useFrameHandler.d.ts

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

package/dist/hooks/useFrameHandler.js

@@ -0,0 +1,176 @@
+import { 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();
+export const useFrameHandler = (ctx) => {
+    const eventQueue = new EventQueue(false);
+    let time = performance.now();
+    useFrame(() => {
+        // 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.step(eventQueue);
+        // Update meshes
+        ctx.rigidBodyObjects.forEach((mesh, handle) => {
+            const rigidBody = world.getRigidBody(handle);
+            if (!rigidBody)
+                return;
+            const dispatcher = ctx.rigidBodyEventDispatchers.get(handle);
+            if (!rigidBody || !rigidBody.isValid())
+                return;
+            if (dispatcher) {
+                if (rigidBody.isSleeping() && !mesh.userData.isSleeping) {
+                    dispatcher('sleep');
+                }
+                if (!rigidBody.isSleeping() && mesh.userData.isSleeping) {
+                    dispatcher('wake');
+                }
+                mesh.userData.isSleeping = rigidBody.isSleeping();
+            }
+            if (!rigidBody || rigidBody.isSleeping() || rigidBody.isFixed() || !mesh.parent) {
+                return;
+            }
+            // Position
+            const { x, y, z } = rigidBody.translation();
+            tempObject.position.set(x, y, z);
+            // Rotation
+            const rotation = rigidBody.rotation();
+            tempQuaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
+            tempObject.rotation.setFromQuaternion(tempQuaternion);
+            // Scale
+            mesh.getWorldScale(tempVector3);
+            tempObject.scale.copy(tempVector3);
+            tempObject.updateMatrix();
+            tempObject.applyMatrix4(mesh.parent.matrixWorld.clone().invert());
+            tempObject.updateMatrix();
+            mesh.position.setFromMatrixPosition(tempObject.matrix);
+            mesh.rotation.setFromRotationMatrix(tempObject.matrix);
+        });
+        // Collision events
+        eventQueue.drainCollisionEvents((handle1, handle2, started) => {
+            const collider1 = world.getCollider(handle1);
+            const collider2 = world.getCollider(handle2);
+            // Sanity check
+            if (!collider1 || !collider2) {
+                return;
+            }
+            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;
+            if (started) {
+                // intersections are triggered by sensors
+                const isIntersection = world.intersectionPair(collider1, collider2);
+                if (isIntersection) {
+                    // Collider Events
+                    colliderDispatcher1?.('sensorenter', {
+                        targetCollider: collider2,
+                        targetRigidBody: rigidBody2
+                    });
+                    colliderDispatcher2?.('sensorenter', {
+                        targetCollider: collider1,
+                        targetRigidBody: rigidBody1
+                    });
+                    // RigidBody Events
+                    rigidBodyDispatcher1?.('sensorenter', {
+                        targetCollider: collider2,
+                        targetRigidBody: rigidBody2
+                    });
+                    rigidBodyDispatcher2?.('sensorenter', {
+                        targetCollider: collider1,
+                        targetRigidBody: rigidBody1
+                    });
+                    // intersections with sensors don't trigger contact pairs, returning
+                    return;
+                }
+                world.contactPair(collider1, collider2, (manifold, flipped) => {
+                    // Collider events
+                    colliderDispatcher1?.('collisionenter', {
+                        flipped,
+                        manifold,
+                        targetCollider: collider2,
+                        targetRigidBody: rigidBody2
+                    });
+                    colliderDispatcher2?.('collisionenter', {
+                        flipped,
+                        manifold,
+                        targetCollider: collider1,
+                        targetRigidBody: rigidBody1
+                    });
+                    // RigidBody Events
+                    rigidBodyDispatcher1?.('collisionenter', {
+                        flipped,
+                        manifold,
+                        targetCollider: collider2,
+                        targetRigidBody: rigidBody2
+                    });
+                    rigidBodyDispatcher2?.('collisionenter', {
+                        flipped,
+                        manifold,
+                        targetCollider: collider1,
+                        targetRigidBody: rigidBody1
+                    });
+                });
+            }
+            else {
+                // COLLISION / INTERSECTION ENDED
+                // intersections are triggered by sensors, but apparently not on collision exit
+                const isIntersection = world.intersectionPair(collider1, collider2) ||
+                    collider1.isSensor() ||
+                    collider2.isSensor();
+                if (isIntersection) {
+                    colliderDispatcher1?.('sensorexit', {
+                        targetCollider: collider2,
+                        targetRigidBody: rigidBody2
+                    });
+                    colliderDispatcher2?.('sensorexit', {
+                        targetCollider: collider1,
+                        targetRigidBody: rigidBody1
+                    });
+                    // RigidBody Events
+                    rigidBodyDispatcher1?.('sensorexit', {
+                        targetCollider: collider2,
+                        targetRigidBody: rigidBody2
+                    });
+                    rigidBodyDispatcher2?.('sensorexit', {
+                        targetCollider: collider1,
+                        targetRigidBody: rigidBody1
+                    });
+                    // intersections with sensors don't trigger contact pairs, returning
+                    return;
+                }
+                // Collider events
+                colliderDispatcher1?.('collisionexit', {
+                    targetCollider: collider2,
+                    targetRigidBody: rigidBody2
+                });
+                colliderDispatcher2?.('collisionexit', {
+                    targetCollider: collider1,
+                    targetRigidBody: rigidBody1
+                });
+                // RigidBody Events
+                rigidBodyDispatcher1?.('collisionexit', {
+                    targetCollider: collider2,
+                    targetRigidBody: rigidBody2
+                });
+                rigidBodyDispatcher2?.('collisionexit', {
+                    targetCollider: collider1,
+                    targetRigidBody: rigidBody1
+                });
+            }
+        });
+        time = now;
+    });
+};

package/dist/hooks/useRapier.d.ts

@@ -0,0 +1,2 @@
+import type { RapierContext } from '../types/types';
+export declare const useRapier: () => RapierContext;

package/dist/hooks/useRapier.js

@@ -0,0 +1,4 @@
+import { getContext } from 'svelte';
+export const useRapier = () => {
+    return getContext('threlte-rapier-context');
+};

package/dist/hooks/useRigidBody.d.ts

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

package/dist/hooks/useRigidBody.js

@@ -0,0 +1,4 @@
+import { getContext } from 'svelte';
+export const useRigidBody = () => {
+    return getContext('threlte-rapier-rigidbody');
+};

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { useRapier } from './hooks/useRapier';
+export { useCollisionGroups } from './hooks/useCollisionGroups';
+export { useRigidBody } from './hooks/useRigidBody';
+export { default as World } from './components/World/World.svelte';
+export { default as RigidBody } from './components/RigidBody/RigidBody.svelte';
+export { default as Debug } from './components/Debug/Debug.svelte';
+export { default as Collider } from './components/Colliders/Collider.svelte';
+export { default as AutoColliders } from './components/Colliders/AutoColliders.svelte';
+export { default as 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 { CollisionGroupsBitMask, AutoCollidersShapes, ColliderEventDispatcher, ColliderShapes, RapierContext, RigidBodyEventDispatcher } from './types/types';

package/dist/index.js

@@ -0,0 +1,13 @@
+// hooks
+export { useRapier } from './hooks/useRapier';
+export { useCollisionGroups } from './hooks/useCollisionGroups';
+export { useRigidBody } from './hooks/useRigidBody';
+// components
+export { default as World } from './components/World/World.svelte';
+export { default as RigidBody } from './components/RigidBody/RigidBody.svelte';
+export { default as Debug } from './components/Debug/Debug.svelte';
+export { default as Collider } from './components/Colliders/Collider.svelte';
+export { default as AutoColliders } from './components/Colliders/AutoColliders.svelte';
+export { default as CollisionGroups } from './components/CollisionGroups/CollisionGroups.svelte';
+// recipes
+export { default as BasicPlayerController } from './recipes/BasicPlayerController.svelte';

package/dist/lib/applyTransforms.d.ts

@@ -0,0 +1,3 @@
+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;

package/dist/lib/applyTransforms.js

@@ -0,0 +1,17 @@
+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));
+};

package/dist/lib/createCollidersFromChildren.d.ts

@@ -0,0 +1,16 @@
+import { Collider, World, RigidBody } from '@dimforge/rapier3d-compat';
+import { type Object3D } from 'three';
+import type { AutoCollidersShapes } from '../types/types';
+/**
+ *
+ * Creates collider descriptions including default translations
+ *
+ * @param object
+ * @param world
+ * @param friction
+ * @param restitution
+ * @param collidersType
+ * @param rigidBody
+ * @returns
+ */
+export declare const createCollidersFromChildren: (object: Object3D, collidersType: AutoCollidersShapes, world: World, rigidBody?: RigidBody) => Collider[];