@absolutejs/rapier3d 0.0.0-stage → 0.1.0

package/dist/types/geometry/collider_set.d.ts

@@ -0,0 +1,97 @@
+import { RawColliderSet } from "../raw";
+import { Collider, ColliderDesc, ColliderHandle } from "./collider";
+import { ImpulseJointHandle, IslandManager, RigidBodyHandle, RigidBodySet, SoftBodySet, SoftMeshBinding } from "../dynamics";
+/**
+ * A set of rigid bodies that can be handled by a physics pipeline.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `colliderSet.free()`
+ * once you are done using it (and all the rigid-bodies it created).
+ */
+export declare class ColliderSet {
+    raw: RawColliderSet;
+    private map;
+    /**
+     * Release the WASM memory occupied by this collider set.
+     */
+    free(): void;
+    constructor(raw?: RawColliderSet);
+    /** @internal */
+    castClosure<Res>(f?: (collider: Collider) => Res): (handle: ColliderHandle) => Res | undefined;
+    /** @internal */
+    finalizeDeserialization(bodies: RigidBodySet): void;
+    /**
+     * Creates a new collider and return its integer handle.
+     *
+     * @param bodies - The set of bodies where the collider's parent can be found.
+     * @param desc - The collider's description.
+     * @param parentHandle - The integer handle of the rigid-body this collider is attached to.
+     */
+    createCollider(bodies: RigidBodySet, desc: ColliderDesc, parentHandle: RigidBodyHandle): Collider;
+    /**
+     * Creates a collider holding a soft body's deformable collision mesh: a polyline (2D) or a
+     * triangle mesh (3D) built with the `DEFORMABLE` flag, whose vertices follow the cluster
+     * of the parent proxy through `binding`.
+     *
+     * Returns `null` when the binding fails: the parent is not a live cluster proxy, the shape
+     * is not a deformable mesh, or a vertex could not be bound.
+     *
+     * @param bodies - The set of bodies where the parent proxy can be found.
+     * @param softBodies - The set of soft bodies owning the cluster.
+     * @param desc - The collider's description.
+     * @param binding - How the mesh follows the cluster.
+     * @param parentHandle - The handle of the cluster proxy (see `SoftBody.rootBody`,
+     *                       `SoftBody.clusterProxy`).
+     */
+    createDeformableCollider(bodies: RigidBodySet, softBodies: SoftBodySet, desc: ColliderDesc, binding: SoftMeshBinding, parentHandle: RigidBodyHandle): Collider | null;
+    /**
+     * Wraps the colliders the engine created on its own (the deformable collision meshes of
+     * soft bodies) that have no JavaScript wrapper yet.
+     */
+    mapNewColliders(bodies: RigidBodySet): void;
+    /**
+     * Drops the wrappers of the colliders the engine removed on its own (the colliders of
+     * removed soft bodies and clusters).
+     */
+    unmapRemovedColliders(): void;
+    /**
+     * Remove a collider from this set.
+     *
+     * @param handle - The integer handle of the collider to remove.
+     * @param bodies - The set of rigid-body containing the rigid-body the collider is attached to.
+     * @param wakeUp - If `true`, the rigid-body the removed collider is attached to will be woken-up automatically.
+     */
+    remove(handle: ColliderHandle, islands: IslandManager, bodies: RigidBodySet, softBodies: SoftBodySet, wakeUp: boolean): void;
+    /**
+     * Internal function, do not call directly.
+     * @param handle
+     */
+    unmap(handle: ImpulseJointHandle): void;
+    /**
+     * Gets the rigid-body with the given handle.
+     *
+     * @param handle - The handle of the rigid-body to retrieve.
+     */
+    get(handle: ColliderHandle): Collider | null;
+    /**
+     * The number of colliders on this set.
+     */
+    len(): number;
+    /**
+     * Does this set contain a collider with the given handle?
+     *
+     * @param handle - The collider handle to check.
+     */
+    contains(handle: ColliderHandle): boolean;
+    /**
+     * Applies the given closure to each collider contained by this set.
+     *
+     * @param f - The closure to apply.
+     */
+    forEach(f: (collider: Collider) => void): void;
+    /**
+     * Gets all colliders in the list.
+     *
+     * @returns collider list.
+     */
+    getAll(): Collider[];
+}

package/dist/types/geometry/contact.d.ts

@@ -0,0 +1,36 @@
+import { Vector } from "../math";
+import { RawShapeContact } from "../raw";
+/**
+ * The contact info between two shapes.
+ */
+export declare class ShapeContact {
+    /**
+     * Distance between the two contact points.
+     * If this is negative, this contact represents a penetration.
+     */
+    distance: number;
+    /**
+     * Position of the contact on the first shape.
+     */
+    point1: Vector;
+    /**
+     * Position of the contact on the second shape.
+     */
+    point2: Vector;
+    /**
+     * Contact normal, pointing towards the exterior of the first shape.
+     */
+    normal1: Vector;
+    /**
+     * Contact normal, pointing towards the exterior of the second shape.
+     * If these contact data are expressed in world-space, this normal is equal to -normal1.
+     */
+    normal2: Vector;
+    constructor(dist: number, point1: Vector, point2: Vector, normal1: Vector, normal2: Vector);
+    /**
+     * @param raw - The raw contact returned by the WASM query. It is freed by this method.
+     * @param target - If provided, this object is populated and returned instead of
+     * allocating a new one.
+     */
+    static fromBuffer(raw: RawShapeContact, target?: ShapeContact): ShapeContact;
+}

package/dist/types/geometry/feature.d.ts

@@ -0,0 +1,6 @@
+export declare enum FeatureType {
+    Vertex = 0,
+    Edge = 1,
+    Face = 2,
+    Unknown = 3
+}

package/dist/types/geometry/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./broad_phase";
+export * from "./narrow_phase";
+export * from "./shape";
+export * from "./collider";
+export * from "./collider_set";
+export * from "./feature";
+export * from "./ray";
+export * from "./point";
+export * from "./toi";
+export * from "./interaction_groups";
+export * from "./contact";

package/dist/types/geometry/interaction_groups.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pairwise filtering using bit masks.
+ *
+ * This filtering method is based on two 16-bit values:
+ * - The interaction groups (the 16 left-most bits of `self.0`).
+ * - The interaction mask (the 16 right-most bits of `self.0`).
+ *
+ * An interaction is allowed between two filters `a` and `b` two conditions
+ * are met simultaneously:
+ * - The interaction groups of `a` has at least one bit set to `1` in common with the interaction mask of `b`.
+ * - The interaction groups of `b` has at least one bit set to `1` in common with the interaction mask of `a`.
+ * In other words, interactions are allowed between two filter iff. the following condition is met:
+ *
+ * ```
+ * ((a >> 16) & b) != 0 && ((b >> 16) & a) != 0
+ * ```
+ */
+export type InteractionGroups = number;

package/dist/types/geometry/narrow_phase.d.ts

@@ -0,0 +1,140 @@
+import { RawNarrowPhase, RawContactManifold } from "../raw";
+import { ColliderHandle } from "./collider";
+import { RigidBodySet } from "../dynamics";
+import { Vector } from "../math";
+/**
+ * The narrow-phase used for precise collision-detection.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `narrowPhase.free()`
+ * once you are done using it.
+ */
+export declare class NarrowPhase {
+    raw: RawNarrowPhase;
+    tempManifold: TempContactManifold;
+    /**
+     * Release the WASM memory occupied by this narrow-phase.
+     */
+    free(): void;
+    constructor(raw?: RawNarrowPhase);
+    /**
+     * Enumerates all the colliders potentially in contact with the given collider.
+     *
+     * @param collider1 - The second collider involved in the contact.
+     * @param f - Closure that will be called on each collider that is in contact with `collider1`.
+     */
+    contactPairsWith(collider1: ColliderHandle, f: (collider2: ColliderHandle) => void): void;
+    /**
+     * Enumerates all the colliders intersecting the given colliders, assuming one of them
+     * is a sensor.
+     */
+    intersectionPairsWith(collider1: ColliderHandle, f: (collider2: ColliderHandle) => void): void;
+    /**
+     * Iterates through all the contact manifolds between the given pair of colliders.
+     *
+     * @param collider1 - The first collider involved in the contact.
+     * @param collider2 - The second collider involved in the contact.
+     * @param bodies - The set of rigid-bodies the colliders are attached to. Solver contacts are
+     *                 anchored in body-local space, so this is needed to read them back in world-space.
+     * @param f - Closure that will be called on each contact manifold between the two colliders. If the second argument
+     *            passed to this closure is `true`, then the contact manifold data is flipped, i.e., methods like `localNormal1`
+     *            actually apply to the `collider2` and fields like `localNormal2` apply to the `collider1`.
+     */
+    contactPair(collider1: ColliderHandle, collider2: ColliderHandle, bodies: RigidBodySet, f: (manifold: TempContactManifold, flipped: boolean) => void): void;
+    /**
+     * Visits the manifolds consumed by the solver, including clustered contacts.
+     * Original geometric manifolds remain available through contactPair().
+     * The view is valid only during the callback. Do not step, free, or mutate
+     * the world in the callback. Copy values that must survive the call.
+     * Clustered contacts do not preserve geometric subshape identifiers.
+     */
+    solverContactPair(collider1: ColliderHandle, collider2: ColliderHandle, bodies: RigidBodySet, f: (manifold: SolverContactManifold, flipped: boolean) => void): void;
+    /**
+     * Returns `true` if `collider1` and `collider2` intersect and at least one of them is a sensor.
+     * @param collider1 − The first collider involved in the intersection.
+     * @param collider2 − The second collider involved in the intersection.
+     */
+    intersectionPair(collider1: ColliderHandle, collider2: ColliderHandle): boolean;
+}
+export declare class TempContactManifold {
+    raw: RawContactManifold;
+    /** The bodies the manifold's solver contacts are anchored to. */
+    bodies: RigidBodySet;
+    free(): void;
+    constructor(raw: RawContactManifold, bodies?: RigidBodySet);
+    /**
+     * The contact normal of the manifold, expressed in world-space.
+     *
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    normal(target?: Vector): Vector;
+    /**
+     * The contact normal of the manifold, expressed in the local-space of the first shape.
+     *
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    localNormal1(target?: Vector): Vector;
+    /**
+     * The contact normal of the manifold, expressed in the local-space of the second shape.
+     *
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    localNormal2(target?: Vector): Vector;
+    subshape1(): number;
+    subshape2(): number;
+    numContacts(): number;
+    /**
+     * The local-space contact point on the first shape, for the `i`-th contact.
+     *
+     * @param {number} i - The index of the contact to read.
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    localContactPoint1(i: number, target?: Vector): Vector | null;
+    /**
+     * The local-space contact point on the second shape, for the `i`-th contact.
+     *
+     * @param {number} i - The index of the contact to read.
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    localContactPoint2(i: number, target?: Vector): Vector | null;
+    contactDist(i: number): number;
+    contactFid1(i: number): number;
+    contactFid2(i: number): number;
+    contactImpulse(i: number): number;
+    contactTangentImpulseX(i: number): number;
+    contactTangentImpulseY(i: number): number;
+    numSolverContacts(): number;
+    /**
+     * The world-space position of the `i`-th solver contact point.
+     *
+     * @param {number} i - The index of the solver contact to read.
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    solverContactPoint(i: number, target?: Vector): Vector | null;
+    solverContactDist(i: number): number;
+    /**
+     * The friction coefficient applied to this manifold's solver contacts. It is combined
+     * once per manifold, so every solver contact of this manifold shares it.
+     */
+    friction(): number;
+    /**
+     * The restitution coefficient applied to this manifold's solver contacts. It is
+     * combined once per manifold, so every solver contact of this manifold shares it.
+     */
+    restitution(): number;
+    /**
+     * The tangent (surface) velocity of the `i`-th solver contact point.
+     *
+     * @param {number} i - The index of the solver contact to read.
+     * @param {Vector?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    solverContactTangentVelocity(i: number, target?: Vector): Vector;
+}
+/** Read-only solver view; geometric subshape and local-surface queries are excluded. */
+export type SolverContactManifold = Pick<TempContactManifold, 'normal' | 'numSolverContacts' | 'solverContactPoint' | 'solverContactDist' | 'friction' | 'restitution' | 'solverContactTangentVelocity'>;

package/dist/types/geometry/point.d.ts

@@ -0,0 +1,58 @@
+import { Collider } from "./collider";
+import { Vector } from "../math";
+import { RawPointColliderProjection, RawPointProjection } from "../raw";
+import { FeatureType } from "./feature";
+import { ColliderSet } from "./collider_set";
+/**
+ * The projection of a point on a collider.
+ */
+export declare class PointProjection {
+    /**
+     * The projection of the point on the collider.
+     */
+    point: Vector;
+    /**
+     * Is the point inside of the collider?
+     */
+    isInside: boolean;
+    constructor(point: Vector, isInside: boolean);
+    /**
+     * @param raw - The raw projection returned by the WASM query. It is freed by this method.
+     * @param target - If provided, this object is populated and returned instead of
+     * allocating a new one.
+     */
+    static fromBuffer(raw: RawPointProjection, target?: PointProjection): PointProjection;
+}
+/**
+ * The projection of a point on a collider (includes the collider handle).
+ */
+export declare class PointColliderProjection {
+    /**
+     * The collider hit by the ray.
+     */
+    collider: Collider;
+    /**
+     * The projection of the point on the collider.
+     */
+    point: Vector;
+    /**
+     * Is the point inside of the collider?
+     */
+    isInside: boolean;
+    /**
+     * The type of the geometric feature the point was projected on.
+     */
+    featureType: FeatureType;
+    /**
+     * The id of the geometric feature the point was projected on.
+     */
+    featureId: number | undefined;
+    constructor(collider: Collider, point: Vector, isInside: boolean, featureType?: FeatureType, featureId?: number);
+    /**
+     * @param colliderSet - The set the projected-on collider belongs to.
+     * @param raw - The raw projection returned by the WASM query. It is freed by this method.
+     * @param target - If provided, this object is populated and returned instead of
+     * allocating a new one.
+     */
+    static fromBuffer(colliderSet: ColliderSet, raw: RawPointColliderProjection, target?: PointColliderProjection): PointColliderProjection;
+}

package/dist/types/geometry/ray.d.ts

@@ -0,0 +1,108 @@
+import { Vector } from "../math";
+import { RawRayColliderIntersection, RawRayColliderHit, RawRayIntersection } from "../raw";
+import { Collider } from "./collider";
+import { FeatureType } from "./feature";
+import { ColliderSet } from "./collider_set";
+/**
+ * A ray. This is a directed half-line.
+ */
+export declare class Ray {
+    /**
+     * The starting point of the ray.
+     */
+    origin: Vector;
+    /**
+     * The direction of propagation of the ray.
+     */
+    dir: Vector;
+    /**
+     * Builds a ray from its origin and direction.
+     *
+     * @param origin - The ray's starting point.
+     * @param dir - The ray's direction of propagation.
+     */
+    constructor(origin: Vector, dir: Vector);
+    pointAt(t: number): Vector;
+}
+/**
+ * The intersection between a ray and a collider.
+ */
+export declare class RayIntersection {
+    /**
+     * The time-of-impact of the ray with the collider.
+     *
+     * The hit point is obtained from the ray's origin and direction: `origin + dir * timeOfImpact`.
+     */
+    timeOfImpact: number;
+    /**
+     * The normal of the collider at the hit point.
+     */
+    normal: Vector;
+    /**
+     * The type of the geometric feature the point was projected on.
+     */
+    featureType: FeatureType;
+    /**
+     * The id of the geometric feature the point was projected on.
+     */
+    featureId: number | undefined;
+    constructor(timeOfImpact: number, normal: Vector, featureType?: FeatureType, featureId?: number);
+    /**
+     * @param raw - The raw intersection returned by the WASM query. It is freed by this method.
+     * @param target - If provided, this object is populated and returned instead of
+     * allocating a new one.
+     */
+    static fromBuffer(raw: RawRayIntersection, target?: RayIntersection): RayIntersection;
+}
+/**
+ * The intersection between a ray and a collider (includes the collider handle).
+ */
+export declare class RayColliderIntersection {
+    /**
+     * The collider hit by the ray.
+     */
+    collider: Collider;
+    /**
+     * The time-of-impact of the ray with the collider.
+     *
+     * The hit point is obtained from the ray's origin and direction: `origin + dir * timeOfImpact`.
+     */
+    timeOfImpact: number;
+    /**
+     * The normal of the collider at the hit point.
+     */
+    normal: Vector;
+    /**
+     * The type of the geometric feature the point was projected on.
+     */
+    featureType: FeatureType;
+    /**
+     * The id of the geometric feature the point was projected on.
+     */
+    featureId: number | undefined;
+    constructor(collider: Collider, timeOfImpact: number, normal: Vector, featureType?: FeatureType, featureId?: number);
+    /**
+     * @param colliderSet - The set the hit collider belongs to.
+     * @param raw - The raw intersection returned by the WASM query. It is freed by this method.
+     * @param target - If provided, this object is populated and returned instead of
+     * allocating a new one.
+     */
+    static fromBuffer(colliderSet: ColliderSet, raw: RawRayColliderIntersection, target?: RayColliderIntersection): RayColliderIntersection;
+}
+/**
+ * The time of impact between a ray and a collider.
+ */
+export declare class RayColliderHit {
+    /**
+     * The handle of the collider hit by the ray.
+     */
+    collider: Collider;
+    /**
+     * The time-of-impact of the ray with the collider.
+     *
+     * The hit point is obtained from the ray's origin and direction: `origin + dir * timeOfImpact`.
+     */
+    timeOfImpact: number;
+    constructor(collider: Collider, timeOfImpact: number);
+    static fromRaw(colliderSet: ColliderSet, raw: RawRayColliderHit): RayColliderHit;
+}