/// <summary>
/// Sweeps a convex shape against the physics world reporting all hits on the path that are not ignored by the filter, beware convex sweeps can be very costly especially if they are long
/// </summary>
/// <param name="shape">Shape to sweep</param>
/// <param name="startPos">Location to start the sweep from</param>
/// <param name="rotation">Rotation of the shape during the sweep</param>
/// <param name="sweep">Direction in which to sweep, the length of the vector is the length of the sweep</param>
/// <param name="group">Collision group to filter the sweep hits, anything above "NoSolver" is ignored</param>
/// <param name="outSweepResults">All overlaps on the sweep path</param>
/// <returns>True if any object was hit</returns>
public bool MultiSweep(ConvexShape shape, ref SharpDX.Vector3 startPos, ref SharpDX.Quaternion rotation, ref SharpDX.Vector3 sweep, CollisionGroup group, List <SRaycastResult> outSweepResults)
{
RigidTransform startTransform = new RigidTransform(startPos.ToBepu(), rotation.ToBepu());
Vector3 sweepVector = sweep.ToBepu();
List <RayCastResult> physicsResults = new List <RayCastResult>();
if (m_physicSpace.ConvexCast(shape, ref startTransform, ref sweepVector, GetOverlapFilter(group), physicsResults))
{
foreach (RayCastResult physicsResult in physicsResults)
{
if (physicsResult.HitObject.Tag is CEntity gameEntity)
{
CollisionRule rule = GetCollisionRuleWithGroup(physicsResult.HitObject, group);
SRaycastResult gameResult = new SRaycastResult()
{
HitEntity = gameEntity,
Location = physicsResult.HitData.Location.ToSharp(),
Normal = -physicsResult.HitData.Normal.ToSharp(),
Distance = physicsResult.HitData.T,
bIsSolidHit = rule <= CollisionRule.Normal
};
outSweepResults.Add(gameResult);
}
}
return(outSweepResults.Count > 0);
}
return(false);
}
/// <summary>
/// Defines a CollisionRule between every group in the first set and every group in the second set for a given space.
/// </summary>
/// <param name="aGroups">First set of groups.</param>
/// <param name="bGroups">Second set of groups.</param>
/// <param name="rule">Collision rule to define between the sets.</param>
/// <param name="space">Space to add the rules to.</param>
public static void DefineCollisionRulesBetweenSets(List<CollisionGroup> aGroups, List<CollisionGroup> bGroups, CollisionRule rule)
{
foreach (CollisionGroup group in aGroups)
{
DefineCollisionRulesWithSet(group, bGroups, rule);
}
}
/// <summary>
/// Returns all overlapping objects of a given ray with the physics world, the ray does NOT stop at solid hit but will report all overlaps and solid hits on the ray
/// </summary>
/// <param name="ray">Ray to test against</param>
/// <param name="length">Maximum distance to test</param>
/// <param name="group">Collision Group to use for the ray anything above "NoSolver" is ignored</param>
/// <param name="outResults">All overlaps on the ray</param>
/// <returns>True if any object was hit</returns>
public bool RayOverlap(ref Ray ray, float length, CollisionGroup group, List <SRaycastResult> outResults)
{
List <RayCastResult> physicsResults = new List <RayCastResult>();
if (m_physicSpace.RayCast(ray.ToBepu(), length, GetOverlapFilter(group), physicsResults))
{
foreach (RayCastResult physicsResult in physicsResults)
{
if (physicsResult.HitObject.Tag is CEntity gameEntity)
{
CollisionRule rule = GetCollisionRuleWithGroup(physicsResult.HitObject, group);
SRaycastResult gameResult = new SRaycastResult()
{
HitEntity = gameEntity,
Location = physicsResult.HitData.Location.ToSharp(),
Normal = physicsResult.HitData.Normal.ToSharp(),
Distance = physicsResult.HitData.T,
bIsSolidHit = rule <= CollisionRule.Normal
};
outResults.Add(gameResult);
}
}
return(outResults.Count > 0);
}
return(false);
}
/// <summary>
/// Defines a CollisionRule between a group and every group in a set of groups for a given space.
/// </summary>
/// <param name="group">First CollisionGroup of the pair.</param>
/// <param name="groups">Set of CollisionGroups; each group will have its CollisionRule with the first group defined.</param>
/// <param name="rule">CollisionRule to use between the pairs.</param>
public static void DefineCollisionRulesWithSet(CollisionGroup group, List<CollisionGroup> groups, CollisionRule rule)
{
foreach (CollisionGroup g in groups)
{
DefineCollisionRule(group, g, rule);
}
}
/// <summary>
/// Defines a CollisionRule between every group in the first set and every group in the second set for a given space.
/// </summary>
/// <param name="aGroups">First set of groups.</param>
/// <param name="bGroups">Second set of groups.</param>
/// <param name="rule">Collision rule to define between the sets.</param>
public static void DefineCollisionRulesBetweenSets(List <CollisionGroup> aGroups, List <CollisionGroup> bGroups,
CollisionRule rule)
{
foreach (CollisionGroup group in aGroups)
{
DefineCollisionRulesWithSet(group, bGroups, rule);
}
}
//Equals is not overriden because the hashcode because the hashcode is the default hashcode, just modified a bit.
/// <summary>
/// Defines the CollisionRule between the two groups for a given space.
/// </summary>
/// <param name="groupA">First CollisionGroup of the pair.</param>
/// <param name="groupB">Second CollisionGroup of the pair.</param>
/// <param name="rule">CollisionRule to use between the pair.</param>
public static void DefineCollisionRule(CollisionGroup groupA, CollisionGroup groupB, CollisionRule rule)
{
var pair = new CollisionGroupPair(groupA, groupB);
if (CollisionRules.CollisionGroupRules.ContainsKey(pair))
CollisionRules.CollisionGroupRules[pair] = rule;
else
CollisionRules.CollisionGroupRules.Add(pair, rule);
}
/// <summary>
/// Defines a CollisionRule between a group and every group in a set of groups for a given space.
/// </summary>
/// <param name="group">First CollisionGroup of the pair.</param>
/// <param name="groups">Set of CollisionGroups; each group will have its CollisionRule with the first group defined.</param>
/// <param name="rule">CollisionRule to use between the pairs.</param>
public static void DefineCollisionRulesWithSet(CollisionGroup group, List <CollisionGroup> groups,
CollisionRule rule)
{
foreach (CollisionGroup g in groups)
{
DefineCollisionRule(group, g, rule);
}
}
private Func <BroadPhaseEntry, bool> GetOverlapFilter(ICollisionRulesOwner rulesOwner)
{
bool Filter(BroadPhaseEntry e)
{
CollisionRule rule = CollisionRules.GetCollisionRule(e, rulesOwner);
return(rule <= CollisionRule.NoSolver);
}
return(Filter);
}
private CollisionRule CustomCollisionRuleCalculator(ICollisionRulesOwner aOwner, ICollisionRulesOwner bOwner)
{
CollisionRules a = aOwner.CollisionRules;
CollisionRules b = bOwner.CollisionRules;
CollisionRule groupRule = CollisionRules.GetGroupCollisionRuleDefault(a, b);
if (groupRule == CollisionRule.NoBroadPhase)
{
return(groupRule);
}
return(CollisionRules.GetCollisionRuleDefault(aOwner, bOwner));
}
/// <summary>
/// Defines a CollisionRule between every group in a set with itself and the others in the set for a given space.
/// </summary>
/// <param name="groups">Set of CollisionGroups.</param>
/// <param name="self">CollisionRule between each group and itself.</param>
/// <param name="other">CollisionRule between each group and every other group in the set.</param>
public static void DefineCollisionRulesInSet(List <CollisionGroup> groups, CollisionRule self, CollisionRule other)
{
for (int i = 0; i < groups.Count; i++)
{
DefineCollisionRule(groups[i], groups[i], self);
}
for (int i = 0; i < groups.Count - 1; i++)
{
for (int j = i + 1; j < groups.Count; j++)
{
DefineCollisionRule(groups[i], groups[j], other);
}
}
}
/// <summary>
/// Defines a CollisionRule between every group in a set with itself and the others in the set for a given space.
/// </summary>
/// <param name="groups">Set of CollisionGroups.</param>
/// <param name="self">CollisionRule between each group and itself.</param>
/// <param name="other">CollisionRule between each group and every other group in the set.</param>
public static void DefineCollisionRulesInSet(List<CollisionGroup> groups, CollisionRule self, CollisionRule other)
{
for (int i = 0; i < groups.Count; i++)
{
DefineCollisionRule(groups[i], groups[i], self);
}
for (int i = 0; i < groups.Count - 1; i++)
{
for (int j = i + 1; j < groups.Count; j++)
{
DefineCollisionRule(groups[i], groups[j], other);
}
}
}
/// <summary>
/// Determines what collision rule governs the interaction between the two objects.
/// </summary>
/// <param name="a">First ruleset in the pair. This entity's space is used to determine the collision detection settings that contain special collision group interaction rules.</param>
/// <param name="b">Second ruleset in the pair.</param>
/// <returns>Collision rule governing the interaction between the pair.</returns>
public static CollisionRule GetCollisionRuleDefault(CollisionRules a, CollisionRules b)
{
CollisionRule pairRule = GetSpecificCollisionRuleDefault(a, b);
if (pairRule == CollisionRule.Defer)
{
pairRule = GetPersonalCollisionRuleDefault(a, b);
if (pairRule == CollisionRule.Defer)
{
pairRule = GetGroupCollisionRuleDefault(a, b);
}
}
if (pairRule == CollisionRule.Defer)
{
pairRule = DefaultCollisionRule;
}
return(pairRule);
}
/// <summary>
/// Determines what collision rule governs the interaction between the two objects.
/// </summary>
/// <param name="aOwner">First ruleset owner in the pair. This entity's space is used to determine the collision detection settings that contain special collision group interaction rules.</param>
/// <param name="bOwner">Second ruleset owner in the pair.</param>
/// <returns>Collision rule governing the interaction between the pair.</returns>
public static CollisionRule GetCollisionRuleDefault(ICollisionRulesOwner aOwner, ICollisionRulesOwner bOwner)
{
var a = aOwner.CollisionRules;
var b = bOwner.CollisionRules;
CollisionRule pairRule = GetSpecificCollisionRuleDefault(a, b);
if (pairRule == CollisionRule.Defer)
{
pairRule = GetPersonalCollisionRuleDefault(a, b);
if (pairRule == CollisionRule.Defer)
{
pairRule = GetGroupCollisionRuleDefault(a, b);
}
}
if (pairRule == CollisionRule.Defer)
{
pairRule = DefaultCollisionRule;
}
return(pairRule);
}
/// <summary>
/// Constructs an overlap.
/// </summary>
/// <param name="entryA">First entry in the pair.</param>
/// <param name="entryB">Second entry in the pair.</param>
/// <param name="collisionRule">Collision rule calculated for the pair.</param>
public BroadPhaseOverlap(BroadPhaseEntry entryA, BroadPhaseEntry entryB, CollisionRule collisionRule)
{
this.entryA = entryA;
this.entryB = entryB;
this.collisionRule = collisionRule;
}
/// <summary>
/// Constructs an overlap.
/// </summary>
/// <param name="entryA">First entry in the pair.</param>
/// <param name="entryB">Second entry in the pair.</param>
public BroadPhaseOverlap(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
{
this.entryA = entryA;
this.entryB = entryB;
collisionRule = CollisionRules.DefaultCollisionRule;
}
/// <summary>
/// Gets a collidable pair handler for a pair of collidables.
/// </summary>
/// <param name="pair">Pair of collidables to use to create the pair handler.</param>
/// <param name="rule">Collision rule governing the pair.</param>
/// <returns>CollidablePairHandler for the pair.</returns>
public static CollidablePairHandler GetPairHandler(ref CollidablePair pair, CollisionRule rule)
{
var overlap = new BroadPhaseOverlap(pair.collidableA, pair.collidableB, rule);
return GetPairHandler(ref overlap) as CollidablePairHandler;
}
///<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 NarrowPhasePair for the overlap.</returns>
public static NarrowPhasePair GetPairHandler(BroadPhaseEntry entryA, BroadPhaseEntry entryB, CollisionRule rule)
{
var overlap = new BroadPhaseOverlap(entryA, entryB, rule);
return GetPairHandler(ref overlap);
}
///<summary>
/// Adds an entry in rulesA's Specific relationships list about ownerB.
///</summary>
///<param name="rulesA">Collision rules that will gain an entry in its Specific relationships.</param>
///<param name="ownerB">Owner of the collision rules that will be added to ownerA's Specific relationships.</param>
///<param name="rule">Rule assigned to the pair.</param>
public static void AddRule(CollisionRules rulesA, ICollisionRulesOwner ownerB, CollisionRule rule)
{
rulesA.specific.Add(ownerB.CollisionRules, rule);
}
///<summary>
/// Adds an entry in rulesA's Specific relationships list about ownerB.
///</summary>
///<param name="ownerA">Owner of the collision rules that will gain an entry in its Specific relationships.</param>
///<param name="rulesB">Collision rules that will be added to ownerA's Specific relationships.</param>
///<param name="rule">Rule assigned to the pair.</param>
public static void AddRule(ICollisionRulesOwner ownerA, CollisionRules rulesB, CollisionRule rule)
{
ownerA.CollisionRules.specific.Add(rulesB, rule);
}
///<summary>
/// Adds an entry in rulesA's Specific relationships list about ownerB.
///</summary>
///<param name="rulesA">Collision rules that will gain an entry in its Specific relationships.</param>
///<param name="ownerB">Owner of the collision rules that will be added to ownerA's Specific relationships.</param>
///<param name="rule">Rule assigned to the pair.</param>
public static void AddRule(CollisionRules rulesA, ICollisionRulesOwner ownerB, CollisionRule rule)
{
rulesA.specific.Add(ownerB.CollisionRules, rule);
}
/// <summary>
/// Gets a collidable pair handler for a pair of collidables.
/// </summary>
/// <param name="pair">Pair of collidables to use to create the pair handler.</param>
/// <param name="rule">Collision rule governing the pair.</param>
/// <returns>CollidablePairHandler for the pair.</returns>
public static CollidablePairHandler GetPairHandler(ref CollidablePair pair, CollisionRule rule)
{
var overlap = new BroadPhaseOverlap(pair.collidableA, pair.collidableB, rule);
return(GetPairHandler(ref overlap) as CollidablePairHandler);
}
//Equals is not overriden because the hashcode because the hashcode is the default hashcode, just modified a bit.
/// <summary>
/// Defines the CollisionRule between the two groups for a given space.
/// </summary>
/// <param name="groupA">First CollisionGroup of the pair.</param>
/// <param name="groupB">Second CollisionGroup of the pair.</param>
/// <param name="rule">CollisionRule to use between the pair.</param>
public static void DefineCollisionRule(CollisionGroup groupA, CollisionGroup groupB, CollisionRule rule)
{
var pair = new CollisionGroupPair(groupA, groupB);
if (CollisionRules.CollisionGroupRules.ContainsKey(pair))
{
CollisionRules.CollisionGroupRules[pair] = rule;
}
else
{
CollisionRules.CollisionGroupRules.Add(pair, rule);
}
}
///<summary>
/// Adds an entry in rulesA's Specific relationships list about ownerB.
///</summary>
///<param name="ownerA">Owner of the collision rules that will gain an entry in its Specific relationships.</param>
///<param name="rulesB">Collision rules that will be added to ownerA's Specific relationships.</param>
///<param name="rule">Rule assigned to the pair.</param>
public static void AddRule(ICollisionRulesOwner ownerA, CollisionRules rulesB, CollisionRule rule)
{
ownerA.CollisionRules.specific.Add(rulesB, rule);
}
///<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 NarrowPhasePair for the overlap.</returns>
public static NarrowPhasePair GetPairHandler(BroadPhaseEntry entryA, BroadPhaseEntry entryB, CollisionRule rule)
{
var overlap = new BroadPhaseOverlap(entryA, entryB, rule);
return(GetPairHandler(ref overlap));
}
