static void CustomMaterialCombinerCallback(ManifoldPoint cp,
     CollisionObjectWrapper colObj0Wrap, int partId0, int index0,
     CollisionObjectWrapper colObj1Wrap, int partId1, int index1)
 {
     // Apply material properties
     if (colObj0Wrap.CollisionShape.ShapeType == BroadphaseNativeType.TriangleShape)
     {
         CollisionShape parent0 = colObj0Wrap.CollisionObject.CollisionShape;
         if (parent0 != null && parent0.ShapeType == BroadphaseNativeType.MultiMaterialTriangleMesh)
         {
             MultimaterialTriangleMeshShape shape = parent0 as MultimaterialTriangleMeshShape;
             BulletMaterial props = shape.GetMaterialProperties(partId0, index0);
             cp.CombinedFriction = CalculateCombinedFriction(props.Friction, colObj1Wrap.CollisionObject.Friction);
             cp.CombinedRestitution = props.Restitution * colObj1Wrap.CollisionObject.Restitution;
         }
     }
     else if (colObj1Wrap.CollisionShape.ShapeType == BroadphaseNativeType.TriangleShape)
     {
         CollisionShape parent1 = colObj1Wrap.CollisionObject.CollisionShape;
         if (parent1 != null && parent1.ShapeType == BroadphaseNativeType.MultiMaterialTriangleMesh)
         {
             MultimaterialTriangleMeshShape shape = parent1 as MultimaterialTriangleMeshShape;
             BulletMaterial props = shape.GetMaterialProperties(partId1, index1);
             cp.CombinedFriction = CalculateCombinedFriction(props.Friction, colObj0Wrap.CollisionObject.Friction);
             cp.CombinedRestitution = props.Restitution * colObj0Wrap.CollisionObject.Restitution;
         }
     }
 }

		public ConvexPlaneCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci,
			CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool isSwapped,
			int numPerturbationIterations, int minimumPointsPerturbationThreshold)
			: base(btConvexPlaneCollisionAlgorithm_new(mf._native, ci._native, body0Wrap._native,
				body1Wrap._native, isSwapped, numPerturbationIterations, minimumPointsPerturbationThreshold))
		{
		}

		public bool GetSphereDistance(CollisionObjectWrapper boxObjWrap, out Vector3 v3PointOnBox,
			out Vector3 normal, out float penetrationDepth, Vector3 v3SphereCenter,
			float fRadius, float maxContactDistance)
		{
			return btSphereBoxCollisionAlgorithm_getSphereDistance(_native, boxObjWrap._native,
				out v3PointOnBox, out normal, out penetrationDepth, ref v3SphereCenter,
				fRadius, maxContactDistance);
		}

 public override float AddSingleResult(ManifoldPoint cp,
     CollisionObjectWrapper colObj0Wrap, int partId0, int index0,
     CollisionObjectWrapper colObj1Wrap, int partId1, int index1)
 {
     Vector3 ptA = cp.PositionWorldOnA;
     Vector3 ptB = cp.PositionWorldOnB;
     world.DebugDrawer.DrawLine(ref ptA, ref ptB, System.Drawing.Color.Blue);
     return 0;
 }

		public unsafe static bool GetSphereDistance(this SphereBoxCollisionAlgorithm obj, CollisionObjectWrapper boxObjWrap, ref OpenTK.Vector3 v3PointOnBox, ref OpenTK.Vector3 normal, out float penetrationDepth, ref OpenTK.Vector3 v3SphereCenter, float fRadius, float maxContactDistance)
		{
			fixed (OpenTK.Vector3* v3PointOnBoxPtr = &v3PointOnBox)
			{
				fixed (OpenTK.Vector3* normalPtr = &normal)
				{
					fixed (OpenTK.Vector3* v3SphereCenterPtr = &v3SphereCenter)
					{
						return obj.GetSphereDistance(boxObjWrap, ref *(BulletSharp.Math.Vector3*)v3PointOnBoxPtr, ref *(BulletSharp.Math.Vector3*)normalPtr, out penetrationDepth, ref *(BulletSharp.Math.Vector3*)v3SphereCenterPtr, fRadius, maxContactDistance);
					}
				}
			}
		}

        // MyContactCallback is just an example to show how to get access to the child shape that collided
        void MyContactCallback(ManifoldPoint cp, CollisionObjectWrapper colObj0Wrap, int partId0, int index0, CollisionObjectWrapper colObj1Wrap, int partId1, int index1)
        {
            if (colObj0Wrap.CollisionObject.CollisionShape.ShapeType == BroadphaseNativeType.CompoundShape)
            {
                CompoundShape compound = colObj0Wrap.CollisionObject.CollisionShape as CompoundShape;
                CollisionShape childShape = compound.GetChildShape(index0);
            }

            if (colObj1Wrap.CollisionObject.CollisionShape.ShapeType == BroadphaseNativeType.CompoundShape)
            {
                CompoundShape compound = colObj1Wrap.CollisionObject.CollisionShape as CompoundShape;
                CollisionShape childShape = compound.GetChildShape(index1);
            }
        }

        //! Called with each contact for your own processing (e.g. test if contacts fall in within sensor parameters)
        public override float AddSingleResult(ManifoldPoint cp,
            CollisionObjectWrapper colObj0, int partId0, int index0,
            CollisionObjectWrapper colObj1, int partId1, int index1)
        {
            Vector3 pt; // will be set to point of collision relative to body
            if (colObj0.CollisionObject == body)
            {
                pt = cp.LocalPointA;
                //Console.WriteLine("ContactSensorCallback");
            }
            else
            {
                System.Diagnostics.Debug.Assert(colObj1.CollisionObject == body);
                pt = cp.LocalPointB;
            }

            // do stuff with the collision point
            return 0; // not actually sure if return value is used for anything...?
        }

 public override float AddSingleResult(ManifoldPoint cp,
     CollisionObjectWrapper colObj0Wrap, int partId0, int index0,
     CollisionObjectWrapper colObj1Wrap, int partId1, int index1)
 {
     Vector3 ptA = cp.PositionWorldOnA;
     Vector3 ptB = cp.PositionWorldOnB;
     UnityEngine.Debug.Log("Contact!");
     world.DebugDrawer.DrawLine(ref ptA, ref ptB, ref ptA);
     return 0;
 }

		public static void RayTestSingleInternal(Matrix rayFromTrans, Matrix rayToTrans,
			CollisionObjectWrapper collisionObjectWrap, RayResultCallback resultCallback)
		{
			btCollisionWorld_rayTestSingleInternal(ref rayFromTrans, ref rayToTrans,
				collisionObjectWrap._native, resultCallback._native);
		}

		public virtual CollisionAlgorithm CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo __unnamed0,
			CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
		{
            return null;
		}

 public CollisionAlgorithm CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo __unnamed0, CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
 {
     return new CollisionAlgorithm(btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm(_native, __unnamed0._native, body0Wrap._native, body1Wrap._native));
 }

 public CollisionAlgorithm FindAlgorithm(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
 {
     return new CollisionAlgorithm(btDispatcher_findAlgorithm(_native, body0Wrap._native, body1Wrap._native));
 }

		public void GImpactVsShape(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap,
			GImpactShapeInterface shape0, CollisionShape shape1, bool swapped)
		{
			btGImpactCollisionAlgorithm_gimpact_vs_shape(_native, body0Wrap._native,
				body1Wrap._native, shape0._native, shape1._native, swapped);
		}

		public void GImpactVsGImpact(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap,
			GImpactShapeInterface shape0, GImpactShapeInterface shape1)
		{
			btGImpactCollisionAlgorithm_gimpact_vs_gimpact(_native, body0Wrap._native,
				body1Wrap._native, shape0._native, shape1._native);
		}

		public GImpactCollisionAlgorithm(CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper body0Wrap,
			CollisionObjectWrapper body1Wrap)
			: base(btGImpactCollisionAlgorithm_new(ci._native, body0Wrap._native,
				body1Wrap._native))
		{
		}

		public SoftBodyConcaveCollisionAlgorithm(CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool isSwapped)
			: base(btSoftBodyConcaveCollisionAlgorithm_new(ci._native, body0Wrap._native, body1Wrap._native, isSwapped))
		{
		}

		public SoftRigidCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper col0, CollisionObjectWrapper col1Wrap, bool isSwapped)
			: base(btSoftRigidCollisionAlgorithm_new(mf._native, ci._native, col0._native, col1Wrap._native, isSwapped))
		{
		}

        private void OnContactAdded(ManifoldPoint cp, CollisionObjectWrapper colObj0Wrap, int partId0, int index0,
            CollisionObjectWrapper colObj1Wrap, int partId1, int index1)
        {
            //Debug.WriteLine("OnContactAdded");
            int numManifolds = BtWorld.Dispatcher.NumManifolds;

            for (int i = 0; i < numManifolds; i++)
            {
                PersistentManifold contactManifold = BtWorld.Dispatcher.GetManifoldByIndexInternal(i);
                int numContacts = contactManifold.NumContacts;
                if (numContacts > 0)
                {
                    cp.UserPersistentData = 1;

                    CollisionObject obA = (CollisionObject) contactManifold.Body0;
                    CollisionObject obB = (CollisionObject) contactManifold.Body1;
                    RigidBody btRigidBodyA = (RigidBody) obA;
                    RigidBody btRigidBodyB = (RigidBody)obB;
                    RigidBodyImp rigidBodyA = new RigidBodyImp();
                    RigidBodyImp rigidBodyB = new RigidBodyImp();
                    rigidBodyA._rbi = btRigidBodyA;
                    rigidBodyB._rbi = btRigidBodyB;
                    rigidBodyA.OnCollision(rigidBodyB);
                }
            }
        }

 public ManifoldResult(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
     : base(btManifoldResult_new2(body0Wrap._native, body1Wrap._native))
 {
 }

		public ConvexConvexAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, VoronoiSimplexSolver simplexSolver, ConvexPenetrationDepthSolver pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold)
			: base(btConvexConvexAlgorithm_new(mf._native, ci._native, body0Wrap._native, body1Wrap._native, simplexSolver._native, pdSolver._native, numPerturbationIterations, minimumPointsPerturbationThreshold))
		{
		}