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 enabled.

    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 enabled.

    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 enabled.

    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 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 enabled.

    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 enabled.

    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 enabled.

    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.

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 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)

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.
EnableMotor 2 If [code]set[/code] there is a rotational motor across these axes.
Max 3 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.
AngularLowerLimit 5 The minimum rotation in negative direction to break loose and rotate around the axes.
AngularUpperLimit 6 The minimum rotation in positive direction to break loose and rotate around the axes.
AngularLimitSoftness 7 The speed of all rotations across the axes.
AngularDamping 8 The amount of rotational damping across the axes. The lower, the more dampening occurs.
AngularRestitution 9 The amount of rotational restitution across the axes. The lower, the more restitution occurs.
AngularForceLimit 10 The maximum amount of force that can occur, when rotating around the axes.
AngularErp 11 When rotating across the axes, this error tolerance factor defines how much the correction gets slowed down. The lower, the slower.
AngularMotorTargetVelocity 12 Target speed for the motor at the axes.
AngularMotorForceLimit 13 Maximum acceleration for the motor at the axes.
Max 14 End flag of PARAM_* constants, used internally.
Tags: