KinematicRagdollControl (jMonkeyEngine 3.1 jme3-bullet Javadoc)

java.lang.Object
- com.jme3.bullet.control.AbstractPhysicsControl
- - com.jme3.bullet.control.KinematicRagdollControl

All Implemented Interfaces:

PhysicsCollisionListener, PhysicsControl, com.jme3.export.Savable, com.jme3.scene.control.Control, com.jme3.util.clone.JmeCloneable, java.lang.Cloneable
```
public class KinematicRagdollControl
extends AbstractPhysicsControl
implements PhysicsCollisionListener, com.jme3.util.clone.JmeCloneable
```
This control is still a WIP, use it at your own risk
To use this control you need a model with an AnimControl and a SkeletonControl.
This should be the case if you imported an animated model from Ogre or blender.
Note enabling/disabling the control add/removes it from the physic space

This control creates collision shapes for each bones of the skeleton when you call spatial.addControl(ragdollControl).
- The shape is HullCollision shape based on the vertices associated with each bone and based on a tweakable weight threshold (see setWeightThreshold)
- If you don't want each bone to be a collision shape, you can specify what bone to use by using the addBoneName method
  By using this method, bone that are not used to create a shape, are "merged" to their parent to create the collision shape.
There are 2 modes for this control :
- The kinematic modes :
  this is the default behavior, this means that the collision shapes of the body are able to interact with physics enabled objects. in this mode physic shapes follow the moovements of the animated skeleton (for example animated by a key framed animation) this mode is enabled by calling setKinematicMode();
- The ragdoll modes :
  To enable this behavior, you need to call setRagdollMode() method. In this mode the charater is entirely controled by physics, so it will fall under the gravity and move if any force is applied to it.
Author:

Normen Hansen and Rémy Bouquet (Nehon)

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class KinematicRagdollControl.Mode

class KinematicRagdollControl.PhysicsBoneLink

Nested Classes
Modifier and Type	Class and Description
`static class`	`KinematicRagdollControl.Mode`
`class`	`KinematicRagdollControl.PhysicsBoneLink`

Field Summary

Fields
Modifier and Type	Field and Description
`protected PhysicsRigidBody`	`baseRigidBody`
`protected boolean`	`blendedControl`
`protected float`	`blendStart`
`protected float`	`blendTime`
`protected java.util.Map<java.lang.String,KinematicRagdollControl.PhysicsBoneLink>`	`boneLinks`
`protected java.util.Set<java.lang.String>`	`boneList`
`protected boolean`	`debug`
`protected float`	`eventDispatchImpulseThreshold`
`protected com.jme3.math.Vector3f`	`initScale`
`protected java.util.List<RagdollCollisionListener>`	`listeners`
`protected static java.util.logging.Logger`	`logger`
`protected KinematicRagdollControl.Mode`	`mode`
`protected com.jme3.math.Vector3f`	`modelPosition`
`protected com.jme3.math.Quaternion`	`modelRotation`
`protected RagdollPreset`	`preset`
`protected float`	`rootMass`
`protected com.jme3.animation.Skeleton`	`skeleton`
`protected com.jme3.scene.Spatial`	`targetModel`
`protected float`	`totalMass`
`protected float`	`weightThreshold`

Fields inherited from class com.jme3.bullet.control.AbstractPhysicsControl
added, applyLocal, enabled, space, spatial

Constructor Summary

Constructors
Constructor and Description
`KinematicRagdollControl()` contruct a KinematicRagdollControl
`KinematicRagdollControl(float weightThreshold)`
`KinematicRagdollControl(RagdollPreset preset)`
`KinematicRagdollControl(RagdollPreset preset, float weightThreshold)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addBoneName(java.lang.String name)` Add a bone name to this control Using this method you can specify which bones of the skeleton will be used to build the collision shapes.
`void`	`addCollisionListener(RagdollCollisionListener listener)` add a
`protected void`	`addPhysics(PhysicsSpace space)` Called when the physics object is supposed to add all objects it needs to manage to the physics space.
`void`	`applyUserControl()`
`void`	`blendToKinematicMode(float blendTime)` Smoothly blend from Ragdoll mode to Kinematic mode This is useful to blend ragdoll actual position to a keyframe animation for example
`protected void`	`boneRecursion(com.jme3.scene.Spatial model, com.jme3.animation.Bone bone, PhysicsRigidBody parent, int reccount, java.util.Map<java.lang.Integer,java.util.List<java.lang.Float>> pointsMap)`
`com.jme3.scene.control.Control`	`cloneForSpatial(com.jme3.scene.Spatial spatial)`
`void`	`collision(PhysicsCollisionEvent event)` For internal use only callback for collisionevent
`protected void`	`createSpatialData(com.jme3.scene.Spatial model)` Called when the control is added to a new spatial, create any spatial-dependent data here.
`com.jme3.animation.Bone`	`getBone(java.lang.String name)`
`PhysicsRigidBody`	`getBoneRigidBody(java.lang.String boneName)` return the rigidBody associated to the given bone
`float`	`getEventDispatchImpulseThreshold()`
`float`	`getIkRotSpeed()`
`float`	`getIKThreshold()`
`SixDofJoint`	`getJoint(java.lang.String boneName)` Return the joint between the given bone and its parent.
`float`	`getLimbDampening()`
`KinematicRagdollControl.Mode`	`getMode()` retruns the mode of this control
`float`	`getTotalMass()`
`float`	`getWeightThreshold()`
`java.lang.Object`	`jmeClone()`
`protected void`	`kinematicUpdate(float tpf)`
`protected void`	`matchPhysicObjectToBone(KinematicRagdollControl.PhysicsBoneLink link, com.jme3.math.Vector3f position, com.jme3.math.Quaternion tmpRot1)` Set the transforms of a rigidBody to match the transforms of a bone.
`protected void`	`ragDollUpdate(float tpf)`
`void`	`read(com.jme3.export.JmeImporter im)` de-serialize this control
`void`	`reBuild()` rebuild the ragdoll this is useful if you applied scale on the ragdoll after it's been initialized, same as reattaching.
`void`	`removeAllIKTargets()`
`void`	`removeIKTarget(com.jme3.animation.Bone bone)`
`protected void`	`removePhysics(PhysicsSpace space)` Called when the physics object is supposed to remove all objects added to the physics space.
`protected void`	`removeSpatialData(com.jme3.scene.Spatial spat)` Called when the control is removed from a spatial, remove any spatial-dependent data here.
`void`	`render(com.jme3.renderer.RenderManager rm, com.jme3.renderer.ViewPort vp)` For internal use only specific render for the ragdoll(if debugging)
`protected void`	`scanSpatial(com.jme3.scene.Spatial model)`
`void`	`setCcdMotionThreshold(float value)` Set the CcdMotionThreshold of all the bone's rigidBodies of the ragdoll
`void`	`setCcdSweptSphereRadius(float value)` Set the CcdSweptSphereRadius of all the bone's rigidBodies of the ragdoll
`void`	`setEventDispatchImpulseThreshold(float eventDispatchImpulseThreshold)`
`void`	`setIKMode()` Sets the control into Inverse Kinematics mode.
`void`	`setIkRotSpeed(float ikRotSpeed)`
`com.jme3.math.Vector3f`	`setIKTarget(com.jme3.animation.Bone bone, com.jme3.math.Vector3f worldPos, int chainLength)`
`void`	`setIKThreshold(float IKThreshold)`
`void`	`setJointLimit(java.lang.String boneName, float maxX, float minX, float maxY, float minY, float maxZ, float minZ)` Set the joint limits for the joint between the given bone and its parent.
`void`	`setKinematicMode()` Set the control into Kinematic mode In theis mode, the collision shapes follow the movements of the skeleton, and can interact with physical environement
`void`	`setLimbDampening(float limbDampening)`
`protected void`	`setMode(KinematicRagdollControl.Mode mode)` Enable or disable the ragdoll behaviour.
`protected void`	`setPhysicsLocation(com.jme3.math.Vector3f vec)` Called when the physics object is supposed to move to the spatial position.
`protected void`	`setPhysicsRotation(com.jme3.math.Quaternion quat)` Called when the physics object is supposed to move to the spatial rotation.
`void`	`setRagdollMode()` Sets the control into Ragdoll mode The skeleton is entirely controlled by physics.
`void`	`setRootMass(float rootMass)`
`void`	`setWeightThreshold(float weightThreshold)`
`void`	`update(float tpf)`
`void`	`updateBone(KinematicRagdollControl.PhysicsBoneLink link, float tpf, com.jme3.util.TempVars vars, com.jme3.math.Quaternion tmpRot1, com.jme3.math.Quaternion[] tmpRot2, com.jme3.animation.Bone tipBone, com.jme3.math.Vector3f target, int depth, int maxDepth)`
`void`	`write(com.jme3.export.JmeExporter ex)` serialize this control

Methods inherited from class com.jme3.bullet.control.AbstractPhysicsControl
applyPhysicsTransform, cloneFields, getPhysicsSpace, getSpatialRotation, getSpatialTranslation, isApplyPhysicsLocal, isEnabled, setApplyPhysicsLocal, setEnabled, setPhysicsSpace, setSpatial

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.jme3.util.clone.JmeCloneable
cloneFields

- Field Detail
  - logger
```
protected static final java.util.logging.Logger logger
```
  - listeners
```
protected java.util.List<RagdollCollisionListener> listeners
```
  - boneList
```
protected final java.util.Set<java.lang.String> boneList
```
  - boneLinks
```
protected final java.util.Map<java.lang.String,KinematicRagdollControl.PhysicsBoneLink> boneLinks
```
  - modelPosition
```
protected final com.jme3.math.Vector3f modelPosition
```
  - modelRotation
```
protected final com.jme3.math.Quaternion modelRotation
```
  - baseRigidBody
```
protected final PhysicsRigidBody baseRigidBody
```
  - targetModel
```
protected com.jme3.scene.Spatial targetModel
```
  - skeleton
```
protected com.jme3.animation.Skeleton skeleton
```
  - preset
```
protected RagdollPreset preset
```
  - initScale
```
protected com.jme3.math.Vector3f initScale
```
  - mode
```
protected KinematicRagdollControl.Mode mode
```
  - debug
```
protected boolean debug
```
  - blendedControl
```
protected boolean blendedControl
```
  - weightThreshold
```
protected float weightThreshold
```
  - blendStart
```
protected float blendStart
```
  - blendTime
```
protected float blendTime
```
  - eventDispatchImpulseThreshold
```
protected float eventDispatchImpulseThreshold
```
  - rootMass
```
protected float rootMass
```
  - totalMass
```
protected float totalMass
```
- Constructor Detail
  - KinematicRagdollControl
```
public KinematicRagdollControl()
```
    contruct a KinematicRagdollControl
  - KinematicRagdollControl
```
public KinematicRagdollControl(float weightThreshold)
```
  - KinematicRagdollControl
```
public KinematicRagdollControl(RagdollPreset preset,
                       float weightThreshold)
```
  - KinematicRagdollControl
```
public KinematicRagdollControl(RagdollPreset preset)
```
- Method Detail
  - update
```
public void update(float tpf)
```
    Specified by:
    
    update in interface com.jme3.scene.control.Control
    
    Overrides:
    
    update in class AbstractPhysicsControl
  - ragDollUpdate
```
protected void ragDollUpdate(float tpf)
```
  - kinematicUpdate
```
protected void kinematicUpdate(float tpf)
```
  - updateBone
```
public void updateBone(KinematicRagdollControl.PhysicsBoneLink link,
              float tpf,
              com.jme3.util.TempVars vars,
              com.jme3.math.Quaternion tmpRot1,
              com.jme3.math.Quaternion[] tmpRot2,
              com.jme3.animation.Bone tipBone,
              com.jme3.math.Vector3f target,
              int depth,
              int maxDepth)
```
  - matchPhysicObjectToBone
```
protected void matchPhysicObjectToBone(KinematicRagdollControl.PhysicsBoneLink link,
                           com.jme3.math.Vector3f position,
                           com.jme3.math.Quaternion tmpRot1)
```
    Set the transforms of a rigidBody to match the transforms of a bone. this is used to make the ragdoll follow the skeleton motion while in Kinematic mode
    
    Parameters:
    link - the link containing the bone and the rigidBody
    position - just a temp vector for position
    tmpRot1 - just a temp quaternion for rotation
  - reBuild
```
public void reBuild()
```
    rebuild the ragdoll this is useful if you applied scale on the ragdoll after it's been initialized, same as reattaching.
  - createSpatialData
```
protected void createSpatialData(com.jme3.scene.Spatial model)
```
    Description copied from class: AbstractPhysicsControl
    
    Called when the control is added to a new spatial, create any spatial-dependent data here.
    
    Specified by:
    
    createSpatialData in class AbstractPhysicsControl
    
    Parameters:
    model - The new spatial, guaranteed not to be null
  - removeSpatialData
```
protected void removeSpatialData(com.jme3.scene.Spatial spat)
```
    Description copied from class: AbstractPhysicsControl
    
    Called when the control is removed from a spatial, remove any spatial-dependent data here.
    
    Specified by:
    
    removeSpatialData in class AbstractPhysicsControl
    
    Parameters:
    spat - The old spatial, guaranteed not to be null
  - addBoneName
```
public void addBoneName(java.lang.String name)
```
    Add a bone name to this control Using this method you can specify which bones of the skeleton will be used to build the collision shapes.
    
    Parameters:
    name -
  - scanSpatial
```
protected void scanSpatial(com.jme3.scene.Spatial model)
```
  - boneRecursion
```
protected void boneRecursion(com.jme3.scene.Spatial model,
                 com.jme3.animation.Bone bone,
                 PhysicsRigidBody parent,
                 int reccount,
                 java.util.Map<java.lang.Integer,java.util.List<java.lang.Float>> pointsMap)
```
  - setJointLimit
```
public void setJointLimit(java.lang.String boneName,
                 float maxX,
                 float minX,
                 float maxY,
                 float minY,
                 float maxZ,
                 float minZ)
```
    Set the joint limits for the joint between the given bone and its parent. This method can't work before attaching the control to a spatial
    
    Parameters:
    boneName - the name of the bone
    maxX - the maximum rotation on the x axis (in radians)
    minX - the minimum rotation on the x axis (in radians)
    maxY - the maximum rotation on the y axis (in radians)
    minY - the minimum rotation on the z axis (in radians)
    maxZ - the maximum rotation on the z axis (in radians)
    minZ - the minimum rotation on the z axis (in radians)
  - getJoint
```
public SixDofJoint getJoint(java.lang.String boneName)
```
    Return the joint between the given bone and its parent. This return null if it's called before attaching the control to a spatial
    
    Parameters:
    boneName - the name of the bone
    
    Returns:
    the joint between the given bone and its parent
  - setPhysicsLocation
```
protected void setPhysicsLocation(com.jme3.math.Vector3f vec)
```
    Description copied from class: AbstractPhysicsControl
    
    Called when the physics object is supposed to move to the spatial position.
    
    Specified by:
    
    setPhysicsLocation in class AbstractPhysicsControl
  - setPhysicsRotation
```
protected void setPhysicsRotation(com.jme3.math.Quaternion quat)
```
    Description copied from class: AbstractPhysicsControl
    
    Called when the physics object is supposed to move to the spatial rotation.
    
    Specified by:
    
    setPhysicsRotation in class AbstractPhysicsControl
  - addPhysics
```
protected void addPhysics(PhysicsSpace space)
```
    Description copied from class: AbstractPhysicsControl
    
    Called when the physics object is supposed to add all objects it needs to manage to the physics space.
    
    Specified by:
    
    addPhysics in class AbstractPhysicsControl
  - removePhysics
```
protected void removePhysics(PhysicsSpace space)
```
    Description copied from class: AbstractPhysicsControl
    
    Called when the physics object is supposed to remove all objects added to the physics space.
    
    Specified by:
    
    removePhysics in class AbstractPhysicsControl
  - collision
```
public void collision(PhysicsCollisionEvent event)
```
    For internal use only callback for collisionevent
    
    Specified by:
    
    collision in interface PhysicsCollisionListener
    
    Parameters:
    event -
  - setMode
```
protected void setMode(KinematicRagdollControl.Mode mode)
```
    Enable or disable the ragdoll behaviour. if ragdollEnabled is true, the character motion will only be powerd by physics else, the characted will be animated by the keyframe animation, but will be able to physically interact with its physic environnement
    
    Parameters:
    ragdollEnabled -
  - blendToKinematicMode
```
public void blendToKinematicMode(float blendTime)
```
    Smoothly blend from Ragdoll mode to Kinematic mode This is useful to blend ragdoll actual position to a keyframe animation for example
    
    Parameters:
    blendTime - the blending time between ragdoll to anim.
  - setKinematicMode
```
public void setKinematicMode()
```
    Set the control into Kinematic mode In theis mode, the collision shapes follow the movements of the skeleton, and can interact with physical environement
  - setRagdollMode
```
public void setRagdollMode()
```
    Sets the control into Ragdoll mode The skeleton is entirely controlled by physics.
  - setIKMode
```
public void setIKMode()
```
    Sets the control into Inverse Kinematics mode. The affected bones are affected by IK. physics.
  - getMode
```
public KinematicRagdollControl.Mode getMode()
```
    retruns the mode of this control
    
    Returns:
  - addCollisionListener
```
public void addCollisionListener(RagdollCollisionListener listener)
```
    add a
    
    Parameters:
    listener -
  - setRootMass
```
public void setRootMass(float rootMass)
```
  - getTotalMass
```
public float getTotalMass()
```
  - getWeightThreshold
```
public float getWeightThreshold()
```
  - setWeightThreshold
```
public void setWeightThreshold(float weightThreshold)
```
  - getEventDispatchImpulseThreshold
```
public float getEventDispatchImpulseThreshold()
```
  - setEventDispatchImpulseThreshold
```
public void setEventDispatchImpulseThreshold(float eventDispatchImpulseThreshold)
```
  - setCcdMotionThreshold
```
public void setCcdMotionThreshold(float value)
```
    Set the CcdMotionThreshold of all the bone's rigidBodies of the ragdoll
    
    Parameters:
    value -
    See Also:
    PhysicsRigidBody.setCcdMotionThreshold(float)
  - setCcdSweptSphereRadius
```
public void setCcdSweptSphereRadius(float value)
```
    Set the CcdSweptSphereRadius of all the bone's rigidBodies of the ragdoll
    
    Parameters:
    value -
    See Also:
    PhysicsRigidBody.setCcdSweptSphereRadius(float)
  - getBoneRigidBody
```
public PhysicsRigidBody getBoneRigidBody(java.lang.String boneName)
```
    return the rigidBody associated to the given bone
    
    Parameters:
    boneName - the name of the bone
    
    Returns:
    the associated rigidBody.
  - render
```
public void render(com.jme3.renderer.RenderManager rm,
          com.jme3.renderer.ViewPort vp)
```
    For internal use only specific render for the ragdoll(if debugging)
    
    Specified by:
    
    render in interface com.jme3.scene.control.Control
    
    Overrides:
    
    render in class AbstractPhysicsControl
    
    Parameters:
    rm -
    vp -
  - cloneForSpatial
```
public com.jme3.scene.control.Control cloneForSpatial(com.jme3.scene.Spatial spatial)
```
    Specified by:
    
    cloneForSpatial in interface com.jme3.scene.control.Control
  - jmeClone
```
public java.lang.Object jmeClone()
```
    Specified by:
    
    jmeClone in interface com.jme3.util.clone.JmeCloneable
  - setIKTarget
```
public com.jme3.math.Vector3f setIKTarget(com.jme3.animation.Bone bone,
                                 com.jme3.math.Vector3f worldPos,
                                 int chainLength)
```
  - removeIKTarget
```
public void removeIKTarget(com.jme3.animation.Bone bone)
```
  - removeAllIKTargets
```
public void removeAllIKTargets()
```
  - applyUserControl
```
public void applyUserControl()
```
  - getIkRotSpeed
```
public float getIkRotSpeed()
```
  - setIkRotSpeed
```
public void setIkRotSpeed(float ikRotSpeed)
```
  - getIKThreshold
```
public float getIKThreshold()
```
  - setIKThreshold
```
public void setIKThreshold(float IKThreshold)
```
  - getLimbDampening
```
public float getLimbDampening()
```
  - setLimbDampening
```
public void setLimbDampening(float limbDampening)
```
  - getBone
```
public com.jme3.animation.Bone getBone(java.lang.String name)
```
  - write
```
public void write(com.jme3.export.JmeExporter ex)
           throws java.io.IOException
```
    serialize this control
    
    Specified by:
    
    write in interface com.jme3.export.Savable
    
    Overrides:
    
    write in class AbstractPhysicsControl
    
    Parameters:
    ex -
    
    Throws:
    
    java.io.IOException
  - read
```
public void read(com.jme3.export.JmeImporter im)
          throws java.io.IOException
```
    de-serialize this control
    
    Specified by:
    
    read in interface com.jme3.export.Savable
    
    Overrides:
    
    read in class AbstractPhysicsControl
    
    Parameters:
    im -
    
    Throws:
    
    java.io.IOException

Class KinematicRagdollControl

Nested Class Summary

Field Summary

Fields inherited from class com.jme3.bullet.control.AbstractPhysicsControl

Constructor Summary

Method Summary

Methods inherited from class com.jme3.bullet.control.AbstractPhysicsControl

Methods inherited from class java.lang.Object

Methods inherited from interface com.jme3.util.clone.JmeCloneable

Field Detail

logger

listeners

boneList

boneLinks

modelPosition

modelRotation

baseRigidBody

targetModel

skeleton

preset

initScale

mode

debug

blendedControl

weightThreshold

blendStart

blendTime

eventDispatchImpulseThreshold

rootMass

totalMass

Constructor Detail

KinematicRagdollControl

KinematicRagdollControl

KinematicRagdollControl

KinematicRagdollControl

Method Detail

update

ragDollUpdate

kinematicUpdate

updateBone

matchPhysicObjectToBone

reBuild

createSpatialData

removeSpatialData

addBoneName

scanSpatial

boneRecursion

setJointLimit

getJoint

setPhysicsLocation

setPhysicsRotation

addPhysics

removePhysics

collision

setMode

blendToKinematicMode

setKinematicMode

setRagdollMode

setIKMode

getMode

addCollisionListener

setRootMass

getTotalMass

getWeightThreshold

setWeightThreshold

getEventDispatchImpulseThreshold

setEventDispatchImpulseThreshold

setCcdMotionThreshold

setCcdSweptSphereRadius

getBoneRigidBody

render

cloneForSpatial

jmeClone

setIKTarget

removeIKTarget

removeAllIKTargets

applyUserControl

getIkRotSpeed

setIkRotSpeed

getIKThreshold