Class CharacterController

java.lang.Object
com.jme3.bullet.NativePhysicsObject
com.jme3.bullet.objects.infos.CharacterController
All Implemented Interfaces:
Comparable<NativePhysicsObject>
public class CharacterController extends NativePhysicsObject
The "action" (controller) portion of a PhysicsCharacter, based on Bullet's btKinematicCharacterController.

  • Field Details

    • logger

      public static final Logger logger
      message logger for this class

  • Constructor Details

    • CharacterController

      public CharacterController(PhysicsCharacter character)
      Instantiate a controller for the specified collision object.
      Parameters:
      character - the collision object to control (not null)

  • Method Details

    • copyAll

      public void copyAll(CharacterController source)
      Copy all parameter values from the specified controller.
      Parameters:
      source - the controller to copy from (not null, unaffected)

    • getAngularDamping

      public float getAngularDamping()
      Determine the character's angular damping.
      Returns:
      the viscous damping ratio (0→no damping, 1→critically damped)

    • getAngularVelocity

      public Vector3f getAngularVelocity(Vector3f storeResult)
      Determine the character's angular velocity.
      Parameters:
      storeResult - storage for the result (modified if not null)
      Returns:
      the velocity vector (in radians per second, either storeResult or a new vector, not null)

    • getFallSpeed

      public float getFallSpeed()
      Determine the character's maximum fall speed (terminal velocity).
      Returns:
      the speed (in physics-space units per second)

    • getGravity

      public Vector3f getGravity(Vector3f storeResult)
      Determine the character's gravitational acceleration.
      Parameters:
      storeResult - storage for the result (modified if not null)
      Returns:
      an acceleration vector (in physics-space units per second squared, direction opposite the "up" vector, either storeResult or a new vector, not null)

    • getJumpSpeed

      public float getJumpSpeed()
      Determine the character's jump speed.
      Returns:
      the speed (in physics-space units per second)

    • getLinearDamping

      public float getLinearDamping()
      Determine the character's linear damping.
      Returns:
      the viscous damping ratio (0→no damping, 1→critically damped)

    • getLinearVelocity

      public Vector3f getLinearVelocity(Vector3f storeResult)
      Determine the character's linear motion command: the sum of its horizontal (walk) offset plus its vertical (jump) velocity. Note that the horizontal units differ from PhysicsRigidBody.

      Collisions can cause the achieved motion to be less than commanded. To determine the achieved displacement, use getMostRecentDisplacement(com.jme3.math.Vector3f).

      Parameters:
      storeResult - storage for the result (modified if not null)
      Returns:
      a vector (horizontal components in physics-space units per time step, vertical component in physics-space units per second, either storeResult or a new vector, not null)
      See Also:

    • getMaxPenetrationDepth

      public float getMaxPenetrationDepth()
      Determine the character's maximum penetration depth.
      Returns:
      the depth (in physics-space units)

    • getMaxSlope

      public float getMaxSlope()
      Determine the character's maximum slope angle.
      Returns:
      the angle relative to the horizontal (in radians)

    • getMostRecentDisplacement

      public Vector3f getMostRecentDisplacement(Vector3f storeResult)
      Copy the character's displacement during the most recent simulation step.

      Unlike getLinearVelocity(com.jme3.math.Vector3f), the units are simply physics-space units per time step.

      Parameters:
      storeResult - storage for the result (modified if not null)
      Returns:
      an offset vector (in physics-space coordinates, either storeResult or a new vector, not null)

    • getStepHeight

      public float getStepHeight()
      Determine the character's step height.
      Returns:
      the maximum amount of vertical movement without jumping or falling (in physics-space units)

    • getUpDirection

      public Vector3f getUpDirection(Vector3f storeResult)
      Determine the character's "up" direction.
      Parameters:
      storeResult - storage for the result (modified if not null)
      Returns:
      a unit vector (in physics-space coordinates, in the direction opposite the gravity vector, either storeResult or a new vector, not null)

    • getWalkDirection

      public Vector3f getWalkDirection(Vector3f storeResult)
      Determine the character's walk offset: its horizontal motion command.

      Collisions can cause the achieved motion to be less than commanded. To determine the achieved displacement, use getMostRecentDisplacement(com.jme3.math.Vector3f).

      Parameters:
      storeResult - storage for the result (modified if not null)
      Returns:
      an offset vector (either storeResult or a new vector, not null)

    • isUsingGhostSweepTest

      public boolean isUsingGhostSweepTest()
      Test whether the ghost's convex-sweep test is in use.
      Returns:
      true if using the ghost's convex-sweep test, otherwise false

    • jump

      public void jump(Vector3f direction)
      Jump in the specified direction.
      Parameters:
      direction - desired jump direction (not null, unaffected) or (0,0,0) to jump in the "up" direction

    • onGround

      public boolean onGround()
      Test whether the character is on the ground.
      Returns:
      true if on the ground, otherwise false

    • reset

      public void reset(PhysicsSpace space)
      Reset this controller, including its velocity.
      Parameters:
      space - (not null)

    • setAngularDamping

      public void setAngularDamping(float damping)
      Alter the character's angular damping.
      Parameters:
      damping - the desired viscous damping ratio (0→no damping, 1→critically damped, default=0)

    • setAngularVelocity

      public void setAngularVelocity(Vector3f angularVelocity)
      Alter the character's angular velocity.
      Parameters:
      angularVelocity - the desired angular velocity vector (in radians per second, not null, unaffected)

    • setFallSpeed

      public void setFallSpeed(float fallSpeed)
      Alter the character's maximum fall speed (terminal velocity).
      Parameters:
      fallSpeed - the desired speed (in physics-space units per second, default=55)

    • setGravity

      public void setGravity(Vector3f gravity)
      Alter the character's gravitational acceleration. This may also alter its "up" vector.
      Parameters:
      gravity - the desired acceleration vector (in physics-space units per second squared, not null, finite, unaffected, default=(0,-29.4,0))

    • setJumpSpeed

      public void setJumpSpeed(float jumpSpeed)
      Alter the character's jump speed.
      Parameters:
      jumpSpeed - the desired speed (in physics-space units per second, default=10)

    • setLinearDamping

      public void setLinearDamping(float damping)
      Alter the character's linear damping.
      Parameters:
      damping - the desired viscous damping ratio (0→no damping, 1→critically damped, default=0)

    • setLinearVelocity

      public void setLinearVelocity(Vector3f velocity)
      Command the linear velocity of this character's center. Note that the horizontal units differ from PhysicsRigidBody!

      Collisions can cause the achieved motion to be less than commanded.

      Parameters:
      velocity - the desired velocity vector (horizontal components in physics-space units per time step, vertical component in physics-space units per second, not null, finite)

    • setMaxPenetrationDepth

      public void setMaxPenetrationDepth(float depth)
      Alter the character's maximum penetration depth.
      Parameters:
      depth - the desired depth (in physics-space units, default=0.2)

    • setMaxSlope

      public void setMaxSlope(float slopeRadians)
      Alter the character's maximum slope angle.
      Parameters:
      slopeRadians - the desired angle relative to the horizontal (in radians, default=Pi/4)

    • setStepHeight

      public void setStepHeight(float height)
      Alter the character's step height.
      Parameters:
      height - the desired maximum amount of vertical movement without jumping or falling (in physics-space units, default=1)

    • setSweepTest

      public void setSweepTest(boolean useGhostSweepTest)
      Alter which convex-sweep test is used.
      Parameters:
      useGhostSweepTest - true to use the ghost's test, false to use the world's test (default=true)

    • setUp

      public void setUp(Vector3f direction)
      Alter the character's "up" direction. This may also alter its gravity vector.
      Parameters:
      direction - the desired direction (not null, not zero, unaffected, default=(0,1,0))

    • setWalkDirection

      public void setWalkDirection(Vector3f offset)
      Alter the character's walk offset. The offset must be perpendicular to the "up" direction. It will continue to be applied until altered again.
      Parameters:
      offset - the desired location increment for each simulation step (in physics-space coordinates, not null, finite, unaffected, default=(0,0,0))

    • warp

      public void warp(Vector3f location)
      Directly alter the location of the character's center.
      Parameters:
      location - the desired physics location (not null, finite, unaffected)

    • warpDp

      public void warpDp(Vec3d location)
      Directly alter the location of the character's center.
      Parameters:
      location - the desired physics location (not null, finite, unaffected)