@threlte/rapier 0.0.1

package/dist/lib/createCollidersFromChildren.js

@@ -0,0 +1,94 @@
+import { ActiveEvents, Collider, ColliderDesc, World, RigidBody } from '@dimforge/rapier3d-compat';
+import { Mesh, Quaternion, Vector3 } from 'three';
+/**
+ *
+ * Creates collider descriptions including default translations
+ *
+ * @param object
+ * @param world
+ * @param friction
+ * @param restitution
+ * @param collidersType
+ * @param rigidBody
+ * @returns
+ */
+export const createCollidersFromChildren = (object, collidersType, world, rigidBody) => {
+    const colliders = [];
+    let description;
+    const offset = new Vector3();
+    /**
+     * Trying to find the parent RigidBody.
+     * If we find something, good. If not,
+     * the Colliders are created on the world positions
+     * of the meshes they resemble.
+     */
+    const rigidBodyWorldPos = new Vector3();
+    const rigidBodyWorldQuatInversed = new Quaternion();
+    object.traverseAncestors((child) => {
+        if (child.userData.isRigidBody) {
+            child.getWorldPosition(rigidBodyWorldPos);
+            child.getWorldQuaternion(rigidBodyWorldQuatInversed);
+            rigidBodyWorldQuatInversed.invert();
+        }
+    });
+    object.traverse((child) => {
+        if ('isMesh' in child) {
+            const { geometry } = child;
+            const worldPos = child.getWorldPosition(new Vector3());
+            const { x, y, z } = worldPos.sub(rigidBodyWorldPos);
+            const worldQuat = child.getWorldQuaternion(new Quaternion());
+            const { x: rx, y: ry, z: rz, w: rw } = worldQuat.clone().premultiply(rigidBodyWorldQuatInversed);
+            const scale = child.getWorldScale(new Vector3());
+            switch (collidersType) {
+                case 'cuboid':
+                    {
+                        geometry.computeBoundingBox();
+                        const { boundingBox } = geometry;
+                        const size = boundingBox.getSize(new Vector3());
+                        boundingBox.getCenter(offset);
+                        description = ColliderDesc.cuboid((size.x / 2) * scale.x, (size.y / 2) * scale.y, (size.z / 2) * scale.z);
+                    }
+                    break;
+                case 'ball':
+                    {
+                        geometry.computeBoundingSphere();
+                        const { boundingSphere } = geometry;
+                        const radius = boundingSphere.radius * scale.x;
+                        offset.copy(boundingSphere.center);
+                        description = ColliderDesc.ball(radius);
+                    }
+                    break;
+                case 'trimesh':
+                    {
+                        const g = geometry.clone().scale(scale.x, scale.y, scale.z);
+                        description = ColliderDesc.trimesh(g.attributes.position.array, g.index?.array);
+                    }
+                    break;
+                case 'capsule':
+                    {
+                        geometry.computeBoundingBox();
+                        const { boundingBox } = geometry;
+                        const size = boundingBox.getSize(new Vector3());
+                        boundingBox.getCenter(offset);
+                        const radius = Math.max((size.x / 2) * scale.x, (size.z / 2) * scale.z);
+                        description = ColliderDesc.capsule((size.y / 2) * scale.y - radius, radius);
+                    }
+                    break;
+                case 'convexHull':
+                    // eslint-disable-next-line no-case-declarations
+                    const g = geometry.clone().scale(scale.x, scale.y, scale.z);
+                    {
+                        description = ColliderDesc.convexHull(g.attributes.position.array);
+                    }
+                    break;
+            }
+            description
+                .setTranslation(x + offset.x, y + offset.y, z + offset.z)
+                .setRotation({ x: rx, y: ry, z: rz, w: rw })
+                .setActiveEvents(ActiveEvents.COLLISION_EVENTS);
+            const collider = world.createCollider(description, rigidBody);
+            colliders.push(collider);
+        }
+    });
+    return colliders;
+};

package/dist/lib/createRapierContext.d.ts

@@ -0,0 +1,16 @@
+import type { Collider, RigidBody } from '@dimforge/rapier3d-compat';
+import RAPIER from '@dimforge/rapier3d-compat';
+import type { Object3D } from 'three';
+import type { ColliderEventDispatcher, ColliderEventDispatchers, RigidBodyEventDispatcher, RigidBodyEventDispatchers } from '../types/types';
+export declare const createRapierContext: (gravity: RAPIER.Vector, 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) => {
+    rapier: typeof RAPIER;
+    world: RAPIER.World;
+    colliderObjects: Map<number, Object3D<import("three").Event>>;
+    rigidBodyObjects: Map<number, Object3D<import("three").Event>>;
+    rigidBodyEventDispatchers: RigidBodyEventDispatchers;
+    colliderEventDispatchers: ColliderEventDispatchers;
+    addColliderToContext: (collider: Collider, object: Object3D, eventDispatcher: ColliderEventDispatcher) => void;
+    removeColliderFromContext: (collider: Collider) => void;
+    addRigidBodyToContext: (rigidBody: RigidBody, object: Object3D, eventDispatcher: RigidBodyEventDispatcher) => void;
+    removeRigidBodyFromContext: (rigidBody: RigidBody) => void;
+};

package/dist/lib/createRapierContext.js

@@ -0,0 +1,56 @@
+import RAPIER from '@dimforge/rapier3d-compat';
+export const createRapierContext = (...args) => {
+    const world = new RAPIER.World(...args);
+    const colliderObjects = new Map();
+    const rigidBodyObjects = new Map();
+    const rigidBodyEventDispatchers = new Map();
+    const colliderEventDispatchers = new Map();
+    /**
+     * Adds a collider to the context
+     * @param collider
+     * @param object
+     * @param eventDispatcher
+     */
+    const addColliderToContext = (collider, object, eventDispatcher) => {
+        colliderObjects.set(collider.handle, object);
+        colliderEventDispatchers.set(collider.handle, eventDispatcher);
+    };
+    /**
+     * Removes the collider from the context
+     * @param collider
+     */
+    const removeColliderFromContext = (collider) => {
+        colliderObjects.delete(collider.handle);
+        colliderEventDispatchers.delete(collider.handle);
+    };
+    /**
+     * Adds a RigidBody to the context
+     * @param rigidBody
+     * @param object
+     * @param eventDispatcher
+     */
+    const addRigidBodyToContext = (rigidBody, object, eventDispatcher) => {
+        rigidBodyObjects.set(rigidBody.handle, object);
+        rigidBodyEventDispatchers.set(rigidBody.handle, eventDispatcher);
+    };
+    /**
+     * Removes the RigidBody from the context
+     * @param rigidBody
+     */
+    const removeRigidBodyFromContext = (rigidBody) => {
+        rigidBodyObjects.delete(rigidBody.handle);
+        rigidBodyEventDispatchers.delete(rigidBody.handle);
+    };
+    return {
+        rapier: RAPIER,
+        world,
+        colliderObjects,
+        rigidBodyObjects,
+        rigidBodyEventDispatchers,
+        colliderEventDispatchers,
+        addColliderToContext,
+        removeColliderFromContext,
+        addRigidBodyToContext,
+        removeRigidBodyFromContext
+    };
+};

package/dist/lib/getWorldTransforms.d.ts

@@ -0,0 +1,41 @@
+import { Euler, Object3D, Quaternion, Vector3 } from 'three';
+/**
+ * Get the world position of an object.
+ * If no target is provided, a globally used
+ * temporary Vector3 is used.
+ *
+ * @param object
+ * @param target
+ * @returns
+ */
+export declare const getWorldPosition: (object: Object3D, target?: Vector3) => Vector3;
+/**
+ * Get the world quaternion of an object.
+ * If no target is provided, a globally used
+ * temporary Quaternion is used.
+ *
+ * @param object
+ * @param target
+ * @returns
+ */
+export declare const getWorldQuaternion: (object: Object3D, target?: Quaternion) => Quaternion;
+/**
+ * Get the world rotation of an object.
+ * If no target is provided, a globally used
+ * temporary Euler is used.
+ *
+ * @param object
+ * @param target
+ * @returns
+ */
+export declare const getWorldRotation: (object: Object3D, target?: Euler) => Euler;
+/**
+ * Get the world scale of an object.
+ * If no target is provided, a globally used
+ * temporary Vector3 is used.
+ *
+ * @param object
+ * @param target
+ * @returns
+ */
+export declare const getWorldScale: (object: Object3D, target?: Vector3) => Vector3;

package/dist/lib/getWorldTransforms.js

@@ -0,0 +1,55 @@
+import { Euler, Object3D, Quaternion, Vector3 } from 'three';
+const tempVector3 = new Vector3();
+const tempQuaternion = new Quaternion();
+const tempEuler = new Euler();
+/**
+ * Get the world position of an object.
+ * If no target is provided, a globally used
+ * temporary Vector3 is used.
+ *
+ * @param object
+ * @param target
+ * @returns
+ */
+export const getWorldPosition = (object, target) => {
+    return object.getWorldPosition(target ?? tempVector3);
+};
+/**
+ * Get the world quaternion of an object.
+ * If no target is provided, a globally used
+ * temporary Quaternion is used.
+ *
+ * @param object
+ * @param target
+ * @returns
+ */
+export const getWorldQuaternion = (object, target) => {
+    return object.getWorldQuaternion(target ?? tempQuaternion);
+};
+/**
+ * Get the world rotation of an object.
+ * If no target is provided, a globally used
+ * temporary Euler is used.
+ *
+ * @param object
+ * @param target
+ * @returns
+ */
+export const getWorldRotation = (object, target) => {
+    object.getWorldQuaternion(tempQuaternion);
+    return target
+        ? target.setFromQuaternion(tempQuaternion)
+        : tempEuler.setFromQuaternion(tempQuaternion);
+};
+/**
+ * Get the world scale of an object.
+ * If no target is provided, a globally used
+ * temporary Vector3 is used.
+ *
+ * @param object
+ * @param target
+ * @returns
+ */
+export const getWorldScale = (object, target) => {
+    return object.getWorldScale(target ?? tempVector3);
+};

package/dist/lib/parseRigidBodyType.d.ts

@@ -0,0 +1,3 @@
+import { RigidBodyType } from '@dimforge/rapier3d-compat';
+export declare type RigidBodyTypeString = 'fixed' | 'dynamic' | 'kinematicPosition' | 'kinematicVelocity';
+export declare const parseRigidBodyType: (type: RigidBodyTypeString) => RigidBodyType;

package/dist/lib/parseRigidBodyType.js

@@ -0,0 +1,10 @@
+import { RigidBodyType } from '@dimforge/rapier3d-compat';
+const rigidBodyTypeMap = {
+    dynamic: RigidBodyType.Dynamic,
+    fixed: RigidBodyType.Fixed,
+    kinematicPosition: RigidBodyType.KinematicPositionBased,
+    kinematicVelocity: RigidBodyType.KinematicVelocityBased
+};
+export const parseRigidBodyType = (type) => {
+    return rigidBodyTypeMap[type];
+};

package/dist/lib/positionToVector3.d.ts

@@ -0,0 +1,3 @@
+import type { Position } from '@threlte/core';
+import { Vector3 } from 'three';
+export declare const positionToVector3: (position?: Position, v3?: Vector3) => Vector3;

package/dist/lib/positionToVector3.js

@@ -0,0 +1,8 @@
+import { Vector3 } from 'three';
+export const positionToVector3 = (position, v3) => {
+    if (v3) {
+        v3.set(position?.x ?? 0, position?.y ?? 0, position?.z ?? 0);
+        return v3;
+    }
+    return new Vector3(position?.x ?? 0, position?.y ?? 0, position?.z ?? 0);
+};

package/dist/lib/rotationToEuler.d.ts

@@ -0,0 +1,3 @@
+import type { Rotation } from '@threlte/core';
+import { Euler } from 'three';
+export declare const rotationToEuler: (rotation?: Rotation, euler?: Euler) => Euler;

package/dist/lib/rotationToEuler.js

@@ -0,0 +1,8 @@
+import { Euler } from 'three';
+export const rotationToEuler = (rotation, euler) => {
+    if (euler) {
+        euler.set(rotation?.x ?? 0, rotation?.y ?? 0, rotation?.z ?? 0);
+        return euler;
+    }
+    return new Euler(rotation?.x ?? 0, rotation?.y ?? 0, rotation?.z ?? 0);
+};

package/dist/lib/rotationToQuaternion.d.ts

@@ -0,0 +1,3 @@
+import type { Rotation } from '@threlte/core';
+import { Quaternion } from 'three';
+export declare const rotationToQuaternion: (rotation?: Rotation, quaternion?: Quaternion) => Quaternion;

package/dist/lib/rotationToQuaternion.js

@@ -0,0 +1,10 @@
+import { Quaternion } from 'three';
+import { rotationToEuler } from './rotationToEuler';
+export const rotationToQuaternion = (rotation, quaternion) => {
+    const euler = rotationToEuler(rotation);
+    if (quaternion) {
+        quaternion.setFromEuler(euler);
+        return quaternion;
+    }
+    return new Quaternion().setFromEuler(euler);
+};

package/dist/lib/scaleColliderArgs.d.ts

@@ -0,0 +1,5 @@
+import type { ColliderDesc } from '@dimforge/rapier3d-compat';
+import type { Vector3 } from 'three';
+import type { ColliderShapes } from '../types/types';
+export declare const scaleVertices: (vertices: ArrayLike<number>, scale: Vector3) => number[];
+export declare const scaleColliderArgs: <Shape extends ColliderShapes>(shape: Shape, args: Parameters<(typeof ColliderDesc)[Shape]>, scale: Vector3) => Parameters<(typeof ColliderDesc)[Shape]>;

package/dist/lib/scaleColliderArgs.js

@@ -0,0 +1,25 @@
+export const scaleVertices = (vertices, scale) => {
+    const scaledVerts = Array.from(vertices);
+    for (let i = 0; i < vertices.length / 3; i++) {
+        scaledVerts[i * 3] *= scale.x;
+        scaledVerts[i * 3 + 1] *= scale.y;
+        scaledVerts[i * 3 + 2] *= scale.z;
+    }
+    return scaledVerts;
+};
+export const scaleColliderArgs = (shape, args, scale) => {
+    // Heightfield only scales the last arg
+    const newArgs = args.slice();
+    if (shape === 'heightfield') {
+        ;
+        newArgs[3] *= scale.x;
+        return newArgs;
+    }
+    // Trimesh and convex scale the vertices
+    if (shape === 'trimesh' || shape === 'convexHull') {
+        newArgs[0] = new Float32Array(scaleVertices(newArgs[0], scale));
+        return newArgs;
+    }
+    const scaleArray = [scale.x, scale.y, scale.z];
+    return newArgs.map((arg, index) => scaleArray[index] * arg);
+};

package/dist/lib/scaleToVector3.d.ts

@@ -0,0 +1,3 @@
+import type { Scale } from '@threlte/core';
+import { Vector3 } from 'three';
+export declare const scaleToVector3: (scale?: Scale, v3?: Vector3) => Vector3;

package/dist/lib/scaleToVector3.js

@@ -0,0 +1,16 @@
+import { Vector3 } from 'three';
+export const scaleToVector3 = (scale, v3) => {
+    if (v3) {
+        if (typeof scale === 'number') {
+            v3.set(scale, scale, scale);
+        }
+        else {
+            v3.set(scale?.x ?? 1, scale?.y ?? 1, scale?.z ?? 1);
+        }
+        return v3;
+    }
+    if (typeof scale === 'number') {
+        return new Vector3(scale, scale, scale);
+    }
+    return new Vector3(scale?.x ?? 1, scale?.y ?? 1, scale?.z ?? 1);
+};

package/dist/recipes/BasicPlayerController.svelte

@@ -0,0 +1,129 @@
+<script>import { Group, useFrame, useThrelte } from '@threlte/core';
+import { createEventDispatcher } from 'svelte';
+import { Vector2, Vector3 } from 'three';
+import Collider from '../components/Colliders/Collider.svelte';
+import CollisionGroups from '../components/CollisionGroups/CollisionGroups.svelte';
+import RigidBody from '../components/RigidBody/RigidBody.svelte';
+export let position = undefined;
+export let height = 1.7;
+export let radius = 0.3;
+export let speed = 1;
+export let jumpStrength = 3;
+export let playerCollisionGroups = [0];
+export let groundCollisionGroups = [15];
+let rigidBody;
+const { renderer } = useThrelte();
+if (!renderer)
+    throw new Error();
+const keys = {
+    up: false,
+    down: false,
+    left: false,
+    right: false
+};
+const t = new Vector3();
+const t2 = new Vector2();
+const dispatch = createEventDispatcher();
+let grounded = false;
+let groundsSensored = 0;
+$: {
+    if (groundsSensored === 0)
+        grounded = false;
+    else
+        grounded = true;
+}
+$: grounded ? dispatch('groundenter') : dispatch('groundexit');
+useFrame(() => {
+    if (!rigidBody)
+        return;
+    t.fromArray([0, 0, 0]);
+    if (keys.down)
+        t.x += 1;
+    if (keys.up)
+        t.x -= 1;
+    if (keys.left)
+        t.z += 1;
+    if (keys.right)
+        t.z -= 1;
+    const l = t.length();
+    const xzLength = t2.set(t.x, t.z).length();
+    if (l > 0)
+        t.divideScalar(l).multiplyScalar(speed);
+    if (xzLength > 0) {
+        rigidBody.resetForces(true);
+        rigidBody.resetTorques(true);
+    }
+    const linVel = rigidBody.linvel();
+    t.y = linVel.y;
+    rigidBody.setLinvel(t, true);
+});
+const onKeyDown = (e) => {
+    switch (e.key) {
+        case 'ArrowDown':
+            keys.down = true;
+            break;
+        case 'ArrowUp':
+            keys.up = true;
+            break;
+        case 'ArrowLeft':
+            keys.left = true;
+            break;
+        case 'ArrowRight':
+            keys.right = true;
+            break;
+        case ' ':
+            if (!rigidBody || !grounded)
+                break;
+            rigidBody.applyImpulse({ x: 0, y: jumpStrength, z: 0 }, true);
+        default:
+            break;
+    }
+};
+const onKeyUp = (e) => {
+    switch (e.key) {
+        case 'ArrowDown':
+            keys.down = false;
+            break;
+        case 'ArrowUp':
+            keys.up = false;
+            break;
+        case 'ArrowLeft':
+            keys.left = false;
+            break;
+        case 'ArrowRight':
+            keys.right = false;
+            break;
+        default:
+            break;
+    }
+};
+</script>
+
+<svelte:window on:keydown|preventDefault={onKeyDown} on:keyup|preventDefault={onKeyUp} />
+
+<RigidBody
+  dominance={127}
+  enabledRotations={[false, false, false]}
+  bind:rigidBody
+  {position}
+  type={'dynamic'}
+>
+  <CollisionGroups groups={playerCollisionGroups}>
+    <Collider shape={'capsule'} args={[height / 2 - radius, radius]} />
+  </CollisionGroups>
+
+  <CollisionGroups groups={groundCollisionGroups}>
+    <Collider
+      sensor
+      on:sensorenter={() => (groundsSensored += 1)}
+      on:sensorexit={() => (groundsSensored -= 1)}
+      shape={'ball'}
+      args={[radius * 1.2]}
+      position={{ y: -height / 2 + radius }}
+    />
+  </CollisionGroups>
+
+  <Group position={{ y: -height / 2 }}>
+    <slot />
+  </Group>
+</RigidBody>

package/dist/recipes/BasicPlayerController.svelte.d.ts

@@ -0,0 +1,29 @@
+import { SvelteComponentTyped } from "svelte";
+import { type Position } from '@threlte/core';
+import type { CollisionGroupsBitMask } from '../types/types';
+declare const __propDef: {
+    props: {
+        position?: Position | undefined;
+        height?: number | undefined;
+        radius?: number | undefined;
+        speed?: number | undefined;
+        jumpStrength?: number | undefined;
+        playerCollisionGroups?: CollisionGroupsBitMask | undefined;
+        groundCollisionGroups?: CollisionGroupsBitMask | undefined;
+    };
+    events: {
+        groundenter: CustomEvent<void>;
+        groundexit: CustomEvent<void>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export declare type BasicPlayerControllerProps = typeof __propDef.props;
+export declare type BasicPlayerControllerEvents = typeof __propDef.events;
+export declare type BasicPlayerControllerSlots = typeof __propDef.slots;
+export default class BasicPlayerController extends SvelteComponentTyped<BasicPlayerControllerProps, BasicPlayerControllerEvents, BasicPlayerControllerSlots> {
+}
+export {};

package/dist/types/components.d.ts

@@ -0,0 +1,131 @@
+import type { CoefficientCombineRule, ColliderDesc } from '@dimforge/rapier3d-compat';
+import type { RawBroadPhase, RawCCDSolver, RawColliderSet, RawDebugRenderPipeline, RawImpulseJointSet, RawIntegrationParameters, RawIslandManager, RawMultibodyJointSet, RawNarrowPhase, RawPhysicsPipeline, RawQueryPipeline, RawRigidBodySet, RawSerializationPipeline } from '@dimforge/rapier3d-compat/raw';
+import type { Position, Rotation, TransformableObjectProperties } from '@threlte/core';
+import type { RigidBodyTypeString } from '../lib/parseRigidBodyType';
+import type { AutoCollidersShapes, ColliderShapes, CollisionGroupsBitMask } from './types';
+export declare type Boolean3Array = [x: boolean, y: boolean, z: boolean];
+export declare type Vector3Array = [x: number, y: number, z: number];
+export declare type RigidBodyProperties = Omit<TransformableObjectProperties, 'object'> & {
+    /**
+     * 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?: Position;
+    /** The angular velocity of this body.
+     * Default: zero velocity.
+     */
+    angularVelocity?: Rotation;
+    /**
+     * 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;
+};
+export declare type ColliderProperties<Shape extends ColliderShapes> = Omit<TransformableObjectProperties, 'object'> & {
+    shape: Shape;
+    /**
+     * Arguments to pass to the collider specific to shape
+     */
+    args: Parameters<typeof ColliderDesc[Shape]>;
+    /**
+     * The mass of this rigid body.
+     * The mass and density is automatically calculated based on the shape of the collider.
+     * Generally, it's not recommended to adjust the mass properties as it could lead to
+     * unexpected behaviors.
+     * More info https://rapier.rs/docs/user_guides/javascript/colliders#mass-properties
+     */
+    mass?: number;
+    /**
+     * The center of mass of this rigid body
+     */
+    centerOfMass?: Position;
+    /**
+     * Principal angular inertia of this rigid body
+     */
+    principalAngularInertia?: Position;
+    /**
+     * Restitution controls how elastic (aka. bouncy) a contact is. Le elasticity of a contact is controlled by the restitution coefficient
+     */
+    restitution?: number;
+    /**
+     * What happens when two bodies meet. See https://rapier.rs/docs/user_guides/javascript/colliders#friction.
+     */
+    restitutionCombineRule?: CoefficientCombineRule;
+    /**
+     * Friction is a force that opposes the relative tangential motion between two rigid-bodies with colliders in contact.
+     * A friction coefficient of 0 implies no friction at all (completely sliding contact) and a coefficient
+     * greater or equal to 1 implies a very strong friction. Values greater than 1 are allowed.
+     */
+    friction?: number;
+    /**
+     * What happens when two bodies meet. See https://rapier.rs/docs/user_guides/javascript/colliders#friction.
+     */
+    frictionCombineRule?: CoefficientCombineRule;
+    /**
+     * A sensor does not participate in  physics simulation and is
+     * used as a trigger e.g. to check whether another RigidBody
+     * entered an area.
+     */
+    sensor?: boolean;
+};
+export declare type AutoCollidersProperties = Omit<ColliderProperties<AutoCollidersShapes>, 'args'>;
+export declare type InnerWorldProperties = {
+    gravity?: Position;
+    rawIntegrationParameters?: RawIntegrationParameters;
+    rawIslands?: RawIslandManager;
+    rawBroadPhase?: RawBroadPhase;
+    rawNarrowPhase?: RawNarrowPhase;
+    rawBodies?: RawRigidBodySet;
+    rawColliders?: RawColliderSet;
+    rawImpulseJoints?: RawImpulseJointSet;
+    rawMultibodyJoints?: RawMultibodyJointSet;
+    rawCCDSolver?: RawCCDSolver;
+    rawQueryPipeline?: RawQueryPipeline;
+    rawPhysicsPipeline?: RawPhysicsPipeline;
+    rawSerializationPipeline?: RawSerializationPipeline;
+    rawDebugRenderPipeline?: RawDebugRenderPipeline;
+};
+export declare type WorldProperties = InnerWorldProperties;
+export declare type CollisionGroupsProperties = {
+    groups: CollisionGroupsBitMask;
+} | {
+    filter: CollisionGroupsBitMask;
+    memberships: CollisionGroupsBitMask;
+};