[Joode-devs] SF.net SVN: joode:[598] trunk/jbullet

[<t_l...@us...>]

Revision: 598
          http://joode.svn.sourceforge.net/joode/?rev=598&view=rev
Author:   t_larkworthy
Date:     2009-02-05 22:59:39 +0000 (Thu, 05 Feb 2009)

Log Message:
-----------
Humble beginnings of a merge between JBullet and JOODE (and a JPCT binding as I have to reinvent all that anyway).

Probably doesn't work at the moment, which is why I am working in a subfolder.

Hopefully I can eventually get rid of all JOODE's current broken collision library and replace with JBullet. JBullet uses vector math library, so hopefully we might be able to switch to OpenMali for both the collision library and the dynamics functionality (but thats way off yet

Added Paths:
-----------
    trunk/jbullet/JBullet-src/
    trunk/jbullet/JBullet-src/com/
    trunk/jbullet/JBullet-src/com/bulletphysics/
    trunk/jbullet/JBullet-src/com/bulletphysics/BulletGlobals.java
    trunk/jbullet/JBullet-src/com/bulletphysics/BulletStats.java
    trunk/jbullet/JBullet-src/com/bulletphysics/ContactAddedCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/ContactDestroyedCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/ContactProcessedCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3Internal.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3_32.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/BroadphaseInterface.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/BroadphaseNativeType.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/BroadphasePair.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/BroadphaseProxy.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/CollisionAlgorithm.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/CollisionAlgorithmConstructionInfo.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/CollisionFilterGroups.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/DispatchFunc.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/Dispatcher.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/DispatcherInfo.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/HashedOverlappingPairCache.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/OverlapCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/OverlapFilterCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/OverlappingPairCache.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/OverlappingPairCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/SimpleBroadphase.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/SimpleBroadphaseProxy.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/package-info.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/CollisionAlgorithmCreateFunc.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/CollisionConfiguration.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/CollisionDispatcher.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/CollisionFlags.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/CollisionObject.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/CollisionObjectType.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/CollisionWorld.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/CompoundCollisionAlgorithm.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/ConvexConcaveCollisionAlgorithm.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/ConvexConvexAlgorithm.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/ConvexPlaneCollisionAlgorithm.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/ConvexTriangleCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/DefaultCollisionConfiguration.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/DefaultNearCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/EmptyAlgorithm.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/ManifoldResult.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/NearCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/SimulationIslandManager.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/SphereSphereCollisionAlgorithm.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/UnionFind.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/dispatch/package-info.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/ConvexCast.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/ConvexPenetrationDepthSolver.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/DiscreteCollisionDetectorInterface.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/GjkConvexCast.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/GjkEpaPenetrationDepthSolver.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/GjkEpaSolver.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/GjkPairDetector.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/ManifoldPoint.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/PersistentManifold.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/PointCollector.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/SimplexSolverInterface.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/SubsimplexConvexCast.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/TriangleConvexcastCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/TriangleRaycastCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/VoronoiSimplexSolver.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/narrowphase/package-info.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/BU_Simplex1to4.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/BoxShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/BvhSubtreeInfo.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/BvhTriangleMeshShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/CapsuleShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/CapsuleShapeX.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/CapsuleShapeZ.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/CollisionShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/CompoundShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/CompoundShapeChild.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/ConcaveShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/ConeShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/ConeShapeX.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/ConeShapeZ.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/ConvexHullShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/ConvexInternalShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/ConvexShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/CylinderShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/CylinderShapeX.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/CylinderShapeZ.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/IndexedMesh.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/InternalTriangleIndexCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/MinkowskiSumShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/NodeOverlapCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/OptimizedBvh.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/OptimizedBvhNode.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/PolyhedralConvexShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/QuantizedBvhNodes.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/ScalarType.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/ShapeHull.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/SphereShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/StaticPlaneShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/StridingMeshInterface.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/TraversalMode.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/TriangleCallback.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/TriangleIndexVertexArray.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/TriangleMeshShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/TriangleShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/UniformScalingShape.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/VertexData.java
    trunk/jbullet/JBullet-src/com/bulletphysics/collision/shapes/package-info.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/AabbUtil2.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/CProfileIterator.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/CProfileManager.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/CProfileNode.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/Clock.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/DebugDrawModes.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/DefaultMotionState.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/GeometryUtil.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/IDebugDraw.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/MatrixUtil.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/MiscUtil.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/MotionState.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/QuaternionUtil.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/ScalarUtil.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/Transform.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/TransformUtil.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/VectorUtil.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/HullDesc.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/HullFlags.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/HullLibrary.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/HullResult.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/Int3.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/Int4.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/IntRef.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/PHullResult.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/Tri.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/convexhull/package-info.java
    trunk/jbullet/JBullet-src/com/bulletphysics/linearmath/package-info.java
    trunk/jbullet/JBullet-src/com/bulletphysics/package-info.java
    trunk/jbullet/JBullet-src/com/bulletphysics/util/
    trunk/jbullet/JBullet-src/com/bulletphysics/util/ArrayPool.java
    trunk/jbullet/JBullet-src/com/bulletphysics/util/FloatArrayList.java
    trunk/jbullet/JBullet-src/com/bulletphysics/util/IntArrayList.java
    trunk/jbullet/JBullet-src/com/bulletphysics/util/ObjectArrayList.java
    trunk/jbullet/JBullet-src/com/bulletphysics/util/ObjectPool.java
    trunk/jbullet/JBullet-src/com/bulletphysics/util/ObjectStackList.java
    trunk/jbullet/JBullet-src/com/bulletphysics/util/StackList.java
    trunk/jbullet/JBullet-src/com/bulletphysics/util/package-info.java

Added: trunk/jbullet/JBullet-src/com/bulletphysics/BulletGlobals.java
===================================================================
--- trunk/jbullet/JBullet-src/com/bulletphysics/BulletGlobals.java	                        (rev 0)
+++ trunk/jbullet/JBullet-src/com/bulletphysics/BulletGlobals.java	2009-02-05 22:59:39 UTC (rev 598)
@@ -0,0 +1,130 @@
+/*
+ * Java port of Bullet (c) 2008 Martin Dvorak <je...@ad...>
+ *
+ * Bullet Continuous Collision Detection and Physics Library
+ * Copyright (c) 2003-2008 Erwin Coumans  http://www.bulletphysics.com/
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+package com.bulletphysics;
+
+import com.bulletphysics.util.ArrayPool;
+import com.bulletphysics.util.ObjectPool;
+import cz.advel.stack.Stack;
+
+/**
+ * Bullet global settings and constants.
+ * 
+ * @author jezek2
+ */
+public class BulletGlobals {
+	
+	public static final boolean DEBUG = false;
+	
+	public static final float CONVEX_DISTANCE_MARGIN = 0.04f;
+	public static final float FLT_EPSILON = 1.19209290e-07f;
+	public static final float SIMD_EPSILON = FLT_EPSILON;
+	
+	public static final float SIMD_2_PI = 6.283185307179586232f;
+	public static final float SIMD_PI = SIMD_2_PI * 0.5f;
+	public static final float SIMD_HALF_PI = SIMD_2_PI * 0.25f;
+	public static final float SIMD_RADS_PER_DEG = SIMD_2_PI / 360f;
+	public static final float SIMD_DEGS_PER_RAD = 360f / SIMD_2_PI;
+	public static final float SIMD_INFINITY = Float.MAX_VALUE;
+
+	////////////////////////////////////////////////////////////////////////////
+
+	private static ThreadLocal<BulletGlobals> threadLocal = new ThreadLocal<BulletGlobals>() {
+		@Override
+		protected BulletGlobals initialValue() {
+			return new BulletGlobals();
+		}
+	};
+
+	private ContactDestroyedCallback gContactDestroyedCallback;
+	private ContactAddedCallback gContactAddedCallback;
+	private ContactProcessedCallback gContactProcessedCallback;
+
+	private float contactBreakingThreshold = 0.02f;
+	// RigidBody
+	private float deactivationTime = 2f;
+	private boolean disableDeactivation = false;
+	
+	public static ContactAddedCallback getContactAddedCallback() {
+		return threadLocal.get().gContactAddedCallback;
+	}
+
+	public static void setContactAddedCallback(ContactAddedCallback callback) {
+		threadLocal.get().gContactAddedCallback = callback;
+	}
+
+	public static ContactDestroyedCallback getContactDestroyedCallback() {
+		return threadLocal.get().gContactDestroyedCallback;
+	}
+
+	public static void setContactDestroyedCallback(ContactDestroyedCallback callback) {
+		threadLocal.get().gContactDestroyedCallback = callback;
+	}
+
+	public static ContactProcessedCallback getContactProcessedCallback() {
+		return threadLocal.get().gContactProcessedCallback;
+	}
+
+	public static void setContactProcessedCallback(ContactProcessedCallback callback) {
+		threadLocal.get().gContactProcessedCallback = callback;
+	}
+	
+	////////////////////////////////////////////////////////////////////////////
+
+	public static float getContactBreakingThreshold() {
+		return threadLocal.get().contactBreakingThreshold;
+	}
+
+	public static void setContactBreakingThreshold(float threshold) {
+		threadLocal.get().contactBreakingThreshold = threshold;
+	}
+
+	public static float getDeactivationTime() {
+		return threadLocal.get().deactivationTime;
+	}
+
+	public static void setDeactivationTime(float time) {
+		threadLocal.get().deactivationTime = time;
+	}
+
+	public static boolean isDeactivationDisabled() {
+		return threadLocal.get().disableDeactivation;
+	}
+
+	public static void setDeactivationDisabled(boolean disable) {
+		threadLocal.get().disableDeactivation = disable;
+	}
+
+	////////////////////////////////////////////////////////////////////////////
+
+	/**
+	 * Cleans all current thread specific settings and caches.
+	 */
+	public static void cleanCurrentThread() {
+		threadLocal.remove();
+		Stack.libraryCleanCurrentThread();
+		ObjectPool.cleanCurrentThread();
+		ArrayPool.cleanCurrentThread();
+	}
+
+}

Added: trunk/jbullet/JBullet-src/com/bulletphysics/BulletStats.java
===================================================================
--- trunk/jbullet/JBullet-src/com/bulletphysics/BulletStats.java	                        (rev 0)
+++ trunk/jbullet/JBullet-src/com/bulletphysics/BulletStats.java	2009-02-05 22:59:39 UTC (rev 598)
@@ -0,0 +1,106 @@
+/*
+ * Java port of Bullet (c) 2008 Martin Dvorak <je...@ad...>
+ *
+ * Bullet Continuous Collision Detection and Physics Library
+ * Copyright (c) 2003-2008 Erwin Coumans  http://www.bulletphysics.com/
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+package com.bulletphysics;
+
+import com.bulletphysics.linearmath.CProfileManager;
+import com.bulletphysics.linearmath.Clock;
+import javax.vecmath.Vector3f;
+
+/**
+ * Bullet statistics and profile support.
+ * 
+ * @author jezek2
+ */
+public class BulletStats {
+	
+	public static int gTotalContactPoints;
+	
+	// GjkPairDetector
+	// temp globals, to improve GJK/EPA/penetration calculations
+	public static int gNumDeepPenetrationChecks = 0;
+	public static int gNumGjkChecks = 0;
+	public static int gNumSplitImpulseRecoveries = 0;
+	
+	public static int gNumAlignedAllocs;
+	public static int gNumAlignedFree;
+	public static int gTotalBytesAlignedAllocs;	
+	
+	public static int gPickingConstraintId = 0;
+	public static final Vector3f gOldPickingPos = new Vector3f();
+	public static float gOldPickingDist = 0.f;
+	
+	public static int gOverlappingPairs = 0;
+	public static int gRemovePairs = 0;
+	public static int gAddedPairs = 0;
+	public static int gFindPairs = 0;
+	
+	public static final Clock gProfileClock = new Clock();
+
+	// JAVA NOTE: added for statistics in applet demo
+	public static long stepSimulationTime;
+	public static long updateTime;
+	
+	private static boolean enableProfile = false;
+	
+	////////////////////////////////////////////////////////////////////////////
+	
+	public static boolean isProfileEnabled() {
+		return enableProfile;
+	}
+
+	public static void setProfileEnabled(boolean b) {
+		enableProfile = b;
+	}
+	
+	public static long profileGetTicks() {
+		long ticks = gProfileClock.getTimeMicroseconds();
+		return ticks;
+	}
+
+	public static float profileGetTickRate() {
+		//return 1000000f;
+		return 1000f;
+	}
+	
+	/**
+	 * Pushes profile node. Use try/finally block to call {@link #popProfile} method.
+	 * 
+	 * @param name must be {@link String#intern interned} String (not needed for String literals)
+	 */
+	public static void pushProfile(String name) {
+		if (enableProfile) {
+			CProfileManager.startProfile(name);
+		}
+	}
+	
+	/**
+	 * Pops profile node.
+	 */
+	public static void popProfile() {
+		if (enableProfile) {
+			CProfileManager.stopProfile();
+		}
+	}
+	
+}

Added: trunk/jbullet/JBullet-src/com/bulletphysics/ContactAddedCallback.java
===================================================================
--- trunk/jbullet/JBullet-src/com/bulletphysics/ContactAddedCallback.java	                        (rev 0)
+++ trunk/jbullet/JBullet-src/com/bulletphysics/ContactAddedCallback.java	2009-02-05 22:59:39 UTC (rev 598)
@@ -0,0 +1,41 @@
+/*
+ * Java port of Bullet (c) 2008 Martin Dvorak <je...@ad...>
+ *
+ * Bullet Continuous Collision Detection and Physics Library
+ * Copyright (c) 2003-2008 Erwin Coumans  http://www.bulletphysics.com/
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+package com.bulletphysics;
+
+import com.bulletphysics.collision.dispatch.CollisionFlags;
+import com.bulletphysics.collision.dispatch.CollisionObject;
+import com.bulletphysics.collision.narrowphase.ManifoldPoint;
+
+/**
+ * Called when contact has been created between two collision objects. At least
+ * one of object must have {@link CollisionFlags#CUSTOM_MATERIAL_CALLBACK} flag set.
+ * 
+ * @see BulletGlobals#setContactAddedCallback
+ * @author jezek2
+ */
+public interface ContactAddedCallback {
+
+	public boolean contactAdded(ManifoldPoint cp, CollisionObject colObj0, int partId0, int index0, CollisionObject colObj1, int partId1, int index1);
+	
+}

Added: trunk/jbullet/JBullet-src/com/bulletphysics/ContactDestroyedCallback.java
===================================================================
--- trunk/jbullet/JBullet-src/com/bulletphysics/ContactDestroyedCallback.java	                        (rev 0)
+++ trunk/jbullet/JBullet-src/com/bulletphysics/ContactDestroyedCallback.java	2009-02-05 22:59:39 UTC (rev 598)
@@ -0,0 +1,36 @@
+/*
+ * Java port of Bullet (c) 2008 Martin Dvorak <je...@ad...>
+ *
+ * Bullet Continuous Collision Detection and Physics Library
+ * Copyright (c) 2003-2008 Erwin Coumans  http://www.bulletphysics.com/
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+package com.bulletphysics;
+
+/**
+ * Called when contact has been destroyed between two collision objects.
+ *
+ * @see BulletGlobals#setContactDestroyedCallback
+ * @author jezek2
+ */
+public interface ContactDestroyedCallback {
+
+	public boolean contactDestroyed(Object userPersistentData);
+	
+}

Added: trunk/jbullet/JBullet-src/com/bulletphysics/ContactProcessedCallback.java
===================================================================
--- trunk/jbullet/JBullet-src/com/bulletphysics/ContactProcessedCallback.java	                        (rev 0)
+++ trunk/jbullet/JBullet-src/com/bulletphysics/ContactProcessedCallback.java	2009-02-05 22:59:39 UTC (rev 598)
@@ -0,0 +1,38 @@
+/*
+ * Java port of Bullet (c) 2008 Martin Dvorak <je...@ad...>
+ *
+ * Bullet Continuous Collision Detection and Physics Library
+ * Copyright (c) 2003-2008 Erwin Coumans  http://www.bulletphysics.com/
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+package com.bulletphysics;
+
+import com.bulletphysics.collision.narrowphase.ManifoldPoint;
+
+/**
+ * Called when existing contact between two collision objects has been processed.
+ * 
+ * @see BulletGlobals#setContactProcessedCallback
+ * @author jezek2
+ */
+public interface ContactProcessedCallback {
+	
+	public boolean contactProcessed(ManifoldPoint cp, Object body0, Object body1);
+
+}

Added: trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3.java
===================================================================
--- trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3.java	                        (rev 0)
+++ trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3.java	2009-02-05 22:59:39 UTC (rev 598)
@@ -0,0 +1,167 @@
+/*
+ * Java port of Bullet (c) 2008 Martin Dvorak <je...@ad...>
+ * 
+ * AxisSweep3
+ * Copyright (c) 2006 Simon Hobbs
+ *
+ * Bullet Continuous Collision Detection and Physics Library
+ * Copyright (c) 2003-2008 Erwin Coumans  http://www.bulletphysics.com/
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+package com.bulletphysics.collision.broadphase;
+
+import javax.vecmath.Vector3f;
+
+/**
+ * AxisSweep3 is an efficient implementation of the 3D axis sweep and prune broadphase.<p>
+ * 
+ * It uses arrays rather then lists for storage of the 3 axis. Also it operates using 16 bit
+ * integer coordinates instead of floats. For large worlds and many objects, use {@link AxisSweep3_32}
+ * instead. AxisSweep3_32 has higher precision and allows more than 16384 objects at the cost
+ * of more memory and bit of performance.
+ *
+ * @author jezek2
+ */
+public class AxisSweep3 extends AxisSweep3Internal {
+
+	public AxisSweep3(Vector3f worldAabbMin, Vector3f worldAabbMax) {
+		this(worldAabbMin, worldAabbMax, 16384, null);
+	}
+
+	public AxisSweep3(Vector3f worldAabbMin, Vector3f worldAabbMax, int maxHandles) {
+		this(worldAabbMin, worldAabbMax, maxHandles, null);
+	}
+	
+	public AxisSweep3(Vector3f worldAabbMin, Vector3f worldAabbMax, int maxHandles/* = 16384*/, OverlappingPairCache pairCache/* = 0*/) {
+		super(worldAabbMin, worldAabbMax, 0xfffe, 0xffff, maxHandles, pairCache);
+		// 1 handle is reserved as sentinel
+		assert (maxHandles > 1 && maxHandles < 32767);
+	}
+	
+	@Override
+	protected EdgeArray createEdgeArray(int size) {
+		return new EdgeArrayImpl(size);
+	}
+
+	@Override
+	protected Handle createHandle() {
+		return new HandleImpl();
+	}
+	
+	protected int getMask() {
+		return 0xFFFF;
+	}
+	
+	protected static class EdgeArrayImpl extends EdgeArray {
+		private short[] pos;
+		private short[] handle;
+
+		public EdgeArrayImpl(int size) {
+			pos = new short[size];
+			handle = new short[size];
+		}
+		
+		@Override
+		public void swap(int idx1, int idx2) {
+			short tmpPos = pos[idx1];
+			short tmpHandle = handle[idx1];
+			
+			pos[idx1] = pos[idx2];
+			handle[idx1] = handle[idx2];
+			
+			pos[idx2] = tmpPos;
+			handle[idx2] = tmpHandle;
+		}
+		
+		@Override
+		public void set(int dest, int src) {
+			pos[dest] = pos[src];
+			handle[dest] = handle[src];
+		}
+		
+		@Override
+		public int getPos(int index) {
+			return pos[index] & 0xFFFF;
+		}
+
+		@Override
+		public void setPos(int index, int value) {
+			pos[index] = (short)value;
+		}
+
+		@Override
+		public int getHandle(int index) {
+			return handle[index] & 0xFFFF;
+		}
+
+		@Override
+		public void setHandle(int index, int value) {
+			handle[index] = (short)value;
+		}
+	}
+	
+	protected static class HandleImpl extends Handle {
+		private short minEdges0;
+		private short minEdges1;
+		private short minEdges2;
+
+		private short maxEdges0;
+		private short maxEdges1;
+		private short maxEdges2;
+		
+		@Override
+		public int getMinEdges(int edgeIndex) {
+			switch (edgeIndex) {
+				default:
+				case 0: return minEdges0 & 0xFFFF;
+				case 1: return minEdges1 & 0xFFFF;
+				case 2: return minEdges2 & 0xFFFF;
+			}
+		}
+		
+		@Override
+		public void setMinEdges(int edgeIndex, int value) {
+			switch (edgeIndex) {
+				case 0: minEdges0 = (short)value; break;
+				case 1: minEdges1 = (short)value; break;
+				case 2: minEdges2 = (short)value; break;
+			}
+		}
+		
+		@Override
+		public int getMaxEdges(int edgeIndex) {
+			switch (edgeIndex) {
+				default:
+				case 0: return maxEdges0 & 0xFFFF;
+				case 1: return maxEdges1 & 0xFFFF;
+				case 2: return maxEdges2 & 0xFFFF;
+			}
+		}
+		
+		@Override
+		public void setMaxEdges(int edgeIndex, int value) {
+			switch (edgeIndex) {
+				case 0: maxEdges0 = (short)value; break;
+				case 1: maxEdges1 = (short)value; break;
+				case 2: maxEdges2 = (short)value; break;
+			}
+		}
+	}
+
+}

Added: trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3Internal.java
===================================================================
--- trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3Internal.java	                        (rev 0)
+++ trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3Internal.java	2009-02-05 22:59:39 UTC (rev 598)
@@ -0,0 +1,705 @@
+/*
+ * Java port of Bullet (c) 2008 Martin Dvorak <je...@ad...>
+ * 
+ * AxisSweep3
+ * Copyright (c) 2006 Simon Hobbs
+ *
+ * Bullet Continuous Collision Detection and Physics Library
+ * Copyright (c) 2003-2008 Erwin Coumans  http://www.bulletphysics.com/
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+package com.bulletphysics.collision.broadphase;
+
+import com.bulletphysics.BulletStats;
+import com.bulletphysics.collision.broadphase.AxisSweep3Internal.Handle;
+import com.bulletphysics.linearmath.MiscUtil;
+import com.bulletphysics.linearmath.VectorUtil;
+import cz.advel.stack.Stack;
+import java.util.List;
+import javax.vecmath.Vector3f;
+
+/**
+ * AxisSweep3Internal is an internal base class that implements sweep and prune.
+ * Use concrete implementation {@link AxisSweep3} or {@link AxisSweep3_32}.
+ * 
+ * @author jezek2
+ */
+public abstract class AxisSweep3Internal implements BroadphaseInterface {
+
+	protected int bpHandleMask;
+	protected int handleSentinel;
+	
+	protected final Vector3f worldAabbMin = new Vector3f(); // overall system bounds
+	protected final Vector3f worldAabbMax = new Vector3f(); // overall system bounds
+
+	protected final Vector3f quantize = new Vector3f();     // scaling factor for quantization
+
+	protected int numHandles;                               // number of active handles
+	protected int maxHandles;                               // max number of handles
+	protected Handle[] pHandles;                            // handles pool
+	protected int firstFreeHandle;		                    // free handles list
+
+	protected EdgeArray[] pEdges = new EdgeArray[3];      // edge arrays for the 3 axes (each array has m_maxHandles * 2 + 2 sentinel entries)
+
+	protected OverlappingPairCache pairCache;
+	
+	// OverlappingPairCallback is an additional optional user callback for adding/removing overlapping pairs, similar interface to OverlappingPairCache.
+	protected OverlappingPairCallback userPairCallback = null;
+	
+	protected boolean ownsPairCache = false;
+
+	protected int invalidPair = 0;
+	
+	// JAVA NOTE: added
+	protected int mask;
+	
+	AxisSweep3Internal(Vector3f worldAabbMin, Vector3f worldAabbMax, int handleMask, int handleSentinel, int userMaxHandles/* = 16384*/, OverlappingPairCache pairCache/*=0*/) {
+		this.bpHandleMask = handleMask;
+		this.handleSentinel = handleSentinel;
+		this.pairCache = pairCache;
+
+		int maxHandles = userMaxHandles + 1; // need to add one sentinel handle
+
+		if (this.pairCache == null) {
+			this.pairCache = new HashedOverlappingPairCache();
+			ownsPairCache = true;
+		}
+
+		//assert(bounds.HasVolume());
+
+		// init bounds
+		this.worldAabbMin.set(worldAabbMin);
+		this.worldAabbMax.set(worldAabbMax);
+
+		Vector3f aabbSize = Stack.alloc(Vector3f.class);
+		aabbSize.sub(this.worldAabbMax, this.worldAabbMin);
+
+		int maxInt = this.handleSentinel;
+
+		quantize.set(maxInt / aabbSize.x, maxInt / aabbSize.y, maxInt / aabbSize.z);
+
+		// allocate handles buffer and put all handles on free list
+		pHandles = new Handle[maxHandles];
+		for (int i=0; i<maxHandles; i++) {
+			pHandles[i] = createHandle();
+		}
+		this.maxHandles = maxHandles;
+		this.numHandles = 0;
+
+		// handle 0 is reserved as the null index, and is also used as the sentinel
+		firstFreeHandle = 1;
+		{
+			for (int i=firstFreeHandle; i<maxHandles; i++) {
+				pHandles[i].setNextFree(i+1);
+			}
+			pHandles[maxHandles - 1].setNextFree(0);
+		}
+
+		{
+			// allocate edge buffers
+			for (int i=0; i<3; i++) {
+				pEdges[i] = createEdgeArray(maxHandles*2);
+			}
+		}
+		//removed overlap management
+
+		// make boundary sentinels
+
+		pHandles[0].clientObject = null;
+
+		for (int axis = 0; axis < 3; axis++) {
+			pHandles[0].setMinEdges(axis, 0);
+			pHandles[0].setMaxEdges(axis, 1);
+
+			pEdges[axis].setPos(0, 0);
+			pEdges[axis].setHandle(0, 0);
+			pEdges[axis].setPos(1, handleSentinel);
+			pEdges[axis].setHandle(1, 0);
+			//#ifdef DEBUG_BROADPHASE
+			//debugPrintAxis(axis);
+			//#endif //DEBUG_BROADPHASE
+		}
+		
+		// JAVA NOTE: added
+		mask = getMask();
+	}
+
+	// allocation/deallocation
+	protected int allocHandle() {
+		assert (firstFreeHandle != 0);
+
+		int handle = firstFreeHandle;
+		firstFreeHandle = getHandle(handle).getNextFree();
+		numHandles++;
+
+		return handle;
+	}
+	
+	protected void freeHandle(int handle) {
+		assert (handle > 0 && handle < maxHandles);
+
+		getHandle(handle).setNextFree(firstFreeHandle);
+		firstFreeHandle = handle;
+
+		numHandles--;
+	}
+	
+	protected boolean testOverlap(int ignoreAxis, Handle pHandleA, Handle pHandleB) {
+		// optimization 1: check the array index (memory address), instead of the m_pos
+
+		for (int axis=0; axis<3; axis++) {
+			if (axis != ignoreAxis) {
+				if (pHandleA.getMaxEdges(axis) < pHandleB.getMinEdges(axis) ||
+						pHandleB.getMaxEdges(axis) < pHandleA.getMinEdges(axis)) {
+					return false;
+				}
+			}
+		}
+
+		//optimization 2: only 2 axis need to be tested (conflicts with 'delayed removal' optimization)
+
+		/*for (int axis = 0; axis < 3; axis++)
+		{
+		if (m_pEdges[axis][pHandleA->m_maxEdges[axis]].m_pos < m_pEdges[axis][pHandleB->m_minEdges[axis]].m_pos ||
+		m_pEdges[axis][pHandleB->m_maxEdges[axis]].m_pos < m_pEdges[axis][pHandleA->m_minEdges[axis]].m_pos)
+		{
+		return false;
+		}
+		}
+		*/
+
+		return true;
+	}
+	
+	//#ifdef DEBUG_BROADPHASE
+	//void debugPrintAxis(int axis,bool checkCardinality=true);
+	//#endif //DEBUG_BROADPHASE
+
+	protected void quantize(int[] out, Vector3f point, int isMax) {
+		Vector3f clampedPoint = Stack.alloc(point);
+
+		VectorUtil.setMax(clampedPoint, worldAabbMin);
+		VectorUtil.setMin(clampedPoint, worldAabbMax);
+
+		Vector3f v = Stack.alloc(Vector3f.class);
+		v.sub(clampedPoint, worldAabbMin);
+		VectorUtil.mul(v, v, quantize);
+
+		out[0] = (((int)v.x & bpHandleMask) | isMax) & mask;
+		out[1] = (((int)v.y & bpHandleMask) | isMax) & mask;
+		out[2] = (((int)v.z & bpHandleMask) | isMax) & mask;
+	}
+
+	// sorting a min edge downwards can only ever *add* overlaps
+	protected void sortMinDown(int axis, int edge, Dispatcher dispatcher, boolean updateOverlaps) {
+		EdgeArray edgeArray = pEdges[axis];
+		int pEdge_idx = edge;
+		int pPrev_idx = pEdge_idx - 1;
+
+		Handle pHandleEdge = getHandle(edgeArray.getHandle(pEdge_idx));
+
+		while (edgeArray.getPos(pEdge_idx) < edgeArray.getPos(pPrev_idx)) {
+			Handle pHandlePrev = getHandle(edgeArray.getHandle(pPrev_idx));
+
+			if (edgeArray.isMax(pPrev_idx) != 0) {
+				// if previous edge is a maximum check the bounds and add an overlap if necessary
+				if (updateOverlaps && testOverlap(axis, pHandleEdge, pHandlePrev)) {
+					pairCache.addOverlappingPair(pHandleEdge, pHandlePrev);
+					if (userPairCallback != null) {
+						userPairCallback.addOverlappingPair(pHandleEdge, pHandlePrev);
+						//AddOverlap(pEdge->m_handle, pPrev->m_handle);
+					}
+				}
+
+				// update edge reference in other handle
+				pHandlePrev.incMaxEdges(axis);
+			}
+			else {
+				pHandlePrev.incMinEdges(axis);
+			}
+			pHandleEdge.decMinEdges(axis);
+
+			// swap the edges
+			edgeArray.swap(pEdge_idx, pPrev_idx);
+
+			// decrement
+			pEdge_idx--;
+			pPrev_idx--;
+		}
+
+		//#ifdef DEBUG_BROADPHASE
+		//debugPrintAxis(axis);
+		//#endif //DEBUG_BROADPHASE
+	}
+	
+	// sorting a min edge upwards can only ever *remove* overlaps
+	protected void sortMinUp(int axis, int edge, Dispatcher dispatcher, boolean updateOverlaps) {
+		EdgeArray edgeArray = pEdges[axis];
+		int pEdge_idx = edge;
+		int pNext_idx = pEdge_idx + 1;
+		Handle pHandleEdge = getHandle(edgeArray.getHandle(pEdge_idx));
+
+		while (edgeArray.getHandle(pNext_idx) != 0 && (edgeArray.getPos(pEdge_idx) >= edgeArray.getPos(pNext_idx))) {
+			Handle pHandleNext = getHandle(edgeArray.getHandle(pNext_idx));
+
+			if (edgeArray.isMax(pNext_idx) != 0) {
+				// if next edge is maximum remove any overlap between the two handles
+				if (updateOverlaps) {
+					Handle handle0 = getHandle(edgeArray.getHandle(pEdge_idx));
+					Handle handle1 = getHandle(edgeArray.getHandle(pNext_idx));
+
+					pairCache.removeOverlappingPair(handle0, handle1, dispatcher);
+					if (userPairCallback != null) {
+						userPairCallback.removeOverlappingPair(handle0, handle1, dispatcher);
+					}
+				}
+
+				// update edge reference in other handle
+				pHandleNext.decMaxEdges(axis);
+			}
+			else {
+				pHandleNext.decMinEdges(axis);
+			}
+			pHandleEdge.incMinEdges(axis);
+
+			// swap the edges
+			edgeArray.swap(pEdge_idx, pNext_idx);
+
+			// increment
+			pEdge_idx++;
+			pNext_idx++;
+		}
+	}
+	
+	// sorting a max edge downwards can only ever *remove* overlaps
+	protected void sortMaxDown(int axis, int edge, Dispatcher dispatcher, boolean updateOverlaps) {
+		EdgeArray edgeArray = pEdges[axis];
+		int pEdge_idx = edge;
+		int pPrev_idx = pEdge_idx - 1;
+		Handle pHandleEdge = getHandle(edgeArray.getHandle(pEdge_idx));
+
+		while (edgeArray.getPos(pEdge_idx) < edgeArray.getPos(pPrev_idx)) {
+			Handle pHandlePrev = getHandle(edgeArray.getHandle(pPrev_idx));
+
+			if (edgeArray.isMax(pPrev_idx) == 0) {
+				// if previous edge was a minimum remove any overlap between the two handles
+				if (updateOverlaps) {
+					// this is done during the overlappingpairarray iteration/narrowphase collision
+					Handle handle0 = getHandle(edgeArray.getHandle(pEdge_idx));
+					Handle handle1 = getHandle(edgeArray.getHandle(pPrev_idx));
+					pairCache.removeOverlappingPair(handle0, handle1, dispatcher);
+					if (userPairCallback != null) {
+						userPairCallback.removeOverlappingPair(handle0, handle1, dispatcher);
+					}
+				}
+
+				// update edge reference in other handle
+				pHandlePrev.incMinEdges(axis);
+			}
+			else {
+				pHandlePrev.incMaxEdges(axis);
+			}
+			pHandleEdge.decMaxEdges(axis);
+
+			// swap the edges
+			edgeArray.swap(pEdge_idx, pPrev_idx);
+
+			// decrement
+			pEdge_idx--;
+			pPrev_idx--;
+		}
+
+		//#ifdef DEBUG_BROADPHASE
+		//debugPrintAxis(axis);
+		//#endif //DEBUG_BROADPHASE
+	}
+	
+	// sorting a max edge upwards can only ever *add* overlaps
+	protected void sortMaxUp(int axis, int edge, Dispatcher dispatcher, boolean updateOverlaps) {
+		EdgeArray edgeArray = pEdges[axis];
+		int pEdge_idx = edge;
+		int pNext_idx = pEdge_idx + 1;
+		Handle pHandleEdge = getHandle(edgeArray.getHandle(pEdge_idx));
+
+		while (edgeArray.getHandle(pNext_idx) != 0 && (edgeArray.getPos(pEdge_idx) >= edgeArray.getPos(pNext_idx))) {
+			Handle pHandleNext = getHandle(edgeArray.getHandle(pNext_idx));
+
+			if (edgeArray.isMax(pNext_idx) == 0) {
+				// if next edge is a minimum check the bounds and add an overlap if necessary
+				if (updateOverlaps && testOverlap(axis, pHandleEdge, pHandleNext)) {
+					Handle handle0 = getHandle(edgeArray.getHandle(pEdge_idx));
+					Handle handle1 = getHandle(edgeArray.getHandle(pNext_idx));
+					pairCache.addOverlappingPair(handle0, handle1);
+					if (userPairCallback != null) {
+						userPairCallback.addOverlappingPair(handle0, handle1);
+					}
+				}
+
+				// update edge reference in other handle
+				pHandleNext.decMinEdges(axis);
+			}
+			else {
+				pHandleNext.decMaxEdges(axis);
+			}
+			pHandleEdge.incMaxEdges(axis);
+
+			// swap the edges
+			edgeArray.swap(pEdge_idx, pNext_idx);
+
+			// increment
+			pEdge_idx++;
+			pNext_idx++;
+		}
+	}
+	
+	public int getNumHandles() {
+		return numHandles;
+	}
+
+	@Override
+	public void calculateOverlappingPairs(Dispatcher dispatcher) {
+		if (pairCache.hasDeferredRemoval()) {
+			List<BroadphasePair> overlappingPairArray = pairCache.getOverlappingPairArray();
+
+			// perform a sort, to find duplicates and to sort 'invalid' pairs to the end
+			MiscUtil.quickSort(overlappingPairArray, BroadphasePair.broadphasePairSortPredicate);
+
+			MiscUtil.resize(overlappingPairArray, overlappingPairArray.size() - invalidPair, BroadphasePair.class);
+			invalidPair = 0;
+
+			int i;
+
+			BroadphasePair previousPair = new BroadphasePair();
+			previousPair.pProxy0 = null;
+			previousPair.pProxy1 = null;
+			previousPair.algorithm = null;
+
+			for (i=0; i<overlappingPairArray.size(); i++) {
+				BroadphasePair pair = overlappingPairArray.get(i);
+
+				boolean isDuplicate = (pair.equals(previousPair));
+
+				previousPair.set(pair);
+
+				boolean needsRemoval = false;
+
+				if (!isDuplicate) {
+					boolean hasOverlap = testAabbOverlap(pair.pProxy0, pair.pProxy1);
+
+					if (hasOverlap) {
+						needsRemoval = false;//callback->processOverlap(pair);
+					}
+					else {
+						needsRemoval = true;
+					}
+				}
+				else {
+					// remove duplicate
+					needsRemoval = true;
+					// should have no algorithm
+					assert (pair.algorithm == null);
+				}
+
+				if (needsRemoval) {
+					pairCache.cleanOverlappingPair(pair, dispatcher);
+
+					//		m_overlappingPairArray.swap(i,m_overlappingPairArray.size()-1);
+					//		m_overlappingPairArray.pop_back();
+					pair.pProxy0 = null;
+					pair.pProxy1 = null;
+					invalidPair++;
+					BulletStats.gOverlappingPairs--;
+				}
+
+			}
+
+			// if you don't like to skip the invalid pairs in the array, execute following code:
+			//#define CLEAN_INVALID_PAIRS 1
+			//#ifdef CLEAN_INVALID_PAIRS
+
+			// perform a sort, to sort 'invalid' pairs to the end
+			MiscUtil.quickSort(overlappingPairArray, BroadphasePair.broadphasePairSortPredicate);
+
+			MiscUtil.resize(overlappingPairArray, overlappingPairArray.size() - invalidPair, BroadphasePair.class);
+			invalidPair = 0;
+			//#endif//CLEAN_INVALID_PAIRS
+
+			//printf("overlappingPairArray.size()=%d\n",overlappingPairArray.size());
+		}
+	}
+	
+	public int addHandle(Vector3f aabbMin, Vector3f aabbMax, Object pOwner, short collisionFilterGroup, short collisionFilterMask, Dispatcher dispatcher, Object multiSapProxy) {
+		// quantize the bounds
+		int[] min = new int[3], max = new int[3];
+		quantize(min, aabbMin, 0);
+		quantize(max, aabbMax, 1);
+
+		// allocate a handle
+		int handle = allocHandle();
+
+		Handle pHandle = getHandle(handle);
+
+		pHandle.uniqueId = handle;
+		//pHandle->m_pOverlaps = 0;
+		pHandle.clientObject = pOwner;
+		pHandle.collisionFilterGroup = collisionFilterGroup;
+		pHandle.collisionFilterMask = collisionFilterMask;
+		pHandle.multiSapParentProxy = multiSapProxy;
+
+		// compute current limit of edge arrays
+		int limit = numHandles * 2;
+
+		// insert new edges just inside the max boundary edge
+		for (int axis = 0; axis < 3; axis++) {
+			pHandles[0].setMaxEdges(axis, pHandles[0].getMaxEdges(axis) + 2);
+
+			pEdges[axis].set(limit + 1, limit - 1);
+
+			pEdges[axis].setPos(limit - 1, min[axis]);
+			pEdges[axis].setHandle(limit - 1, handle);
+
+			pEdges[axis].setPos(limit, max[axis]);
+			pEdges[axis].setHandle(limit, handle);
+
+			pHandle.setMinEdges(axis, limit - 1);
+			pHandle.setMaxEdges(axis, limit);
+		}
+
+		// now sort the new edges to their correct position
+		sortMinDown(0, pHandle.getMinEdges(0), dispatcher, false);
+		sortMaxDown(0, pHandle.getMaxEdges(0), dispatcher, false);
+		sortMinDown(1, pHandle.getMinEdges(1), dispatcher, false);
+		sortMaxDown(1, pHandle.getMaxEdges(1), dispatcher, false);
+		sortMinDown(2, pHandle.getMinEdges(2), dispatcher, true);
+		sortMaxDown(2, pHandle.getMaxEdges(2), dispatcher, true);
+
+		return handle;
+	}
+	
+	public void removeHandle(int handle, Dispatcher dispatcher) {
+		Handle pHandle = getHandle(handle);
+
+		// explicitly remove the pairs containing the proxy
+		// we could do it also in the sortMinUp (passing true)
+		// todo: compare performance
+		if (!pairCache.hasDeferredRemoval()) {
+			pairCache.removeOverlappingPairsContainingProxy(pHandle, dispatcher);
+		}
+
+		// compute current limit of edge arrays
+		int limit = numHandles * 2;
+
+		int axis;
+
+		for (axis = 0; axis < 3; axis++) {
+			pHandles[0].setMaxEdges(axis, pHandles[0].getMaxEdges(axis) - 2);
+		}
+
+		// remove the edges by sorting them up to the end of the list
+		for (axis = 0; axis < 3; axis++) {
+			EdgeArray pEdges = this.pEdges[axis];
+			int max = pHandle.getMaxEdges(axis);
+			pEdges.setPos(max, handleSentinel);
+
+			sortMaxUp(axis, max, dispatcher, false);
+
+			int i = pHandle.getMinEdges(axis);
+			pEdges.setPos(i, handleSentinel);
+
+			sortMinUp(axis, i, dispatcher, false);
+
+			pEdges.setHandle(limit - 1, 0);
+			pEdges.setPos(limit - 1, handleSentinel);
+
+			//#ifdef DEBUG_BROADPHASE
+			//debugPrintAxis(axis,false);
+			//#endif //DEBUG_BROADPHASE
+		}
+
+		// free the handle
+		freeHandle(handle);
+	}
+	
+	public void updateHandle(int handle, Vector3f aabbMin, Vector3f aabbMax, Dispatcher dispatcher) {
+		Handle pHandle = getHandle(handle);
+
+		// quantize the new bounds
+		int[] min = new int[3], max = new int[3];
+		quantize(min, aabbMin, 0);
+		quantize(max, aabbMax, 1);
+
+		// update changed edges
+		for (int axis = 0; axis < 3; axis++) {
+			int emin = pHandle.getMinEdges(axis);
+			int emax = pHandle.getMaxEdges(axis);
+
+			int dmin = (int) min[axis] - (int) pEdges[axis].getPos(emin);
+			int dmax = (int) max[axis] - (int) pEdges[axis].getPos(emax);
+
+			pEdges[axis].setPos(emin, min[axis]);
+			pEdges[axis].setPos(emax, max[axis]);
+
+			// expand (only adds overlaps)
+			if (dmin < 0) {
+				sortMinDown(axis, emin, dispatcher, true);
+			}
+			if (dmax > 0) {
+				sortMaxUp(axis, emax, dispatcher, true); // shrink (only removes overlaps)
+			}
+			if (dmin > 0) {
+				sortMinUp(axis, emin, dispatcher, true);
+			}
+			if (dmax < 0) {
+				sortMaxDown(axis, emax, dispatcher, true);
+			}
+				
+			//#ifdef DEBUG_BROADPHASE
+			//debugPrintAxis(axis);
+			//#endif //DEBUG_BROADPHASE
+		}
+	}
+	
+	public Handle getHandle(int index) {
+		return pHandles[index];
+	}
+	
+	//public void processAllOverlappingPairs(OverlapCallback callback) {
+	//}
+	
+	@Override
+	public BroadphaseProxy createProxy(Vector3f aabbMin, Vector3f aabbMax, BroadphaseNativeType shapeType, Object userPtr, short collisionFilterGroup, short collisionFilterMask, Dispatcher dispatcher, Object multiSapProxy) {
+		int handleId = addHandle(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask, dispatcher, multiSapProxy);
+
+		Handle handle = getHandle(handleId);
+
+		return handle;
+	}
+	
+	@Override
+	public void destroyProxy(BroadphaseProxy proxy, Dispatcher dispatcher) {
+		Handle handle = (Handle)proxy;
+		removeHandle(handle.uniqueId, dispatcher);
+	}
+
+	@Override
+	public void setAabb(BroadphaseProxy proxy, Vector3f aabbMin, Vector3f aabbMax, Dispatcher dispatcher) {
+		Handle handle = (Handle) proxy;
+		updateHandle(handle.uniqueId, aabbMin, aabbMax, dispatcher);
+	}
+	
+	public boolean testAabbOverlap(BroadphaseProxy proxy0, BroadphaseProxy proxy1) {
+		Handle pHandleA = (Handle)proxy0;
+		Handle pHandleB = (Handle)proxy1;
+
+		// optimization 1: check the array index (memory address), instead of the m_pos
+
+		for (int axis = 0; axis < 3; axis++) {
+			if (pHandleA.getMaxEdges(axis) < pHandleB.getMinEdges(axis) ||
+					pHandleB.getMaxEdges(axis) < pHandleA.getMinEdges(axis)) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	@Override
+	public OverlappingPairCache getOverlappingPairCache() {
+		return pairCache;
+	}
+
+	public void setOverlappingPairUserCallback(OverlappingPairCallback pairCallback) {
+		userPairCallback = pairCallback;
+	}
+	
+	public OverlappingPairCallback getOverlappingPairUserCallback() {
+		return userPairCallback;
+	}
+	
+	// getAabb returns the axis aligned bounding box in the 'global' coordinate frame
+	// will add some transform later
+	@Override
+	public void getBroadphaseAabb(Vector3f aabbMin, Vector3f aabbMax) {
+		aabbMin.set(worldAabbMin);
+		aabbMax.set(worldAabbMax);
+	}
+
+	@Override
+	public void printStats() {
+		/*
+		printf("btAxisSweep3.h\n");
+		printf("numHandles = %d, maxHandles = %d\n",m_numHandles,m_maxHandles);
+		printf("aabbMin=%f,%f,%f,aabbMax=%f,%f,%f\n",m_worldAabbMin.getX(),m_worldAabbMin.getY(),m_worldAabbMin.getZ(),
+		m_worldAabbMax.getX(),m_worldAabbMax.getY(),m_worldAabbMax.getZ());
+		*/
+	}
+	
+	////////////////////////////////////////////////////////////////////////////
+	
+	protected abstract EdgeArray createEdgeArray(int size);
+	protected abstract Handle createHandle();
+	protected abstract int getMask();
+	
+	protected static abstract class EdgeArray {
+		public abstract void swap(int idx1, int idx2);
+		public abstract void set(int dest, int src);
+		
+		public abstract int getPos(int index);
+		public abstract void setPos(int index, int value);
+
+		public abstract int getHandle(int index);
+		public abstract void setHandle(int index, int value);
+		
+		public int isMax(int offset) {
+			return (getPos(offset) & 1);
+		}
+	}
+	
+	protected static abstract class Handle extends BroadphaseProxy {
+		public abstract int getMinEdges(int edgeIndex);
+		public abstract void setMinEdges(int edgeIndex, int value);
+		
+		public abstract int getMaxEdges(int edgeIndex);
+		public abstract void setMaxEdges(int edgeIndex, int value);
+
+		public void incMinEdges(int edgeIndex) {
+			setMinEdges(edgeIndex, getMinEdges(edgeIndex)+1);
+		}
+
+		public void incMaxEdges(int edgeIndex) {
+			setMaxEdges(edgeIndex, getMaxEdges(edgeIndex)+1);
+		}
+
+		public void decMinEdges(int edgeIndex) {
+			setMinEdges(edgeIndex, getMinEdges(edgeIndex)-1);
+		}
+
+		public void decMaxEdges(int edgeIndex) {
+			setMaxEdges(edgeIndex, getMaxEdges(edgeIndex)-1);
+		}
+		
+		public void setNextFree(int next) {
+			setMinEdges(0, next);
+		}
+		
+		public int getNextFree() {
+			return getMinEdges(0);
+		}
+	}
+	
+}

Added: trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3_32.java
===================================================================
--- trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3_32.java	                        (rev 0)
+++ trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/AxisSweep3_32.java	2009-02-05 22:59:39 UTC (rev 598)
@@ -0,0 +1,164 @@
+/*
+ * Java port of Bullet (c) 2008 Martin Dvorak <je...@ad...>
+ * 
+ * AxisSweep3
+ * Copyright (c) 2006 Simon Hobbs
+ *
+ * Bullet Continuous Collision Detection and Physics Library
+ * Copyright (c) 2003-2008 Erwin Coumans  http://www.bulletphysics.com/
+ *
+ * This software is provided 'as-is', without any express or implied warranty.
+ * In no event will the authors be held liable for any damages arising from
+ * the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose, 
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+package com.bulletphysics.collision.broadphase;
+
+import javax.vecmath.Vector3f;
+
+/**
+ * AxisSweep3_32 allows higher precision quantization and more objects compared
+ * to the {@link AxisSweep3} sweep and prune. This comes at the cost of more memory
+ * per handle, and a bit slower performance.
+ *
+ * @author jezek2
+ */
+public class AxisSweep3_32 extends AxisSweep3Internal {
+
+	public AxisSweep3_32(Vector3f worldAabbMin, Vector3f worldAabbMax) {
+		this(worldAabbMin, worldAabbMax, 1500000, null);
+	}
+
+	public AxisSweep3_32(Vector3f worldAabbMin, Vector3f worldAabbMax, int maxHandles) {
+		this(worldAabbMin, worldAabbMax, maxHandles, null);
+	}
+	
+	public AxisSweep3_32(Vector3f worldAabbMin, Vector3f worldAabbMax, int maxHandles/* = 1500000*/, OverlappingPairCache pairCache/* = 0*/) {
+		super(worldAabbMin, worldAabbMax, 0xfffffffe, 0x7fffffff, maxHandles, pairCache);
+		// 1 handle is reserved as sentinel
+		assert (maxHandles > 1 && maxHandles < 2147483647);
+	}
+	
+	@Override
+	protected EdgeArray createEdgeArray(int size) {
+		return new EdgeArrayImpl(size);
+	}
+
+	@Override
+	protected Handle createHandle() {
+		return new HandleImpl();
+	}
+	
+	protected int getMask() {
+		return 0xFFFFFFFF;
+	}
+	
+	protected static class EdgeArrayImpl extends EdgeArray {
+		private int[] pos;
+		private int[] handle;
+
+		public EdgeArrayImpl(int size) {
+			pos = new int[size];
+			handle = new int[size];
+		}
+		
+		@Override
+		public void swap(int idx1, int idx2) {
+			int tmpPos = pos[idx1];
+			int tmpHandle = handle[idx1];
+			
+			pos[idx1] = pos[idx2];
+			handle[idx1] = handle[idx2];
+			
+			pos[idx2] = tmpPos;
+			handle[idx2] = tmpHandle;
+		}
+		
+		@Override
+		public void set(int dest, int src) {
+			pos[dest] = pos[src];
+			handle[dest] = handle[src];
+		}
+		
+		@Override
+		public int getPos(int index) {
+			return pos[index];
+		}
+
+		@Override
+		public void setPos(int index, int value) {
+			pos[index] = value;
+		}
+
+		@Override
+		public int getHandle(int index) {
+			return handle[index];
+		}
+
+		@Override
+		public void setHandle(int index, int value) {
+			handle[index] = value;
+		}
+	}
+	
+	protected static class HandleImpl extends Handle {
+		private int minEdges0;
+		private int minEdges1;
+		private int minEdges2;
+
+		private int maxEdges0;
+		private int maxEdges1;
+		private int maxEdges2;
+		
+		@Override
+		public int getMinEdges(int edgeIndex) {
+			switch (edgeIndex) {
+				default:
+				case 0: return minEdges0;
+				case 1: return minEdges1;
+				case 2: return minEdges2;
+			}
+		}
+		
+		@Override
+		public void setMinEdges(int edgeIndex, int value) {
+			switch (edgeIndex) {
+				case 0: minEdges0 = value; break;
+				case 1: minEdges1 = value; break;
+				case 2: minEdges2 = value; break;
+			}
+		}
+		
+		@Override
+		public int getMaxEdges(int edgeIndex) {
+			switch (edgeIndex) {
+				default:
+				case 0: return maxEdges0;
+				case 1: return maxEdges1;
+				case 2: return maxEdges2;
+			}
+		}
+		
+		@Override
+		public void setMaxEdges(int edgeIndex, int value) {
+			switch (edgeIndex) {
+				case 0: maxEdges0 = value; break;
+				case 1: maxEdges1 = value; break;
+				case 2: maxEdges2 = value; break;
+			}
+		}
+	}
+
+}

Added: trunk/jbullet/JBullet-src/com/bulletphysics/collision/broadphase/BroadphaseInterface.java
===================================================================
--- trunk/jbullet/JBullet-src/com/bulletp...
 
[truncated message content]