public override void batchedUnitVectorGetSupportingVertexWithoutMargin( btVector3[] vectors, btVector3[] supportVerticesOut, int numVectors )
		{
			for( int i = 0; i < numVectors; i++ )
			{
				localGetSupportingVertexWithoutMargin( ref vectors[i], out supportVerticesOut[i] );
			}
		}

		public override void drawContactPoint( ref btVector3 PointOnB, ref btVector3 normalOnB, double distance, int lifeTime, ref btVector3 color )
		{
			btVector3 tmpD;
			PointOnB.Add( ref normalOnB, out tmpD );
			drawLine( ref PointOnB, ref tmpD, ref color, ref color );

		}

 public static void Multiply(ref btTransform t, ref btVector3 x, out btVector3 result)
 {
     result.X = t.Basis.el0.dot(x) + t.Origin.X;
     result.Y = t.Basis.el1.dot(x) + t.Origin.Y;
     result.Z = t.Basis.el2.dot(x) + t.Origin.Z;
     result.W = 0;
 }

		// See also geometrictools.com
		// Basic idea: D = |p - (lo + t0*lv)| where t0 = lv . (p - lo) / lv . lv
		double SegmentSqrDistance( ref btVector3 from, ref btVector3 to, ref btVector3 p, out btVector3 nearest )
		{
			btVector3 diff = p - from;
			btVector3 v = to - from;
			double t = v.dot( diff );

			if( t > 0 )
			{
				double dotVV = v.dot( v );
				if( t < dotVV )
				{
					t /= dotVV;
					diff.AddScale( ref v, -t, out diff );
					//diff -= t * v;
				}
				else
				{
					t = 1;
					diff.Sub( ref v, out diff );
					//diff -= v;
				}
			}
			else
				t = 0;

			from.AddScale( ref v, t, out nearest );
			//nearest = from + t * v;
			return diff.dot( ref diff );
		}

			public void addContactPoint( ref btVector3 normalOnBInWorld, ref btVector3 pointInWorld, double depth )
			{
				m_normalOnBInWorld = normalOnBInWorld;
				m_pointInWorld = pointInWorld;
				m_depth = depth;
				m_hasResult = true;
			}

		public void addPoint( ref btVector3 point, bool recalculateLocalAabb = true )
		{
			m_unscaledPoints.Add( point );
			if( recalculateLocalAabb )
				recalcLocalAabb();

		}

		public virtual void project( ref btTransform trans, ref btVector3 dir
			, ref double min, ref double max
			, out btVector3 witnesPtMin, out btVector3 witnesPtMax )
		{
			btVector3 localAxis; trans.m_basis.ApplyInverse( ref dir, out localAxis );
			btVector3 tmpv;
			localGetSupportingVertex( ref localAxis, out tmpv );
			btVector3 vtx1; trans.Apply( ref tmpv, out vtx1 );
			localAxis.Invert( out localAxis );
			localGetSupportingVertex( ref localAxis, out tmpv );

			btVector3 vtx2; trans.Apply( ref tmpv, out vtx2 );

			min = vtx1.dot( ref dir );
			max = vtx2.dot( ref dir );
			witnesPtMax = vtx2;
			witnesPtMin = vtx1;

			if( min > max )
			{
				double tmp = min;
				min = max;
				max = tmp;
				witnesPtMax = vtx1;
				witnesPtMin = vtx2;
			}
		}

		public void setSafeMargin( ref btVector3 halfExtents, double defaultMarginMultiplier = 0.1f )
		{
			//see http://code.google.com/p/bullet/issues/detail?id=349
			//this margin check could could be added to other collision shapes too,
			//or add some assert/warning somewhere
			double minDimension = halfExtents[halfExtents.minAxis()];
			setSafeMargin( minDimension, defaultMarginMultiplier );
		}

		btStaticPlaneShape( ref btVector3 planeOrigin, ref btVector3 planeNormal ) : base()
		{
			planeNormal.normalized( out m_planeNormal );
			m_planeConstant = planeOrigin.dot( ref planeNormal );
			m_localScaling = btVector3.Zero;
			m_shapeType = BroadphaseNativeTypes.STATIC_PLANE_PROXYTYPE;
			//	Debug.Assert( btFuzzyZero(m_planeNormal.length() - btScalar.BT_ONE) );
		}

		public override void localGetSupportingVertexWithoutMargin( ref btVector3 vec, out btVector3 result )
		{
			btVector3 halfExtents; getHalfExtentsWithoutMargin( out halfExtents );

			result = new btVector3( btScalar.btFsels( vec.x, halfExtents.x, -halfExtents.x ),
				btScalar.btFsels( vec.y, halfExtents.y, -halfExtents.y ),
				btScalar.btFsels( vec.z, halfExtents.z, -halfExtents.z ) );
		}

		public static void AabbExpand( ref btVector3 aabbMin,
										   ref btVector3 aabbMax,
										   ref btVector3 expansionMin,
										   ref btVector3 expansionMax )
		{
			aabbMin.Add( ref expansionMin, out aabbMin );
			aabbMin.Add( ref expansionMax, out aabbMin );
		}

		public btTriangleRaycastCallback( ref btVector3 from, ref btVector3 to, EFlags flags = EFlags.kF_None )
		{
			m_from = ( from );
			m_to = ( to );
			//@BP Mod
			m_flags = ( flags );
			m_hitFraction = ( btScalar.BT_ONE );
		}

		static void convexHullSupport( ref btVector3 localDirOrg, btVector3[] points, int numPoints, ref btVector3 localScaling, out btVector3 result )
		{
			btVector3 vec; localDirOrg.Mult( ref localScaling, out vec );
			double maxDot;
			long ptIndex = vec.maxDot( points, numPoints, out maxDot );
			Debug.Assert( ptIndex >= 0 );
			points[ptIndex].Mult( ref localScaling, out result );
		}

		public void setPoints( btVector3[] points, int numPoints, bool computeAabb, ref btVector3 localScaling )
		{
			m_unscaledPoints = points;
			m_numPoints = numPoints;
			m_localScaling = localScaling;

			if( computeAabb )
				recalcLocalAabb();
		}

        public static bool TestAabbAgainstAabb2(btVector3 aabbMin1, btVector3 aabbMax1,
								btVector3 aabbMin2, btVector3 aabbMax2)
        {
	        bool overlap = true;
	        overlap = (aabbMin1.X > aabbMax2.X || aabbMax1.X < aabbMin2.X) ? false : overlap;
	        overlap = (aabbMin1.Z > aabbMax2.Z || aabbMax1.Z < aabbMin2.Z) ? false : overlap;
	        overlap = (aabbMin1.Y > aabbMax2.Y || aabbMax1.Y < aabbMin2.Y) ? false : overlap;
	        return overlap;
        }

		public virtual void addContactPoint( ref btVector3 normalOnBInWorld, ref btVector3 pointInWorld, double depth )
		{
			if( depth < m_distance )
			{
				m_normalOnSurfaceB = normalOnBInWorld;
				m_closestPointInB = pointInWorld;
				m_distance = depth;
			}
		}

		public static int btOutcode( ref btVector3 p, ref btVector3 halfExtent )
		{
			return ( p.x < -halfExtent.x ? 0x01 : 0x0 ) |
				   ( p.x > halfExtent.x ? 0x08 : 0x0 ) |
				   ( p.y < -halfExtent.y ? 0x02 : 0x0 ) |
				   ( p.y > halfExtent.y ? 0x10 : 0x0 ) |
				   ( p.z < -halfExtent.z ? 0x4 : 0x0 ) |
				   ( p.z > halfExtent.z ? 0x20 : 0x0 );
		}

		/// conservative test for overlap between two aabbs
		public static bool TestAabbAgainstAabb2( ref btVector3 aabbMin1, ref btVector3 aabbMax1,
										ref btVector3 aabbMin2, ref btVector3 aabbMax2 )
		{
			bool overlap = true;
			overlap = ( aabbMin1.x > aabbMax2.x || aabbMax1.x < aabbMin2.x ) ? false : overlap;
			overlap = ( aabbMin1.z > aabbMax2.z || aabbMax1.z < aabbMin2.z ) ? false : overlap;
			overlap = ( aabbMin1.y > aabbMax2.y || aabbMax1.y < aabbMin2.y ) ? false : overlap;
			return overlap;
		}

		/// conservative test for overlap between two aabbs
		public static bool TestPointAgainstAabb2( ref btVector3 aabbMin1, ref btVector3 aabbMax1,
										ref btVector3 point )
		{
			bool overlap = true;
			overlap = ( aabbMin1.x > point.x || aabbMax1.x < point.x ) ? false : overlap;
			overlap = ( aabbMin1.z > point.z || aabbMax1.z < point.z ) ? false : overlap;
			overlap = ( aabbMin1.y > point.y || aabbMax1.y < point.y ) ? false : overlap;
			return overlap;
		}

		public override void drawLine( ref btVector3 from, ref btVector3 to, ref btVector3 fromColor, ref btVector3 toColor )
		{

			GL.Begin( PrimitiveType.Lines );
			GL.Color4( fromColor.ToFloat4() );
			GL.Vertex3( from.ToFloat4() );
			GL.Color4( toColor.ToFloat4() );
			GL.Vertex3( to.ToFloat4() );
			GL.End();
		}