BulletAppState (jMonkeyEngine 3.1 jme3-bullet Javadoc)

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

All Implemented Interfaces:

com.jme3.app.state.AppState, PhysicsTickListener
```
public class BulletAppState
extends java.lang.Object
implements com.jme3.app.state.AppState, PhysicsTickListener
```
BulletAppState allows using bullet physics in an Application.

Author:

normenhansen

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class BulletAppState.ThreadingType

Nested Classes
Modifier and Type	Class and Description
`static class`	`BulletAppState.ThreadingType`

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`active`
`protected com.jme3.app.Application`	`app`
`protected PhysicsSpace.BroadphaseType`	`broadphaseType`
`protected BulletDebugAppState`	`debugAppState`
`protected boolean`	`debugEnabled`
`protected java.util.concurrent.ScheduledThreadPoolExecutor`	`executor`
`protected boolean`	`initialized`
`protected java.util.concurrent.Future`	`physicsFuture`
`protected PhysicsSpace`	`pSpace`
`protected float`	`speed`
`protected com.jme3.app.state.AppStateManager`	`stateManager`
`protected BulletAppState.ThreadingType`	`threadingType`
`protected float`	`tpf`
`protected com.jme3.math.Vector3f`	`worldMax`
`protected com.jme3.math.Vector3f`	`worldMin`

Constructor Summary

Constructors
Constructor and Description
`BulletAppState()` Creates a new BulletAppState running a PhysicsSpace for physics simulation, use getStateManager().addState(bulletAppState) to enable physics for an Application.
`BulletAppState(PhysicsSpace.BroadphaseType broadphaseType)` Creates a new BulletAppState running a PhysicsSpace for physics simulation, use getStateManager().addState(bulletAppState) to enable physics for an Application.
`BulletAppState(com.jme3.math.Vector3f worldMin, com.jme3.math.Vector3f worldMax)` Creates a new BulletAppState running a PhysicsSpace for physics simulation, use getStateManager().addState(bulletAppState) to enable physics for an Application.
`BulletAppState(com.jme3.math.Vector3f worldMin, com.jme3.math.Vector3f worldMax, PhysicsSpace.BroadphaseType broadphaseType)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`cleanup()`
`PhysicsSpace`	`getPhysicsSpace()`
`float`	`getSpeed()`
`BulletAppState.ThreadingType`	`getThreadingType()`
`void`	`initialize(com.jme3.app.state.AppStateManager stateManager, com.jme3.app.Application app)`
`boolean`	`isDebugEnabled()`
`boolean`	`isEnabled()`
`boolean`	`isInitialized()`
`void`	`physicsTick(PhysicsSpace space, float f)` Called after the physics has been stepped, use to check for forces etc.
`void`	`postRender()`
`void`	`prePhysicsTick(PhysicsSpace space, float f)` Called before the physics is actually stepped, use to apply forces etc.
`void`	`render(com.jme3.renderer.RenderManager rm)`
`void`	`setBroadphaseType(PhysicsSpace.BroadphaseType broadphaseType)` Use before attaching state
`void`	`setDebugEnabled(boolean debugEnabled)`
`void`	`setEnabled(boolean enabled)`
`void`	`setSpeed(float speed)`
`void`	`setThreadingType(BulletAppState.ThreadingType threadingType)` Use before attaching state
`void`	`setWorldMax(com.jme3.math.Vector3f worldMax)` Use before attaching state
`void`	`setWorldMin(com.jme3.math.Vector3f worldMin)` Use before attaching state
`void`	`startPhysics()` The physics system is started automatically on attaching, if you want to start it before for some reason, you can use this method.
`void`	`stateAttached(com.jme3.app.state.AppStateManager stateManager)`
`void`	`stateDetached(com.jme3.app.state.AppStateManager stateManager)`
`void`	`stopPhysics()`
`void`	`update(float tpf)`

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

- Field Detail
  - initialized
```
protected boolean initialized
```
  - app
```
protected com.jme3.app.Application app
```
  - stateManager
```
protected com.jme3.app.state.AppStateManager stateManager
```
  - executor
```
protected java.util.concurrent.ScheduledThreadPoolExecutor executor
```
  - pSpace
```
protected PhysicsSpace pSpace
```
  - threadingType
```
protected BulletAppState.ThreadingType threadingType
```
  - broadphaseType
```
protected PhysicsSpace.BroadphaseType broadphaseType
```
  - worldMin
```
protected com.jme3.math.Vector3f worldMin
```
  - worldMax
```
protected com.jme3.math.Vector3f worldMax
```
  - speed
```
protected float speed
```
  - active
```
protected boolean active
```
  - debugEnabled
```
protected boolean debugEnabled
```
  - debugAppState
```
protected BulletDebugAppState debugAppState
```
  - tpf
```
protected float tpf
```
  - physicsFuture
```
protected java.util.concurrent.Future physicsFuture
```
- Constructor Detail
  - BulletAppState
```
public BulletAppState()
```
    Creates a new BulletAppState running a PhysicsSpace for physics simulation, use getStateManager().addState(bulletAppState) to enable physics for an Application.
  - BulletAppState
```
public BulletAppState(PhysicsSpace.BroadphaseType broadphaseType)
```
    Creates a new BulletAppState running a PhysicsSpace for physics simulation, use getStateManager().addState(bulletAppState) to enable physics for an Application.
    
    Parameters:
    broadphaseType - The type of broadphase collision detection, BroadphaseType.DVBT is the default
  - BulletAppState
```
public BulletAppState(com.jme3.math.Vector3f worldMin,
              com.jme3.math.Vector3f worldMax)
```
    Creates a new BulletAppState running a PhysicsSpace for physics simulation, use getStateManager().addState(bulletAppState) to enable physics for an Application. An AxisSweep broadphase is used.
    
    Parameters:
    worldMin - The minimum world extent
    worldMax - The maximum world extent
  - BulletAppState
```
public BulletAppState(com.jme3.math.Vector3f worldMin,
              com.jme3.math.Vector3f worldMax,
              PhysicsSpace.BroadphaseType broadphaseType)
```
- Method Detail
  - getPhysicsSpace
```
public PhysicsSpace getPhysicsSpace()
```
  - startPhysics
```
public void startPhysics()
```
    The physics system is started automatically on attaching, if you want to start it before for some reason, you can use this method.
  - stopPhysics
```
public void stopPhysics()
```
  - initialize
```
public void initialize(com.jme3.app.state.AppStateManager stateManager,
              com.jme3.app.Application app)
```
    Specified by:
    
    initialize in interface com.jme3.app.state.AppState
  - isInitialized
```
public boolean isInitialized()
```
    Specified by:
    
    isInitialized in interface com.jme3.app.state.AppState
  - setEnabled
```
public void setEnabled(boolean enabled)
```
    Specified by:
    
    setEnabled in interface com.jme3.app.state.AppState
  - isEnabled
```
public boolean isEnabled()
```
    Specified by:
    
    isEnabled in interface com.jme3.app.state.AppState
  - setDebugEnabled
```
public void setDebugEnabled(boolean debugEnabled)
```
  - isDebugEnabled
```
public boolean isDebugEnabled()
```
  - stateAttached
```
public void stateAttached(com.jme3.app.state.AppStateManager stateManager)
```
    Specified by:
    
    stateAttached in interface com.jme3.app.state.AppState
  - stateDetached
```
public void stateDetached(com.jme3.app.state.AppStateManager stateManager)
```
    Specified by:
    
    stateDetached in interface com.jme3.app.state.AppState
  - update
```
public void update(float tpf)
```
    Specified by:
    
    update in interface com.jme3.app.state.AppState
  - render
```
public void render(com.jme3.renderer.RenderManager rm)
```
    Specified by:
    
    render in interface com.jme3.app.state.AppState
  - postRender
```
public void postRender()
```
    Specified by:
    
    postRender in interface com.jme3.app.state.AppState
  - cleanup
```
public void cleanup()
```
    Specified by:
    
    cleanup in interface com.jme3.app.state.AppState
  - getThreadingType
```
public BulletAppState.ThreadingType getThreadingType()
```
    Returns:
    the threadingType
  - setThreadingType
```
public void setThreadingType(BulletAppState.ThreadingType threadingType)
```
    Use before attaching state
    
    Parameters:
    threadingType - the threadingType to set
  - setBroadphaseType
```
public void setBroadphaseType(PhysicsSpace.BroadphaseType broadphaseType)
```
    Use before attaching state
  - setWorldMin
```
public void setWorldMin(com.jme3.math.Vector3f worldMin)
```
    Use before attaching state
  - setWorldMax
```
public void setWorldMax(com.jme3.math.Vector3f worldMax)
```
    Use before attaching state
  - getSpeed
```
public float getSpeed()
```
  - setSpeed
```
public void setSpeed(float speed)
```
  - prePhysicsTick
```
public void prePhysicsTick(PhysicsSpace space,
                  float f)
```
    Description copied from interface: PhysicsTickListener
    
    Called before the physics is actually stepped, use to apply forces etc.
    
    Specified by:
    
    prePhysicsTick in interface PhysicsTickListener
    
    Parameters:
    space - the physics space
    f - the time per frame in seconds
  - physicsTick
```
public void physicsTick(PhysicsSpace space,
               float f)
```
    Description copied from interface: PhysicsTickListener
    
    Called after the physics has been stepped, use to check for forces etc.
    
    Specified by:
    
    physicsTick in interface PhysicsTickListener
    
    Parameters:
    space - the physics space
    f - the time per frame in seconds

Class BulletAppState

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

initialized

app

stateManager

executor

pSpace

threadingType

broadphaseType

worldMin

worldMax

speed

active

debugEnabled

debugAppState

tpf

physicsFuture

Constructor Detail

BulletAppState

BulletAppState

BulletAppState

BulletAppState

Method Detail

getPhysicsSpace

startPhysics

stopPhysics

initialize

isInitialized

setEnabled

isEnabled

setDebugEnabled

isDebugEnabled

stateAttached

stateDetached

update

render

postRender

cleanup

getThreadingType

setThreadingType

setBroadphaseType

setWorldMin

setWorldMax

getSpeed

setSpeed

prePhysicsTick

physicsTick