PhysicsComponent (fxgl 0.4.2 API)

java.lang.Object
- com.almasb.fxgl.entity.Module
- - com.almasb.fxgl.entity.Component
  - - com.almasb.fxgl.physics.PhysicsComponent

```
public class PhysicsComponent
extends Component
```
Adds physics properties to an entity.

Author:

Almas Baimagambetov (AlmasB) (almaslvl@gmail.com)

Constructor Summary

Constructors
Constructor and Description

PhysicsComponent()

Constructors
Constructor and Description
`PhysicsComponent()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`applyAngularImpulse(float impulse)` Apply an angular impulse.
`void`	`applyBodyAngularImpulse(float impulse)` Apply an angular impulse.
`void`	`applyBodyForce(Vec2 force, Vec2 point)` Apply a force at a world point.
`void`	`applyBodyForceToCenter(Vec2 force)` Apply a force to the center of mass.
`void`	`applyBodyLinearImpulse(Vec2 impulse, Vec2 point, boolean wake)` Apply an impulse at a point.
`void`	`applyBodyTorque(float torque)` Apply a torque.
`void`	`applyForce(javafx.geometry.Point2D force, javafx.geometry.Point2D point)` Apply a force at a world point.
`void`	`applyForceToCenter(javafx.geometry.Point2D force)` Apply a force to the center of mass.
`void`	`applyLinearImpulse(javafx.geometry.Point2D impulse, javafx.geometry.Point2D point, boolean wake)` Apply an impulse at a point.
`void`	`applyTorque(float torque)` Apply a torque.
`Body`	`getBody()`
`javafx.geometry.Point2D`	`getLinearVelocity()`
`double`	`getVelocityX()`
`double`	`getVelocityY()`
`boolean`	`isGenerateGroundSensor()`
`boolean`	`isMoving()`
`boolean`	`isMovingX()`
`boolean`	`isMovingY()`
`boolean`	`isOnGround()` Note: only works when `setGenerateGroundSensor(boolean)` was called with value true before attaching entity to game world.
`boolean`	`isRaycastIgnored()`
`void`	`setAngularVelocity(double velocity)` Set velocity (angle in deg) at which the entity will rotate per tick.
`void`	`setBodyDef(BodyDef def)` Set custom body definition to describe a generated body for this physics entity.
`void`	`setBodyLinearVelocity(Vec2 vector)` Set linear velocity for a physics entity.
`void`	`setBodyType(BodyType type)` A convenience method to avoid setting body definition if only a change of body type is required.
`void`	`setFixtureDef(FixtureDef def)` Set custom fixture definition to describe a generated fixture for this physics entity.
`void`	`setGenerateGroundSensor(boolean generate)` Force this entity to create a ground sensor, so that `isOnGround()` can be used.
`void`	`setLinearVelocity(double x, double y)` Set linear velocity for a physics entity.
`void`	`setLinearVelocity(javafx.geometry.Point2D vector)` Set linear velocity for a physics entity.
`void`	`setOnPhysicsInitialized(Runnable code)` Set a callback to run when this entity has been added to physics world.
`void`	`setRaycastIgnored(boolean b)` Set true to make raycast ignore this entity.
`void`	`setVelocityX(double x)`
`void`	`setVelocityY(double y)`

Methods inherited from class com.almasb.fxgl.entity.Module
getEntity, onAdded, onRemoved

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

- Constructor Detail
  - PhysicsComponent
```
public PhysicsComponent()
```
- Method Detail
  - isOnGround
```
public boolean isOnGround()
```
    Note: only works when setGenerateGroundSensor(boolean) was called with value true before attaching entity to game world.
    
    Returns:
    
    true if entity is standing on top of another entity with physics component
  - getBody
```
public final Body getBody()
```
  - setOnPhysicsInitialized
```
public void setOnPhysicsInitialized(Runnable code)
```
    Set a callback to run when this entity has been added to physics world.
    
    Parameters:
    
    code - the code to run
  - setGenerateGroundSensor
```
public void setGenerateGroundSensor(boolean generate)
```
    Force this entity to create a ground sensor, so that isOnGround() can be used.
    
    Parameters:
    
    generate - flag
    
    Default Value:
    
    false
  - isGenerateGroundSensor
```
public boolean isGenerateGroundSensor()
```
    Returns:
    
    does this entity have a ground sensor
  - setFixtureDef
```
public void setFixtureDef(FixtureDef def)
```
    Set custom fixture definition to describe a generated fixture for this physics entity.
    
    Parameters:
    
    def - fixture definition
  - setBodyDef
```
public void setBodyDef(BodyDef def)
```
    Set custom body definition to describe a generated body for this physics entity.
    
    Parameters:
    
    def - body definition
  - setBodyType
```
public void setBodyType(BodyType type)
```
    A convenience method to avoid setting body definition if only a change of body type is required.
    
    Parameters:
    
    type - body type
  - isMovingX
```
public boolean isMovingX()
```
    Returns:
    
    true if moving in X axis
  - isMovingY
```
public boolean isMovingY()
```
    Returns:
    
    true if moving in Y axis
  - isMoving
```
public boolean isMoving()
```
    Returns:
    
    true if moving in X or Y axis
  - setLinearVelocity
```
public void setLinearVelocity(javafx.geometry.Point2D vector)
```
    Set linear velocity for a physics entity.
    Use this method to move a physics entity. Please note that the vector x and y are in pixels.
    
    Parameters:
    
    vector - x and y in pixels
  - setLinearVelocity
```
public void setLinearVelocity(double x,
                              double y)
```
    Set linear velocity for a physics entity.
    Use this method to move a physics entity. Please note that x and y are in pixels.
    
    Parameters:
    
    x - and y in pixels
  - setVelocityX
```
public void setVelocityX(double x)
```
  - setVelocityY
```
public void setVelocityY(double y)
```
  - getVelocityX
```
public double getVelocityX()
```
  - getVelocityY
```
public double getVelocityY()
```
  - setBodyLinearVelocity
```
public void setBodyLinearVelocity(Vec2 vector)
```
    Set linear velocity for a physics entity.
    Similar to setLinearVelocity(Point2D) but x and y of the argument are in meters.
    
    Parameters:
    
    vector - x and y in meters
  - getLinearVelocity
```
public javafx.geometry.Point2D getLinearVelocity()
```
    Returns:
    
    linear velocity in pixels
  - setAngularVelocity
```
public void setAngularVelocity(double velocity)
```
    Set velocity (angle in deg) at which the entity will rotate per tick.
    
    Parameters:
    
    velocity - value in ~ degrees per tick
  - applyLinearImpulse
```
public void applyLinearImpulse(javafx.geometry.Point2D impulse,
                               javafx.geometry.Point2D 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.
    
    Parameters:
    
    impulse - the world impulse vector (in pixel/sec)
    
    point - the world position of the point of application (in pixel)
    
    wake - if this impulse should wake up the body
  - applyBodyLinearImpulse
```
public void applyBodyLinearImpulse(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.
    
    Parameters:
    
    impulse - the world impulse vector (in meter/sec)
    
    point - the world position of the point of application (in meter)
    
    wake - if this impulse should wake up the body
  - applyForce
```
public void applyForce(javafx.geometry.Point2D force,
                       javafx.geometry.Point2D 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 (in pixel/sec)
    
    point - the world position of the point of application (in pixel)
  - applyBodyForce
```
public void applyBodyForce(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 (in meter/sec)
    
    point - the world position of the point of application (in meter)
  - applyForceToCenter
```
public void applyForceToCenter(javafx.geometry.Point2D force)
```
    Apply a force to the center of mass. This wakes up the body.
    
    Parameters:
    
    force - the world force vector (in pixel/sec)
  - applyBodyForceToCenter
```
public void applyBodyForceToCenter(Vec2 force)
```
    Apply a force to the center of mass. This wakes up the body.
    
    Parameters:
    
    force - the world force vector (in meter/sec)
  - applyAngularImpulse
```
public void applyAngularImpulse(float impulse)
```
    Apply an angular impulse.
    
    Parameters:
    
    impulse - the angular impulse (in pixel/sec)
  - applyBodyAngularImpulse
```
public void applyBodyAngularImpulse(float impulse)
```
    Apply an angular impulse.
    
    Parameters:
    
    impulse - the angular impulse (in meter/sec)
  - 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 - the force (in pixel)
  - applyBodyTorque
```
public void applyBodyTorque(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 - the force (in meter)
  - setRaycastIgnored
```
public void setRaycastIgnored(boolean b)
```
    Set true to make raycast ignore this entity.
    
    Parameters:
    
    b - raycast flag
  - isRaycastIgnored
```
public boolean isRaycastIgnored()
```
    Returns:
    
    true if raycast should ignore this entity, false otherwise

Class PhysicsComponent

Constructor Summary

Method Summary

Methods inherited from class com.almasb.fxgl.entity.Module

Methods inherited from class java.lang.Object

Constructor Detail

PhysicsComponent

Method Detail

isOnGround

getBody

setOnPhysicsInitialized

setGenerateGroundSensor

isGenerateGroundSensor

setFixtureDef

setBodyDef

setBodyType

isMovingX

isMovingY

isMoving

setLinearVelocity

setLinearVelocity

setVelocityX

setVelocityY

getVelocityX

getVelocityY

setBodyLinearVelocity

getLinearVelocity

setAngularVelocity

applyLinearImpulse

applyBodyLinearImpulse

applyForce

applyBodyForce

applyForceToCenter

applyBodyForceToCenter

applyAngularImpulse

applyBodyAngularImpulse

applyTorque

applyBodyTorque

setRaycastIgnored

isRaycastIgnored