RigidBody (Bonzai Engine bonzaiengine.com Copyright © 2007-2015 Jérôme Jouvie)

java.lang.Object
- com.bonzaiengine.physics.CollisionObject
- - com.bonzaiengine.physics.RigidBody

All Implemented Interfaces:

INative
```
public final class RigidBody
extends CollisionObject
```
From Bullet/JBullet: It is recommended for performance and memory use to share CollisionShape objects whenever possible.
There are 3 types of rigid bodies:
1. Dynamic rigid bodies, with positive mass. Motion is controlled by rigid body dynamics.
2. Fixed objects with zero mass. They are not moving (basically collision objects).
3. Kinematic objects, which are objects without mass, but the user can move them. There is on-way interaction, and Bullet calculates a velocity based on the timestep and previous and current world transform.
Bullet automatically deactivates dynamic rigid bodies, when the velocity is below a threshold for a given time.
Deactivated (sleeping) rigid bodies don't take any processing time, except a minor broadphase collision detection impact (to allow active objects to activate/wake up sleeping objects).

Nested Class Summary
- Nested classes/interfaces inherited from class com.bonzaiengine.physics.CollisionObject
  CollisionObject.ActivationState

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`applyCentralForce(Vec3 force)`
`void`	`applyCentralImpulse(Vec3 impulse)`
`void`	`applyForce(Vec3 force, Vec3 relPos)`
`void`	`applyImpulse(Vec3 impulse, Vec3 relPos)`
`void`	`applyTorque(Vec3 torque)`
`void`	`applyTorqueImpulse(Vec3 torque)`
`void`	`clearForces()`
`void`	`destroy()` Must call `CollisionObject.nSetUserPointer(long, CollisionObject)` and destroy native objects
`float`	`getAngularDamping()`
`void`	`getAngularFactor(Vec3 dst)`
`Vec3`	`getAngularVelocity(Vec3 dst)`
`Constraint[]`	`getConstraints()`
`Vec3`	`getGravity(Vec3 dst)`
`float`	`getLinearDamping()`
`void`	`getLinearFactor(Vec3 dst)`
`Vec3`	`getLinearVelocity(Vec3 dst)`
`float`	`getMass()`
`int`	`getNumConstraints()`
`void`	`getTotalForce(Vec3 dst)`
`void`	`getTotalTorque(Vec3 dst)`
`void`	`setAngularDamping(float angularDamping)` Damping is similar to friction but also applies when the body is not touching any other surface.
`void`	`setAngularFactor(Vec3 angularFactor)` Angular factor is used to attenuate/reduce body rotation (0 to block rotation).
`void`	`setAngularVelocity(Vec3 angularVelocity)`
`void`	`setCollisionShape(CollisionShape shape)`
`void`	`setGravity(Vec3 gravity)` Override gravity force of `PhysicWorld` to this `RigidBody`.
`void`	`setKinematic(boolean kinematic)`
`void`	`setLinearDamping(float linearDamping)` Damping is similar to friction but also applies when the body is not touching any other surface.
`void`	`setLinearFactor(Vec3 linearFactor)` Linear factor is used to attenuate/reduce body translation (0 to block translation).
`void`	`setLinearVelocity(Vec3 linearVelocity)`
`void`	`setMass(float mass)`
`void`	`setMass(float mass, boolean inertia)`
`void`	`setTransformAndStop(Transform t)` Stop this `RigidBody` This is equivalent to: `setTransform(t); stop();`
`void`	`stop()` Stop this `RigidBody` This is equivalent to: `setLinearVelocity(Vec3.zero); setAngularVelocity(Vec3.zero);`

Methods inherited from class com.bonzaiengine.physics.CollisionObject
activate, getActivationState, getCollisionShape, getFriction, getRestitution, getRollingFriction, getTransform, getUserObject, getWorldTransform, hasContactResponse, isActive, isKinematicObject, isStaticObject, setActivationState, setContactResponse, setFriction, setRestitution, setRollingFriction, setTransform, setTransform, setUserObject, setWorldTransform, setWorldTransform

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

- Method Detail
  - destroy
```
public void destroy()
```
    Description copied from class: CollisionObject
    
    Must call CollisionObject.nSetUserPointer(long, CollisionObject) and destroy native objects
    
    Specified by:
    
    destroy in interface INative
    
    Overrides:
    
    destroy in class CollisionObject
    
    See Also:
    
    CollisionObject.nSetUserPointer(long, CollisionObject)
  - setCollisionShape
```
public void setCollisionShape(CollisionShape shape)
                       throws java.lang.IllegalStateException
```
    Overrides:
    
    setCollisionShape in class CollisionObject
    
    Parameters:
    
    shape - new CollisionShape for this RigidBody
    
    Throws:
    
    java.lang.IllegalStateException - when getNumConstraints() is not 0
  - getMass
```
public final float getMass()
```
    Returns:
    
    the mass or 0 if static
  - setMass
```
public final void setMass(float mass)
```
    Parameters:
    
    the - new mass
  - setMass
```
public final void setMass(float mass,
                          boolean inertia)
```
  - setKinematic
```
public final void setKinematic(boolean kinematic)
```
    Parameters:
    
    kinematic - true to set this RigidBody a kinematic object
    
    See Also:
    
    CollisionObject.isKinematicObject()
  - getGravity
```
public final Vec3 getGravity(Vec3 dst)
```
    Parameters:
    
    dst - destination to store the gravity force applied to this RigidBody.
    By default, it is set to the default PhysicWorld gravity force which is equals to the earth gravity.
    
    Returns:
    
    dst
  - setTransformAndStop
```
public final void setTransformAndStop(Transform t)
```
    Stop this RigidBody
    
    This is equivalent to:
    setTransform(t); stop();
  - stop
```
public final void stop()
```
    Stop this RigidBody
    
    This is equivalent to:
    setLinearVelocity(Vec3.zero); setAngularVelocity(Vec3.zero);
  - setGravity
```
public final void setGravity(Vec3 gravity)
```
    Override gravity force of PhysicWorld to this RigidBody.
    This must be called after PhysicWorld#addRigidBody(RigidBody) has been called
  - getLinearVelocity
```
public final Vec3 getLinearVelocity(Vec3 dst)
```
    Parameters:
    
    dst - destination to store the linear ('translation') velocity of this RigidBody.
    
    Returns:
    
    dst
  - setLinearVelocity
```
public final void setLinearVelocity(Vec3 linearVelocity)
```
    Parameters:
    
    angularVelocity - new linear velocity for this RigidBody
  - getAngularVelocity
```
public final Vec3 getAngularVelocity(Vec3 dst)
```
    Parameters:
    
    dst - destination to store the angular ('rotation') velocity of this RigidBody.
    
    Returns:
    
    dst
  - setAngularVelocity
```
public final void setAngularVelocity(Vec3 angularVelocity)
```
    Parameters:
    
    angularVelocity - new angular velocity for this RigidBody
  - getLinearDamping
```
public final float getLinearDamping()
```
  - setLinearDamping
```
public final void setLinearDamping(float linearDamping)
```
    Damping is similar to friction but also applies when the body is not touching any other surface.
    Linear damping applies for translation. Value is clamped in range [0;1], default value is 0.0
  - getAngularDamping
```
public final float getAngularDamping()
```
  - setAngularDamping
```
public final void setAngularDamping(float angularDamping)
```
    Damping is similar to friction but also applies when the body is not touching any other surface.
    Angular damping applies for rotation. Value is clamped in range [0;1], default value is 0.0
  - getLinearFactor
```
public final void getLinearFactor(Vec3 dst)
```
  - setLinearFactor
```
public final void setLinearFactor(Vec3 linearFactor)
```
    Linear factor is used to attenuate/reduce body translation (0 to block translation).
    Default value is (1,1,1) which is no attenuation
  - getAngularFactor
```
public final void getAngularFactor(Vec3 dst)
```
  - setAngularFactor
```
public final void setAngularFactor(Vec3 angularFactor)
```
    Angular factor is used to attenuate/reduce body rotation (0 to block rotation).
    Default value is (1,1,1) which is no attenuation
  - getNumConstraints
```
public final int getNumConstraints()
```
    Returns:
    
    the number of Constraint applied to this RigidBody
  - getConstraints
```
public final Constraint[] getConstraints()
```
  - applyTorque
```
public final void applyTorque(Vec3 torque)
```
  - applyForce
```
public final void applyForce(Vec3 force,
                             Vec3 relPos)
```
  - applyCentralImpulse
```
public final void applyCentralImpulse(Vec3 impulse)
```
  - applyTorqueImpulse
```
public final void applyTorqueImpulse(Vec3 torque)
```
  - applyCentralForce
```
public final void applyCentralForce(Vec3 force)
```
  - applyImpulse
```
public final void applyImpulse(Vec3 impulse,
                               Vec3 relPos)
```
  - clearForces
```
public final void clearForces()
```
  - getTotalForce
```
public final void getTotalForce(Vec3 dst)
```
  - getTotalTorque
```
public final void getTotalTorque(Vec3 dst)
```

Class RigidBody

Nested Class Summary

Nested classes/interfaces inherited from class com.bonzaiengine.physics.CollisionObject

Method Summary

Methods inherited from class com.bonzaiengine.physics.CollisionObject

Methods inherited from class java.lang.Object

Method Detail

destroy

setCollisionShape

getMass

setMass

setMass

setKinematic

getGravity

setTransformAndStop

stop

setGravity

getLinearVelocity

setLinearVelocity

getAngularVelocity

setAngularVelocity

getLinearDamping

setLinearDamping

getAngularDamping

setAngularDamping

getLinearFactor

setLinearFactor

getAngularFactor

setAngularFactor

getNumConstraints

getConstraints

applyTorque

applyForce

applyCentralImpulse

applyTorqueImpulse

applyCentralForce

applyImpulse

clearForces

getTotalForce

getTotalTorque