Beispiel #1
0
 public void RemoveCollisionObject(BulletSharp.CollisionObject co)
 {
     if (co is RigidBody)
     {
         RemoveRigidBody((RigidBody)co);
         return;
     }
     if (co is SoftBody)
     {
         RemoveSoftBody((SoftBody)co);
         return;
     }
     if (!_isDisposed)
     {
         if (debugType >= BDebug.DebugType.Debug)
         {
             Debug.LogFormat("Removing collisionObject {0} from world", co.UserObject);
         }
         m_world.RemoveCollisionObject(co);
         if (co.UserObject is BCollisionObject)
         {
             ((BCollisionObject)co.UserObject).isInWorld = false;
         }
         //TODO handle removing kinematic character controller action
     }
 }
        protected override void OnInitializePhysics()
        {
            BoxShape boxA = new BoxShape(new Vector3(1, 1, 1));
            boxA.Margin = 0;

            BoxShape boxB = new BoxShape(new Vector3(0.5f, 0.5f, 0.5f));
            boxB.Margin = 0;

            objects[0] = new CollisionObject();
            objects[1] = new CollisionObject();

            objects[0].CollisionShape = boxA;
            objects[1].CollisionShape = boxB;

            // collision configuration contains default setup for memory, collision setup
            CollisionConf = new DefaultCollisionConfiguration();
            Dispatcher = new CollisionDispatcher(CollisionConf);

            Broadphase = new AxisSweep3(new Vector3(-1000, -1000, -1000), new Vector3(1000, 1000, 1000));

            World = new DiscreteDynamicsWorld(Dispatcher, Broadphase, null, CollisionConf);
            World.Gravity = new Vector3(0, -10, 0);
            IsDebugDrawEnabled = true;

            //World.AddCollisionObject(objects[0]);
            World.AddCollisionObject(objects[1]);

            Quaternion rotA = new Quaternion(0.739f, -0.204f, 0.587f, 0.257f);
            rotA.Normalize();

            objects[0].WorldTransform = Matrix.RotationQuaternion(rotA) * Matrix.Translation(0, 3, 0);
            objects[1].WorldTransform = Matrix.Translation(0, 4.248f, 0);
        }
Beispiel #3
0
 public void Render(CollisionObject body)
 {
     switch (body.CollisionShape.ShapeType)
     {
         case BroadphaseNativeType.SoftBodyShape:
             device.SetTransform(TransformState.World, Matrix.Identity);
             RenderSoftBody(body as SoftBody);
             break;
         case BroadphaseNativeType.CompoundShape:
             CompoundShape compoundShape = body.CollisionShape as CompoundShape;
             //if (compoundShape.NumChildShapes == 0)
             //    return;
             foreach (CompoundShapeChild child in compoundShape.ChildList)
             {
                 device.SetTransform(TransformState.World,
                     MathHelper.Convert(child.Transform) * MathHelper.Convert(body.WorldTransform));
                 Render(child.ChildShape);
             }
             break;
         default:
             device.SetTransform(TransformState.World, MathHelper.Convert(body.WorldTransform));
             Render(body.CollisionShape);
             break;
     }
 }
        /// <summary>
        /// Create a data holder without a LThing object.
        /// </summary>
        /// <param name="collisionGroup">The collision group of the object</param>
        /// <param name="name">The name of the object, excluding an ID</param>
        /// <param name="owner">The collision object this data holder is attached to</param>
        public CollisionObjectDataHolder(CollisionObject owner, PonykartCollisionGroups collisionGroup, string name)
        {
            this.Owner = owner;
            this.CollisionGroup = collisionGroup;
            this.Name = name;

            this.ID = IDs.Random;
        }
 public override float AddSingleResult(ManifoldPoint cp, CollisionObject colObj0, int partId0, int index0, CollisionObject colObj1, int partId1, int index1)
 {
     if (colObj0.UserObject != null && colObj0.UserObject is IPhysicObject)
     {
         objs.Add(colObj0.UserObject as IPhysicObject);
     }
     return 0;
 }
        public BulletPhysicObject(CollisionShape CollisionShape, Vector3 translation, Matrix rotation, Vector3 Scale, float mass, CollisionFilterGroups CollisionFilterGroup = CollisionFilterGroups.DefaultFilter,CollisionFilterGroups collisionFilterMask = CollisionFilterGroups.DefaultFilter)
        {
            shape  = CollisionShape;
            this.scale = Scale;
            this.mass = mass;
            shape.LocalScaling = Scale;
            obj = LocalCreateRigidBody(mass, Matrix.CreateTranslation(translation) * rotation, CollisionShape);            

        }
 public void Render(CollisionObject body)
 {
     if (body.CollisionShape.ShapeType == BroadphaseNativeType.SoftBodyShape)
     {
         RenderSoftBody(body as SoftBody);
     }
     else
     {
         Render(body.CollisionShape);
     }
 }
Beispiel #8
0
 public void RemoveCollisionObject(BulletSharp.CollisionObject co)
 {
     if (!_isDisposed)
     {
         BDebug.Log(debugType, "Removing collisionObject {0} from world", co.UserObject);
         m_world.RemoveCollisionObject(co);
         if (co.UserObject is BCollisionObject)
         {
             ((BCollisionObject)co.UserObject).isInWorld = false;
         }
         //TODO handle removing kinematic character controller action
     }
 }
 public Model(params GeometricPrimitive[] Primitives)
 {
     this.Primitives = Primitives.ToList();
     CollisionShape compound = null;
     CastShadow = true;
     List<Vector3> points = new List<Vector3>();
     if (Primitives.Length > 1)
     {
         compound = new CompoundShape(true);
         foreach (GeometricPrimitive prim in Primitives)
         {
             (compound as CompoundShape).AddChildShape(Matrix.Identity, prim.CollisionShape);
             points.AddRange(prim.GeometryData.Positions);
         }
     }
     else
     {
         compound = Primitives[0].CollisionShape;
         points.AddRange(Primitives[0].GeometryData.Positions);
     }
     mass = 10;
     body = new RigidBody(new RigidBodyConstructionInfo(mass, new DefaultMotionState(), compound, compound.CalculateLocalInertia(mass)));
     bbox = BoundingBox.FromPoints(points.ToArray());
 }
 public static PonykartCollisionGroups GetCollisionGroup(CollisionObject obj)
 {
     return obj.GetCollisionGroup();
 }
 public PersistentManifold(CollisionObject body0, CollisionObject body1, int __unnamed2,
                           Scalar contactBreakingThreshold, Scalar contactProcessingThreshold)
 {
     Native = btPersistentManifold_new2(body0.Native, body1.Native, __unnamed2,
                                        contactBreakingThreshold, contactProcessingThreshold);
 }
Beispiel #12
0
 void InitRigidBodyInstance(CollisionObject colObj, CollisionShape shape, ref Matrix transform)
 {
     if (shape.ShapeType == BroadphaseNativeType.CompoundShape)
     {
         foreach (var child in (shape as CompoundShape).ChildList)
         {
             Matrix childTransform = child.Transform * transform;
             InitRigidBodyInstance(colObj, child.ChildShape, ref childTransform);
         }
     }
     else
     {
         var shapeData = InitShapeData(shape);
         shapeData.Instances.Add(new InstanceData()
         {
             WorldTransform = transform,
             Color = "Ground".Equals(colObj.UserObject) ? groundColor :
                 colObj.ActivationState == ActivationState.ActiveTag ? activeColor : passiveColor
         });
     }
 }
        static void TestRayCast(CollisionObject testObject)
        {
            Vector3 rayFromWorld = testObject.WorldTransform.Origin + new Vector3(0, 0, -2);
            Vector3 rayToWorld = testObject.WorldTransform.Origin + new Vector3(0, 0, 2);
            var rayCallback = new CustomRayCallback(ref rayFromWorld, ref rayToWorld);
            world.RayTestRef(ref rayFromWorld, ref rayToWorld, rayCallback);
            if (rayCallback.CollisionObject != testObject)
            {
                Console.WriteLine("Raycast FAILED!");
            }

            AddToDisposeQueue(rayCallback);
        }
 public bool CheckCollideWithOverride(CollisionObject co)
 {
     return btCollisionObject_checkCollideWithOverride(_native, co._native);
 }
 public bool NeedsResponse(CollisionObject body0, CollisionObject body1)
 {
     return btDispatcher_needsResponse(_native, body0._native, body1._native);
 }
 void OnContactProcessed(ManifoldPoint cp, CollisionObject body0, CollisionObject body1)
 {
     // Debug.WriteLine("OnContactProcessed");
     cp.UserPersistentData = 1;
 }
 public KinematicClosestNotMeConvexResultCallback(CollisionObject me, Vector3 up, float minSlopeDot)
     : base(ref zero, ref zero)
 {
     _me = me;
     _up = up;
     _minSlopeDot = minSlopeDot;
 }
 public override void BOnTriggerExit(CollisionObject other)
 {
     Debug.Log("Exit with " + other.UserObject + " fixedFrame " + BPhysicsWorld.Get().frameCount);
 }
 public void SetBodies(CollisionObject body0, CollisionObject body1)
 {
     btPersistentManifold_setBodies(Native, body0.Native, body1.Native);
 }
 private static bool ContactProcessedUnmanaged(IntPtr cp, IntPtr body0, IntPtr body1)
 {
     _contactProcessed.Invoke(new ManifoldPoint(cp, true), CollisionObject.GetManaged(body0), CollisionObject.GetManaged(body1));
     return(false);
 }
 public override void BOnTriggerStay(CollisionObject other, AlignedManifoldArray manifoldArray)
 {
     Debug.Log("Stay with " + other.UserObject + " fixedFrame " + BPhysicsWorld.Get().frameCount);
 }
		public void ContactTest(CollisionObject colObj, ContactResultCallback resultCallback)
		{
			btCollisionWorld_contactTest(_native, colObj._native, resultCallback._native);
		}
 public KinematicClosestNotMeRayResultCallback(CollisionObject me)
     : base(ref zero, ref zero)
 {
     _me = me;
 }
		public static void ObjectQuerySingle(ConvexShape castShape, Matrix rayFromTrans,
			Matrix rayToTrans, CollisionObject collisionObject, CollisionShape collisionShape,
			Matrix colObjWorldTransform, ConvexResultCallback resultCallback, float allowedPenetration)
		{
			btCollisionWorld_objectQuerySingle(castShape._native, ref rayFromTrans,
				ref rayToTrans, collisionObject._native, collisionShape._native, ref colObjWorldTransform,
				resultCallback._native, allowedPenetration);
		}
		public static void RayTestSingle(Matrix rayFromTrans, Matrix rayToTrans,
			CollisionObject collisionObject, CollisionShape collisionShape, Matrix colObjWorldTransform,
			RayResultCallback resultCallback)
		{
			btCollisionWorld_rayTestSingle(ref rayFromTrans, ref rayToTrans, collisionObject._native,
				collisionShape._native, ref colObjWorldTransform, resultCallback._native);
		}
		public void RemoveCollisionObject(CollisionObject collisionObject)
		{
            _collisionObjectArray.Remove(collisionObject);
		}
 public PersistentManifold GetNewManifold(CollisionObject b0, CollisionObject b1)
 {
     return new PersistentManifold(btDispatcher_getNewManifold(_native, b0._native, b1._native), true);
 }
		public void UpdateSingleAabb(CollisionObject colObj)
		{
			btCollisionWorld_updateSingleAabb(_native, colObj._native);
		}
 public static MultiBodyLinkCollider Upcast(CollisionObject colObj)
 {
     return CollisionObject.GetManaged(btMultiBodyLinkCollider_upcast(colObj._native)) as MultiBodyLinkCollider;
 }
        //called by Physics World just before rigid body is added to world.
        //the current rigid body properties are used to rebuild the rigid body.
        internal virtual bool _BuildCollisionObject()
        {
            BPhysicsWorld world = BPhysicsWorld.Get();
            if (m_collisionObject != null)
            {
                if (isInWorld && world != null)
                {
                    world.RemoveCollisionObject(m_collisionObject);
                }
            }

            if (transform.localScale != UnityEngine.Vector3.one)
            {
                Debug.LogError("The local scale on this collision shape is not one. Bullet physics does not support scaling on a rigid body world transform. Instead alter the dimensions of the CollisionShape.");
            }

            m_collisionShape = GetComponent<BCollisionShape>();
            if (m_collisionShape == null)
            {
                Debug.LogError("There was no collision shape component attached to this BRigidBody. " + name);
                return false;
            }

            CollisionShape cs = m_collisionShape.GetCollisionShape();
            //rigidbody is dynamic if and only if mass is non zero, otherwise static

            if (m_collisionObject == null)
            {
                m_collisionObject = new CollisionObject();
                m_collisionObject.CollisionShape = cs;
                m_collisionObject.UserObject = this;

                BulletSharp.Math.Matrix worldTrans;
                BulletSharp.Math.Quaternion q = transform.rotation.ToBullet();
                BulletSharp.Math.Matrix.RotationQuaternion(ref q, out worldTrans);
                worldTrans.Origin = transform.position.ToBullet();
                m_collisionObject.WorldTransform = worldTrans;
                m_collisionObject.CollisionFlags = m_collisionFlags;
            }
            else {
                m_collisionObject.CollisionShape = cs;
                BulletSharp.Math.Matrix worldTrans;
                BulletSharp.Math.Quaternion q = transform.rotation.ToBullet();
                BulletSharp.Math.Matrix.RotationQuaternion(ref q, out worldTrans);
                worldTrans.Origin = transform.position.ToBullet();
                m_collisionObject.WorldTransform = worldTrans;
                m_collisionObject.CollisionFlags = m_collisionFlags;
            }
            return true;
        }
 public void SetIgnoreCollisionCheck(CollisionObject co, bool ignoreCollisionCheck)
 {
     btCollisionObject_setIgnoreCollisionCheck(_native, co._native, ignoreCollisionCheck);
 }
        protected virtual void Dispose(bool isdisposing)
        {
            if (isInWorld && isdisposing && m_collisionObject != null)
            {
                BPhysicsWorld pw = BPhysicsWorld.Get();
                if (pw != null && pw.world != null)
                {
                    ((DiscreteDynamicsWorld)pw.world).RemoveCollisionObject(m_collisionObject);
                }
            }
            if (m_collisionObject != null)
            {

                m_collisionObject.Dispose();
                m_collisionObject = null;
            }
        }
 public float CalculateTimeOfImpact(CollisionObject body0, CollisionObject body1, DispatcherInfo dispatchInfo, ManifoldResult resultOut)
 {
     return btCollisionAlgorithm_calculateTimeOfImpact(_native, body0._native, body1._native, dispatchInfo._native, resultOut._native);
 }
 public static string GetBodyName(CollisionObject obj)
 {
     return obj.GetName();
 }
Beispiel #35
0
        void InitInstanceData(CollisionObject colObj, CollisionShape shape, ref Matrix transform)
        {
            if (shape.ShapeType == BroadphaseNativeType.CompoundShape)
            {
                foreach (CompoundShapeChild child in (shape as CompoundShape).ChildList)
                {
                    Matrix childTransform = child.Transform * transform;
                    InitInstanceData(colObj, child.ChildShape, ref childTransform);
                }
            }
            else if (shape.ShapeType == BroadphaseNativeType.SoftBodyShape)
            {
                ShapeData shapeData = InitShapeData(shape);
                UpdateSoftBody(colObj as SoftBody, shapeData);

                shapeData.InstanceDataList.Add(new InstanceData()
                {
                    WorldTransform = transform,
                    Color = softBodyColor
                });
            }
            else
            {
                InitShapeData(shape).InstanceDataList.Add(new InstanceData()
                {
                    WorldTransform = transform,
                    Color = "Ground".Equals(colObj.UserObject) ? groundColor :
                        colObj.ActivationState == ActivationState.ActiveTag ? activeColor : passiveColor
                });
            }
        }
Beispiel #36
0
 public static MultiBodyLinkCollider Upcast(CollisionObject colObj)
 {
     return(GetManaged(btMultiBodyLinkCollider_upcast(colObj.Native)) as MultiBodyLinkCollider);
 }