@absolutejs/rapier3d 0.0.0-stage → 0.1.0

package/dist/types/dynamics/soft_body_set.d.ts

@@ -0,0 +1,99 @@
+import { RawSoftBodySet } from "../raw";
+import { Vector } from "../math";
+import { SoftBody, SoftBodyDesc, SoftBodyHandle, SoftBodyTearEvent } from "./soft_body";
+import { RigidBodySet } from "./rigid_body_set";
+import { ColliderSet } from "../geometry";
+import { ImpulseJointSet } from "./impulse_joint_set";
+import { MultibodyJointSet } from "./multibody_joint_set";
+import { IslandManager } from "./island_manager";
+/**
+ * A set of soft bodies that can be handled by a physics pipeline.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `softBodySet.free()`
+ * once you are done using it (and all the soft bodies it created).
+ */
+export declare class SoftBodySet {
+    raw: RawSoftBodySet;
+    private map;
+    /**
+     * Release the WASM memory occupied by this soft-body set.
+     */
+    free(): void;
+    constructor(raw?: RawSoftBodySet);
+    /**
+     * Internal method, do not call this explicitly.
+     */
+    finalizeDeserialization(bodies: RigidBodySet, colliders: ColliderSet): void;
+    /**
+     * Creates a new soft body, its hidden root rigid body and its colliders, and returns it.
+     *
+     * @param bodies - The set of rigid bodies receiving the body's proxies.
+     * @param colliders - The set of colliders receiving the body's colliders.
+     * @param desc - The description of the soft body to create.
+     */
+    createSoftBody(bodies: RigidBodySet, colliders: ColliderSet, desc: SoftBodyDesc): SoftBody;
+    /**
+     * Removes a soft body from this set, with its proxies, colliders and attached joints.
+     */
+    remove(handle: SoftBodyHandle, islands: IslandManager, bodies: RigidBodySet, colliders: ColliderSet, impulseJoints: ImpulseJointSet, multibodyJoints: MultibodyJointSet): void;
+    /**
+     * Adds a cluster over the given particles: a rigid proxy that joints and colliders can
+     * attach to. Returns the cluster's index, or `null` if no particle was valid.
+     */
+    addCluster(handle: SoftBodyHandle, particles: Uint32Array | number[], bodies: RigidBodySet, colliders: ColliderSet): number | null;
+    /**
+     * Removes a cluster with its proxy, colliders and joints. Returns `false` if the cluster
+     * did not exist.
+     */
+    removeCluster(handle: SoftBodyHandle, cluster: number, islands: IslandManager, bodies: RigidBodySet, colliders: ColliderSet, impulseJoints: ImpulseJointSet, multibodyJoints: MultibodyJointSet): boolean;
+    /**
+     * Tears a soft body at once along the given edges and through the given cells, without
+     * removing material. Pieces disconnected by the tear become soft bodies of their own.
+     *
+     * Returns the tear event (which must be freed), or `null` when nothing changed.
+     */
+    tear(handle: SoftBodyHandle, edges: Uint32Array | number[], cells: Uint32Array | number[], islands: IslandManager, bodies: RigidBodySet, colliders: ColliderSet, impulseJoints: ImpulseJointSet, multibodyJoints: MultibodyJointSet): SoftBodyTearEvent | null;
+    /**
+     * Cuts a soft body along a blade: a segment (two points) in 2D, a triangle (three points)
+     * in 3D. Pieces disconnected by the cut become soft bodies of their own.
+     *
+     * Returns the tear event (which must be freed), or `null` when nothing changed.
+     */
+    cut(handle: SoftBodyHandle, blade: Vector[], islands: IslandManager, bodies: RigidBodySet, colliders: ColliderSet, impulseJoints: ImpulseJointSet, multibodyJoints: MultibodyJointSet): SoftBodyTearEvent | null;
+    /**
+     * Maps the soft bodies, proxies and colliders a topology change created, and unmaps what
+     * it removed.
+     */
+    private finishTopologyChange;
+    /**
+     * Wraps the soft bodies the engine created (the pieces a tear split off) that have no
+     * JavaScript wrapper yet; the pieces of a tear event are only reachable after this.
+     */
+    mapNewSoftBodies(bodies: RigidBodySet, colliders: ColliderSet): void;
+    /**
+     * Wakes a soft body and everything it touches up.
+     *
+     * @param strong - If `true` the bodies stay awake for a while even if they are at rest.
+     */
+    wakeUp(handle: SoftBodyHandle, bodies: RigidBodySet, strong: boolean): void;
+    /**
+     * The number of soft bodies on this set.
+     */
+    len(): number;
+    /**
+     * Does this set contain a soft body with the given handle?
+     */
+    contains(handle: SoftBodyHandle): boolean;
+    /**
+     * Gets the soft body with the given handle.
+     */
+    get(handle: SoftBodyHandle): SoftBody | null;
+    /**
+     * Applies the given closure to each soft body contained by this set.
+     */
+    forEach(f: (body: SoftBody) => void): void;
+    /**
+     * Gets all soft bodies in the list.
+     */
+    getAll(): SoftBody[];
+}

package/dist/types/exports.d.ts

@@ -0,0 +1,8 @@
+export declare function version(): string;
+export declare function reserveMemory(extraBytesCount: number): void;
+export * from "./math";
+export * from "./dynamics";
+export * from "./geometry";
+export * from "./pipeline";
+export * from "./init";
+export * from "./control";

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

@@ -0,0 +1,162 @@
+import { RawBroadPhase } from "../raw";
+import { RigidBodyHandle, RigidBodySet } from "../dynamics";
+import { ColliderSet } from "./collider_set";
+import { Ray, RayColliderHit, RayColliderIntersection } from "./ray";
+import { InteractionGroups } from "./interaction_groups";
+import { ColliderHandle } from "./collider";
+import { Rotation, Vector } from "../math";
+import { Shape } from "./shape";
+import { PointColliderProjection } from "./point";
+import { ColliderShapeCastHit } from "./toi";
+import { QueryFilterFlags } from "../pipeline";
+import { NarrowPhase } from "./narrow_phase";
+/**
+ * The broad-phase used for coarse collision-detection.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `broadPhase.free()`
+ * once you are done using it.
+ */
+export declare class BroadPhase {
+    raw: RawBroadPhase;
+    /**
+     * Release the WASM memory occupied by this broad-phase.
+     */
+    free(): void;
+    constructor(raw?: RawBroadPhase);
+    /**
+     * Find the closest intersection between a ray and a set of collider.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @param ray - The ray to cast.
+     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively
+     *   limits the length of the ray to `ray.dir.norm() * maxToi`.
+     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its
+     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,
+     *   whereas `false` implies that all shapes are hollow for this ray-cast.
+     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.
+     * @param filter - The callback to filter out which collider will be hit.
+     */
+    castRay(narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, ray: Ray, maxToi: number, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): RayColliderHit | null;
+    /**
+     * Find the closest intersection between a ray and a set of collider.
+     *
+     * This also computes the normal at the hit point.
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @param ray - The ray to cast.
+     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively
+     *   limits the length of the ray to `ray.dir.norm() * maxToi`.
+     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its
+     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,
+     *   whereas `false` implies that all shapes are hollow for this ray-cast.
+     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.
+     */
+    castRayAndGetNormal(narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, ray: Ray, maxToi: number, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean, target?: RayColliderIntersection): RayColliderIntersection | null;
+    /**
+     * Cast a ray and collects all the intersections between a ray and the scene.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @param ray - The ray to cast.
+     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively
+     *   limits the length of the ray to `ray.dir.norm() * maxToi`.
+     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its
+     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,
+     *   whereas `false` implies that all shapes are hollow for this ray-cast.
+     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.
+     * @param callback - The callback called once per hit (in no particular order) between a ray and a collider.
+     *   If this callback returns `false`, then the cast will stop and no further hits will be detected/reported.
+     */
+    intersectionsWithRay(narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, ray: Ray, maxToi: number, solid: boolean, callback: (intersect: RayColliderIntersection) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): void;
+    /**
+     * Gets the handle of up to one collider intersecting the given shape.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @param shapePos - The position of the shape used for the intersection test.
+     * @param shapeRot - The orientation of the shape used for the intersection test.
+     * @param shape - The shape used for the intersection test.
+     * @param groups - The bit groups and filter associated to the ray, in order to only
+     *   hit the colliders with collision groups compatible with the ray's group.
+     */
+    intersectionWithShape(narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, shapePos: Vector, shapeRot: Rotation, shape: Shape, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): ColliderHandle | null;
+    /**
+     * Find the projection of a point on the closest collider.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @param point - The point to project.
+     * @param solid - If this is set to `true` then the collider shapes are considered to
+     *   be plain (if the point is located inside of a plain shape, its projection is the point
+     *   itself). If it is set to `false` the collider shapes are considered to be hollow
+     *   (if the point is located inside of an hollow shape, it is projected on the shape's
+     *   boundary).
+     * @param groups - The bit groups and filter associated to the point to project, in order to only
+     *   project on colliders with collision groups compatible with the ray's group.
+     */
+    projectPoint(narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, point: Vector, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean, target?: PointColliderProjection): PointColliderProjection | null;
+    /**
+     * Find the projection of a point on the closest collider.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @param point - The point to project.
+     * @param groups - The bit groups and filter associated to the point to project, in order to only
+     *   project on colliders with collision groups compatible with the ray's group.
+     */
+    projectPointAndGetFeature(narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, point: Vector, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean, target?: PointColliderProjection): PointColliderProjection | null;
+    /**
+     * Find all the colliders containing the given point.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @param point - The point used for the containment test.
+     * @param groups - The bit groups and filter associated to the point to test, in order to only
+     *   test on colliders with collision groups compatible with the ray's group.
+     * @param callback - A function called with the handles of each collider with a shape
+     *   containing the `point`.
+     */
+    intersectionsWithPoint(narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, point: Vector, callback: (handle: ColliderHandle) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): void;
+    /**
+     * Casts a shape at a constant linear velocity and retrieve the first collider it hits.
+     * This is similar to ray-casting except that we are casting a whole shape instead of
+     * just a point (the ray origin).
+     *
+     * In the returned hit, `witness1` and `normal1` lie on the hit collider and are expressed in
+     * world-space, while `witness2` and `normal2` lie on the cast shape and are expressed in its
+     * local-space (relative to `shapePos` and `shapeRot`).
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @param shapePos - The initial position of the shape to cast.
+     * @param shapeRot - The initial rotation of the shape to cast.
+     * @param shapeVel - The constant velocity of the shape to cast (i.e. the cast direction).
+     * @param shape - The shape to cast.
+     * @param targetDistance − If the shape moves closer to this distance from a collider, a hit
+     *                       will be returned.
+     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively
+     *   limits the distance traveled by the shape to `shapeVel.norm() * maxToi`.
+     * @param stopAtPenetration - If set to `false`, the linear shape-cast won’t immediately stop if
+     *   the shape is penetrating another shape at its starting point **and** its trajectory is such
+     *   that it’s on a path to exit that penetration state.
+     * @param groups - The bit groups and filter associated to the shape to cast, in order to only
+     *   test on colliders with collision groups compatible with this group.
+     * @param {ColliderShapeCastHit?} target - The object to be populated. If provided,
+     * the function returns this object instead of creating a new one.
+     */
+    castShape(narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, shapePos: Vector, shapeRot: Rotation, shapeVel: Vector, shape: Shape, targetDistance: number, maxToi: number, stopAtPenetration: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean, target?: ColliderShapeCastHit): ColliderShapeCastHit | null;
+    /**
+     * Retrieve all the colliders intersecting the given shape.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @param shapePos - The position of the shape to test.
+     * @param shapeRot - The orientation of the shape to test.
+     * @param shape - The shape to test.
+     * @param groups - The bit groups and filter associated to the shape to test, in order to only
+     *   test on colliders with collision groups compatible with this group.
+     * @param callback - A function called with the handles of each collider intersecting the `shape`.
+     */
+    intersectionsWithShape(narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, shapePos: Vector, shapeRot: Rotation, shape: Shape, callback: (handle: ColliderHandle) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: ColliderHandle, filterExcludeRigidBody?: RigidBodyHandle, filterPredicate?: (collider: ColliderHandle) => boolean): void;
+    /**
+     * Finds the handles of all the colliders with an AABB intersecting the given AABB.
+     *
+     * @param aabbCenter - The center of the AABB to test.
+     * @param aabbHalfExtents - The half-extents of the AABB to test.
+     * @param callback - The callback that will be called with the handles of all the colliders
+     *                   currently intersecting the given AABB.
+     */
+    collidersWithAabbIntersectingAabb(narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, aabbCenter: Vector, aabbHalfExtents: Vector, callback: (handle: ColliderHandle) => boolean): void;
+}