Spring

dampingRatio

get dampingRatio(): number

var dampingRatio: Double { get }

The amount of drag applied, as a fraction of the amount needed to produce critical damping. When `dampingRatio` is 1, the spring will smoothly decelerate to its final position without oscillating. Damping ratios less than 1 will oscillate more and more before coming to a complete stop.

init

static initSettlingDurationDampingRatioEpsilon(settlingDuration: number, dampingRatio: number, epsilon?: number): Spring

init(settlingDuration: TimeInterval, dampingRatio: Double, epsilon: Double = 0.001)

Creates a spring with the specified duration and damping ratio. - Parameters: - settlingDuration: The approximate time it will take for the spring to come to rest. - dampingRatio: The amount of drag applied as a fraction of the amount needed to produce critical damping. - epsilon: The threshhold for how small all subsequent values need to be before the spring is considered to have settled.

settlingDuration

settlingDurationTargetInitialVelocityEpsilon(target: number, initialVelocity: number, epsilon: number): number

func settlingDuration<V>(target: V, initialVelocity: V = .zero, epsilon: Double) -> TimeInterval where V : VectorArithmetic

The estimated duration required for the spring system to be considered at rest. The epsilon value specifies the threshold for how small all subsequent values need to be before the spring is considered to have settled.

settlingDuration

settlingDurationFromValueToValueInitialVelocityEpsilon(fromValue: number, toValue: number, initialVelocity: number, epsilon: number): number

func settlingDuration<V>(fromValue: V, toValue: V, initialVelocity: V, epsilon: Double) -> TimeInterval where V : Animatable

The estimated duration required for the spring system to be considered at rest. The epsilon value specifies the threshold for how small all subsequent values need to be before the spring is considered to have settled.

settlingDuration

get settlingDuration(): number

var settlingDuration: TimeInterval { get }

The estimated duration required for the spring system to be considered at rest. This uses a `target` of 1.0, an `initialVelocity` of 0, and an `epsilon` of 0.001.

init

static initMassStiffnessDampingAllowOverDamping(mass: number, stiffness: number, damping: number, allowOverDamping?: boolean): Spring

init(mass: Double = 1.0, stiffness: Double, damping: Double, allowOverDamping: Bool = false)

Creates a spring with the specified mass, stiffness, and damping. - Parameters: - mass: Specifies that property of the object attached to the end of the spring. - stiffness: The corresponding spring coefficient. - damping: Defines how the spring's motion should be damped due to the forces of friction. - allowOverDamping: A value of true specifies that over-damping should be allowed when appropriate based on the other inputs, and a value of false specifies that such cases should instead be treated as critically damped.

mass

get mass(): number

var mass: Double { get }

The mass of the object attached to the end of the spring. The default mass is 1. Increasing this value will increase the spring's effect: the attached object will be subject to more oscillations and greater overshoot, resulting in an increased settling duration. Decreasing the mass will reduce the spring effect: there will be fewer oscillations and a reduced overshoot, resulting in a decreased settling duration.

force

forceTargetPositionVelocity(target: number, position: number, velocity: number): number

func force<V>(target: V, position: V, velocity: V) -> V where V : VectorArithmetic

Calculates the force upon the spring given a current position, target, and velocity amount of change. This value is in units of the vector type per second squared.

force

forceFromValueToValuePositionVelocity(fromValue: number, toValue: number, position: number, velocity: number): number

func force<V>(fromValue: V, toValue: V, position: V, velocity: V) -> V where V : Animatable

Calculates the force upon the spring given a current position, velocity, and divisor from the starting and end values for the spring to travel. This value is in units of the vector type per second squared.

value

valueTargetInitialVelocityTime(target: number, initialVelocity: number, time: number): number

func value<V>(target: V, initialVelocity: V = .zero, time: TimeInterval) -> V where V : VectorArithmetic

Calculates the value of the spring at a given time given a target amount of change.

value

valueFromValueToValueInitialVelocityTime(fromValue: number, toValue: number, initialVelocity: number, time: number): number

func value<V>(fromValue: V, toValue: V, initialVelocity: V, time: TimeInterval) -> V where V : Animatable

Calculates the value of the spring at a given time for a starting and ending value for the spring to travel.

bounce

get bounce(): number

var bounce: Double { get }

How bouncy the spring is. A value of 0 indicates no bounces (a critically damped spring), positive values indicate increasing amounts of bounciness up to a maximum of 1.0 (corresponding to undamped oscillation), and negative values indicate overdamped springs with a minimum value of -1.0.

bouncy

static bouncyDurationExtraBounce(duration?: number, extraBounce?: number): Spring

@export(implementation) static func bouncy(duration: TimeInterval = 0.5, extraBounce: Double = 0.0) -> Spring

A spring with a predefined duration and higher amount of bounce that can be tuned. - Parameters: - duration: The perceptual duration, which defines the pace of the spring. This is approximately equal to the settling duration, but for very bouncy springs, will be the duration of the period of oscillation for the spring. - extraBounce: How much additional bounce should be added to the base bounce of 0.3.

bouncy

static get bouncy(): Spring

@export(implementation) static var bouncy: Spring { get }

A spring with a predefined duration and higher amount of bounce.

smooth

static smoothDurationExtraBounce(duration?: number, extraBounce?: number): Spring

@export(implementation) static func smooth(duration: TimeInterval = 0.5, extraBounce: Double = 0.0) -> Spring

A smooth spring with a predefined duration and no bounce that can be tuned. - Parameters: - duration: The perceptual duration, which defines the pace of the spring. This is approximately equal to the settling duration, but for very bouncy springs, will be the duration of the period of oscillation for the spring. - extraBounce: How much additional bounce should be added to the base bounce of 0.

smooth

static get smooth(): Spring

@export(implementation) static var smooth: Spring { get }

A smooth spring with a predefined duration and no bounce.

snappy

static snappyDurationExtraBounce(duration?: number, extraBounce?: number): Spring

@export(implementation) static func snappy(duration: TimeInterval = 0.5, extraBounce: Double = 0.0) -> Spring

A spring with a predefined duration and small amount of bounce that feels more snappy and can be tuned. - Parameters: - duration: The perceptual duration, which defines the pace of the spring. This is approximately equal to the settling duration, but for very bouncy springs, will be the duration of the period of oscillation for the spring. - extraBounce: How much additional bounciness should be added to the base bounce of 0.15.

snappy

static get snappy(): Spring

@export(implementation) static var snappy: Spring { get }

A spring with a predefined duration and small amount of bounce that feels more snappy.

update

update(value: number, velocity: number, target: number, deltaTime: number): { $ret: null; $out: { "value": number; "velocity": number } }

func update<V>(value: inout V, velocity: inout V, target: V, deltaTime: TimeInterval) where V : VectorArithmetic

Updates the current value and velocity of a spring. - Parameters: - value: The current value of the spring. - velocity: The current velocity of the spring. - target: The target that `value` is moving towards. - deltaTime: The amount of time that has passed since the spring was at the position specified by `value`.

Omit the output parameters from the call. The result contains $ret and $out, with value, velocity inside $out.

damping

get damping(): number

var damping: Double { get }

Defines how the spring’s motion should be damped due to the forces of friction. Reducing this value reduces the energy loss with each oscillation: the spring will overshoot its destination. Increasing the value increases the energy loss with each duration: there will be fewer and smaller oscillations.

init

static initDurationBounce(duration?: number, bounce?: number): Spring

init(duration: TimeInterval = 0.5, bounce: Double = 0.0)

Creates a spring with the specified duration and bounce. - Parameters: - duration: Defines the pace of the spring. This is approximately equal to the settling duration, but for springs with very large bounce values, will be the duration of the period of oscillation for the spring. - bounce: How bouncy the spring should be. A value of 0 indicates no bounces (a critically damped spring), positive values indicate increasing amounts of bounciness up to a maximum of 1.0 (corresponding to undamped oscillation), and negative values indicate overdamped springs with a minimum value of -1.0.

duration

get duration(): number

var duration: TimeInterval { get }

The perceptual duration, which defines the pace of the spring.

init

static initResponseDampingRatio(response: number, dampingRatio: number): Spring

init(response: Double, dampingRatio: Double)

Creates a spring with the specified response and damping ratio. - Parameters: - response: Defines the stiffness of the spring as an approximate duration in seconds. - dampingRatio: Defines the amount of drag applied as a fraction the amount needed to produce critical damping.

response

get response(): number

var response: Double { get }

The stiffness of the spring, defined as an approximate duration in seconds.

velocity

velocityTargetInitialVelocityTime(target: number, initialVelocity: number, time: number): number

func velocity<V>(target: V, initialVelocity: V = .zero, time: TimeInterval) -> V where V : VectorArithmetic

Calculates the velocity of the spring at a given time given a target amount of change.

velocity

velocityFromValueToValueInitialVelocityTime(fromValue: number, toValue: number, initialVelocity: number, time: number): number

func velocity<V>(fromValue: V, toValue: V, initialVelocity: V, time: TimeInterval) -> V where V : Animatable

Calculates the velocity of the spring at a given time given a starting and ending value for the spring to travel.

stiffness

get stiffness(): number

var stiffness: Double { get }

The spring stiffness coefficient. Increasing the stiffness reduces the number of oscillations and will reduce the settling duration. Decreasing the stiffness increases the number of oscillations and will increase the settling duration.