The generic 6 degrees of freedom joint can implement a variety of joint-types by locking certain axes' rotation or translation.
    public class Generic6DOFJoint : Joint

The first 3 DOF axes are linear axes, which represent translation of Bodies, and the latter 3 DOF axes represent the angular motion. Each axis can be either locked, or limited.

Inheritance Chain

Constructors

    public Generic6DOFJoint()

Properties

    public float AngularLimitX__damping { get; set; }

The amount of rotational damping across the x-axis.

The lower, the longer an impulse from one side takes to travel to the other side.

    public bool AngularLimitX__enabled { get; set; }

If true, rotation across the x-axis is limited.

    public float AngularLimitX__erp { get; set; }

When rotating across x-axis, this error tolerance factor defines how much the correction gets slowed down. The lower, the slower.

    public float AngularLimitX__forceLimit { get; set; }

The maximum amount of force that can occur, when rotating around x-axis.

    public float AngularLimitX__lowerAngle { get; set; }

The minimum rotation in negative direction to break loose and rotate around the x-axis.

    public float AngularLimitX__restitution { get; set; }

The amount of rotational restitution across the x-axis. The lower, the more restitution occurs.

    public float AngularLimitX__softness { get; set; }

The speed of all rotations across the x-axis.

    public float AngularLimitX__upperAngle { get; set; }

The minimum rotation in positive direction to break loose and rotate around the x-axis.

    public float AngularLimitY__damping { get; set; }

The amount of rotational damping across the y-axis. The lower, the more dampening occurs.

    public bool AngularLimitY__enabled { get; set; }

If true, rotation across the y-axis is limited.

    public float AngularLimitY__erp { get; set; }

When rotating across y-axis, this error tolerance factor defines how much the correction gets slowed down. The lower, the slower.

    public float AngularLimitY__forceLimit { get; set; }

The maximum amount of force that can occur, when rotating around y-axis.

    public float AngularLimitY__lowerAngle { get; set; }

The minimum rotation in negative direction to break loose and rotate around the y-axis.

    public float AngularLimitY__restitution { get; set; }

The amount of rotational restitution across the y-axis. The lower, the more restitution occurs.

    public float AngularLimitY__softness { get; set; }

The speed of all rotations across the y-axis.

    public float AngularLimitY__upperAngle { get; set; }

The minimum rotation in positive direction to break loose and rotate around the y-axis.

    public float AngularLimitZ__damping { get; set; }

The amount of rotational damping across the z-axis. The lower, the more dampening occurs.

    public bool AngularLimitZ__enabled { get; set; }

If true, rotation across the z-axis is limited.

    public float AngularLimitZ__erp { get; set; }

When rotating across z-axis, this error tolerance factor defines how much the correction gets slowed down. The lower, the slower.

    public float AngularLimitZ__forceLimit { get; set; }

The maximum amount of force that can occur, when rotating around z-axis.

    public float AngularLimitZ__lowerAngle { get; set; }

The minimum rotation in negative direction to break loose and rotate around the z-axis.

    public float AngularLimitZ__restitution { get; set; }

The amount of rotational restitution across the z-axis. The lower, the more restitution occurs.

    public float AngularLimitZ__softness { get; set; }

The speed of all rotations across the z-axis.

    public float AngularLimitZ__upperAngle { get; set; }

The minimum rotation in positive direction to break loose and rotate around the z-axis.

    public bool AngularMotorX__enabled { get; set; }

If true, a rotating motor at the x-axis is enabled.

    public float AngularMotorX__forceLimit { get; set; }

Maximum acceleration for the motor at the x-axis.

    public float AngularMotorX__targetVelocity { get; set; }

Target speed for the motor at the x-axis.

    public bool AngularMotorY__enabled { get; set; }

If true, a rotating motor at the y-axis is enabled.

    public float AngularMotorY__forceLimit { get; set; }

Maximum acceleration for the motor at the y-axis.

    public float AngularMotorY__targetVelocity { get; set; }

Target speed for the motor at the y-axis.

    public bool AngularMotorZ__enabled { get; set; }

If true, a rotating motor at the z-axis is enabled.

    public float AngularMotorZ__forceLimit { get; set; }

Maximum acceleration for the motor at the z-axis.

    public float AngularMotorZ__targetVelocity { get; set; }

Target speed for the motor at the z-axis.

    public float AngularSpringX__damping { get; set; }

    public bool AngularSpringX__enabled { get; set; }

    public float AngularSpringX__equilibriumPoint { get; set; }

    public float AngularSpringX__stiffness { get; set; }

    public float AngularSpringY__damping { get; set; }

    public bool AngularSpringY__enabled { get; set; }

    public float AngularSpringY__equilibriumPoint { get; set; }

    public float AngularSpringY__stiffness { get; set; }

    public float AngularSpringZ__damping { get; set; }

    public bool AngularSpringZ__enabled { get; set; }

    public float AngularSpringZ__equilibriumPoint { get; set; }

    public float AngularSpringZ__stiffness { get; set; }

    public float LinearLimitX__damping { get; set; }

The amount of damping that happens at the x-motion.

    public bool LinearLimitX__enabled { get; set; }

If true, the linear motion across the x-axis is limited.

    public float LinearLimitX__lowerDistance { get; set; }

The minimum difference between the pivot points’ x-axis.

    public float LinearLimitX__restitution { get; set; }

The amount of restitution on the x-axis movement The lower, the more momentum gets lost.

    public float LinearLimitX__softness { get; set; }

A factor applied to the movement across the x-axis The lower, the slower the movement.

    public float LinearLimitX__upperDistance { get; set; }

The maximum difference between the pivot points’ x-axis.

    public float LinearLimitY__damping { get; set; }

The amount of damping that happens at the y-motion.

    public bool LinearLimitY__enabled { get; set; }

If true, the linear motion across the y-axis is limited.

    public float LinearLimitY__lowerDistance { get; set; }

The minimum difference between the pivot points’ y-axis.

    public float LinearLimitY__restitution { get; set; }

The amount of restitution on the y-axis movement The lower, the more momentum gets lost.

    public float LinearLimitY__softness { get; set; }

A factor applied to the movement across the y-axis The lower, the slower the movement.

    public float LinearLimitY__upperDistance { get; set; }

The maximum difference between the pivot points’ y-axis.

    public float LinearLimitZ__damping { get; set; }

The amount of damping that happens at the z-motion.

    public bool LinearLimitZ__enabled { get; set; }

If true, the linear motion across the z-axis is limited.

    public float LinearLimitZ__lowerDistance { get; set; }

The minimum difference between the pivot points’ z-axis.

    public float LinearLimitZ__restitution { get; set; }

The amount of restitution on the z-axis movement The lower, the more momentum gets lost.

    public float LinearLimitZ__softness { get; set; }

A factor applied to the movement across the z-axis The lower, the slower the movement.

    public float LinearLimitZ__upperDistance { get; set; }

The maximum difference between the pivot points’ z-axis.

    public bool LinearMotorX__enabled { get; set; }

If true, then there is a linear motor on the x-axis. It will attempt to reach the target velocity while staying within the force limits.

    public float LinearMotorX__forceLimit { get; set; }

The maximum force the linear motor can apply on the x-axis while trying to reach the target velocity.

    public float LinearMotorX__targetVelocity { get; set; }

The speed that the linear motor will attempt to reach on the x-axis.

    public bool LinearMotorY__enabled { get; set; }

If true, then there is a linear motor on the y-axis. It will attempt to reach the target velocity while staying within the force limits.

    public float LinearMotorY__forceLimit { get; set; }

The maximum force the linear motor can apply on the y-axis while trying to reach the target velocity.

    public float LinearMotorY__targetVelocity { get; set; }

The speed that the linear motor will attempt to reach on the y-axis.

    public bool LinearMotorZ__enabled { get; set; }

If true, then there is a linear motor on the z-axis. It will attempt to reach the target velocity while staying within the force limits.

    public float LinearMotorZ__forceLimit { get; set; }

The maximum force the linear motor can apply on the z-axis while trying to reach the target velocity.

    public float LinearMotorZ__targetVelocity { get; set; }

The speed that the linear motor will attempt to reach on the z-axis.

    public float LinearSpringX__damping { get; set; }

    public bool LinearSpringX__enabled { get; set; }

    public float LinearSpringX__equilibriumPoint { get; set; }

    public float LinearSpringX__stiffness { get; set; }

    public float LinearSpringY__damping { get; set; }

    public bool LinearSpringY__enabled { get; set; }

    public float LinearSpringY__equilibriumPoint { get; set; }

    public float LinearSpringY__stiffness { get; set; }

    public float LinearSpringZ__damping { get; set; }

    public bool LinearSpringZ__enabled { get; set; }

    public float LinearSpringZ__equilibriumPoint { get; set; }

    public float LinearSpringZ__stiffness { get; set; }

    public int Precision { get; set; }

Methods

    public bool GetFlagX(Flag flag)

    public bool GetFlagY(Flag flag)

    public bool GetFlagZ(Flag flag)

    public float GetParamX(Param param)

    public float GetParamY(Param param)

    public float GetParamZ(Param param)

    public int GetPrecision()

Getter for Precision

    public void SetFlagX(Flag flag, bool value)

    public void SetFlagY(Flag flag, bool value)

    public void SetFlagZ(Flag flag, bool value)

    public void SetParamX(Param param, float value)

    public void SetParamY(Param param, float value)

    public void SetParamZ(Param param, float value)

    public void SetPrecision(int precision)

Setter for Precision

Inner Types

Flag

Name Value Description
EnableLinearLimit 0 If [code]set[/code] there is linear motion possible within the given limits.
EnableAngularLimit 1 If [code]set[/code] there is rotational motion possible.
EnableLinearSpring 3  
EnableAngularSpring 2  
EnableMotor 4 If [code]set[/code] there is a rotational motor across these axes.
EnableLinearMotor 5  
Max 6 End flag of FLAG_* constants, used internally.

Param

Name Value Description
LinearLowerLimit 0 The minimum difference between the pivot points’ axes.
LinearUpperLimit 1 The maximum difference between the pivot points’ axes.
LinearLimitSoftness 2 A factor applied to the movement across the axes The lower, the slower the movement.
LinearRestitution 3 The amount of restitution on the axes movement The lower, the more momentum gets lost.
LinearDamping 4 The amount of damping that happens at the linear motion across the axes.
LinearMotorTargetVelocity 5 The velocity the linear motor will try to reach.
LinearMotorForceLimit 6 The maximum force the linear motor will apply while trying to reach the velocity target.
AngularLowerLimit 10 The minimum rotation in negative direction to break loose and rotate around the axes.
AngularUpperLimit 11 The minimum rotation in positive direction to break loose and rotate around the axes.
AngularLimitSoftness 12 The speed of all rotations across the axes.
AngularDamping 13 The amount of rotational damping across the axes. The lower, the more dampening occurs.
AngularRestitution 14 The amount of rotational restitution across the axes. The lower, the more restitution occurs.
AngularForceLimit 15 The maximum amount of force that can occur, when rotating around the axes.
AngularErp 16 When rotating across the axes, this error tolerance factor defines how much the correction gets slowed down. The lower, the slower.
AngularMotorTargetVelocity 17 Target speed for the motor at the axes.
AngularMotorForceLimit 18 Maximum acceleration for the motor at the axes.
Max 22 End flag of PARAM_* constants, used internally.
Tags: