//! If you don't want to consider collisions where the bodies are joined by a constraint, override NeedsCollision:
        /*! However, if you use a CollisionObject for #body instead of a RigidBody,
         *  then this is unnecessary—CheckCollideWithOverride isn't available */
        public override bool NeedsCollision(BroadphaseProxy proxy)
        {
            // superclass will check CollisionFilterGroup and CollisionFilterMask
            if (!base.NeedsCollision(proxy))
                return false;

            // if passed filters, may also want to avoid contacts between constraints
            return body.CheckCollideWithOverride(proxy.ClientObject as CollisionObject);
        }

        public unsafe static void GetAabb(this BroadphaseInterface obj, BroadphaseProxy proxy, out OpenTK.Vector3 aabbMin, out OpenTK.Vector3 aabbMax)
		{
			fixed (OpenTK.Vector3* aabbMinPtr = &aabbMin)
			{
				fixed (OpenTK.Vector3* aabbMaxPtr = &aabbMax)
				{
                    obj.GetAabb(proxy, out *(BulletSharp.Math.Vector3*)aabbMinPtr, out *(BulletSharp.Math.Vector3*)aabbMaxPtr);
				}
			}
		}

		public unsafe static void SetAabbForceUpdate(this DbvtBroadphase obj, BroadphaseProxy absproxy, ref OpenTK.Vector3 aabbMin, ref OpenTK.Vector3 aabbMax, Dispatcher __unnamed3)
		{
			fixed (OpenTK.Vector3* aabbMinPtr = &aabbMin)
			{
				fixed (OpenTK.Vector3* aabbMaxPtr = &aabbMax)
				{
					obj.SetAabbForceUpdate(absproxy, ref *(BulletSharp.Math.Vector3*)aabbMinPtr, ref *(BulletSharp.Math.Vector3*)aabbMaxPtr, __unnamed3);
				}
			}
		}

		public void CleanProxyFromPairs(BroadphaseProxy proxy, Dispatcher dispatcher)
		{
			btOverlappingPairCache_cleanProxyFromPairs(_native, proxy._native, dispatcher._native);
		}

 public override void RemoveOverlappingPairsContainingProxy(BroadphaseProxy proxy0, Dispatcher dispatcher)
 {
     btOverlappingPairCallback_removeOverlappingPairsContainingProxy(_native, proxy0._native, dispatcher._native);
 }

 public override BroadphasePair AddOverlappingPair(BroadphaseProxy proxy0, BroadphaseProxy proxy1)
 {
     return new BroadphasePair(btOverlappingPairCallback_addOverlappingPair(_native, proxy0._native, proxy1._native));
 }

		public BroadphasePair FindPair(BroadphaseProxy proxy0, BroadphaseProxy proxy1)
		{
            return new BroadphasePair(btOverlappingPairCache_findPair(_native, proxy0._native, proxy1._native));
		}

 void UnQuantize(BroadphaseProxy proxy, Vector3 aabbMin, Vector3 aabbMax)
 {
     btAxisSweep3_unQuantize(_native, proxy._native, out aabbMin, out aabbMax);
 }

 public void SetAabb(BroadphaseProxy proxy, Vector3 aabbMin, Vector3 aabbMax, Dispatcher dispatcher)
 {
     SetAabbRef(proxy, ref aabbMin, ref aabbMax, dispatcher);
 }

 public void GetAabb(BroadphaseProxy proxy, out Vector3 aabbMin, out Vector3 aabbMax)
 {
     btBroadphaseInterface_getAabb(_native, proxy._native, out aabbMin, out aabbMax);
 }

 public void DestroyProxy(BroadphaseProxy proxy, Dispatcher dispatcher)
 {
     btBroadphaseInterface_destroyProxy(_native, proxy._native, dispatcher._native);
 }

 public void SetNewBroadphaseProxy(BroadphaseProxy broadphaseProxy)
 {
     btRigidBody_setNewBroadphaseProxy(_native, broadphaseProxy._native);
 }

 public abstract void RemoveOverlappingPairsContainingProxy(BroadphaseProxy proxy0, Dispatcher dispatcher);

 public abstract IntPtr RemoveOverlappingPair(BroadphaseProxy proxy0, BroadphaseProxy proxy1, Dispatcher dispatcher);

 /*
 protected OverlappingPairCallback()
 {
     _native = btOverlappingPairCallbackWrapper_new();
 }
 */
 public abstract BroadphasePair AddOverlappingPair(BroadphaseProxy proxy0, BroadphaseProxy proxy1);

		public virtual bool NeedsCollision(BroadphaseProxy proxy0)
		{
			return btCollisionWorld_RayResultCallbackWrapper_needsCollision(_native, proxy0._native);
		}

 public bool TestAabbOverlap(BroadphaseProxy proxy0, BroadphaseProxy proxy1)
 {
     return btSimpleBroadphase_testAabbOverlap(_native, proxy0._native, proxy1._native);
 }

 public void SetAabbRef(BroadphaseProxy proxy, ref Vector3 aabbMin, ref Vector3 aabbMax, Dispatcher dispatcher)
 {
     btBroadphaseInterface_setAabb(_native, proxy._native, ref aabbMin, ref aabbMax, dispatcher._native);
 }

 bool TestAabbOverlap(BroadphaseProxy proxy0, BroadphaseProxy proxy1)
 {
     return btAxisSweep3_testAabbOverlap(_native, proxy0._native, proxy1._native);
 }

 public abstract bool Process(BroadphaseProxy proxy);