com.jme3.bullet.joints

Class HingeJoint

java.lang.Object

com.jme3.bullet.joints.PhysicsJoint

com.jme3.bullet.joints.HingeJoint

All Implemented Interfaces:

Savable

public class HingeJoint
extends PhysicsJoint

From bullet manual:
Hinge constraint, or revolute joint restricts two additional angular degrees of freedom, so the body can only rotate around one axis, the hinge axis. This can be useful to represent doors or wheels rotating around one axis. The user can specify limits and motor for the hinge.

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	angularOnly
protected Vector3f	axisA
protected Vector3f	axisB
protected float	biasFactor
protected float	limitSoftness
protected float	relaxationFactor

Fields inherited from class com.jme3.bullet.joints.PhysicsJoint

collisionBetweenLinkedBodys, constraint, nodeA, nodeB, pivotA, pivotB

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	HingeJoint()
	HingeJoint(PhysicsRigidBody nodeA, PhysicsRigidBody nodeB, Vector3f pivotA, Vector3f pivotB, Vector3f axisA, Vector3f axisB) Creates a new HingeJoint

Method Summary

Modifier and Type	Method and Description
protected void	createJoint()
void	enableMotor(boolean enable, float targetVelocity, float maxMotorImpulse) Enables the motor.
float	getHingeAngle()
float	getLowerLimit()
float	getUpperLimit()
void	read(JmeImporter im)
void	setAngularOnly(boolean angularOnly)
void	setLimit(float low, float high) Sets the limits of this joint.
void	setLimit(float low, float high, float _softness, float _biasFactor, float _relaxationFactor) Sets the limits of this joint.
void	write(JmeExporter ex)

Methods inherited from class com.jme3.bullet.joints.PhysicsJoint

destroy, getAppliedImpulse, getBodyA, getBodyB, getObjectId, getPivotA, getPivotB, isCollisionBetweenLinkedBodys, setCollisionBetweenLinkedBodys

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

axisA

protected Vector3f axisA

axisB

protected Vector3f axisB

angularOnly

protected boolean angularOnly

biasFactor

protected float biasFactor

relaxationFactor

protected float relaxationFactor

limitSoftness

protected float limitSoftness

Constructor Detail

HingeJoint

protected HingeJoint()

HingeJoint

public HingeJoint(PhysicsRigidBody nodeA,
                  PhysicsRigidBody nodeB,
                  Vector3f pivotA,
                  Vector3f pivotB,
                  Vector3f axisA,
                  Vector3f axisB)

Creates a new HingeJoint

Parameters:

nodeA - the body for the A end (not null, alias created)

nodeB - the body for the B end (not null, alias created)

pivotA - local translation of the joint connection point in node A

pivotB - local translation of the joint connection point in node B

axisA - the joint axis in A's local coordinates (unit vector, alias created)

axisB - the joint axis in B's local coordinates (unit vector, alias created)

Method Detail

enableMotor

public void enableMotor(boolean enable,
                        float targetVelocity,
                        float maxMotorImpulse)

Enables the motor.

Parameters:

enable - if true, motor is enabled.

targetVelocity - the target velocity of the rotation.

maxMotorImpulse - the max force applied to the hinge to rotate it.

setLimit

public void setLimit(float low,
                     float high)

Sets the limits of this joint.

Parameters:

low - the low limit in radians.

high - the high limit in radians.

setLimit

public void setLimit(float low,
                     float high,
                     float _softness,
                     float _biasFactor,
                     float _relaxationFactor)

Sets the limits of this joint. If you're above the softness, velocities that would shoot through the actual limit are slowed down. The bias be in the range of 0.2 - 0.5.

Parameters:

low - the low limit in radians.

high - the high limit in radians.

_softness - the factor at which the velocity error correction starts operating,i.e a softness of 0.9 means that the vel. corr starts at 90% of the limit range.

_biasFactor - the magnitude of the position correction. It tells you how strictly the position error (drift ) is corrected.

_relaxationFactor - the rate at which velocity errors are corrected. This can be seen as the strength of the limits. A low value will make the limits more spongy.

getUpperLimit

public float getUpperLimit()

getLowerLimit

public float getLowerLimit()

setAngularOnly

public void setAngularOnly(boolean angularOnly)

getHingeAngle

public float getHingeAngle()

write

public void write(JmeExporter ex)
           throws java.io.IOException

Specified by:

write in interface Savable

Overrides:

write in class PhysicsJoint

Throws:

java.io.IOException

read

public void read(JmeImporter im)
          throws java.io.IOException

Specified by:

read in interface Savable

Overrides:

read in class PhysicsJoint

Throws:

java.io.IOException

createJoint

protected void createJoint()