///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
mesh = entryA as StaticMesh;
convex = entryB as ConvexCollidable;
if (mesh == null || convex == null)
{
mesh = entryB as StaticMesh;
convex = entryA as ConvexCollidable;
if (mesh == null || convex == null)
throw new Exception("Inappropriate types used to initialize pair.");
}
//Contact normal goes from A to B.
broadPhaseOverlap.entryA = convex;
broadPhaseOverlap.entryB = mesh;
UpdateMaterialProperties(convex.entity != null ? convex.entity.material : null, mesh.material);
base.Initialize(entryA, entryB);
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
box = entryA as ConvexCollidable<BoxShape>;
sphere = entryB as ConvexCollidable<SphereShape>;
if (box == null || sphere == null)
{
box = entryB as ConvexCollidable<BoxShape>;
sphere = entryA as ConvexCollidable<SphereShape>;
if (box == null || sphere == null)
{
throw new Exception("Inappropriate types used to initialize pair.");
}
}
//Reorder the entries so that the guarantee that the normal points from A to B is satisfied.
broadPhaseOverlap.entryA = box;
broadPhaseOverlap.entryB = sphere;
base.Initialize(entryA, entryB);
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
mobileMesh = entryA as MobileMeshCollidable;
convex = entryB as ConvexCollidable;
if (mobileMesh == null || convex == null)
{
mobileMesh = entryB as MobileMeshCollidable;
convex = entryA as ConvexCollidable;
if (mobileMesh == null || convex == null)
throw new Exception("Inappropriate types used to initialize pair.");
}
//Contact normal goes from A to B.
broadPhaseOverlap.entryA = convex;
broadPhaseOverlap.entryB = mobileMesh;
//It's possible that the convex does not have an entity if it is a proxy for a non-entity collidable.
//Similarly, the mesh could be a query object.
UpdateMaterialProperties(convex.entity != null ? convex.entity.material : null, mobileMesh.entity != null ? mobileMesh.entity.material : null);
base.Initialize(entryA, entryB);
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
//Child initialization is responsible for setting up the entries.
//Child initialization is responsible for setting up the manifold, if any.
manifoldConstraintGroup.Initialize(EntityA, EntityB);
base.Initialize(entryA, entryB);
}
/// <summary>
/// Adds a broad phase overlap if the collision rules permit it.
/// </summary>
/// <param name="entryA">First entry of the overlap.</param>
/// <param name="entryB">Second entry of the overlap.</param>
protected internal void TryToAddOverlap(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
CollisionRule rule;
if ((rule = GetCollisionRule(entryA, entryB)) < CollisionRule.NoBroadPhase)
{
overlapAddLock.Enter();
overlaps.Add(new BroadPhaseOverlap(entryA, entryB, rule));
overlapAddLock.Exit();
}
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
compoundInfoB = entryB as CompoundCollidable;
if (compoundInfoB == null)
{
throw new Exception("Inappropriate types used to initialize pair.");
}
base.Initialize(entryA, entryB);
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
//Child initialization is responsible for setting up the entries.
ContactManifold.Initialize(CollidableA, CollidableB);
ContactConstraint.Initialize(EntityA, EntityB, this);
base.Initialize(entryA, entryB);
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
boxA = entryA as ConvexCollidable<BoxShape>;
boxB = entryB as ConvexCollidable<BoxShape>;
if (boxA == null || boxB == null)
{
throw new Exception("Inappropriate types used to initialize pair.");
}
base.Initialize(entryA, entryB);
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
mesh = entryA as InstancedMesh;
if (mesh == null)
{
mesh = entryB as InstancedMesh;
if (mesh == null)
{
throw new Exception("Inappropriate types used to initialize pair.");
}
}
base.Initialize(entryA, entryB);
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
//Other member of the pair is initialized by the child.
mobileMesh = entryA as MobileMeshCollidable;
if (mobileMesh == null)
{
mobileMesh = entryB as MobileMeshCollidable;
if (mobileMesh == null)
{
throw new Exception("Inappropriate types used to initialize pair.");
}
}
base.Initialize(entryA, entryB);
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
terrain = entryA as Terrain;
if (terrain == null)
{
terrain = entryB as Terrain;
if (terrain == null)
{
throw new Exception("Inappropriate types used to initialize pair.");
}
}
base.Initialize(entryA, entryB);
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
//Other member of the pair is initialized by the child.
compoundInfo = entryA as CompoundCollidable;
if (compoundInfo == null)
{
compoundInfo = entryB as CompoundCollidable;
if (compoundInfo == null)
{
throw new Exception("Inappropriate types used to initialize pair.");
}
}
base.Initialize(entryA, entryB);
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
triangle = entryA as ConvexCollidable<TriangleShape>;
convex = entryB as ConvexCollidable;
if (triangle == null || convex == null)
{
triangle = entryB as ConvexCollidable<TriangleShape>;
convex = entryA as ConvexCollidable;
if (triangle == null || convex == null)
throw new Exception("Inappropriate types used to initialize pair.");
}
//Contact normal goes from A to B.
broadPhaseOverlap.entryA = convex;
broadPhaseOverlap.entryB = triangle;
base.Initialize(entryA, entryB);
}
protected internal CollisionRule GetCollisionRule(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
if (entryA.IsActive || entryB.IsActive)
return CollisionRules.collisionRuleCalculator(entryA.collisionRules, entryB.collisionRules);
return CollisionRule.NoBroadPhase;
}
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
UpdateMaterialProperties();
base.Initialize(entryA, entryB);
}
/// <summary> /// Removes an entry from the broad phase. /// </summary> /// <param name="entry">Entry to remove.</param> public abstract void Remove(BroadPhaseEntry entry);
///<summary>
/// Gets a narrow phase pair for a given pair of entries.
///</summary>
///<param name="entryA">First entry in the pair.</param>
/// <param name="entryB">Second entry in the pair.</param>
/// <param name="rule">Collision rule governing the pair.</param>
///<returns>A INarrowPhasePair for the overlap.</returns>
public static NarrowPhasePair GetPair(BroadPhaseEntry entryA, BroadPhaseEntry entryB, CollisionRule rule)
{
BroadPhaseOverlap overlap = new BroadPhaseOverlap(entryA, entryB, rule);
return GetPair(ref overlap);
}
///<summary>
/// Gets a narrow phase pair for a given pair of entries.
///</summary>
///<param name="entryA">First entry in the pair.</param>
/// <param name="entryB">Second entry in the pair.</param>
///<returns>A INarrowPhasePair for the overlap.</returns>
public static NarrowPhasePair GetPair(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
BroadPhaseOverlap overlap = new BroadPhaseOverlap(entryA, entryB);
return GetPair(ref overlap);
}
/// <summary> /// Adds an entry to the broad phase. /// </summary> /// <param name="entry">Entry to add.</param> public abstract void Add(BroadPhaseEntry entry);
internal EventStoragePairRemoved(BroadPhaseEntry other)
{
this.other = other;
}
void RemoveFriction(EntityCollidable sender, BroadPhaseEntry other, NarrowPhasePair pair)
{
var collidablePair = pair as CollidablePairHandler;
if (collidablePair != null)
{
//The default values for InteractionProperties is all zeroes- zero friction, zero bounciness.
//That's exactly how we want the character to behave when hitting objects.
collidablePair.UpdateMaterialProperties(new InteractionProperties());
}
}
/// <summary>
/// Recovers iobject from broad phase entry.
/// </summary>
/// <param name="entry">The entry.</param>
/// <returns></returns>
public static IObject RecoverObjectFromBroadPhase(BroadPhaseEntry entry)
{
IPhysicObject phyObj = null;
if (entry is Collidable)
{
Collidable collidable = (entry as Collidable);
phyObj = collidable.Tag as IPhysicObject;
return phyObj.ObjectOwner;
}
else
{
return null;
}
}
/// <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;
}
///<summary> /// Initializes the pair. ///</summary> ///<param name="entryA">First entry in the pair.</param> ///<param name="entryB">Second entry in the pair.</param> public abstract void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB);
public override void Remove(BroadPhaseEntry entry)
{
entries.Remove(entry);
}
internal EventStoragePairUpdated(BroadPhaseEntry other, NarrowPhasePair pair)
{
this.other = other;
this.pair = pair;
}
///<summary>
/// Constructs a new ray cast result.
///</summary>
///<param name="hitData">Ray cast hit data.</param>
///<param name="hitObject">Object hit by the ray.</param>
public RayCastResult(RayHit hitData, BroadPhaseEntry hitObject)
{
HitData = hitData;
HitObject = hitObject;
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
mesh = (MobileMeshCollidable)entryB;
base.Initialize(entryA, entryB);
}
bool SupportRayFilterFunction(BroadPhaseEntry entry)
{
//Only permit an object to be used as a support if it fully collides with the character.
return CollisionRules.CollisionRuleCalculator(entry.CollisionRules, character.Body.CollisionInformation.CollisionRules) == CollisionRule.Normal;
}
///<summary>
/// Initializes the pair handler.
///</summary>
///<param name="entryA">First entry in the pair.</param>
///<param name="entryB">Second entry in the pair.</param>
public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
//Child initialization is responsible for setting up the entries.
//Child initialization is responsible for setting up the material.
//Child initialization is responsible for setting up the manifold.
//Child initialization is responsible for setting up the constraint.
if (!suppressEvents)
{
CollidableA.EventTriggerer.OnPairCreated(CollidableB, this);
CollidableB.EventTriggerer.OnPairCreated(CollidableA, this);
}
}