nape-js API
    Preparing search index...

    Class SpringJoint

    A spring/damper constraint between two anchor points on two bodies.

    Applies a spring force that pulls or pushes the anchors toward a target restLength. The spring behavior is controlled by frequency (Hz) and damping (ratio), inherited from Constraint.

    Unlike DistanceJoint, a SpringJoint:

    • Is always soft — there is no rigid/stiff mode.
    • Has a single restLength instead of a [jointMin, jointMax] range.
    • Applies force in both directions (compression and extension).
    • Never goes slack — the spring always exerts a restorative force.

    Ideal for: vehicle suspension, soft-body connections, ragdoll hair/cloth, bouncy UI animations, bridge/rope segments, trampolines.

    const spring = new SpringJoint(
      body1, body2,
      Vec2.weak(0, 0),   // anchor on body1 (local)
      Vec2.weak(0, 0),   // anchor on body2 (local)
      100,               // rest length (pixels)
    );
    spring.frequency = 5;  // 5 Hz oscillation
    spring.damping = 0.5;  // underdamped (bouncy)
    spring.space = space;

    Hierarchy (View Summary)

    Index
    constructor
    debugDraw
    active anchor1 anchor2 body1 body2 breakUnderError breakUnderForce cbTypes compound damping frequency ignore isSleeping maxError maxForce removeOnBreak restLength space stiff userData
    bodyImpulse copy impulse toString visitBodies

    • Parameters

      • body1: Body | null

        First body, or null for a static world anchor.

      • body2: Body | null

        Second body, or null for a static world anchor.

      • anchor1: Vec2

        Anchor point in body1's local space (disposed if weak).

      • anchor2: Vec2

        Anchor point in body2's local space (disposed if weak).

      • restLength: number

        Equilibrium distance between anchors (must be >= 0).

      Returns SpringJoint

    debugDraw: boolean = true
    • get damping(): number

      Damping ratio for soft constraints (stiff = false).

      0 = undamped (oscillates freely), 1 = critically damped. Values > 1 are overdamped. Must be >= 0. Ignored when stiff is true.

      Returns number

      1

    • set damping(value: number): void

      Parameters

      • value: number

      Returns void

    • get frequency(): number

      Spring frequency in Hz for soft constraints (stiff = false).

      Higher values make the spring stiffer; lower values make it bouncier. Must be > 0. Ignored when stiff is true.

      Returns number

      10

    • set frequency(value: number): void

      Parameters

      • value: number

      Returns void

    • get isSleeping(): boolean

      Whether the constraint's simulation component is currently sleeping.

      Only valid when the constraint is active and in a space — throws otherwise.

      Returns boolean

    • get maxForce(): number

      Maximum force (in Newtons) the constraint may apply per step.

      When the required force exceeds this value the constraint becomes slack. If breakUnderForce is true the constraint breaks instead. Must be >= 0. Infinity disables the limit.

      Returns number

      Infinity

    • set maxForce(value: number): void

      Parameters

      • value: number

      Returns void

    • get stiff(): boolean

      SpringJoint is always soft — setting stiff to true is not allowed. Use DistanceJoint if you need a rigid distance constraint.

      Returns boolean

    • set stiff(_value: boolean): void

      When true (default) the constraint is stiff/rigid. When false the constraint uses a soft spring model driven by frequency and damping.

      Parameters

      • _value: boolean

      Returns void

      true

    • get userData(): Record<string, unknown>

      Arbitrary user data attached to this constraint. Lazily initialized to {} on first access.

      Returns Record<string, unknown>

    Settings
    Member Visibility

    On This Page
    Constructors
    Properties
    Accessors
    Methods