Object
- AbstractCollisionBody<BodyFixture>
- - AbstractPhysicsBody

All Implemented Interfaces:

CollisionBody<BodyFixture>, DataContainer, PhysicsBody, Rotatable, Shiftable, Transformable, Translatable, Ownable

Direct Known Subclasses:

Body
```
public abstract class AbstractPhysicsBody
extends AbstractCollisionBody<BodyFixture>
implements PhysicsBody, CollisionBody<BodyFixture>, Transformable, DataContainer, Ownable
```
Abstract implementation of the PhysicsBody interface.

Since:

4.0.0

Version:

4.1.0

Author:

William Bittle

Field Summary

Fields
Modifier and Type	Field	Description
`protected double`	`angularDamping`	The `AbstractPhysicsBody`'s angular damping
`protected double`	`angularVelocity`	The current angular velocity
`protected boolean`	`atRest`	True if the body is at-rest
`protected boolean`	`atRestDetectionEnabled`	True if at-rest detection is enabled
`protected double`	`atRestTime`	The time that the `PhysicsBody` has been at-rest
`protected boolean`	`bullet`	True if the body is fast, small or both
`protected Vector2`	`force`	The current force
`protected List<Force>`	`forces`	The force accumulator
`protected double`	`gravityScale`	The per body gravity scale factor
`protected double`	`linearDamping`	The `AbstractPhysicsBody`'s linear damping
`protected Vector2`	`linearVelocity`	The current linear velocity
`protected Mass`	`mass`	The `Mass` information
`protected double`	`torque`	The current torque
`protected List<Torque>`	`torques`	The torque accumulator

Fields inherited from class AbstractCollisionBody
enabled, fixtureModificationHandler, fixtures, fixturesUnmodifiable, owner, radius, transform, transform0, userData

Fields inherited from interface CollisionBody
TYPICAL_FIXTURE_COUNT

Fields inherited from interface PhysicsBody
DEFAULT_ANGULAR_DAMPING, DEFAULT_LINEAR_DAMPING

Constructor Summary

Constructors
Constructor Description

AbstractPhysicsBody()
Default constructor.

AbstractPhysicsBody(int fixtureCount)
Optional constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected void`	`accumulate(double elapsedTime)`	Accumulates the forces and torques.
`BodyFixture`	`addFixture(Convex convex)`	Creates a `Fixture` for the given `Convex` `Shape`, adds it to this `CollisionBody`, and returns it.
`BodyFixture`	`addFixture(Convex convex, double density)`	Creates a `BodyFixture` for the given `Convex` `Shape`, adds it to the `PhysicsBody`, and returns it for configuration.
`BodyFixture`	`addFixture(Convex convex, double density, double friction, double restitution)`	Creates a `BodyFixture` for the given `Convex` `Shape`, adds it to the `PhysicsBody`, and returns it for configuration.
`AbstractPhysicsBody`	`applyForce(Force force)`	Applies the given `Force` to this `PhysicsBody`.
`AbstractPhysicsBody`	`applyForce(Vector2 force)`	Applies the given force to this `PhysicsBody`.
`AbstractPhysicsBody`	`applyForce(Vector2 force, Vector2 point)`	Applies the given force to this `PhysicsBody` at the given point (torque).
`AbstractPhysicsBody`	`applyImpulse(double impulse)`	Applies an angular impulse to this `PhysicsBody` about its center of mass.
`AbstractPhysicsBody`	`applyImpulse(Vector2 impulse)`	Applies a linear impulse to this `PhysicsBody` at its center of mass.
`AbstractPhysicsBody`	`applyImpulse(Vector2 impulse, Vector2 point)`	Applies an impulse to this `PhysicsBody` at the given point.
`AbstractPhysicsBody`	`applyTorque(double torque)`	Applies the given torque about the center of this `PhysicsBody`.
`AbstractPhysicsBody`	`applyTorque(Torque torque)`	Applies the given `Torque` to this `PhysicsBody`.
`void`	`clearAccumulatedForce()`	Clears the forces stored in the force accumulator.
`void`	`clearAccumulatedTorque()`	Clears the torques stored in the torque accumulator.
`void`	`clearForce()`	Clears the last time step's force on the `PhysicsBody`.
`void`	`clearTorque()`	Clears the last time step's torque on the `PhysicsBody`.
`void`	`computeSweptAABB(AABB result)`	Computes a swept `AABB` that contains the maximal space in which the `PhysicsBody` exists from the initial transform to the final transform and places the result in the given AABB.
`void`	`computeSweptAABB(Transform initialTransform, Transform finalTransform, AABB result)`	Computes a swept `AABB` from the given start and end `Transform`s using the fixtures on this `PhysicsBody` and places the result in the given AABB.
`AABB`	`createSweptAABB()`	Returns a swept `AABB` that contains the maximal space in which the `PhysicsBody` exists from the initial transform to the final transform.
`AABB`	`createSweptAABB(Transform initialTransform, Transform finalTransform)`	Creates a swept `AABB` from the given start and end `Transform`s using the fixtures on this `PhysicsBody`.
`Vector2`	`getAccumulatedForce()`	Returns the total force currently stored in the force accumulator.
`double`	`getAccumulatedTorque()`	Returns the total torque currently stored in the torque accumulator.
`double`	`getAngularDamping()`	Returns the angular damping.
`double`	`getAngularVelocity()`	Returns the angular velocity.
`double`	`getChangeInOrientation()`	Returns the change in orientation computed from last frame's transform and this frame's transform.
`Vector2`	`getChangeInPosition()`	Returns the change in position computed from last frame's transform and this frame's transform.
`Vector2`	`getForce()`	Returns the force applied in the last iteration.
`double`	`getGravityScale()`	Returns the gravity scale.
`double`	`getLinearDamping()`	Returns the linear damping.
`Vector2`	`getLinearVelocity()`	Returns the linear velocity.
`Vector2`	`getLinearVelocity(Vector2 point)`	Returns the velocity of this body at the given world space point.
`Vector2`	`getLocalCenter()`	Returns the center for this `CollisionBody` in local coordinates.
`Mass`	`getMass()`	Returns this `PhysicsBody`'s mass information.
`double`	`getTorque()`	Returns the torque applied in the last iteration.
`Vector2`	`getWorldCenter()`	Returns the center for this `CollisionBody` in world coordinates.
`void`	`integratePosition(TimeStep timestep, Settings settings)`	Integrates the linear and angular velocities to update the position and rotation of this body
`void`	`integrateVelocity(Vector2 gravity, TimeStep timestep, Settings settings)`	Integrates the forces, torques, and gravity to update the linear and angular velocity of this body.
`boolean`	`isAtRest()`	Returns true if this `PhysicsBody` is at-rest.
`boolean`	`isAtRestDetectionEnabled()`	Returns true if this `PhysicsBody` can participate in automatic at-rest detection.
`boolean`	`isBullet()`	Returns true if this `PhysicsBody` is a bullet.
`boolean`	`isDynamic()`	Returns true if this body's mass type is NOT `MassType.INFINITE`.
`boolean`	`isKinematic()`	Returns true if this body's mass type is `MassType.INFINITE` and either the linear or angular velocity are NOT zero (i.e.
`boolean`	`isStatic()`	Returns true if this body's mass type is `MassType.INFINITE` and the linear and angular velocity are close to zero (as determined by `Epsilon.E`.
`void`	`setAngularDamping(double angularDamping)`	Sets the angular damping.
`void`	`setAngularVelocity(double angularVelocity)`	Sets the angular velocity in radians per second
`void`	`setAtRest(boolean flag)`	Sets whether this `PhysicsBody` is at-rest or not.
`void`	`setAtRestDetectionEnabled(boolean flag)`	Determines whether this `PhysicsBody` can participate in automatic at-rest detection.
`void`	`setBullet(boolean flag)`	Sets the bullet flag for this `PhysicsBody`.
`void`	`setGravityScale(double scale)`	Sets the gravity scale.
`void`	`setLinearDamping(double linearDamping)`	Sets the linear damping.
`void`	`setLinearVelocity(double x, double y)`	Sets the linear velocity.
`void`	`setLinearVelocity(Vector2 velocity)`	Sets the linear velocity.
`AbstractPhysicsBody`	`setMass(Mass mass)`	Explicitly sets this `PhysicsBody`'s mass information.
`AbstractPhysicsBody`	`setMass(MassType type)`	This method should be called after fixture modification is complete.
`AbstractPhysicsBody`	`setMassType(MassType type)`	Sets the `MassType` of this `PhysicsBody`.
`String`	`toString()`
`double`	`updateAtRestTime(TimeStep timestep, Settings settings)`	Updates the at-rest time for this body based on the given timestep and returns the current at-rest time.
`AbstractPhysicsBody`	`updateMass()`	This is a shortcut method for the `PhysicsBody.setMass(org.dyn4j.geometry.MassType)` method that will use the current mass type as the mass type and then recompute the mass from the body's fixtures.

Methods inherited from class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface DataContainer
getUserData, setUserData

Methods inherited from interface Ownable
getOwner, setOwner

Methods inherited from interface Rotatable
rotate, rotate, rotate, rotate, rotate, rotate

Methods inherited from interface Shiftable
shift

Methods inherited from interface Translatable
translate, translate

- Field Detail
  - mass
```
protected Mass mass
```
    The Mass information
  - linearVelocity
```
protected final Vector2 linearVelocity
```
    The current linear velocity
  - angularVelocity
```
protected double angularVelocity
```
    The current angular velocity
  - linearDamping
```
protected double linearDamping
```
    The AbstractPhysicsBody's linear damping
  - angularDamping
```
protected double angularDamping
```
    The AbstractPhysicsBody's angular damping
  - gravityScale
```
protected double gravityScale
```
    The per body gravity scale factor
  - bullet
```
protected boolean bullet
```
    True if the body is fast, small or both
  - atRestDetectionEnabled
```
protected boolean atRestDetectionEnabled
```
    True if at-rest detection is enabled
  - atRest
```
protected boolean atRest
```
    True if the body is at-rest
  - atRestTime
```
protected double atRestTime
```
    The time that the PhysicsBody has been at-rest
  - force
```
protected final Vector2 force
```
    The current force
  - torque
```
protected double torque
```
    The current torque
  - forces
```
protected final List<Force> forces
```
    The force accumulator
  - torques
```
protected final List<Torque> torques
```
    The torque accumulator
- Constructor Detail
  - AbstractPhysicsBody
```
public AbstractPhysicsBody()
```
    Default constructor.
  - AbstractPhysicsBody
```
public AbstractPhysicsBody(int fixtureCount)
```
    Optional constructor.
    Creates a new AbstractPhysicsBody using the given estimated fixture count. Assignment of the initial fixture count allows sizing of internal structures for optimal memory/performance. This estimated fixture count is not a limit on the number of fixtures.
    
    Parameters:
    
    fixtureCount - the estimated number of fixtures
    
    Throws:
    
    IllegalArgumentException - if fixtureCount less than zero
    
    Since:
    
    3.1.1
- Method Detail
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - addFixture
```
public BodyFixture addFixture(Convex convex)
```
    Description copied from interface: CollisionBody
    
    Creates a Fixture for the given Convex Shape, adds it to this CollisionBody, and returns it.
    
    Specified by:
    
    addFixture in interface CollisionBody<BodyFixture>
    
    Parameters:
    
    convex - the Convex Shape to add
    
    Returns:
    
    T the fixture created
  - addFixture
```
public BodyFixture addFixture(Convex convex,
                              double density)
```
    Description copied from interface: PhysicsBody
    
    Creates a BodyFixture for the given Convex Shape, adds it to the PhysicsBody, and returns it for configuration.
    After adding or removing fixtures make sure to call the PhysicsBody.updateMass() or PhysicsBody.setMass(MassType) method to compute the new total Mass for the body.
    This is a convenience method for setting the density of a BodyFixture.
    
    Specified by:
    
    addFixture in interface PhysicsBody
    
    Parameters:
    
    convex - the Convex Shape to add to the PhysicsBody
    
    density - the density of the shape in kg/m²; in the range (0.0, ∞]
    
    Returns:
    
    BodyFixture the fixture created using the given Shape and added to the PhysicsBody
    
    See Also:
    
    CollisionBody.addFixture(Convex), PhysicsBody.addFixture(Convex, double, double, double)
  - addFixture
```
public BodyFixture addFixture(Convex convex,
                              double density,
                              double friction,
                              double restitution)
```
    Description copied from interface: PhysicsBody
    
    Creates a BodyFixture for the given Convex Shape, adds it to the PhysicsBody, and returns it for configuration.
    After adding or removing fixtures make sure to call the PhysicsBody.updateMass() or PhysicsBody.setMass(MassType) method to compute the new total Mass for the body.
    This is a convenience method for setting the properties of a BodyFixture. Use the BodyFixture.DEFAULT_DENSITY, BodyFixture.DEFAULT_FRICTION, and BodyFixture.DEFAULT_RESTITUTION values if you need to only set one of these properties.
    
    Specified by:
    
    addFixture in interface PhysicsBody
    
    Parameters:
    
    convex - the Convex Shape to add to the PhysicsBody
    
    density - the density of the shape in kg/m²; in the range (0.0, ∞]
    
    friction - the coefficient of friction; in the range [0.0, ∞]
    
    restitution - the coefficient of restitution; in the range [0.0, ∞]
    
    Returns:
    
    BodyFixture the fixture created using the given Shape and added to the PhysicsBody
    
    See Also:
    
    CollisionBody.addFixture(Convex), PhysicsBody.addFixture(Convex, double)
  - updateMass
```
public AbstractPhysicsBody updateMass()
```
    Description copied from interface: PhysicsBody
    
    This is a shortcut method for the PhysicsBody.setMass(org.dyn4j.geometry.MassType) method that will use the current mass type as the mass type and then recompute the mass from the body's fixtures.
    
    Specified by:
    
    updateMass in interface PhysicsBody
    
    Returns:
    
    PhysicsBody this body
    
    See Also:
    
    PhysicsBody.setMass(org.dyn4j.geometry.MassType)
  - setMass
```
public AbstractPhysicsBody setMass(MassType type)
```
    Description copied from interface: PhysicsBody
    
    This method should be called after fixture modification is complete.
    This method will calculate a total mass for the body given the masses of the attached fixtures.
    A MassType can be used to create special mass types.
    
    Specified by:
    
    setMass in interface PhysicsBody
    
    Parameters:
    
    type - the mass type
    
    Returns:
    
    PhysicsBody this body
  - setMass
```
public AbstractPhysicsBody setMass(Mass mass)
```
    Description copied from interface: PhysicsBody
    
    Explicitly sets this PhysicsBody's mass information.
    
    Specified by:
    
    setMass in interface PhysicsBody
    
    Parameters:
    
    mass - the new Mass
    
    Returns:
    
    PhysicsBody this body
  - setMassType
```
public AbstractPhysicsBody setMassType(MassType type)
```
    Description copied from interface: PhysicsBody
    
    Sets the MassType of this PhysicsBody.
    This method does not compute/recompute the mass of the body but solely sets the mass type to one of the special types.
    Since its possible to create a Mass object with zero mass and/or zero inertia (Mass m = new Mass(new Vector2(), 0, 0); for example), setting the type to something other than MassType.INFINITE can have undefined results.
    
    Specified by:
    
    setMassType in interface PhysicsBody
    
    Parameters:
    
    type - the desired type
    
    Returns:
    
    PhysicsBody this body
  - getMass
```
public Mass getMass()
```
    Description copied from interface: PhysicsBody
    
    Returns this PhysicsBody's mass information.
    
    Specified by:
    
    getMass in interface PhysicsBody
    
    Returns:
    
    Mass
  - applyForce
```
public AbstractPhysicsBody applyForce(Vector2 force)
```
    Description copied from interface: PhysicsBody
    
    Applies the given force to this PhysicsBody.
    This method will wake-up the body if its sleeping.
    This method does not apply the force if this body returns zero from the Mass.getMass() method.
    The force is not applied immediately, but instead stored in the force accumulator (PhysicsBody.getAccumulatedForce()). This is to preserve the last time step's computed force (PhysicsBody.getForce().
    The force is assumed to be in world space coordinates.
    
    Specified by:
    
    applyForce in interface PhysicsBody
    
    Parameters:
    
    force - the force
    
    Returns:
    
    PhysicsBody this body
  - applyForce
```
public AbstractPhysicsBody applyForce(Force force)
```
    Description copied from interface: PhysicsBody
    
    Applies the given Force to this PhysicsBody.
    This method will wake-up the body if its sleeping.
    This method does not apply the force if this body returns zero from the Mass.getMass() method.
    The force is not applied immediately, but instead stored in the force accumulator (PhysicsBody.getAccumulatedForce()). This is to preserve the last time step's computed force (PhysicsBody.getForce().
    The force is assumed to be in world space coordinates.
    
    Specified by:
    
    applyForce in interface PhysicsBody
    
    Parameters:
    
    force - the force
    
    Returns:
    
    PhysicsBody this body
  - applyTorque
```
public AbstractPhysicsBody applyTorque(double torque)
```
    Description copied from interface: PhysicsBody
    
    Applies the given torque about the center of this PhysicsBody.
    This method will wake-up the body if its sleeping.
    This method does not apply the torque if this body returns zero from the Mass.getInertia() method.
    The torque is not applied immediately, but instead stored in the torque accumulator (PhysicsBody.getAccumulatedTorque()). This is to preserve the last time step's computed torque (PhysicsBody.getTorque().
    
    Specified by:
    
    applyTorque in interface PhysicsBody
    
    Parameters:
    
    torque - the torque about the center
    
    Returns:
    
    PhysicsBody this body
  - applyTorque
```
public AbstractPhysicsBody applyTorque(Torque torque)
```
    Description copied from interface: PhysicsBody
    
    Applies the given Torque to this PhysicsBody.
    This method will wake-up the body if its sleeping.
    This method does not apply the torque if this body returns zero from the Mass.getInertia() method.
    The torque is not applied immediately, but instead stored in the torque accumulator (PhysicsBody.getAccumulatedTorque()). This is to preserve the last time step's computed torque (PhysicsBody.getTorque().
    
    Specified by:
    
    applyTorque in interface PhysicsBody
    
    Parameters:
    
    torque - the torque
    
    Returns:
    
    PhysicsBody this body
  - applyForce
```
public AbstractPhysicsBody applyForce(Vector2 force,
                                      Vector2 point)
```
    Description copied from interface: PhysicsBody
    
    Applies the given force to this PhysicsBody at the given point (torque).
    This method will wake-up the body if its sleeping.
    This method does not apply the force if this body returns zero from the Mass.getMass() method nor will it apply the torque if this body returns zero from the Mass.getInertia() method.
    The force/torque is not applied immediately, but instead stored in the force/torque accumulators (PhysicsBody.getAccumulatedForce() and PhysicsBody.getAccumulatedTorque()). This is to preserve the last time step's computed force (PhysicsBody.getForce() and torque (PhysicsBody.getTorque()).
    The force and point are assumed to be in world space coordinates.
    
    Specified by:
    
    applyForce in interface PhysicsBody
    
    Parameters:
    
    force - the force
    
    point - the application point in world coordinates
    
    Returns:
    
    PhysicsBody this body
  - applyImpulse
```
public AbstractPhysicsBody applyImpulse(Vector2 impulse)
```
    Description copied from interface: PhysicsBody
    
    Applies a linear impulse to this PhysicsBody at its center of mass.
    This method will wake-up the body if its sleeping.
    This method does not apply the impulse if this body's mass returns zero from the Mass.getInertia() method.
    NOTE: Applying an impulse differs from applying a force and/or torque. Forces and torques are stored in accumulators, but impulses are applied to the velocities of the body immediately.
    The impulse is assumed to be in world space coordinates.
    
    Specified by:
    
    applyImpulse in interface PhysicsBody
    
    Parameters:
    
    impulse - the impulse to apply
    
    Returns:
    
    PhysicsBody this body
  - applyImpulse
```
public AbstractPhysicsBody applyImpulse(double impulse)
```
    Description copied from interface: PhysicsBody
    
    Applies an angular impulse to this PhysicsBody about its center of mass.
    This method will wake-up the body if its sleeping.
    This method does not apply the impulse if this body's inertia returns zero from the Mass.getInertia() method.
    NOTE: Applying an impulse differs from applying a force and/or torque. Forces and torques are stored in accumulators, but impulses are applied to the velocities of the body immediately.
    
    Specified by:
    
    applyImpulse in interface PhysicsBody
    
    Parameters:
    
    impulse - the impulse to apply
    
    Returns:
    
    PhysicsBody this body
  - applyImpulse
```
public AbstractPhysicsBody applyImpulse(Vector2 impulse,
                                        Vector2 point)
```
    Description copied from interface: PhysicsBody
    
    Applies an impulse to this PhysicsBody at the given point.
    This method will wake-up the body if its sleeping.
    This method does not apply the linear impulse if this body returns zero from the Mass.getMass() method nor will it apply the angular impulse if this body returns zero from the Mass.getInertia() method.
    NOTE: Applying an impulse differs from applying a force and/or torque. Forces and torques are stored in accumulators, but impulses are applied to the velocities of the body immediately.
    The impulse and point are assumed to be in world space coordinates.
    
    Specified by:
    
    applyImpulse in interface PhysicsBody
    
    Parameters:
    
    impulse - the impulse to apply
    
    point - the world space point to apply the impulse
    
    Returns:
    
    PhysicsBody this body
  - clearForce
```
public void clearForce()
```
    Description copied from interface: PhysicsBody
    
    Clears the last time step's force on the PhysicsBody.
    
    Specified by:
    
    clearForce in interface PhysicsBody
  - clearAccumulatedForce
```
public void clearAccumulatedForce()
```
    Description copied from interface: PhysicsBody
    
    Clears the forces stored in the force accumulator.
    Renamed from clearForces (3.0.0 and below).
    
    Specified by:
    
    clearAccumulatedForce in interface PhysicsBody
  - clearTorque
```
public void clearTorque()
```
    Description copied from interface: PhysicsBody
    
    Clears the last time step's torque on the PhysicsBody.
    
    Specified by:
    
    clearTorque in interface PhysicsBody
  - clearAccumulatedTorque
```
public void clearAccumulatedTorque()
```
    Description copied from interface: PhysicsBody
    
    Clears the torques stored in the torque accumulator.
    Renamed from clearTorques (3.0.0 and below).
    
    Specified by:
    
    clearAccumulatedTorque in interface PhysicsBody
  - accumulate
```
protected void accumulate(double elapsedTime)
```
    Accumulates the forces and torques.
    
    Parameters:
    
    elapsedTime - the elapsed time since the last call
    
    Since:
    
    3.1.0
  - integrateVelocity
```
public void integrateVelocity(Vector2 gravity,
                              TimeStep timestep,
                              Settings settings)
```
    Description copied from interface: PhysicsBody
    
    Integrates the forces, torques, and gravity to update the linear and angular velocity of this body.
    
    Specified by:
    
    integrateVelocity in interface PhysicsBody
    
    Parameters:
    
    gravity - the world gravity
    
    timestep - the timestep information
    
    settings - the world settings
  - integratePosition
```
public void integratePosition(TimeStep timestep,
                              Settings settings)
```
    Description copied from interface: PhysicsBody
    
    Integrates the linear and angular velocities to update the position and rotation of this body
    
    Specified by:
    
    integratePosition in interface PhysicsBody
    
    Parameters:
    
    timestep - the timestep information
    
    settings - the world settings
  - updateAtRestTime
```
public double updateAtRestTime(TimeStep timestep,
                               Settings settings)
```
    Description copied from interface: PhysicsBody
    
    Updates the at-rest time for this body based on the given timestep and returns the current at-rest time.
    For PhysicsBody.isStatic() bodies, this method will return -1 to indicate that this body can always be at-rest since it's velocity is zero and cannot be moved.
    
    Specified by:
    
    updateAtRestTime in interface PhysicsBody
    
    Parameters:
    
    timestep - the timestep information
    
    settings - the world settings
    
    Returns:
    
    double
  - isStatic
```
public boolean isStatic()
```
    Description copied from interface: PhysicsBody
    
    Returns true if this body's mass type is MassType.INFINITE and the linear and angular velocity are close to zero (as determined by Epsilon.E.
    
    Specified by:
    
    isStatic in interface PhysicsBody
    
    Returns:
    
    boolean
  - isKinematic
```
public boolean isKinematic()
```
    Description copied from interface: PhysicsBody
    
    Returns true if this body's mass type is MassType.INFINITE and either the linear or angular velocity are NOT zero (i.e. it's moving).
    
    Specified by:
    
    isKinematic in interface PhysicsBody
    
    Returns:
    
    boolean
  - isDynamic
```
public boolean isDynamic()
```
    Description copied from interface: PhysicsBody
    
    Returns true if this body's mass type is NOT MassType.INFINITE.
    
    Specified by:
    
    isDynamic in interface PhysicsBody
    
    Returns:
    
    boolean
  - setAtRestDetectionEnabled
```
public void setAtRestDetectionEnabled(boolean flag)
```
    Description copied from interface: PhysicsBody
    
    Determines whether this PhysicsBody can participate in automatic at-rest detection.
    
    Specified by:
    
    setAtRestDetectionEnabled in interface PhysicsBody
    
    Parameters:
    
    flag - true if it should
  - isAtRestDetectionEnabled
```
public boolean isAtRestDetectionEnabled()
```
    Description copied from interface: PhysicsBody
    
    Returns true if this PhysicsBody can participate in automatic at-rest detection.
    
    Specified by:
    
    isAtRestDetectionEnabled in interface PhysicsBody
    
    Returns:
    
    boolean
  - isAtRest
```
public boolean isAtRest()
```
    Description copied from interface: PhysicsBody
    
    Returns true if this PhysicsBody is at-rest.
    
    Specified by:
    
    isAtRest in interface PhysicsBody
    
    Returns:
    
    boolean
  - setAtRest
```
public void setAtRest(boolean flag)
```
    Description copied from interface: PhysicsBody
    
    Sets whether this PhysicsBody is at-rest or not.
    If flag is true, this body's velocity, angular velocity, force, torque, and accumulators are cleared.
    
    Specified by:
    
    setAtRest in interface PhysicsBody
    
    Parameters:
    
    flag - true if the body should be at-rest
  - isBullet
```
public boolean isBullet()
```
    Description copied from interface: PhysicsBody
    
    Returns true if this PhysicsBody is a bullet.
    
    Specified by:
    
    isBullet in interface PhysicsBody
    
    Returns:
    
    boolean
    
    See Also:
    
    PhysicsBody.setBullet(boolean)
  - setBullet
```
public void setBullet(boolean flag)
```
    Description copied from interface: PhysicsBody
    
    Sets the bullet flag for this PhysicsBody.
    A bullet is a very fast moving body that requires continuous collision detection with all other PhysicsBodys to ensure that no collisions are missed.
    
    Specified by:
    
    setBullet in interface PhysicsBody
    
    Parameters:
    
    flag - true if this PhysicsBody is a bullet
  - createSweptAABB
```
public AABB createSweptAABB()
```
    Description copied from interface: PhysicsBody
    
    Returns a swept AABB that contains the maximal space in which the PhysicsBody exists from the initial transform to the final transform.
    The AABB returned from this method can vary based on the state of the body, the number of fixtures, whether the body was rotating or not, and so on. This method attempts to return the tightest fitting AABB possible, but it should not be relied on.
    NOTE: This method is dependent upon the CollisionBody.getRotationDiscRadius() and CollisionBody.getWorldCenter() methods in some scenarios, please ensure these are properly setup before calling this method.
    
    Specified by:
    
    createSweptAABB in interface PhysicsBody
    
    Returns:
    
    AABB
  - createSweptAABB
```
public AABB createSweptAABB(Transform initialTransform,
                            Transform finalTransform)
```
    Description copied from interface: PhysicsBody
    
    Creates a swept AABB from the given start and end Transforms using the fixtures on this PhysicsBody.
    The AABB returned from this method can vary based on the state of the body, the number of fixtures, whether the body was rotating or not, and so on. This method attempts to return the tightest fitting AABB possible, but it should not be relied on.
    NOTE: This method is dependent upon the CollisionBody.getRotationDiscRadius() and CollisionBody.getWorldCenter() methods in some scenarios, please ensure these are properly setup before calling this method.
    
    Specified by:
    
    createSweptAABB in interface PhysicsBody
    
    Parameters:
    
    initialTransform - the initial Transform
    
    finalTransform - the final Transform
    
    Returns:
    
    AABB
  - computeSweptAABB
```
public void computeSweptAABB(AABB result)
```
    Description copied from interface: PhysicsBody
    
    Computes a swept AABB that contains the maximal space in which the PhysicsBody exists from the initial transform to the final transform and places the result in the given AABB.
    The AABB returned from this method can vary based on the state of the body, the number of fixtures, whether the body was rotating or not, and so on. This method attempts to return the tightest fitting AABB possible, but it should not be relied on.
    NOTE: This method is dependent upon the CollisionBody.getRotationDiscRadius() and CollisionBody.getWorldCenter() methods in some scenarios, please ensure these are properly setup before calling this method.
    
    Specified by:
    
    computeSweptAABB in interface PhysicsBody
    
    Parameters:
    
    result - the AABB to set
  - computeSweptAABB
```
public void computeSweptAABB(Transform initialTransform,
                             Transform finalTransform,
                             AABB result)
```
    Description copied from interface: PhysicsBody
    
    Computes a swept AABB from the given start and end Transforms using the fixtures on this PhysicsBody and places the result in the given AABB.
    The AABB returned from this method can vary based on the state of the body, the number of fixtures, whether the body was rotating or not, and so on. This method attempts to return the tightest fitting AABB possible, but it should not be relied on.
    NOTE: This method is dependent upon the CollisionBody.getRotationDiscRadius() and CollisionBody.getWorldCenter() methods in some scenarios, please ensure these are properly setup before calling this method.
    
    Specified by:
    
    computeSweptAABB in interface PhysicsBody
    
    Parameters:
    
    initialTransform - the initial Transform
    
    finalTransform - the final Transform
    
    result - the AABB to set
  - getChangeInPosition
```
public Vector2 getChangeInPosition()
```
    Description copied from interface: PhysicsBody
    
    Returns the change in position computed from last frame's transform and this frame's transform.
    
    Specified by:
    
    getChangeInPosition in interface PhysicsBody
    
    Returns:
    
    Vector2
  - getChangeInOrientation
```
public double getChangeInOrientation()
```
    Description copied from interface: PhysicsBody
    
    Returns the change in orientation computed from last frame's transform and this frame's transform.
    This method will return a change in the range [0, 2π). This isn't as useful if the angular velocity is greater than 2π per time step. Since we don't have the timestep here, we can't compute the exact change in this case.
    If the angular velocity is zero, this method returns the minimum difference in orientation.
    
    Specified by:
    
    getChangeInOrientation in interface PhysicsBody
    
    Returns:
    
    double
  - getLocalCenter
```
public Vector2 getLocalCenter()
```
    Description copied from interface: CollisionBody
    
    Returns the center for this CollisionBody in local coordinates.
    
    Specified by:
    
    getLocalCenter in interface CollisionBody<BodyFixture>
    
    Returns:
    
    Vector2 the center in local coordinates
  - getWorldCenter
```
public Vector2 getWorldCenter()
```
    Description copied from interface: CollisionBody
    
    Returns the center for this CollisionBody in world coordinates.
    
    Specified by:
    
    getWorldCenter in interface CollisionBody<BodyFixture>
    
    Overrides:
    
    getWorldCenter in class AbstractCollisionBody<BodyFixture>
    
    Returns:
    
    Vector2 the center in world coordinates
  - getLinearVelocity
```
public Vector2 getLinearVelocity()
```
    Description copied from interface: PhysicsBody
    
    Returns the linear velocity.
    
    Specified by:
    
    getLinearVelocity in interface PhysicsBody
    
    Returns:
    
    Vector2
  - getLinearVelocity
```
public Vector2 getLinearVelocity(Vector2 point)
```
    Description copied from interface: PhysicsBody
    
    Returns the velocity of this body at the given world space point.
    
    Specified by:
    
    getLinearVelocity in interface PhysicsBody
    
    Parameters:
    
    point - the point in world space
    
    Returns:
    
    Vector2
  - setLinearVelocity
```
public void setLinearVelocity(Vector2 velocity)
```
    Description copied from interface: PhysicsBody
    
    Sets the linear velocity.
    Call the PhysicsBody.setAtRest(boolean) method to wake up the PhysicsBody if the PhysicsBody is asleep and the velocity is not zero.
    
    Specified by:
    
    setLinearVelocity in interface PhysicsBody
    
    Parameters:
    
    velocity - the desired velocity
  - setLinearVelocity
```
public void setLinearVelocity(double x,
                              double y)
```
    Description copied from interface: PhysicsBody
    
    Sets the linear velocity.
    Call the PhysicsBody.setAtRest(boolean) method to wake up the PhysicsBody if the PhysicsBody is asleep and the velocity is not zero.
    
    Specified by:
    
    setLinearVelocity in interface PhysicsBody
    
    Parameters:
    
    x - the linear velocity along the x-axis
    
    y - the linear velocity along the y-axis
  - getAngularVelocity
```
public double getAngularVelocity()
```
    Description copied from interface: PhysicsBody
    
    Returns the angular velocity.
    
    Specified by:
    
    getAngularVelocity in interface PhysicsBody
    
    Returns:
    
    double
  - setAngularVelocity
```
public void setAngularVelocity(double angularVelocity)
```
    Description copied from interface: PhysicsBody
    
    Sets the angular velocity in radians per second
    Call the PhysicsBody.setAtRest(boolean) method to wake up the PhysicsBody if the PhysicsBody is asleep and the velocity is not zero.
    
    Specified by:
    
    setAngularVelocity in interface PhysicsBody
    
    Parameters:
    
    angularVelocity - the angular velocity in radians per second
  - getForce
```
public Vector2 getForce()
```
    Description copied from interface: PhysicsBody
    
    Returns the force applied in the last iteration.
    This is the accumulated force from the last iteration.
    
    Specified by:
    
    getForce in interface PhysicsBody
    
    Returns:
    
    Vector2
  - getAccumulatedForce
```
public Vector2 getAccumulatedForce()
```
    Description copied from interface: PhysicsBody
    
    Returns the total force currently stored in the force accumulator.
    
    Specified by:
    
    getAccumulatedForce in interface PhysicsBody
    
    Returns:
    
    Vector2
  - getTorque
```
public double getTorque()
```
    Description copied from interface: PhysicsBody
    
    Returns the torque applied in the last iteration.
    This is the accumulated torque from the last iteration.
    
    Specified by:
    
    getTorque in interface PhysicsBody
    
    Returns:
    
    double
  - getAccumulatedTorque
```
public double getAccumulatedTorque()
```
    Description copied from interface: PhysicsBody
    
    Returns the total torque currently stored in the torque accumulator.
    
    Specified by:
    
    getAccumulatedTorque in interface PhysicsBody
    
    Returns:
    
    double
  - getLinearDamping
```
public double getLinearDamping()
```
    Description copied from interface: PhysicsBody
    
    Returns the linear damping.
    
    Specified by:
    
    getLinearDamping in interface PhysicsBody
    
    Returns:
    
    double
    
    See Also:
    
    PhysicsBody.setLinearDamping(double)
  - setLinearDamping
```
public void setLinearDamping(double linearDamping)
```
    Description copied from interface: PhysicsBody
    
    Sets the linear damping.
    Linear damping is used to reduce the linear velocity over time. The default is zero and larger values will cause the linear velocity to reduce faster.
    The units are seconds^-1.
    
    Specified by:
    
    setLinearDamping in interface PhysicsBody
    
    Parameters:
    
    linearDamping - the linear damping; must be greater than or equal to zero
  - getAngularDamping
```
public double getAngularDamping()
```
    Description copied from interface: PhysicsBody
    
    Returns the angular damping.
    
    Specified by:
    
    getAngularDamping in interface PhysicsBody
    
    Returns:
    
    double
    
    See Also:
    
    PhysicsBody.setAngularDamping(double)
  - setAngularDamping
```
public void setAngularDamping(double angularDamping)
```
    Description copied from interface: PhysicsBody
    
    Sets the angular damping.
    Angular damping is used to reduce the angular velocity over time. The default is zero and larger values will cause the angular velocity to reduce faster.
    The units are seconds^-1.
    
    Specified by:
    
    setAngularDamping in interface PhysicsBody
    
    Parameters:
    
    angularDamping - the angular damping; must be greater than or equal to zero
  - getGravityScale
```
public double getGravityScale()
```
    Description copied from interface: PhysicsBody
    
    Returns the gravity scale.
    
    Specified by:
    
    getGravityScale in interface PhysicsBody
    
    Returns:
    
    double
    
    See Also:
    
    PhysicsBody.setGravityScale(double)
  - setGravityScale
```
public void setGravityScale(double scale)
```
    Description copied from interface: PhysicsBody
    
    Sets the gravity scale.
    The gravity scale is a multiplier applied to the acceleration due to gravity before applying the force of gravity to the body. This allows bodies to be affected differently under the same gravity.
    
    Specified by:
    
    setGravityScale in interface PhysicsBody
    
    Parameters:
    
    scale - the gravity scale for this body

Constructor	Description
`AbstractPhysicsBody()`	Default constructor.
`AbstractPhysicsBody(int fixtureCount)`	Optional constructor.

Class AbstractPhysicsBody

Field Summary

Fields inherited from class AbstractCollisionBody

Fields inherited from interface CollisionBody

Fields inherited from interface PhysicsBody

Constructor Summary

Method Summary

Methods inherited from class AbstractCollisionBody

Methods inherited from class Object

Methods inherited from interface CollisionBody

Methods inherited from interface DataContainer

Methods inherited from interface Ownable

Methods inherited from interface Rotatable

Methods inherited from interface Shiftable

Methods inherited from interface Translatable

Field Detail

mass

linearVelocity

angularVelocity

linearDamping

angularDamping

gravityScale

bullet

atRestDetectionEnabled

atRest

atRestTime

force

torque

forces

torques

Constructor Detail

AbstractPhysicsBody

AbstractPhysicsBody

Method Detail

toString

addFixture

addFixture

addFixture

updateMass

setMass

setMass

setMassType

getMass

applyForce

applyForce

applyTorque

applyTorque

applyForce

applyImpulse

applyImpulse

applyImpulse

clearForce

clearAccumulatedForce

clearTorque

clearAccumulatedTorque

accumulate

integrateVelocity

integratePosition

updateAtRestTime

isStatic

isKinematic

isDynamic

setAtRestDetectionEnabled

isAtRestDetectionEnabled

isAtRest

setAtRest

isBullet

setBullet

createSweptAABB

createSweptAABB

computeSweptAABB

computeSweptAABB

getChangeInPosition

getChangeInOrientation

getLocalCenter

getWorldCenter

getLinearVelocity

getLinearVelocity

setLinearVelocity

setLinearVelocity