/// <summary> /// Triggers a new 3D sound. /// </summary> public Cue Play3DCue(string cueName, IPhysicObject emitter) { Cue3D cue3D; if (this.m_CuePool.Count > 0) { // If possible, reuse an existing Cue3D instance. cue3D = this.m_CuePool.Pop(); } else { // Otherwise we have to allocate a new one. cue3D = new Cue3D(); } // Fill in the cue and emitter fields. cue3D.Cue = this.m_SoundBank.GetCue(cueName); cue3D.Emitter = emitter; // Set the 3D position of this cue, and then play it. Apply3D(cue3D); cue3D.Cue.Play(); // Remember that this cue is now active. this.m_ActiveCues.Add(cue3D); return(cue3D.Cue); }
/// <summary> /// Disparador del evento de vehículo en movimiento /// </summary> /// <param name="vehicle">Vehículo</param> private void FireVehicleMovedEvent(IPhysicObject vehicle) { if (this.VehicleMoved != null) { this.VehicleMoved(vehicle); } }
/// <summary> /// Actualiza el gestor de colisión /// </summary> /// <param name="gameTime">Tiempo de juego</param> public override void Update(GameTime gameTime) { base.Update(gameTime); List <IPhysicObject> list = new List <IPhysicObject>(); foreach (GameComponent gameComponent in this.Game.Components) { IPhysicObject obj = gameComponent as IPhysicObject; if (obj != null) { list.Add(obj); } } for (int a = 0; a < list.Count - 1; a++) { IPhysicObject objA = list[a]; for (int b = a + 1; b < list.Count; b++) { IPhysicObject objB = list[b]; if ((!objA.IsStatic) || (!objB.IsStatic)) { CollisionManager.TestCollision(objA, objB); } } } }
public ServerIObject(IPhysicObject PhysicObject) { System.Diagnostics.Debug.Assert(PhysicObject != null); this.PhysicObject = PhysicObject; IObjectAttachment = new List <IObjectAttachment>(); Name = null; }
public virtual bool CollidesWith(IPhysicObject other) { foreach (Tile tile in tiles) if (!tile.IsHollow && tile.CollidesWith(other)) return true; return false; }
// TODO : optimiz. // This function too will have to be optimized. // public override bool CollidesWith(IPhysicObject hitter) { foreach (Tile[] layer in layers) foreach (Tile tile in layer) if (!tile.IsHollow && tile.CollidesWith(hitter)) return true; return false; }
/// <summary> /// Detects the collisions. /// </summary> /// <param name="po">The po.</param> /// <param name="col">The col.</param> public override void DetectCollisions(IPhysicObject po, List <IPhysicObject> col) { System.Diagnostics.Debug.Assert(col != null); System.Diagnostics.Debug.Assert(po != null); col.Clear(); CollidableCollection CollidableCollection; if (po is TriangleMeshObject) { CollidableCollection = (po as TriangleMeshObject).StaticMesh.OverlappedCollidables; } else { CollidableCollection = (po as BepuEntityObject).Entity.CollisionInformation.OverlappedCollidables; } foreach (var item in CollidableCollection) { IPhysicObject candidate = BepuEntityObject.RecoverIPhysicObjectFromCollidable(item); if (candidate != null) { col.Add(candidate); } } }
public ServerIObject(IPhysicObject PhysicObject) { System.Diagnostics.Debug.Assert(PhysicObject != null); this.PhysicObject = PhysicObject; IObjectAttachment = new List<IObjectAttachment>(); Name = null; }
/// <summary> /// Cuando el vehículo es contactado por otro, se notifica el causante del contacto /// </summary> /// <param name="obj">Objeto que ha contactado con el vehículo actual</param> public void SetContactedWith(IPhysicObject obj) { if (obj is AmmoRound) { this.TakeDamage(obj as AmmoRound); } else if (obj is IVehicle) { //Obtener las velocidades y calcular la magnitud del choque if (this.Velocity > 15f) { this.TakeDamage(this.Velocity, 0f); } } else if (obj is IScenery) { //Usar la velocidad del vehículo como magnitud del choque if (this.Velocity > 15f) { this.TakeDamage(this.Velocity, 0f); } } if (this.Contacted != null) { this.Contacted(obj); } }
/// <summary> /// Cuando el vehículo es contactado por otro, se notifica el causante del contacto /// </summary> /// <param name="obj">Objeto que ha contactado con el vehículo actual</param> public void SetContactedWith(IPhysicObject obj) { if (this.Contacted != null) { this.Contacted(obj); } }
/// <summary> /// Aplica la fuerza del amortiguador al objeto especificado /// </summary> /// <param name="obj">Objeto</param> /// <param name="duration">Duración</param> public override void UpdateForce(ref IPhysicObject obj, float duration) { // Obtener el cuerpo del objeto CollisionPrimitive primitive = obj.Primitive; if (primitive != null) { // Calculate the two ends in world space Vector3 lws = primitive.GetPointInWorldSpace(m_ConnectionPoint); Vector3 ows = m_Other.GetPointInWorldSpace(m_OtherConnectionPoint); // Calculate the vector of the spring Vector3 force = lws - ows; // Calculate the magnitude of the force float magnitude = force.Length(); magnitude = Math.Abs(magnitude - m_RestLength); magnitude *= m_SpringConstant; // Calculate the final force and apply it force.Normalize(); force *= -magnitude; primitive.AddForceAtPoint(force, lws); } }
public override void DetectCollisions(IPhysicObject po, System.Collections.Generic.List <IPhysicObject> resp) { BulletPhysicObject BulletPhysicObject = po as BulletPhysicObject; contactcallbac.objs = new List <IPhysicObject>(); world.ContactTest(BulletPhysicObject.Body, contactcallbac); resp = contactcallbac.objs; }
/// <summary> /// Registra una primitiva de colisión que actuará como objecto /// </summary> /// <param name="primitive">Primitiva de colisión</param> public void RegisterObject(IPhysicObject obj) { this.m_ObjectData.Add(obj); if (obj is IVehicle) { ((IVehicle)obj).Destroyed += new VehicleStateHandler(PhysicsController_OnVehicleDestroyed); } }
/// <summary> /// Constructor /// </summary> /// <param name="game">Juego</param> /// <param name="worldPoint">Punto fijo al que está conectado el mundo</param> /// <param name="obj">Objeto al que está conectado la barra</param> /// <param name="relativeContactPoint">Posición relativa al objeto</param> /// <param name="size">Longitud de la unión</param> public JointComponent( Game game, Vector3 worldPoint, IPhysicObject obj, Vector3 relativeContactPoint, float size) : this(game, null, worldPoint, obj, relativeContactPoint, size) { }
public new bool CollidesWith(IPhysicObject other) { if (base.CollidesWith(other)) { base.RaiseCollisionEvent(this, new TeleportationEventArgs(nextWorld)); return(true); } return(false); }
public SkinnedIObject(GraphicFactory factory, String modelName, IPhysicObject phyobj) { this.Modelo = SkinnedModel = new SkinnedModel(factory, modelName); ForwardSkinnedShader = new ForwardSkinnedShader(); this.Material = new ForwardMaterial(ForwardSkinnedShader); this.PhysicObject = phyobj; IObjectAttachment = new List <IObjectAttachment>(); Name = modelName; }
public SkinnedIObject(GraphicFactory factory,String modelName, IPhysicObject phyobj) { this.Modelo = SkinnedModel = new SkinnedModel(factory,modelName); ForwardSkinnedShader = new ForwardSkinnedShader(); this.Material = new ForwardMaterial(ForwardSkinnedShader); this.PhysicObject = phyobj; IObjectAttachment = new List<IObjectAttachment>(); Name = modelName; }
public new bool CollidesWith(IPhysicObject other) { if (base.CollidesWith(other)) { base.RaiseCollisionEvent(this, new TeleportationEventArgs(nextWorld)); return true; } return false; }
public override void AddObject(IPhysicObject obj) { if (obj is BulletPhysicObject && obj.PhysicObjectTypes != PhysicObjectTypes.GHOST) { BulletPhysicObject BulletPhysicObject = obj as BulletPhysicObject; world.AddRigidBody(BulletPhysicObject.Body, BulletPhysicObject.CollisionFilterGroup, BulletPhysicObject.CollisionFilterMask); BulletPhysicObject.Body.UserObject = obj; } objs.Add(obj); }
/// <summary> /// [Utility] Recovers the object from collidable. /// </summary> /// <param name="collidable">The collidable.</param> /// <returns></returns> public static IObject RecoverObjectFromCollidable(BEPUphysics.Collidables.Collidable collidable) { IPhysicObject phy = (collidable.Tag as IPhysicObject); if (phy != null) { return(phy.ObjectOwner); } return(null); }
/// <summary> /// Añade un generador estático de fuego /// </summary> /// <param name="particleType">Tipo de partícula</param> /// <param name="obj">Objeto que genera el fuego</param> /// <param name="duration">Duración</param> public void AddParticleGenerator(ParticleSystemTypes particleType, IPhysicObject obj, float duration) { if (particleType != ParticleSystemTypes.None) { this.m_ParticleGenerators.Add(new ParticleGenerator() { Emitter = obj, ParticleType = particleType, Duration = duration }); } }
/// <summary> /// [Utility] Recovers the object from entity. /// </summary> /// <param name="entity">The entity.</param> /// <returns></returns> public static IObject RecoverObjectFromEntity(BEPUphysics.Entities.Entity entity) { IPhysicObject phy = (entity.CollisionInformation.Tag as IPhysicObject); if (phy != null) { return(phy.ObjectOwner); } return(null); }
public override void RemoveObject(IPhysicObject obj) { if (obj is BulletPhysicObject && obj.PhysicObjectTypes != PhysicObjectTypes.GHOST) { BulletPhysicObject BulletPhysicObject = obj as BulletPhysicObject; world.RemoveRigidBody(BulletPhysicObject.Body); BulletPhysicObject.Body.UserObject = null; } objs.Remove(obj); }
/// <summary> /// Disparador del evento de contacto /// </summary> /// <param name="obj">Objeto contactado</param> public void SetContactedWith(IPhysicObject obj) { this.m_Active = false; this.OnDeactivated(); if (this.Contacted != null) { this.Contacted(obj); } }
public virtual bool CollidesWith(IPhysicObject other) { foreach (Tile tile in tiles) { if (!tile.IsHollow && tile.CollidesWith(other)) { return(true); } } return(false); }
public NetworkCliente(IWorld world, String serverName = "GameServer", int port = 14242, bool waitForConnect = true) { Debug.Assert(world != null); this.world = world; NetPeerConfiguration config = new NetPeerConfiguration(serverName); config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse); client = new NetClient(config); client.Start(); client.DiscoverLocalPeers(port); if (waitForConnect) { waitConnection(); } AddMessageHandler(NetMessageType.CreateNetworkObjectOnClient, RecieveCreateNetworkObjectOnClient); AddMessageHandler(NetMessageType.PhysicInternalSync, StartRecieveSyncPhysicMessages); AddMessageHandler(NetMessageType.Echo, HandleEchoMessage); RegisterMessagePhysicSync(PhysicObjectTypes.SPHEREOBJECT, (mes, obj) => { IPhysicObject ent = obj.PhysicObject; ent.Position = mes.ReadVector3(); ent.Rotation = Matrix.CreateFromQuaternion(mes.ReadRotation()); ent.Velocity = mes.ReadVector3(); ent.AngularVelocity = mes.ReadVector3(); } ); RegisterMessagePhysicSync(PhysicObjectTypes.BOXOBJECT, (mes, obj) => { IPhysicObject ent = obj.PhysicObject; ent.Position = mes.ReadVector3(); ent.Rotation = Matrix.CreateFromQuaternion(mes.ReadRotation()); ent.Velocity = mes.ReadVector3(); ent.AngularVelocity = mes.ReadVector3(); } ); RegisterMessagePhysicSync(PhysicObjectTypes.CYLINDEROBJECT, (mes, obj) => { IPhysicObject ent = obj.PhysicObject; ent.Position = mes.ReadVector3(); ent.Rotation = Matrix.CreateFromQuaternion(mes.ReadRotation()); ent.Velocity = mes.ReadVector3(); ent.AngularVelocity = mes.ReadVector3(); } ); }
/// <summary> /// Recovers physicobject from broad phase entry. /// </summary> /// <param name="entry">The entry.</param> /// <returns></returns> public static IPhysicObject RecoverIPhysicObjectFromBroadPhase(BroadPhaseEntry entry) { IPhysicObject phyObj = null; if (entry is Collidable) { Collidable collidable = (entry as Collidable); phyObj = collidable.Tag as IPhysicObject; } return(phyObj); }
public PointPointConstraint(Vector3 position, IPhysicObject obA, IPhysicObject obB) { if (obA.PhysicObjectTypes != PhysicObjectTypes.TRIANGLEMESHOBJECT && obB.PhysicObjectTypes != PhysicObjectTypes.TRIANGLEMESHOBJECT) { BodyA = (BepuEntityObject)obA; BodyB = (BepuEntityObject)obB; joint = new BallSocketJoint(BodyA.Entity, BodyB.Entity, position); } else { throw new Exception("Cannot apply this Constraint on Triangle Meshes"); } }
/// <summary> /// Constructor /// </summary> /// <param name="game">Juego</param> /// <param name="objOne">Objeto primero al que está conectado la barra</param> /// <param name="relativeContactPointOne">Posición relativa al objeto uno</param> /// <param name="objTwo">Objeto segundo al que está conectado la barra</param> /// <param name="relativeContactPointTwo">Posición relativa al objeto dos</param> /// <param name="size">Longitud de la barra</param> public Joint2Component( Game game, IPhysicObject objOne, Vector3 relativeContactPointOne, IPhysicObject objTwo, Vector3 relativeContactPointTwo, float size) : base(game) { this.Rod = new Joint2(objOne, relativeContactPointOne, objTwo, relativeContactPointTwo, size); PolyGenerator.InitializeLine(out this.m_LineVertices, Vector3.Zero, Vector3.One, Color.Red); }
public override void AddObject(IPhysicObject obj) { if (obj is PhysxPhysicObject) { PhysxPhysicObject PhysxPhysicObject = obj as PhysxPhysicObject; if (PhysxPhysicObject.Actor == null) { PhysxPhysicObject.Actor = Scene.CreateActor(PhysxPhysicObject.ActorDesc, int.MaxValue); PhysxPhysicObject.Actor.UserData = obj; for (int i = 0; i < PhysxPhysicObject.ActorDesc.Shapes.Count; i++) { PhysxPhysicObject.Actor.Shapes[i].UserData = PhysxPhysicObject.ActorDesc.Shapes[i].UserData; } } else { PhysxPhysicObject.Actor.UserData = obj; } } else if (obj is PhysxClothObject) { PhysxClothObject PhysxPhysicObject = obj as PhysxClothObject; PhysxPhysicObject.Cloth = Scene.CreateCloth(PhysxPhysicObject.ClothDesc); PhysxPhysicObject.Cloth.UserData = obj; } else if (obj is PhysxFluidObject) { PhysxFluidObject PhysxPhysicObject = obj as PhysxFluidObject; PhysxPhysicObject.Fluid = Scene.CreateFluid(PhysxPhysicObject.FluidDesc); PhysxPhysicObject.Fluid.UserData = obj; } else if (obj is PhysxCapsuleCharacterObject) { PhysxCapsuleCharacterObject PhysxPhysicObject = obj as PhysxCapsuleCharacterObject; PhysxPhysicObject.Controller = ControllerManager.CreateController <CapsuleController>(PhysxPhysicObject.CapsuleControllerDescription); PhysxPhysicObject.Controller.UserData = obj; } else if (obj is PhysxBoxCharacterObject) { PhysxBoxCharacterObject PhysxPhysicObject = obj as PhysxBoxCharacterObject; PhysxPhysicObject.Controller = ControllerManager.CreateController <BoxController>((PhysxPhysicObject.BoxControllerDescription)); PhysxPhysicObject.Controller.UserData = obj; } objs.Add(obj); }
public Character(Vector2D position, Vector2D speed, DirectionAnimationCouple animationCouples, World world, string animation, int collisionLayer) : base(position) { this.collisionLayer = collisionLayer; this.world = world is LayeredWorld ? (LayeredWorld)world : world; this.speed = speed; this.position = position; this.animationCouples = animationCouples; this.animation = AnimationGroupManager.GetAnimationGroup(animation); this.animation.CurrentAnimation = animationCouples[Direction.Down]; }
public override bool CollidesWith(IPhysicObject other) { CirclePhysicsObject cpo = ExceptionHelper.AssertIsTAndReturnCasted <CirclePhysicsObject>(other, "CirclePhysicsObject.Collides()"); float distance = (float)(Math.Abs((decimal)((cpo.position - this.position).Magnitude))); // The distance is the magnitude of the vector linking this object's // position to the other's position. //Because 'radius' is always positive, we have to be sure that //'distance' is too. That's the perfect job for Math.Abs(). return(distance < radius); //It's on the circle hitbox if is inferior //to the radius of this circle. }
/// <summary> /// Constructor /// </summary> /// <param name="bodyOne">Cuerpo uno</param> /// <param name="relativePointOne">Posición de unión relativa al cuerpo uno</param> /// <param name="bodyTwo">Cuerpo dos</param> /// <param name="relativePointTwo">Posición de unión relativa al cuerpo dos</param> /// <param name="length">Longitud de la barra</param> public Rod( IPhysicObject bodyOne, Vector3 relativePointOne, IPhysicObject bodyTwo, Vector3 relativePointTwo, float length) : base() { this.m_BodyOne = bodyOne; this.m_BodyTwo = bodyTwo; this.m_RelativePointOne = relativePointOne; this.m_RelativePointTwo = relativePointTwo; this.m_Length = length; }
public override bool CollidesWith(IPhysicObject hitter, Direction direction) { PhysicsObject hit = (PhysicsObject)hitter; Vector2D dirVec = VectorHelper.GetDirectionVector(direction); int x = (int)(hit.Position.X / TextureManager.TextureSize.X + dirVec.X); int y = (int)(hit.Position.Y / TextureManager.TextureSize.Y + dirVec.Y); int index = CoordinateSystemConverter.PlaneToLine(new Vector2D(x, y), Width); Tile tile = layers[Layer][index]; if (tile.IsHollow) return false; return tile.CollidesWith(hit); }
// TODO : optimiz. // This function too will have to be optimized. // public override bool CollidesWith(IPhysicObject hitter) { foreach (Tile[] layer in layers) { foreach (Tile tile in layer) { if (!tile.IsHollow && tile.CollidesWith(hitter)) { return(true); } } } return(false); }
/// <summary> /// Realiza los tests de colisión /// </summary> /// <param name="obj1">Objeto 1</param> /// <param name="obj2">Objeto 2</param> public static void TestCollision(IPhysicObject obj1, IPhysicObject obj2) { if ((obj1 != null) && (obj2 != null)) { //if (obj1.BSph.Intersects(obj2.BSph)) { if (IntersectionTests.BoxAndBox(obj1.TransformedOBB, obj2.TransformedOBB)) { obj1.Reaction(obj2); obj2.Reaction(obj1); } } } }
/// <summary> /// Initializes a new instance of the <see cref="IObject"/> class. /// </summary> /// <param name="Material">The material. (cannot be null, use the InvisibleMaterial.GetInstance when you dont need Material)</param> /// <param name="Modelo">The modelo. (can be null)</param> /// <param name="PhysicObject">The physic object. (cannot be null)</param> /// <param name="name">The name of the IObject (just an identifier).</param> public IObject(IMaterial Material, IModelo Modelo, IPhysicObject PhysicObject,String name = null) { System.Diagnostics.Debug.Assert(Material != null); System.Diagnostics.Debug.Assert(PhysicObject != null); this.Material = Material; this.Modelo = Modelo; this.PhysicObject = PhysicObject; this.Name = name; IObjectAttachment = new List<IObjectAttachment>(); if (this.Modelo == null && this.Material != null) { Material.IsVisible = false; #if !WINDOWS_PHONE && !REACH Material.CanAppearOfReflectionRefraction = false; Material.CanCreateShadow = false; #endif } }
public override void GetPhysicsObjectsInRange(IPhysicObject po, float distance, CullerConditionAvaliator<IPhysicObject, SceneControl.IObject> CullerAvaliator, System.Collections.Generic.List<IPhysicObject> resp) { SphereShape.SetUnscaledRadius(distance); CollisionObject.WorldTransform = Matrix.CreateTranslation(po.Position); CollisionObject.CollisionShape = SphereShape; contactcallbac.objs = new List<IPhysicObject>(); world.ContactTest(CollisionObject, contactcallbac); foreach (var item in contactcallbac.objs) { if (CullerAvaliator(item, item.ObjectOwner) == true) { resp.Add(item); } } }
/// <summary> /// Removes the object. /// </summary> /// <param name="obj">The obj.</param> public abstract void RemoveObject(IPhysicObject obj);
/// <summary> /// Adds the object. /// </summary> /// <param name="obj">The obj.</param> public abstract void AddObject(IPhysicObject obj);
public override void GetPhysicsObjectsInRange(IPhysicObject po, float distance, CullerConditionAvaliator<IPhysicObject, SceneControl.IObject> CullerAvaliator, List<IPhysicObject> resp) { foreach (var item in Scene.OverlappedShapes(new Sphere(distance, po.Position.AsPhysX()), ShapesType.All)) { if (item.Actor.UserData is IPhysicObject) { IPhysicObject IPhysicObject = item.Actor.UserData as IPhysicObject; if (CullerAvaliator(IPhysicObject, IPhysicObject.ObjectOwner)) { resp.Add(IPhysicObject); } } } }
public override void DetectCollisions(IPhysicObject po, System.Collections.Generic.List<IPhysicObject> resp) { BulletPhysicObject BulletPhysicObject = po as BulletPhysicObject; contactcallbac.objs = new List<IPhysicObject>(); world.ContactTest(BulletPhysicObject.Body, contactcallbac); resp = contactcallbac.objs; }
/// <summary> /// Detects the collisions of a physic object /// </summary> /// <param name="po">The po.</param> /// <param name="resp">The resp.</param> public abstract void DetectCollisions(IPhysicObject po,List<IPhysicObject> resp);
public BaseObject(IMaterial mat, IPhysicObject py, IModelo model) : base(mat,model,py) { }
public override void RemoveObject(IPhysicObject obj) { if (obj is PhysxPhysicObject) { PhysxPhysicObject PhysxPhysicObject = obj as PhysxPhysicObject; PhysxPhysicObject.RigidActor.UserData = null; scene.RemoveActor(PhysxPhysicObject.RigidActor); } else if (obj is PhysxTriangleMesh) { PhysxTriangleMesh PhysxTriangleMesh = obj as PhysxTriangleMesh; PhysxTriangleMesh.StaticActor.UserData = null; scene.RemoveActor(PhysxTriangleMesh.StaticActor); } else if (obj is PhysxStaticActor) { PhysxStaticActor PhysxTriangleMesh = obj as PhysxStaticActor; PhysxTriangleMesh.StaticActor.UserData = null; scene.RemoveActor(PhysxTriangleMesh.StaticActor); } objs.Remove(obj); }
public MoveablePointLight(IPhysicObject obj, Color color, float lightRadius, float lightIntensity) : base(obj.Position, color, lightRadius, lightIntensity) { this.ob = obj; }
public RVOObject(int id, IMaterial mat, IModelo model,IPhysicObject py) : base(mat,model,py) { this.RVOID = id; }
public virtual bool CollidesWith(IPhysicObject other, Direction direction) { throw new NotImplementedException(); }
public bool CollidesWith(IPhysicObject other) { return hitbox.CollidesWith(other); }
public override void DetectCollisions(IPhysicObject po, List<IPhysicObject> resp) { PhysxPhysicObject PhysxPhysicObject = po as PhysxPhysicObject; }
/// <summary> /// Removes the object. /// </summary> /// <param name="obj">The obj.</param> public override void RemoveObject(IPhysicObject obj) { if (obj.PhysicObjectTypes == PhysicObjectTypes.TRIANGLEMESHOBJECT) { TriangleMeshObject bo = (TriangleMeshObject)obj; bo.StaticMesh.Tag = null; space.Remove(bo.StaticMesh); objs.Remove(obj); } else if (obj.PhysicObjectTypes == PhysicObjectTypes.InstancedTriangleMeshObject) { InstancedTriangleMeshObject bo = (InstancedTriangleMeshObject)obj; bo.InstancedMesh.Tag = null; space.Remove(bo.InstancedMesh); objs.Remove(obj); } else if (obj.PhysicObjectTypes == PhysicObjectTypes.MobilePhysicObject) { MobileMeshObject bo = (MobileMeshObject)obj; bo.MobileMesh.Tag = null; space.Remove(bo.MobileMesh); objs.Remove(obj); } else if (obj.PhysicObjectTypes == PhysicObjectTypes.SPECIALIZEDMOVER) { ObjectMover m = (ObjectMover)obj; space.Remove(m.BepuEntityObject.Entity); m.BepuEntityObject.Entity.CollisionInformation.Tag = null; space.Remove(m.Mover); space.Remove(m.Rotator); objs.Remove(m.BepuEntityObject); } else if (obj.PhysicObjectTypes == PhysicObjectTypes.DETECTOROBJECT) { DetectorVolumeObject m = (DetectorVolumeObject)obj; space.Remove(m.DetectorVolume); } else if (obj.PhysicObjectTypes == PhysicObjectTypes.TERRAIN) { TerrainObject t = obj as TerrainObject; space.Remove(t.Terrain); t.Terrain.Tag = null; objs.Remove(obj); } else if (obj.PhysicObjectTypes == PhysicObjectTypes.CHARACTEROBJECT) { CharacterObject cc = (CharacterObject)obj; cc.CharacterController.Body.CollisionInformation.Tag = null; space.Remove(cc.CharacterController); objs.Remove(obj); } else if (obj.PhysicObjectTypes == PhysicObjectTypes.FULLCHARACTEROBJECT) { FullCharacterObject cc = (FullCharacterObject)obj; cc.CharacterController.Body.CollisionInformation.Tag = null; space.Remove(cc.CharacterController); objs.Remove(obj); } else if (obj.PhysicObjectTypes == PhysicObjectTypes.SPHERECHARACTEROBJECT) { SphereCharacterObject cc = (SphereCharacterObject)obj; cc.CharacterController.Body.CollisionInformation.Tag = null; space.Remove(cc.CharacterController); objs.Remove(obj); } else if (obj.PhysicObjectTypes == PhysicObjectTypes.GHOST) { //if (obj is AgregatedPhysicObject) //{ // objs.Remove(obj); // AgregatedPhysicObject ag = obj as AgregatedPhysicObject; // foreach (var item in ag.PhysicsObjects) // { // item.ObjectOwner = null; // this.RemoveObject(item); // } //} //else //{ objs.Remove(obj); //} } else { BepuEntityObject bo = (BepuEntityObject)obj; bo.Entity.CollisionInformation.Tag = null; space.Remove(bo.Entity); objs.Remove(obj); } }
/// <summary> /// Get the objects near the object passed as parameter /// </summary> /// <param name="po">The po.</param> /// <param name="distance">The distance.</param> /// <param name="CullerAvaliator">The culler avaliator.</param> /// <param name="resp">The resp.</param> public abstract void GetPhysicsObjectsInRange(IPhysicObject po, float distance, CullerConditionAvaliator<IPhysicObject, IObject> CullerAvaliator,List<IPhysicObject> resp);
/// <summary> /// Detects the collisions. /// </summary> /// <param name="po">The po.</param> /// <param name="col">The col.</param> public override void DetectCollisions(IPhysicObject po,List<IPhysicObject> col) { System.Diagnostics.Debug.Assert(col!=null); System.Diagnostics.Debug.Assert(po != null); col.Clear(); CollidableCollection CollidableCollection; if (po is TriangleMeshObject) { CollidableCollection = (po as TriangleMeshObject).StaticMesh.OverlappedCollidables; } else { CollidableCollection = (po as BepuEntityObject).Entity.CollisionInformation.OverlappedCollidables; } foreach (var item in CollidableCollection) { IPhysicObject candidate = BepuEntityObject.RecoverIPhysicObjectFromCollidable(item); if(candidate!=null) col.Add(candidate); } }
/// <summary> /// Gets the physics objects in range. /// </summary> /// <param name="po">The po.</param> /// <param name="distance">The distance.</param> /// <param name="condition">The condition.</param> /// <param name="resp">The resp.</param> public override void GetPhysicsObjectsInRange(IPhysicObject po, float distance, CullerConditionAvaliator<IPhysicObject, IObject> condition,List<IPhysicObject> resp) { resp.Clear(); List<BroadPhaseEntry> ent = new List<BroadPhaseEntry>(); space.BroadPhase.QueryAccelerator.GetEntries(new BoundingSphere(po.Position, distance), ent); foreach (var item in ent) { IPhysicObject phyObj = BepuEntityObject.RecoverIPhysicObjectFromBroadPhase(item); if (phyObj != null) { if (condition(phyObj, phyObj.ObjectOwner)) { resp.Add(phyObj); } } } }
public override bool CollidesWith(IPhysicObject other) { RectanglePhysicsObject rpo = ExceptionHelper.AssertIsTAndReturnCasted<RectanglePhysicsObject>(other,"RectanglePhysicsObject.Collides()"); return rpo.hitbox.Intersects(this.hitbox); }
public override void GetPhysicsObjectsInRange(IPhysicObject po, float distance, CullerConditionAvaliator<IPhysicObject, SceneControl.IObject> CullerAvaliator, List<IPhysicObject> resp) { SphereGeometry SphereGeometry = new PhysX.SphereGeometry(distance); foreach (var item in scene.OverlapMultiple(SphereGeometry, PhysX.Math.Matrix.Translation(po.Position.AsPhysX()))) { if (item.UserData is IPhysicObject) { IPhysicObject IPhysicObject =item.UserData as IPhysicObject; if (CullerAvaliator(IPhysicObject, IPhysicObject.ObjectOwner)) { resp.Add(IPhysicObject); } } } }