Class SpringConstraint

Creates a SpringConstraint, which is a type of SixDofConstraint. This constraint applies a force at the ends which is proportional to the distance between ends, and a stiffness and damping factor. The force is calculated as (stiffness * positionError) - (damping * velocity)

This constraint applies a force at the ends which is proportional to the distance between ends, and a stiffness and damping factor.

Zicon

lock

Zparents

three/Object3D/**

Hierarchy (view full)

Accessors

disposed

Constructors

constructor

Methods

dispose getZComponentInstance init onStart onStop register unregister

Properties - AxisFriction

axisFriction

Properties - Behavior

enabled

Properties - Other

_context body? childBody? constraintid constructorProps contextManager dirtyFlags enabledResolved instance limits onDispose options

Properties - axisMaxLimit

axisMaxLimit

Properties - axisMinLimit

axisMinLimit

Properties - axisMotorMaxForce

axisMotorMaxForce

Properties - axisMotorTargetVelocity

axisMotorTarget

Properties - axisMotorType

axisMotorType

Properties - setAxisMode

axisMode

Accessors

disposed

  • get disposed(): boolean

  • Gets the disposed status of the entity.

    Returns boolean

    The disposed status.

Constructors

constructor

Methods

dispose

getZComponentInstance

  • getZComponentInstance<T>(type?): T

  • Get the instance of the ZComponent that constructed this entity.

    If you pass the class of a ZComponent as the type parameter, this function will ensure that it returns an instance of that ZComponent. If this component or behavior was constructed by a different ZComponent class, or by a different entity altogether, the function with throw an error.

    Type Parameters

    • T extends ZComponent<any, T> = ZComponent<any>

    Parameters

    • Optionaltype: ConstructorForComponent<T>

      The ZComponent class that you are expecting to receive

    Returns T

    The instance of the ZComponent that constructed this component or behavior

init

onStart

onStop

register

  • register<Args>(evt, fn, priority?): any

  • Register a function to be called when an Event is fired, or an Observable's value changes. The function will only be bound to the underlying Event or Observable while this entity is enabled.

    Using this function, rather than attaching your handler directly to the Event or Observable, ensures your handler is automatically released when this entity is disposed.

    Type Parameters

    • Args extends any[]

    Parameters

    • evt: Event<Args>

      The Event or Observable to listen to

    • fn: ((...args: Args) => void)

      A function that will be called when the event fires, or the Observable value changes

        • (...args): void

        • Parameters

          Returns void

    • Optionalpriority: number

    Returns any

  • register<Args>(evt, fn, options?): any

  • Type Parameters

    • Args extends any[]

    Parameters

    Returns any

  • register<Type>(observable, fn, priority?): any

  • Type Parameters

    • Type

    Parameters

    • observable: Observable<Type, never>
    • fn: ((v: Type) => void)
        • (v): void

        • Parameters

          Returns void

    • Optionalpriority: number

    Returns any

  • register<Type>(observable, fn, options?): any

  • Type Parameters

    • Type

    Parameters

    Returns any

unregister

  • unregister<Args>(evt, fn): any

  • Unregisters a function that was previously registered to an Event or Observable.

    Type Parameters

    • Args extends any[]

    Parameters

    • evt: Event<Args>

      The Event or Observable

    • fn: ((...args: Args) => void)

      The function that was passed in the call to register

        • (...args): void

        • Parameters

          Returns void

    Returns any

  • unregister<Type>(observable, fn): any

  • Type Parameters

    • Type

    Parameters

    • observable: Observable<Type, never>
    • fn: ((v: Type) => void)
        • (v): void

        • Parameters

          Returns void

    Returns any

Properties - AxisFriction

axisFriction

axisFriction: Observable<[axis: PhysicsConstraintAxis, friction: number], never> = ...

Sets the friction of the given axis of the physics engine.

Param: axis

The axis of the physics engine to set the friction for.

Param: friction

The friction to set for the given axis.

Zprop

Zdefault

[LinearX, 0.5]

Properties - Behavior

Readonlyenabled

enabled: Observable<boolean, never>

If false, this entity and its children will no longer participate in the experience.

Note - to read this value, you may wish to use enabledResolved which will be false if this entity, or any of its parents, have enabled set to false.

The precise implications of enabled being false will vary between entities, but in general disabled entities:

  • should not emit any events,
  • should not take any action, e.g. navigate the user to a different page,
  • should not perform any network communication,
  • should not make changes to other behaviors or components in the experience,
  • should minimise any runtime performance cost (e.g. detach from any frame handlers).

Zprop

Zdefault

true

Zgrouppriority

10

Properties - Other

Readonly_context

_context: HavokContext = ...

Optionalbody

body?: RigidBodyBehavior

OptionalchildBody

childBody?: RigidBodyBehavior

constraintid

constraintid: HP_ConstraintId

constructorProps

constructorProps: PhysicsConstraintConstructorProps

ReadonlycontextManager

contextManager: ContextManager

dirtyFlags

dirtyFlags: {
    axisFriction: boolean;
    axisMaxLimit: boolean;
    axisMinLimit: boolean;
    axisMode: boolean;
    axisMotorMaxForce: boolean;
    axisMotorTarget: boolean;
    axisMotorType: boolean;
} = ...

ReadonlyenabledResolved

enabledResolved: Observable<boolean, never>

This will have value false if this entity, or any of its parents, have enabled set to false.

To change the enabled status of this entity, use the enabled property instead.

The precise implications of enabled being false will vary between entities, but in general disabled entities:

  • should not emit any events,
  • should not take any action, e.g. navigate the user to a different page,
  • should not perform any network communication,
  • should not make changes to other behaviors or components in the experience,
  • should minimise any runtime performance cost.

Disabled entities will typically remain visible (if they have a visible appearance).

Readonlyinstance

instance: Component<any, ConstructorProps>

limits

limits: Physics6DoFLimit[]

The collection of limits which this constraint will apply

ReadonlyonDispose

onDispose: Event<[]>

An event that is fired as the last act of this entity being destroyed.

options

options: _Options = {}

Properties - axisMaxLimit

axisMaxLimit

axisMaxLimit: Observable<[axis: PhysicsConstraintAxis, maxLimit: number], never> = ...

Sets the maximum limit of the given axis for the physics engine.

Param: axis

The axis to set the limit for.

Param: limit

The maximum limit of the axis.

This method is useful for setting the maximum limit of the given axis for the physics engine, which can be used to control the movement of the physics object. This helps to ensure that the physics object does not move beyond the given limit.

Zprop

Zdefault

[LinearX, 0]

Properties - axisMinLimit

axisMinLimit

axisMinLimit: Observable<[axis: PhysicsConstraintAxis, minLimit: number], never> = ...

Sets the minimum limit of a given axis of a constraint.

Param: axis

The axis of the constraint.

Param: minLimit

The minimum limit of the axis.

Zprop

Zdefault

[LinearX, 0]

Properties - axisMotorMaxForce

axisMotorMaxForce

axisMotorMaxForce: Observable<[axis: PhysicsConstraintAxis, maxForce: number], never> = ...

Sets the maximum force of the motor of the given axis of the constraint.

Param: axis

The axis of the constraint.

Param: maxForce

The maximum force of the motor.

Zprop

Zdefault

[LinearX, 0]

Properties - axisMotorTargetVelocity

axisMotorTarget

axisMotorTarget: Observable<[axis: PhysicsConstraintAxis, target: number], never> = ...

Sets the target velocity of the motor associated with the given axis of the constraint.

Param: axis

The axis of the constraint.

Param: target

The target velocity of the motor.

This method is useful for setting the target velocity of the motor associated with the given axis of the constraint.

Zprop

Zdefault

[LinearX, 0]

Properties - axisMotorType

axisMotorType

axisMotorType: Observable<[axis: PhysicsConstraintAxis, motorType: PhysicsConstraintMotorType], never> = ...

Sets the motor type of the given axis of the constraint.

Param: axis

The axis of the constraint.

Param: motorType

The type of motor to use.

Returns

void

Zprop

Zdefault

[LinearX, None]

Properties - setAxisMode

axisMode

axisMode: Observable<[axis: PhysicsConstraintAxis, limitMode: PhysicsConstraintAxisLimitMode], never> = ...

Sets the limit mode for the given axis of the constraint.

Param: axis

The axis to set the limit mode for.

Param: limitMode

The limit mode to set.

This method is useful for setting the limit mode for a given axis of the constraint. This is important for controlling the behavior of the physics engine when the constraint is reached. By setting the limit mode, the engine can be configured to either stop the motion of the objects, or to allow them to continue moving beyond the constraint.

Zprop

Zdefault

[LinearX, Free]

Settings

Member Visibility

On This Page

disposedconstructordisposegetZComponentInstanceinitonStartonStopregisterunregisteraxisFrictionenabled_contextbodychildBodyconstraintidconstructorPropscontextManagerdirtyFlagsenabledResolvedinstancelimitsonDisposeoptionsaxisMaxLimitaxisMinLimitaxisMotorMaxForceaxisMotorTargetaxisMotorTypeaxisMode