@tushar-br/desktop 1.0.173 → 1.0.174

package/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/geometry/collider_set.d.ts

@@ -0,0 +1,72 @@
+import { RawColliderSet } from "../raw";
+import { Collider, ColliderDesc, ColliderHandle } from "./collider";
+import { ImpulseJointHandle, IslandManager, RigidBodyHandle } from "../dynamics";
+import { RigidBodySet } 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;
+    /**
+     * 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, 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/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/geometry/contact.d.ts

@@ -0,0 +1,31 @@
+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);
+    static fromRaw(raw: RawShapeContact): ShapeContact;
+}

package/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/geometry/feature.d.ts

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

package/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/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/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/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 declare type InteractionGroups = number;

package/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/geometry/narrow_phase.d.ts

@@ -0,0 +1,71 @@
+import { RawNarrowPhase, RawContactManifold } from "../raw";
+import { ColliderHandle } from "./collider";
+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 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, f: (manifold: TempContactManifold, 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;
+    free(): void;
+    constructor(raw: RawContactManifold);
+    normal(): Vector;
+    localNormal1(): Vector;
+    localNormal2(): Vector;
+    subshape1(): number;
+    subshape2(): number;
+    numContacts(): number;
+    localContactPoint1(i: number): Vector | null;
+    localContactPoint2(i: number): 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;
+    solverContactPoint(i: number): Vector;
+    solverContactDist(i: number): number;
+    solverContactFriction(i: number): number;
+    solverContactRestitution(i: number): number;
+    solverContactTangentVelocity(i: number): Vector;
+}

package/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/geometry/point.d.ts

@@ -0,0 +1,47 @@
+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);
+    static fromRaw(raw: RawPointProjection): 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);
+    static fromRaw(colliderSet: ColliderSet, raw: RawPointColliderProjection): PointColliderProjection;
+}

package/staging_area/desktop/car gaem/node_modules/@dimforge/rapier3d-compat/geometry/ray.d.ts

@@ -0,0 +1,97 @@
+import { Vector } from "../math";
+import { RawRayColliderIntersection, RawRayColliderToi, 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 * toi`.
+     */
+    toi: 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(toi: number, normal: Vector, featureType?: FeatureType, featureId?: number);
+    static fromRaw(raw: RawRayIntersection): 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 * toi`.
+     */
+    toi: 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, toi: number, normal: Vector, featureType?: FeatureType, featureId?: number);
+    static fromRaw(colliderSet: ColliderSet, raw: RawRayColliderIntersection): RayColliderIntersection;
+}
+/**
+ * The time of impact between a ray and a collider.
+ */
+export declare class RayColliderToi {
+    /**
+     * 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 * toi`.
+     */
+    toi: number;
+    constructor(collider: Collider, toi: number);
+    static fromRaw(colliderSet: ColliderSet, raw: RawRayColliderToi): RayColliderToi;
+}