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); }
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); } }
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); }
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(); }
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 }); } }
public static MultiBodyLinkCollider Upcast(CollisionObject colObj) { return(GetManaged(btMultiBodyLinkCollider_upcast(colObj.Native)) as MultiBodyLinkCollider); }