# Class Body

java.lang.Object
com.codename1.gaming.physics.box2d.dynamics.Body

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

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final int`
  `e_activeFlag`
  `static final int`
  `e_autoSleepFlag`
  `static final int`
  `e_awakeFlag`
  `static final int`
  `e_bulletFlag`
  `static final int`
  `e_fixedRotationFlag`
  `static final int`
  `e_islandFlag`
  `static final int`
  `e_toiFlag`
  `float`
  `m_angularDamping`
  `float`
  `m_angularVelocity`
  `ContactEdge`
  `m_contactList`
  `int`
  `m_fixtureCount`
  `Fixture`
  `m_fixtureList`
  `int`
  `m_flags`
  `final Vec2`
  `m_force`
  `float`
  `m_gravityScale`
  `float`
  `m_I`
  `float`
  `m_invI`
  `float`
  `m_invMass`
  `int`
  `m_islandIndex`
  `JointEdge`
  `m_jointList`
  `float`
  `m_linearDamping`
  `final Vec2`
  `m_linearVelocity`
  `float`
  `m_mass`
  `Body`
  `m_next`
  `Body`
  `m_prev`
  `float`
  `m_sleepTime`
  `final Sweep`
  `m_sweep`
  The swept motion for CCD
  `float`
  `m_torque`
  `BodyType`
  `m_type`
  `Object`
  `m_userData`
  `World`
  `m_world`
  `final Transform`
  `m_xf`
  The body origin transform.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `Body(BodyDef bd, World world)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected final void`
  `advance(float t)`
  `void`
  `applyAngularImpulse(float impulse)`
  Apply an angular impulse.
  `final void`
  `applyForce(Vec2 force, Vec2 point)`
  Apply a force at a world point.
  `final void`
  `applyForceToCenter(Vec2 force)`
  Apply a force to the center of mass.
  `final void`
  `applyLinearImpulse(Vec2 impulse, Vec2 point)`
  Apply an impulse at a point.
  `final void`
  `applyTorque(float torque)`
  Apply a torque.
  `final Fixture`
  `createFixture(Shape shape, float density)`
  Creates a fixture from a shape and attach it to this body.
  `final Fixture`
  `createFixture(FixtureDef def)`
  Creates a fixture and attach it to this body.
  `final void`
  `destroyFixture(Fixture fixture)`
  Destroy a fixture.
  `final float`
  `getAngle()`
  Get the angle in radians.
  `final float`
  `getAngularDamping()`
  Get the angular damping of the body.
  `final float`
  `getAngularVelocity()`
  Get the angular velocity.
  `final ContactEdge`
  `getContactList()`
  Get the list of all contacts attached to this body.
  `final Fixture`
  `getFixtureList()`
  Get the list of all fixtures attached to this body.
  `float`
  `getGravityScale()`
  Get the gravity scale of the body.
  `final float`
  `getInertia()`
  Get the central rotational inertia of the body.
  `final JointEdge`
  `getJointList()`
  Get the list of all joints attached to this body.
  `final float`
  `getLinearDamping()`
  Get the linear damping of the body.
  `final Vec2`
  `getLinearVelocity()`
  Get the linear velocity of the center of mass.
  `final Vec2`
  `getLinearVelocityFromLocalPoint(Vec2 localPoint)`
  Get the world velocity of a local point.
  `final void`
  `getLinearVelocityFromLocalPointToOut(Vec2 localPoint, Vec2 out)`
  `final Vec2`
  `getLinearVelocityFromWorldPoint(Vec2 worldPoint)`
  Get the world linear velocity of a world point attached to this body.
  `final void`
  `getLinearVelocityFromWorldPointToOut(Vec2 worldPoint, Vec2 out)`
  `final Vec2`
  `getLocalCenter()`
  Get the local position of the center of mass.
  `final Vec2`
  `getLocalPoint(Vec2 worldPoint)`
  Gets a local point relative to the body's origin given a world point.
  `final void`
  `getLocalPointToOut(Vec2 worldPoint, Vec2 out)`
  `final Vec2`
  `getLocalVector(Vec2 worldVector)`
  Gets a local vector given a world vector.
  `final void`
  `getLocalVectorToOut(Vec2 worldVector, Vec2 out)`
  `final void`
  `getLocalVectorToOutUnsafe(Vec2 worldVector, Vec2 out)`
  `final float`
  `getMass()`
  Get the total mass of the body.
  `final void`
  `getMassData(MassData data)`
  Get the mass data of the body.
  `final Body`
  `getNext()`
  Get the next body in the world's body list.
  `final Vec2`
  `getPosition()`
  Get the world body origin position.
  `final Transform`
  `getTransform()`
  Get the body transform for the body's origin.
  `BodyType`
  `getType()`
  `final Object`
  `getUserData()`
  Get the user data pointer that was provided in the body definition.
  `final World`
  `getWorld()`
  Get the parent world of this body.
  `final Vec2`
  `getWorldCenter()`
  Get the world position of the center of mass.
  `final Vec2`
  `getWorldPoint(Vec2 localPoint)`
  Get the world coordinates of a point given the local coordinates.
  `final void`
  `getWorldPointToOut(Vec2 localPoint, Vec2 out)`
  `final Vec2`
  `getWorldVector(Vec2 localVector)`
  Get the world coordinates of a vector given the local coordinates.
  `final void`
  `getWorldVectorToOut(Vec2 localVector, Vec2 out)`
  `final void`
  `getWorldVectorToOutUnsafe(Vec2 localVector, Vec2 out)`
  `boolean`
  `isActive()`
  Get the active state of the body.
  `boolean`
  `isAwake()`
  Get the sleeping state of this body.
  `final boolean`
  `isBullet()`
  Is this body treated like a bullet for continuous collision detection?
  `boolean`
  `isFixedRotation()`
  Does this body have fixed rotation?
  `boolean`
  `isSleepingAllowed()`
  Is this body allowed to sleep
  `final 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.
  `final void`
  `setAngularDamping(float angularDamping)`
  Set the angular damping of the body.
  `final void`
  `setAngularVelocity(float w)`
  Set the angular velocity.
  `void`
  `setAwake(boolean flag)`
  Set the sleep state of the body.
  `final 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.
  `final void`
  `setLinearDamping(float linearDamping)`
  Set the linear damping of the body.
  `final void`
  `setLinearVelocity(Vec2 v)`
  Set the linear velocity of the center of mass.
  `final 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.
  `final 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.
  `final void`
  `setUserData(Object data)`
  Set the user data.
  `boolean`
  `shouldCollide(Body other)`
  This is used to prevent connected bodies from colliding.
  `protected final void`
  `synchronizeFixtures()`
  `final void`
  `synchronizeTransform()`

  ### Methods inherited from class Object

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

- ## Field Details

  - ### 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_type

    public BodyType m_type

  - ### m_flags

    public int m_flags

  - ### m_islandIndex

    public int m_islandIndex

  - ### m_xf

    public final Transform m_xf
    The body origin transform.

  - ### 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_world

    public World m_world

  - ### m_prev

    public Body m_prev

  - ### m_next

    public Body m_next

  - ### m_fixtureList

    public Fixture m_fixtureList

  - ### m_fixtureCount

    public int m_fixtureCount

  - ### m_jointList

    public JointEdge m_jointList

  - ### m_contactList

    public ContactEdge m_contactList

  - ### m_mass

    public float m_mass

  - ### m_invMass

    public float m_invMass

  - ### m_I

    public float m_I

  - ### m_invI

    public float m_invI

  - ### m_linearDamping

    public float m_linearDamping

  - ### m_angularDamping

    public float m_angularDamping

  - ### m_gravityScale

    public float m_gravityScale

  - ### m_sleepTime

    public float m_sleepTime

  - ### m_userData

    public Object m_userData

- ## Constructor Details

  - ### Body

    public Body(BodyDef bd, World world)

- ## Method Details

  - ### createFixture

    public final 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.
    Parameters:
      `def` - the fixture definition.

  - ### createFixture

    public final 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.
    Parameters:
      `shape` - the shape to be cloned.
      `density` - the shape density (set to zero for static bodies).

  - ### destroyFixture

    public final 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.
    Parameters:
      `fixture` - the fixture to be removed.

  - ### setTransform

    public final 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.
    Parameters:
      `position` - the world position of the body's local origin.
      `angle` - the world rotation in radians.

  - ### getTransform

    public final Transform getTransform()
    Get the body transform for the body's origin.
    Returns:
      the world transform of the body's origin.

  - ### getPosition

    public final Vec2 getPosition()
    Get the world body origin position. Do not modify.
    Returns:
      the world position of the body's origin.

  - ### getAngle

    public final float getAngle()
    Get the angle in radians.
    Returns:
      the current world rotation angle in radians.

  - ### getWorldCenter

    public final Vec2 getWorldCenter()
    Get the world position of the center of mass. Do not modify.

  - ### getLocalCenter

    public final Vec2 getLocalCenter()
    Get the local position of the center of mass. Do not modify.

  - ### setLinearVelocity

    public final 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 final 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 final void setAngularVelocity(float w)
    Set the angular velocity.
    Parameters:
      `omega` - the new angular velocity in radians/second.

  - ### getAngularVelocity

    public final float getAngularVelocity()
    Get the angular velocity.
    Returns:
      the angular velocity in radians/second.

  - ### getGravityScale

    public float getGravityScale()
    Get the gravity scale of the body.
    Returns:

  - ### setGravityScale

    public void setGravityScale(float gravityScale)
    Set the gravity scale of the body.
    Parameters:
      `gravityScale` -

  - ### applyForce

    public final 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 final 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 final 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 final void applyLinearImpulse(Vec2 impulse, Vec2 point)
    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.
    Parameters:
      `impulse` - the world impulse vector, usually in N-seconds or kg-m/s.
      `point` - the world position of the point of application.

  - ### applyAngularImpulse

    public void applyAngularImpulse(float impulse)
    Apply an angular impulse.
    Parameters:
      `impulse` - the angular impulse in units of kgmm/s

  - ### getMass

    public final float getMass()
    Get the total mass of the body.
    Returns:
      the mass, usually in kilograms (kg).

  - ### getInertia

    public final float getInertia()
    Get the central rotational inertia of the body.
    Returns:
      the rotational inertia, usually in kg-m^2.

  - ### getMassData

    public final void getMassData(MassData data)
    Get the mass data of the body. The rotational inertia is relative to the center of mass.

  - ### setMassData

    public final 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 final 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 final 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 final void getWorldPointToOut(Vec2 localPoint, Vec2 out)

  - ### getWorldVector

    public final 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 final void getWorldVectorToOut(Vec2 localVector, Vec2 out)

  - ### getWorldVectorToOutUnsafe

    public final void getWorldVectorToOutUnsafe(Vec2 localVector, Vec2 out)

  - ### getLocalPoint

    public final Vec2 getLocalPoint(Vec2 worldPoint)
    Gets a local point relative to the body's origin given a world point.
    Parameters:
      `a` - point in world coordinates.
    Returns:
      the corresponding local point relative to the body's origin.

  - ### getLocalPointToOut

    public final void getLocalPointToOut(Vec2 worldPoint, Vec2 out)

  - ### getLocalVector

    public final Vec2 getLocalVector(Vec2 worldVector)
    Gets a local vector given a world vector.
    Parameters:
      `a` - vector in world coordinates.
    Returns:
      the corresponding local vector.

  - ### getLocalVectorToOut

    public final void getLocalVectorToOut(Vec2 worldVector, Vec2 out)

  - ### getLocalVectorToOutUnsafe

    public final void getLocalVectorToOutUnsafe(Vec2 worldVector, Vec2 out)

  - ### getLinearVelocityFromWorldPoint

    public final Vec2 getLinearVelocityFromWorldPoint(Vec2 worldPoint)
    Get the world linear velocity of a world point attached to this body.
    Parameters:
      `a` - point in world coordinates.
    Returns:
      the world velocity of a point.

  - ### getLinearVelocityFromWorldPointToOut

    public final void getLinearVelocityFromWorldPointToOut(Vec2 worldPoint, Vec2 out)

  - ### getLinearVelocityFromLocalPoint

    public final Vec2 getLinearVelocityFromLocalPoint(Vec2 localPoint)
    Get the world velocity of a local point.
    Parameters:
      `a` - point in local coordinates.
    Returns:
      the world velocity of a point.

  - ### getLinearVelocityFromLocalPointToOut

    public final void getLinearVelocityFromLocalPointToOut(Vec2 localPoint, Vec2 out)

  - ### getLinearDamping

    public final float getLinearDamping()
    Get the linear damping of the body.

  - ### setLinearDamping

    public final void setLinearDamping(float linearDamping)
    Set the linear damping of the body.

  - ### getAngularDamping

    public final float getAngularDamping()
    Get the angular damping of the body.

  - ### setAngularDamping

    public final void setAngularDamping(float angularDamping)
    Set the angular damping of the body.

  - ### getType

    public BodyType getType()

  - ### setType

    public void setType(BodyType type)
    Set the type of this body. This may alter the mass and velocity.
    Parameters:
      `type` -

  - ### isBullet

    public final boolean isBullet()
    Is this body treated like a bullet for continuous collision detection?

  - ### setBullet

    public final 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` -

  - ### isSleepingAllowed

    public boolean isSleepingAllowed()
    Is this body allowed to sleep
    Returns:

  - ### 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.
      `flag` -

  - ### isAwake

    public boolean isAwake()
    Get the sleeping state of this body.
    Returns:
      true if the body is sleeping.

  - ### 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` -

  - ### isActive

    public boolean isActive()
    Get the active state of the body.
    Returns:

  - ### setFixedRotation

    public void setFixedRotation(boolean flag)
    Set this body to have fixed rotation. This causes the mass to be reset.
    Parameters:
      `flag` -

  - ### isFixedRotation

    public boolean isFixedRotation()
    Does this body have fixed rotation?
    Returns:

  - ### getFixtureList

    public final Fixture getFixtureList()
    Get the list of all fixtures attached to this body.

  - ### getJointList

    public final JointEdge getJointList()
    Get the list of all joints attached to this body.

  - ### getContactList

    public final ContactEdge getContactList()
    Get the list of all contacts attached to this body.

  - ### getNext

    public final Body getNext()
    Get the next body in the world's body list.

  - ### getUserData

    public final Object getUserData()
    Get the user data pointer that was provided in the body definition.

  - ### setUserData

    public final void setUserData(Object data)
    Set the user data. Use this to store your application specific data.

  - ### getWorld

    public final World getWorld()
    Get the parent world of this body.

  - ### synchronizeFixtures

    protected final void synchronizeFixtures()

  - ### synchronizeTransform

    public final void synchronizeTransform()

  - ### 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` -
    Returns:

  - ### advance

    protected final void advance(float t)