/// <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 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");
}
}
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 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 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);
}
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);
}
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);
}
}
}
}
