Exemple #1
0
 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))
 {
 }
Exemple #2
0
 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))
		{
		}
Exemple #4
0
 public unsafe static void GetWorldTransform(this CollisionObjectWrapper obj, out OpenTK.Matrix4 value)
 {
     fixed(OpenTK.Matrix4 *valuePtr = &value)
     {
         *(BulletSharp.Math.Matrix *)valuePtr = obj.WorldTransform;
     }
 }
 public Convex2DConvex2DAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci,
                                  CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, VoronoiSimplexSolver simplexSolver,
                                  ConvexPenetrationDepthSolver pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold)
     : base(btConvex2dConvex2dAlgorithm_new(mf._native, ci._native, body0Wrap._native,
                                            body1Wrap._native, simplexSolver._native, pdSolver._native, 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);
		}
Exemple #7
0
        public SphereSphereCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci,
                                              CollisionObjectWrapper col0Wrap, CollisionObjectWrapper col1Wrap)
        {
            IntPtr native = btSphereSphereCollisionAlgorithm_new(mf.Native, ci.Native, col0Wrap.Native,
                                                                 col1Wrap.Native);

            InitializeUserOwned(native);
        }
Exemple #8
0
        public SoftBodyConcaveCollisionAlgorithm(CollisionAlgorithmConstructionInfo ci,
                                                 CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool isSwapped)
        {
            IntPtr native = btSoftBodyConcaveCollisionAlgorithm_new(ci.Native, body0Wrap.Native,
                                                                    body1Wrap.Native, isSwapped);

            InitializeUserOwned(native);
        }
 public bool GetSphereDistance(CollisionObjectWrapper boxObjWrap, out Vector3 v3PointOnBox,
                               out Vector3 normal, out double penetrationDepth, Vector3 v3SphereCenter,
                               double fRadius, double maxContactDistance)
 {
     return(btSphereBoxCollisionAlgorithm_getSphereDistance(Native, boxObjWrap.Native,
                                                            out v3PointOnBox, out normal, out penetrationDepth, ref v3SphereCenter,
                                                            fRadius, maxContactDistance));
 }
        public GImpactCollisionAlgorithm(CollisionAlgorithmConstructionInfo constructionInfo, CollisionObjectWrapper body0Wrap,
                                         CollisionObjectWrapper body1Wrap)
        {
            IntPtr native = btGImpactCollisionAlgorithm_new(constructionInfo.Native, body0Wrap.Native,
                                                            body1Wrap.Native);

            InitializeUserOwned(native);
        }
Exemple #11
0
        public SoftSoftCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci,
                                          CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
        {
            IntPtr native = btSoftSoftCollisionAlgorithm_new2(mf.Native, ci.Native, body0Wrap.Native,
                                                              body1Wrap.Native);

            InitializeUserOwned(native);
        }
        public SphereTriangleCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci,
                                                CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool swapped)
        {
            IntPtr native = btSphereTriangleCollisionAlgorithm_new(mf.Native, ci.Native,
                                                                   body0Wrap.Native, body1Wrap.Native, swapped);

            InitializeUserOwned(native);
        }
Exemple #13
0
        public SoftRigidCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci,
                                           CollisionObjectWrapper col0, CollisionObjectWrapper col1Wrap, bool isSwapped)
        {
            IntPtr native = btSoftRigidCollisionAlgorithm_new(mf.Native, ci.Native, col0.Native,
                                                              col1Wrap.Native, isSwapped);

            InitializeUserOwned(native);
        }
 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...?
        }
Exemple #18
0
        public override float AddSingleResult(ManifoldPoint cp, CollisionObjectWrapper colObj0, int partId0, int index0,
                                              CollisionObjectWrapper colObj1, int partId1, int index1)
        {
            if (colObj0.CollisionObject == _controller.RigidBody)
            {
                CheckGround(cp);
                _resolveStepUp.Resolve(cp);
                if (_resolveStepUp.IsStep)
                {
                    if (!HaveStep || _resolveStepUp.DistSqr < _stepDistSqr)
                    {
                        StepPoint    = _resolveStepUp.RealPosWorld;
                        _stepNormal  = cp.NormalWorldOnB;
                        _stepDistSqr = _resolveStepUp.DistSqr;
                    }
                    HaveStep = true;
                }
            }

            // By looking at btCollisionWorld.cpp, it seems Bullet ignores this value
            return(0);
        }
 public SphereBoxCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci,
                                    CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool isSwapped)
     : base(btSphereBoxCollisionAlgorithm_new(mf.Native, ci.Native, body0Wrap.Native,
                                              body1Wrap.Native, isSwapped))
 {
 }
		public virtual CollisionAlgorithm CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo __unnamed0,
			CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
		{
            return null;
		}
Exemple #21
0
 public void GImpactVsConcave(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap,
                              GImpactShapeInterface shape0, ConcaveShape shape1, bool swapped)
 {
     btGImpactCollisionAlgorithm_gimpact_vs_concave(_native, body0Wrap._native,
                                                    body1Wrap._native, shape0._native, shape1._native, swapped);
 }
 public void ProcessCollision(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, DispatcherInfo dispatchInfo, ManifoldResult resultOut)
 {
     btCollisionAlgorithm_processCollision(_native, body0Wrap._native, body1Wrap._native, dispatchInfo._native, resultOut._native);
 }
 public void CollideSingleContact(Quaternion perturbeRot, CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, DispatcherInfo dispatchInfo, ManifoldResult resultOut)
 {
     btConvexPlaneCollisionAlgorithm_collideSingleContact(_native, ref perturbeRot, body0Wrap._native, body1Wrap._native, dispatchInfo._native, resultOut._native);
 }
 public override CollisionAlgorithm CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo __unnamed0, CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
 {
     return(new Convex2DConvex2DAlgorithm(btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm(
                                              _native, __unnamed0._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 override CollisionAlgorithm CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo __unnamed0,
                                                             CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
 {
     return(new SoftRigidCollisionAlgorithm(btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm(
                                                Native, __unnamed0.Native, body0Wrap.Native, body1Wrap.Native)));
 }
 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 static void ObjectQuerySingleInternal(ConvexShape castShape, Matrix convexFromTrans,
			Matrix convexToTrans, CollisionObjectWrapper colObjWrap, ConvexResultCallback resultCallback,
			float allowedPenetration)
		{
			btCollisionWorld_objectQuerySingleInternal(castShape._native, ref convexFromTrans,
				ref convexToTrans, colObjWrap._native, resultCallback._native, allowedPenetration);
		}
 public abstract float AddSingleResult(ManifoldPoint cp, CollisionObjectWrapper colObj0Wrap, int partId0, int index0, CollisionObjectWrapper colObj1Wrap, int partId1, int index1);
 public ManifoldResult(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
     : base(btManifoldResult_new2(body0Wrap.Native, body1Wrap.Native))
 {
 }
 public SphereTriangleCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci,
                                         CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool swapped)
     : base(btSphereTriangleCollisionAlgorithm_new(mf._native, ci._native,
                                                   body0Wrap._native, body1Wrap._native, swapped))
 {
 }
		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))
 {
 }
		public SoftRigidCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper col0, CollisionObjectWrapper col1Wrap, bool isSwapped)
			: base(btSoftRigidCollisionAlgorithm_new(mf._native, ci._native, col0._native, col1Wrap._native, isSwapped))
		{
		}
 public CollisionAlgorithm FindAlgorithm(CollisionObjectWrapper body0Wrap,
                                         CollisionObjectWrapper body1Wrap)
 {
     return(new CollisionAlgorithm(btDispatcher_findAlgorithm(_native, body0Wrap._native, body1Wrap._native)));
 }
        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 SphereSphereCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper col0Wrap, CollisionObjectWrapper col1Wrap)
			: base(btSphereSphereCollisionAlgorithm_new(mf._native, ci._native, col0Wrap._native, col1Wrap._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 SphereTriangleCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci,
			CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool swapped)
			: base(btSphereTriangleCollisionAlgorithm_new(mf._native, ci._native,
				body0Wrap._native, body1Wrap._native, swapped))
		{
		}
 public CollisionAlgorithm FindAlgorithm(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
 {
     return new CollisionAlgorithm(btDispatcher_findAlgorithm(_native, body0Wrap._native, body1Wrap._native));
 }
Exemple #42
0
 public GImpactCollisionAlgorithm(CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper body0Wrap,
                                  CollisionObjectWrapper body1Wrap)
     : base(btGImpactCollisionAlgorithm_new(ci._native, body0Wrap._native,
                                            body1Wrap._native))
 {
 }
 public CollisionAlgorithm FindAlgorithm(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, PersistentManifold sharedManifold)
 {
     return new CollisionAlgorithm(btDispatcher_findAlgorithm2(_native, body0Wrap._native, body1Wrap._native, sharedManifold._native));
 }
 public CollisionAlgorithm CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo __unnamed0, CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
 {
     return new CollisionAlgorithm(btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm(_native, __unnamed0._native, body0Wrap._native, body1Wrap._native));
 }
		public void GImpactVsGImpact(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap,
			GImpactShapeInterface shape0, GImpactShapeInterface shape1)
		{
			btGImpactCollisionAlgorithm_gimpact_vs_gimpact(_native, body0Wrap._native,
				body1Wrap._native, shape0._native, shape1._native);
		}
Exemple #46
0
 public void CollideSingleContact(Quaternion perturbeRot, CollisionObjectWrapper body0Wrap,
                                  CollisionObjectWrapper body1Wrap, DispatcherInfo dispatchInfo, ManifoldResult resultOut)
 {
     btConvexPlaneCollisionAlgorithm_collideSingleContact(_native, ref perturbeRot,
                                                          body0Wrap._native, body1Wrap._native, dispatchInfo._native, resultOut._native);
 }
 public void ProcessCollision(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap,
                              DispatcherInfo dispatchInfo, ManifoldResult resultOut)
 {
     btCollisionAlgorithm_processCollision(_native, body0Wrap._native, body1Wrap._native,
                                           dispatchInfo._native, resultOut._native);
 }
		public GImpactCollisionAlgorithm(CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper body0Wrap,
			CollisionObjectWrapper body1Wrap)
			: base(btGImpactCollisionAlgorithm_new(ci._native, body0Wrap._native,
				body1Wrap._native))
		{
		}
 public SoftSoftCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci,
                                   CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
     : base(btSoftSoftCollisionAlgorithm_new2(mf.Native, ci.Native, body0Wrap.Native,
                                              body1Wrap.Native))
 {
 }
 public override CollisionAlgorithm CreateCollisionAlgorithm(CollisionAlgorithmConstructionInfo __unnamed0,
                                                             CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
 {
     return(new GImpactCollisionAlgorithm(btCollisionAlgorithmCreateFunc_CreateCollisionAlgorithm(
                                              Native, __unnamed0.Native, body0Wrap.Native, body1Wrap.Native), __unnamed0.Dispatcher));
 }
		public ConvexConcaveCollisionAlgorithm(CollisionAlgorithmConstructionInfo ci,
			CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool isSwapped)
			: base(btConvexConcaveCollisionAlgorithm_new(ci.Native, body0Wrap.Native,
				body1Wrap.Native, isSwapped))
		{
		}
 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 SoftBodyConcaveCollisionAlgorithm(CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool isSwapped)
     : base(btSoftBodyConcaveCollisionAlgorithm_new(ci._native, body0Wrap._native, body1Wrap._native, isSwapped))
 {
 }
 public SoftSoftCollisionAlgorithm(PersistentManifold mf, CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
     : base(btSoftSoftCollisionAlgorithm_new2(mf._native, ci._native, body0Wrap._native, body1Wrap._native))
 {
 }
 public CompoundCollisionAlgorithm(CollisionAlgorithmConstructionInfo ci, CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool isSwapped)
     : base(btCompoundCollisionAlgorithm_new(ci._native, body0Wrap._native, body1Wrap._native, isSwapped))
 {
 }
 public CollisionAlgorithm FindAlgorithm(CollisionObjectWrapper body0Wrap,
                                         CollisionObjectWrapper body1Wrap, PersistentManifold sharedManifold)
 {
     return(new CollisionAlgorithm(btDispatcher_findAlgorithm2(_native, body0Wrap._native, body1Wrap._native, sharedManifold._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))
		{
		}
 public CompoundCollisionAlgorithm(CollisionAlgorithmConstructionInfo ci,
                                   CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap, bool isSwapped)
     : base(btCompoundCollisionAlgorithm_new(ci._native, body0Wrap._native,
                                             body1Wrap._native, isSwapped))
 {
 }
 public ManifoldResult(CollisionObjectWrapper body0Wrap, CollisionObjectWrapper body1Wrap)
     : base(btManifoldResult_new2(body0Wrap._native, body1Wrap._native))
 {
 }