@orillusion/physics-rapier 0.1.0

package/README.md

@@ -0,0 +1,158 @@
+# @orillusion/physics-rapier
+
+Rapier-backed physics plugin for Orillusion (WebGPU engine).
+
+Independent of `@orillusion/physics` (which uses Bullet/ammo). Both packages
+can coexist in one project — `physics-rapier` is the recommended path for new
+work; `physics` remains supported for soft-body cases until a GPU XPBD plugin
+ships.
+
+## Why Rapier
+
+| | `@orillusion/physics` (ammo) | `@orillusion/physics-rapier` |
+|---|---|---|
+| Backend | Bullet 2.x via Emscripten asm.js | Rapier (Rust → WASM) |
+| Bundle size | ~1.95 MB | ~600 KB (compat) |
+| TypeScript | Community .d.ts | Official .d.ts |
+| Determinism | No | Yes |
+| Public raycast / sweep / overlap | Missing | `PhysicsQuery.*` |
+| Character controller | Missing | `CharacterController` |
+| Vehicle | Bare `btRaycastVehicle` | `VehicleController` |
+| Soft body | Yes (cloth, rope) | No (use ammo, or future XPBD) |
+| Snapshots / replay | Partial | `Physics.snapshot/restore` |
+
+## Quick start
+
+```ts
+import { Engine3D, Object3D, MeshRenderer, BoxGeometry, LitMaterial, Vector3 } from '@orillusion/core';
+import { Physics, Rigidbody, BodyType, CollisionShapeUtil } from '@orillusion/physics-rapier';
+
+await Physics.init();
+const engine = await Engine3D.init({ renderLoop: () => Physics.update() });
+
+const cube = new Object3D();
+cube.y = 5;
+const mr = cube.addComponent(MeshRenderer);
+mr.geometry = new BoxGeometry(1, 1, 1);
+mr.material = new LitMaterial();
+
+const rb = cube.addComponent(Rigidbody);
+rb.bodyType = BodyType.Dynamic;
+rb.mass = 1;
+rb.shape = CollisionShapeUtil.createBoxShape(cube, new Vector3(1, 1, 1));
+```
+
+## Module map
+
+| Path | Class | Purpose |
+|---|---|---|
+| `Physics` | `Physics` (singleton) | World, step, snapshot, gravity |
+| `rigidbody/Rigidbody` | `Rigidbody` | Dynamic/Static/Kinematic body component |
+| `rigidbody/RigidbodyEnum` | `BodyType` | Body kind enum |
+| `shape/CollisionShapeUtil` | `CollisionShapeUtil` | Box / Sphere / Capsule / Cylinder / Cone / Plane / ConvexHull / Trimesh / Heightfield / Compound |
+| `joint/HingeJoint` | `HingeJoint` | 1 angular DOF (revolute) |
+| `joint/SliderJoint` | `SliderJoint` | 1 linear DOF (prismatic) |
+| `joint/FixedJoint` | `FixedJoint` | All 6 DOFs locked |
+| `joint/SphericalJoint` | `SphericalJoint` | Ball-and-socket (replaces P2P + ConeTwist) |
+| `joint/GenericJoint` | `GenericJoint` | 6-DOF, axis mask |
+| `joint/RopeJoint` | `RopeJoint` | Max distance constraint |
+| `joint/SpringJoint` | `SpringJoint` | Hooke's law spring |
+| `character/CharacterController` | `CharacterController` | Kinematic character with slope/step/snap |
+| `vehicle/VehicleController` | `VehicleController` | Raycast vehicle (chassis + N wheels) |
+| `query/PhysicsQuery` | `PhysicsQuery` | `raycast / raycastAll / sweep / overlap / closestPoint` |
+| `debug/PhysicsDebugDrawer` | `PhysicsDebugDrawer` | Live wireframe via `Graphic3D` |
+| `utils/PhysicsDragger` | `PhysicsDragger` | Mouse drag for dynamic bodies |
+| `utils/TempPhyMath` | `TempPhyMath` | `Vector3`/`Quaternion` ↔ Rapier POJO helpers |
+
+## Triggers and events
+
+```ts
+const sensor = obj.addComponent(Rigidbody);
+sensor.bodyType = BodyType.Static;
+sensor.shape = CollisionShapeUtil.createBoxShape(obj, new Vector3(2, 2, 2));
+sensor.isSensor = true;        // must be set before start()
+sensor.enableEvents = true;    // must be set before start()
+sensor.onTriggerEnter = (other) => console.log('entered', other.object3D.name);
+sensor.onTriggerExit  = (other) => console.log('left',    other.object3D.name);
+
+// On a dynamic body, the same flag plus contact callbacks:
+const rb = body.addComponent(Rigidbody);
+rb.enableEvents = true;
+rb.onContactBegin = (other) => { /* one-shot */ };
+rb.onContactStay  = (other) => { /* every frame while touching */ };
+rb.onContactEnd   = (other) => { /* one-shot */ };
+```
+
+## Queries
+
+```ts
+import { PhysicsQuery } from '@orillusion/physics-rapier';
+
+const hit = PhysicsQuery.raycast(origin, dir, { maxDistance: 100 });
+if (hit) console.log(hit.rigidbody, hit.point, hit.normal);
+
+const overlapping = PhysicsQuery.overlap(
+    CollisionShapeUtil.createBoxShape(obj, new Vector3(2, 2, 2)),
+    pos, rot, { excludeSensors: true },
+);
+```
+
+## Snapshot / replay
+
+```ts
+const blob = Physics.snapshot();      // Uint8Array
+// ... time passes ...
+Physics.restore(blob);                // world rewound
+// NOTE: engine-side Rigidbody bindings are not restored automatically.
+// See samples/physics-rapier/Sample_RapierSnapshot.ts for the pattern.
+```
+
+## Migration from `@orillusion/physics` (ammo)
+
+For most projects:
+
+```ts
+- import { Physics, Rigidbody, ColliderComponent, BoxColliderShape, ... } from '@orillusion/physics';
++ import { Physics, Rigidbody, BodyType, CollisionShapeUtil } from '@orillusion/physics-rapier';
+```
+
+Behavioral differences:
+
+| ammo | physics-rapier |
+|---|---|
+| `rb.mass = 0` for static | `rb.bodyType = BodyType.Static` *(or `mass = 0`, both work)* |
+| `ColliderComponent` + `BoxColliderShape` | `rb.shape = CollisionShapeUtil.createBoxShape(obj)` (no separate collider component) |
+| `setCcdMotionThreshold(t) + setCcdSweptSphereRadius(r)` | `rb.enableCcd(true)` |
+| `setLinearFactor(x, y, z)` | `rb.lockTranslations(x === 0, y === 0, z === 0)` |
+| `Physics.world.rayTest(...)` (private) | `PhysicsQuery.raycast(origin, dir, { ... })` |
+| `Ammo.btRaycastVehicle` raw API | `VehicleController` component |
+| Soft body (`ClothSoftbody`, `RopeSoftbody`) | NOT SUPPORTED — keep using `@orillusion/physics` |
+| Joints: `HingeConstraint`, `SliderConstraint`, ... | Renamed to `HingeJoint`, `SliderJoint`, ... |
+| `PointToPointConstraint` + `ConeTwistConstraint` | Both replaced by `SphericalJoint` |
+| `Generic6DofConstraint` + `Generic6DofSpringConstraint` | Replaced by `GenericJoint` (spring built-in) + `SpringJoint` |
+
+## Escape hatches
+
+When you need a Rapier-only feature that the engine wrapper doesn't expose:
+
+```ts
+import RAPIER from '@dimforge/rapier3d-compat';
+
+const native = rb.native;             // Rapier RigidBody
+native.setEnabledRotations(true, false, true, true);
+
+const world = Physics.world;          // Rapier World
+world.integrationParameters.numSolverIterations = 8;
+```
+
+Touching `.native` or `Physics.world` opts out of cross-backend portability.
+
+## Roadmap
+
+- **Done (P0–P2):** rigid bodies, 7 joints, character, vehicle, queries, events, debug, dragger, snapshot, deterministic flag.
+- **Future:** Web Worker mode (`Physics.init({ worker: true })` is API-stable; landing pending COOP/COEP infrastructure).
+- **Future:** GPU XPBD soft body / cloth / fluid as a separate `@orillusion/physics-xpbd` package.
+
+## License
+
+MIT

package/dist/Physics.d.ts

@@ -0,0 +1,114 @@
+import RAPIER from '@dimforge/rapier3d-compat';
+import { Vector3, View3D } from '@orillusion/core';
+import { PhysicsDebugDrawer, DebugDrawerOptions } from './debug/PhysicsDebugDrawer';
+import { PhysicsDragger } from './utils/PhysicsDragger';
+import type { Rigidbody } from './rigidbody/Rigidbody';
+declare class _Physics {
+    private _world;
+    private _eventQueue;
+    private _isInited;
+    private _isStop;
+    private _gravity;
+    /** Maximum number of internal physics sub-steps per update tick. */
+    maxSubSteps: number;
+    /** Fixed simulation timestep used to clamp variable frame deltas. */
+    fixedTimeStep: number;
+    /** @internal Collider handle → Rigidbody component. */
+    private _handleToRigidbody;
+    /** @internal Vehicle controllers needing per-frame `updateVehicle()`. */
+    private _preStepCallbacks;
+    private _debugDrawer;
+    private _dragger;
+    /**
+     * Initialize Rapier physics world.
+     *
+     * @param options.gravity - Default `(0, -9.8, 0)`.
+     * @param options.deterministic - When `true`, force a single-thread serial
+     *   solver path so simulation is bit-exact across runs / machines (cost:
+     *   ~10-20% perf). Rapier is largely deterministic by default within the
+     *   same WASM build; this flag pins additional knobs for cross-machine
+     *   reproducibility.
+     * @param options.worker - Reserved for future use. When set, the world
+     *   would be marshalled into a Web Worker via SharedArrayBuffer. Currently
+     *   logs a one-time warning and falls back to main-thread execution; the
+     *   API is stable enough that user code passing this flag will Just Work
+     *   when worker mode lands.
+     */
+    init(options?: {
+        gravity?: Vector3;
+        deterministic?: boolean;
+        worker?: boolean;
+    }): Promise<void>;
+    /**
+     * Step the physics world. Drains the event queue and dispatches contact /
+     * trigger callbacks back onto registered Rigidbody components.
+     *
+     * @param timeStep - Default `Time.delta * 0.001`. Clamped against
+     *   `fixedTimeStep * maxSubSteps` to avoid spiral-of-death.
+     */
+    update(timeStep?: number): void;
+    /**
+     * Enable physics debug drawing. Pass a `Graphic3D` instance attached to your scene.
+     */
+    initDebugDrawer(graphic3D: any, options?: DebugDrawerOptions): PhysicsDebugDrawer;
+    get debugDrawer(): PhysicsDebugDrawer;
+    /**
+     * Enable mouse drag of dynamic rigid bodies. Safe to call at any point
+     * after `Physics.init`; if `view.engine3D` is not yet bound (i.e. called
+     * before `engine.startRenderView`), the dragger defers event registration
+     * to the next animation frame and picks up the input system once
+     * `startRenderView` runs.
+     */
+    enableDragger(view: View3D): PhysicsDragger;
+    get dragger(): PhysicsDragger;
+    /**
+     * Serialize the entire physics world to a transferable byte array.
+     *
+     * Use this for replay / network rollback / save-game state. Rapier
+     * snapshots preserve body/collider handle indices, which lets `restore`
+     * re-attach existing `Rigidbody` components to the rebuilt world without
+     * tearing down Object3Ds.
+     *
+     * Caveats: snapshots do NOT round-trip Rapier-side controllers (vehicle,
+     * character) or engine-only metadata (`onContactBegin` callbacks, sensor
+     * flags rebuilt at collider-create time). If you use those, recreate them
+     * after `restore`.
+     */
+    snapshot(): Uint8Array;
+    /**
+     * Replace the active world with a previously taken snapshot.
+     *
+     * Re-binds existing `Rigidbody` components to wrappers in the new world
+     * using preserved handle indices, so components stay live after restore.
+     * Any Rigidbody whose body handle is not present in the snapshot (e.g.
+     * spawned after the snapshot was taken) is detached and emits a warning.
+     */
+    restore(data: Uint8Array): void;
+    get world(): RAPIER.World;
+    get eventQueue(): RAPIER.EventQueue;
+    get isInited(): boolean;
+    set isStop(value: boolean);
+    get isStop(): boolean;
+    set gravity(value: Vector3);
+    get gravity(): Vector3;
+    /** @internal Used by Rigidbody.start to register all colliders for events. */
+    _registerRigidbody(rb: Rigidbody): void;
+    /** @internal */
+    _unregisterRigidbody(rb: Rigidbody): void;
+    /** @internal Lookup the Rigidbody component owning a Rapier collider handle. */
+    _rigidbodyOfHandle(handle: number): Rigidbody | undefined;
+    /** Register a callback to run before every world.step (used by VehicleController). */
+    addPreStep(cb: (dt: number) => void): void;
+    removePreStep(cb: (dt: number) => void): void;
+}
+/**
+ * Single physics instance, mirroring `@orillusion/physics` Physics symbol.
+ *
+ * ```ts
+ * await Physics.init();
+ * ```
+ *
+ * @group Plugin
+ */
+export declare let Physics: _Physics;
+export { RAPIER };

package/dist/character/CharacterController.d.ts

@@ -0,0 +1,54 @@
+import { ComponentBase, Vector3 } from '@orillusion/core';
+import RAPIER from '@dimforge/rapier3d-compat';
+/**
+ * Kinematic character controller — Rapier-only, no ammo equivalent.
+ *
+ * Owns its own kinematic-position-based body and collider; user calls `move()`
+ * each frame with a desired translation, controller resolves penetration,
+ * slope climbing, snap-to-ground.
+ *
+ * @group Components
+ */
+export declare class CharacterController extends ComponentBase {
+    private _initResolve;
+    private _initializationPromise;
+    private _body;
+    private _collider;
+    private _controller;
+    private _bodyInited;
+    private _grounded;
+    /** Collider descriptor (typically a capsule). Set BEFORE `start()`. */
+    shape: RAPIER.ColliderDesc;
+    /** Penetration prediction offset. Default `0.01`. */
+    offset: number;
+    /** Maximum slope angle the character can walk up (radians). */
+    maxSlopeClimbAngle: number;
+    /** Below this slope angle the character starts sliding (radians). */
+    minSlopeSlideAngle: number;
+    /** Snap-to-ground distance. `0` disables snapping. */
+    snapToGround: number;
+    /** Whether character pushes dynamic bodies it collides with. */
+    applyImpulsesToDynamicBodies: boolean;
+    /** Auto-step config: `null` to disable. */
+    autoStep: {
+        maxHeight: number;
+        minWidth: number;
+        includeDynamic: boolean;
+    } | null;
+    start(): void;
+    /**
+     * Compute and apply a movement step. Internal pipeline:
+     * 1. computeColliderMovement(desired) → resolves penetration / slopes
+     * 2. read computedMovement() & computedGrounded()
+     * 3. setNextKinematicTranslation to apply
+     */
+    move(desiredTranslation: Vector3): void;
+    onUpdate(): void;
+    destroy(force?: boolean): void;
+    wait(): Promise<void>;
+    /** Whether the character is touching the ground after the last `move()`. */
+    isGrounded(): boolean;
+    get body(): RAPIER.RigidBody;
+    get collider(): RAPIER.Collider;
+    get native(): RAPIER.KinematicCharacterController;
+}

package/dist/debug/PhysicsDebugDrawer.d.ts

@@ -0,0 +1,38 @@
+export interface DebugDrawerOptions {
+    enable?: boolean;
+    /** Draw every N frames. Default 1 = every frame. */
+    updateFreq?: number;
+    /** Hard cap on rendered segments to prevent UI freeze on huge scenes. */
+    maxLineCount?: number;
+}
+/**
+ * Visualize the physics world via `world.debugRender()`. Wraps the
+ * `Graphic3D` line renderer.
+ *
+ * Mirrors `@orillusion/physics`'s `PhysicsDebugDrawer` shape, but uses Rapier's
+ * built-in debug renderer (returns line buffer + color buffer in one call).
+ *
+ * @example
+ * ```ts
+ * const g = new Graphic3D();
+ * scene.addChild(g);
+ * Physics.initDebugDrawer(g);
+ * ```
+ */
+export declare class PhysicsDebugDrawer {
+    private _enable;
+    private _frameCount;
+    private _drawnUuids;
+    /** A `Graphic3D` instance (typed loosely so this package doesn't hard-depend on `@orillusion/graphic`). */
+    graphic3D: any;
+    updateFreq: number;
+    maxLineCount: number;
+    private readonly _tmpA;
+    private readonly _tmpB;
+    constructor(graphic3D: any, options?: DebugDrawerOptions);
+    set enable(value: boolean);
+    get enable(): boolean;
+    /** Called once per frame from `Physics.update`. */
+    update(): void;
+    private _clearLines;
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from './Physics';
+export * from './utils/TempPhyMath';
+export * from './utils/PhysicsDragger';
+export * from './rigidbody/RigidbodyEnum';
+export * from './rigidbody/Rigidbody';
+export * from './shape/CollisionShapeUtil';
+export * from './joint/ConstraintBase';
+export * from './joint/HingeJoint';
+export * from './joint/SliderJoint';
+export * from './joint/FixedJoint';
+export * from './joint/SphericalJoint';
+export * from './joint/GenericJoint';
+export * from './joint/RopeJoint';
+export * from './joint/SpringJoint';
+export * from './character/CharacterController';
+export * from './vehicle/VehicleController';
+export * from './query/PhysicsQuery';
+export * from './debug/PhysicsDebugDrawer';
+export * from '@dimforge/rapier3d-compat';

package/dist/joint/ConstraintBase.d.ts

@@ -0,0 +1,26 @@
+import { ComponentBase } from '@orillusion/core';
+import RAPIER from '@dimforge/rapier3d-compat';
+import { Rigidbody } from '../rigidbody/Rigidbody';
+/**
+ * Shared base for all joint components.
+ *
+ * Subclasses set `connectedBody` (the second body, with this Object3D's body
+ * being the first) and override `buildJointData()` to return a `RAPIER.JointData`.
+ */
+export declare abstract class ConstraintBase<T extends RAPIER.ImpulseJoint = RAPIER.ImpulseJoint> extends ComponentBase {
+    protected _joint: T;
+    /** The other body of the constraint. */
+    connectedBody: Rigidbody;
+    /** Whether contacts are computed between the two connected bodies. Default: false. */
+    collisionsEnabled: boolean;
+    /** Whether to wake up the bodies when the joint is created. Default: true. */
+    wakeUpOnCreate: boolean;
+    start(): Promise<void>;
+    /** Subclasses build their JointData (revolute, fixed, etc.). */
+    protected abstract buildJointData(): RAPIER.JointData;
+    /** Hook for subclasses to apply per-joint settings (limits, motor) post-creation. */
+    protected afterStart(): void;
+    destroy(force?: boolean): void;
+    /** Native impulse joint. Touching this opts out of cross-backend portability. */
+    get native(): T;
+}

package/dist/joint/FixedJoint.d.ts

@@ -0,0 +1,14 @@
+import { Vector3, Quaternion } from '@orillusion/core';
+import RAPIER from '@dimforge/rapier3d-compat';
+import { ConstraintBase } from './ConstraintBase';
+/**
+ * Fixed joint — locks all 6 DOFs between two bodies. Mirrors
+ * `@orillusion/physics`'s `FixedConstraint`.
+ */
+export declare class FixedJoint extends ConstraintBase<RAPIER.FixedImpulseJoint> {
+    anchorSelf: Vector3;
+    anchorTarget: Vector3;
+    frameSelf: Quaternion;
+    frameTarget: Quaternion;
+    protected buildJointData(): RAPIER.JointData;
+}

package/dist/joint/GenericJoint.d.ts

@@ -0,0 +1,31 @@
+import { Vector3 } from '@orillusion/core';
+import RAPIER from '@dimforge/rapier3d-compat';
+import { ConstraintBase } from './ConstraintBase';
+/**
+ * Bit-mask of joint axes to lock. Combine with `|`. Each unset axis remains
+ * free; each set axis is locked. Default `LockAll - LinX` would lock 5 axes
+ * leaving X translation free.
+ */
+export declare const JointAxis: {
+    readonly LinX: 1;
+    readonly LinY: 2;
+    readonly LinZ: 4;
+    readonly AngX: 8;
+    readonly AngY: 16;
+    readonly AngZ: 32;
+    readonly LockAll: number;
+};
+/**
+ * Generic 6-DOF joint — pick which axes to lock via `lockedAxes` mask.
+ *
+ * Replaces `Generic6DofConstraint` and `Generic6DofSpringConstraint` from
+ * the ammo plugin (Rapier's `GenericJoint` natively supports both).
+ */
+export declare class GenericJoint extends ConstraintBase<RAPIER.GenericImpulseJoint> {
+    anchorSelf: Vector3;
+    anchorTarget: Vector3;
+    axis: Vector3;
+    /** Which axes are locked. Default: all 5 except LinX (slider-like). */
+    lockedAxes: number;
+    protected buildJointData(): RAPIER.JointData;
+}

package/dist/joint/HingeJoint.d.ts

@@ -0,0 +1,28 @@
+import { Vector3 } from '@orillusion/core';
+import RAPIER from '@dimforge/rapier3d-compat';
+import { ConstraintBase } from './ConstraintBase';
+/**
+ * Hinge (revolute) joint — 1 angular DOF around `axis`.
+ *
+ * Mirrors `@orillusion/physics`'s `HingeConstraint` symbol and method names.
+ */
+export declare class HingeJoint extends ConstraintBase<RAPIER.RevoluteImpulseJoint> {
+    /** Anchor point on body A (own Object3D's Rigidbody), in local space. */
+    anchorSelf: Vector3;
+    /** Anchor point on body B (`connectedBody`), in local space. */
+    anchorTarget: Vector3;
+    /** Hinge axis, defaults to world up. */
+    axis: Vector3;
+    private _limits;
+    private _motor;
+    protected buildJointData(): RAPIER.JointData;
+    protected afterStart(): void;
+    /** Set rotation limits (radians). */
+    setLimit(low: number, high: number): void;
+    /**
+     * Configure the angular motor for velocity control.
+     * @param targetVel - Target angular velocity (rad/s).
+     * @param factor - Damping/strength factor.
+     */
+    setMotor(targetVel: number, factor?: number): void;
+}

package/dist/joint/RopeJoint.d.ts

@@ -0,0 +1,13 @@
+import { Vector3 } from '@orillusion/core';
+import RAPIER from '@dimforge/rapier3d-compat';
+import { ConstraintBase } from './ConstraintBase';
+/**
+ * Rope joint — bodies cannot drift further apart than `length`, but may
+ * approach freely. Rapier-specific (not present in ammo plugin).
+ */
+export declare class RopeJoint extends ConstraintBase<RAPIER.ImpulseJoint> {
+    anchorSelf: Vector3;
+    anchorTarget: Vector3;
+    length: number;
+    protected buildJointData(): RAPIER.JointData;
+}

package/dist/joint/SliderJoint.d.ts

@@ -0,0 +1,19 @@
+import { Vector3 } from '@orillusion/core';
+import RAPIER from '@dimforge/rapier3d-compat';
+import { ConstraintBase } from './ConstraintBase';
+/**
+ * Slider (prismatic) joint — 1 linear DOF along `axis`.
+ *
+ * Mirrors `@orillusion/physics`'s `SliderConstraint`.
+ */
+export declare class SliderJoint extends ConstraintBase<RAPIER.PrismaticImpulseJoint> {
+    anchorSelf: Vector3;
+    anchorTarget: Vector3;
+    axis: Vector3;
+    private _limits;
+    private _motor;
+    protected buildJointData(): RAPIER.JointData;
+    protected afterStart(): void;
+    setLimit(low: number, high: number): void;
+    setMotor(targetVel: number, factor?: number): void;
+}

package/dist/joint/SphericalJoint.d.ts

@@ -0,0 +1,14 @@
+import { Vector3 } from '@orillusion/core';
+import RAPIER from '@dimforge/rapier3d-compat';
+import { ConstraintBase } from './ConstraintBase';
+/**
+ * Spherical (ball-and-socket) joint — 3 angular DOFs free, position locked.
+ *
+ * Replaces both `PointToPointConstraint` and `ConeTwistConstraint` from the
+ * ammo plugin (Rapier folds them into one primitive).
+ */
+export declare class SphericalJoint extends ConstraintBase<RAPIER.SphericalImpulseJoint> {
+    anchorSelf: Vector3;
+    anchorTarget: Vector3;
+    protected buildJointData(): RAPIER.JointData;
+}

package/dist/joint/SpringJoint.d.ts

@@ -0,0 +1,15 @@
+import { Vector3 } from '@orillusion/core';
+import RAPIER from '@dimforge/rapier3d-compat';
+import { ConstraintBase } from './ConstraintBase';
+/**
+ * Spring joint — Hooke's law spring connecting two anchors with a rest length.
+ * Replaces ammo plugin's `Generic6DofSpringConstraint` for the simple case.
+ */
+export declare class SpringJoint extends ConstraintBase<RAPIER.ImpulseJoint> {
+    anchorSelf: Vector3;
+    anchorTarget: Vector3;
+    restLength: number;
+    stiffness: number;
+    damping: number;
+    protected buildJointData(): RAPIER.JointData;
+}