Body (fxgl-base 0.5.1 API)

java.lang.Object
- com.almasb.fxgl.physics.box2d.dynamics.Body

```
public final class Body
extends Object
```
A rigid body. These are created via World.createBody.

Author:

Daniel Murphy

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`e_activeFlag`
`static int`	`e_autoSleepFlag`
`static int`	`e_awakeFlag`
`static int`	`e_bulletFlag`
`static int`	`e_fixedRotationFlag`
`static int`	`e_islandFlag`
`static int`	`e_toiFlag`
`float`	`m_angularVelocity`
`ContactEdge`	`m_contactList`
`int`	`m_flags`
`Vec2`	`m_force`
`float`	`m_invI`
`float`	`m_invMass`
`int`	`m_islandIndex`
`JointEdge`	`m_jointList`
`Vec2`	`m_linearVelocity`
`float`	`m_mass`
`Sweep`	`m_sweep` The swept motion for CCD
`float`	`m_torque`
`Transform`	`m_xf` The body origin transform.
`Transform`	`m_xf0` The previous transform for particle simulation

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`applyAngularImpulse(float impulse)` Apply an angular impulse.
`void`	`applyForce(Vec2 force, Vec2 point)` Apply a force at a world point.
`void`	`applyForceToCenter(Vec2 force)` Apply a force to the center of mass.
`void`	`applyLinearImpulse(Vec2 impulse, Vec2 point, boolean wake)` Apply an impulse at a point.
`void`	`applyTorque(float torque)` Apply a torque.
`Fixture`	`createFixture(FixtureDef def)` Creates a fixture and attach it to this body.
`Fixture`	`createFixture(Shape shape, float density)` Creates a fixture from a shape and attach it to this body.
`void`	`destroyFixture(Fixture fixture)` Destroy a fixture.
`float`	`getAngle()` Get the angle in radians.
`float`	`getAngularDamping()` Get the angular damping of the body.
`float`	`getAngularVelocity()` Get the angular velocity.
`ContactEdge`	`getContactList()` Get the list of all contacts attached to this body.
`List<Fixture>`	`getFixtures()`
`float`	`getGravityScale()`
`float`	`getInertia()`
`JointEdge`	`getJointList()` Get the list of all joints attached to this body.
`float`	`getLinearDamping()` Get the linear damping of the body.
`Vec2`	`getLinearVelocity()` Get the linear velocity of the center of mass.
`Vec2`	`getLinearVelocityFromLocalPoint(Vec2 localPoint)` Get the world velocity of a local point.
`void`	`getLinearVelocityFromLocalPointToOut(Vec2 localPoint, Vec2 out)`
`Vec2`	`getLinearVelocityFromWorldPoint(Vec2 worldPoint)` Get the world linear velocity of a world point attached to this body.
`void`	`getLinearVelocityFromWorldPointToOut(Vec2 worldPoint, Vec2 out)`
`Vec2`	`getLocalCenter()` Get the local position of the center of mass.
`Vec2`	`getLocalPoint(Vec2 worldPoint)` Gets a local point relative to the body's origin given a world point.
`void`	`getLocalPointToOut(Vec2 worldPoint, Vec2 out)`
`Vec2`	`getLocalVector(Vec2 worldVector)` Gets a local vector given a world vector.
`void`	`getLocalVectorToOut(Vec2 worldVector, Vec2 out)`
`void`	`getLocalVectorToOutUnsafe(Vec2 worldVector, Vec2 out)`
`float`	`getMass()`
`void`	`getMassData(MassData data)` Get the mass data of the body.
`Vec2`	`getPosition()` Get the world body origin position.
`float`	`getSleepTime()`
`Transform`	`getTransform()`
`BodyType`	`getType()`
`Object`	`getUserData()` Get the user data pointer that was provided in the body definition.
`World`	`getWorld()` Get the parent world of this body.
`Vec2`	`getWorldCenter()` Get the world position of the center of mass.
`Vec2`	`getWorldPoint(Vec2 localPoint)` Get the world coordinates of a point given the local coordinates.
`void`	`getWorldPointToOut(Vec2 localPoint, Vec2 out)`
`Vec2`	`getWorldVector(Vec2 localVector)` Get the world coordinates of a vector given the local coordinates.
`void`	`getWorldVectorToOut(Vec2 localVector, Vec2 out)`
`void`	`getWorldVectorToOutUnsafe(Vec2 localVector, Vec2 out)`
`boolean`	`isActive()`
`boolean`	`isAwake()` Get the sleeping state of this body.
`boolean`	`isBullet()`
`boolean`	`isFixedRotation()`
`boolean`	`isSleepingAllowed()`
`void`	`resetMassData()` This resets the mass properties to the sum of the mass properties of the fixtures.
`void`	`setActive(boolean flag)` Set the active state of the body.
`void`	`setAngularDamping(float angularDamping)` Set the angular damping of the body.
`void`	`setAngularVelocity(float w)` Set the angular velocity.
`void`	`setAwake(boolean flag)` Set the sleep state of the body.
`void`	`setBullet(boolean flag)` Should this body be treated like a bullet for continuous collision detection?
`void`	`setFixedRotation(boolean flag)` Set this body to have fixed rotation.
`void`	`setGravityScale(float gravityScale)` Set the gravity scale of the body.
`void`	`setLinearDamping(float linearDamping)` Set the linear damping of the body.
`void`	`setLinearVelocity(Vec2 v)` Set the linear velocity of the center of mass.
`void`	`setMassData(MassData massData)` Set the mass properties to override the mass properties of the fixtures.
`void`	`setSleepingAllowed(boolean flag)` You can disable sleeping on this body.
`void`	`setTransform(Vec2 position, float angle)` Set the position of the body's origin and rotation.
`void`	`setType(BodyType type)` Set the type of this body.
`void`	`setUserData(Object data)` Set the user data.
`boolean`	`shouldCollide(Body other)` This is used to prevent connected bodies from colliding.

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

- Field Detail
  - e_islandFlag
```
public static final int e_islandFlag
```
    See Also:
    
    Constant Field Values
  - e_awakeFlag
```
public static final int e_awakeFlag
```
    See Also:
    
    Constant Field Values
  - e_autoSleepFlag
```
public static final int e_autoSleepFlag
```
    See Also:
    
    Constant Field Values
  - e_bulletFlag
```
public static final int e_bulletFlag
```
    See Also:
    
    Constant Field Values
  - e_fixedRotationFlag
```
public static final int e_fixedRotationFlag
```
    See Also:
    
    Constant Field Values
  - e_activeFlag
```
public static final int e_activeFlag
```
    See Also:
    
    Constant Field Values
  - e_toiFlag
```
public static final int e_toiFlag
```
    See Also:
    
    Constant Field Values
  - m_jointList
```
public JointEdge m_jointList
```
  - m_contactList
```
public ContactEdge m_contactList
```
  - m_flags
```
public int m_flags
```
  - m_islandIndex
```
public int m_islandIndex
```
  - m_xf
```
public final Transform m_xf
```
    The body origin transform.
  - m_xf0
```
public final Transform m_xf0
```
    The previous transform for particle simulation
  - m_sweep
```
public final Sweep m_sweep
```
    The swept motion for CCD
  - m_linearVelocity
```
public final Vec2 m_linearVelocity
```
  - m_angularVelocity
```
public float m_angularVelocity
```
  - m_force
```
public final Vec2 m_force
```
  - m_torque
```
public float m_torque
```
  - m_mass
```
public float m_mass
```
  - m_invMass
```
public float m_invMass
```
  - m_invI
```
public float m_invI
```
- Method Detail
  - getFixtures
```
public List<Fixture> getFixtures()
```
    Returns:
    
    reference to the underlying list of fixtures attached to this body
  - createFixture
```
public Fixture createFixture(FixtureDef def)
```
    Creates a fixture and attach it to this body. Use this function if you need to set some fixture parameters, like friction. Otherwise you can create the fixture directly from a shape. If the density is non-zero, this function automatically updates the mass of the body. Contacts are not created until the next time step. Note: This function is locked during callbacks.
    
    Parameters:
    
    def - the fixture definition
  - createFixture
```
public Fixture createFixture(Shape shape,
                             float density)
```
    Creates a fixture from a shape and attach it to this body. This is a convenience function. Use FixtureDef if you need to set parameters like friction, restitution, user data, or filtering. If the density is non-zero, this function automatically updates the mass of the body. Note: this function is locked during callbacks.
    
    Parameters:
    
    shape - the shape to be cloned.
    
    density - the shape density (set to zero for static bodies).
  - destroyFixture
```
public void destroyFixture(Fixture fixture)
```
    Destroy a fixture. This removes the fixture from the broad-phase and destroys all contacts associated with this fixture. This will automatically adjust the mass of the body if the body is dynamic and the fixture has positive density. All fixtures attached to a body are implicitly destroyed when the body is destroyed. Note: this function is locked during callbacks.
    
    Parameters:
    
    fixture - the fixture to be removed
  - setTransform
```
public void setTransform(Vec2 position,
                         float angle)
```
    Set the position of the body's origin and rotation. This breaks any contacts and wakes the other bodies. Manipulating a body's transform may cause non-physical behavior. Note: contacts are updated on the next call to World.step().
    
    Parameters:
    
    position - the world position of the body's local origin
    
    angle - the world rotation in radians
  - getTransform
```
public Transform getTransform()
```
    Returns:
    
    the world transform of the body's origin.
  - getPosition
```
public Vec2 getPosition()
```
    Get the world body origin position. Do not modify.
    
    Returns:
    
    the world position of the body's origin.
  - getAngle
```
public float getAngle()
```
    Get the angle in radians.
    
    Returns:
    
    the current world rotation angle in radians.
  - getWorldCenter
```
public Vec2 getWorldCenter()
```
    Get the world position of the center of mass. Do not modify.
  - getLocalCenter
```
public Vec2 getLocalCenter()
```
    Get the local position of the center of mass. Do not modify.
  - setLinearVelocity
```
public void setLinearVelocity(Vec2 v)
```
    Set the linear velocity of the center of mass.
    
    Parameters:
    
    v - the new linear velocity of the center of mass.
  - getLinearVelocity
```
public Vec2 getLinearVelocity()
```
    Get the linear velocity of the center of mass. Do not modify, instead use setLinearVelocity(Vec2).
    
    Returns:
    
    the linear velocity of the center of mass.
  - setAngularVelocity
```
public void setAngularVelocity(float w)
```
    Set the angular velocity.
    
    Parameters:
    
    w - the new angular velocity in radians/second.
  - getAngularVelocity
```
public float getAngularVelocity()
```
    Get the angular velocity.
    
    Returns:
    
    the angular velocity in radians/second.
  - getGravityScale
```
public float getGravityScale()
```
    Returns:
    
    the gravity scale of the body
  - setGravityScale
```
public void setGravityScale(float gravityScale)
```
    Set the gravity scale of the body.
    
    Parameters:
    
    gravityScale - gravity scale
  - applyForce
```
public void applyForce(Vec2 force,
                       Vec2 point)
```
    Apply a force at a world point. If the force is not applied at the center of mass, it will generate a torque and affect the angular velocity. This wakes up the body.
    
    Parameters:
    
    force - the world force vector, usually in Newtons (N)
    
    point - the world position of the point of application
  - applyForceToCenter
```
public void applyForceToCenter(Vec2 force)
```
    Apply a force to the center of mass. This wakes up the body.
    
    Parameters:
    
    force - the world force vector, usually in Newtons (N)
  - applyTorque
```
public void applyTorque(float torque)
```
    Apply a torque. This affects the angular velocity without affecting the linear velocity of the center of mass. This wakes up the body.
    
    Parameters:
    
    torque - about the z-axis (out of the screen), usually in N-m
  - applyLinearImpulse
```
public void applyLinearImpulse(Vec2 impulse,
                               Vec2 point,
                               boolean wake)
```
    Apply an impulse at a point. This immediately modifies the velocity. It also modifies the angular velocity if the point of application is not at the center of mass. This wakes up the body if 'wake' is set to true. If the body is sleeping and 'wake' is false, then there is no effect.
    
    Parameters:
    
    impulse - the world impulse vector, usually in N-seconds or kg-m/s
    
    point - the world position of the point of application
    
    wake - also wake up the body
  - applyAngularImpulse
```
public void applyAngularImpulse(float impulse)
```
    Apply an angular impulse.
    
    Parameters:
    
    impulse - the angular impulse in units of kg*m*m/s
  - getMass
```
public float getMass()
```
    Returns:
    
    total mass of the body, usually in kilograms (kg)
  - getInertia
```
public float getInertia()
```
    Returns:
    
    central rotational inertia of the body, usually in kg-m^2
  - getMassData
```
public void getMassData(MassData data)
```
    Get the mass data of the body. The rotational inertia is relative to the center of mass. Fills in a struct containing the mass, inertia and center of the body.
  - setMassData
```
public void setMassData(MassData massData)
```
    Set the mass properties to override the mass properties of the fixtures. Note that this changes the center of mass position. Note that creating or destroying fixtures can also alter the mass. This function has no effect if the body isn't dynamic.
    
    Parameters:
    
    massData - the mass properties.
  - resetMassData
```
public void resetMassData()
```
    This resets the mass properties to the sum of the mass properties of the fixtures. This normally does not need to be called unless you called setMassData to override the mass and you later want to reset the mass.
  - getWorldPoint
```
public Vec2 getWorldPoint(Vec2 localPoint)
```
    Get the world coordinates of a point given the local coordinates.
    
    Parameters:
    
    localPoint - a point on the body measured relative the the body's origin.
    
    Returns:
    
    the same point expressed in world coordinates.
  - getWorldPointToOut
```
public void getWorldPointToOut(Vec2 localPoint,
                               Vec2 out)
```
  - getWorldVector
```
public Vec2 getWorldVector(Vec2 localVector)
```
    Get the world coordinates of a vector given the local coordinates.
    
    Parameters:
    
    localVector - a vector fixed in the body.
    
    Returns:
    
    the same vector expressed in world coordinates.
  - getWorldVectorToOut
```
public void getWorldVectorToOut(Vec2 localVector,
                                Vec2 out)
```
  - getWorldVectorToOutUnsafe
```
public void getWorldVectorToOutUnsafe(Vec2 localVector,
                                      Vec2 out)
```
  - getLocalPoint
```
public Vec2 getLocalPoint(Vec2 worldPoint)
```
    Gets a local point relative to the body's origin given a world point.
    
    Parameters:
    
    worldPoint - point in world coordinates.
    
    Returns:
    
    the corresponding local point relative to the body's origin.
  - getLocalPointToOut
```
public void getLocalPointToOut(Vec2 worldPoint,
                               Vec2 out)
```
  - getLocalVector
```
public Vec2 getLocalVector(Vec2 worldVector)
```
    Gets a local vector given a world vector.
    
    Parameters:
    
    worldVector - vector in world coordinates.
    
    Returns:
    
    the corresponding local vector.
  - getLocalVectorToOut
```
public void getLocalVectorToOut(Vec2 worldVector,
                                Vec2 out)
```
  - getLocalVectorToOutUnsafe
```
public void getLocalVectorToOutUnsafe(Vec2 worldVector,
                                      Vec2 out)
```
  - getLinearVelocityFromWorldPoint
```
public Vec2 getLinearVelocityFromWorldPoint(Vec2 worldPoint)
```
    Get the world linear velocity of a world point attached to this body.
    
    Parameters:
    
    worldPoint - point in world coordinates.
    
    Returns:
    
    the world velocity of a point.
  - getLinearVelocityFromWorldPointToOut
```
public void getLinearVelocityFromWorldPointToOut(Vec2 worldPoint,
                                                 Vec2 out)
```
  - getLinearVelocityFromLocalPoint
```
public Vec2 getLinearVelocityFromLocalPoint(Vec2 localPoint)
```
    Get the world velocity of a local point.
    
    Parameters:
    
    localPoint - point in local coordinates.
    
    Returns:
    
    the world velocity of a point.
  - getLinearVelocityFromLocalPointToOut
```
public void getLinearVelocityFromLocalPointToOut(Vec2 localPoint,
                                                 Vec2 out)
```
  - getLinearDamping
```
public float getLinearDamping()
```
    Get the linear damping of the body.
  - setLinearDamping
```
public void setLinearDamping(float linearDamping)
```
    Set the linear damping of the body.
  - getAngularDamping
```
public float getAngularDamping()
```
    Get the angular damping of the body.
  - setAngularDamping
```
public void setAngularDamping(float angularDamping)
```
    Set the angular damping of the body.
  - getSleepTime
```
public float getSleepTime()
```
  - getType
```
public BodyType getType()
```
    Returns:
    
    body type
  - setType
```
public void setType(BodyType type)
```
    Set the type of this body. This may alter the mass and velocity.
    
    Parameters:
    
    type - body type
  - isBullet
```
public boolean isBullet()
```
    Returns:
    
    is this body treated like a bullet for continuous collision detection?
  - setBullet
```
public void setBullet(boolean flag)
```
    Should this body be treated like a bullet for continuous collision detection?
  - setSleepingAllowed
```
public void setSleepingAllowed(boolean flag)
```
    You can disable sleeping on this body. If you disable sleeping, the body will be woken.
    
    Parameters:
    
    flag - sleep flag
  - isSleepingAllowed
```
public boolean isSleepingAllowed()
```
    Returns:
    
    whether this body is allowed to sleep
  - setAwake
```
public void setAwake(boolean flag)
```
    Set the sleep state of the body. A sleeping body has very low CPU cost.
    
    Parameters:
    
    flag - set to true to put body to sleep, false to wake it
  - isAwake
```
public boolean isAwake()
```
    Get the sleeping state of this body.
    
    Returns:
    
    true if the body is awake.
  - setActive
```
public void setActive(boolean flag)
```
    Set the active state of the body. An inactive body is not simulated and cannot be collided with or woken up. If you pass a flag of true, all fixtures will be added to the broad-phase. If you pass a flag of false, all fixtures will be removed from the broad-phase and all contacts will be destroyed. Fixtures and joints are otherwise unaffected. You may continue to create/destroy fixtures and joints on inactive bodies. Fixtures on an inactive body are implicitly inactive and will not participate in collisions, ray-casts, or queries. Joints connected to an inactive body are implicitly inactive. An inactive body is still owned by a World object and remains in the body list.
    
    Parameters:
    
    flag - active flag
  - isActive
```
public boolean isActive()
```
    Returns:
    
    the active state of the body
  - setFixedRotation
```
public void setFixedRotation(boolean flag)
```
    Set this body to have fixed rotation. This causes the mass to be reset.
    
    Parameters:
    
    flag - fixed rotation flag
  - isFixedRotation
```
public boolean isFixedRotation()
```
    Returns:
    
    does this body have fixed rotation
  - getJointList
```
public JointEdge getJointList()
```
    Get the list of all joints attached to this body.
  - getContactList
```
public ContactEdge getContactList()
```
    Get the list of all contacts attached to this body. Note: this list changes during the time step and you may miss some collisions if you don't use ContactListener.
  - getUserData
```
public Object getUserData()
```
    Get the user data pointer that was provided in the body definition.
  - setUserData
```
public void setUserData(Object data)
```
    Set the user data. Use this to store your application specific data.
  - getWorld
```
public World getWorld()
```
    Get the parent world of this body.
  - shouldCollide
```
public boolean shouldCollide(Body other)
```
    This is used to prevent connected bodies from colliding. It may lie, depending on the collideConnected flag.
    
    Parameters:
    
    other - other body
    
    Returns:
    
    if they should collide

Class Body

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

e_islandFlag

e_awakeFlag

e_autoSleepFlag

e_bulletFlag

e_fixedRotationFlag

e_activeFlag

e_toiFlag

m_jointList

m_contactList

m_flags

m_islandIndex

m_xf

m_xf0

m_sweep

m_linearVelocity

m_angularVelocity

m_force

m_torque

m_mass

m_invMass

m_invI

Method Detail

getFixtures

createFixture

createFixture

destroyFixture

setTransform

getTransform

getPosition

getAngle

getWorldCenter

getLocalCenter

setLinearVelocity

getLinearVelocity

setAngularVelocity

getAngularVelocity

getGravityScale

setGravityScale

applyForce

applyForceToCenter

applyTorque

applyLinearImpulse

applyAngularImpulse

getMass

getInertia

getMassData

setMassData

resetMassData

getWorldPoint

getWorldPointToOut

getWorldVector

getWorldVectorToOut

getWorldVectorToOutUnsafe

getLocalPoint

getLocalPointToOut

getLocalVector

getLocalVectorToOut

getLocalVectorToOutUnsafe

getLinearVelocityFromWorldPoint

getLinearVelocityFromWorldPointToOut

getLinearVelocityFromLocalPoint

getLinearVelocityFromLocalPointToOut

getLinearDamping

setLinearDamping

getAngularDamping

setAngularDamping

getSleepTime

getType

setType

isBullet

setBullet

setSleepingAllowed

isSleepingAllowed

setAwake

isAwake