@absolutejs/rapier3d 0.18.0 → 0.21.0

package/dist/types/build-info.d.ts

@@ -10,6 +10,8 @@ export interface PhysicsBuildInfo {
     /** Collision library version and exact Cargo source identity used by this build. */
     readonly collisionLibraryVersion: string;
     readonly collisionSource: string;
+    /** Arithmetic used to reconstruct public convex boundaries; contact storage stays f32. */
+    readonly convexExportPrecision: 'float64';
     readonly bindings: string;
     readonly bindgen: string;
     readonly wasmSha256: string;

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

@@ -10,3 +10,5 @@ export * from "./ccd_solver";
 export * from "./island_manager";
 export * from "./soft_body";
 export * from "./soft_body_set";
+export * from "./quadratic_drag";
+export * from "./quadratic_drag_patches";

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

@@ -0,0 +1,26 @@
+/** One scalar velocity-dependent resistance channel. Use one consistent length
+ * unit for speed, impulse, resistance and energy; mass remains kg. */
+export type QuadraticDragInput = {
+    /** Body-point speed minus fluid speed along the impulse direction. */
+    relativeSpeed: number;
+    /** Fluid speed along the same direction, for reservoir-work accounting. */
+    fluidSpeed: number;
+    /** Positive effective inverse mass including the point's angular response. */
+    inverseEffectiveMass: number;
+    /** Nonnegative coefficient k in resistance = -k |v| v. No default Cd. */
+    quadraticResistance: number;
+    dt: number;
+};
+/** Backward-Euler quadratic resistance, solved analytically without reversal.
+ * Pure calculation: does not change a body, infer exposure, or choose drag
+ * coefficients. For point impulses the caller supplies the complete effective
+ * inverse mass, including rotational/coupled response. Returned work is the
+ * exact frozen-mass impulse work, not a time-continuous CFD energy estimate.
+ * Native application precision must be checked independently by the caller. */
+export declare function solveQuadraticDragImpulse(input: QuadraticDragInput): {
+    impulse: number;
+    relativeSpeedAfter: number;
+    dissipatedEnergy: number;
+    bodyWork: number;
+    reservoirWork: number;
+};

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

@@ -0,0 +1,38 @@
+import type { Vector } from '../math';
+export type QuadraticDragPatch = {
+    /** World-space offset from the mass centre, in the chosen length unit. */
+    offset: Vector;
+    /** Nonzero direction; normalized by the solver without changing the input. */
+    direction: Vector;
+    fluidVelocity: Vector;
+    quadraticResistance: number;
+    /** Skip nonpositive relative speed, for a caller-selected exposed side. */
+    oneSided: boolean;
+};
+export type QuadraticDragPatchesInput = {
+    linearVelocity: Vector;
+    angularVelocity: Vector;
+    /** Diagonal translational inverse mass, including locked axes. */
+    inverseMass: Vector;
+    /** Symmetric world inverse inertia: xx, xy, xz, yy, yz, zz. */
+    inverseInertia: readonly [number, number, number, number, number, number];
+    patches: readonly QuadraticDragPatch[];
+    dt: number;
+};
+/** Sequential frozen-pose patch solve in JS double precision, returning one
+ * accumulated linear/angular impulse. This avoids repeated native Float32
+ * velocity rounding. Patch order is explicit and finite-step convergence must
+ * be measured; no fluid exposure or coefficients are inferred. Free rigid-body
+ * response only: articulated/constraint-coupled response is not represented by
+ * this block-diagonal inverse mass. Inputs are borrowed; outputs are owned. */
+export declare function solveQuadraticDragPatches(input: QuadraticDragPatchesInput): {
+    impulse: Vector;
+    angularImpulse: Vector;
+    linearVelocity: Vector;
+    angularVelocity: Vector;
+    dissipatedEnergy: number;
+    reservoirWork: number;
+    bodyWork: number;
+    activePatches: number;
+    lockedPatches: number;
+};

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

@@ -478,6 +478,16 @@ export declare class Collider {
      * this returns the index buffer of said shape.
      */
     indices(): Uint32Array | undefined;
+    /**
+     * Owned vertices and indices of the current convex core, computed together.
+     * Reconstructs the boundary once instead of once per separate buffer query.
+     * Rounded convex shapes exclude their border radius. Other shapes return
+     * undefined. Mutating returned arrays does not change this collider.
+     */
+    convexMeshData(): {
+        vertices: Float32Array;
+        indices: Uint32Array;
+    } | undefined;
     /**
      * If this collider has a heightfield shape, this returns the heights buffer of
      * the heightfield.

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

@@ -6,3 +6,5 @@ export * from "./physics_hooks";
 export * from "./debug_render_pipeline";
 export * from "./query_pipeline";
 export * from "./step_profile";
+export * from "./solver_schedule";
+export * from "./step_profile_packet";

package/dist/types/pipeline/solver_schedule.d.ts

@@ -0,0 +1,5 @@
+import type { SolverScheduleStats } from './world';
+/** Validate a copied schedule without coercion, property getters or mutation.
+ * Extra application metadata is ignored. This checks internal scalar consistency,
+ * not provenance, freshness, per-body identity or physical solver correctness. */
+export declare function isSolverScheduleStats(value: unknown): value is SolverScheduleStats;

package/dist/types/pipeline/step_profile.d.ts

@@ -1,5 +1,5 @@
 import type { ContactSoftness } from "../dynamics/integration_parameters";
-import type { World, ContactConvergenceStats, FreeRotationStats, FreeAssemblyStats } from "./world";
+import type { World, ContactConvergenceStats, FreeRotationStats, FreeAssemblyStats, SolverScheduleStats } from "./world";
 import type { EventQueue } from "./event_queue";
 import type { PhysicsHooks } from "./physics_hooks";
 export interface PhysicsContactSettings {
@@ -31,6 +31,9 @@ export interface PhysicsStepSample {
         convergence: ContactConvergenceStats;
         freeRotation: FreeRotationStats;
         freeAssembly: FreeAssemblyStats;
+        /** Index into the owning profile's bounded solverSchedules table. */
+        /** Omitted means table entry 0; the table is always present. */
+        solverScheduleIndex?: number;
     } | null;
 }
 export interface PhysicsStepProfile {
@@ -52,6 +55,8 @@ export interface PhysicsStepProfile {
     samples: PhysicsStepSample[];
     /** Distinct numerical settings, at most one entry per retained sample. */
     contactSettings: PhysicsContactSettings[];
+    /** Distinct owned schedules, at most one per retained sample. */
+    solverSchedules: SolverScheduleStats[];
 }
 export interface PhysicsStepProfileOptions {
     /** Capture every Nth managed call, default 32; integer 1..1,000,000. */

package/dist/types/pipeline/step_profile_packet.d.ts

@@ -0,0 +1,18 @@
+import type { PhysicsStepProfile } from './step_profile';
+type Cell = number | null | '-0';
+/** Versioned numeric transport. The single '-0' tag preserves signed zero in JSON.
+ * No user strings or arbitrary application metadata are encoded. */
+export interface PhysicsStepProfilePacket {
+    format: 'absolutejs-physics-step-profile/1';
+    header: Cell[];
+    contactSettings: Cell[][];
+    solverSchedules: Cell[][];
+    samples: Array<[Cell, 0 | 1, Cell, 0 | 1 | 2, Cell[] | null]>;
+}
+/** Decode bounded, owned readable observations. This validates encoding and
+ * internal scalar consistency, not native provenance or physical correctness. */
+export declare function decodePhysicsStepProfile(value: unknown): PhysicsStepProfile;
+/** Encode the defined profile fields without rounding or losing observations.
+ * Arrays are bounded before traversal. Decode to recover human-readable labels. */
+export declare function encodePhysicsStepProfile(profile: PhysicsStepProfile): PhysicsStepProfilePacket;
+export {};

package/dist/types/pipeline/world.d.ts

@@ -14,6 +14,17 @@ import { DynamicRayCastVehicleController } from "../control";
  * Counts describe solve groups/phases, not individual contacts or physical islands.
  * Residuals are projected normal velocity errors in world units per second.
  */
+/** Prepared rigid-body schedules, summed across CCD passes. Counts are not unique
+ * bodies or iterations of the internal PGS loop. Empty groups are omitted. */
+export interface SolverScheduleStats {
+    groupVisits: number;
+    rigidBodyVisits: number;
+    rigidBodySubsteps: number;
+    minSubsteps: number | null;
+    maxSubsteps: number | null;
+    minSubstepDt: number | null;
+    maxSubstepDt: number | null;
+}
 export interface ContactConvergenceStats {
     compressionSolves: number;
     compressionIterations: number;
@@ -620,6 +631,12 @@ export declare class World {
      * Reading or modifying the result never changes simulation.
      */
     freeRotationStats(): FreeRotationStats | null;
+    /** Owned schedule observations from the last completed profiled step. Null
+     * before completion, with profiling disabled/toggled, or after restore.
+     * Min/max values are null when no nonempty rigid group was prepared. This
+     * reports prepared groups, not per-body identities, solver CPU time or a
+     * forecast for the next step; it must not select gameplay force timing. */
+    solverSchedule(): SolverScheduleStats | null;
     /** Owned observations from the last completed profiled step; null before
      * that step, after toggling profiling, when disabled, or after restoration.
      * Zero solves means no eligible adaptive path, not proof of convergence.

package/dist/types/rapier_wasm3d.d.ts

@@ -70,6 +70,11 @@ export class RawColliderSet {
     coContactShape(handle: number, shape2: RawShape, shapePos2: RawVector, shapeRot2: RawRotation, prediction: number): RawShapeContact | undefined;
     coContactSkin(handle: number): number;
     coContainsPoint(handle: number, point: RawVector): boolean;
+    /**
+     * Owned core boundary of a convex collider, reconstructed only once.
+     * Rounded shapes exclude their border radius from this core mesh.
+     */
+    coConvexMeshData(handle: number): RawConvexMeshData | undefined;
     /**
      * The density of this collider.
      */
@@ -910,6 +915,7 @@ export class RawPhysicsPipeline {
     is_profiler_enabled(): boolean;
     constructor();
     set_profiler_enabled(enabled: boolean): void;
+    solver_schedule(): Float64Array | undefined;
     stepWithEvents(gravity: RawVector, integrationParameters: RawIntegrationParameters, islands: RawIslandManager, broadPhase: RawBroadPhase, narrowPhase: RawNarrowPhase, bodies: RawRigidBodySet, colliders: RawColliderSet, softBodies: RawSoftBodySet, joints: RawImpulseJointSet, articulations: RawMultibodyJointSet, ccd_solver: RawCCDSolver, eventQueue: RawEventQueue, hookObject: object, hookFilterContactPair: Function, hookFilterIntersectionPair: Function): void;
     step(gravity: RawVector, integrationParameters: RawIntegrationParameters, islands: RawIslandManager, broadPhase: RawBroadPhase, narrowPhase: RawNarrowPhase, bodies: RawRigidBodySet, colliders: RawColliderSet, softBodies: RawSoftBodySet, joints: RawImpulseJointSet, articulations: RawMultibodyJointSet, ccd_solver: RawCCDSolver): void;
     timing_broad_phase(): number;
@@ -2101,6 +2107,7 @@ export interface InitOutput {
     readonly rawcolliderset_coContactShape: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
     readonly rawcolliderset_coContactSkin: (a: number, b: number) => number;
     readonly rawcolliderset_coContainsPoint: (a: number, b: number, c: number) => number;
+    readonly rawcolliderset_coConvexMeshData: (a: number, b: number) => number;
     readonly rawcolliderset_coDensity: (a: number, b: number) => number;
     readonly rawcolliderset_coFriction: (a: number, b: number) => number;
     readonly rawcolliderset_coFrictionCombineRule: (a: number, b: number) => number;
@@ -2423,6 +2430,7 @@ export interface InitOutput {
     readonly rawphysicspipeline_is_profiler_enabled: (a: number) => number;
     readonly rawphysicspipeline_new: () => number;
     readonly rawphysicspipeline_set_profiler_enabled: (a: number, b: number) => void;
+    readonly rawphysicspipeline_solver_schedule: (a: number, b: number) => void;
     readonly rawphysicspipeline_step: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
     readonly rawphysicspipeline_stepWithEvents: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number) => void;
     readonly rawphysicspipeline_timing_broad_phase: (a: number) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/rapier3d",
-  "version": "0.18.0",
+  "version": "0.21.0",
   "description": "Rapier 3D with matched free-body rotation, corrected contact witnesses and solver diagnostics",
   "type": "module",
   "license": "Apache-2.0",