Physics Simulation with JBullet in Java

Introduction

JBullet is a pure Java port of the popular Bullet Physics SDK, providing robust 3D physics simulation capabilities including rigid body dynamics, collision detection, soft body dynamics, and constraints. It's widely used in games, simulations, and visualization applications.

Setup and Dependencies

Maven Configuration

<dependencies> <dependency> <groupId>com.bulletphysics</groupId> <artifactId>jbullet</artifactId> <version>20101010</version> </dependency> <dependency> <groupId>org.jogamp.jogl</groupId> <artifactId>jogl-all</artifactId> <version>2.3.2</version> </dependency> <dependency> <groupId>org.jogamp.gluegen</groupId> <artifactId>gluegen-rt</artifactId> <version>2.3.2</version> </dependency> </dependencies>

Basic JBullet Setup

import com.bulletphysics.collision.broadphase.*; import com.bulletphysics.collision.dispatch.*; import com.bulletphysics.collision.shapes.*; import com.bulletphysics.dynamics.*; import com.bulletphysics.dynamics.constraintsolver.*; import com.bulletphysics.linearmath.*; import javax.vecmath.*; public class PhysicsWorld { private DynamicsWorld dynamicsWorld; private CollisionConfiguration collisionConfig; private Dispatcher dispatcher; private BroadphaseInterface broadphase; private ConstraintSolver solver; public PhysicsWorld() { initializePhysics(); } private void initializePhysics() { // Default collision configuration collisionConfig = new DefaultCollisionConfiguration(); dispatcher = new CollisionDispatcher(collisionConfig); // Broadphase setup broadphase = new DbvtBroadphase(); // Constraint solver solver = new SequentialImpulseConstraintSolver(); // Create dynamics world dynamicsWorld = new DiscreteDynamicsWorld( dispatcher, broadphase, solver, collisionConfig); // Set gravity (Earth gravity: -9.81 m/s² on Y axis) dynamicsWorld.setGravity(new Vector3f(0, -9.81f, 0)); } public void stepSimulation(float timeStep) { dynamicsWorld.stepSimulation(timeStep, 10); } public DynamicsWorld getDynamicsWorld() { return dynamicsWorld; } }

Rigid Body Physics

Creating Rigid Bodies

public class RigidBodyFactory { // Create a box rigid body public static RigidBody createBox(Vector3f position, Vector3f size, float mass) { // Collision shape CollisionShape boxShape = new BoxShape(size); // Motion state for transformation updates DefaultMotionState motionState = new DefaultMotionState( new Transform(new Matrix4f(new Quat4f(0, 0, 0, 1), position, 1.0f)) ); // Calculate local inertia Vector3f localInertia = new Vector3f(0, 0, 0); if (mass > 0) { boxShape.calculateLocalInertia(mass, localInertia); } // Rigid body construction info RigidBodyConstructionInfo constructionInfo = new RigidBodyConstructionInfo( mass, motionState, boxShape, localInertia ); return new RigidBody(constructionInfo); } // Create a sphere rigid body public static RigidBody createSphere(Vector3f position, float radius, float mass) { CollisionShape sphereShape = new SphereShape(radius); DefaultMotionState motionState = new DefaultMotionState( new Transform(new Matrix4f(new Quat4f(0, 0, 0, 1), position, 1.0f)) ); Vector3f localInertia = new Vector3f(0, 0, 0); if (mass > 0) { sphereShape.calculateLocalInertia(mass, localInertia); } RigidBodyConstructionInfo constructionInfo = new RigidBodyConstructionInfo( mass, motionState, sphereShape, localInertia ); return new RigidBody(constructionInfo); } // Create a cylinder rigid body public static RigidBody createCylinder(Vector3f position, Vector3f halfExtents, float mass) { CollisionShape cylinderShape = new CylinderShape(halfExtents); DefaultMotionState motionState = new DefaultMotionState( new Transform(new Matrix4f(new Quat4f(0, 0, 0, 1), position, 1.0f)) ); Vector3f localInertia = new Vector3f(0, 0, 0); if (mass > 0) { cylinderShape.calculateLocalInertia(mass, localInertia); } RigidBodyConstructionInfo constructionInfo = new RigidBodyConstructionInfo( mass, motionState, cylinderShape, localInertia ); return new RigidBody(constructionInfo); } // Create a static ground plane public static RigidBody createGroundPlane() { CollisionShape groundShape = new StaticPlaneShape(new Vector3f(0, 1, 0), 0); DefaultMotionState groundMotionState = new DefaultMotionState( new Transform(new Matrix4f(new Quat4f(0, 0, 0, 1), new Vector3f(0, 0, 0), 1.0f)) ); RigidBodyConstructionInfo groundConstructionInfo = new RigidBodyConstructionInfo( 0, groundMotionState, groundShape, new Vector3f(0, 0, 0) ); return new RigidBody(groundConstructionInfo); } // Create a compound shape (multiple collision shapes) public static RigidBody createCompoundObject(Vector3f position, float mass) { CompoundShape compoundShape = new CompoundShape(); // Add a box BoxShape boxShape = new BoxShape(new Vector3f(1, 0.5f, 1)); Transform boxTransform = new Transform(); boxTransform.setIdentity(); boxTransform.origin.set(0, 1.5f, 0); compoundShape.addChildShape(boxTransform, boxShape); // Add a sphere SphereShape sphereShape = new SphereShape(1); Transform sphereTransform = new Transform(); sphereTransform.setIdentity(); sphereTransform.origin.set(0, 0, 0); compoundShape.addChildShape(sphereTransform, sphereShape); DefaultMotionState motionState = new DefaultMotionState( new Transform(new Matrix4f(new Quat4f(0, 0, 0, 1), position, 1.0f)) ); Vector3f localInertia = new Vector3f(0, 0, 0); if (mass > 0) { compoundShape.calculateLocalInertia(mass, localInertia); } RigidBodyConstructionInfo constructionInfo = new RigidBodyConstructionInfo( mass, motionState, compoundShape, localInertia ); return new RigidBody(constructionInfo); } }

Complete Physics Simulation Example

public class PhysicsSimulation { private DynamicsWorld dynamicsWorld; private List<RigidBody> rigidBodies; public PhysicsSimulation() { initializePhysicsWorld(); rigidBodies = new ArrayList<>(); createScene(); } private void initializePhysicsWorld() { CollisionConfiguration collisionConfig = new DefaultCollisionConfiguration(); CollisionDispatcher dispatcher = new CollisionDispatcher(collisionConfig); BroadphaseInterface broadphase = new DbvtBroadphase(); ConstraintSolver solver = new SequentialImpulseConstraintSolver(); dynamicsWorld = new DiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfig); dynamicsWorld.setGravity(new Vector3f(0, -9.81f, 0)); } private void createScene() { // Create ground plane RigidBody ground = RigidBodyFactory.createGroundPlane(); dynamicsWorld.addRigidBody(ground); rigidBodies.add(ground); // Create some falling boxes Random random = new Random(); for (int i = 0; i < 10; i++) { Vector3f position = new Vector3f( random.nextFloat() * 10 - 5, 5 + i * 2, random.nextFloat() * 10 - 5 ); Vector3f size = new Vector3f( 0.5f + random.nextFloat() * 0.5f, 0.5f + random.nextFloat() * 0.5f, 0.5f + random.nextFloat() * 0.5f ); RigidBody box = RigidBodyFactory.createBox(position, size, 1.0f); dynamicsWorld.addRigidBody(box); rigidBodies.add(box); } // Create some spheres for (int i = 0; i < 5; i++) { Vector3f position = new Vector3f( random.nextFloat() * 8 - 4, 10 + i * 3, random.nextFloat() * 8 - 4 ); RigidBody sphere = RigidBodyFactory.createSphere(position, 0.5f, 0.8f); dynamicsWorld.addRigidBody(sphere); rigidBodies.add(sphere); } // Create a compound object RigidBody compound = RigidBodyFactory.createCompoundObject(new Vector3f(0, 15, 0), 2.0f); dynamicsWorld.addRigidBody(compound); rigidBodies.add(compound); } public void update(float deltaTime) { dynamicsWorld.stepSimulation(deltaTime, 10); // Update object positions for rendering for (RigidBody body : rigidBodies) { if (body.getMotionState() != null) { body.getMotionState().getWorldTransform(new Transform()); } } } public List<RigidBody> getRigidBodies() { return rigidBodies; } public void addRigidBody(RigidBody body) { dynamicsWorld.addRigidBody(body); rigidBodies.add(body); } public void removeRigidBody(RigidBody body) { dynamicsWorld.removeRigidBody(body); rigidBodies.remove(body); } }

Collision Detection and Response

Collision Detection System

public class CollisionHandler extends CollisionWorld.ContactResultCallback { private List<CollisionEvent> collisionEvents; public CollisionHandler() { collisionEvents = new ArrayList<>(); } @Override public float addSingleResult(ManifoldPoint cp, CollisionObject colObj0, int partId0, int index0, CollisionObject colObj1, int partId1, int index1) { // Extract collision information Vector3f pointA = new Vector3f(); Vector3f pointB = new Vector3f(); cp.getPositionWorldOnA(pointA); cp.getPositionWorldOnB(pointB); Vector3f normalOnB = new Vector3f(); cp.normalWorldOnB(normalOnB); float distance = cp.getDistance(); float impulse = cp.getAppliedImpulse(); // Create collision event CollisionEvent event = new CollisionEvent( (RigidBody) colObj0, (RigidBody) colObj1, pointA, pointB, normalOnB, distance, impulse ); collisionEvents.add(event); return 1.0f; } public void checkCollisions(DynamicsWorld world) { collisionEvents.clear(); world.contactTest(world.getCollisionObjectArray(), this); } public List<CollisionEvent> getCollisionEvents() { return new ArrayList<>(collisionEvents); } } public class CollisionEvent { private final RigidBody bodyA; private final RigidBody bodyB; private final Vector3f pointA; private final Vector3f pointB; private final Vector3f normal; private final float distance; private final float impulse; private final long timestamp; public CollisionEvent(RigidBody bodyA, RigidBody bodyB, Vector3f pointA, Vector3f pointB, Vector3f normal, float distance, float impulse) { this.bodyA = bodyA; this.bodyB = bodyB; this.pointA = pointA; this.pointB = pointB; this.normal = normal; this.distance = distance; this.impulse = impulse; this.timestamp = System.currentTimeMillis(); } // Getters public RigidBody getBodyA() { return bodyA; } public RigidBody getBodyB() { return bodyB; } public Vector3f getPointA() { return pointA; } public Vector3f getPointB() { return pointB; } public Vector3f getNormal() { return normal; } public float getDistance() { return distance; } public float getImpulse() { return impulse; } public long getTimestamp() { return timestamp; } public boolean involves(RigidBody body) { return bodyA == body || bodyB == body; } }

Raycasting and Object Picking

public class RaycastHandler { private DynamicsWorld dynamicsWorld; public RaycastHandler(DynamicsWorld dynamicsWorld) { this.dynamicsWorld = dynamicsWorld; } public RaycastResult raycast(Vector3f rayFrom, Vector3f rayTo) { ClosestRayResultCallback callback = new ClosestRayResultCallback(rayFrom, rayTo); dynamicsWorld.rayTest(rayFrom, rayTo, callback); if (callback.hasHit()) { Vector3f hitPoint = new Vector3f(); callback.hitPointWorld(hitPoint); Vector3f hitNormal = new Vector3f(); callback.hitNormalWorld(hitNormal); return new RaycastResult( true, (RigidBody) callback.collisionObject, hitPoint, hitNormal, callback.closestHitFraction ); } return new RaycastResult(false, null, null, null, 0); } public List<RaycastResult> raycastAll(Vector3f rayFrom, Vector3f rayTo) { AllHitsRayResultCallback callback = new AllHitsRayResultCallback(rayFrom, rayTo); dynamicsWorld.rayTest(rayFrom, rayTo, callback); List<RaycastResult> results = new ArrayList<>(); for (int i = 0; i < callback.collisionObjects.size(); i++) { CollisionObject colObj = callback.collisionObjects.get(i); Vector3f hitPoint = callback.hitPointWorld.get(i); Vector3f hitNormal = callback.hitNormalWorld.get(i); float hitFraction = callback.hitFractions.get(i); results.add(new RaycastResult( true, (RigidBody) colObj, hitPoint, hitNormal, hitFraction )); } return results; } // Object picking with mouse coordinates (requires conversion to 3D) public RaycastResult pickObject(int mouseX, int mouseY, int screenWidth, int screenHeight, Matrix4f viewMatrix, Matrix4f projectionMatrix) { // Convert mouse coordinates to normalized device coordinates float x = (2.0f * mouseX) / screenWidth - 1.0f; float y = 1.0f - (2.0f * mouseY) / screenHeight; // Create ray in clip space Vector4f rayClip = new Vector4f(x, y, -1.0f, 1.0f); // Convert to eye space Matrix4f invertedProjection = new Matrix4f(); invertedProjection.invert(projectionMatrix); TransformUtil.multiply(invertedProjection, rayClip, rayClip); rayClip.z = -1.0f; rayClip.w = 0.0f; // Convert to world space Matrix4f invertedView = new Matrix4f(); invertedView.invert(viewMatrix); TransformUtil.multiply(invertedView, rayClip, rayClip); Vector3f rayDir = new Vector3f(rayClip.x, rayClip.y, rayClip.z); rayDir.normalize(); // Get camera position from view matrix Vector3f cameraPos = new Vector3f( viewMatrix.m30, viewMatrix.m31, viewMatrix.m32 ); Vector3f rayTo = new Vector3f(cameraPos); rayTo.add(rayDir); return raycast(cameraPos, rayTo); } } public class RaycastResult { private final boolean hasHit; private final RigidBody hitBody; private final Vector3f hitPoint; private final Vector3f hitNormal; private final float hitFraction; public RaycastResult(boolean hasHit, RigidBody hitBody, Vector3f hitPoint, Vector3f hitNormal, float hitFraction) { this.hasHit = hasHit; this.hitBody = hitBody; this.hitPoint = hitPoint; this.hitNormal = hitNormal; this.hitFraction = hitFraction; } // Getters public boolean hasHit() { return hasHit; } public RigidBody getHitBody() { return hitBody; } public Vector3f getHitPoint() { return hitPoint; } public Vector3f getHitNormal() { return hitNormal; } public float getHitFraction() { return hitFraction; } }

Constraints and Joints

Implementing Various Constraints

public class ConstraintSystem { private DynamicsWorld dynamicsWorld; private List<TypedConstraint> constraints; public ConstraintSystem(DynamicsWorld dynamicsWorld) { this.dynamicsWorld = dynamicsWorld; this.constraints = new ArrayList<>(); } // Point-to-point constraint (ball joint) public Point2PointConstraint createBallJoint(RigidBody bodyA, RigidBody bodyB, Vector3f pivotInA, Vector3f pivotInB) { Point2PointConstraint constraint = new Point2PointConstraint(bodyA, bodyB, pivotInA, pivotInB); dynamicsWorld.addConstraint(constraint); constraints.add(constraint); return constraint; } // Hinge constraint public HingeConstraint createHingeJoint(RigidBody bodyA, RigidBody bodyB, Vector3f pivotInA, Vector3f pivotInB, Vector3f axisInA, Vector3f axisInB) { HingeConstraint constraint = new HingeConstraint(bodyA, bodyB, pivotInA, pivotInB, axisInA, axisInB); dynamicsWorld.addConstraint(constraint); constraints.add(constraint); return constraint; } // Slider constraint public SliderConstraint createSliderJoint(RigidBody bodyA, RigidBody bodyB, Transform frameInA, Transform frameInB, boolean useLinearReferenceFrameA) { SliderConstraint constraint = new SliderConstraint(bodyA, bodyB, frameInA, frameInB, useLinearReferenceFrameA); dynamicsWorld.addConstraint(constraint); constraints.add(constraint); return constraint; } // Generic 6DOF constraint public Generic6DofConstraint createGeneric6DofJoint(RigidBody bodyA, RigidBody bodyB, Transform frameInA, Transform frameInB, boolean useLinearReferenceFrameA) { Generic6DofConstraint constraint = new Generic6DofConstraint(bodyA, bodyB, frameInA, frameInB, useLinearReferenceFrameA); dynamicsWorld.addConstraint(constraint); constraints.add(constraint); return constraint; } // Spring constraint public Generic6DofSpringConstraint createSpringJoint(RigidBody bodyA, RigidBody bodyB, Transform frameInA, Transform frameInB, boolean useLinearReferenceFrameA) { Generic6DofSpringConstraint constraint = new Generic6DofSpringConstraint( bodyA, bodyB, frameInA, frameInB, useLinearReferenceFrameA); // Enable spring for specific degrees of freedom for (int i = 0; i < 6; i++) { constraint.enableSpring(i, true); constraint.setStiffness(i, 100.0f); constraint.setDamping(i, 0.5f); } dynamicsWorld.addConstraint(constraint); constraints.add(constraint); return constraint; } public void removeConstraint(TypedConstraint constraint) { dynamicsWorld.removeConstraint(constraint); constraints.remove(constraint); } public List<TypedConstraint> getConstraints() { return new ArrayList<>(constraints); } }

Vehicle Physics

Vehicle Simulation

public class VehicleSystem { private DynamicsWorld dynamicsWorld; private RaycastVehicle vehicle; private VehicleTuning tuning; private DefaultVehicleRaycaster raycaster; public VehicleSystem(DynamicsWorld dynamicsWorld) { this.dynamicsWorld = dynamicsWorld; this.tuning = new VehicleTuning(); this.raycaster = new DefaultVehicleRaycaster(dynamicsWorld); } public RaycastVehicle createVehicle(Vector3f chassisPosition) { // Create vehicle chassis CollisionShape chassisShape = new BoxShape(new Vector3f(1.0f, 0.5f, 2.0f)); DefaultMotionState motionState = new DefaultMotionState( new Transform(new Matrix4f(new Quat4f(0, 0, 0, 1), chassisPosition, 1.0f)) ); Vector3f chassisInertia = new Vector3f(0, 0, 0); chassisShape.calculateLocalInertia(800, chassisInertia); RigidBodyConstructionInfo chassisInfo = new RigidBodyConstructionInfo( 800, motionState, chassisShape, chassisInertia ); RigidBody chassis = new RigidBody(chassisInfo); dynamicsWorld.addRigidBody(chassis); // Create vehicle vehicle = new RaycastVehicle(tuning, chassis, raycaster); vehicle.setCoordinateSystem(0, 1, 2); // right, up, forward // Add wheels addWheels(); dynamicsWorld.addVehicle(vehicle); return vehicle; } private void addWheels() { Vector3f wheelDirectionCS0 = new Vector3f(0, -1, 0); Vector3f wheelAxleCS = new Vector3f(-1, 0, 0); float suspensionRestLength = 0.6f; float wheelRadius = 0.5f; float wheelWidth = 0.4f; float connectionHeight = 1.2f; boolean isFrontWheel = true; // Front left wheel vehicle.addWheel( new Vector3f(-1.0f, connectionHeight, 1.5f), // connection point wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, isFrontWheel ); // Front right wheel vehicle.addWheel( new Vector3f(1.0f, connectionHeight, 1.5f), wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, isFrontWheel ); // Rear left wheel vehicle.addWheel( new Vector3f(-1.0f, connectionHeight, -1.5f), wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, !isFrontWheel ); // Rear right wheel vehicle.addWheel( new Vector3f(1.0f, connectionHeight, -1.5f), wheelDirectionCS0, wheelAxleCS, suspensionRestLength, wheelRadius, tuning, !isFrontWheel ); // Configure wheels for (int i = 0; i < vehicle.getNumWheels(); i++) { WheelInfo wheel = vehicle.getWheelInfo(i); wheel.suspensionStiffness = 20.0f; wheel.wheelsDampingRelaxation = 2.3f; wheel.wheelsDampingCompression = 4.4f; wheel.frictionSlip = 1000.0f; wheel.rollInfluence = 0.1f; } } public void updateVehicleControls(float engineForce, float brakingForce, float steering) { if (vehicle == null) return; // Apply steering to front wheels vehicle.setSteeringValue(steering, 0); // Front left vehicle.setSteeringValue(steering, 1); // Front right // Apply engine force to rear wheels (rear-wheel drive) vehicle.applyEngineForce(engineForce, 2); // Rear left vehicle.applyEngineForce(engineForce, 3); // Rear right // Apply braking to all wheels for (int i = 0; i < vehicle.getNumWheels(); i++) { vehicle.setBrake(brakingForce, i); } } public Transform getWheelTransform(int wheelIndex) { if (vehicle == null) return null; Transform transform = new Transform(); vehicle.updateWheelTransform(wheelIndex, true); vehicle.getWheelInfo(wheelIndex).getWorldTransform(transform); return transform; } }

Integration with Rendering

JBullet to OpenGL Integration

public class PhysicsRenderer { public static void renderRigidBody(RigidBody body, GL2 gl) { if (body.getMotionState() == null) return; Transform transform = new Transform(); body.getMotionState().getWorldTransform(transform); gl.glPushMatrix(); applyTransform(gl, transform); renderCollisionShape(gl, body.getCollisionShape()); gl.glPopMatrix(); } private static void applyTransform(GL2 gl, Transform transform) { Matrix4f matrix = new Matrix4f(); transform.getMatrix(matrix); FloatBuffer buffer = BufferUtils.createFloatBuffer(16); buffer.put(matrix.m00); buffer.put(matrix.m01); buffer.put(matrix.m02); buffer.put(matrix.m03); buffer.put(matrix.m10); buffer.put(matrix.m11); buffer.put(matrix.m12); buffer.put(matrix.m13); buffer.put(matrix.m20); buffer.put(matrix.m21); buffer.put(matrix.m22); buffer.put(matrix.m23); buffer.put(matrix.m30); buffer.put(matrix.m31); buffer.put(matrix.m32); buffer.put(matrix.m33); buffer.flip(); gl.glMultMatrixf(buffer); } private static void renderCollisionShape(GL2 gl, CollisionShape shape) { if (shape instanceof BoxShape) { renderBoxShape(gl, (BoxShape) shape); } else if (shape instanceof SphereShape) { renderSphereShape(gl, (SphereShape) shape); } else if (shape instanceof CylinderShape) { renderCylinderShape(gl, (CylinderShape) shape); } else if (shape instanceof CompoundShape) { renderCompoundShape(gl, (CompoundShape) shape); } } private static void renderBoxShape(GL2 gl, BoxShape boxShape) { Vector3f halfExtents = new Vector3f(); boxShape.getHalfExtentsWithMargin(halfExtents); float width = halfExtents.x * 2; float height = halfExtents.y * 2; float depth = halfExtents.z * 2; gl.glBegin(GL2.GL_QUADS); // Render box faces... gl.glEnd(); } private static void renderSphereShape(GL2 gl, SphereShape sphereShape) { float radius = sphereShape.getRadius(); // Render sphere using GLU GLU glu = GLU.createGLU(gl); GLUquadric quadric = glu.gluNewQuadric(); glu.gluSphere(quadric, radius, 32, 32); glu.gluDeleteQuadric(quadric); } public static void renderDebugWorld(DynamicsWorld world, GL2 gl) { DebugDrawModes debugDrawer = new DebugDrawModes(); world.setDebugDrawer(debugDrawer); world.debugDrawWorld(); debugDrawer.render(gl); } } class DebugDrawModes extends DebugDraw { private List<DebugLine> lines = new ArrayList<>(); @Override public void drawLine(Vector3f from, Vector3f to, Vector3f color) { lines.add(new DebugLine(from, to, color)); } @Override public void drawContactPoint(Vector3f pointOnB, Vector3f normalOnB, float distance, int lifeTime, Vector3f color) { // Render contact points Vector3f endPoint = new Vector3f(pointOnB); endPoint.add(normalOnB); lines.add(new DebugLine(pointOnB, endPoint, color)); } @Override public void reportErrorWarning(String warningString) { System.err.println("JBullet Warning: " + warningString); } @Override public void draw3dText(Vector3f location, String textString) { // Text rendering not implemented } @Override public void setDebugMode(int debugMode) { // Debug mode setting } @Override public int getDebugMode() { return DebugDrawModes.DBG_DrawWireframe | DebugDrawModes.DBG_DrawAabb; } public void render(GL2 gl) { gl.glBegin(GL2.GL_LINES); for (DebugLine line : lines) { gl.glColor3f(line.color.x, line.color.y, line.color.z); gl.glVertex3f(line.from.x, line.from.y, line.from.z); gl.glVertex3f(line.to.x, line.to.y, line.to.z); } gl.glEnd(); lines.clear(); } } class DebugLine { final Vector3f from; final Vector3f to; final Vector3f color; DebugLine(Vector3f from, Vector3f to, Vector3f color) { this.from = from; this.to = to; this.color = color; } }

Performance Optimization

Optimized Physics Simulation

public class OptimizedPhysicsWorld { private DiscreteDynamicsWorld dynamicsWorld; private CollisionConfiguration collisionConfig; private int maxSubSteps = 10; private float fixedTimeStep = 1.0f / 60.0f; public OptimizedPhysicsWorld() { setupOptimizedWorld(); } private void setupOptimizedWorld() { // Optimized collision configuration collisionConfig = new DefaultCollisionConfiguration(); // Optimized dispatcher CollisionDispatcher dispatcher = new CollisionDispatcher(collisionConfig); // Optimized broadphase BroadphaseInterface broadphase = new DbvtBroadphase(); // Constraint solver ConstraintSolver solver = new SequentialImpulseConstraintSolver(); dynamicsWorld = new DiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfig); dynamicsWorld.setGravity(new Vector3f(0, -9.81f, 0)); // Optimize simulation optimizeWorldSettings(); } private void optimizeWorldSettings() { // Set solver parameters for better performance dynamicsWorld.getSolverInfo().numIterations = 10; dynamicsWorld.getSolverInfo().solverMode = SolverMode.SOLVER_USE_WARMSTARTING | SolverMode.SOLVER_RANDMIZE_ORDER; // Optimize collision detection dynamicsWorld.getDispatchInfo().allowedCcdPenetration = 0.0001f; } public void update(float deltaTime) { // Use fixed timestep for stability dynamicsWorld.stepSimulation(deltaTime, maxSubSteps, fixedTimeStep); } // Batch add/remove operations public void addRigidBodies(List<RigidBody> bodies) { for (RigidBody body : bodies) { dynamicsWorld.addRigidBody(body); } } public void removeRigidBodies(List<RigidBody> bodies) { for (RigidBody body : bodies) { dynamicsWorld.removeRigidBody(body); } } // Object pooling for rigid bodies private final Map<String, List<RigidBody>> objectPools = new HashMap<>(); public RigidBody getPooledRigidBody(String type, Vector3f position) { List<RigidBody> pool = objectPools.computeIfAbsent(type, k -> new ArrayList<>()); if (!pool.isEmpty()) { RigidBody body = pool.remove(pool.size() - 1); // Reactivate and reposition body.activate(); body.setWorldTransform(new Transform(new Matrix4f( new Quat4f(0, 0, 0, 1), position, 1.0f))); return body; } // Create new body if pool is empty return createRigidBody(type, position); } public void returnToPool(String type, RigidBody body) { body.setLinearVelocity(new Vector3f(0, 0, 0)); body.setAngularVelocity(new Vector3f(0, 0, 0)); dynamicsWorld.removeRigidBody(body); List<RigidBody> pool = objectPools.computeIfAbsent(type, k -> new ArrayList<>()); pool.add(body); } private RigidBody createRigidBody(String type, Vector3f position) { // Implementation depends on type return RigidBodyFactory.createBox(position, new Vector3f(1, 1, 1), 1.0f); } }

Best Practices and Common Patterns

Physics Application Architecture

public class PhysicsEngine { private OptimizedPhysicsWorld physicsWorld; private CollisionHandler collisionHandler; private ConstraintSystem constraintSystem; private VehicleSystem vehicleSystem; private RaycastHandler raycastHandler; private final List<PhysicsObject> physicsObjects; private final Map<RigidBody, PhysicsObject> bodyToObjectMap; public PhysicsEngine() { physicsWorld = new OptimizedPhysicsWorld(); collisionHandler = new CollisionHandler(); constraintSystem = new ConstraintSystem(physicsWorld.getDynamicsWorld()); vehicleSystem = new VehicleSystem(physicsWorld.getDynamicsWorld()); raycastHandler = new RaycastHandler(physicsWorld.getDynamicsWorld()); physicsObjects = new ArrayList<>(); bodyToObjectMap = new HashMap<>(); } public void update(float deltaTime) { // Step physics simulation physicsWorld.update(deltaTime); // Handle collisions collisionHandler.checkCollisions(physicsWorld.getDynamicsWorld()); processCollisions(); // Update physics object states updatePhysicsObjects(); } private void processCollisions() { for (CollisionEvent event : collisionHandler.getCollisionEvents()) { PhysicsObject objA = bodyToObjectMap.get(event.getBodyA()); PhysicsObject objB = bodyToObjectMap.get(event.getBodyB()); if (objA != null) objA.onCollision(event); if (objB != null) objB.onCollision(event); } } private void updatePhysicsObjects() { for (PhysicsObject obj : physicsObjects) { obj.update(); } } public PhysicsObject createPhysicsObject(String type, Vector3f position) { RigidBody body = physicsWorld.getPooledRigidBody(type, position); PhysicsObject physicsObject = new PhysicsObject(body, type); physicsObjects.add(physicsObject); bodyToObjectMap.put(body, physicsObject); return physicsObject; } public void destroyPhysicsObject(PhysicsObject obj) { physicsObjects.remove(obj); bodyToObjectMap.remove(obj.getRigidBody()); physicsWorld.returnToPool(obj.getType(), obj.getRigidBody()); } // Getters for subsystems public RaycastHandler getRaycastHandler() { return raycastHandler; } public ConstraintSystem getConstraintSystem() { return constraintSystem; } public VehicleSystem getVehicleSystem() { return vehicleSystem; } } public abstract class PhysicsObject { protected final RigidBody rigidBody; protected final String type; protected Transform worldTransform; public PhysicsObject(RigidBody rigidBody, String type) { this.rigidBody = rigidBody; this.type = type; this.worldTransform = new Transform(); } public void update() { if (rigidBody.getMotionState() != null) { rigidBody.getMotionState().getWorldTransform(worldTransform); } } public abstract void onCollision(CollisionEvent event); // Getters public RigidBody getRigidBody() { return rigidBody; } public String getType() { return type; } public Transform getWorldTransform() { return worldTransform; } }

This comprehensive JBullet physics simulation guide covers everything from basic setup to advanced features like vehicles, constraints, and performance optimization. The library provides robust physics capabilities suitable for games, simulations, and interactive applications.