PhysicsSpace (jMonkeyEngine 3.1 jme3-bullet Javadoc)

java.lang.Object
- com.jme3.bullet.PhysicsSpace

```
public class PhysicsSpace
extends java.lang.Object
```
PhysicsSpace - The central jbullet-jme physics space

Author:

normenhansen

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class PhysicsSpace.BroadphaseType
interface with Broadphase types

Nested Classes
Modifier and Type	Class and Description
`static class`	`PhysicsSpace.BroadphaseType` interface with Broadphase types

Field Summary

Fields
Modifier and Type Field and Description

static int AXIS_X

static int AXIS_Y

static int AXIS_Z

Fields
Modifier and Type	Field and Description
`static int`	`AXIS_X`
`static int`	`AXIS_Y`
`static int`	`AXIS_Z`

Constructor Summary

Constructors
Constructor and Description
`PhysicsSpace()`
`PhysicsSpace(PhysicsSpace.BroadphaseType broadphaseType)`
`PhysicsSpace(com.jme3.math.Vector3f worldMin, com.jme3.math.Vector3f worldMax)`
`PhysicsSpace(com.jme3.math.Vector3f worldMin, com.jme3.math.Vector3f worldMax, PhysicsSpace.BroadphaseType broadphaseType)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`add(java.lang.Object obj)` adds an object to the physics space
`void`	`addAll(com.jme3.scene.Spatial spatial)` adds all physics controls and joints in the given spatial node to the physics space (e.g.
`void`	`addCollisionGroupListener(PhysicsCollisionGroupListener listener, int collisionGroup)` Adds a listener for a specific collision group, such a listener can disable collisions when they happen. There can be only one listener per collision group.
`void`	`addCollisionListener(PhysicsCollisionListener listener)` Adds a CollisionListener that will be informed about collision events
`void`	`addCollisionObject(PhysicsCollisionObject obj)`
`void`	`addTickListener(PhysicsTickListener listener)` Adds the specified listener to the physics tick listeners.
`void`	`create()` Has to be called from the (designated) physics thread
`void`	`destroy()` destroys the current PhysicsSpace so that a new one can be created
`void`	`distributeEvents()`
`<V> java.util.concurrent.Future<V>`	`enqueue(java.util.concurrent.Callable<V> callable)` calls the callable on the next physics tick (ensuring e.g.
`static <V> java.util.concurrent.Future<V>`	`enqueueOnThisThread(java.util.concurrent.Callable<V> callable)`
`protected void`	`finalize()`
`float`	`getAccuracy()` get the current accuracy of the physics computation
`PhysicsSpace.BroadphaseType`	`getBroadphaseType()`
`java.util.Collection<PhysicsCharacter>`	`getCharacterList()`
`java.util.Collection<PhysicsGhostObject>`	`getGhostObjectList()`
`com.jme3.math.Vector3f`	`getGravity(com.jme3.math.Vector3f gravity)`
`java.util.Collection<PhysicsJoint>`	`getJointList()`
`static PhysicsSpace`	`getPhysicsSpace()` Get the current PhysicsSpace running on this thread For parallel physics, this can also be called from the OpenGL thread to receive the PhysicsSpace
`int`	`GetRayTestFlags()` Gets m_flags for raytest, see https://code.google.com/p/bullet/source/browse/trunk/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h for possible options.
`java.util.Collection<PhysicsRigidBody>`	`getRigidBodyList()`
`int`	`getSolverNumIterations()` Get the number of iterations used by the contact solver.
`long`	`getSpaceId()` // * used internally //
`java.util.Collection<PhysicsVehicle>`	`getVehicleList()`
`com.jme3.math.Vector3f`	`getWorldMax()`
`com.jme3.math.Vector3f`	`getWorldMin()`
`static void`	`initNativePhysics()`
`void`	`rayTest_native(com.jme3.math.Vector3f from, com.jme3.math.Vector3f to, long physicsSpaceId, java.util.List<PhysicsRayTestResult> results, int flags)`
`java.util.List`	`rayTest(com.jme3.math.Vector3f from, com.jme3.math.Vector3f to)` Performs a ray collision test and returns the results as a list of PhysicsRayTestResults
`java.util.List<PhysicsRayTestResult>`	`rayTest(com.jme3.math.Vector3f from, com.jme3.math.Vector3f to, java.util.List<PhysicsRayTestResult> results)` Performs a ray collision test and returns the results as a list of PhysicsRayTestResults
`void`	`remove(java.lang.Object obj)` removes an object from the physics space
`void`	`removeAll(com.jme3.scene.Spatial spatial)` Removes all physics controls and joints in the given spatial from the physics space (e.g.
`void`	`removeCollisionGroupListener(int collisionGroup)`
`void`	`removeCollisionListener(PhysicsCollisionListener listener)` Removes a CollisionListener from the list
`void`	`removeCollisionObject(PhysicsCollisionObject obj)`
`void`	`removeTickListener(PhysicsTickListener listener)`
`void`	`setAccuracy(float accuracy)` sets the accuracy of the physics computation, default=1/60s
`void`	`setBroadphaseType(PhysicsSpace.BroadphaseType broadphaseType)`
`void`	`setGravity(com.jme3.math.Vector3f gravity)` Sets the gravity of the PhysicsSpace, set before adding physics objects!
`static void`	`setLocalThreadPhysicsSpace(PhysicsSpace space)` Used internally
`void`	`setMaxSubSteps(int steps)` Sets the maximum amount of extra steps that will be used to step the physics when the fps is below the physics fps.
`void`	`SetRayTestFlags(int flags)` Sets m_flags for raytest, see https://code.google.com/p/bullet/source/browse/trunk/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h for possible options.
`void`	`setSolverNumIterations(int numIterations)` Set the number of iterations used by the contact solver.
`void`	`setWorldMax(com.jme3.math.Vector3f worldMax)` only applies for AXIS_SWEEP broadphase
`void`	`setWorldMin(com.jme3.math.Vector3f worldMin)` only applies for AXIS_SWEEP broadphase
`void`	`sweepTest_native(long shape, com.jme3.math.Transform from, com.jme3.math.Transform to, long physicsSpaceId, java.util.List<PhysicsSweepTestResult> results, float allowedCcdPenetration)`
`java.util.List<PhysicsSweepTestResult>`	`sweepTest(CollisionShape shape, com.jme3.math.Transform start, com.jme3.math.Transform end)` Performs a sweep collision test and returns the results as a list of PhysicsSweepTestResults You have to use different Transforms for start and end (at least distance > 0.4f).
`java.util.List<PhysicsSweepTestResult>`	`sweepTest(CollisionShape shape, com.jme3.math.Transform start, com.jme3.math.Transform end, java.util.List<PhysicsSweepTestResult> results)`
`java.util.List<PhysicsSweepTestResult>`	`sweepTest(CollisionShape shape, com.jme3.math.Transform start, com.jme3.math.Transform end, java.util.List<PhysicsSweepTestResult> results, float allowedCcdPenetration)` Performs a sweep collision test and returns the results as a list of PhysicsSweepTestResults You have to use different Transforms for start and end (at least distance > allowedCcdPenetration).
`void`	`update(float time)` updates the physics space
`void`	`update(float time, int maxSteps)` updates the physics space, uses maxSteps

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

- Field Detail
  - AXIS_X
```
public static final int AXIS_X
```
    See Also:
    Constant Field Values
  - AXIS_Y
```
public static final int AXIS_Y
```
    See Also:
    Constant Field Values
  - AXIS_Z
```
public static final int AXIS_Z
```
    See Also:
    Constant Field Values
- Constructor Detail
  - PhysicsSpace
```
public PhysicsSpace()
```
  - PhysicsSpace
```
public PhysicsSpace(PhysicsSpace.BroadphaseType broadphaseType)
```
  - PhysicsSpace
```
public PhysicsSpace(com.jme3.math.Vector3f worldMin,
            com.jme3.math.Vector3f worldMax)
```
  - PhysicsSpace
```
public PhysicsSpace(com.jme3.math.Vector3f worldMin,
            com.jme3.math.Vector3f worldMax,
            PhysicsSpace.BroadphaseType broadphaseType)
```
- Method Detail
  - getPhysicsSpace
```
public static PhysicsSpace getPhysicsSpace()
```
    Get the current PhysicsSpace running on this thread
    For parallel physics, this can also be called from the OpenGL thread to receive the PhysicsSpace
    
    Returns:
    the PhysicsSpace running on this thread
  - setLocalThreadPhysicsSpace
```
public static void setLocalThreadPhysicsSpace(PhysicsSpace space)
```
    Used internally
    
    Parameters:
    space -
  - create
```
public void create()
```
    Has to be called from the (designated) physics thread
  - update
```
public void update(float time)
```
    updates the physics space
    
    Parameters:
    time - the current time value
  - update
```
public void update(float time,
          int maxSteps)
```
    updates the physics space, uses maxSteps
    
    Parameters:
    time - the current time value
    maxSteps -
  - distributeEvents
```
public void distributeEvents()
```
  - enqueueOnThisThread
```
public static <V> java.util.concurrent.Future<V> enqueueOnThisThread(java.util.concurrent.Callable<V> callable)
```
  - enqueue
```
public <V> java.util.concurrent.Future<V> enqueue(java.util.concurrent.Callable<V> callable)
```
    calls the callable on the next physics tick (ensuring e.g. force applying)
    
    Type Parameters:
    V -
    Parameters:
    callable -
    
    Returns:
    Future object
  - add
```
public void add(java.lang.Object obj)
```
    adds an object to the physics space
    
    Parameters:
    obj - the PhysicsControl or Spatial with PhysicsControl to add
  - addCollisionObject
```
public void addCollisionObject(PhysicsCollisionObject obj)
```
  - remove
```
public void remove(java.lang.Object obj)
```
    removes an object from the physics space
    
    Parameters:
    obj - the PhysicsControl or Spatial with PhysicsControl to remove
  - removeCollisionObject
```
public void removeCollisionObject(PhysicsCollisionObject obj)
```
  - addAll
```
public void addAll(com.jme3.scene.Spatial spatial)
```
    adds all physics controls and joints in the given spatial node to the physics space (e.g. after loading from disk) - recursive if node
    
    Parameters:
    spatial - the rootnode containing the physics objects
  - removeAll
```
public void removeAll(com.jme3.scene.Spatial spatial)
```
    Removes all physics controls and joints in the given spatial from the physics space (e.g. before saving to disk) - recursive if node
    
    Parameters:
    spatial - the rootnode containing the physics objects
  - getRigidBodyList
```
public java.util.Collection<PhysicsRigidBody> getRigidBodyList()
```
  - getGhostObjectList
```
public java.util.Collection<PhysicsGhostObject> getGhostObjectList()
```
  - getCharacterList
```
public java.util.Collection<PhysicsCharacter> getCharacterList()
```
  - getJointList
```
public java.util.Collection<PhysicsJoint> getJointList()
```
  - getVehicleList
```
public java.util.Collection<PhysicsVehicle> getVehicleList()
```
  - setGravity
```
public void setGravity(com.jme3.math.Vector3f gravity)
```
    Sets the gravity of the PhysicsSpace, set before adding physics objects!
    
    Parameters:
    gravity -
  - getGravity
```
public com.jme3.math.Vector3f getGravity(com.jme3.math.Vector3f gravity)
```
  - addTickListener
```
public void addTickListener(PhysicsTickListener listener)
```
    Adds the specified listener to the physics tick listeners. The listeners are called on each physics step, which is not necessarily each frame but is determined by the accuracy of the physics space.
    
    Parameters:
    listener -
  - removeTickListener
```
public void removeTickListener(PhysicsTickListener listener)
```
  - addCollisionListener
```
public void addCollisionListener(PhysicsCollisionListener listener)
```
    Adds a CollisionListener that will be informed about collision events
    
    Parameters:
    listener - the CollisionListener to add
  - removeCollisionListener
```
public void removeCollisionListener(PhysicsCollisionListener listener)
```
    Removes a CollisionListener from the list
    
    Parameters:
    listener - the CollisionListener to remove
  - addCollisionGroupListener
```
public void addCollisionGroupListener(PhysicsCollisionGroupListener listener,
                             int collisionGroup)
```
    Adds a listener for a specific collision group, such a listener can disable collisions when they happen.
    There can be only one listener per collision group.
    
    Parameters:
    listener -
    collisionGroup -
  - removeCollisionGroupListener
```
public void removeCollisionGroupListener(int collisionGroup)
```
  - rayTest
```
public java.util.List rayTest(com.jme3.math.Vector3f from,
                     com.jme3.math.Vector3f to)
```
    Performs a ray collision test and returns the results as a list of PhysicsRayTestResults
  - SetRayTestFlags
```
public void SetRayTestFlags(int flags)
```
    Sets m_flags for raytest, see https://code.google.com/p/bullet/source/browse/trunk/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h for possible options. Defaults to using the faster, approximate raytest.
  - GetRayTestFlags
```
public int GetRayTestFlags()
```
    Gets m_flags for raytest, see https://code.google.com/p/bullet/source/browse/trunk/src/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h for possible options.
    
    Returns:
    rayTestFlags
  - rayTest
```
public java.util.List<PhysicsRayTestResult> rayTest(com.jme3.math.Vector3f from,
                                           com.jme3.math.Vector3f to,
                                           java.util.List<PhysicsRayTestResult> results)
```
    Performs a ray collision test and returns the results as a list of PhysicsRayTestResults
  - rayTest_native
```
public void rayTest_native(com.jme3.math.Vector3f from,
                  com.jme3.math.Vector3f to,
                  long physicsSpaceId,
                  java.util.List<PhysicsRayTestResult> results,
                  int flags)
```
  - sweepTest
```
public java.util.List<PhysicsSweepTestResult> sweepTest(CollisionShape shape,
                                               com.jme3.math.Transform start,
                                               com.jme3.math.Transform end)
```
    Performs a sweep collision test and returns the results as a list of PhysicsSweepTestResults
    You have to use different Transforms for start and end (at least distance > 0.4f). SweepTest will not see a collision if it starts INSIDE an object and is moving AWAY from its center.
  - sweepTest
```
public java.util.List<PhysicsSweepTestResult> sweepTest(CollisionShape shape,
                                               com.jme3.math.Transform start,
                                               com.jme3.math.Transform end,
                                               java.util.List<PhysicsSweepTestResult> results)
```
  - sweepTest_native
```
public void sweepTest_native(long shape,
                    com.jme3.math.Transform from,
                    com.jme3.math.Transform to,
                    long physicsSpaceId,
                    java.util.List<PhysicsSweepTestResult> results,
                    float allowedCcdPenetration)
```
  - sweepTest
```
public java.util.List<PhysicsSweepTestResult> sweepTest(CollisionShape shape,
                                               com.jme3.math.Transform start,
                                               com.jme3.math.Transform end,
                                               java.util.List<PhysicsSweepTestResult> results,
                                               float allowedCcdPenetration)
```
    Performs a sweep collision test and returns the results as a list of PhysicsSweepTestResults
    You have to use different Transforms for start and end (at least distance > allowedCcdPenetration). SweepTest will not see a collision if it starts INSIDE an object and is moving AWAY from its center.
  - destroy
```
public void destroy()
```
    destroys the current PhysicsSpace so that a new one can be created
  - getSpaceId
```
public long getSpaceId()
```
    // * used internally //
    
    Returns:
    the dynamicsWorld //
  - getBroadphaseType
```
public PhysicsSpace.BroadphaseType getBroadphaseType()
```
  - setBroadphaseType
```
public void setBroadphaseType(PhysicsSpace.BroadphaseType broadphaseType)
```
  - setMaxSubSteps
```
public void setMaxSubSteps(int steps)
```
    Sets the maximum amount of extra steps that will be used to step the physics when the fps is below the physics fps. Doing this maintains determinism in physics. For example a maximum number of 2 can compensate for framerates as low as 30fps when the physics has the default accuracy of 60 fps. Note that setting this value too high can make the physics drive down its own fps in case its overloaded.
    
    Parameters:
    steps - The maximum number of extra steps, default is 4.
  - getAccuracy
```
public float getAccuracy()
```
    get the current accuracy of the physics computation
    
    Returns:
    the current accuracy
  - setAccuracy
```
public void setAccuracy(float accuracy)
```
    sets the accuracy of the physics computation, default=1/60s
    
    Parameters:
    accuracy -
  - getWorldMin
```
public com.jme3.math.Vector3f getWorldMin()
```
  - setWorldMin
```
public void setWorldMin(com.jme3.math.Vector3f worldMin)
```
    only applies for AXIS_SWEEP broadphase
    
    Parameters:
    worldMin -
  - getWorldMax
```
public com.jme3.math.Vector3f getWorldMax()
```
  - setWorldMax
```
public void setWorldMax(com.jme3.math.Vector3f worldMax)
```
    only applies for AXIS_SWEEP broadphase
    
    Parameters:
    worldMax -
  - setSolverNumIterations
```
public void setSolverNumIterations(int numIterations)
```
    Set the number of iterations used by the contact solver. The default is 10. Use 4 for low quality, 20 for high quality.
    
    Parameters:
    numIterations - The number of iterations used by the contact & constraint solver.
  - getSolverNumIterations
```
public int getSolverNumIterations()
```
    Get the number of iterations used by the contact solver.
    
    Returns:
    The number of iterations used by the contact & constraint solver.
  - initNativePhysics
```
public static void initNativePhysics()
```
  - finalize
```
protected void finalize()
                 throws java.lang.Throwable
```
    Overrides:
    
    finalize in class java.lang.Object
    
    Throws:
    
    java.lang.Throwable

Class PhysicsSpace

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

AXIS_X

AXIS_Y

AXIS_Z

Constructor Detail

PhysicsSpace

PhysicsSpace

PhysicsSpace

PhysicsSpace

Method Detail

getPhysicsSpace

setLocalThreadPhysicsSpace

create

update

update

distributeEvents

enqueueOnThisThread

enqueue

add

addCollisionObject

remove

removeCollisionObject

addAll

removeAll

getRigidBodyList

getGhostObjectList

getCharacterList

getJointList

getVehicleList

setGravity

getGravity

addTickListener

removeTickListener

addCollisionListener

removeCollisionListener

addCollisionGroupListener

removeCollisionGroupListener

rayTest

SetRayTestFlags

GetRayTestFlags

rayTest

rayTest_native

sweepTest

sweepTest

sweepTest_native

sweepTest

destroy

getSpaceId

getBroadphaseType

setBroadphaseType

setMaxSubSteps

getAccuracy

setAccuracy

getWorldMin

setWorldMin

getWorldMax

setWorldMax

setSolverNumIterations

getSolverNumIterations

initNativePhysics

finalize