[
{
"path": ".gitignore",
"content": "*.suo\n/Installer/Content\n*bin\n*obj\n*Debug\n*.opensdf\n*.sdf\n*.blend1\n*.blend2\nThumbs.db\n/packages\nSteam/*.manifest\nSteam/*.manifest.txt\nSteam/*.log\nSteam/*.csd\nSteam/*.csm\n"
},
{
"path": ".gitmodules",
"content": "[submodule \"Game\"]\n\tpath = Lemma/Game\n\turl = git@bitbucket.org:etodd/lemma-game-assets.git\n[submodule \"LemmaAnalytics\"]\n\tpath = LemmaAnalytics\n\turl = git@bitbucket.org:etodd/lemmaanalytics.git\n[submodule \"SharpZipLib\"]\n\tpath = SharpZipLib\n\turl = git@github.com:etodd/SharpZipLib.git\n[submodule \"Steamworks.NET\"]\n\tpath = Steamworks.NET\n\turl = git@github.com:etodd/Steamworks.NET.git\n\tignore = dirty"
},
{
"path": "BEPUphysics/BEPUphysics.csproj",
"content": "\n\n \n {2A9D2227-78D7-4804-B6D1-560BB43AE911}\n {6D335F3A-9D43-41b4-9D22-F6F17C4BE596};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}\n Debug\n x86\n Library\n Properties\n BEPUphysics\n BEPUphysics\n v4.0\n Client\n v4.0\n Windows\n HiDef\n 7370a280-2dc9-49be-8ea9-7b6a817e142c\n Library\n \n \n true\n full\n false\n bin\\x86\\Debug\n TRACE;DEBUG;WINDOWS;ALLOWUNSAFE\n prompt\n 4\n true\n false\n x86\n false\n true\n \n \n pdbonly\n true\n bin\\x86\\Release\n WINDOWS;ALLOWUNSAFE\n prompt\n 4\n true\n false\n x86\n true\n true\n bin\\x86\\Release\\BEPUphysics.XML\n true\n \n \n true\n \n \n strongNameKey.snk\n \n \n \n \n \n \n False\n \n \n False\n \n \n False\n \n \n False\n \n \n False\n \n \n False\n \n \n False\n \n \n False\n \n \n False\n \n \n False\n \n \n False\n \n \n False\n \n \n 4.0\n False\n \n \n False\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n {E3AAEB61-D7DF-4E7E-A75B-B5282D2FF3F5}\n BEPUutilities\n \n \n \n \n \n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/BroadPhaseEntry.cs",
"content": "using System;\nusing BEPUphysics.BroadPhaseSystems;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.CollisionRuleManagement;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUutilities;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n /// \n /// Superclass of all objects which live inside the broad phase.\n /// The BroadPhase will generate pairs between BroadPhaseEntries.\n /// \n public abstract class BroadPhaseEntry : IBoundingBoxOwner, ICollisionRulesOwner\n {\n internal int hashCode;\n protected BroadPhaseEntry()\n {\n CollisionRules = new CollisionRules();\n collisionRulesUpdatedDelegate = CollisionRulesUpdated;\n\n hashCode = (int)(base.GetHashCode() * 0xd8163841);\n }\n\n /// \n /// Gets the broad phase to which this broad phase entry belongs.\n /// \n public BroadPhase BroadPhase\n {\n get;\n internal set;\n }\n\n /// \n /// Gets the object's hash code.\n /// \n /// Hash code for the object.\n public override int GetHashCode()\n {\n return hashCode;\n }\n\n private Action collisionRulesUpdatedDelegate;\n protected abstract void CollisionRulesUpdated();\n\n protected internal BoundingBox boundingBox;\n /// \n /// Gets or sets the bounding box of the entry.\n /// \n public BoundingBox BoundingBox\n {\n get { return boundingBox; }\n set\n {\n boundingBox = value;\n }\n }\n\n protected internal abstract bool IsActive { get; }\n\n internal CollisionRules collisionRules;\n /// \n /// Gets the entry's collision rules.\n /// \n public CollisionRules CollisionRules\n {\n get { return collisionRules; }\n set\n {\n if (collisionRules != value)\n {\n if (collisionRules != null)\n collisionRules.CollisionRulesChanged -= collisionRulesUpdatedDelegate;\n collisionRules = value;\n if (collisionRules != null)\n collisionRules.CollisionRulesChanged += collisionRulesUpdatedDelegate;\n CollisionRulesUpdated();\n }\n }\n }\n\n /// \n /// Tests a ray against the entry.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit location of the ray on the entry, if any.\n /// Whether or not the ray hit the entry.\n public abstract bool RayCast(Ray ray, float maximumLength, out RayHit rayHit);\n\n /// \n /// Tests a ray against the entry.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present\n /// in the entry, this filter will be passed into inner ray casts.\n /// Hit location of the ray on the entry, if any.\n /// Whether or not the ray hit the entry.\n public virtual bool RayCast(Ray ray, float maximumLength, Func filter, out RayHit rayHit)\n {\n if (filter(this))\n return RayCast(ray, maximumLength, out rayHit);\n rayHit = new RayHit();\n return false;\n }\n\n\n\n /// \n /// Sweeps a convex shape against the entry.\n /// \n /// Swept shape.\n /// Beginning location and orientation of the cast shape.\n /// Sweep motion to apply to the cast shape.\n /// Hit data of the cast on the entry, if any.\n /// Whether or not the cast hit the entry.\n public abstract bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit);\n\n /// \n /// Sweeps a convex shape against the entry.\n /// \n /// Swept shape.\n /// Beginning location and orientation of the cast shape.\n /// Sweep motion to apply to the cast shape.\n /// Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present\n /// in the entry, this filter will be passed into inner ray casts.\n /// Hit data of the cast on the entry, if any.\n /// Whether or not the cast hit the entry.\n public virtual bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, Func filter, out RayHit hit)\n {\n if (filter(this))\n return ConvexCast(castShape, ref startingTransform, ref sweep, out hit);\n hit = new RayHit();\n return false;\n }\n\n /// \n /// Updates the bounding box to the current state of the entry.\n /// \n public abstract void UpdateBoundingBox();\n\n \n /// \n /// Gets or sets the user data associated with this entry.\n /// \n public object Tag { get; set; }\n\n\n }\n\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Collidable.cs",
"content": "using BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.BroadPhaseSystems;\nusing BEPUphysics.CollisionShapes;\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\nusing BEPUphysics.CollisionRuleManagement;\nusing System;\nusing BEPUutilities.DataStructures;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///\n /// Superclass of objects living in the collision detection pipeline\n /// that can result in contacts.\n ///\n public abstract class Collidable : BroadPhaseEntry\n {\n protected Collidable()\n {\n shapeChangedDelegate = OnShapeChanged;\n }\n\n\n\n internal CollisionShape shape; //Having this non-private allows for some very special-casey stuff; see TriangleShape initialization.\n ///\n /// Gets the shape used by the collidable.\n ///\n public CollisionShape Shape\n {\n get\n {\n return shape;\n }\n protected set\n {\n if (shape != null)\n shape.ShapeChanged -= shapeChangedDelegate;\n shape = value;\n if (shape != null)\n shape.ShapeChanged += shapeChangedDelegate;\n OnShapeChanged(shape);\n\n //TODO: Watch out for unwanted references in the delegate lists.\n }\n }\n\n protected internal abstract IContactEventTriggerer EventTriggerer { get; }\n\n\n\n /// \n /// Gets or sets whether or not to ignore shape changes. When true, changing the collision shape will not force the collidable to perform any updates.\n /// \n public bool IgnoreShapeChanges { get; set; }\n\n Action shapeChangedDelegate;\n protected virtual void OnShapeChanged(CollisionShape collisionShape)\n {\n }\n\n\n internal RawList pairs = new RawList();\n ///\n /// Gets the list of pairs associated with the collidable.\n /// These pairs are found by the broad phase and are managed by the narrow phase;\n /// they can contain other collidables, entities, and contacts.\n ///\n public ReadOnlyList Pairs\n {\n get\n {\n return new ReadOnlyList(pairs);\n }\n }\n\n ///\n /// Gets a list of all other collidables that this collidable overlaps.\n ///\n public CollidableCollection OverlappedCollidables\n {\n get\n {\n return new CollidableCollection(this);\n }\n }\n\n protected override void CollisionRulesUpdated()\n {\n for (int i = 0; i < pairs.Count; i++)\n {\n pairs[i].CollisionRule = CollisionRules.CollisionRuleCalculator(pairs[i].BroadPhaseOverlap.entryA, pairs[i].BroadPhaseOverlap.entryB);\n }\n }\n\n\n\n internal void AddPair(CollidablePairHandler pair, ref int index)\n {\n index = pairs.Count;\n pairs.Add(pair);\n }\n\n internal void RemovePair(CollidablePairHandler pair, ref int index)\n {\n if (pairs.Count > index)\n {\n pairs.FastRemoveAt(index);\n if (pairs.Count > index)\n {\n var endPair = pairs.Elements[index];\n if (endPair.CollidableA == this)\n endPair.listIndexA = index;\n else\n endPair.listIndexB = index;\n }\n }\n index = -1;\n }\n\n\n }\n\n\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/CollidableCollection.cs",
"content": "using System;\nusing System.Collections.Generic;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///\n /// List of collidable objects overlapping another collidable.\n ///\n public struct CollidableCollection : IList\n {\n\n ///\n /// Enumerator for the CollidableCollection.\n ///\n public struct Enumerator : IEnumerator\n {\n CollidableCollection collection;\n int index;\n ///\n /// Constructs an enumerator.\n ///\n ///Collection to which the enumerator belongs.\n public Enumerator(CollidableCollection collection)\n {\n this.collection = collection;\n index = -1;\n }\n\n /// \n /// Gets the element in the collection at the current position of the enumerator.\n /// \n /// \n /// The element in the collection at the current position of the enumerator.\n /// \n public Collidable Current\n {\n get { return collection[index]; }\n }\n\n /// \n /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.\n /// \n /// 2\n public void Dispose()\n {\n }\n\n object System.Collections.IEnumerator.Current\n {\n get { return Current; }\n }\n\n /// \n /// Advances the enumerator to the next element of the collection.\n /// \n /// \n /// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.\n /// \n /// The collection was modified after the enumerator was created.\n /// T:System.InvalidOperationException\n /// 2\n public bool MoveNext()\n {\n return ++index < collection.Count;\n }\n\n /// \n /// Sets the enumerator to its initial position, which is before the first element in the collection.\n /// \n /// The collection was modified after the enumerator was created.\n /// T:System.InvalidOperationException\n /// 2\n public void Reset()\n {\n index = -1;\n }\n }\n\n ///\n /// Constructs a new CollidableCollection.\n ///\n ///The collidable to which the collection belongs.\n public CollidableCollection(Collidable owner)\n {\n this.owner = owner;\n }\n\n internal Collidable owner;\n\n\n ///\n /// Gets an enumerator which can be used to enumerate over the list.\n ///\n ///Enumerator for the collection.\n public Enumerator GetEnumerator()\n {\n return new Enumerator(this);\n }\n\n IEnumerator IEnumerable.GetEnumerator()\n {\n return new Enumerator(this);\n }\n\n System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()\n {\n return new Enumerator(this);\n }\n\n\n /// \n /// Determines the index of a specific item in the \n /// T:System.Collections.Generic.IList`1\n /// .\n /// \n /// \n /// The index of if found in the list; otherwise, -1.\n /// \n /// The object to locate in the \n /// T:System.Collections.Generic.IList`1\n /// .\n public int IndexOf(Collidable item)\n {\n for (int i = 0; i < Count; i++)\n {\n if (item == this[i])\n return i;\n }\n return -1;\n }\n\n\n /// \n /// Gets or sets the element at the specified index.\n /// \n /// \n /// The element at the specified index.\n /// \n /// The zero-based index of the element to get or set.\n /// T:System.ArgumentOutOfRangeException\n /// is not a valid index in the \n /// T:System.Collections.Generic.IList`1\n /// \n /// .The property is set and the\n /// T:System.NotSupportedException\n /// \n /// T:System.Collections.Generic.IList`1\n /// \n /// is read-only.\n public Collidable this[int index]\n {\n get\n {\n //It's guaranteed to be a CollisionInformation, because it's a member of a CollidablePairHandler.\n return (Collidable)(owner.pairs[index].broadPhaseOverlap.entryA == owner ? owner.pairs[index].broadPhaseOverlap.entryB : owner.pairs[index].broadPhaseOverlap.entryA);\n }\n set\n {\n throw new NotSupportedException();\n }\n }\n\n\n /// \n /// Determines whether the \n /// T:System.Collections.Generic.ICollection`1\n /// contains a specific value.\n /// \n /// \n /// true if is found in the \n /// T:System.Collections.Generic.ICollection`1\n /// ; otherwise, false.\n /// \n /// The object to locate in the \n /// T:System.Collections.Generic.ICollection`1\n /// .\n public bool Contains(Collidable item)\n {\n for (int i = 0; i < Count; i++)\n {\n if (item == this[i])\n return true;\n }\n return false;\n }\n\n /// \n /// Copies the elements of the \n /// T:System.Collections.Generic.ICollection`1\n /// to an \n /// T:System.Array\n /// , starting at a particular \n /// T:System.Array\n /// index.\n /// \n /// The one-dimensional \n /// T:System.Array\n /// that is the destination of the elements copied from \n /// T:System.Collections.Generic.ICollection`1\n /// . The \n /// T:System.Array\n /// must have zero-based indexing.The zero-based index in at which copying begins. is null. is less than 0. is multidimensional.-or-The number of elements in the source is greater than the available space from to the end of the destination .-or-Type cannot be cast automatically to the type of the destination .\n public void CopyTo(Collidable[] array, int arrayIndex)\n {\n for (int i = 0; i < Count; i++)\n {\n array[arrayIndex + i] = this[i];\n }\n }\n\n /// \n /// Gets the number of elements contained in the \n /// T:System.Collections.Generic.ICollection`1\n /// .\n /// \n /// \n /// The number of elements contained in the \n /// T:System.Collections.Generic.ICollection`1\n /// .\n /// \n public int Count\n {\n get { return owner.pairs.Count; }\n }\n\n bool ICollection.IsReadOnly\n {\n get { return true; }\n }\n\n bool ICollection.Remove(Collidable item)\n {\n throw new NotSupportedException();\n }\n\n void ICollection.Add(Collidable item)\n {\n throw new NotSupportedException();\n }\n\n void ICollection.Clear()\n {\n throw new NotSupportedException();\n }\n\n void IList.Insert(int index, Collidable item)\n {\n throw new NotSupportedException();\n }\n\n void IList.RemoveAt(int index)\n {\n throw new NotSupportedException();\n }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/CollidablePair.cs",
"content": "using System;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///\n /// Pair of collidables.\n ///\n public struct CollidablePair : IEquatable\n {\n internal Collidable collidableA;\n ///\n /// First collidable in the pair.\n ///\n public Collidable CollidableA\n {\n get { return collidableA; }\n }\n\n internal Collidable collidableB;\n /// \n /// Second collidable in the pair.\n /// \n public Collidable CollidableB\n {\n get { return collidableB; }\n }\n\n ///\n /// Constructs a new collidable pair.\n ///\n ///First collidable in the pair.\n ///Second collidable in the pair.\n public CollidablePair(Collidable collidableA, Collidable collidableB)\n {\n this.collidableA = collidableA;\n this.collidableB = collidableB;\n }\n\n\n /// \n /// Returns the hash code for this instance.\n /// \n /// \n /// A 32-bit signed integer that is the hash code for this instance.\n /// \n /// 2\n public override int GetHashCode()\n {\n //TODO: Use old prime-based system?\n return collidableA.GetHashCode() + collidableB.GetHashCode();\n }\n\n\n\n #region IEquatable Members\n\n /// \n /// Indicates whether the current object is equal to another object of the same type.\n /// \n /// \n /// true if the current object is equal to the parameter; otherwise, false.\n /// \n /// An object to compare with this object.\n public bool Equals(CollidablePair other)\n {\n return (other.collidableA == collidableA && other.collidableB == collidableB) || (other.collidableA == collidableB && other.collidableB == collidableA);\n }\n\n #endregion\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/DetectorVolume.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUphysics.DataStructures;\nusing BEPUutilities.DataStructures;\nusing BEPUphysics.Entities;\nusing BEPUphysics.OtherSpaceStages;\nusing BEPUutilities;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUphysics.CollisionRuleManagement;\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\nusing RigidTransform = BEPUutilities.RigidTransform;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n /// \n /// Stores flags regarding an object's degree of inclusion in a volume.\n /// \n public struct ContainmentState\n {\n /// \n /// Whether or not the object is fully contained.\n /// \n public bool IsContained;\n\n /// \n /// Whether or not the object is partially or fully contained.\n /// \n public bool IsTouching;\n\n /// \n /// Whether or not the entity associated with this state has been refreshed during the last update.\n /// \n internal bool StaleState;\n\n /// \n /// Constructs a new ContainmentState.\n /// \n /// Whether or not the object is partially or fully contained.\n /// Whether or not the object is fully contained.\n public ContainmentState(bool touching, bool contained)\n {\n IsTouching = touching;\n IsContained = contained;\n StaleState = false;\n }\n /// \n /// Constructs a new ContainmentState.\n /// \n /// Whether or not the object is partially or fully contained.\n /// Whether or not the object is fully contained.\n /// Whether or not the entity associated with this state has been refreshed in the previous update.\n internal ContainmentState(bool touching, bool contained, bool stale)\n {\n IsTouching = touching;\n IsContained = contained;\n StaleState = stale;\n }\n\n\n }\n\n /// \n /// Manages the detection of entities within an arbitrary closed triangle mesh.\n /// \n public class DetectorVolume : BroadPhaseEntry, ISpaceObject, IDeferredEventCreator\n {\n\n internal Dictionary pairs = new Dictionary();\n /// \n /// Gets the list of pairs associated with the detector volume.\n /// \n public ReadOnlyDictionary Pairs\n {\n get\n {\n return new ReadOnlyDictionary(pairs);\n }\n }\n\n\n TriangleMesh triangleMesh;\n /// \n /// Gets or sets the triangle mesh data and acceleration structure. Must be a closed mesh with consistent winding.\n /// \n public TriangleMesh TriangleMesh\n {\n get\n {\n return triangleMesh;\n }\n set\n {\n triangleMesh = value;\n UpdateBoundingBox();\n Reinitialize();\n }\n }\n\n\n\n\n\n\n /// \n /// Creates a detector volume.\n /// \n /// Closed and consistently wound mesh defining the volume.\n public DetectorVolume(TriangleMesh triangleMesh)\n {\n TriangleMesh = triangleMesh;\n UpdateBoundingBox();\n }\n\n\n \n /// \n /// Fires when an entity comes into contact with the volume.\n /// \n public event EntityBeginsTouchingVolumeEventHandler EntityBeganTouching;\n\n /// \n /// Fires when an entity ceases to intersect the volume.\n /// \n public event EntityStopsTouchingVolumeEventHandler EntityStoppedTouching;\n\n /// \n /// Fires when an entity becomes fully engulfed by a volume.\n /// \n public event VolumeBeginsContainingEntityEventHandler VolumeBeganContainingEntity;\n\n /// \n /// Fires when an entity ceases to be fully engulfed by a volume.\n /// \n public event VolumeStopsContainingEntityEventHandler VolumeStoppedContainingEntity;\n\n\n \n\n private ISpace space;\n ISpace ISpaceObject.Space\n {\n get\n {\n return space;\n }\n set\n {\n space = value;\n }\n }\n\n ///\n /// Space that owns the detector volume.\n ///\n public ISpace Space\n {\n get\n {\n return space;\n }\n }\n\n private bool innerFacingIsClockwise;\n\n /// \n /// Determines if a point is contained by the detector volume.\n /// \n /// Point to check for containment.\n /// Whether or not the point is contained by the detector volume.\n public bool IsPointContained(Vector3 point)\n {\n var triangles = CommonResources.GetIntList();\n bool contained = IsPointContained(ref point, triangles);\n CommonResources.GiveBack(triangles);\n return contained;\n }\n\n internal bool IsPointContained(ref Vector3 point, RawList triangles)\n {\n Vector3 rayDirection;\n //Point from the approximate center of the mesh outwards.\n //This is a cheap way to reduce the number of unnecessary checks when objects are external to the mesh.\n Vector3.Add(ref boundingBox.Max, ref boundingBox.Min, out rayDirection);\n Vector3.Multiply(ref rayDirection, .5f, out rayDirection);\n Vector3.Subtract(ref point, ref rayDirection, out rayDirection);\n //If the point is right in the middle, we'll need a backup.\n if (rayDirection.LengthSquared() < .01f)\n rayDirection = Vector3.Up;\n\n var ray = new Ray(point, rayDirection);\n triangleMesh.Tree.GetOverlaps(ray, triangles);\n\n float minimumT = float.MaxValue;\n bool minimumIsClockwise = false;\n\n for (int i = 0; i < triangles.Count; i++)\n {\n Vector3 a, b, c;\n triangleMesh.Data.GetTriangle(triangles.Elements[i], out a, out b, out c);\n\n RayHit hit;\n bool hitClockwise;\n if (Toolbox.FindRayTriangleIntersection(ref ray, float.MaxValue, ref a, ref b, ref c, out hitClockwise, out hit))\n {\n if (hit.T < minimumT)\n {\n minimumT = hit.T;\n minimumIsClockwise = hitClockwise;\n }\n }\n }\n\n triangles.Clear();\n\n //If the first hit is on the inner surface, then the ray started inside the mesh.\n return minimumT < float.MaxValue && minimumIsClockwise == innerFacingIsClockwise;\n }\n\n protected override void CollisionRulesUpdated()\n {\n foreach (var pair in pairs.Values)\n pair.CollisionRule = CollisionRules.CollisionRuleCalculator(pair.BroadPhaseOverlap.entryA, pair.BroadPhaseOverlap.entryB);\n\n }\n\n protected internal override bool IsActive\n {\n get { return false; }\n }\n\n public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)\n {\n return triangleMesh.RayCast(ray, maximumLength, TriangleSidedness.DoubleSided, out rayHit);\n }\n\n public override bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit)\n {\n hit = new RayHit();\n BoundingBox boundingBox;\n castShape.GetSweptBoundingBox(ref startingTransform, ref sweep, out boundingBox);\n var tri = PhysicsResources.GetTriangle();\n var hitElements = CommonResources.GetIntList();\n if (triangleMesh.Tree.GetOverlaps(boundingBox, hitElements))\n {\n hit.T = float.MaxValue;\n for (int i = 0; i < hitElements.Count; i++)\n {\n triangleMesh.Data.GetTriangle(hitElements[i], out tri.vA, out tri.vB, out tri.vC);\n Vector3 center;\n Vector3.Add(ref tri.vA, ref tri.vB, out center);\n Vector3.Add(ref center, ref tri.vC, out center);\n Vector3.Multiply(ref center, 1f / 3f, out center);\n Vector3.Subtract(ref tri.vA, ref center, out tri.vA);\n Vector3.Subtract(ref tri.vB, ref center, out tri.vB);\n Vector3.Subtract(ref tri.vC, ref center, out tri.vC);\n tri.maximumRadius = tri.vA.LengthSquared();\n float radius = tri.vB.LengthSquared();\n if (tri.maximumRadius < radius)\n tri.maximumRadius = radius;\n radius = tri.vC.LengthSquared();\n if (tri.maximumRadius < radius)\n tri.maximumRadius = radius;\n tri.maximumRadius = (float)Math.Sqrt(tri.maximumRadius);\n tri.collisionMargin = 0;\n var triangleTransform = new RigidTransform { Orientation = Quaternion.Identity, Position = center };\n RayHit tempHit;\n if (MPRToolbox.Sweep(castShape, tri, ref sweep, ref Toolbox.ZeroVector, ref startingTransform, ref triangleTransform, out tempHit) && tempHit.T < hit.T)\n {\n hit = tempHit;\n }\n }\n tri.maximumRadius = 0;\n PhysicsResources.GiveBack(tri);\n CommonResources.GiveBack(hitElements);\n return hit.T != float.MaxValue;\n }\n PhysicsResources.GiveBack(tri);\n CommonResources.GiveBack(hitElements);\n return false;\n }\n\n /// \n /// Sets the bounding box of the detector volume to the current hierarchy root bounding box. This is called automatically if the TriangleMesh property is set.\n /// \n public override void UpdateBoundingBox()\n {\n boundingBox = triangleMesh.Tree.BoundingBox;\n }\n\n /// \n /// Updates the detector volume's interpretation of the mesh. This should be called when the the TriangleMesh is changed significantly. This is called automatically if the TriangleMesh property is set.\n /// \n public void Reinitialize()\n {\n //Pick a point that is known to be outside the mesh as the origin.\n Vector3 origin = (triangleMesh.Tree.BoundingBox.Max - triangleMesh.Tree.BoundingBox.Min) * 1.5f + triangleMesh.Tree.BoundingBox.Min;\n\n //Pick a direction which will definitely hit the mesh.\n Vector3 a, b, c;\n triangleMesh.Data.GetTriangle(0, out a, out b, out c);\n var direction = (a + b + c) / 3 - origin;\n\n var ray = new Ray(origin, direction);\n var triangles = CommonResources.GetIntList();\n triangleMesh.Tree.GetOverlaps(ray, triangles);\n\n float minimumT = float.MaxValue;\n\n for (int i = 0; i < triangles.Count; i++)\n {\n triangleMesh.Data.GetTriangle(triangles.Elements[i], out a, out b, out c);\n\n RayHit hit;\n bool hitClockwise;\n if (Toolbox.FindRayTriangleIntersection(ref ray, float.MaxValue, ref a, ref b, ref c, out hitClockwise, out hit))\n {\n if (hit.T < minimumT)\n {\n minimumT = hit.T;\n innerFacingIsClockwise = !hitClockwise;\n }\n }\n }\n CommonResources.GiveBack(triangles);\n }\n\n\n void ISpaceObject.OnAdditionToSpace(ISpace newSpace)\n {\n\n }\n\n void ISpaceObject.OnRemovalFromSpace(ISpace oldSpace)\n {\n\n }\n\n\n /// \n /// Used to protect against containment changes coming in from multithreaded narrowphase contexts.\n /// \n SpinLock locker = new SpinLock();\n struct ContainmentChange\n {\n public Entity Entity;\n public ContainmentChangeType Change;\n }\n enum ContainmentChangeType : byte\n {\n BeganTouching,\n StoppedTouching,\n BeganContaining,\n StoppedContaining\n }\n private Queue containmentChanges = new Queue();\n internal void BeganTouching(DetectorVolumePairHandler pair)\n {\n locker.Enter();\n containmentChanges.Enqueue(new ContainmentChange\n {\n Change = ContainmentChangeType.BeganTouching,\n Entity = pair.Collidable.entity\n });\n locker.Exit();\n }\n\n internal void StoppedTouching(DetectorVolumePairHandler pair)\n {\n locker.Enter();\n containmentChanges.Enqueue(new ContainmentChange\n {\n Change = ContainmentChangeType.StoppedTouching,\n Entity = pair.Collidable.entity\n });\n locker.Exit();\n }\n\n internal void BeganContaining(DetectorVolumePairHandler pair)\n {\n locker.Enter();\n containmentChanges.Enqueue(new ContainmentChange\n {\n Change = ContainmentChangeType.BeganContaining,\n Entity = pair.Collidable.entity\n });\n locker.Exit();\n }\n\n internal void StoppedContaining(DetectorVolumePairHandler pair)\n {\n locker.Enter();\n containmentChanges.Enqueue(new ContainmentChange\n {\n Change = ContainmentChangeType.StoppedContaining,\n Entity = pair.Collidable.entity\n });\n locker.Exit();\n }\n\n\n DeferredEventDispatcher IDeferredEventCreator.DeferredEventDispatcher { get; set; }\n\n bool IDeferredEventCreator.IsActive\n {\n get { return true; }\n set { throw new NotSupportedException(\"Detector volumes are always active deferred event generators.\"); }\n }\n\n void IDeferredEventCreator.DispatchEvents()\n {\n while (containmentChanges.Count > 0)\n {\n var change = containmentChanges.Dequeue();\n switch (change.Change)\n {\n case ContainmentChangeType.BeganTouching:\n if (EntityBeganTouching != null)\n EntityBeganTouching(this, change.Entity);\n break;\n case ContainmentChangeType.StoppedTouching:\n if (EntityStoppedTouching != null)\n EntityStoppedTouching(this, change.Entity);\n break;\n case ContainmentChangeType.BeganContaining:\n if (VolumeBeganContainingEntity != null)\n VolumeBeganContainingEntity(this, change.Entity);\n break;\n case ContainmentChangeType.StoppedContaining:\n if (VolumeStoppedContainingEntity != null)\n VolumeStoppedContainingEntity(this, change.Entity);\n break;\n }\n }\n }\n\n int IDeferredEventCreator.ChildDeferredEventCreators\n {\n get { return 0; }\n set\n {\n throw new NotSupportedException(\"The detector volume does not allow child deferred event creators.\");\n }\n }\n }\n\n\n /// \n /// Handles any special logic to perform when an entry begins touching a detector volume.\n /// Runs within an update loop for updateables; modifying the updateable listing during the event is disallowed.\n /// \n /// DetectorVolume being touched.\n /// Entry touching the volume.\n public delegate void EntityBeginsTouchingVolumeEventHandler(DetectorVolume volume, Entity toucher);\n\n /// \n /// Handles any special logic to perform when an entry stops touching a detector volume.\n /// Runs within an update loop for updateables; modifying the updateable listing during the event is disallowed.\n /// \n /// DetectorVolume no longer being touched.\n /// Entry no longer touching the volume.\n public delegate void EntityStopsTouchingVolumeEventHandler(DetectorVolume volume, Entity toucher);\n\n /// \n /// Handles any special logic to perform when an entity begins being contained by a detector volume.\n /// Runs within an update loop for updateables; modifying the updateable listing during the event is disallowed.\n /// \n /// DetectorVolume containing the entry.\n /// Entity contained by the volume.\n public delegate void VolumeBeginsContainingEntityEventHandler(DetectorVolume volume, Entity entity);\n\n /// \n /// Handles any special logic to perform when an entry stops being contained by a detector volume.\n /// Runs within an update loop for updateables; modifying the updateable listing during the event is disallowed.\n /// \n /// DetectorVolume no longer containing the entry.\n /// Entity no longer contained by the volume.\n public delegate void VolumeStopsContainingEntityEventHandler(DetectorVolume volume, Entity entity);\n}"
},
{
"path": "BEPUphysics/BroadPhaseEntries/EntityCollidableCollection.cs",
"content": "using System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.Entities;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///\n /// Enumerable collection of entities associated with a collidable.\n ///\n public struct EntityCollidableCollection : IEnumerable\n {\n\n ///\n /// Enumerator for the EntityCollidableCollection.\n ///\n public struct Enumerator : IEnumerator\n {\n EntityCollidableCollection collection;\n EntityCollidable current;\n int index;\n ///\n /// Constructs a new enumerator.\n ///\n ///Owning collection.\n public Enumerator(EntityCollidableCollection collection)\n {\n this.collection = collection;\n index = -1;\n current = null;\n }\n\n /// \n /// Gets the element in the collection at the current position of the enumerator.\n /// \n /// \n /// The element in the collection at the current position of the enumerator.\n /// \n public Entity Current\n {\n get { return current.entity; }\n }\n\n /// \n /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.\n /// \n /// 2\n public void Dispose()\n {\n }\n\n object System.Collections.IEnumerator.Current\n {\n get { return Current; }\n }\n\n /// \n /// Advances the enumerator to the next element of the collection.\n /// \n /// \n /// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.\n /// \n /// The collection was modified after the enumerator was created.\n /// T:System.InvalidOperationException\n /// 2\n public bool MoveNext()\n {\n while (++index < collection.owner.pairs.Count)\n {\n if ((current = (collection.owner.pairs[index].broadPhaseOverlap.entryA == collection.owner ?\n collection.owner.pairs[index].broadPhaseOverlap.entryB : \n collection.owner.pairs[index].broadPhaseOverlap.entryA) as EntityCollidable) != null)\n return true;\n }\n return false;\n }\n\n /// \n /// Sets the enumerator to its initial position, which is before the first element in the collection.\n /// \n /// The collection was modified after the enumerator was created.\n /// T:System.InvalidOperationException\n /// 2\n public void Reset()\n {\n index = -1;\n }\n }\n\n ///\n /// Constructs a new EntityCollidableCollection.\n ///\n ///Owner of the collection.\n public EntityCollidableCollection(EntityCollidable owner)\n {\n this.owner = owner;\n }\n\n internal EntityCollidable owner;\n\n\n ///\n /// Gets an enumerator over the entities in the collection.\n ///\n ///Enumerator over the entities in the collection.\n public Enumerator GetEnumerator()\n {\n return new Enumerator(this);\n }\n\n IEnumerator IEnumerable.GetEnumerator()\n {\n return new Enumerator(this);\n }\n\n System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()\n {\n return new Enumerator(this);\n }\n\n\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/CollisionEventTypes.cs",
"content": "using BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseSystems;\nusing BEPUphysics.CollisionTests;\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\n\nnamespace BEPUphysics.BroadPhaseEntries.Events\n{\n //TODO: Contravariance isn't supported on all platforms...\n\n /// \n /// Handles any special logic when two objects' bounding boxes overlap as determined by the broadphase system.\n /// \n /// Entry sending the event.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair presiding over the interaction of the two involved bodies.\n /// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.\n public delegate void PairCreatedEventHandler(T sender, BroadPhaseEntry other, NarrowPhasePair pair);\n\n /// \n /// Handles any special logic when two objects' bounding boxes overlap as determined by the broadphase system.\n /// Unlike PairCreatedEventHandler, this will be called as soon as a pair is created instead of at the end of the frame.\n /// This allows the pair's data to be adjusted prior to any usage, but some actions are not supported due to the execution stage.\n /// \n /// Entry sending the event.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair presiding over the interaction of the two involved bodies.\n /// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.\n public delegate void CreatingPairEventHandler(T sender, BroadPhaseEntry other, NarrowPhasePair pair);\n\n /// \n /// Handles any special logic when two objects' bounding boxes cease to overlap as determined by the broadphase system.\n /// \n /// Entry sending the event.\n /// The entry formerly interacting with the sender via the deleted pair.\n public delegate void PairRemovedEventHandler(T sender, BroadPhaseEntry other);\n\n /// \n /// Handles any special logic when two objects' bounding boxes cease to overlap as determined by the broadphase system.\n /// Unlike PairRemovedEventHandler, this will trigger at the time of pair removal instead of at the end of the space's update.\n /// \n /// Entry sending the event.\n /// The entry formerly interacting with the sender via the deleted pair.\n public delegate void RemovingPairEventHandler(T sender, BroadPhaseEntry other);\n\n /// \n /// Handles any special logic when two bodies are touching and generate a contact point.\n /// \n /// Entry sending the event.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair presiding over the interaction of the two involved bodies.\n /// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.\n /// Created contact data.\n public delegate void ContactCreatedEventHandler(T sender, Collidable other, CollidablePairHandler pair, ContactData contact);\n\n /// \n /// Handles any special logic when two bodies are touching and generate a contact point.\n /// Unlike ContactCreatedEventHandler, this will trigger at the time of contact generation instead of at the end of the space's update.\n /// This allows the contact's data to be adjusted prior to usage in the velocity solver, \n /// but other actions such as altering the owning space's pair or entry listings are unsafe.\n /// \n /// Entry sending the event.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair presiding over the interaction of the two involved bodies.\n /// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.\n /// Newly generated contact point between the pair's two bodies.\n /// This reference cannot be safely kept outside of the scope of the handler; contacts can quickly return to the resource pool.\n public delegate void CreatingContactEventHandler(T sender, Collidable other, CollidablePairHandler pair, Contact contact);\n\n /// \n /// Handles any special logic when two bodies initally collide and generate a contact point.\n /// \n /// Entry sending the event.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair presiding over the interaction of the two involved bodies.\n /// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.\n public delegate void InitialCollisionDetectedEventHandler(T sender, Collidable other, CollidablePairHandler pair);\n\n /// \n /// Handles any special logic when two bodies initally collide and generate a contact point.\n /// Unlike InitialCollisionDetectedEventHandler, this will trigger at the time of contact creation instead of at the end of the space's update.\n /// Performing operations outside of the scope of the pair is unsafe.\n /// \n /// Entry sending the event.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair presiding over the interaction of the two involved bodies.\n /// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.\n public delegate void DetectingInitialCollisionEventHandler(T sender, Collidable other, CollidablePairHandler pair);\n\n /// \n /// Handles any special logic when a contact point between two bodies is removed.\n /// \n /// Entry sending the event.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair presiding over the interaction of the two involved bodies and data about the removed contact.\n /// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.\n /// Removed contact data.\n public delegate void ContactRemovedEventHandler(T sender, Collidable other, CollidablePairHandler pair, ContactData contact);\n\n /// \n /// Handles any special logic when a contact point between two bodies is removed.\n /// Unlike ContactRemovedEventHandler, this will trigger at the time of contact removal instead of at the end of the space's update.\n /// Performing operations outside of the scope of the controller is unsafe.\n /// \n /// Entry sending the event.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair presiding over the interaction of the two involved bodies and data about the removed contact.\n /// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.\n /// Contact between the two entries. This reference cannot be safely kept outside of the scope of the handler;\n /// it will be immediately returned to the resource pool after the event handler completes.\n public delegate void RemovingContactEventHandler(T sender, Collidable other, CollidablePairHandler pair, Contact contact);\n\n /// \n /// Handles any special logic when two bodies go from a touching state to a separated state.\n /// \n /// Entry sending the event.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair overseeing the collision. Note that this instance may be invalid if the entries' bounding boxes no longer overlap.\n public delegate void CollisionEndedEventHandler(T sender, Collidable other, CollidablePairHandler pair);\n\n /// \n /// Handles any special logic when two bodies go from a touching state to a separated state.\n /// Unlike CollisionEndedEventHandler, this will trigger at the time of contact removal instead of at the end of the space's update.\n /// Performing operations outside of the scope of the controller is unsafe.\n /// \n /// Entry sending the event.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair presiding over the interaction of the two involved bodies.\n /// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.\n public delegate void CollisionEndingEventHandler(T sender, Collidable other, CollidablePairHandler pair);\n\n /// \n /// Handles any special logic to perform at the end of a pair's UpdateContactManifold method.\n /// This is called every single update regardless if the process was quit early or did not complete due to interaction rules.\n /// \n /// Entry involved in the pair monitored for events.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair that was updated.\n public delegate void PairUpdatedEventHandler(T sender, BroadPhaseEntry other, NarrowPhasePair pair);\n\n /// \n /// Handles any special logic to perform at the end of a pair's UpdateContactManifold method.\n /// This is called every single update regardless if the process was quit early or did not complete due to interaction rules.\n /// Unlike PairUpdatedEventHandler, this is called at the time of the collision detection update rather than at the end of the space's update.\n /// Other entries' information may not be up to date, and operations acting on data outside of the character controller may be unsafe.\n /// \n /// Entry involved in the pair monitored for events.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair that was updated.\n public delegate void PairUpdatingEventHandler(T sender, BroadPhaseEntry other, NarrowPhasePair pair);\n\n /// \n /// Handles any special logic to perform at the end of a pair's UpdateContactManifold method if the two objects are colliding.\n /// This is called every single update regardless if the process was quit early or did not complete due to interaction rules.\n /// \n /// Entry involved in the pair monitored for events.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair that was updated.\n public delegate void PairTouchedEventHandler(T sender, Collidable other, CollidablePairHandler pair);\n\n /// \n /// Handles any special logic to perform at the end of a pair's UpdateContactManifold method if the two objects are colliding.\n /// This is called every single update regardless if the process was quit early or did not complete due to interaction rules.\n /// Unlike PairTouchedEventHandler, this is called at the time of the collision detection update rather than at the end of the space's update.\n /// Other entries' information may not be up to date, and operations acting on data outside of the character controller may be unsafe.\n /// \n /// Entry involved in the pair monitored for events.\n /// Other entry within the pair opposing the monitored entry.\n /// Pair that was updated.\n public delegate void PairTouchingEventHandler(T sender, Collidable other, CollidablePairHandler pair);\n\n //Storage for deferred event dispatching\n internal struct EventStoragePairCreated\n {\n internal NarrowPhasePair pair;\n internal BroadPhaseEntry other;\n\n internal EventStoragePairCreated(BroadPhaseEntry other, NarrowPhasePair pair)\n {\n this.other = other;\n this.pair = pair;\n }\n }\n\n internal struct EventStoragePairRemoved\n {\n internal BroadPhaseEntry other;\n\n internal EventStoragePairRemoved(BroadPhaseEntry other)\n {\n this.other = other;\n }\n }\n\n internal struct EventStorageContactCreated\n {\n internal CollidablePairHandler pair;\n internal ContactData contactData;\n internal Collidable other;\n\n\n internal EventStorageContactCreated(Collidable other, CollidablePairHandler pair, ref ContactData contactData)\n {\n this.other = other;\n this.pair = pair;\n this.contactData = contactData;\n }\n }\n\n internal struct EventStorageInitialCollisionDetected\n {\n internal CollidablePairHandler pair;\n internal Collidable other;\n\n internal EventStorageInitialCollisionDetected(Collidable other, CollidablePairHandler pair)\n {\n this.pair = pair;\n this.other = other;\n }\n }\n\n internal struct EventStorageContactRemoved\n {\n internal CollidablePairHandler pair;\n internal ContactData contactData;\n internal Collidable other;\n\n internal EventStorageContactRemoved(Collidable other, CollidablePairHandler pair, ref ContactData contactData)\n {\n this.other = other;\n this.pair = pair;\n this.contactData = contactData;\n }\n }\n\n internal struct EventStorageCollisionEnded\n {\n internal CollidablePairHandler pair;\n internal Collidable other;\n\n internal EventStorageCollisionEnded(Collidable other, CollidablePairHandler pair)\n {\n this.other = other;\n this.pair = pair;\n }\n }\n\n internal struct EventStoragePairUpdated\n {\n internal NarrowPhasePair pair;\n internal BroadPhaseEntry other;\n\n internal EventStoragePairUpdated(BroadPhaseEntry other, NarrowPhasePair pair)\n {\n this.other = other;\n this.pair = pair;\n }\n }\n\n internal struct EventStoragePairTouched\n {\n internal CollidablePairHandler pair;\n internal Collidable other;\n\n internal EventStoragePairTouched(Collidable other, CollidablePairHandler pair)\n {\n this.other = other;\n this.pair = pair;\n }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/CompoundEventManager.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.OtherSpaceStages;\n\nnamespace BEPUphysics.BroadPhaseEntries.Events\n{\n /// \n /// Event manager for use with the CompoundCollidable.\n /// It's possible to use the ContactEventManager directly with a compound,\n /// but without using this class, any child event managers will fail to dispatch\n /// deferred events.\n /// \n public class CompoundEventManager : ContactEventManager\n {\n\n //TODO: This class can be generalized if there is ever another collidable which has similar requirements to the compound body.\n protected override void DispatchEvents()\n {\n //Go through all children and dispatch events.\n //They won't be touched by the primary event manager otherwise.\n var compound = this.owner as CompoundCollidable;\n if (compound != null)\n {\n foreach (var child in compound.children)\n {\n var deferredEventCreator = child.CollisionInformation.events as IDeferredEventCreator;\n if (deferredEventCreator.IsActive)\n deferredEventCreator.DispatchEvents();\n }\n }\n else\n {\n throw new InvalidOperationException(\"Cannot use a CompoundEventManager with anything but a CompoundCollidable.\");\n }\n base.DispatchEvents();\n }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/ContactEventManager.cs",
"content": "using BEPUutilities;\nusing BEPUphysics.CollisionTests;\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\nusing BEPUutilities.DataStructures;\n\nnamespace BEPUphysics.BroadPhaseEntries.Events\n{\n\n ///\n /// Event manager for collidables (things which can create contact points).\n ///\n ///Some Collidable subclass.\n public class ContactEventManager : EntryEventManager, IContactEventTriggerer where T : Collidable\n {\n\n #region Events\n\n /// \n /// Fires when the entity stops touching another entity.\n /// \n public event CollisionEndedEventHandler CollisionEnded\n {\n add\n {\n InternalCollisionEnded += value;\n AddToEventfuls();\n }\n remove\n {\n InternalCollisionEnded -= value;\n VerifyEventStatus();\n }\n }\n\n /// \n /// Fires when the entity stops touching another entity.\n /// Unlike the CollisionEnded event, this event will run inline instead of at the end of the space's update.\n /// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.\n /// \n public event CollisionEndingEventHandler CollisionEnding;\n\n /// \n /// Fires when a pair is updated and there are contact points in it.\n /// \n public event PairTouchedEventHandler PairTouched\n {\n add\n {\n InternalPairTouched += value;\n AddToEventfuls();\n }\n remove\n {\n InternalPairTouched -= value;\n VerifyEventStatus();\n }\n }\n\n /// \n /// Fires when a pair is updated and there are contact points in it.\n /// Unlike the PairTouched event, this event will run inline instead of at the end of the space's update.\n /// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.\n /// \n public event PairTouchingEventHandler PairTouching;\n\n /// \n /// Fires when this entity gains a contact point with another entity.\n /// \n public event ContactCreatedEventHandler ContactCreated\n {\n add\n {\n InternalContactCreated += value;\n AddToEventfuls();\n }\n remove\n {\n InternalContactCreated -= value;\n VerifyEventStatus();\n }\n }\n\n /// \n /// Fires when this entity loses a contact point with another entity.\n /// \n public event ContactRemovedEventHandler ContactRemoved\n {\n add\n {\n InternalContactRemoved += value;\n AddToEventfuls();\n }\n remove\n {\n InternalContactRemoved -= value;\n VerifyEventStatus();\n }\n }\n\n /// \n /// Fires when this entity gains a contact point with another entity.\n /// Unlike the ContactCreated event, this event will run inline instead of at the end of the space's update.\n /// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.\n /// \n public event CreatingContactEventHandler CreatingContact;\n\n /// \n /// Fires when a collision first occurs.\n /// Unlike the InitialCollisionDetected event, this event will run inline instead of at the end of the space's update.\n /// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.\n /// \n public event DetectingInitialCollisionEventHandler DetectingInitialCollision;\n\n /// \n /// Fires when a collision first occurs.\n /// \n public event InitialCollisionDetectedEventHandler InitialCollisionDetected\n {\n add\n {\n InternalInitialCollisionDetected += value;\n AddToEventfuls();\n }\n remove\n {\n InternalInitialCollisionDetected -= value;\n VerifyEventStatus();\n }\n }\n\n /// \n /// Fires when this entity loses a contact point with another entity.\n /// Unlike the ContactRemoved event, this event will run inline instead of at the end of the space's update.\n /// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.\n /// \n public event RemovingContactEventHandler RemovingContact;\n\n private event CollisionEndedEventHandler InternalCollisionEnded;\n private event PairTouchedEventHandler InternalPairTouched;\n private event ContactCreatedEventHandler InternalContactCreated;\n private event ContactRemovedEventHandler InternalContactRemoved;\n private event InitialCollisionDetectedEventHandler InternalInitialCollisionDetected;\n\n #endregion\n\n #region Supporting members\n\n protected override bool EventsAreInactive()\n {\n return InternalCollisionEnded == null &&\n InternalPairTouched == null &&\n InternalContactCreated == null &&\n InternalContactRemoved == null &&\n InternalInitialCollisionDetected == null &&\n base.EventsAreInactive();\n }\n\n readonly ConcurrentDeque eventStorageContactCreated = new ConcurrentDeque(0);\n readonly ConcurrentDeque eventStorageInitialCollisionDetected = new ConcurrentDeque(0);\n readonly ConcurrentDeque eventStorageContactRemoved = new ConcurrentDeque(0);\n readonly ConcurrentDeque eventStorageCollisionEnded = new ConcurrentDeque(0);\n readonly ConcurrentDeque eventStoragePairTouched = new ConcurrentDeque(0);\n\n protected override void DispatchEvents()\n {\n //Note: Deferred event creation should be performed sequentially with dispatching.\n //This means a event creation from this creator cannot occur ASYNCHRONOUSLY while DispatchEvents is running.\n\n //Note: If the deferred event handler is removed during the execution of the engine, the handler may be null.\n //In this situation, ignore the event.\n //This is not a particularly clean behavior, but it's better than just crashing.\n EventStorageContactCreated contactCreated;\n while (eventStorageContactCreated.TryUnsafeDequeueFirst(out contactCreated))\n if (InternalContactCreated != null)\n InternalContactCreated(owner, contactCreated.other, contactCreated.pair, contactCreated.contactData);\n\n EventStorageInitialCollisionDetected initialCollisionDetected;\n while (eventStorageInitialCollisionDetected.TryUnsafeDequeueFirst(out initialCollisionDetected))\n if (InternalInitialCollisionDetected != null)\n InternalInitialCollisionDetected(owner, initialCollisionDetected.other, initialCollisionDetected.pair);\n\n EventStorageContactRemoved contactRemoved;\n while (eventStorageContactRemoved.TryUnsafeDequeueFirst(out contactRemoved))\n if (InternalContactRemoved != null)\n InternalContactRemoved(owner, contactRemoved.other, contactRemoved.pair, contactRemoved.contactData);\n\n EventStorageCollisionEnded collisionEnded;\n while (eventStorageCollisionEnded.TryUnsafeDequeueFirst(out collisionEnded))\n if (InternalCollisionEnded != null)\n InternalCollisionEnded(owner, collisionEnded.other, collisionEnded.pair);\n\n EventStoragePairTouched collisionPairTouched;\n while (eventStoragePairTouched.TryUnsafeDequeueFirst(out collisionPairTouched))\n if (InternalPairTouched != null)\n InternalPairTouched(owner, collisionPairTouched.other, collisionPairTouched.pair);\n\n base.DispatchEvents();\n }\n\n public void OnCollisionEnded(Collidable other, CollidablePairHandler collisionPair)\n {\n if (InternalCollisionEnded != null)\n eventStorageCollisionEnded.Enqueue(new EventStorageCollisionEnded(other, collisionPair));\n if (CollisionEnding != null)\n CollisionEnding(owner, other, collisionPair);\n }\n\n public void OnPairTouching(Collidable other, CollidablePairHandler collisionPair)\n {\n if (InternalPairTouched != null)\n eventStoragePairTouched.Enqueue(new EventStoragePairTouched(other, collisionPair));\n if (PairTouching != null)\n PairTouching(owner, other, collisionPair);\n }\n\n public void OnContactCreated(Collidable other, CollidablePairHandler collisionPair, Contact contact)\n {\n if (InternalContactCreated != null)\n {\n ContactData contactData;\n contactData.Position = contact.Position;\n contactData.Normal = contact.Normal;\n contactData.PenetrationDepth = contact.PenetrationDepth;\n contactData.Id = contact.Id;\n eventStorageContactCreated.Enqueue(new EventStorageContactCreated(other, collisionPair, ref contactData));\n }\n if (CreatingContact != null)\n CreatingContact(owner, other, collisionPair, contact);\n }\n\n public void OnContactRemoved(Collidable other, CollidablePairHandler collisionPair, Contact contact)\n {\n if (InternalContactRemoved != null)\n {\n ContactData contactData;\n contactData.Position = contact.Position;\n contactData.Normal = contact.Normal;\n contactData.PenetrationDepth = contact.PenetrationDepth;\n contactData.Id = contact.Id;\n eventStorageContactRemoved.Enqueue(new EventStorageContactRemoved(other, collisionPair, ref contactData));\n }\n if (RemovingContact != null)\n RemovingContact(owner, other, collisionPair, contact);\n }\n\n public void OnInitialCollisionDetected(Collidable other, CollidablePairHandler collisionPair)\n {\n if (InternalInitialCollisionDetected != null)\n eventStorageInitialCollisionDetected.Enqueue(new EventStorageInitialCollisionDetected(other, collisionPair));\n if (DetectingInitialCollision != null)\n DetectingInitialCollision(owner, other, collisionPair);\n }\n\n ///\n /// Removes all event hooks from the event manager.\n ///\n public override void RemoveAllEvents()\n {\n InternalCollisionEnded = null;\n InternalPairTouched = null;\n InternalContactCreated = null;\n InternalContactRemoved = null;\n InternalInitialCollisionDetected = null;\n\n CollisionEnding = null;\n DetectingInitialCollision = null;\n CreatingContact = null;\n RemovingContact = null;\n PairTouching = null;\n\n base.RemoveAllEvents();\n }\n\n #endregion\n\n\n\n }\n\n\n\n\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/EntryEventManager.cs",
"content": "using BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseSystems;\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\nusing BEPUphysics.OtherSpaceStages;\nusing BEPUutilities;\nusing System;\nusing BEPUutilities.DataStructures;\n\nnamespace BEPUphysics.BroadPhaseEntries.Events\n{\n\n ///\n /// Event manager for BroadPhaseEntries (all types that live in the broad phase).\n ///\n ///Some BroadPhaseEntry subclass.\n public class EntryEventManager : IDeferredEventCreator, IEntryEventTriggerer where T : BroadPhaseEntry\n {\n protected internal int childDeferredEventCreators;\n /// \n /// Number of child deferred event creators.\n /// \n int IDeferredEventCreator.ChildDeferredEventCreators\n {\n get\n {\n return childDeferredEventCreators;\n }\n set\n {\n int previousValue = childDeferredEventCreators;\n childDeferredEventCreators = value;\n if (childDeferredEventCreators == 0 && previousValue != 0)\n {\n //Deactivate!\n if (EventsAreInactive())\n {\n //The events are inactive method tests to see if this event manager\n //has any events that need to be deferred.\n //If we get here, that means that there's zero children active, and we aren't active...\n ((IDeferredEventCreator)this).IsActive = false;\n }\n }\n else if (childDeferredEventCreators != 0 && previousValue == 0)\n {\n //Activate!\n //It doesn't matter if there are any events active in this instance, just try to activate anyway.\n //If it is already active, nothing will happen.\n ((IDeferredEventCreator)this).IsActive = true;\n }\n }\n }\n\n private CompoundEventManager parent;\n /// \n /// The parent of the event manager, if any.\n /// \n protected internal CompoundEventManager Parent\n {\n get\n {\n return parent;\n }\n set\n {\n //The child deferred event creator links must be maintained.\n if (parent != null && isActive)\n ((IDeferredEventCreator)parent).ChildDeferredEventCreators--;\n parent = value;\n if (parent != null && isActive)\n ((IDeferredEventCreator)parent).ChildDeferredEventCreators++;\n }\n\n }\n\n protected internal T owner;\n ///\n /// Owner of the event manager.\n ///\n public T Owner\n {\n get\n {\n return owner;\n }\n protected internal set\n {\n owner = value;\n }\n }\n\n\n #region Events\n /// \n /// Fires when this entity's bounding box newly overlaps another entity's bounding box.\n /// \n public event PairCreatedEventHandler PairCreated\n {\n add\n {\n InternalPairCreated += value;\n AddToEventfuls();\n }\n remove\n {\n InternalPairCreated -= value;\n VerifyEventStatus();\n }\n }\n\n /// \n /// Fires when this entity's bounding box no longer overlaps another entity's bounding box.\n /// \n public event PairRemovedEventHandler PairRemoved\n {\n add\n {\n InternalPairRemoved += value;\n AddToEventfuls();\n }\n remove\n {\n InternalPairRemoved -= value;\n VerifyEventStatus();\n }\n }\n\n /// \n /// Fires when a pair is updated.\n /// \n public event PairUpdatedEventHandler PairUpdated\n {\n add\n {\n InternalPairUpdated += value;\n AddToEventfuls();\n }\n remove\n {\n InternalPairUpdated -= value;\n VerifyEventStatus();\n }\n }\n\n /// \n /// Fires when a pair is updated.\n /// Unlike the PairUpdated event, this event will run inline instead of at the end of the space's update.\n /// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.\n /// \n public event PairUpdatingEventHandler PairUpdating;\n\n /// \n /// Fires when this entity's bounding box newly overlaps another entity's bounding box.\n /// Unlike the PairCreated event, this event will run inline instead of at the end of the space's update.\n /// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.\n /// \n public event CreatingPairEventHandler CreatingPair;\n\n /// \n /// Fires when this entity's bounding box no longer overlaps another entity's bounding box.\n /// Unlike the PairRemoved event, this event will run inline instead of at the end of the space's update.\n /// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.\n /// \n public event RemovingPairEventHandler RemovingPair;\n\n\n private event PairCreatedEventHandler InternalPairCreated;\n private event PairRemovedEventHandler InternalPairRemoved;\n private event PairUpdatedEventHandler InternalPairUpdated;\n\n #endregion\n\n\n #region Supporting members\n\n /// \n /// Removes the entity from the space's list of eventful entities if no events are active.\n /// \n protected void VerifyEventStatus()\n {\n if (EventsAreInactive() && childDeferredEventCreators == 0)\n {\n ((IDeferredEventCreator)this).IsActive = false;\n }\n }\n\n protected virtual bool EventsAreInactive()\n {\n return InternalPairCreated == null &&\n InternalPairRemoved == null &&\n InternalPairUpdated == null;\n }\n\n\n protected void AddToEventfuls()\n {\n ((IDeferredEventCreator)this).IsActive = true;\n }\n\n\n private DeferredEventDispatcher deferredEventDispatcher;\n DeferredEventDispatcher IDeferredEventCreator.DeferredEventDispatcher\n {\n get\n {\n return deferredEventDispatcher;\n }\n set\n {\n deferredEventDispatcher = value;\n }\n }\n\n readonly ConcurrentDeque eventStoragePairCreated = new ConcurrentDeque(0);\n readonly ConcurrentDeque eventStoragePairRemoved = new ConcurrentDeque(0);\n readonly ConcurrentDeque eventStoragePairUpdated = new ConcurrentDeque(0);\n\n void IDeferredEventCreator.DispatchEvents()\n {\n DispatchEvents();\n }\n protected virtual void DispatchEvents()\n {\n //Note: Deferred event creation should be performed sequentially with dispatching.\n //This means a event creation from this creator cannot occur ASYNCHRONOUSLY while DispatchEvents is running.\n\n //Note: If the deferred event handler is removed during the execution of the engine, the handler may be null.\n //In this situation, ignore the event.\n //This is not a particularly clean behavior, but it's better than just crashing.\n EventStoragePairCreated collisionPairCreated;\n while (eventStoragePairCreated.TryUnsafeDequeueFirst(out collisionPairCreated))\n if (InternalPairCreated != null)\n InternalPairCreated(owner, collisionPairCreated.other, collisionPairCreated.pair);\n EventStoragePairRemoved collisionPairRemoved;\n while (eventStoragePairRemoved.TryUnsafeDequeueFirst(out collisionPairRemoved))\n if (InternalPairRemoved != null)\n InternalPairRemoved(owner, collisionPairRemoved.other);\n EventStoragePairUpdated collisionPairUpdated;\n while (eventStoragePairUpdated.TryUnsafeDequeueFirst(out collisionPairUpdated))\n if (InternalPairUpdated != null)\n InternalPairUpdated(owner, collisionPairUpdated.other, collisionPairUpdated.pair);\n\n\n }\n\n\n public void OnPairCreated(BroadPhaseEntry other, NarrowPhasePair collisionPair)\n {\n if (InternalPairCreated != null)\n eventStoragePairCreated.Enqueue(new EventStoragePairCreated(other, collisionPair));\n if (CreatingPair != null)\n CreatingPair(owner, other, collisionPair);\n }\n\n public void OnPairRemoved(BroadPhaseEntry other)\n {\n if (InternalPairRemoved != null)\n {\n eventStoragePairRemoved.Enqueue(new EventStoragePairRemoved(other));\n }\n if (RemovingPair != null)\n {\n RemovingPair(owner, other);\n }\n }\n\n public void OnPairUpdated(BroadPhaseEntry other, NarrowPhasePair collisionPair)\n {\n if (InternalPairUpdated != null)\n eventStoragePairUpdated.Enqueue(new EventStoragePairUpdated(other, collisionPair));\n if (PairUpdating != null)\n PairUpdating(owner, other, collisionPair);\n }\n\n\n private bool isActive;\n //IsActive is enabled whenever this collision information can dispatch events.\n bool IDeferredEventCreator.IsActive\n {\n get\n {\n return isActive;\n }\n set\n {\n if (!isActive && value)\n {\n isActive = true;\n //Notify the parent that it needs to activate.\n if (parent != null)\n ((IDeferredEventCreator)parent).ChildDeferredEventCreators++;\n\n if (deferredEventDispatcher != null)\n deferredEventDispatcher.CreatorActivityChanged(this);\n }\n else if (isActive && !value)\n {\n isActive = false;\n //Notify the parent that it can deactivate.\n if (parent != null)\n ((IDeferredEventCreator)parent).ChildDeferredEventCreators--;\n\n if (deferredEventDispatcher != null)\n deferredEventDispatcher.CreatorActivityChanged(this);\n }\n }\n }\n\n ///\n /// Removes all event hooks from the manager.\n ///\n public virtual void RemoveAllEvents()\n {\n PairUpdating = null;\n CreatingPair = null;\n RemovingPair = null;\n InternalPairCreated = null;\n InternalPairRemoved = null;\n InternalPairUpdated = null;\n\n VerifyEventStatus();\n }\n\n #endregion\n\n\n\n }\n\n\n\n\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/IContactEventTriggerer.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseSystems;\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\nusing BEPUphysics.CollisionTests;\n\nnamespace BEPUphysics.BroadPhaseEntries.Events\n{\n /// \n /// Manages triggers for events in an ContactEventManager.\n /// \n public interface IContactEventTriggerer : IEntryEventTriggerer\n {\n /// \n /// Fires collision ending events.\n /// \n /// Other collidable involved in the pair.\n /// Collidable pair handler that manages the two objects.\n void OnCollisionEnded(Collidable other, CollidablePairHandler collisionPair);\n\n /// \n /// Fires pair touching events.\n /// \n /// Other collidable involved in the pair.\n /// Collidable pair handler that manages the two objects.\n void OnPairTouching(Collidable other, CollidablePairHandler collisionPair);\n\n /// \n /// Fires contact creating events.\n /// \n /// Other collidable involved in the pair.\n /// Collidable pair handler that manages the two objects.\n /// Contact point of collision.\n void OnContactCreated(Collidable other, CollidablePairHandler collisionPair, Contact contact);\n\n /// \n /// Fires contact removal events.\n /// \n /// Other collidable involved in the pair.\n /// Collidable pair handler that manages the two objects.\n /// Contact point of collision.\n void OnContactRemoved(Collidable other, CollidablePairHandler collisionPair, Contact contact);\n\n /// \n /// Fires initial collision detected events.\n /// \n /// Other collidable involved in the pair.\n /// Collidable pair handler that manages the two objects.\n void OnInitialCollisionDetected(Collidable other, CollidablePairHandler collisionPair);\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/IEntryEventTriggerer.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseSystems;\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\n\nnamespace BEPUphysics.BroadPhaseEntries.Events\n{\n /// \n /// Manages triggers for events in an EntryEventManager.\n /// \n public interface IEntryEventTriggerer\n {\n /// \n /// Fires the event manager's pair creation events.\n /// \n /// Other entry involved in the pair.\n /// Narrow phase pair governing the two objects.\n void OnPairCreated(BroadPhaseEntry other, NarrowPhasePair collisionPair);\n\n /// \n /// Fires the event manager's pair removal events.\n /// \n /// Other entry involved in the pair.\n void OnPairRemoved(BroadPhaseEntry other);\n\n /// \n /// Fires the event manager's pair updated events.\n /// \n /// Other entry involved in the pair.\n /// Narrow phase pair governing the two objects.\n void OnPairUpdated(BroadPhaseEntry other, NarrowPhasePair collisionPair);\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/InstancedMesh.cs",
"content": "using System;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes;\nusing BEPUutilities;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUphysics.OtherSpaceStages;\nusing AffineTransform = BEPUutilities.AffineTransform;\nusing RigidTransform = BEPUutilities.RigidTransform;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///\n /// Collidable mesh which can be created from a reusable InstancedMeshShape.\n /// Very little data is needed for each individual InstancedMesh object, allowing\n /// a complicated mesh to be repeated many times. Since the hierarchy used to accelerate\n /// collisions is purely local, it may be marginally slower than an individual StaticMesh.\n ///\n public class InstancedMesh : StaticCollidable\n {\n\n internal AffineTransform worldTransform;\n ///\n /// Gets or sets the world transform of the mesh.\n ///\n public AffineTransform WorldTransform\n {\n get\n {\n return worldTransform;\n }\n set\n {\n worldTransform = value;\n Shape.ComputeBoundingBox(ref value, out boundingBox);\n }\n }\n\n /// \n /// Updates the bounding box to the current state of the entry.\n /// \n public override void UpdateBoundingBox()\n {\n Shape.ComputeBoundingBox(ref worldTransform, out boundingBox);\n }\n\n\n ///\n /// Constructs a new InstancedMesh.\n ///\n ///Shape to use for the instance.\n public InstancedMesh(InstancedMeshShape meshShape)\n : this(meshShape, AffineTransform.Identity)\n {\n }\n\n ///\n /// Constructs a new InstancedMesh.\n ///\n ///Shape to use for the instance.\n ///Transform to use for the instance.\n public InstancedMesh(InstancedMeshShape meshShape, AffineTransform worldTransform)\n {\n this.worldTransform = worldTransform;\n base.Shape = meshShape;\n Events = new ContactEventManager();\n\n\n }\n\n ///\n /// Gets the shape used by the instanced mesh.\n ///\n public new InstancedMeshShape Shape\n {\n get\n {\n return (InstancedMeshShape)shape;\n }\n }\n\n internal TriangleSidedness sidedness = TriangleSidedness.DoubleSided;\n ///\n /// Gets or sets the sidedness of the mesh. This can be used to ignore collisions and rays coming from a direction relative to the winding of the triangle.\n ///\n public TriangleSidedness Sidedness\n {\n get\n {\n return sidedness;\n }\n set\n {\n sidedness = value;\n }\n }\n\n internal bool improveBoundaryBehavior = true;\n /// \n /// Gets or sets whether or not the collision system should attempt to improve contact behavior at the boundaries between triangles.\n /// This has a slight performance cost, but prevents objects sliding across a triangle boundary from 'bumping,' and otherwise improves\n /// the robustness of contacts at edges and vertices.\n /// \n public bool ImproveBoundaryBehavior\n {\n get\n {\n return improveBoundaryBehavior;\n }\n set\n {\n improveBoundaryBehavior = value;\n }\n }\n\n\n protected internal ContactEventManager events;\n ///\n /// Gets the event manager of the mesh.\n ///\n public ContactEventManager Events\n {\n get\n {\n return events;\n }\n set\n {\n if (value.Owner != null && //Can't use a manager which is owned by a different entity.\n value != events) //Stay quiet if for some reason the same event manager is being set.\n throw new ArgumentException(\"Event manager is already owned by a mesh; event managers cannot be shared.\");\n if (events != null)\n events.Owner = null;\n events = value;\n if (events != null)\n events.Owner = this;\n }\n }\n protected internal override IContactEventTriggerer EventTriggerer\n {\n get { return events; }\n }\n\n protected override IDeferredEventCreator EventCreator\n {\n get\n {\n return events;\n }\n }\n\n\n /// \n /// Tests a ray against the entry.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit location of the ray on the entry, if any.\n /// Whether or not the ray hit the entry.\n public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)\n {\n return RayCast(ray, maximumLength, sidedness, out rayHit);\n }\n\n ///\n /// Tests a ray against the instance.\n ///\n ///Ray to test.\n ///Maximum length of the ray to test; in units of the ray's direction's length.\n ///Sidedness to use during the ray cast. This does not have to be the same as the mesh's sidedness.\n ///The hit location of the ray on the mesh, if any.\n ///Whether or not the ray hit the mesh.\n public bool RayCast(Ray ray, float maximumLength, TriangleSidedness sidedness, out RayHit rayHit)\n {\n //Put the ray into local space.\n Ray localRay;\n AffineTransform inverse;\n AffineTransform.Invert(ref worldTransform, out inverse);\n Matrix3x3.Transform(ref ray.Direction, ref inverse.LinearTransform, out localRay.Direction);\n AffineTransform.Transform(ref ray.Position, ref inverse, out localRay.Position);\n\n if (Shape.TriangleMesh.RayCast(localRay, maximumLength, sidedness, out rayHit))\n {\n //Transform the hit into world space.\n Vector3.Multiply(ref ray.Direction, rayHit.T, out rayHit.Location);\n Vector3.Add(ref rayHit.Location, ref ray.Position, out rayHit.Location);\n Matrix3x3.TransformTranspose(ref rayHit.Normal, ref inverse.LinearTransform, out rayHit.Normal);\n return true;\n }\n rayHit = new RayHit();\n return false;\n }\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Hit data, if any.\n /// Whether or not the cast hit anything.\n public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit)\n {\n hit = new RayHit();\n BoundingBox boundingBox;\n castShape.GetSweptLocalBoundingBox(ref startingTransform, ref worldTransform, ref sweep, out boundingBox);\n var tri = PhysicsResources.GetTriangle();\n var hitElements = CommonResources.GetIntList();\n if (this.Shape.TriangleMesh.Tree.GetOverlaps(boundingBox, hitElements))\n {\n hit.T = float.MaxValue;\n for (int i = 0; i < hitElements.Count; i++)\n {\n Shape.TriangleMesh.Data.GetTriangle(hitElements[i], out tri.vA, out tri.vB, out tri.vC);\n AffineTransform.Transform(ref tri.vA, ref worldTransform, out tri.vA);\n AffineTransform.Transform(ref tri.vB, ref worldTransform, out tri.vB);\n AffineTransform.Transform(ref tri.vC, ref worldTransform, out tri.vC);\n Vector3 center;\n Vector3.Add(ref tri.vA, ref tri.vB, out center);\n Vector3.Add(ref center, ref tri.vC, out center);\n Vector3.Multiply(ref center, 1f / 3f, out center);\n Vector3.Subtract(ref tri.vA, ref center, out tri.vA);\n Vector3.Subtract(ref tri.vB, ref center, out tri.vB);\n Vector3.Subtract(ref tri.vC, ref center, out tri.vC);\n tri.maximumRadius = tri.vA.LengthSquared();\n float radius = tri.vB.LengthSquared();\n if (tri.maximumRadius < radius)\n tri.maximumRadius = radius;\n radius = tri.vC.LengthSquared();\n if (tri.maximumRadius < radius)\n tri.maximumRadius = radius;\n tri.maximumRadius = (float)Math.Sqrt(tri.maximumRadius);\n tri.collisionMargin = 0;\n var triangleTransform = new RigidTransform { Orientation = Quaternion.Identity, Position = center };\n RayHit tempHit;\n if (MPRToolbox.Sweep(castShape, tri, ref sweep, ref Toolbox.ZeroVector, ref startingTransform, ref triangleTransform, out tempHit) && tempHit.T < hit.T)\n {\n hit = tempHit;\n }\n }\n tri.maximumRadius = 0;\n PhysicsResources.GiveBack(tri);\n CommonResources.GiveBack(hitElements);\n return hit.T != float.MaxValue;\n }\n PhysicsResources.GiveBack(tri);\n CommonResources.GiveBack(hitElements);\n return false;\n }\n\n \n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundCollidable.cs",
"content": "using System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.BroadPhaseSystems;\nusing BEPUphysics.CollisionShapes;\nusing BEPUutilities;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities.DataStructures;\nusing BEPUphysics.Materials;\nusing BEPUphysics.CollisionRuleManagement;\nusing System;\n\nnamespace BEPUphysics.BroadPhaseEntries.MobileCollidables\n{\n ///\n /// Collidable used by compound shapes.\n ///\n public class CompoundCollidable : EntityCollidable\n {\n /// \n /// Gets or sets the event manager for the collidable.\n /// Compound collidables must use a special CompoundEventManager in order for the deferred events created\n /// by child collidables to be dispatched.\n /// If this method is bypassed and a different event manager is used, this method will return null and \n /// deferred events from children will fail.\n /// \n public new CompoundEventManager Events\n {\n get\n {\n return events as CompoundEventManager;\n }\n set\n {\n //Tell every child to update their parent references to the new object.\n foreach (var child in children)\n {\n child.CollisionInformation.events.Parent = value;\n }\n base.Events = value;\n }\n }\n\n ///\n /// Gets the shape of the collidable.\n ///\n public new CompoundShape Shape\n {\n get\n {\n return (CompoundShape)shape;\n }\n protected internal set\n {\n base.Shape = value;\n }\n }\n\n internal RawList children = new RawList();\n ///\n /// Gets a list of the children in the collidable.\n ///\n public ReadOnlyList Children\n {\n get\n {\n return new ReadOnlyList(children);\n }\n }\n\n\n\n protected override void OnEntityChanged()\n {\n for (int i = 0; i < children.Count; i++)\n {\n children.Elements[i].CollisionInformation.Entity = entity;\n if (children.Elements[i].Material == null)\n children.Elements[i].Material = entity.material;\n }\n base.OnEntityChanged();\n }\n\n\n\n\n private CompoundChild GetChild(CompoundChildData data, int index)\n {\n var instance = data.Entry.Shape.GetCollidableInstance();\n\n if (data.Events != null)\n instance.Events = data.Events;\n //Establish the link between the child event manager and our event manager.\n instance.events.Parent = Events;\n\n if (data.CollisionRules != null)\n instance.CollisionRules = data.CollisionRules;\n\n instance.Tag = data.Tag;\n\n if (data.Material == null)\n data.Material = new Material();\n\n return new CompoundChild(Shape, instance, data.Material, index);\n }\n\n private CompoundChild GetChild(CompoundShapeEntry entry, int index)\n {\n var instance = entry.Shape.GetCollidableInstance();\n //Establish the link between the child event manager and our event manager.\n instance.events.Parent = Events;\n return new CompoundChild(Shape, instance, index);\n }\n\n //Used to efficiently split compounds.\n internal CompoundCollidable()\n {\n Events = new CompoundEventManager();\n\n hierarchy = new CompoundHierarchy(this);\n\n }\n\n ///\n /// Constructs a compound collidable using additional information about the shapes in the compound.\n ///\n ///Data representing the children of the compound collidable.\n public CompoundCollidable(IList children)\n {\n Events = new CompoundEventManager();\n\n var shapeList = new RawList();\n //Create the shape first.\n for (int i = 0; i < children.Count; i++)\n {\n shapeList.Add(children[i].Entry);\n }\n base.Shape = new CompoundShape(shapeList);\n //Now create the actual child objects.\n for (int i = 0; i < children.Count; i++)\n {\n this.children.Add(GetChild(children[i], i));\n }\n hierarchy = new CompoundHierarchy(this);\n\n }\n\n ///\n /// Constructs a compound collidable using additional information about the shapes in the compound.\n ///\n ///Data representing the children of the compound collidable.\n ///Location computed to be the center of the compound object.\n public CompoundCollidable(IList children, out Vector3 center)\n {\n Events = new CompoundEventManager();\n\n var shapeList = new RawList();\n //Create the shape first.\n for (int i = 0; i < children.Count; i++)\n {\n shapeList.Add(children[i].Entry);\n }\n base.Shape = new CompoundShape(shapeList, out center);\n //Now create the actual child objects.\n for (int i = 0; i < children.Count; i++)\n {\n this.children.Add(GetChild(children[i], i));\n }\n hierarchy = new CompoundHierarchy(this);\n\n }\n\n\n ///\n /// Constructs a new CompoundCollidable.\n ///\n ///Compound shape to use for the collidable.\n public CompoundCollidable(CompoundShape compoundShape)\n : base(compoundShape)\n {\n Events = new CompoundEventManager();\n\n for (int i = 0; i < compoundShape.shapes.Count; i++)\n {\n CompoundChild child = GetChild(compoundShape.shapes.Elements[i], i);\n this.children.Add(child);\n }\n hierarchy = new CompoundHierarchy(this);\n\n\n }\n\n\n\n\n\n\n internal CompoundHierarchy hierarchy;\n ///\n /// Gets the hierarchy of children used by the collidable.\n ///\n public CompoundHierarchy Hierarchy\n {\n get\n {\n return hierarchy;\n }\n }\n\n\n ///\n /// Updates the world transform of the collidable.\n ///\n ///Position to use for the calculation.\n ///Orientation to use for the calculation.\n public override void UpdateWorldTransform(ref Vector3 position, ref Quaternion orientation)\n {\n base.UpdateWorldTransform(ref position, ref orientation);\n var shapeList = Shape.shapes;\n for (int i = 0; i < children.Count; i++)\n {\n RigidTransform transform;\n RigidTransform.Transform(ref shapeList.Elements[children.Elements[i].shapeIndex].LocalTransform, ref worldTransform, out transform);\n children.Elements[i].CollisionInformation.UpdateWorldTransform(ref transform.Position, ref transform.Orientation);\n }\n }\n\n protected internal override void UpdateBoundingBoxInternal(float dt)\n {\n for (int i = 0; i < children.Count; i++)\n {\n children.Elements[i].CollisionInformation.UpdateBoundingBoxInternal(dt);\n }\n hierarchy.Tree.Refit();\n boundingBox = hierarchy.Tree.BoundingBox;\n\n }\n\n\n /// \n /// Tests a ray against the collidable.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit location of the ray on the collidable, if any.\n /// Whether or not the ray hit the collidable.\n public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)\n {\n CompoundChild hitChild;\n bool hit = RayCast(ray, maximumLength, out rayHit, out hitChild);\n return hit;\n }\n\n /// \n /// Tests a ray against the compound.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit data and the hit child collidable, if any.\n /// Whether or not the ray hit the entry.\n public bool RayCast(Ray ray, float maximumLength, out RayCastResult rayHit)\n {\n RayHit hitData;\n CompoundChild hitChild;\n bool hit = RayCast(ray, maximumLength, out hitData, out hitChild);\n rayHit = new RayCastResult { HitData = hitData, HitObject = hitChild.CollisionInformation };\n return hit;\n }\n\n /// \n /// Tests a ray against the collidable.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit data, if any.\n /// Child collidable hit by the ray, if any.\n /// Whether or not the ray hit the entry.\n public bool RayCast(Ray ray, float maximumLength, out RayHit rayHit, out CompoundChild hitChild)\n {\n rayHit = new RayHit();\n hitChild = null;\n var hitElements = PhysicsResources.GetCompoundChildList();\n if (hierarchy.Tree.GetOverlaps(ray, maximumLength, hitElements))\n {\n rayHit.T = float.MaxValue;\n for (int i = 0; i < hitElements.Count; i++)\n {\n EntityCollidable candidate = hitElements.Elements[i].CollisionInformation;\n RayHit tempHit;\n if (candidate.RayCast(ray, maximumLength, out tempHit) && tempHit.T < rayHit.T)\n {\n rayHit = tempHit;\n hitChild = hitElements.Elements[i];\n }\n }\n PhysicsResources.GiveBack(hitElements);\n return rayHit.T != float.MaxValue;\n }\n PhysicsResources.GiveBack(hitElements);\n return false;\n }\n\n /// \n /// Tests a ray against the collidable.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present\n /// in the entry, this filter will be passed into inner ray casts.\n /// Hit location of the ray on the collidable, if any.\n /// Whether or not the ray hit the collidable.\n public override bool RayCast(Ray ray, float maximumLength, Func filter, out RayHit rayHit)\n {\n CompoundChild hitChild;\n bool hit = RayCast(ray, maximumLength, filter, out rayHit, out hitChild);\n return hit;\n }\n\n /// \n /// Tests a ray against the compound.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit data and the hit child collidable, if any.\n /// Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present\n /// in the entry, this filter will be passed into inner ray casts.\n /// Whether or not the ray hit the entry.\n public bool RayCast(Ray ray, float maximumLength, Func filter, out RayCastResult rayHit)\n {\n RayHit hitData;\n CompoundChild hitChild;\n bool hit = RayCast(ray, maximumLength, filter, out hitData, out hitChild);\n rayHit = new RayCastResult { HitData = hitData, HitObject = hitChild.CollisionInformation };\n return hit;\n }\n\n /// \n /// Tests a ray against the collidable.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present\n /// in the entry, this filter will be passed into inner ray casts.\n /// Hit location of the ray on the collidable, if any.\n /// Child hit by the ray.\n /// Whether or not the ray hit the collidable.\n public bool RayCast(Ray ray, float maximumLength, Func filter, out RayHit rayHit, out CompoundChild hitChild)\n {\n rayHit = new RayHit();\n hitChild = null;\n if (filter(this))\n {\n var hitElements = PhysicsResources.GetCompoundChildList();\n if (hierarchy.Tree.GetOverlaps(ray, maximumLength, hitElements))\n {\n rayHit.T = float.MaxValue;\n for (int i = 0; i < hitElements.Count; i++)\n {\n RayHit tempHit;\n if (hitElements.Elements[i].CollisionInformation.RayCast(ray, maximumLength, filter, out tempHit) && tempHit.T < rayHit.T)\n {\n rayHit = tempHit;\n hitChild = hitElements.Elements[i];\n }\n }\n PhysicsResources.GiveBack(hitElements);\n return rayHit.T != float.MaxValue;\n }\n PhysicsResources.GiveBack(hitElements);\n }\n return false;\n }\n\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Hit data, if any.\n /// Whether or not the cast hit anything.\n public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit rayHit)\n {\n CompoundChild hitChild;\n bool hit = ConvexCast(castShape, ref startingTransform, ref sweep, out rayHit, out hitChild);\n return hit;\n }\n\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Data and hit object from the first impact, if any.\n /// Whether or not the cast hit anything.\n public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayCastResult result)\n {\n CompoundChild hitChild;\n RayHit rayHit;\n bool hit = ConvexCast(castShape, ref startingTransform, ref sweep, out rayHit, out hitChild);\n result = new RayCastResult { HitData = rayHit, HitObject = hitChild.CollisionInformation };\n return hit;\n }\n\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Hit data, if any.\n /// Child hit by the cast.\n /// Whether or not the cast hit anything.\n public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit, out CompoundChild hitChild)\n {\n hit = new RayHit();\n hitChild = null;\n BoundingBox boundingBox;\n castShape.GetSweptBoundingBox(ref startingTransform, ref sweep, out boundingBox);\n var hitElements = PhysicsResources.GetCompoundChildList();\n if (hierarchy.Tree.GetOverlaps(boundingBox, hitElements))\n {\n hit.T = float.MaxValue;\n for (int i = 0; i < hitElements.Count; i++)\n {\n var candidate = hitElements.Elements[i].CollisionInformation;\n RayHit tempHit;\n if (candidate.ConvexCast(castShape, ref startingTransform, ref sweep, out tempHit) && tempHit.T < hit.T)\n {\n hit = tempHit;\n hitChild = hitElements.Elements[i];\n }\n }\n PhysicsResources.GiveBack(hitElements);\n return hit.T != float.MaxValue;\n }\n PhysicsResources.GiveBack(hitElements);\n return false;\n }\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present\n /// in the entry, this filter will be passed into inner ray casts.\n /// Hit data, if any.\n /// Whether or not the cast hit anything.\n public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, Func filter, out RayHit rayHit)\n {\n CompoundChild hitChild;\n bool hit = ConvexCast(castShape, ref startingTransform, ref sweep, filter, out rayHit, out hitChild);\n return hit;\n }\n\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present\n /// in the entry, this filter will be passed into inner ray casts.\n /// Data and hit object from the first impact, if any.\n /// Whether or not the cast hit anything.\n public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, Func filter, out RayCastResult result)\n {\n CompoundChild hitChild;\n RayHit rayHit;\n bool hit = ConvexCast(castShape, ref startingTransform, ref sweep, filter, out rayHit, out hitChild);\n result = new RayCastResult { HitData = rayHit, HitObject = hitChild.CollisionInformation };\n return hit;\n }\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present\n /// in the entry, this filter will be passed into inner ray casts.\n /// Hit data, if any.\n /// Child hit by the cast.\n /// Whether or not the cast hit anything.\n public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, Func filter, out RayHit hit, out CompoundChild hitChild)\n {\n hit = new RayHit();\n hitChild = null;\n BoundingBox boundingBox;\n castShape.GetSweptBoundingBox(ref startingTransform, ref sweep, out boundingBox);\n var hitElements = PhysicsResources.GetCompoundChildList();\n if (hierarchy.Tree.GetOverlaps(boundingBox, hitElements))\n {\n hit.T = float.MaxValue;\n for (int i = 0; i < hitElements.Count; i++)\n {\n var candidate = hitElements.Elements[i].CollisionInformation;\n RayHit tempHit;\n if (candidate.ConvexCast(castShape, ref startingTransform, ref sweep, filter, out tempHit) && tempHit.T < hit.T)\n {\n hit = tempHit;\n hitChild = hitElements.Elements[i];\n }\n }\n PhysicsResources.GiveBack(hitElements);\n return hit.T != float.MaxValue;\n }\n PhysicsResources.GiveBack(hitElements);\n return false;\n }\n\n }\n\n ///\n /// Data which can be used to create a CompoundChild.\n /// This data is not itself a child yet; another system\n /// will use it as input to construct the children.\n ///\n public struct CompoundChildData\n {\n ///\n /// Shape entry of the compound child.\n ///\n public CompoundShapeEntry Entry;\n ///\n /// Event manager for the new child.\n ///\n public ContactEventManager Events;\n ///\n /// Collision rules for the new child.\n ///\n public CollisionRules CollisionRules;\n ///\n /// Material for the new child.\n ///\n public Material Material;\n /// \n /// Tag to assign to the collidable created for this child.\n /// \n public object Tag;\n\n }\n\n\n ///\n /// A collidable child of a compound.\n ///\n public class CompoundChild : IBoundingBoxOwner\n {\n CompoundShape shape;\n internal int shapeIndex;\n\n /// \n /// Gets the index of the shape used by this child in the CompoundShape's shapes list.\n /// \n public int ShapeIndex\n {\n get\n {\n return shapeIndex;\n }\n }\n\n private EntityCollidable collisionInformation;\n ///\n /// Gets the Collidable associated with the child.\n ///\n public EntityCollidable CollisionInformation\n {\n get\n {\n return collisionInformation;\n }\n }\n\n ///\n /// Gets or sets the material associated with the child.\n ///\n public Material Material { get; set; }\n\n /// \n /// Gets the index of the shape associated with this child in the CompoundShape's shapes list.\n /// \n public CompoundShapeEntry Entry\n {\n get\n {\n return shape.shapes.Elements[shapeIndex];\n }\n\n }\n\n internal CompoundChild(CompoundShape shape, EntityCollidable collisionInformation, Material material, int index)\n {\n this.shape = shape;\n this.collisionInformation = collisionInformation;\n Material = material;\n this.shapeIndex = index;\n }\n\n internal CompoundChild(CompoundShape shape, EntityCollidable collisionInformation, int index)\n {\n this.shape = shape;\n this.collisionInformation = collisionInformation;\n this.shapeIndex = index;\n }\n\n /// \n /// Gets the bounding box of the child.\n /// \n public BoundingBox BoundingBox\n {\n get { return collisionInformation.boundingBox; }\n }\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHelper.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.CollisionShapes;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\nusing BEPUphysics.Entities;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\n\nnamespace BEPUphysics.BroadPhaseEntries.MobileCollidables\n{\n /// \n /// Contains methods to help with splitting compound objects into multiple pieces.\n /// \n public static class CompoundHelper\n {\n /// \n /// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.\n /// \n /// Delegate which determines if a child in the original compound should be moved to the new compound.\n /// Original compound to be split. Children in this compound will be removed and added to the other compound.\n /// Compound to receive children removed from the original compound.\n /// Whether or not the predicate returned true for any element in the original compound and split the compound.\n public static bool SplitCompound(Func splitPredicate,\n Entity a, out Entity b)\n {\n var childContributions = a.CollisionInformation.Shape.ComputeChildContributions();\n return SplitCompound(childContributions, splitPredicate, a, out b);\n }\n /// \n /// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.\n /// \n /// List of distribution information associated with each child shape of the whole compound shape used by the compound being split.\n /// Delegate which determines if a child in the original compound should be moved to the new compound.\n /// Original compound to be split. Children in this compound will be removed and added to the other compound.\n /// Compound to receive children removed from the original compound.\n /// Whether or not the predicate returned true for any element in the original compound and split the compound.\n public static bool SplitCompound(IList childContributions, Func splitPredicate,\n Entity a, out Entity b)\n {\n\n ShapeDistributionInformation distributionInfoA, distributionInfoB;\n if (SplitCompound(childContributions, splitPredicate, a, out b, out distributionInfoA, out distributionInfoB))\n {\n return true;\n }\n else\n return false;\n }\n\n /// \n /// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.\n /// \n /// List of distribution information associated with each child shape of the whole compound shape used by the compound being split.\n /// Delegate which determines if a child in the original compound should be moved to the new compound.\n /// Original compound to be split. Children in this compound will be removed and added to the other compound.\n /// Compound to receive children removed from the original compound.\n /// Volume, volume distribution, and center information about the new form of the original compound collidable.\n /// Volume, volume distribution, and center information about the new compound collidable.\n /// Whether or not the predicate returned true for any element in the original compound and split the compound.\n public static bool SplitCompound(IList childContributions, Func splitPredicate,\n Entity a, out Entity b,\n out ShapeDistributionInformation distributionInfoA, out ShapeDistributionInformation distributionInfoB)\n {\n var bCollidable = new CompoundCollidable { Shape = a.CollisionInformation.Shape };\n b = null;\n\n\n float weightA, weightB;\n if (SplitCompound(childContributions, splitPredicate, a.CollisionInformation, bCollidable, out distributionInfoA, out distributionInfoB, out weightA, out weightB))\n {\n //Reconfigure the entities using the data computed in the split.\n float originalMass = a.mass;\n if (a.CollisionInformation.children.Count > 0)\n {\n float newMassA = (weightA / (weightA + weightB)) * originalMass;\n Matrix3x3.Multiply(ref distributionInfoA.VolumeDistribution, newMassA * InertiaHelper.InertiaTensorScale, out distributionInfoA.VolumeDistribution);\n a.Initialize(a.CollisionInformation, newMassA, distributionInfoA.VolumeDistribution, distributionInfoA.Volume);\n }\n if (bCollidable.children.Count > 0)\n {\n float newMassB = (weightB / (weightA + weightB)) * originalMass;\n Matrix3x3.Multiply(ref distributionInfoB.VolumeDistribution, newMassB * InertiaHelper.InertiaTensorScale, out distributionInfoB.VolumeDistribution);\n b = new Entity();\n b.Initialize(bCollidable, newMassB, distributionInfoB.VolumeDistribution, distributionInfoB.Volume);\n }\n\n SplitReposition(a, b, ref distributionInfoA, ref distributionInfoB, weightA, weightB);\n return true;\n }\n else\n return false;\n }\n\n static void SplitReposition(Entity a, Entity b, ref ShapeDistributionInformation distributionInfoA, ref ShapeDistributionInformation distributionInfoB, float weightA, float weightB)\n {\n //The compounds are not aligned with the original's position yet.\n //In order to align them, first look at the centers the split method computed.\n //They are offsets from the center of the original shape in local space.\n //These can be used to reposition the objects in world space.\n Vector3 weightedA, weightedB;\n Vector3.Multiply(ref distributionInfoA.Center, weightA, out weightedA);\n Vector3.Multiply(ref distributionInfoB.Center, weightB, out weightedB);\n Vector3 newLocalCenter;\n Vector3.Add(ref weightedA, ref weightedB, out newLocalCenter);\n Vector3.Divide(ref newLocalCenter, weightA + weightB, out newLocalCenter);\n\n Vector3 localOffsetA;\n Vector3 localOffsetB;\n Vector3.Subtract(ref distributionInfoA.Center, ref newLocalCenter, out localOffsetA);\n Vector3.Subtract(ref distributionInfoB.Center, ref newLocalCenter, out localOffsetB);\n\n Vector3 originalPosition = a.position;\n\n b.Orientation = a.Orientation;\n Vector3 offsetA = Vector3.Transform(localOffsetA, a.Orientation);\n Vector3 offsetB = Vector3.Transform(localOffsetB, a.Orientation);\n a.Position = originalPosition + offsetA;\n b.Position = originalPosition + offsetB;\n\n Vector3 originalLinearVelocity = a.linearVelocity;\n Vector3 originalAngularVelocity = a.angularVelocity;\n a.AngularVelocity = originalAngularVelocity;\n b.AngularVelocity = originalAngularVelocity;\n a.LinearVelocity = originalLinearVelocity + Vector3.Cross(originalAngularVelocity, offsetA);\n b.LinearVelocity = originalLinearVelocity + Vector3.Cross(originalAngularVelocity, offsetB);\n }\n\n\n /// \n /// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.\n /// \n /// Delegate which determines if a child in the original compound should be moved to the new compound.\n /// Original compound to be split. Children in this compound will be removed and added to the other compound.\n /// Compound to receive children removed from the original compound.\n /// Whether or not the predicate returned true for any element in the original compound and split the compound.\n public static bool SplitCompound(Func splitPredicate,\n Entity a, Entity b)\n {\n var childContributions = a.CollisionInformation.Shape.ComputeChildContributions();\n if (SplitCompound(childContributions, splitPredicate, a, b))\n {\n return true;\n }\n else\n return false;\n }\n\n\n /// \n /// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.\n /// \n /// List of distribution information associated with each child shape of the whole compound shape used by the compound being split.\n /// Delegate which determines if a child in the original compound should be moved to the new compound.\n /// Original compound to be split. Children in this compound will be removed and added to the other compound.\n /// Compound to receive children removed from the original compound.\n /// Whether or not the predicate returned true for any element in the original compound and split the compound.\n public static bool SplitCompound(IList childContributions, Func splitPredicate,\n Entity a, Entity b)\n {\n ShapeDistributionInformation distributionInfoA, distributionInfoB;\n if (SplitCompound(childContributions, splitPredicate, a, b, out distributionInfoA, out distributionInfoB))\n {\n return true;\n }\n else\n return false;\n }\n\n /// \n /// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.\n /// \n /// List of distribution information associated with each child shape of the whole compound shape used by the compound being split.\n /// Delegate which determines if a child in the original compound should be moved to the new compound.\n /// Volume, volume distribution, and center information about the new form of the original compound collidable.\n /// Volume, volume distribution, and center information about the new compound collidable.\n /// Original compound to be split. Children in this compound will be removed and added to the other compound.\n /// Compound to receive children removed from the original compound.\n /// Whether or not the predicate returned true for any element in the original compound and split the compound.\n public static bool SplitCompound(IList childContributions, Func splitPredicate,\n Entity a, Entity b,\n out ShapeDistributionInformation distributionInfoA, out ShapeDistributionInformation distributionInfoB)\n {\n float weightA, weightB;\n if (SplitCompound(childContributions, splitPredicate, a.CollisionInformation, b.CollisionInformation, out distributionInfoA, out distributionInfoB, out weightA, out weightB))\n {\n //Reconfigure the entities using the data computed in the split.\n float originalMass = a.mass;\n if (a.CollisionInformation.children.Count > 0)\n {\n float newMassA = (weightA / (weightA + weightB)) * originalMass;\n Matrix3x3.Multiply(ref distributionInfoA.VolumeDistribution, newMassA * InertiaHelper.InertiaTensorScale, out distributionInfoA.VolumeDistribution);\n a.Initialize(a.CollisionInformation, newMassA, distributionInfoA.VolumeDistribution, distributionInfoA.Volume);\n }\n\n if (b.CollisionInformation.children.Count > 0)\n {\n float newMassB = (weightB / (weightA + weightB)) * originalMass;\n Matrix3x3.Multiply(ref distributionInfoB.VolumeDistribution, newMassB * InertiaHelper.InertiaTensorScale, out distributionInfoB.VolumeDistribution);\n b.Initialize(b.CollisionInformation, newMassB, distributionInfoB.VolumeDistribution, distributionInfoB.Volume);\n }\n\n SplitReposition(a, b, ref distributionInfoA, ref distributionInfoB, weightA, weightB);\n\n return true;\n }\n else\n return false;\n }\n\n /// \n /// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.\n /// \n /// List of distribution information associated with each child shape of the whole compound shape used by the compound being split.\n /// Delegate which determines if a child in the original compound should be moved to the new compound.\n /// Original compound to be split. Children in this compound will be removed and added to the other compound.\n /// Compound to receive children removed from the original compound.\n /// Volume, volume distribution, and center information about the new form of the original compound collidable.\n /// Volume, volume distribution, and center information about the new compound collidable.\n /// Total weight associated with the new form of the original compound collidable.\n /// Total weight associated with the new compound collidable.\n /// Whether or not the predicate returned true for any element in the original compound and split the compound.\n public static bool SplitCompound(IList childContributions, Func splitPredicate,\n CompoundCollidable a, CompoundCollidable b,\n out ShapeDistributionInformation distributionInfoA, out ShapeDistributionInformation distributionInfoB,\n out float weightA, out float weightB)\n {\n bool splitOccurred = false;\n for (int i = a.children.Count - 1; i >= 0; i--)\n {\n //The shape doesn't change during this process. The entity could, though.\n //All of the other collidable information, like the Tag, CollisionRules, Events, etc. all stay the same.\n var child = a.children.Elements[i];\n if (splitPredicate(child))\n {\n splitOccurred = true;\n\n a.children.FastRemoveAt(i);\n b.children.Add(child);\n //The child event handler must be unhooked from the old compound and given to the new one.\n child.CollisionInformation.events.Parent = b.Events;\n }\n }\n\n if (!splitOccurred)\n {\n //No split occurred, so we cannot proceed.\n distributionInfoA = new ShapeDistributionInformation();\n distributionInfoB = new ShapeDistributionInformation();\n weightA = 0;\n weightB = 0;\n return false;\n }\n\n //Compute the contributions from the original shape to the new form of the original collidable.\n distributionInfoA = new ShapeDistributionInformation();\n weightA = 0;\n distributionInfoB = new ShapeDistributionInformation();\n weightB = 0;\n for (int i = a.children.Count - 1; i >= 0; i--)\n {\n var child = a.children.Elements[i];\n var entry = child.Entry;\n var contribution = childContributions[child.shapeIndex];\n Vector3.Add(ref contribution.Center, ref entry.LocalTransform.Position, out contribution.Center);\n Vector3.Multiply(ref contribution.Center, child.Entry.Weight, out contribution.Center);\n Vector3.Add(ref contribution.Center, ref distributionInfoA.Center, out distributionInfoA.Center);\n distributionInfoA.Volume += contribution.Volume;\n weightA += entry.Weight;\n }\n for (int i = b.children.Count - 1; i >= 0; i--)\n {\n var child = b.children.Elements[i];\n var entry = child.Entry;\n var contribution = childContributions[child.shapeIndex];\n Vector3.Add(ref contribution.Center, ref entry.LocalTransform.Position, out contribution.Center);\n Vector3.Multiply(ref contribution.Center, child.Entry.Weight, out contribution.Center);\n Vector3.Add(ref contribution.Center, ref distributionInfoB.Center, out distributionInfoB.Center);\n distributionInfoB.Volume += contribution.Volume;\n weightB += entry.Weight;\n }\n\n //Average the center out.\n if (weightA > 0)\n Vector3.Divide(ref distributionInfoA.Center, weightA, out distributionInfoA.Center);\n\n if (weightB > 0)\n Vector3.Divide(ref distributionInfoB.Center, weightB, out distributionInfoB.Center);\n\n //Note that the 'entry' is from the Shape, and so the translations are local to the shape's center.\n //That is not technically the center of the new collidable- distributionInfoA.Center is.\n //Offset the child collidables by -distributionInfoA.Center using their local offset.\n Vector3 offsetA;\n Vector3.Negate(ref distributionInfoA.Center, out offsetA);\n Vector3 offsetB;\n Vector3.Negate(ref distributionInfoB.Center, out offsetB);\n\n //Compute the unscaled inertia tensor.\n for (int i = a.children.Count - 1; i >= 0; i--)\n {\n var child = a.children.Elements[i];\n var entry = child.Entry;\n Vector3 transformedOffset;\n Quaternion conjugate;\n Quaternion.Conjugate(ref entry.LocalTransform.Orientation, out conjugate);\n Vector3.Transform(ref offsetA, ref conjugate, out transformedOffset);\n child.CollisionInformation.localPosition = transformedOffset;\n var contribution = childContributions[child.shapeIndex];\n CompoundShape.TransformContribution(ref entry.LocalTransform, ref distributionInfoA.Center, ref contribution.VolumeDistribution, entry.Weight, out contribution.VolumeDistribution);\n //Vector3.Add(ref entry.LocalTransform.Position, ref offsetA, out entry.LocalTransform.Position);\n Matrix3x3.Add(ref contribution.VolumeDistribution, ref distributionInfoA.VolumeDistribution, out distributionInfoA.VolumeDistribution);\n }\n for (int i = b.children.Count - 1; i >= 0; i--)\n {\n var child = b.children.Elements[i];\n var entry = child.Entry;\n Vector3 transformedOffset;\n Quaternion conjugate;\n Quaternion.Conjugate(ref entry.LocalTransform.Orientation, out conjugate);\n Vector3.Transform(ref offsetB, ref conjugate, out transformedOffset);\n child.CollisionInformation.localPosition = transformedOffset;\n var contribution = childContributions[child.shapeIndex];\n CompoundShape.TransformContribution(ref entry.LocalTransform, ref distributionInfoB.Center, ref contribution.VolumeDistribution, entry.Weight, out contribution.VolumeDistribution);\n //Vector3.Add(ref entry.LocalTransform.Position, ref offsetB, out entry.LocalTransform.Position);\n Matrix3x3.Add(ref contribution.VolumeDistribution, ref distributionInfoB.VolumeDistribution, out distributionInfoB.VolumeDistribution);\n }\n\n //Normalize the volume distribution.\n Matrix3x3.Multiply(ref distributionInfoA.VolumeDistribution, 1 / weightA, out distributionInfoA.VolumeDistribution);\n Matrix3x3.Multiply(ref distributionInfoB.VolumeDistribution, 1 / weightB, out distributionInfoB.VolumeDistribution);\n\n //Update the hierarchies of the compounds.\n //TODO: Create a new method that does this quickly without garbage. Requires a new Reconstruct method which takes a pool which stores the appropriate node types.\n a.hierarchy.Tree.Reconstruct(a.children);\n b.hierarchy.Tree.Reconstruct(b.children);\n\n return true;\n }\n\n\n static void RemoveReposition(Entity compound, ref ShapeDistributionInformation distributionInfo, float weight, float removedWeight, ref Vector3 removedCenter)\n {\n //The compounds are not aligned with the original's position yet.\n //In order to align them, first look at the centers the split method computed.\n //They are offsets from the center of the original shape in local space.\n //These can be used to reposition the objects in world space.\n Vector3 weightedA, weightedB;\n Vector3.Multiply(ref distributionInfo.Center, weight, out weightedA);\n Vector3.Multiply(ref removedCenter, removedWeight, out weightedB);\n Vector3 newLocalCenter;\n Vector3.Add(ref weightedA, ref weightedB, out newLocalCenter);\n Vector3.Divide(ref newLocalCenter, weight + removedWeight, out newLocalCenter);\n\n Vector3 localOffset;\n Vector3.Subtract(ref distributionInfo.Center, ref newLocalCenter, out localOffset);\n\n Vector3 originalPosition = compound.position;\n\n Vector3 offset = Vector3.Transform(localOffset, compound.orientation);\n compound.Position = originalPosition + offset;\n\n Vector3 originalLinearVelocity = compound.linearVelocity;\n Vector3 originalAngularVelocity = compound.angularVelocity;\n compound.AngularVelocity = originalAngularVelocity;\n compound.LinearVelocity = originalLinearVelocity + Vector3.Cross(originalAngularVelocity, offset);\n }\n\n /// \n /// Removes a child from a compound body.\n /// \n /// List of distribution information associated with each child shape of the whole compound shape used by the compound being split.\n /// Delegate which determines if a child in the original compound should be moved to the new compound.\n /// Original compound to have a child removed.\n /// Whether or not the predicate returned true for any element in the original compound and split the compound.\n public static bool RemoveChildFromCompound(Entity compound, Func removalPredicate, IList childContributions)\n {\n ShapeDistributionInformation distributionInfo;\n if (RemoveChildFromCompound(compound, removalPredicate, childContributions, out distributionInfo))\n {\n return true;\n }\n else\n return false;\n }\n\n /// \n /// Removes a child from a compound body.\n /// \n /// List of distribution information associated with each child shape of the whole compound shape used by the compound being split.\n /// Delegate which determines if a child in the original compound should be moved to the new compound.\n /// Volume, volume distribution, and center information about the new form of the original compound collidable.\n /// Original compound to have a child removed.\n /// Whether or not the predicate returned true for any element in the original compound and split the compound.\n public static bool RemoveChildFromCompound(Entity compound, Func removalPredicate, IList childContributions,\n out ShapeDistributionInformation distributionInfo)\n {\n float weight;\n float removedWeight;\n Vector3 removedCenter;\n if (RemoveChildFromCompound(compound.CollisionInformation, removalPredicate, childContributions, out distributionInfo, out weight, out removedWeight, out removedCenter))\n {\n //Reconfigure the entities using the data computed in the split.\n //Only bother if there are any children left in the compound!\n if (compound.CollisionInformation.Children.Count > 0)\n {\n float originalMass = compound.mass;\n float newMass = (weight / (weight + removedWeight)) * originalMass;\n Matrix3x3.Multiply(ref distributionInfo.VolumeDistribution, newMass * InertiaHelper.InertiaTensorScale, out distributionInfo.VolumeDistribution);\n compound.Initialize(compound.CollisionInformation, newMass, distributionInfo.VolumeDistribution, distributionInfo.Volume);\n\n RemoveReposition(compound, ref distributionInfo, weight, removedWeight, ref removedCenter);\n }\n\n return true;\n }\n else\n return false;\n }\n\n /// \n /// Removes a child from a compound collidable.\n /// \n /// Compound collidable to remove a child from.\n /// Callback which analyzes a child and determines if it should be removed from the compound.\n /// Distribution contributions from all shapes in the compound shape. This can include shapes which are not represented in the compound.\n /// Distribution information of the new compound.\n /// Total weight of the new compound.\n /// Weight removed from the compound.\n /// Center of the chunk removed from the compound.\n /// Whether or not any removal took place.\n public static bool RemoveChildFromCompound(CompoundCollidable compound, Func removalPredicate, IList childContributions,\n out ShapeDistributionInformation distributionInfo, out float weight, out float removedWeight, out Vector3 removedCenter)\n {\n bool removalOccurred = false;\n removedWeight = 0;\n removedCenter = new Vector3();\n for (int i = compound.children.Count - 1; i >= 0; i--)\n {\n //The shape doesn't change during this process. The entity could, though.\n //All of the other collidable information, like the Tag, CollisionRules, Events, etc. all stay the same.\n var child = compound.children.Elements[i];\n if (removalPredicate(child))\n {\n removalOccurred = true;\n var entry = child.Entry;\n removedWeight += entry.Weight;\n Vector3 toAdd;\n Vector3.Multiply(ref entry.LocalTransform.Position, entry.Weight, out toAdd);\n Vector3.Add(ref removedCenter, ref toAdd, out removedCenter);\n //The child event handler must be unhooked from the compound.\n child.CollisionInformation.events.Parent = null;\n compound.children.FastRemoveAt(i);\n }\n }\n\n if (!removalOccurred)\n {\n //No removal occurred, so we cannot proceed.\n distributionInfo = new ShapeDistributionInformation();\n weight = 0;\n return false;\n }\n if (removedWeight > 0)\n {\n Vector3.Divide(ref removedCenter, removedWeight, out removedCenter);\n }\n\n //Compute the contributions from the original shape to the new form of the original collidable.\n distributionInfo = new ShapeDistributionInformation();\n weight = 0;\n for (int i = compound.children.Count - 1; i >= 0; i--)\n {\n var child = compound.children.Elements[i];\n var entry = child.Entry;\n var contribution = childContributions[child.shapeIndex];\n Vector3.Add(ref contribution.Center, ref entry.LocalTransform.Position, out contribution.Center);\n Vector3.Multiply(ref contribution.Center, child.Entry.Weight, out contribution.Center);\n Vector3.Add(ref contribution.Center, ref distributionInfo.Center, out distributionInfo.Center);\n distributionInfo.Volume += contribution.Volume;\n weight += entry.Weight;\n }\n //Average the center out.\n Vector3.Divide(ref distributionInfo.Center, weight, out distributionInfo.Center);\n\n //Note that the 'entry' is from the Shape, and so the translations are local to the shape's center.\n //That is not technically the center of the new collidable- distributionInfo.Center is.\n //Offset the child collidables by -distributionInfo.Center using their local offset.\n Vector3 offset;\n Vector3.Negate(ref distributionInfo.Center, out offset);\n\n //Compute the unscaled inertia tensor.\n for (int i = compound.children.Count - 1; i >= 0; i--)\n {\n var child = compound.children.Elements[i];\n var entry = child.Entry;\n Vector3 transformedOffset;\n Quaternion conjugate;\n Quaternion.Conjugate(ref entry.LocalTransform.Orientation, out conjugate);\n Vector3.Transform(ref offset, ref conjugate, out transformedOffset);\n child.CollisionInformation.localPosition = transformedOffset;\n var contribution = childContributions[child.shapeIndex];\n CompoundShape.TransformContribution(ref entry.LocalTransform, ref distributionInfo.Center, ref contribution.VolumeDistribution, entry.Weight, out contribution.VolumeDistribution);\n //Vector3.Add(ref entry.LocalTransform.Position, ref offsetA, out entry.LocalTransform.Position);\n Matrix3x3.Add(ref contribution.VolumeDistribution, ref distributionInfo.VolumeDistribution, out distributionInfo.VolumeDistribution);\n }\n\n //Normalize the volume distribution.\n Matrix3x3.Multiply(ref distributionInfo.VolumeDistribution, 1 / weight, out distributionInfo.VolumeDistribution);\n\n //Update the hierarchies of the compounds.\n //TODO: Create a new method that does this quickly without garbage. Requires a new Reconstruct method which takes a pool which stores the appropriate node types.\n compound.hierarchy.Tree.Reconstruct(compound.children);\n\n return true;\n }\n\n /// \n /// Constructs a compound collidable containing only the specified subset of children.\n /// \n /// Shape to base the compound collidable on.\n /// Indices of child shapes from the CompoundShape to include in the compound collidable.\n /// Compound collidable containing only the specified subset of children.\n public static CompoundCollidable CreatePartialCompoundCollidable(CompoundShape shape, IList childIndices)\n {\n if (childIndices.Count == 0)\n throw new ArgumentException(\"Cannot create a compound from zero shapes.\");\n \n CompoundCollidable compound = new CompoundCollidable();\n Vector3 center = new Vector3();\n float totalWeight = 0;\n for (int i = 0; i < childIndices.Count; i++)\n {\n //Create and add the child object itself.\n var entry = shape.shapes[childIndices[i]];\n compound.children.Add(new CompoundChild(shape, entry.Shape.GetCollidableInstance(), childIndices[i]));\n //Grab its entry to compute the center of mass of this subset.\n Vector3 toAdd;\n Vector3.Multiply(ref entry.LocalTransform.Position, entry.Weight, out toAdd);\n Vector3.Add(ref center, ref toAdd, out center);\n totalWeight += entry.Weight;\n }\n if (totalWeight <= 0)\n {\n throw new ArgumentException(\"Compound has zero total weight; invalid configuration.\");\n }\n Vector3.Divide(ref center, totalWeight, out center);\n //Our subset of the compound is not necessarily aligned with the shape's origin.\n //By default, an object will rotate around the center of the collision shape.\n //We can't modify the shape data itself since it could be shared, which leaves\n //modifying the local position of the collidable.\n //We have the subset position in shape space, so pull the collidable back into alignment\n //with the origin.\n //This approach matches the rest of the CompoundHelper's treatment of subsets.\n compound.LocalPosition = -center;\n\n //Recompute the hierarchy for the compound.\n compound.hierarchy.Tree.Reconstruct(compound.children);\n compound.Shape = shape;\n return compound;\n }\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHierarchy.cs",
"content": "using System;\nusing BEPUphysics.DataStructures;\n\nnamespace BEPUphysics.BroadPhaseEntries.MobileCollidables\n{\n ///\n /// Hierarchy of children used to accelerate queries and tests for compound collidables.\n ///\n public class CompoundHierarchy\n {\n private BoundingBoxTree tree;\n ///\n /// Gets the bounding box tree of the hierarchy.\n ///\n public BoundingBoxTree Tree\n {\n get\n {\n return tree;\n }\n }\n\n private CompoundCollidable owner;\n ///\n /// Gets the CompoundCollidable that owns this hierarchy.\n ///\n public CompoundCollidable Owner\n {\n get\n {\n return owner;\n }\n }\n\n ///\n /// Constructs a new compound hierarchy.\n ///\n ///Owner of the hierarchy.\n public CompoundHierarchy(CompoundCollidable owner)\n {\n this.owner = owner;\n var children = new CompoundChild[owner.children.Count];\n Array.Copy(owner.children.Elements, children, owner.children.Count);\n //In order to initialize a good tree, the local space bounding boxes should first be computed.\n //Otherwise, the tree would try to create a hierarchy based on a bunch of zeroed out bounding boxes!\n for (int i = 0; i < children.Length; i++)\n {\n children[i].CollisionInformation.worldTransform = owner.Shape.shapes.Elements[i].LocalTransform;\n children[i].CollisionInformation.UpdateBoundingBoxInternal(0);\n }\n tree = new BoundingBoxTree(children);\n }\n\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/ConvexCollidable.cs",
"content": "using BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\nusing System;\nusing BEPUphysics.PositionUpdating;\nusing BEPUphysics.Settings;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\n\nnamespace BEPUphysics.BroadPhaseEntries.MobileCollidables\n{\n ///\n /// Collidable with a convex shape.\n ///\n public abstract class ConvexCollidable : EntityCollidable\n {\n\n protected ConvexCollidable(ConvexShape shape)\n : base(shape)\n {\n Events = new ContactEventManager();\n }\n\n ///\n /// Gets the shape of the collidable.\n ///\n public new ConvexShape Shape\n {\n get\n {\n return (ConvexShape)shape;\n }\n }\n\n\n public override bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit)\n {\n return MPRToolbox.Sweep(castShape, Shape, ref sweep, ref Toolbox.ZeroVector, ref startingTransform, ref worldTransform, out hit);\n }\n\n }\n\n ///\n /// Collidable with a convex shape of a particular type.\n ///\n ///ConvexShape type.\n public class ConvexCollidable : ConvexCollidable where T : ConvexShape\n {\n ///\n /// Gets the shape of the collidable.\n ///\n public new T Shape\n {\n get\n {\n return (T)shape;\n }\n }\n\n ///\n /// Constructs a new convex collidable.\n ///\n ///Shape to use in the collidable.\n public ConvexCollidable(T shape)\n : base(shape)\n {\n\n }\n\n\n /// \n /// Tests a ray against the entry.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit location of the ray on the entry, if any.\n /// Whether or not the ray hit the entry.\n public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)\n {\n return Shape.RayTest(ref ray, ref worldTransform, maximumLength, out rayHit);\n }\n\n\n\n protected internal override void UpdateBoundingBoxInternal(float dt)\n {\n Shape.GetBoundingBox(ref worldTransform, out boundingBox);\n\n ExpandBoundingBox(ref boundingBox, dt);\n }\n\n\n\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/EntityCollidable.cs",
"content": "using BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.Settings;\nusing System;\nusing BEPUphysics.PositionUpdating;\n\nnamespace BEPUphysics.BroadPhaseEntries.MobileCollidables\n{\n ///\n /// Mobile collidable acting as a collision proxy for an entity.\n ///\n public abstract class EntityCollidable : MobileCollidable\n {\n protected EntityCollidable()\n {\n //This constructor is used when the subclass is going to set the shape after doing some extra initialization.\n }\n\n protected EntityCollidable(EntityShape shape)\n {\n base.Shape = shape;\n }\n\n\n\n\n\n /// \n /// Gets the shape of the collidable.\n /// \n public new EntityShape Shape\n {\n get\n {\n return (EntityShape)shape;\n }\n protected set\n {\n base.Shape = value;\n }\n }\n\n protected internal Entity entity;\n ///\n /// Gets the entity owning the collidable.\n ///\n public Entity Entity\n {\n get\n {\n return entity;\n }\n protected internal set\n {\n entity = value;\n OnEntityChanged();\n }\n }\n\n\n protected virtual void OnEntityChanged()\n {\n }\n\n protected internal RigidTransform worldTransform;\n ///\n /// Gets or sets the world transform of the collidable.\n /// The EntityCollidable's LocalPosition is ignored for this process; the shape will end up\n /// centered exactly on the world transform.\n /// Setting this property also updates the bounding box.\n ///\n public RigidTransform WorldTransform\n {\n get\n {\n return worldTransform;\n }\n set\n {\n //Remove the local position. The UpdateBoundingBoxForTransform will reintroduce it; we want the final result to put the shape (i.e. the WorldTransform) right where defined.\n Quaternion conjugate;\n Quaternion.Conjugate(ref value.Orientation, out conjugate);\n Vector3 worldOffset;\n Vector3.Transform(ref localPosition, ref conjugate, out worldOffset);\n Vector3.Subtract(ref value.Position, ref worldOffset, out value.Position);\n UpdateBoundingBoxForTransform(ref value);\n }\n }\n\n protected internal override bool IsActive\n {\n get\n {\n return entity != null ? entity.activityInformation.IsActive : false;\n }\n }\n\n protected internal Vector3 localPosition;\n ///\n /// Gets or sets the local position of the collidable.\n /// The local position can be used to offset the collision geometry\n /// from an entity's center of mass.\n ///\n public Vector3 LocalPosition\n {\n get\n {\n return localPosition;\n }\n set\n {\n localPosition = value;\n\n localPosition.Validate();\n }\n }\n\n ///\n /// Updates the bounding box of the mobile collidable according to the associated entity's current state.\n /// Do not use this if the EntityCollidable does not have an associated entity; consider using\n /// UpdateBoundingBoxForTransform instead.\n ///\n public override void UpdateBoundingBox()\n {\n UpdateBoundingBox(0);\n }\n\n ///\n /// Updates the bounding box of the mobile collidable according to the associated entity's current state.\n /// Do not use this if the EntityCollidable does not have an associated entity; consider using\n /// UpdateBoundingBoxForTransform instead.\n ///\n ///Timestep with which to update the bounding box.\n public override void UpdateBoundingBox(float dt)\n {\n //The world transform update isn't strictly required for uninterrupted simulation.\n //The entity update method manages the world transforms.\n //However, the redundancy allows a user to change the position in between frames.\n //If the order of the space update changes to position-update-first, this is completely unnecessary.\n UpdateWorldTransform(ref entity.position, ref entity.orientation);\n UpdateBoundingBoxInternal(dt);\n }\n\n ///\n /// Updates the world transform of the shape using the given position and orientation.\n /// The world transform of the shape is offset from the given position and orientation by the collidable's LocalPosition.\n ///\n ///Position to use for the calculation.\n ///Orientation to use for the calculation.\n public virtual void UpdateWorldTransform(ref Vector3 position, ref Quaternion orientation)\n {\n Vector3.Transform(ref localPosition, ref orientation, out worldTransform.Position);\n Vector3.Add(ref worldTransform.Position, ref position, out worldTransform.Position);\n worldTransform.Orientation = orientation;\n\n worldTransform.Validate();\n }\n\n /// \n /// Updates the collidable's world transform and bounding box. The transform provided\n /// will be offset by the collidable's LocalPosition to get the shape transform.\n /// This is a convenience method for external modification of the collidable's data.\n /// \n /// Transform to use for the collidable.\n /// Duration of the simulation time step. Used to expand the\n /// bounding box using the owning entity's velocity. If the collidable\n /// does not have an owning entity, this must be zero.\n public void UpdateBoundingBoxForTransform(ref RigidTransform transform, float dt)\n {\n UpdateWorldTransform(ref transform.Position, ref transform.Orientation);\n UpdateBoundingBoxInternal(dt);\n }\n\n\n /// \n /// Updates the collidable's world transform and bounding box.\n /// This is a convenience method for external modification of the collidable's data.\n /// \n /// Transform to use for the collidable.\n public void UpdateBoundingBoxForTransform(ref RigidTransform transform)\n {\n UpdateBoundingBoxForTransform(ref transform, 0);\n }\n\n\n protected internal abstract void UpdateBoundingBoxInternal(float dt);\n\n //Helper method for mobile collidables.\n internal void ExpandBoundingBox(ref BoundingBox boundingBox, float dt)\n {\n //Expand bounding box with velocity.\n if (dt > 0)\n {\n bool useExtraExpansion = MotionSettings.UseExtraExpansionForContinuousBoundingBoxes && entity.PositionUpdateMode == PositionUpdateMode.Continuous;\n float velocityScaling = useExtraExpansion ? 2 : 1;\n if (entity.linearVelocity.X > 0)\n boundingBox.Max.X += entity.linearVelocity.X * dt * velocityScaling;\n else\n boundingBox.Min.X += entity.linearVelocity.X * dt * velocityScaling;\n\n if (entity.linearVelocity.Y > 0)\n boundingBox.Max.Y += entity.linearVelocity.Y * dt * velocityScaling;\n else\n boundingBox.Min.Y += entity.linearVelocity.Y * dt * velocityScaling;\n\n if (entity.linearVelocity.Z > 0)\n boundingBox.Max.Z += entity.linearVelocity.Z * dt * velocityScaling;\n else\n boundingBox.Min.Z += entity.linearVelocity.Z * dt * velocityScaling;\n\n\n\n\n if (useExtraExpansion)\n {\n float expansion = 0;\n //It's possible that an object could have a small bounding box since its own\n //velocity is low, but then a collision with a high velocity object sends\n //it way out of its bounding box. By taking into account high velocity objects\n //in danger of hitting us and expanding our own bounding box by their speed,\n //we stand a much better chance of not missing secondary collisions.\n foreach (var e in OverlappedEntities)\n {\n\n float velocity = e.linearVelocity.LengthSquared();\n if (velocity > expansion)\n expansion = velocity;\n }\n expansion = (float)Math.Sqrt(expansion) * dt;\n\n\n boundingBox.Min.X -= expansion;\n boundingBox.Min.Y -= expansion;\n boundingBox.Min.Z -= expansion;\n\n boundingBox.Max.X += expansion;\n boundingBox.Max.Y += expansion;\n boundingBox.Max.Z += expansion;\n\n }\n\n //Could use this to incorporate angular motion. Since the bounding box is an approximation to begin with,\n //this isn't too important. If an updating system is used where the bounding box MUST fully contain the frame's motion\n //then the commented area should be used.\n //Math.Min(entity.angularVelocity.Length() * dt, Shape.maximumRadius) * velocityScaling;\n //TODO: consider using minimum radius \n\n }\n\n boundingBox.Validate();\n }\n\n\n\n protected override void CollisionRulesUpdated()\n {\n //Try to activate the entity since our collision rules just changed; broadphase might need to update some stuff.\n //Beware, though; if this collidable is still being constructed, then the entity won't be available.\n if (entity != null)\n entity.activityInformation.Activate();\n }\n\n\n protected internal ContactEventManager events;\n ///\n /// Gets or sets the event manager of the collidable.\n ///\n public ContactEventManager Events\n {\n get\n {\n return events;\n }\n set\n {\n if (value.Owner != null && //Can't use a manager which is owned by a different entity.\n value != events) //Stay quiet if for some reason the same event manager is being set.\n throw new ArgumentException(\"Event manager is already owned by an entity; event managers cannot be shared.\");\n //Must pass on the link to the parent event manager to the new event manager in case we are the child of a compound.\n CompoundEventManager oldParent = null;\n if (events != null)\n {\n events.Owner = null;\n oldParent = events.Parent;\n events.Parent = null;\n }\n events = value;\n if (events != null)\n {\n events.Owner = this;\n events.Parent = oldParent;\n }\n }\n }\n protected internal override IContactEventTriggerer EventTriggerer\n {\n get { return events; }\n }\n\n\n ///\n /// Gets an enumerable collection of all entities overlapping this collidable.\n ///\n public EntityCollidableCollection OverlappedEntities\n {\n get\n {\n return new EntityCollidableCollection(this);\n }\n }\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/MobileCollidable.cs",
"content": "namespace BEPUphysics.BroadPhaseEntries.MobileCollidables\n{\n //This is implemented by anything which wants the engine to update its bounding box every frame (so long as it is 'active').\n ///\n /// Superclass of all collidables which are capable of movement, and thus need bounding box updates every frame.\n ///\n public abstract class MobileCollidable : Collidable\n {\n //TODO: Imagine needing to calculate the bounding box for a data structure that is not axis-aligned. Being able to return BB without 'setting' would be helpful.\n //Possibly require second method. The parameterless one uses 'self data' to do the calculation, as a sort of convenience. The parameterful would return without setting.\n ///\n /// Updates the bounding box of the mobile collidable.\n ///\n ///Timestep with which to update the bounding box.\n public abstract void UpdateBoundingBox(float dt);\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/MobileMeshCollidable.cs",
"content": "using BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes;\nusing BEPUutilities;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing System;\n\nnamespace BEPUphysics.BroadPhaseEntries.MobileCollidables\n{\n ///\n /// Collidable used by compound shapes.\n ///\n public class MobileMeshCollidable : EntityCollidable\n {\n ///\n /// Gets the shape of the collidable.\n ///\n public new MobileMeshShape Shape\n {\n get\n {\n return (MobileMeshShape)shape;\n }\n }\n\n /// \n /// Constructs a new mobile mesh collidable.\n /// \n /// Shape to use in the collidable.\n public MobileMeshCollidable(MobileMeshShape shape)\n : base(shape)\n {\n Events = new ContactEventManager();\n }\n\n\n\n internal bool improveBoundaryBehavior = true;\n /// \n /// Gets or sets whether or not the collision system should attempt to improve contact behavior at the boundaries between triangles.\n /// This has a slight performance cost, but prevents objects sliding across a triangle boundary from 'bumping,' and otherwise improves\n /// the robustness of contacts at edges and vertices.\n /// \n public bool ImproveBoundaryBehavior\n {\n get\n {\n return improveBoundaryBehavior;\n }\n set\n {\n improveBoundaryBehavior = value;\n }\n }\n\n protected internal override void UpdateBoundingBoxInternal(float dt)\n {\n Shape.GetBoundingBox(ref worldTransform, out boundingBox);\n\n //This DOES NOT EXPAND the local hierarchy.\n //The bounding boxes of queries against the local hierarchy\n //should be expanded using the relative velocity.\n ExpandBoundingBox(ref boundingBox, dt);\n }\n\n\n\n\n /// \n /// Tests a ray against the entry.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit location of the ray on the entry, if any.\n /// Whether or not the ray hit the entry.\n public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)\n {\n //Put the ray into local space.\n Ray localRay;\n Matrix3x3 orientation;\n Matrix3x3.CreateFromQuaternion(ref worldTransform.Orientation, out orientation);\n Matrix3x3.TransformTranspose(ref ray.Direction, ref orientation, out localRay.Direction);\n Vector3.Subtract(ref ray.Position, ref worldTransform.Position, out localRay.Position);\n Matrix3x3.TransformTranspose(ref localRay.Position, ref orientation, out localRay.Position);\n\n\n if (Shape.solidity == MobileMeshSolidity.Solid)\n {\n //Find all hits. Use the count to determine the ray started inside or outside.\n //If it starts inside and we're in 'solid' mode, then return the ray start.\n //The raycast must be of infinite length at first. This allows it to determine\n //if it is inside or outside.\n if (Shape.IsLocalRayOriginInMesh(ref localRay, out rayHit))\n {\n //It was inside!\n rayHit = new RayHit() { Location = ray.Position, Normal = Vector3.Zero, T = 0 };\n return true;\n\n }\n else\n {\n if (rayHit.T < maximumLength)\n {\n //Transform the hit into world space.\n Vector3.Multiply(ref ray.Direction, rayHit.T, out rayHit.Location);\n Vector3.Add(ref rayHit.Location, ref ray.Position, out rayHit.Location);\n Matrix3x3.Transform(ref rayHit.Normal, ref orientation, out rayHit.Normal);\n }\n else\n {\n //The hit was too far away, or there was no hit (in which case T would be float.MaxValue).\n return false;\n }\n return true;\n }\n }\n else\n {\n //Just do a normal raycast since the object isn't solid.\n TriangleSidedness sidedness;\n switch (Shape.solidity)\n {\n case MobileMeshSolidity.Clockwise:\n sidedness = TriangleSidedness.Clockwise;\n break;\n case MobileMeshSolidity.Counterclockwise:\n sidedness = TriangleSidedness.Counterclockwise;\n break;\n default:\n sidedness = TriangleSidedness.DoubleSided;\n break;\n }\n if (Shape.TriangleMesh.RayCast(localRay, maximumLength, sidedness, out rayHit))\n {\n //Transform the hit into world space.\n Vector3.Multiply(ref ray.Direction, rayHit.T, out rayHit.Location);\n Vector3.Add(ref rayHit.Location, ref ray.Position, out rayHit.Location);\n Matrix3x3.Transform(ref rayHit.Normal, ref orientation, out rayHit.Normal);\n return true;\n }\n }\n rayHit = new RayHit();\n return false;\n }\n\n ///\n /// Tests a ray against the surface of the mesh. This does not take into account solidity.\n ///\n ///Ray to test.\n ///Maximum length of the ray to test; in units of the ray's direction's length.\n ///Sidedness to use during the ray cast. This does not have to be the same as the mesh's sidedness.\n ///The hit location of the ray on the mesh, if any.\n ///Whether or not the ray hit the mesh.\n public bool RayCast(Ray ray, float maximumLength, TriangleSidedness sidedness, out RayHit rayHit)\n {\n //Put the ray into local space.\n Ray localRay;\n Matrix3x3 orientation;\n Matrix3x3.CreateFromQuaternion(ref worldTransform.Orientation, out orientation);\n Matrix3x3.TransformTranspose(ref ray.Direction, ref orientation, out localRay.Direction);\n Vector3.Subtract(ref ray.Position, ref worldTransform.Position, out localRay.Position);\n Matrix3x3.TransformTranspose(ref localRay.Position, ref orientation, out localRay.Position);\n\n if (Shape.TriangleMesh.RayCast(localRay, maximumLength, sidedness, out rayHit))\n {\n //Transform the hit into world space.\n Vector3.Multiply(ref ray.Direction, rayHit.T, out rayHit.Location);\n Vector3.Add(ref rayHit.Location, ref ray.Position, out rayHit.Location);\n Matrix3x3.Transform(ref rayHit.Normal, ref orientation, out rayHit.Normal);\n return true;\n }\n rayHit = new RayHit();\n return false;\n }\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Hit data, if any.\n /// Whether or not the cast hit anything.\n public override bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit)\n {\n if (Shape.solidity == MobileMeshSolidity.Solid)\n {\n //If the convex cast is inside the mesh and the mesh is solid, it should return t = 0.\n var ray = new Ray() { Position = startingTransform.Position, Direction = Toolbox.UpVector };\n if (Shape.IsLocalRayOriginInMesh(ref ray, out hit))\n {\n\n hit = new RayHit() { Location = startingTransform.Position, Normal = new Vector3(), T = 0 };\n return true;\n }\n }\n hit = new RayHit();\n BoundingBox boundingBox;\n var transform = new AffineTransform {Translation = worldTransform.Position};\n Matrix3x3.CreateFromQuaternion(ref worldTransform.Orientation, out transform.LinearTransform);\n castShape.GetSweptLocalBoundingBox(ref startingTransform, ref transform, ref sweep, out boundingBox);\n var tri = PhysicsResources.GetTriangle();\n var hitElements = CommonResources.GetIntList();\n if (this.Shape.TriangleMesh.Tree.GetOverlaps(boundingBox, hitElements))\n {\n hit.T = float.MaxValue;\n for (int i = 0; i < hitElements.Count; i++)\n {\n Shape.TriangleMesh.Data.GetTriangle(hitElements[i], out tri.vA, out tri.vB, out tri.vC);\n AffineTransform.Transform(ref tri.vA, ref transform, out tri.vA);\n AffineTransform.Transform(ref tri.vB, ref transform, out tri.vB);\n AffineTransform.Transform(ref tri.vC, ref transform, out tri.vC);\n Vector3 center;\n Vector3.Add(ref tri.vA, ref tri.vB, out center);\n Vector3.Add(ref center, ref tri.vC, out center);\n Vector3.Multiply(ref center, 1f / 3f, out center);\n Vector3.Subtract(ref tri.vA, ref center, out tri.vA);\n Vector3.Subtract(ref tri.vB, ref center, out tri.vB);\n Vector3.Subtract(ref tri.vC, ref center, out tri.vC);\n tri.maximumRadius = tri.vA.LengthSquared();\n float radius = tri.vB.LengthSquared();\n if (tri.maximumRadius < radius)\n tri.maximumRadius = radius;\n radius = tri.vC.LengthSquared();\n if (tri.maximumRadius < radius)\n tri.maximumRadius = radius;\n tri.maximumRadius = (float)Math.Sqrt(tri.maximumRadius);\n tri.collisionMargin = 0;\n var triangleTransform = new RigidTransform {Orientation = Quaternion.Identity, Position = center};\n RayHit tempHit;\n if (MPRToolbox.Sweep(castShape, tri, ref sweep, ref Toolbox.ZeroVector, ref startingTransform, ref triangleTransform, out tempHit) && tempHit.T < hit.T)\n {\n hit = tempHit;\n }\n }\n tri.maximumRadius = 0;\n PhysicsResources.GiveBack(tri);\n CommonResources.GiveBack(hitElements);\n return hit.T != float.MaxValue;\n }\n PhysicsResources.GiveBack(tri);\n CommonResources.GiveBack(hitElements);\n return false;\n }\n }\n\n\n\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/TriangleCollidable.cs",
"content": "using BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.BroadPhaseEntries.MobileCollidables\n{\n ///\n /// Special case collidable for reuseable triangles.\n ///\n public class TriangleCollidable : ConvexCollidable\n {\n ///\n /// Constructs a new shapeless collidable.\n ///\n public TriangleCollidable()\n : base(new TriangleShape())\n {\n }\n\n ///\n /// Constructs the triangle collidable using the given shape.\n ///\n ///TriangleShape to use in the collidable.\n public TriangleCollidable(TriangleShape shape)\n : base(shape)\n {\n }\n\n ///\n /// Initializes the collidable using the new triangle shape, but does NOT\n /// fire any shape-changed events.\n ///\n ///First vertex in the triangle.\n ///Second vertex in the triangle. \n ///Third vertex in the triangle. \n public void Initialize(ref Vector3 a, ref Vector3 b, ref Vector3 c)\n {\n var shape = Shape;\n shape.collisionMargin = 0;\n shape.sidedness = TriangleSidedness.DoubleSided;\n shape.vA = a;\n shape.vB = b;\n shape.vC = c;\n }\n\n ///\n /// Cleans up the collidable by removing all events.\n ///\n public void CleanUp()\n {\n events.RemoveAllEvents();\n }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/StaticCollidable.cs",
"content": "using System;\nusing BEPUphysics.CollisionShapes;\nusing BEPUphysics.Materials;\nusing BEPUphysics.CollisionRuleManagement;\nusing BEPUphysics.OtherSpaceStages;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///\n /// Superclass of static collidable objects which can be added directly to a space. Static objects cannot move.\n ///\n public abstract class StaticCollidable : Collidable, ISpaceObject, IMaterialOwner, IDeferredEventCreatorOwner\n {\n\n\n ///\n /// Performs common initialization.\n ///\n protected StaticCollidable()\n {\n collisionRules.group = CollisionRules.DefaultKinematicCollisionGroup;\n //Note that the Events manager is not created here. That is left for subclasses to implement so that the type is more specific.\n //Entities can get away with having EntityCollidable specificity since you generally care more about the entity than the collidable,\n //but with static objects, the collidable is the only important object. It would be annoying to cast to the type you know it is every time\n //just to get access to some type-specific properties.\n\n material = new Material();\n materialChangedDelegate = OnMaterialChanged;\n material.MaterialChanged += materialChangedDelegate;\n }\n\n protected override void OnShapeChanged(CollisionShape collisionShape)\n {\n if (!IgnoreShapeChanges)\n UpdateBoundingBox();\n }\n\n internal Material material;\n //NOT thread safe due to material change pair update.\n ///\n /// Gets or sets the material used by the collidable.\n ///\n public Material Material\n {\n get\n {\n return material;\n }\n set\n {\n if (material != null)\n material.MaterialChanged -= materialChangedDelegate;\n material = value;\n if (material != null)\n material.MaterialChanged += materialChangedDelegate;\n OnMaterialChanged(material);\n }\n }\n\n Action materialChangedDelegate;\n protected virtual void OnMaterialChanged(Material newMaterial)\n {\n for (int i = 0; i < pairs.Count; i++)\n {\n pairs[i].UpdateMaterialProperties();\n }\n }\n\n protected internal override bool IsActive\n {\n get { return false; }\n }\n\n \n\n ISpace space;\n ISpace ISpaceObject.Space\n {\n get\n {\n return space;\n }\n set\n {\n space = value;\n }\n }\n ///\n /// Gets the space that owns the mesh.\n ///\n public ISpace Space\n {\n get\n {\n return space;\n }\n }\n\n void ISpaceObject.OnAdditionToSpace(ISpace newSpace)\n {\n }\n\n void ISpaceObject.OnRemovalFromSpace(ISpace oldSpace)\n {\n }\n\n\n\n IDeferredEventCreator IDeferredEventCreatorOwner.EventCreator\n {\n get\n {\n return EventCreator;\n }\n }\n\n /// \n /// Gets the event creator associated with this collidable.\n /// \n protected abstract IDeferredEventCreator EventCreator\n {\n get;\n }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/StaticGroup.cs",
"content": "using System;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUphysics.OtherSpaceStages;\nusing System.Collections.Generic;\nusing RigidTransform = BEPUutilities.RigidTransform;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///\n /// Collection of unmoving collidable objects.\n ///\n ///\n /// Batching multiple static objects together into a StaticGroup as opposed to adding them separately to the Space avoids BroadPhase pollution, improving performance.\n /// \n public class StaticGroup : StaticCollidable\n {\n\n\n ///\n /// Constructs a new static mesh.\n ///\n ///List of collidables in the static group.\n public StaticGroup(IList collidables)\n {\n shape = new StaticGroupShape(collidables, this);\n Events = new ContactEventManager();\n\n }\n\n ///\n /// Gets the shape used by the mesh. Unlike most collidable-shape pairs, StaticGroupShapes cannot be shared between multiple StaticGroups.\n ///\n public new StaticGroupShape Shape\n {\n get\n {\n return (StaticGroupShape)shape;\n }\n }\n\n\n protected internal ContactEventManager events;\n\n ///\n /// Gets the event manager used by the mesh.\n ///\n public ContactEventManager Events\n {\n get\n {\n return events;\n }\n set\n {\n if (value.Owner != null && //Can't use a manager which is owned by a different entity.\n value != events) //Stay quiet if for some reason the same event manager is being set.\n throw new ArgumentException(\"Event manager is already owned by a mesh; event managers cannot be shared.\");\n if (events != null)\n events.Owner = null;\n events = value;\n if (events != null)\n events.Owner = this;\n }\n }\n protected internal override IContactEventTriggerer EventTriggerer\n {\n get { return events; }\n }\n protected override IDeferredEventCreator EventCreator\n {\n get { return events; }\n }\n\n\n /// \n /// Updates the bounding box to the current state of the entry.\n /// \n public override void UpdateBoundingBox()\n {\n boundingBox = Shape.CollidableTree.BoundingBox;\n }\n\n /// \n /// Tests a ray against the entry.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit location of the ray on the entry, if any.\n /// Whether or not the ray hit the entry.\n public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)\n {\n RayCastResult result;\n bool toReturn = Shape.RayCast(ray, maximumLength, out result);\n rayHit = result.HitData;\n return toReturn;\n }\n\n /// \n /// Tests a ray against the entry.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present\n /// in the entry, this filter will be passed into inner ray casts.\n /// Hit location of the ray on the entry, if any.\n /// Whether or not the ray hit the entry.\n public override bool RayCast(Ray ray, float maximumLength, Func filter, out RayHit rayHit)\n {\n RayCastResult result;\n bool toReturn = Shape.RayCast(ray, maximumLength, filter, out result);\n rayHit = result.HitData;\n return toReturn;\n }\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Hit data, if any.\n /// Whether or not the cast hit anything.\n public override bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit)\n {\n RayCastResult result;\n bool toReturn = Shape.ConvexCast(castShape, ref startingTransform, ref sweep, out result);\n hit = result.HitData;\n return toReturn;\n }\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present\n /// in the entry, this filter will be passed into inner ray casts.\n /// Hit data, if any.\n /// Whether or not the cast hit anything.\n public override bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, Func filter, out RayHit hit)\n {\n RayCastResult result;\n bool toReturn = Shape.ConvexCast(castShape, ref startingTransform, ref sweep, filter, out result);\n hit = result.HitData;\n return toReturn;\n }\n\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/StaticMesh.cs",
"content": "using System;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes;\nusing BEPUphysics.DataStructures;\nusing BEPUutilities;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUphysics.OtherSpaceStages;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///\n /// Unmoving, collidable triangle mesh.\n ///\n ///\n /// The acceleration structure for the mesh is created individually for each\n /// StaticMesh; if you want to create many meshes of the same model, consider using the\n /// InstancedMesh.\n /// \n public class StaticMesh : StaticCollidable\n {\n\n TriangleMesh mesh;\n ///\n /// Gets the TriangleMesh acceleration structure used by the StaticMesh.\n ///\n public TriangleMesh Mesh\n {\n get\n {\n return mesh;\n }\n }\n\n ///\n /// Gets or sets the world transform of the mesh.\n ///\n public AffineTransform WorldTransform\n {\n get\n {\n return ((TransformableMeshData)mesh.Data).worldTransform;\n }\n set\n {\n ((TransformableMeshData)mesh.Data).WorldTransform = value;\n mesh.Tree.Refit();\n UpdateBoundingBox();\n }\n }\n\n ///\n /// Constructs a new static mesh.\n ///\n ///Vertex positions of the mesh.\n ///Index list of the mesh.\n public StaticMesh(Vector3[] vertices, uint[] indices, int indexCount)\n {\n base.Shape = new StaticMeshShape(vertices, indices, indexCount);\n Events = new ContactEventManager();\n\n }\n\n ///\n /// Constructs a new static mesh.\n ///\n ///Vertex positions of the mesh.\n ///Index list of the mesh.\n /// Transform to use to create the mesh initially.\n public StaticMesh(Vector3[] vertices, uint[] indices, int indexCount, AffineTransform worldTransform)\n {\n base.Shape = new StaticMeshShape(vertices, indices, indexCount, worldTransform);\n Events = new ContactEventManager();\n }\n\n ///\n /// Gets the shape used by the mesh.\n ///\n public new StaticMeshShape Shape\n {\n get\n {\n return (StaticMeshShape)shape;\n }\n }\n\n internal TriangleSidedness sidedness = TriangleSidedness.DoubleSided;\n ///\n /// Gets or sets the sidedness of the mesh. This can be used to ignore collisions and rays coming from a direction relative to the winding of the triangle.\n ///\n public TriangleSidedness Sidedness\n {\n get\n {\n return sidedness;\n }\n set\n {\n sidedness = value;\n }\n }\n\n internal bool improveBoundaryBehavior = true;\n /// \n /// Gets or sets whether or not the collision system should attempt to improve contact behavior at the boundaries between triangles.\n /// This has a slight performance cost, but prevents objects sliding across a triangle boundary from 'bumping,' and otherwise improves\n /// the robustness of contacts at edges and vertices.\n /// \n public bool ImproveBoundaryBehavior\n {\n get\n {\n return improveBoundaryBehavior;\n }\n set\n {\n improveBoundaryBehavior = value;\n }\n }\n\n\n protected internal ContactEventManager events;\n\n ///\n /// Gets the event manager used by the mesh.\n ///\n public ContactEventManager Events\n {\n get\n {\n return events;\n }\n set\n {\n if (value.Owner != null && //Can't use a manager which is owned by a different entity.\n value != events) //Stay quiet if for some reason the same event manager is being set.\n throw new ArgumentException(\"Event manager is already owned by a mesh; event managers cannot be shared.\");\n if (events != null)\n events.Owner = null;\n events = value;\n if (events != null)\n events.Owner = this;\n }\n }\n protected internal override IContactEventTriggerer EventTriggerer\n {\n get { return events; }\n }\n protected override IDeferredEventCreator EventCreator\n {\n get { return events; }\n }\n\n protected override void OnShapeChanged(CollisionShape collisionShape)\n {\n if (!IgnoreShapeChanges)\n {\n mesh = new TriangleMesh(Shape.TriangleMeshData);\n UpdateBoundingBox();\n }\n }\n\n /// \n /// Updates the bounding box to the current state of the entry.\n /// \n public override void UpdateBoundingBox()\n {\n boundingBox = mesh.Tree.BoundingBox;\n }\n\n /// \n /// Tests a ray against the entry.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit location of the ray on the entry, if any.\n /// Whether or not the ray hit the entry.\n public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)\n {\n return mesh.RayCast(ray, maximumLength, sidedness, out rayHit);\n }\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Hit data, if any.\n /// Whether or not the cast hit anything.\n public override bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit)\n {\n hit = new RayHit();\n BoundingBox boundingBox;\n castShape.GetSweptBoundingBox(ref startingTransform, ref sweep, out boundingBox);\n var tri = PhysicsResources.GetTriangle();\n var hitElements = CommonResources.GetIntList();\n if (Mesh.Tree.GetOverlaps(boundingBox, hitElements))\n {\n hit.T = float.MaxValue;\n for (int i = 0; i < hitElements.Count; i++)\n {\n mesh.Data.GetTriangle(hitElements[i], out tri.vA, out tri.vB, out tri.vC);\n Vector3 center;\n Vector3.Add(ref tri.vA, ref tri.vB, out center);\n Vector3.Add(ref center, ref tri.vC, out center);\n Vector3.Multiply(ref center, 1f / 3f, out center);\n Vector3.Subtract(ref tri.vA, ref center, out tri.vA);\n Vector3.Subtract(ref tri.vB, ref center, out tri.vB);\n Vector3.Subtract(ref tri.vC, ref center, out tri.vC);\n tri.maximumRadius = tri.vA.LengthSquared();\n float radius = tri.vB.LengthSquared();\n if (tri.maximumRadius < radius)\n tri.maximumRadius = radius;\n radius = tri.vC.LengthSquared(); \n if (tri.maximumRadius < radius)\n tri.maximumRadius = radius;\n tri.maximumRadius = (float)Math.Sqrt(tri.maximumRadius);\n tri.collisionMargin = 0;\n var triangleTransform = new RigidTransform {Orientation = Quaternion.Identity, Position = center};\n RayHit tempHit;\n if (MPRToolbox.Sweep(castShape, tri, ref sweep, ref Toolbox.ZeroVector, ref startingTransform, ref triangleTransform, out tempHit) && tempHit.T < hit.T)\n {\n hit = tempHit;\n }\n }\n tri.maximumRadius = 0;\n PhysicsResources.GiveBack(tri);\n CommonResources.GiveBack(hitElements);\n return hit.T != float.MaxValue;\n }\n PhysicsResources.GiveBack(tri);\n CommonResources.GiveBack(hitElements);\n return false;\n }\n\n ///\n /// Tests a ray against the mesh.\n ///\n ///Ray to test.\n ///Maximum length to test in units of the ray direction's length.\n ///Sidedness to use when raycasting. Doesn't have to be the same as the mesh's own sidedness.\n ///Data about the ray's intersection with the mesh, if any.\n ///Whether or not the ray hit the mesh.\n public bool RayCast(Ray ray, float maximumLength, TriangleSidedness sidedness, out RayHit rayHit)\n {\n return mesh.RayCast(ray, maximumLength, sidedness, out rayHit);\n }\n\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Terrain.cs",
"content": "using System;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUutilities;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.CollisionShapes;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUphysics.OtherSpaceStages;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///\n /// Heightfield-based unmovable collidable object.\n ///\n public class Terrain : StaticCollidable\n {\n ///\n /// Gets the shape of this collidable.\n ///\n public new TerrainShape Shape\n {\n get\n {\n return (TerrainShape)shape;\n }\n set\n {\n base.Shape = value;\n }\n }\n\n\n internal AffineTransform worldTransform;\n ///\n /// Gets or sets the affine transform of the terrain.\n ///\n public AffineTransform WorldTransform\n {\n get\n {\n return worldTransform;\n }\n set\n {\n worldTransform = value;\n }\n }\n\n\n internal bool improveBoundaryBehavior = true;\n /// \n /// Gets or sets whether or not the collision system should attempt to improve contact behavior at the boundaries between triangles.\n /// This has a slight performance cost, but prevents objects sliding across a triangle boundary from 'bumping,' and otherwise improves\n /// the robustness of contacts at edges and vertices.\n /// \n public bool ImproveBoundaryBehavior\n {\n get\n {\n return improveBoundaryBehavior;\n }\n set\n {\n improveBoundaryBehavior = value;\n }\n }\n\n protected internal ContactEventManager events;\n ///\n /// Gets the event manager used by the Terrain.\n ///\n public ContactEventManager Events\n {\n get\n {\n return events;\n }\n set\n {\n if (value.Owner != null && //Can't use a manager which is owned by a different entity.\n value != events) //Stay quiet if for some reason the same event manager is being set.\n throw new ArgumentException(\"Event manager is already owned by a Terrain; event managers cannot be shared.\");\n if (events != null)\n events.Owner = null;\n events = value;\n if (events != null)\n events.Owner = this;\n }\n }\n\n protected internal override IContactEventTriggerer EventTriggerer\n {\n get { return events; }\n }\n\n protected override IDeferredEventCreator EventCreator\n {\n get { return events; }\n }\n\n\n internal float thickness;\n /// \n /// Gets or sets the thickness of the terrain. This defines how far below the triangles of the terrain's surface the terrain 'body' extends.\n /// Anything within the body of the terrain will be pulled back up to the surface.\n /// \n public float Thickness\n {\n get\n {\n return thickness;\n }\n set\n {\n if (value < 0)\n throw new ArgumentException(\"Cannot use a negative thickness value.\");\n\n //Modify the bounding box to include the new thickness.\n Vector3 down = Vector3.Normalize(worldTransform.LinearTransform.Down);\n Vector3 thicknessOffset = down * (value - thickness);\n //Use the down direction rather than the thicknessOffset to determine which\n //component of the bounding box to subtract, since the down direction contains all\n //previous extra thickness.\n if (down.X < 0)\n boundingBox.Min.X += thicknessOffset.X;\n else\n boundingBox.Max.X += thicknessOffset.X;\n if (down.Y < 0)\n boundingBox.Min.Y += thicknessOffset.Y;\n else\n boundingBox.Max.Y += thicknessOffset.Y;\n if (down.Z < 0)\n boundingBox.Min.Z += thicknessOffset.Z;\n else\n boundingBox.Max.Z += thicknessOffset.Z;\n\n thickness = value;\n }\n }\n\n\n ///\n /// Constructs a new Terrain.\n ///\n ///Shape to use for the terrain.\n ///Transform to use for the terrain.\n public Terrain(TerrainShape shape, AffineTransform worldTransform)\n {\n this.worldTransform = worldTransform;\n Shape = shape;\n\n Events = new ContactEventManager();\n }\n\n\n ///\n /// Constructs a new Terrain.\n ///\n ///Height data to use to create the TerrainShape.\n ///Transform to use for the terrain.\n public Terrain(float[,] heights, AffineTransform worldTransform)\n : this(new TerrainShape(heights), worldTransform)\n {\n }\n\n\n ///\n /// Updates the bounding box of the terrain.\n ///\n public override void UpdateBoundingBox()\n {\n Shape.GetBoundingBox(ref worldTransform, out boundingBox);\n //Include the thickness of the terrain.\n Vector3 thicknessOffset = Vector3.Normalize(worldTransform.LinearTransform.Down) * thickness;\n if (thicknessOffset.X < 0)\n boundingBox.Min.X += thicknessOffset.X;\n else\n boundingBox.Max.X += thicknessOffset.X;\n if (thicknessOffset.Y < 0)\n boundingBox.Min.Y += thicknessOffset.Y;\n else\n boundingBox.Max.Y += thicknessOffset.Y;\n if (thicknessOffset.Z < 0)\n boundingBox.Min.Z += thicknessOffset.Z;\n else\n boundingBox.Max.Z += thicknessOffset.Z;\n }\n\n \n\n /// \n /// Tests a ray against the entry.\n /// \n /// Ray to test.\n /// Maximum length, in units of the ray's direction's length, to test.\n /// Hit location of the ray on the entry, if any.\n /// Whether or not the ray hit the entry.\n public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)\n {\n return Shape.RayCast(ref ray, maximumLength, ref worldTransform, out rayHit);\n }\n\n /// \n /// Casts a convex shape against the collidable.\n /// \n /// Shape to cast.\n /// Initial transform of the shape.\n /// Sweep to apply to the shape.\n /// Hit data, if any.\n /// Whether or not the cast hit anything.\n public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit)\n {\n hit = new RayHit();\n BoundingBox boundingBox;\n castShape.GetSweptLocalBoundingBox(ref startingTransform, ref worldTransform, ref sweep, out boundingBox);\n var tri = PhysicsResources.GetTriangle();\n var hitElements = PhysicsResources.GetTriangleIndicesList();\n if (Shape.GetOverlaps(boundingBox, hitElements))\n {\n hit.T = float.MaxValue;\n for (int i = 0; i < hitElements.Count; i++)\n {\n Shape.GetTriangle(ref hitElements.Elements[i], ref worldTransform, out tri.vA, out tri.vB, out tri.vC);\n Vector3 center;\n Vector3.Add(ref tri.vA, ref tri.vB, out center);\n Vector3.Add(ref center, ref tri.vC, out center);\n Vector3.Multiply(ref center, 1f / 3f, out center);\n Vector3.Subtract(ref tri.vA, ref center, out tri.vA);\n Vector3.Subtract(ref tri.vB, ref center, out tri.vB);\n Vector3.Subtract(ref tri.vC, ref center, out tri.vC);\n tri.maximumRadius = tri.vA.LengthSquared();\n float radius = tri.vB.LengthSquared();\n if (tri.maximumRadius < radius)\n tri.maximumRadius = radius;\n radius = tri.vC.LengthSquared();\n if (tri.maximumRadius < radius)\n tri.maximumRadius = radius;\n tri.maximumRadius = (float)Math.Sqrt(tri.maximumRadius);\n tri.collisionMargin = 0;\n var triangleTransform = new RigidTransform { Orientation = Quaternion.Identity, Position = center };\n RayHit tempHit;\n if (MPRToolbox.Sweep(castShape, tri, ref sweep, ref Toolbox.ZeroVector, ref startingTransform, ref triangleTransform, out tempHit) && tempHit.T < hit.T)\n {\n hit = tempHit;\n }\n }\n tri.maximumRadius = 0;\n PhysicsResources.GiveBack(tri);\n PhysicsResources.GiveBack(hitElements);\n return hit.T != float.MaxValue;\n }\n PhysicsResources.GiveBack(tri);\n PhysicsResources.GiveBack(hitElements);\n return false;\n }\n\n ///\n /// Gets the normal of a vertex at the given indices.\n ///\n ///First dimension index into the heightmap array.\n ///Second dimension index into the heightmap array.\n ///Normal at the given indices.\n public void GetNormal(int i, int j, out Vector3 normal)\n {\n Shape.GetNormal(i, j, ref worldTransform, out normal);\n }\n\n ///\n /// Gets the position of a vertex at the given indices.\n ///\n ///First dimension index into the heightmap array.\n ///Second dimension index into the heightmap array.\n ///Position at the given indices.\n public void GetPosition(int i, int j, out Vector3 position)\n {\n Shape.GetPosition(i, j, ref worldTransform, out position);\n }\n\n\n\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/BroadPhase.cs",
"content": "using BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.Threading;\nusing BEPUutilities;\nusing BEPUphysics.CollisionRuleManagement;\nusing BEPUutilities.DataStructures;\nusing System;\n\nnamespace BEPUphysics.BroadPhaseSystems\n{\n ///\n /// Superclass of all broad phases. Broad phases collect overlapping broad phase entry pairs.\n ///\n public abstract class BroadPhase : MultithreadedProcessingStage\n {\n readonly SpinLock overlapAddLock = new SpinLock();\n\n ///\n /// Gets the object which is locked by the broadphase during synchronized update processes.\n ///\n public object Locker { get; protected set; }\n protected BroadPhase()\n {\n Locker = new object();\n Enabled = true;\n }\n\n protected BroadPhase(IThreadManager threadManager)\n : this()\n {\n ThreadManager = threadManager;\n AllowMultithreading = true;\n }\n //TODO: Initial capacity? Special collection type other than list due to structs? RawList? Clear at beginning of each frame?\n readonly RawList overlaps = new RawList();\n /// \n /// Gets the list of overlaps identified in the previous broad phase update.\n /// \n public RawList Overlaps\n {\n get { return overlaps; }\n }\n\n\n\n ///\n /// Gets an interface to the broad phase's support for volume-based queries.\n ///\n public IQueryAccelerator QueryAccelerator { get; protected set; }\n\n /// \n /// Adds an entry to the broad phase.\n /// \n /// Entry to add.\n public virtual void Add(BroadPhaseEntry entry)\n {\n if (entry.BroadPhase == null)\n entry.BroadPhase = this;\n else\n throw new ArgumentException(\"Cannot add entry; it already belongs to a broad phase.\");\n }\n\n /// \n /// Removes an entry from the broad phase.\n /// \n /// Entry to remove.\n public virtual void Remove(BroadPhaseEntry entry)\n {\n if (entry.BroadPhase == this)\n entry.BroadPhase = null;\n else\n throw new ArgumentException(\"Cannot remove entry; it does not belong to this broad phase.\");\n }\n\n protected internal void AddOverlap(BroadPhaseOverlap overlap)\n {\n overlapAddLock.Enter();\n overlaps.Add(overlap);\n overlapAddLock.Exit();\n }\n\n /// \n /// Adds a broad phase overlap if the collision rules permit it.\n /// \n /// First entry of the overlap.\n /// Second entry of the overlap.\n protected internal void TryToAddOverlap(BroadPhaseEntry entryA, BroadPhaseEntry entryB)\n {\n CollisionRule rule;\n if ((rule = GetCollisionRule(entryA, entryB)) < CollisionRule.NoBroadPhase)\n {\n overlapAddLock.Enter();\n overlaps.Add(new BroadPhaseOverlap(entryA, entryB, rule));\n overlapAddLock.Exit();\n }\n }\n\n protected internal CollisionRule GetCollisionRule(BroadPhaseEntry entryA, BroadPhaseEntry entryB)\n {\n if (entryA.IsActive || entryB.IsActive)\n return CollisionRules.collisionRuleCalculator(entryA, entryB);\n return CollisionRule.NoBroadPhase;\n }\n\n //TODO: Consider what happens when an overlap is found twice. How should it be dealt with?\n //Can the DBH spit out redundancies?\n //The PUG definitely can- consider two entities that are both in two adjacent cells.\n //Could say 'whatever' to it and handle it in the narrow phase- use the NeedsUpdate property.\n //If NeedsUpdate is false, that means it's already been updated once. Consider multithreaded problems.\n //Would require an interlocked compare exchange or something similar to protect it. \n //Slightly ruins the whole 'embarassingly parallel' aspect.\n\n //Need a something which has O(1) add, O(1) contains check, and fast iteration without requiring external nodes since everything gets regenerated each frame.\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/BroadPhaseOverlap.cs",
"content": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.CollisionRuleManagement;\n\nnamespace BEPUphysics.BroadPhaseSystems\n{\n /// \n /// A pair of overlapping BroadPhaseEntries.\n /// \n public struct BroadPhaseOverlap : IEquatable\n {\n internal BroadPhaseEntry entryA;\n /// \n /// First entry in the pair.\n /// \n public BroadPhaseEntry EntryA\n {\n get { return entryA; }\n }\n\n internal BroadPhaseEntry entryB;\n /// \n /// Second entry in the pair.\n /// \n public BroadPhaseEntry EntryB\n {\n get { return entryB; }\n }\n\n internal CollisionRule collisionRule;\n\n /// \n /// Constructs an overlap.\n /// \n /// First entry in the pair.\n /// Second entry in the pair.\n public BroadPhaseOverlap(BroadPhaseEntry entryA, BroadPhaseEntry entryB)\n {\n this.entryA = entryA;\n this.entryB = entryB;\n collisionRule = CollisionRules.DefaultCollisionRule;\n }\n\n /// \n /// Constructs an overlap.\n /// \n /// First entry in the pair.\n /// Second entry in the pair.\n /// Collision rule calculated for the pair.\n public BroadPhaseOverlap(BroadPhaseEntry entryA, BroadPhaseEntry entryB, CollisionRule collisionRule)\n {\n this.entryA = entryA;\n this.entryB = entryB;\n this.collisionRule = collisionRule;\n }\n\n /// \n /// Gets the collision rule calculated for the pair.\n /// \n public CollisionRule CollisionRule\n {\n get { return collisionRule; }\n }\n\n /// \n /// Gets the hash code of the object.\n /// \n /// Hash code of the object.\n public override int GetHashCode()\n {\n //TODO: Use old prime-based system?\n return (int)((entryA.hashCode + entryB.hashCode) * 0xd8163841);\n }\n\n\n #region IEquatable Members\n\n /// \n /// Compares the overlaps for equality based on the involved entries.\n /// \n /// Overlap to compare.\n /// Whether or not the overlaps were equal.\n public bool Equals(BroadPhaseOverlap other)\n {\n return (other.entryA == entryA && other.entryB == entryB) || (other.entryA == entryB && other.entryB == entryA);\n }\n\n #endregion\n\n public override string ToString()\n {\n return \"{\" + entryA + \", \" + entryB + \"}\";\n }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/BruteForce.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntries;\n\nnamespace BEPUphysics.BroadPhaseSystems\n{\n public class BruteForce : BroadPhase\n {\n public List entries = new List();\n\n public override void Add(BroadPhaseEntry entry)\n {\n entries.Add(entry);\n }\n\n public override void Remove(BroadPhaseEntry entry)\n {\n entries.Remove(entry);\n }\n\n protected override void UpdateMultithreaded()\n {\n UpdateSingleThreaded();\n }\n\n protected override void UpdateSingleThreaded()\n {\n Overlaps.Clear();\n for (int i = 0; i < entries.Count; i++)\n {\n for (int j = i + 1; j < entries.Count; j++)\n {\n if (entries[i].boundingBox.Intersects(entries[j].boundingBox))\n base.TryToAddOverlap(entries[i], entries[j]);\n }\n }\n }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchy.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.Threading;\nusing BEPUutilities.DataStructures;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.BroadPhaseSystems.Hierarchies\n{\n /// \n /// Broad phase that incrementally updates the internal tree acceleration structure.\n /// \n /// \n /// This is a good all-around broad phase; its performance is consistent and all queries are supported and speedy.\n /// The memory usage is higher than simple one-axis sort and sweep, but a bit lower than the Grid2DSortAndSweep option.\n /// \n public class DynamicHierarchy : BroadPhase\n {\n internal Node root;\n\n /// \n /// Constructs a new dynamic hierarchy broad phase.\n /// \n public DynamicHierarchy()\n {\n multithreadedRefit = MultithreadedRefit;\n multithreadedOverlap = MultithreadedOverlap;\n QueryAccelerator = new DynamicHierarchyQueryAccelerator(this);\n }\n\n /// \n /// Constructs a new dynamic hierarchy broad phase.\n /// \n /// Thread manager to use in the broad phase.\n public DynamicHierarchy(IThreadManager threadManager)\n : base(threadManager)\n {\n multithreadedRefit = MultithreadedRefit;\n multithreadedOverlap = MultithreadedOverlap;\n QueryAccelerator = new DynamicHierarchyQueryAccelerator(this);\n }\n\n /// \n /// This is a few test-based values which help threaded scaling.\n /// By going deeper into the trees, a better distribution of work is achieved.\n /// Going above the tested core count theoretically benefits from a '0 if power of 2, 2 otherwise' rule of thumb.\n /// \n private int[] threadSplitOffsets = new[]\n#if !XBOX360\n { 0, 0, 4, 1, 2, 2, 2, 0, 2, 2, 2, 2 };\n#else\n { 2, 2, 2, 1};\n#endif\n#if PROFILE\n /// \n /// Gets the time used in refitting the acceleration structure and making any necessary incremental improvements.\n /// \n public double RefitTime\n {\n get\n {\n return (endRefit - startRefit) / (double)Stopwatch.Frequency;\n }\n }\n /// \n /// Gets the time used in testing the tree against itself to find overlapping pairs. \n /// \n public double OverlapTime\n {\n get\n {\n return (endOverlap - endRefit) / (double)Stopwatch.Frequency;\n }\n }\n long startRefit, endRefit;\n long endOverlap;\n\n\n#endif\n\n #region Multithreading\n\n private void MultithreadedRefitPhase(int splitDepth)\n {\n if (splitDepth > 0)\n {\n root.CollectMultithreadingNodes(splitDepth, 1, multithreadingSourceNodes);\n //Go through every node and refit it.\n ThreadManager.ForLoop(0, multithreadingSourceNodes.Count, multithreadedRefit);\n multithreadingSourceNodes.Clear();\n //Now that the subtrees belonging to the source nodes are refit, refit the top nodes.\n //Sometimes, this will go deeper than necessary because the refit process may require an extremely high level (nonmultithreaded) revalidation.\n //The waste cost is a matter of nanoseconds due to the simplicity of the operations involved.\n root.PostRefit(splitDepth, 1);\n }\n else\n {\n SingleThreadedRefitPhase();\n }\n }\n\n private void MultithreadedOverlapPhase(int splitDepth)\n {\n if (splitDepth > 0)\n {\n //The trees are now fully refit (and revalidated, if the refit process found it to be necessary).\n //The overlap traversal is conceptually similar to the multithreaded refit, but is a bit easier since there's no need to go back up the stack.\n if (!root.IsLeaf) //If the root is a leaf, it's alone- nothing to collide against! This test is required by the assumptions of the leaf-leaf test.\n {\n root.GetMultithreadedOverlaps(root, splitDepth, 1, this, multithreadingSourceOverlaps);\n ThreadManager.ForLoop(0, multithreadingSourceOverlaps.Count, multithreadedOverlap);\n multithreadingSourceOverlaps.Clear();\n }\n }\n else\n {\n SingleThreadedOverlapPhase();\n }\n }\n\n protected override void UpdateMultithreaded()\n {\n lock (Locker)\n {\n Overlaps.Clear();\n if (root != null)\n {\n //To multithread the tree traversals, we have to do a little single threaded work.\n //Dive down into the tree far enough that there are enough nodes to split amongst all the threads in the thread manager.\n //The depth to which we dive is offset by some precomputed values (when available) or a guess based on whether or not the \n //thread count is a power of 2. Thread counts which are a power of 2 match well to the binary tree, while other thread counts\n //require going deeper for better distributions.\n int offset = ThreadManager.ThreadCount <= threadSplitOffsets.Length\n ? threadSplitOffsets[ThreadManager.ThreadCount - 1]\n : (ThreadManager.ThreadCount & (ThreadManager.ThreadCount - 1)) == 0 ? 0 : 2;\n int splitDepth = offset + (int)Math.Ceiling(Math.Log(ThreadManager.ThreadCount, 2));\n#if PROFILE\n startRefit = Stopwatch.GetTimestamp();\n#endif\n MultithreadedRefitPhase(splitDepth);\n#if PROFILE\n endRefit = Stopwatch.GetTimestamp();\n#endif\n MultithreadedOverlapPhase(splitDepth);\n#if PROFILE\n endOverlap = Stopwatch.GetTimestamp();\n#endif\n }\n }\n\n }\n\n internal struct NodePair\n {\n internal Node a;\n internal Node b;\n }\n\n RawList multithreadingSourceNodes = new RawList(4);\n Action multithreadedRefit;\n void MultithreadedRefit(int i)\n {\n multithreadingSourceNodes.Elements[i].Refit();\n }\n\n RawList multithreadingSourceOverlaps = new RawList(10);\n Action multithreadedOverlap;\n void MultithreadedOverlap(int i)\n {\n var overlap = multithreadingSourceOverlaps.Elements[i];\n //Note: It's okay not to check to see if a and b are equal and leaf nodes, because the systems which added nodes to the list already did it.\n overlap.a.GetOverlaps(overlap.b, this);\n }\n\n #endregion\n\n private void SingleThreadedRefitPhase()\n {\n root.Refit();\n }\n\n private void SingleThreadedOverlapPhase()\n {\n if (!root.IsLeaf) //If the root is a leaf, it's alone- nothing to collide against! This test is required by the assumptions of the leaf-leaf test.\n root.GetOverlaps(root, this);\n }\n\n protected override void UpdateSingleThreaded()\n {\n lock (Locker)\n {\n Overlaps.Clear();\n if (root != null)\n {\n#if PROFILE\n startRefit = Stopwatch.GetTimestamp();\n#endif\n SingleThreadedRefitPhase();\n#if PROFILE\n endRefit = Stopwatch.GetTimestamp();\n#endif\n SingleThreadedOverlapPhase();\n#if PROFILE\n endOverlap = Stopwatch.GetTimestamp();\n#endif\n }\n }\n }\n\n UnsafeResourcePool leafNodes = new UnsafeResourcePool();\n\n /// \n /// Adds an entry to the hierarchy.\n /// \n /// Entry to remove.\n public override void Add(BroadPhaseEntry entry)\n {\n base.Add(entry);\n //Entities do not set up their own bounding box before getting stuck in here. If they're all zeroed out, the tree will be horrible.\n Vector3 offset;\n Vector3.Subtract(ref entry.boundingBox.Max, ref entry.boundingBox.Min, out offset);\n if (offset.X * offset.Y * offset.Z == 0)\n entry.UpdateBoundingBox();\n //Could buffer additions to get a better construction in the tree.\n var node = leafNodes.Take();\n node.Initialize(entry);\n if (root == null)\n {\n //Empty tree. This is the first and only node.\n root = node;\n }\n else\n {\n if (root.IsLeaf) //Root is alone.\n root.TryToInsert(node, out root);\n else\n {\n BoundingBox.CreateMerged(ref node.BoundingBox, ref root.BoundingBox, out root.BoundingBox);\n var internalNode = (InternalNode)root;\n Vector3.Subtract(ref root.BoundingBox.Max, ref root.BoundingBox.Min, out offset);\n internalNode.currentVolume = offset.X * offset.Y * offset.Z;\n //internalNode.maximumVolume = internalNode.currentVolume * InternalNode.MaximumVolumeScale;\n //The caller is responsible for the merge.\n var treeNode = root;\n while (!treeNode.TryToInsert(node, out treeNode)) ;//TryToInsert returns the next node, if any, and updates node bounding box.\n }\n }\n }\n /// \n /// Removes an entry from the hierarchy.\n /// \n /// Entry to remove.\n public override void Remove(BroadPhaseEntry entry)\n {\n if (root == null)\n throw new InvalidOperationException(\"Entry not present in the hierarchy.\");\n //Attempt to search for the entry with a boundingbox lookup first.\n if (!RemoveFast(entry))\n {\n //Oof, could not locate it with the fast method; it must have been force-moved or something.\n //Fall back to a slow brute force approach.\n if (!RemoveBrute(entry))\n {\n throw new InvalidOperationException(\"Entry not present in the hierarchy.\");\n }\n }\n }\n\n internal bool RemoveFast(BroadPhaseEntry entry)\n {\n LeafNode leafNode;\n //Update the root with the replacement just in case the removal triggers a root change.\n if (root.RemoveFast(entry, out leafNode, out root))\n {\n leafNode.CleanUp();\n leafNodes.GiveBack(leafNode);\n base.Remove(entry);\n return true;\n }\n return false;\n }\n\n internal bool RemoveBrute(BroadPhaseEntry entry)\n {\n LeafNode leafNode;\n //Update the root with the replacement just in case the removal triggers a root change.\n if (root.Remove(entry, out leafNode, out root))\n {\n leafNode.CleanUp();\n leafNodes.GiveBack(leafNode);\n base.Remove(entry);\n return true;\n }\n return false;\n }\n\n #region Debug\n internal void Analyze(List depths, out int nodeCount)\n {\n nodeCount = 0;\n root.Analyze(depths, 0, ref nodeCount);\n }\n\n internal void ForceRevalidation()\n {\n ((InternalNode)root).Revalidate();\n }\n #endregion\n }\n\n}"
},
{
"path": "BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchyNode.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities.DataStructures;\n\nnamespace BEPUphysics.BroadPhaseSystems.Hierarchies\n{\n internal abstract class Node\n {\n internal BoundingBox BoundingBox;\n internal abstract void GetOverlaps(ref BoundingBox boundingBox, IList outputOverlappedElements);\n internal abstract void GetOverlaps(ref BoundingSphere boundingSphere, IList outputOverlappedElements);\n internal abstract void GetOverlaps(ref BoundingFrustum boundingFrustum, IList outputOverlappedElements);\n internal abstract void GetOverlaps(ref Ray ray, float maximumLength, IList outputOverlappedElements);\n internal abstract void GetOverlaps(Node node, DynamicHierarchy owner);\n\n internal abstract bool IsLeaf { get; }\n\n internal abstract Node ChildA { get; }\n internal abstract Node ChildB { get; }\n internal abstract BroadPhaseEntry Element { get; }\n\n internal abstract bool TryToInsert(LeafNode node, out Node treeNode);\n\n internal abstract void Analyze(List depths, int depth, ref int nodeCount);\n\n internal abstract void Refit();\n\n internal abstract void RetrieveNodes(RawList leafNodes);\n\n\n\n internal abstract void CollectMultithreadingNodes(int splitDepth, int currentDepth, RawList multithreadingSourceNodes);\n\n internal abstract void PostRefit(int splitDepth, int currentDepth);\n\n internal abstract void GetMultithreadedOverlaps(Node opposingNode, int splitDepth, int currentDepth, DynamicHierarchy owner, RawList multithreadingSourceOverlaps);\n\n internal abstract bool Remove(BroadPhaseEntry entry, out LeafNode leafNode, out Node replacementNode);\n internal abstract bool RemoveFast(BroadPhaseEntry entry, out LeafNode leafNode, out Node replacementNode);\n }\n\n internal sealed class InternalNode : Node\n {\n internal Node childA;\n internal Node childB;\n\n internal float currentVolume;\n internal float maximumVolume;\n\n internal static float MaximumVolumeScale = 1.4f;\n\n internal override Node ChildA\n {\n get\n {\n return childA;\n }\n }\n internal override Node ChildB\n {\n get\n {\n return childB;\n }\n }\n internal override BroadPhaseEntry Element\n {\n get\n {\n return default(BroadPhaseEntry);\n }\n }\n\n internal override bool IsLeaf\n {\n get { return false; }\n }\n\n\n internal override void GetOverlaps(ref BoundingBox boundingBox, IList outputOverlappedElements)\n {\n //Users of the GetOverlaps method will have to check the bounding box before calling\n //root.getoverlaps. This is actually desired in some cases, since the outer bounding box is used\n //to determine a pair, and further overlap tests shouldn'BroadPhaseEntry bother retesting the root.\n bool intersects;\n childA.BoundingBox.Intersects(ref boundingBox, out intersects);\n if (intersects)\n childA.GetOverlaps(ref boundingBox, outputOverlappedElements);\n childB.BoundingBox.Intersects(ref boundingBox, out intersects);\n if (intersects)\n childB.GetOverlaps(ref boundingBox, outputOverlappedElements);\n }\n\n internal override void GetOverlaps(ref BoundingSphere boundingSphere, IList outputOverlappedElements)\n {\n bool intersects;\n childA.BoundingBox.Intersects(ref boundingSphere, out intersects);\n if (intersects)\n childA.GetOverlaps(ref boundingSphere, outputOverlappedElements);\n childB.BoundingBox.Intersects(ref boundingSphere, out intersects);\n if (intersects)\n childB.GetOverlaps(ref boundingSphere, outputOverlappedElements);\n }\n\n internal override void GetOverlaps(ref BoundingFrustum boundingFrustum, IList outputOverlappedElements)\n {\n bool intersects;\n boundingFrustum.Intersects(ref childA.BoundingBox, out intersects);\n if (intersects)\n childA.GetOverlaps(ref boundingFrustum, outputOverlappedElements);\n boundingFrustum.Intersects(ref childB.BoundingBox, out intersects);\n if (intersects)\n childB.GetOverlaps(ref boundingFrustum, outputOverlappedElements);\n }\n\n internal override void GetOverlaps(ref Ray ray, float maximumLength, IList outputOverlappedElements)\n {\n float? result;\n ray.Intersects(ref childA.BoundingBox, out result);\n if (result != null && result < maximumLength)\n childA.GetOverlaps(ref ray, maximumLength, outputOverlappedElements);\n ray.Intersects(ref childB.BoundingBox, out result);\n if (result != null && result < maximumLength)\n childB.GetOverlaps(ref ray, maximumLength, outputOverlappedElements);\n }\n\n internal override void GetOverlaps(Node opposingNode, DynamicHierarchy owner)\n {\n bool intersects;\n\n if (this == opposingNode)\n {\n //We are being compared against ourselves!\n //Obviously we're an internal node, so spawn three children:\n //A versus A:\n if (!childA.IsLeaf) //This is performed in the child method usually by convention, but this saves some time.\n childA.GetOverlaps(childA, owner);\n //B versus B:\n if (!childB.IsLeaf) //This is performed in the child method usually by convention, but this saves some time.\n childB.GetOverlaps(childB, owner);\n //A versus B (if they intersect):\n childA.BoundingBox.Intersects(ref childB.BoundingBox, out intersects);\n if (intersects)\n childA.GetOverlaps(childB, owner);\n\n }\n else\n {\n //Two different nodes. The other one may be a leaf.\n if (opposingNode.IsLeaf)\n {\n //If it's a leaf, go deeper in our hierarchy, but not the opposition.\n childA.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);\n if (intersects)\n childA.GetOverlaps(opposingNode, owner);\n childB.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);\n if (intersects)\n childB.GetOverlaps(opposingNode, owner);\n }\n else\n {\n var opposingChildA = opposingNode.ChildA;\n var opposingChildB = opposingNode.ChildB;\n //If it's not a leaf, try to go deeper in both hierarchies.\n childA.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);\n if (intersects)\n childA.GetOverlaps(opposingChildA, owner);\n childA.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);\n if (intersects)\n childA.GetOverlaps(opposingChildB, owner);\n childB.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);\n if (intersects)\n childB.GetOverlaps(opposingChildA, owner);\n childB.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);\n if (intersects)\n childB.GetOverlaps(opposingChildB, owner);\n\n\n }\n }\n\n\n\n\n\n }\n\n internal static LockingResourcePool nodePool = new LockingResourcePool();\n internal override bool TryToInsert(LeafNode node, out Node treeNode)\n {\n //Since we are an internal node, we know we have two children.\n //Regardless of what kind of nodes they are, figure out which would be a better choice to merge the new node with.\n\n //Use the path which produces the smallest 'volume.'\n BoundingBox mergedA, mergedB;\n BoundingBox.CreateMerged(ref childA.BoundingBox, ref node.BoundingBox, out mergedA);\n BoundingBox.CreateMerged(ref childB.BoundingBox, ref node.BoundingBox, out mergedB);\n\n Vector3 offset;\n float originalAVolume, originalBVolume;\n Vector3.Subtract(ref childA.BoundingBox.Max, ref childA.BoundingBox.Min, out offset);\n originalAVolume = offset.X * offset.Y * offset.Z;\n Vector3.Subtract(ref childB.BoundingBox.Max, ref childB.BoundingBox.Min, out offset);\n originalBVolume = offset.X * offset.Y * offset.Z;\n\n float mergedAVolume, mergedBVolume;\n Vector3.Subtract(ref mergedA.Max, ref mergedA.Min, out offset);\n mergedAVolume = offset.X * offset.Y * offset.Z;\n Vector3.Subtract(ref mergedB.Max, ref mergedB.Min, out offset);\n mergedBVolume = offset.X * offset.Y * offset.Z;\n\n //Could use factor increase or absolute difference\n if (mergedAVolume - originalAVolume < mergedBVolume - originalBVolume)\n {\n //merging A produces a better result.\n if (childA.IsLeaf)\n {\n var newChildA = nodePool.Take();\n newChildA.BoundingBox = mergedA;\n newChildA.childA = this.childA;\n newChildA.childB = node;\n newChildA.currentVolume = mergedAVolume;\n //newChildA.maximumVolume = newChildA.currentVolume * MaximumVolumeScale;\n childA = newChildA;\n treeNode = null;\n return true;\n }\n else\n {\n childA.BoundingBox = mergedA;\n var internalNode = (InternalNode)childA;\n internalNode.currentVolume = mergedAVolume;\n //internalNode.maximumVolume = internalNode.currentVolume * MaximumVolumeScale;\n treeNode = childA;\n return false;\n }\n }\n else\n {\n //merging B produces a better result.\n if (childB.IsLeaf)\n {\n //Target is a leaf! Return.\n var newChildB = nodePool.Take();\n newChildB.BoundingBox = mergedB;\n newChildB.childA = node;\n newChildB.childB = this.childB;\n newChildB.currentVolume = mergedBVolume;\n //newChildB.maximumVolume = newChildB.currentVolume * MaximumVolumeScale;\n childB = newChildB;\n treeNode = null;\n return true;\n }\n else\n {\n childB.BoundingBox = mergedB;\n treeNode = childB;\n var internalNode = (InternalNode)childB;\n internalNode.currentVolume = mergedBVolume;\n //internalNode.maximumVolume = internalNode.currentVolume * MaximumVolumeScale;\n return false;\n }\n }\n\n\n\n }\n\n public override string ToString()\n {\n return \"{\" + childA + \", \" + childB + \"}\";\n\n }\n\n internal override void Analyze(List depths, int depth, ref int nodeCount)\n {\n nodeCount++;\n childA.Analyze(depths, depth + 1, ref nodeCount);\n childB.Analyze(depths, depth + 1, ref nodeCount);\n }\n\n internal override void Refit()\n {\n if (currentVolume > maximumVolume)\n {\n Revalidate();\n return;\n }\n childA.Refit();\n childB.Refit();\n BoundingBox.CreateMerged(ref childA.BoundingBox, ref childB.BoundingBox, out BoundingBox);\n //float DEBUGlastVolume = currentVolume;\n currentVolume = (BoundingBox.Max.X - BoundingBox.Min.X) * (BoundingBox.Max.Y - BoundingBox.Min.Y) * (BoundingBox.Max.Z - BoundingBox.Min.Z);\n //if (Math.Abs(currentVolume - DEBUGlastVolume) > .000001 * (DEBUGlastVolume + currentVolume))\n // Debug.WriteLine(\":Break>:)\");\n }\n\n internal static LockingResourcePool> nodeListPool = new LockingResourcePool>();\n internal void Revalidate()\n {\n //The revalidation procedure 'reconstructs' a portion of the tree that has expanded beyond its old limits.\n //To reconstruct the tree, the nodes (internal and leaf) currently in use need to be retrieved.\n //The internal nodes can be put back into the nodePool. LeafNodes are reinserted one by one into the new tree.\n //To retrieve the nodes, a depth-first search is used.\n\n //Given that an internal node is being revalidated, it is known that there are at least two children.\n var oldChildA = childA;\n var oldChildB = childB;\n childA = null;\n childB = null;\n var leafNodes = nodeListPool.Take();\n oldChildA.RetrieveNodes(leafNodes);\n oldChildB.RetrieveNodes(leafNodes);\n for (int i = 0; i < leafNodes.Count; i++)\n leafNodes.Elements[i].Refit();\n Reconstruct(leafNodes, 0, leafNodes.Count);\n leafNodes.Clear();\n nodeListPool.GiveBack(leafNodes);\n\n\n }\n\n void Reconstruct(RawList leafNodes, int begin, int end)\n {\n //It is known that we have 2 children; this is safe.\n //This is because this is only an internal node if the parent figured out it involved more than 2 leaf nodes, OR\n //this node was the initiator of the revalidation (in which case, it was an internal node with 2+ children).\n BoundingBox.CreateMerged(ref leafNodes.Elements[begin].BoundingBox, ref leafNodes.Elements[begin + 1].BoundingBox, out BoundingBox);\n for (int i = begin + 2; i < end; i++)\n {\n BoundingBox.CreateMerged(ref BoundingBox, ref leafNodes.Elements[i].BoundingBox, out BoundingBox);\n }\n Vector3 offset;\n Vector3.Subtract(ref BoundingBox.Max, ref BoundingBox.Min, out offset);\n currentVolume = offset.X * offset.Y * offset.Z;\n maximumVolume = currentVolume * MaximumVolumeScale;\n\n //Pick an axis and sort along it.\n if (offset.X > offset.Y && offset.X > offset.Z)\n {\n //Maximum variance axis is X.\n Array.Sort(leafNodes.Elements, begin, end - begin, xComparer);\n }\n else if (offset.Y > offset.Z)\n {\n //Maximum variance axis is Y. \n Array.Sort(leafNodes.Elements, begin, end - begin, yComparer);\n }\n else\n {\n //Maximum variance axis is Z.\n Array.Sort(leafNodes.Elements, begin, end - begin, zComparer);\n }\n\n //Find the median index.\n int median = (begin + end) / 2;\n\n if (median - begin >= 2)\n {\n //There are 2 or more leaf nodes remaining in the first half. The next childA will be an internal node.\n var newChildA = nodePool.Take();\n newChildA.Reconstruct(leafNodes, begin, median);\n childA = newChildA;\n }\n else\n {\n //There is only 1 leaf node remaining in this half. It's a leaf node.\n childA = leafNodes.Elements[begin];\n }\n\n if (end - median >= 2)\n {\n //There are 2 or more leaf nodes remaining in the second half. The next childB will be an internal node.\n var newChildB = nodePool.Take();\n newChildB.Reconstruct(leafNodes, median, end);\n childB = newChildB;\n }\n else\n {\n //There is only 1 leaf node remaining in this half. It's a leaf node.\n childB = leafNodes.Elements[median];\n }\n\n }\n\n internal override void RetrieveNodes(RawList leafNodes)\n {\n var oldChildA = childA;\n var oldChildB = childB;\n childA = null;\n childB = null;\n nodePool.GiveBack(this); //Give internal nodes back to the pool before going deeper to minimize the creation of additional internal instances.\n oldChildA.RetrieveNodes(leafNodes);\n oldChildB.RetrieveNodes(leafNodes);\n\n\n }\n\n internal override void CollectMultithreadingNodes(int splitDepth, int currentDepth, RawList multithreadingSourceNodes)\n {\n if (currentVolume > maximumVolume)\n {\n //Very rarely, one of these extremely high level nodes will need to be revalidated. This isn't great.\n //We may lose a frame. This could be independently multithreaded, but the benefit is unknown.\n Revalidate();\n return;\n }\n if (currentDepth == splitDepth)\n {\n //We are deep enough in the tree where our children will act as the starting point for multithreaded refits.\n //The split depth ensures that we have enough tasks to thread across our core count.\n multithreadingSourceNodes.Add(childA);\n multithreadingSourceNodes.Add(childB);\n }\n else\n {\n childA.CollectMultithreadingNodes(splitDepth, currentDepth + 1, multithreadingSourceNodes);\n childB.CollectMultithreadingNodes(splitDepth, currentDepth + 1, multithreadingSourceNodes);\n }\n }\n\n internal override void PostRefit(int splitDepth, int currentDepth)\n {\n if (splitDepth > currentDepth)\n {\n //We are not yet back to the nodes that triggered the multithreaded split.\n //Need to go deeper into the tree.\n childA.PostRefit(splitDepth, currentDepth + 1);\n childB.PostRefit(splitDepth, currentDepth + 1);\n }\n BoundingBox.CreateMerged(ref childA.BoundingBox, ref childB.BoundingBox, out BoundingBox);\n currentVolume = (BoundingBox.Max.X - BoundingBox.Min.X) * (BoundingBox.Max.Y - BoundingBox.Min.Y) * (BoundingBox.Max.Z - BoundingBox.Min.Z);\n }\n\n internal override void GetMultithreadedOverlaps(Node opposingNode, int splitDepth, int currentDepth, DynamicHierarchy owner, RawList multithreadingSourceOverlaps)\n {\n bool intersects;\n if (currentDepth == splitDepth)\n {\n //We've reached the depth where our child comparisons will be multithreaded.\n if (this == opposingNode)\n {\n //We are being compared against ourselves!\n //Obviously we're an internal node, so spawn three children:\n //A versus A:\n if (!childA.IsLeaf) //This is performed in the child method usually by convention, but this saves some time.\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = childA, b = childA });\n //B versus B:\n if (!childB.IsLeaf) //This is performed in the child method usually by convention, but this saves some time.\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = childB, b = childB });\n //A versus B (if they intersect):\n childA.BoundingBox.Intersects(ref childB.BoundingBox, out intersects);\n if (intersects)\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = childA, b = childB });\n\n }\n else\n {\n //Two different nodes. The other one may be a leaf.\n if (opposingNode.IsLeaf)\n {\n //If it's a leaf, go deeper in our hierarchy, but not the opposition.\n childA.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);\n if (intersects)\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = childA, b = opposingNode });\n childB.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);\n if (intersects)\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = childB, b = opposingNode });\n }\n else\n {\n var opposingChildA = opposingNode.ChildA;\n var opposingChildB = opposingNode.ChildB;\n //If it's not a leaf, try to go deeper in both hierarchies.\n childA.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);\n if (intersects)\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = childA, b = opposingChildA });\n childA.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);\n if (intersects)\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = childA, b = opposingChildB });\n childB.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);\n if (intersects)\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = childB, b = opposingChildA });\n childB.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);\n if (intersects)\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = childB, b = opposingChildB });\n }\n }\n return;\n }\n if (this == opposingNode)\n {\n //We are being compared against ourselves!\n //Obviously we're an internal node, so spawn three children:\n //A versus A:\n if (!childA.IsLeaf) //This is performed in the child method usually by convention, but this saves some time.\n childA.GetMultithreadedOverlaps(childA, splitDepth, currentDepth + 1, owner, multithreadingSourceOverlaps);\n //B versus B:\n if (!childB.IsLeaf) //This is performed in the child method usually by convention, but this saves some time.\n childB.GetMultithreadedOverlaps(childB, splitDepth, currentDepth + 1, owner, multithreadingSourceOverlaps);\n //A versus B (if they intersect):\n childA.BoundingBox.Intersects(ref childB.BoundingBox, out intersects);\n if (intersects)\n childA.GetMultithreadedOverlaps(childB, splitDepth, currentDepth + 1, owner, multithreadingSourceOverlaps);\n\n }\n else\n {\n //Two different nodes. The other one may be a leaf.\n if (opposingNode.IsLeaf)\n {\n //If it's a leaf, go deeper in our hierarchy, but not the opposition.\n childA.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);\n if (intersects)\n childA.GetMultithreadedOverlaps(opposingNode, splitDepth, currentDepth + 1, owner, multithreadingSourceOverlaps);\n childB.BoundingBox.Intersects(ref opposingNode.BoundingBox, out intersects);\n if (intersects)\n childB.GetMultithreadedOverlaps(opposingNode, splitDepth, currentDepth + 1, owner, multithreadingSourceOverlaps);\n }\n else\n {\n var opposingChildA = opposingNode.ChildA;\n var opposingChildB = opposingNode.ChildB;\n //If it's not a leaf, try to go deeper in both hierarchies.\n childA.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);\n if (intersects)\n childA.GetMultithreadedOverlaps(opposingChildA, splitDepth, currentDepth + 1, owner, multithreadingSourceOverlaps);\n childA.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);\n if (intersects)\n childA.GetMultithreadedOverlaps(opposingChildB, splitDepth, currentDepth + 1, owner, multithreadingSourceOverlaps);\n childB.BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);\n if (intersects)\n childB.GetMultithreadedOverlaps(opposingChildA, splitDepth, currentDepth + 1, owner, multithreadingSourceOverlaps);\n childB.BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);\n if (intersects)\n childB.GetMultithreadedOverlaps(opposingChildB, splitDepth, currentDepth + 1, owner, multithreadingSourceOverlaps);\n }\n }\n }\n\n\n internal override bool Remove(BroadPhaseEntry entry, out LeafNode leafNode, out Node replacementNode)\n {\n if (childA.Remove(entry, out leafNode, out replacementNode))\n {\n if (childA.IsLeaf)\n replacementNode = childB;\n else\n {\n //It was not a leaf node, but a child found the leaf.\n //Change the child to the replacement node.\n childA = replacementNode;\n replacementNode = this; //We don't need to be replaced!\n }\n return true;\n\n }\n if (childB.Remove(entry, out leafNode, out replacementNode))\n {\n if (childB.IsLeaf)\n replacementNode = childA;\n else\n {\n //It was not a leaf node, but a child found the leaf.\n //Change the child to the replacement node.\n childB = replacementNode;\n replacementNode = this; //We don't need to be replaced!\n }\n return true;\n }\n replacementNode = this;\n return false;\n }\n\n internal override bool RemoveFast(BroadPhaseEntry entry, out LeafNode leafNode, out Node replacementNode)\n {\n //Only bother checking deeper in the path if the entry and child have overlapping bounding boxes.\n bool intersects;\n childA.BoundingBox.Intersects(ref entry.boundingBox, out intersects);\n if (intersects && childA.RemoveFast(entry, out leafNode, out replacementNode))\n {\n if (childA.IsLeaf)\n replacementNode = childB;\n else\n {\n //It was not a leaf node, but a child found the leaf.\n //Change the child to the replacement node.\n childA = replacementNode;\n replacementNode = this; //We don't need to be replaced!\n }\n return true;\n\n }\n childB.BoundingBox.Intersects(ref entry.boundingBox, out intersects);\n if (intersects && childB.RemoveFast(entry, out leafNode, out replacementNode))\n {\n if (childB.IsLeaf)\n replacementNode = childA;\n else\n {\n //It was not a leaf node, but a child found the leaf.\n //Change the child to the replacement node.\n childB = replacementNode;\n replacementNode = this; //We don't need to be replaced!\n }\n return true;\n }\n replacementNode = this;\n leafNode = null;\n return false;\n }\n\n\n static XComparer xComparer = new XComparer();\n static YComparer yComparer = new YComparer();\n static ZComparer zComparer = new ZComparer();\n //Try using Comparer instead of IComparer- is there some tricky hardcoded optimization?\n class XComparer : IComparer\n {\n public int Compare(LeafNode x, LeafNode y)\n {\n return x.BoundingBox.Min.X < y.BoundingBox.Min.X ? -1 : 1;\n }\n }\n class YComparer : IComparer\n {\n public int Compare(LeafNode x, LeafNode y)\n {\n return x.BoundingBox.Min.Y < y.BoundingBox.Min.Y ? -1 : 1;\n }\n }\n class ZComparer : IComparer\n {\n public int Compare(LeafNode x, LeafNode y)\n {\n return x.BoundingBox.Min.Z < y.BoundingBox.Min.Z ? -1 : 1;\n }\n }\n }\n\n\n\n\n internal sealed class LeafNode : Node\n {\n BroadPhaseEntry element;\n internal override Node ChildA\n {\n get\n {\n return null;\n }\n }\n internal override Node ChildB\n {\n get\n {\n return null;\n }\n }\n\n internal override BroadPhaseEntry Element\n {\n get\n {\n return element;\n }\n }\n\n internal override bool IsLeaf\n {\n get { return true; }\n }\n\n\n internal void Initialize(BroadPhaseEntry element)\n {\n this.element = element;\n BoundingBox = element.BoundingBox;\n }\n internal void CleanUp()\n {\n element = null;\n }\n\n internal override void GetOverlaps(ref BoundingBox boundingBox, IList outputOverlappedElements)\n {\n //Our parent already tested the bounding box. All that's left is to add myself to the list.\n outputOverlappedElements.Add(element);\n }\n\n internal override void GetOverlaps(ref BoundingSphere boundingSphere, IList outputOverlappedElements)\n {\n outputOverlappedElements.Add(element);\n }\n\n internal override void GetOverlaps(ref BoundingFrustum boundingFrustum, IList outputOverlappedElements)\n {\n outputOverlappedElements.Add(element);\n }\n\n internal override void GetOverlaps(ref Ray ray, float maximumLength, IList outputOverlappedElements)\n {\n outputOverlappedElements.Add(element);\n }\n\n internal override void GetOverlaps(Node opposingNode, DynamicHierarchy owner)\n {\n bool intersects;\n //note: This is never executed when the opposing node is the current node.\n if (opposingNode.IsLeaf)\n {\n //We're both leaves! Our parents have already done the testing for us, so we know we're overlapping.\n owner.TryToAddOverlap(element, opposingNode.Element);\n }\n else\n {\n var opposingChildA = opposingNode.ChildA;\n var opposingChildB = opposingNode.ChildB;\n //If it's not a leaf, try to go deeper in the opposing hierarchy.\n BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);\n if (intersects)\n GetOverlaps(opposingChildA, owner);\n BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);\n if (intersects)\n GetOverlaps(opposingChildB, owner);\n\n }\n }\n\n internal override bool TryToInsert(LeafNode node, out Node treeNode)\n {\n var newTreeNode = InternalNode.nodePool.Take();\n BoundingBox.CreateMerged(ref BoundingBox, ref node.BoundingBox, out newTreeNode.BoundingBox);\n Vector3 offset;\n Vector3.Subtract(ref newTreeNode.BoundingBox.Max, ref newTreeNode.BoundingBox.Min, out offset);\n newTreeNode.currentVolume = offset.X * offset.Y * offset.Z;\n //newTreeNode.maximumVolume = newTreeNode.currentVolume * InternalNode.MaximumVolumeScale;\n newTreeNode.childA = this;\n newTreeNode.childB = node;\n treeNode = newTreeNode;\n return true;\n }\n\n public override string ToString()\n {\n return element.ToString();\n }\n\n internal override void Analyze(List depths, int depth, ref int nodeCount)\n {\n nodeCount++;\n depths.Add(depth);\n }\n\n internal override void Refit()\n {\n BoundingBox = element.boundingBox;\n }\n\n internal override void RetrieveNodes(RawList leafNodes)\n {\n Refit();\n leafNodes.Add(this);\n }\n\n internal override void CollectMultithreadingNodes(int splitDepth, int currentDepth, RawList multithreadingSourceNodes)\n {\n //This could happen if there are almost no elements in the tree. No biggie- do nothing!\n }\n\n internal override void PostRefit(int splitDepth, int currentDepth)\n {\n //This could happen if there are almost no elements in the tree. Just do a normal leaf refit.\n BoundingBox = element.boundingBox;\n }\n\n internal override void GetMultithreadedOverlaps(Node opposingNode, int splitDepth, int currentDepth, DynamicHierarchy owner, RawList multithreadingSourceOverlaps)\n {\n bool intersects;\n //note: This is never executed when the opposing node is the current node.\n if (opposingNode.IsLeaf)\n {\n //We're both leaves! Our parents have already done the testing for us, so we know we're overlapping.\n owner.TryToAddOverlap(element, opposingNode.Element);\n }\n else\n {\n var opposingChildA = opposingNode.ChildA;\n var opposingChildB = opposingNode.ChildB;\n if (splitDepth == currentDepth)\n {\n //Time to add the child overlaps to the multithreading set!\n BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);\n if (intersects)\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = this, b = opposingChildA });\n BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);\n if (intersects)\n multithreadingSourceOverlaps.Add(new DynamicHierarchy.NodePair() { a = this, b = opposingChildB });\n\n return;\n }\n //If it's not a leaf, try to go deeper in the opposing hierarchy.\n BoundingBox.Intersects(ref opposingChildA.BoundingBox, out intersects);\n if (intersects)\n GetOverlaps(opposingChildA, owner);\n BoundingBox.Intersects(ref opposingChildB.BoundingBox, out intersects);\n if (intersects)\n GetOverlaps(opposingChildB, owner);\n\n }\n }\n\n internal override bool Remove(BroadPhaseEntry entry, out LeafNode leafNode, out Node replacementNode)\n {\n replacementNode = null;\n if (element == entry)\n {\n leafNode = this;\n return true;\n }\n leafNode = null;\n return false;\n }\n internal override bool RemoveFast(BroadPhaseEntry entry, out LeafNode leafNode, out Node replacementNode)\n {\n //The fastremove leaf node procedure is identical to the brute force approach.\n //We don't need to perform any bounding box test here; if they're equal, they're equal!\n replacementNode = null;\n if (element == entry)\n {\n leafNode = this;\n return true;\n }\n leafNode = null;\n return false;\n }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchyQueryAccelerator.cs",
"content": "using System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.BroadPhaseSystems.Hierarchies\n{\n ///\n /// Interface to the DynamicHierarchy's volume query systems.\n ///\n public class DynamicHierarchyQueryAccelerator : IQueryAccelerator\n {\n private readonly DynamicHierarchy hierarchy;\n internal DynamicHierarchyQueryAccelerator(DynamicHierarchy hierarchy)\n {\n this.hierarchy = hierarchy;\n }\n\n /// \n /// Gets the broad phase associated with this query accelerator.\n /// \n public BroadPhase BroadPhase\n {\n get\n {\n return hierarchy;\n }\n }\n\n /// \n /// Collects all entries with bounding boxes which intersect the given bounding box.\n /// \n /// Bounding box to test against the world.\n /// Entries of the space which intersect the bounding box.\n public void GetEntries(BoundingBox box, IList entries)\n {\n if (hierarchy.root != null)\n hierarchy.root.GetOverlaps(ref box, entries);\n\n }\n\n /// \n /// Collects all entries with bounding boxes which intersect the given frustum.\n /// \n /// Frustum to test against the world.\n /// Entries of the space which intersect the frustum.\n public void GetEntries(BoundingFrustum frustum, IList entries)\n {\n if (hierarchy.root != null)\n hierarchy.root.GetOverlaps(ref frustum, entries);\n\n }\n\n /// \n /// Collects all entries with bounding boxes which intersect the given sphere.\n /// \n /// Sphere to test against the world.\n /// Entries of the space which intersect the sphere.\n public void GetEntries(BoundingSphere sphere, IList entries)\n {\n if (hierarchy.root != null)\n hierarchy.root.GetOverlaps(ref sphere, entries);\n\n }\n\n\n /// \n /// Finds all intersections between the ray and broad phase entries.\n /// \n /// Ray to test against the structure.\n /// Maximum length of the ray in units of the ray's direction's length.\n /// Entries which have bounding boxes that overlap the ray.\n public bool RayCast(Ray ray, float maximumLength, IList entries)\n {\n if (hierarchy.root != null)\n {\n hierarchy.root.GetOverlaps(ref ray, maximumLength, entries);\n\n return entries.Count > 0;\n }\n return false;\n }\n\n\n /// \n /// Finds all intersections between the ray and broad phase entries.\n /// \n /// Ray to test against the structure.\n /// Entries which have bounding boxes that overlap the ray.\n public bool RayCast(Ray ray, IList entries)\n {\n if (hierarchy.root != null)\n {\n hierarchy.root.GetOverlaps(ref ray, float.MaxValue, entries);\n\n return entries.Count > 0;\n }\n return false;\n }\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/IBoundingBoxOwner.cs",
"content": "using Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.BroadPhaseSystems\n{\n ///\n /// Requires that a class have a BoundingBox.\n ///\n public interface IBoundingBoxOwner\n {\n ///\n /// Gets the bounding box of the object.\n ///\n BoundingBox BoundingBox { get; }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/IBroadPhaseEntryOwner.cs",
"content": "using BEPUphysics.BroadPhaseEntries;\n\nnamespace BEPUphysics.BroadPhaseSystems\n{\n ///\n /// Requires that a class own a BroadPhaseEntry.\n ///\n public interface IBroadPhaseEntryOwner\n {\n ///\n /// Gets the broad phase entry associated with this object.\n ///\n BroadPhaseEntry Entry { get; }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/IQueryAccelerator.cs",
"content": "using System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.BroadPhaseSystems\n{\n ///\n /// Defines a system that accelerates bounding volume and ray cast queries.\n ///\n public interface IQueryAccelerator\n {\n /// \n /// Gets the broad phase associated with this query accelerator, if any.\n /// \n BroadPhase BroadPhase { get; }\n ///\n /// Gets the broad phase entries overlapping the ray.\n ///\n ///Ray to test.\n ///Overlapped entries.\n ///Whether or not the ray hit anything.\n bool RayCast(Ray ray, IList outputIntersections);\n ///\n /// Gets the broad phase entries overlapping the ray.\n ///\n ///Ray to test.\n /// Maximum length of the ray in units of the ray's direction's length.\n ///Overlapped entries.\n ///Whether or not the ray hit anything.\n bool RayCast(Ray ray, float maximumLength, IList outputIntersections);\n\n //There's no single-hit version because the TOI on queries isn't really meaningful.\n //TODO: IQueryAccelerator + BroadPhase. Both have add methods. A user might expect to be able to add separately, but that doesn't really work.\n //Consider pulling the query accelerator into the broadphase so people consider it to be a part of the broadphase- it accelerates queries against the broadphase.\n //If someone wanted to raycast against something other than the broadphase, they can create an IQueryAccelerator of some kind in isolation.\n\n /// \n /// Gets the entries with bounding boxes which overlap the bounding shape.\n /// \n /// Bounding shape to test.\n /// Overlapped entries.\n void GetEntries(BoundingBox boundingShape, IList overlaps);\n /// \n /// Gets the entries with bounding boxes which overlap the bounding shape.\n /// \n /// Bounding shape to test.\n /// Overlapped entries.\n void GetEntries(BoundingSphere boundingShape, IList overlaps);\n /// \n /// Gets the entries with bounding boxes which overlap the bounding shape.\n /// \n /// Bounding shape to test.\n /// Overlapped entries.\n void GetEntries(BoundingFrustum boundingShape, IList overlaps);\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DEntry.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntries;\n\nnamespace BEPUphysics.BroadPhaseSystems.SortAndSweep\n{\n class Grid2DEntry\n {\n internal void Initialize(BroadPhaseEntry entry)\n {\n this.item = entry;\n Grid2DSortAndSweep.ComputeCell(ref entry.boundingBox.Min, out previousMin);\n Grid2DSortAndSweep.ComputeCell(ref entry.boundingBox.Max, out previousMax);\n }\n\n\n internal BroadPhaseEntry item;\n internal Int2 previousMin;\n internal Int2 previousMax;\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DSortAndSweep.cs",
"content": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.Threading;\nusing BEPUutilities.DataStructures;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.BroadPhaseSystems.SortAndSweep\n{\n /// \n /// Broad phase implementation that partitions objects into a 2d grid, and then performs a sort and sweep on the final axis.\n /// \n /// \n /// This broad phase typically has very good collision performance and scales well with multithreading, but its query times can sometimes be worse than tree-based systems\n /// since it must scan cells. Keeping rays as short as possible helps avoid unnecessary cell checks.\n /// The performance can degrade noticeably in some situations involving significant off-axis motion.\n /// \n public class Grid2DSortAndSweep : BroadPhase\n {\n /// \n /// Gets or sets the width of cells in the 2D grid. For sparser, larger scenes, increasing this can help performance.\n /// For denser scenes, decreasing this may help.\n /// \n public static float CellSize\n {\n get\n {\n return 1 / cellSizeInverse;\n }\n set\n {\n cellSizeInverse = 1 / value;\n }\n }\n //TODO: Try different values for this.\n internal static float cellSizeInverse = 1 / 8f; \n\n internal static void ComputeCell(ref Vector3 v, out Int2 cell)\n {\n cell.Y = (int)Math.Floor(v.Y * cellSizeInverse);\n cell.Z = (int)Math.Floor(v.Z * cellSizeInverse);\n }\n\n \n\n\n\n internal SortedGrid2DSet cellSet = new SortedGrid2DSet();\n\n\n RawList entries = new RawList();\n Action updateEntry, updateCell;\n\n /// \n /// Constructs a grid-based sort and sweep broad phase.\n /// \n /// Thread manager to use for the broad phase.\n public Grid2DSortAndSweep(IThreadManager threadManager)\n :base(threadManager)\n {\n updateEntry = UpdateEntry;\n updateCell = UpdateCell;\n QueryAccelerator = new Grid2DSortAndSweepQueryAccelerator(this);\n }\n /// \n /// Constructs a grid-based sort and sweep broad phase.\n /// \n public Grid2DSortAndSweep()\n {\n updateEntry = UpdateEntry;\n updateCell = UpdateCell;\n QueryAccelerator = new Grid2DSortAndSweepQueryAccelerator(this);\n }\n\n UnsafeResourcePool entryPool = new UnsafeResourcePool();\n /// \n /// Adds an entry to the broad phase.\n /// \n /// Entry to add.\n public override void Add(BroadPhaseEntry entry)\n {\n base.Add(entry);\n //Entities do not set up their own bounding box before getting stuck in here. If they're all zeroed out, the tree will be horrible.\n Vector3 offset;\n Vector3.Subtract(ref entry.boundingBox.Max, ref entry.boundingBox.Min, out offset);\n if (offset.X * offset.Y * offset.Z == 0)\n entry.UpdateBoundingBox();\n var newEntry = entryPool.Take();\n newEntry.Initialize(entry);\n entries.Add(newEntry);\n //Add the object to the grid.\n for (int i = newEntry.previousMin.Y; i <= newEntry.previousMax.Y; i++)\n {\n for (int j = newEntry.previousMin.Z; j <= newEntry.previousMax.Z; j++)\n {\n var index = new Int2 {Y = i, Z = j};\n cellSet.Add(ref index, newEntry);\n }\n }\n }\n\n /// \n /// Removes an entry from the broad phase.\n /// \n /// Entry to remove.\n public override void Remove(BroadPhaseEntry entry)\n {\n base.Remove(entry);\n for (int i = 0; i < entries.Count; i++)\n {\n if (entries.Elements[i].item == entry)\n {\n var gridEntry = entries.Elements[i];\n entries.RemoveAt(i);\n //Remove the object from any cells that it is held by.\n for (int j = gridEntry.previousMin.Y; j <= gridEntry.previousMax.Y; j++)\n {\n for (int k = gridEntry.previousMin.Z; k <= gridEntry.previousMax.Z; k++)\n {\n var index = new Int2 {Y = j, Z = k};\n cellSet.Remove(ref index, gridEntry);\n }\n }\n gridEntry.item = null;\n entryPool.GiveBack(gridEntry);\n return;\n }\n }\n }\n\n protected override void UpdateMultithreaded()\n {\n lock (Locker)\n {\n Overlaps.Clear();\n //Update the entries!\n ThreadManager.ForLoop(0, entries.Count, updateEntry);\n //Update the cells!\n ThreadManager.ForLoop(0, cellSet.count, updateCell);\n }\n }\n\n protected override void UpdateSingleThreaded()\n {\n lock (Locker)\n {\n Overlaps.Clear();\n //Update the placement of objects.\n for (int i = 0; i < entries.Count; i++)\n {\n //Compute the current cells occupied by the entry.\n var entry = entries.Elements[i];\n Int2 min, max;\n ComputeCell(ref entry.item.boundingBox.Min, out min);\n ComputeCell(ref entry.item.boundingBox.Max, out max);\n //For any cell that used to be occupied (defined by the previous min/max),\n //remove the entry.\n for (int j = entry.previousMin.Y; j <= entry.previousMax.Y; j++)\n {\n for (int k = entry.previousMin.Z; k <= entry.previousMax.Z; k++)\n {\n if (j >= min.Y && j <= max.Y && k >= min.Z && k <= max.Z)\n continue; //This cell is currently occupied, do not remove.\n var index = new Int2 {Y = j, Z = k};\n cellSet.Remove(ref index, entry);\n }\n }\n //For any cell that is newly occupied (was not previously contained),\n //add the entry.\n for (int j = min.Y; j <= max.Y; j++)\n {\n for (int k = min.Z; k <= max.Z; k++)\n {\n if (j >= entry.previousMin.Y && j <= entry.previousMax.Y && k >= entry.previousMin.Z && k <= entry.previousMax.Z)\n continue; //This cell is already occupied, do not add.\n var index = new Int2 {Y = j, Z = k};\n cellSet.Add(ref index, entry);\n }\n }\n entry.previousMin = min;\n entry.previousMax = max;\n }\n\n //Update each cell to find the overlaps.\n for (int i = 0; i < cellSet.count; i++)\n {\n cellSet.cells.Elements[i].UpdateOverlaps(this);\n }\n }\n }\n\n //TODO: Cell change operations take a while. Spin lock can't efficiently wait that long.\n //This causes some pretty horrible scaling problems in some scenarios.\n //Improving the cell set operations directly should improve that problem and the query times noticeably.\n\n\n SpinLock cellSetLocker = new SpinLock();\n void UpdateEntry(int i)\n {\n\n //Compute the current cells occupied by the entry.\n var entry = entries.Elements[i];\n Int2 min, max;\n ComputeCell(ref entry.item.boundingBox.Min, out min);\n ComputeCell(ref entry.item.boundingBox.Max, out max);\n //For any cell that used to be occupied (defined by the previous min/max),\n //remove the entry.\n for (int j = entry.previousMin.Y; j <= entry.previousMax.Y; j++)\n {\n for (int k = entry.previousMin.Z; k <= entry.previousMax.Z; k++)\n {\n if (j >= min.Y && j <= max.Y && k >= min.Z && k <= max.Z)\n continue; //This cell is currently occupied, do not remove.\n var index = new Int2 {Y = j, Z = k};\n cellSetLocker.Enter();\n cellSet.Remove(ref index, entry);\n cellSetLocker.Exit();\n }\n }\n //For any cell that is newly occupied (was not previously contained),\n //add the entry.\n for (int j = min.Y; j <= max.Y; j++)\n {\n for (int k = min.Z; k <= max.Z; k++)\n {\n if (j >= entry.previousMin.Y && j <= entry.previousMax.Y && k >= entry.previousMin.Z && k <= entry.previousMax.Z)\n continue; //This cell is already occupied, do not add.\n var index = new Int2 {Y = j, Z = k};\n cellSetLocker.Enter();\n cellSet.Add(ref index, entry);\n cellSetLocker.Exit();\n }\n }\n entry.previousMin = min;\n entry.previousMax = max;\n }\n\n void UpdateCell(int i)\n {\n //TODO: Consider permuting.\n //In some simulations, there may be a ton of unoccupied cells.\n //It would be best to distribute these over the threads.\n //(int)((i * 122949823L) % cellSet.count)\n //(i * 122949823L) % cellSet.count\n cellSet.cells.Elements[i].UpdateOverlaps(this);\n }\n }\n\n struct Int2\n {\n internal int Y;\n internal int Z;\n\n public override int GetHashCode()\n {\n return Y + Z;\n }\n\n\n\n internal int GetSortingHash()\n {\n return (int)(Y * 15485863L + Z * 32452843L);\n }\n\n public override string ToString()\n {\n return \"{\" + Y + \", \" + Z + \"}\";\n }\n }\n\n\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DSortAndSweepQueryAccelerator.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntries;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.BroadPhaseSystems.SortAndSweep\n{\n public class Grid2DSortAndSweepQueryAccelerator : IQueryAccelerator\n {\n Grid2DSortAndSweep owner;\n public Grid2DSortAndSweepQueryAccelerator(Grid2DSortAndSweep owner)\n {\n this.owner = owner;\n }\n\n /// \n /// Gets the broad phase associated with this query accelerator.\n /// \n public BroadPhase BroadPhase\n {\n get\n {\n return owner;\n }\n }\n\n public bool RayCast(Microsoft.Xna.Framework.Ray ray, IList outputIntersections)\n {\n throw new NotSupportedException(\"The Grid2DSortAndSweep broad phase cannot accelerate infinite ray casts. Consider specifying a maximum length or using a broad phase which supports infinite ray casts.\");\n }\n\n public bool RayCast(Microsoft.Xna.Framework.Ray ray, float maximumLength, IList outputIntersections)\n {\n if (maximumLength == float.MaxValue) \n throw new NotSupportedException(\"The Grid2DSortAndSweep broad phase cannot accelerate infinite ray casts. Consider specifying a maximum length or using a broad phase which supports infinite ray casts.\");\n \n //Use 2d line rasterization.\n //Compute the exit location in the cell.\n //Test against each bounding box up until the exit value is reached.\n float length = 0;\n Int2 cellIndex;\n Vector3 currentPosition = ray.Position;\n Grid2DSortAndSweep.ComputeCell(ref currentPosition, out cellIndex);\n while (true)\n {\n\n float cellWidth = 1 / Grid2DSortAndSweep.cellSizeInverse;\n float nextT; //Distance along ray to next boundary.\n float nextTy; //Distance along ray to next boundary along y axis.\n float nextTz; //Distance along ray to next boundary along z axis.\n //Find the next cell.\n if (ray.Direction.Y > 0)\n nextTy = ((cellIndex.Y + 1) * cellWidth - currentPosition.Y) / ray.Direction.Y;\n else if (ray.Direction.Y < 0)\n nextTy = ((cellIndex.Y) * cellWidth - currentPosition.Y) / ray.Direction.Y;\n else\n nextTy = 10e10f;\n if (ray.Direction.Z > 0)\n nextTz = ((cellIndex.Z + 1) * cellWidth - currentPosition.Z) / ray.Direction.Z;\n else if (ray.Direction.Z < 0)\n nextTz = ((cellIndex.Z) * cellWidth - currentPosition.Z) / ray.Direction.Z;\n else\n nextTz = 10e10f;\n\n bool yIsMinimum = nextTy < nextTz;\n nextT = yIsMinimum ? nextTy : nextTz;\n\n\n\n\n //Grab the cell that we are currently in.\n GridCell2D cell;\n if (owner.cellSet.TryGetCell(ref cellIndex, out cell))\n {\n float endingX;\n if(ray.Direction.X < 0)\n endingX = currentPosition.X;\n else\n endingX = currentPosition.X + ray.Direction.X * nextT;\n\n //To fully accelerate this, the entries list would need to contain both min and max interval markers.\n //Since it only contains the sorted min intervals, we can't just start at a point in the middle of the list.\n //Consider some giant bounding box that spans the entire list. \n for (int i = 0; i < cell.entries.Count \n && cell.entries.Elements[i].item.boundingBox.Min.X <= endingX; i++) //TODO: Try additional x axis pruning?\n {\n float? intersects;\n var item = cell.entries.Elements[i].item;\n ray.Intersects(ref item.boundingBox, out intersects);\n if (intersects != null && intersects < maximumLength && !outputIntersections.Contains(item))\n {\n outputIntersections.Add(item);\n }\n }\n }\n\n //Move the position forward.\n length += nextT;\n if (length > maximumLength) //Note that this catches the case in which the ray is pointing right down the middle of a row (resulting in a nextT of 10e10f).\n break;\n Vector3 offset;\n Vector3.Multiply(ref ray.Direction, nextT, out offset);\n Vector3.Add(ref offset, ref currentPosition, out currentPosition);\n if (yIsMinimum)\n if (ray.Direction.Y < 0)\n cellIndex.Y -= 1;\n else\n cellIndex.Y += 1;\n else\n if (ray.Direction.Z < 0)\n cellIndex.Z -= 1;\n else\n cellIndex.Z += 1;\n }\n return outputIntersections.Count > 0;\n\n }\n\n\n public void GetEntries(Microsoft.Xna.Framework.BoundingBox boundingShape, IList overlaps)\n {\n //Compute the min and max of the bounding box.\n //Loop through the cells and select bounding boxes which overlap the x axis.\n\n Int2 min, max;\n Grid2DSortAndSweep.ComputeCell(ref boundingShape.Min, out min);\n Grid2DSortAndSweep.ComputeCell(ref boundingShape.Max, out max);\n for (int i = min.Y; i <= max.Y; i++)\n {\n for (int j = min.Z; j <= max.Z; j++)\n {\n //Grab the cell that we are currently in.\n Int2 cellIndex;\n cellIndex.Y = i;\n cellIndex.Z = j;\n GridCell2D cell;\n if (owner.cellSet.TryGetCell(ref cellIndex, out cell))\n {\n \n //To fully accelerate this, the entries list would need to contain both min and max interval markers.\n //Since it only contains the sorted min intervals, we can't just start at a point in the middle of the list.\n //Consider some giant bounding box that spans the entire list. \n for (int k = 0; k < cell.entries.Count\n && cell.entries.Elements[k].item.boundingBox.Min.X <= boundingShape.Max.X; k++) //TODO: Try additional x axis pruning? A bit of optimization potential due to overlap with AABB test.\n {\n bool intersects;\n var item = cell.entries.Elements[k].item;\n boundingShape.Intersects(ref item.boundingBox, out intersects);\n if (intersects && !overlaps.Contains(item))\n {\n overlaps.Add(item);\n }\n }\n }\n }\n }\n }\n\n public void GetEntries(Microsoft.Xna.Framework.BoundingSphere boundingShape, IList overlaps)\n {\n //Create a bounding box based on the bounding sphere.\n //Compute the min and max of the bounding box.\n //Loop through the cells and select bounding boxes which overlap the x axis.\n#if !WINDOWS\n Vector3 offset = new Vector3();\n#else\n Vector3 offset;\n#endif\n offset.X = boundingShape.Radius;\n offset.Y = offset.X;\n offset.Z = offset.Y;\n BoundingBox box;\n Vector3.Add(ref boundingShape.Center, ref offset, out box.Max);\n Vector3.Subtract(ref boundingShape.Center, ref offset, out box.Min);\n\n Int2 min, max;\n Grid2DSortAndSweep.ComputeCell(ref box.Min, out min);\n Grid2DSortAndSweep.ComputeCell(ref box.Max, out max);\n for (int i = min.Y; i <= max.Y; i++)\n {\n for (int j = min.Z; j <= max.Z; j++)\n {\n //Grab the cell that we are currently in.\n Int2 cellIndex;\n cellIndex.Y = i;\n cellIndex.Z = j;\n GridCell2D cell;\n if (owner.cellSet.TryGetCell(ref cellIndex, out cell))\n {\n\n //To fully accelerate this, the entries list would need to contain both min and max interval markers.\n //Since it only contains the sorted min intervals, we can't just start at a point in the middle of the list.\n //Consider some giant bounding box that spans the entire list. \n for (int k = 0; k < cell.entries.Count\n && cell.entries.Elements[k].item.boundingBox.Min.X <= box.Max.X; k++) //TODO: Try additional x axis pruning? A bit of optimization potential due to overlap with AABB test.\n {\n bool intersects;\n var item = cell.entries.Elements[k].item;\n boundingShape.Intersects(ref item.boundingBox, out intersects);\n if (intersects && !overlaps.Contains(item))\n {\n overlaps.Add(item);\n }\n }\n }\n }\n }\n }\n\n public void GetEntries(Microsoft.Xna.Framework.BoundingFrustum boundingShape, IList overlaps)\n {\n throw new NotSupportedException(\"The Grid2DSortAndSweep broad phase cannot accelerate frustum tests. Consider using a broad phase which supports frustum tests or using a custom solution.\");\n }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/GridCell2D.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUutilities.DataStructures;\nusing Microsoft.Xna.Framework;\nusing System.Diagnostics;\n\nnamespace BEPUphysics.BroadPhaseSystems.SortAndSweep\n{\n class GridCell2D\n {\n internal RawList entries = new RawList();\n internal Int2 cellIndex;\n internal int sortingHash;\n\n internal void Initialize(ref Int2 cellIndex, int hash)\n {\n this.cellIndex = cellIndex;\n sortingHash = hash;\n }\n\n internal int GetIndex(float x)\n {\n int minIndex = 0; //inclusive\n int maxIndex = entries.Count; //exclusive\n int index = 0;\n while (maxIndex - minIndex > 0)\n {\n index = (maxIndex + minIndex) / 2;\n if (entries.Elements[index].item.boundingBox.Min.X > x)\n maxIndex = index;\n else if (entries.Elements[index].item.boundingBox.Min.X < x)\n minIndex = ++index;\n else\n break; //Found an equal value!\n\n }\n return index;\n }\n\n internal void Add(Grid2DEntry entry)\n {\n //binary search for the approximately correct location. This helps prevent large first-frame sort times.\n entries.Insert(GetIndex(entry.item.boundingBox.Min.X), entry);\n }\n\n internal void Remove(Grid2DEntry entry)\n {\n entries.Remove(entry);\n }\n\n internal void UpdateOverlaps(Grid2DSortAndSweep owner)\n {\n //Sort along x axis using insertion sort; the list will be nearly sorted, so very few swaps are necessary.\n for (int i = 1; i < entries.Count; i++)\n {\n var entry = entries.Elements[i];\n for (int j = i - 1; j >= 0; j--)\n {\n if (entry.item.boundingBox.Min.X < entries.Elements[j].item.boundingBox.Min.X)\n {\n entries.Elements[j + 1] = entries.Elements[j];\n entries.Elements[j] = entry;\n }\n else\n break;\n }\n }\n //Sweep the list looking for overlaps.\n for (int i = 0; i < entries.Count; i++)\n {\n Grid2DEntry a = entries.Elements[i];\n Grid2DEntry b;\n //TODO: Microoptimize\n for (int j = i + 1; j < entries.Count && a.item.boundingBox.Max.X >= (b = entries.Elements[j]).item.boundingBox.Min.X; j++)\n {\n if (!(a.item.boundingBox.Min.Y > b.item.boundingBox.Max.Y || a.item.boundingBox.Max.Y < b.item.boundingBox.Min.Y ||\n a.item.boundingBox.Min.Z > b.item.boundingBox.Max.Z || a.item.boundingBox.Max.Z < b.item.boundingBox.Min.Z))\n {\n //Now we know this pair is overlapping, but we do not know if this overlap is already added.\n //Rather than use a hashset or other heavy structure to check, rely on the rules of the grid.\n\n //It's possible to avoid adding pairs entirely unless we are the designated 'responsible' cell.\n //All other cells will defer to the cell 'responsible' for a pair.\n //A simple rule for determining the cell which is responsible is to choose the cell which is the \n //smallest index in the shared cells. So first, compute that cell's index.\n\n Int2 minimumSharedIndex = a.previousMin;\n\n if (minimumSharedIndex.Y < b.previousMin.Y)\n minimumSharedIndex.Y = b.previousMin.Y;\n if (minimumSharedIndex.Y > b.previousMax.Y)\n minimumSharedIndex.Y = b.previousMax.Y;\n\n if (minimumSharedIndex.Z < b.previousMin.Z)\n minimumSharedIndex.Z = b.previousMin.Z;\n if (minimumSharedIndex.Z > b.previousMax.Z)\n minimumSharedIndex.Z = b.previousMax.Z;\n\n //Is our cell the minimum cell?\n if (minimumSharedIndex.Y == cellIndex.Y && minimumSharedIndex.Z == cellIndex.Z)\n owner.TryToAddOverlap(a.item, b.item);\n\n\n\n\n\n }\n }\n }\n }\n\n\n public override string ToString()\n {\n return \"{\" + cellIndex.Y + \", \" + cellIndex.Z + \"}: \" + entries.Count;\n }\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/SortAndSweep1D.cs",
"content": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.Threading;\nusing BEPUutilities.DataStructures;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.BroadPhaseSystems.SortAndSweep\n{\n /// \n /// Simple and standard implementation of the one-axis sort and sweep (sweep and prune) algorithm.\n /// \n /// \n /// In small scenarios, it can be the quickest option. It uses very little memory.\n /// However, it tends to scale poorly relative to other options and can slow down significantly when entries cluster along the axis.\n /// Additionally, it supports no queries at all.\n /// \n public class SortAndSweep1D : BroadPhase\n {\n /// \n /// Constructs a new sort and sweep broad phase.\n /// \n /// Thread manager to use in the broad phase.\n public SortAndSweep1D(IThreadManager threadManager)\n : base(threadManager)\n {\n sweepSegment = Sweep;\n backbuffer = new RawList();\n }\n\n /// \n /// Constructs a new sort and sweep broad phase.\n /// \n public SortAndSweep1D()\n {\n\n sweepSegment = Sweep;\n backbuffer = new RawList();\n }\n\n\n RawList entries = new RawList();\n /// \n /// Adds an entry to the broad phase.\n /// \n /// Entry to add.\n public override void Add(BroadPhaseEntry entry)\n {\n base.Add(entry);\n //Entities do not set up their own bounding box before getting stuck in here. If they're all zeroed out, the tree will be horrible.\n Vector3 offset;\n Vector3.Subtract(ref entry.boundingBox.Max, ref entry.boundingBox.Min, out offset);\n if (offset.X * offset.Y * offset.Z == 0)\n entry.UpdateBoundingBox();\n //binary search for the approximately correct location. This helps prevent large first-frame sort times.\n int minIndex = 0; //inclusive\n int maxIndex = entries.Count; //exclusive\n int index = 0;\n while (maxIndex - minIndex > 0)\n {\n index = (maxIndex + minIndex) / 2;\n if (entries.Elements[index].boundingBox.Min.X > entry.boundingBox.Min.X)\n maxIndex = index;\n else if (entries.Elements[index].boundingBox.Min.X < entry.boundingBox.Min.X)\n minIndex = ++index;\n else\n break; //Found an equal value!\n\n }\n entries.Insert(index, entry);\n }\n\n /// \n /// Removes an entry from the broad phase.\n /// \n /// Entry to remove.\n public override void Remove(BroadPhaseEntry entry)\n {\n base.Remove(entry);\n entries.Remove(entry);\n }\n\n Action sweepSegment;\n protected override void UpdateMultithreaded()\n {\n if (backbuffer.Count != entries.Count)\n {\n backbuffer.Capacity = entries.Capacity;\n backbuffer.Count = entries.Count;\n }\n Overlaps.Clear();\n //Sort along x axis using insertion sort; the list will be nearly sorted, so very few swaps are necessary.\n for (int i = 1; i < entries.Count; i++)\n {\n var entry = entries.Elements[i];\n for (int j = i - 1; j >= 0; j--)\n {\n if (entry.boundingBox.Min.X < entries.Elements[j].boundingBox.Min.X)\n {\n entries.Elements[j + 1] = entries.Elements[j];\n entries.Elements[j] = entry;\n }\n else\n break;\n }\n\n }\n\n //TODO: Multithreaded sorting could help in some large cases.\n //The overhead involved in this implementation is way too high for reasonable object counts.\n //for (int i = 0; i < sortSegmentCount; i++)\n // SortSection(i);\n\n ////MergeSections(0, 1);\n ////MergeSections(2, 3);\n ////MergeSections(0, 2);\n ////MergeSections(1, 3);\n\n //MergeSections(0, 1);\n //MergeSections(2, 3);\n //MergeSections(4, 5);\n //MergeSections(6, 7);\n\n //MergeSections(0, 2);\n //MergeSections(1, 3);\n //MergeSections(4, 6);\n //MergeSections(5, 7);\n\n //MergeSections(0, 4);\n //MergeSections(1, 5);\n //MergeSections(2, 6);\n //MergeSections(3, 7);\n\n //var temp = backbuffer;\n //backbuffer = entries;\n //entries = temp;\n\n ThreadManager.ForLoop(0, sweepSegmentCount, sweepSegment);\n }\n\n protected override void UpdateSingleThreaded()\n {\n Overlaps.Clear();\n //Sort along x axis using insertion sort; the list will be nearly sorted, so very few swaps are necessary.\n for (int i = 1; i < entries.Count; i++)\n {\n var entry = entries.Elements[i];\n for (int j = i - 1; j >= 0; j--)\n {\n if (entry.boundingBox.Min.X < entries.Elements[j].boundingBox.Min.X)\n {\n entries.Elements[j + 1] = entries.Elements[j];\n entries.Elements[j] = entry;\n }\n else\n break;\n }\n\n }\n //Sweep the list looking for overlaps.\n for (int i = 0; i < entries.Count; i++)\n {\n BoundingBox a = entries.Elements[i].boundingBox;\n for (int j = i + 1; j < entries.Count && a.Max.X >= entries.Elements[j].boundingBox.Min.X; j++)\n {\n if (!(a.Min.Y > entries.Elements[j].boundingBox.Max.Y || a.Max.Y < entries.Elements[j].boundingBox.Min.Y ||\n a.Min.Z > entries.Elements[j].boundingBox.Max.Z || a.Max.Z < entries.Elements[j].boundingBox.Min.Z))\n {\n TryToAddOverlap(entries.Elements[i], entries.Elements[j]);\n }\n }\n }\n }\n\n\n //TODO: It is possible to distribute things a bit better. Instead of lumping all of the remainder into the final, put and \n\n int sweepSegmentCount = 32;\n void Sweep(int segment)\n {\n int intervalLength = entries.Count / sweepSegmentCount;\n int end;\n if (segment == sweepSegmentCount - 1)\n end = entries.Count;\n else\n end = intervalLength * (segment + 1);\n for (int i = intervalLength * segment; i < end; i++)\n {\n BoundingBox a = entries.Elements[i].boundingBox;\n for (int j = i + 1; j < entries.Count && a.Max.X >= entries.Elements[j].boundingBox.Min.X; j++)\n {\n if (!(a.Min.Y > entries.Elements[j].boundingBox.Max.Y || a.Max.Y < entries.Elements[j].boundingBox.Min.Y ||\n a.Min.Z > entries.Elements[j].boundingBox.Max.Z || a.Max.Z < entries.Elements[j].boundingBox.Min.Z))\n {\n TryToAddOverlap(entries.Elements[i], entries.Elements[j]);\n }\n }\n }\n }\n\n int sortSegmentCount = 4;\n void SortSection(int section)\n {\n int intervalLength = entries.Count / sortSegmentCount;\n int start = section * intervalLength;\n int end;\n if (section == sortSegmentCount - 1)\n end = entries.Count;\n else\n end = intervalLength * (section + 1);\n\n for (int i = start + 1; i < end; i++)\n {\n var entry = entries.Elements[i];\n for (int j = i - 1; j >= 0; j--)\n {\n if (entry.boundingBox.Min.X < entries.Elements[j].boundingBox.Min.X)\n {\n entries.Elements[j + 1] = entries.Elements[j];\n entries.Elements[j] = entry;\n }\n else\n break;\n }\n\n }\n }\n\n RawList backbuffer;\n void MergeSections(int a, int b)\n {\n int intervalLength = entries.Count / sortSegmentCount;\n //'a' is known to be less than b, which means it cannot be the last section.\n int aStart = intervalLength * a;\n int aEnd = intervalLength * (a + 1);\n int bStart = intervalLength * b;\n int bEnd;\n int length;\n if (b == sortSegmentCount - 1)\n {\n bEnd = entries.Count;\n length = intervalLength + entries.Count - bStart;\n }\n else\n {\n bEnd = intervalLength * (b + 1);\n length = intervalLength * 2;\n }\n\n int aIndex = aStart, bIndex = bStart;\n int i = 0;\n while (i < length)\n {\n //Compute the location in the buffer array to put the minimum element.\n int bufferIndex;\n if (i >= intervalLength) //a length is intervalLength.\n bufferIndex = bStart + i - intervalLength;\n else\n bufferIndex = aStart + i;\n\n if (aIndex < aEnd && bIndex < bEnd)\n {\n //Compare the element at a to the one at b.\n if (entries.Elements[aIndex].boundingBox.Min.X < entries.Elements[bIndex].boundingBox.Min.X)\n {\n //a was the minimum element. Put it into the buffer and increment the considered a index.\n backbuffer.Elements[bufferIndex] = entries.Elements[aIndex++];\n }\n else\n {\n //b was the minimum element. Put it into the buffer and increment the considered b index.\n backbuffer.Elements[bufferIndex] = entries.Elements[bIndex++];\n }\n }\n else if (aIndex < aEnd)\n {\n //B is at the max, so just use a.\n backbuffer.Elements[bufferIndex] = entries.Elements[aIndex++];\n }\n else\n {\n //A is at the max, so just use b.\n backbuffer.Elements[bufferIndex] = entries.Elements[bIndex++];\n }\n i++;\n }\n }\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/SortedGrid2DSet.cs",
"content": "using BEPUutilities.DataStructures;\nusing BEPUutilities.ResourceManagement;\n\nnamespace BEPUphysics.BroadPhaseSystems.SortAndSweep\n{\n internal class SortedGrid2DSet\n {\n //TODO: The cell set is the number one reason why Grid2DSortAndSweep fails in corner cases.\n //One option:\n //Instead of trying to maintain a sorted set, stick to a dictionary + RawList combo.\n //The update phase can add active cell-object pairs to a raw list. Could do bottom-up recreation too, though contention might be an issue.\n //Another option: Some other parallel-enumerable set, possibly with tricky hashing.\n\n internal RawList cells = new RawList();\n UnsafeResourcePool cellPool = new UnsafeResourcePool();\n\n internal int count;\n\n internal bool TryGetIndex(ref Int2 cellIndex, out int index, out int sortingHash)\n {\n sortingHash = cellIndex.GetSortingHash();\n int minIndex = 0; //inclusive\n int maxIndex = count; //exclusive\n index = 0;\n while (maxIndex - minIndex > 0) //If the testing interval has a length of zero, we've done as much as we can.\n {\n index = (maxIndex + minIndex) / 2;\n if (cells.Elements[index].sortingHash > sortingHash)\n maxIndex = index;\n else if (cells.Elements[index].sortingHash < sortingHash)\n minIndex = ++index;\n else\n {\n //Found an equal sorting hash!\n //The hash can collide, and we cannot add an entry to \n //an incorrect index. It would break the 'cell responsibility' \n //used by the cell update process to avoid duplicate overlaps.\n //So, check if the index we found is ACTUALLY correct.\n if (cells.Elements[index].cellIndex.Y == cellIndex.Y && cells.Elements[index].cellIndex.Z == cellIndex.Z)\n {\n return true;\n }\n //If it was not the correct index, let it continue searching.\n }\n\n }\n return false;\n }\n\n internal bool TryGetCell(ref Int2 cellIndex, out GridCell2D cell)\n {\n int index;\n int sortingHash;\n if (TryGetIndex(ref cellIndex, out index, out sortingHash))\n {\n cell = cells.Elements[index];\n return true;\n }\n cell = null;\n return false;\n }\n\n internal void Add(ref Int2 index, Grid2DEntry entry)\n {\n int cellIndex;\n int sortingHash;\n if (TryGetIndex(ref index, out cellIndex, out sortingHash))\n {\n cells.Elements[cellIndex].Add(entry);\n return;\n }\n var cell = cellPool.Take();\n cell.Initialize(ref index, sortingHash);\n cell.Add(entry);\n cells.Insert(cellIndex, cell);\n count++;\n\n ////Take an index. See if it's taken in the set.\n ////If it's already there, then add the entry to the cell.\n ////If it's not already there, create a new cell and add the entry to the cell and insert it at the index located.\n\n //int sortingHash = index.GetSortingHash();\n //int minIndex = 0; //inclusive\n //int maxIndex = count; //exclusive\n //int i = 0;\n //while (maxIndex - minIndex > 0) //If the testing interval has a length of zero, we've done as much as we can.\n //{\n // i = (maxIndex + minIndex) / 2;\n // if (cells.Elements[i].sortingHash > sortingHash)\n // maxIndex = i;\n // else if (cells.Elements[i].sortingHash < sortingHash)\n // minIndex = ++i;\n // else\n // {\n // //Found an equal sorting hash!\n // //The hash can collide, and we cannot add an entry to \n // //an incorrect index. It would break the 'cell responsibility' \n // //used by the cell update process to avoid duplicate overlaps.\n // //So, check if the index we found is ACTUALLY correct.\n // if (cells.Elements[i].cellIndex.Y == index.Y && cells.Elements[i].cellIndex.Z == index.Z)\n // {\n // cells.Elements[i].Add(entry);\n // return;\n // }\n // //If it was not the correct index, let it continue searching.\n // }\n\n //}\n //var cell = cellPool.Take();\n //cell.Initialize(ref index, sortingHash);\n //cell.Add(entry);\n //cells.Insert(i, cell);\n //count++;\n\n }\n\n internal void Remove(ref Int2 index, Grid2DEntry entry)\n {\n int cellIndex;\n int sortingHash;\n if (TryGetIndex(ref index, out cellIndex, out sortingHash))\n {\n cells.Elements[cellIndex].Remove(entry);\n if (cells.Elements[cellIndex].entries.Count == 0)\n {\n //The cell is now empty. Give it back to the pool.\n var toRemove = cells.Elements[cellIndex];\n //There's no cleanup to do on the grid cell.\n //Its list is empty, and the rest is just value types.\n cells.RemoveAt(cellIndex);\n cellPool.GiveBack(toRemove);\n count--;\n }\n }\n\n\n //int sortingHash = index.GetSortingHash();\n //int minIndex = 0; //inclusive\n //int maxIndex = count; //exclusive\n //int i = 0;\n //while (maxIndex - minIndex > 0) //If the testing interval has a length of zero, we've done as much as we can.\n //{\n // i = (maxIndex + minIndex) / 2;\n // if (cells.Elements[i].sortingHash > sortingHash)\n // maxIndex = i;\n // else if (cells.Elements[i].sortingHash < sortingHash)\n // minIndex = ++i;\n // else\n // {\n // //Found an equal sorting hash!\n // //The hash can collide, and we cannot add an entry to \n // //an incorrect index. It would break the 'cell responsibility' \n // //used by the cell update process to avoid duplicate overlaps.\n // //So, check if the index we found is ACTUALLY correct.\n // if (cells.Elements[i].cellIndex.Y == index.Y && cells.Elements[i].cellIndex.Z == index.Z)\n // {\n // cells.Elements[i].Remove(entry);\n // if (cells.Elements[i].entries.count == 0)\n // {\n // //The cell is now empty. Give it back to the pool.\n // var toRemove = cells.Elements[i];\n // //There's no cleanup to do on the grid cell.\n // //Its list is empty, and the rest is just value types.\n // cells.RemoveAt(i);\n // cellPool.GiveBack(toRemove);\n // count--;\n // }\n // return;\n // }\n // //If it was not the correct index, let it continue searching.\n // }\n\n //}\n ////Getting here should be impossible.\n\n }\n\n\n\n }\n}\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Testing/SortAndSweep3D.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUutilities.DataStructures;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.BroadPhaseSystems.SortAndSweep.Testing\n{\n internal class SortAndSweep3D : BroadPhase\n {\n RawList entriesX = new RawList();\n RawList entriesY = new RawList();\n RawList entriesZ = new RawList();\n\n public override void Add(BroadPhaseEntry entry)\n {\n base.Add(entry);\n //binary search for the approximately correct location. This helps prevent large first-frame sort times.\n //X Axis:\n int minIndex = 0; //inclusive\n int maxIndex = entriesX.Count; //exclusive\n int index = 0;\n while (maxIndex - minIndex > 0)\n {\n index = (maxIndex + minIndex) / 2;\n if (entriesX.Elements[index].boundingBox.Min.X > entry.boundingBox.Min.X)\n maxIndex = index;\n else if (entriesX.Elements[index].boundingBox.Min.X < entry.boundingBox.Min.X)\n minIndex = ++index;\n else\n break; //Found an equal value!\n }\n entriesX.Insert(index, entry);\n\n //Y Axis:\n minIndex = 0; //inclusive\n maxIndex = entriesY.Count; //exclusive\n while (maxIndex - minIndex > 0)\n {\n index = (maxIndex + minIndex) / 2;\n if (entriesY.Elements[index].boundingBox.Min.Y > entry.boundingBox.Min.Y)\n maxIndex = index;\n else if (entriesY.Elements[index].boundingBox.Min.Y < entry.boundingBox.Min.Y)\n minIndex = ++index;\n else\n break; //Found an equal value!\n }\n entriesY.Insert(index, entry);\n\n //Z Axis:\n minIndex = 0; //inclusive\n maxIndex = entriesZ.Count; //exclusive\n while (maxIndex - minIndex > 0)\n {\n index = (maxIndex + minIndex) / 2;\n if (entriesZ.Elements[index].boundingBox.Min.Z > entry.boundingBox.Min.Z)\n maxIndex = index;\n else if (entriesZ.Elements[index].boundingBox.Min.Z < entry.boundingBox.Min.Z)\n minIndex = ++index;\n else\n break; //Found an equal value!\n }\n entriesZ.Insert(index, entry);\n }\n\n public override void Remove(BroadPhaseEntry entry)\n {\n base.Remove(entry);\n entriesX.Remove(entry);\n entriesY.Remove(entry);\n entriesZ.Remove(entry);\n }\n\n protected override void UpdateMultithreaded()\n {\n UpdateSingleThreaded();\n }\n\n HashSet overlapCandidatesX = new HashSet