< Summary

Line coverage
100%
Covered lines: 210
Uncovered lines: 0
Coverable lines: 210
Total lines: 536
Line coverage: 100%
Branch coverage
100%
Covered branches: 102
Total branches: 102
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
File 1: .ctor()100%11100%
File 1: GetGroupStartIndex(...)100%22100%
File 1: GetGroupContactCount(...)100%11100%
File 1: GetGroup(...)100%22100%
File 1: FindGroup(...)100%66100%
File 1: ReserveGroups(...)100%44100%
File 1: get_Count()100%11100%
File 1: get_HasContact()100%11100%
File 1: get_LastUpdatedFrame()100%11100%
File 1: get_PrimaryContact()100%88100%
File 1: get_Item(...)100%22100%
File 1: BeginUpdate(...)100%11100%
File 1: Reset()100%11100%
File 1: SetContact(...)100%11100%
File 1: SetContact(...)100%11100%
File 1: AddContact(...)100%11100%
File 1: AddContact(...)100%11100%
File 1: AddContact(...)100%11100%
File 1: AddContact(...)100%11100%
File 1: AddContactCore(...)100%44100%
File 1: AddContact(...)100%1212100%
File 1: CopyFrom(...)100%66100%
File 1: HasSameContacts(...)100%1212100%
File 1: SameConstraint(...)100%2020100%
File 1: SamePoint(...)100%44100%
File 1: ReferencesSuppliers(...)100%88100%
File 1: ClearContacts()100%22100%
File 1: GetEnumerator()100%11100%
File 1: System.Collections.Generic.IEnumerable<Gravitas.CollisionHandling.ManifoldContact>.GetEnumerator()100%11100%
File 1: System.Collections.IEnumerable.GetEnumerator()100%11100%
File 1: RemapContactIdentity(...)100%11100%
File 1: CreateContactId(...)100%22100%
File 1: CompareLocalFeature(...)100%22100%
File 1: Mix(...)100%11100%
File 1: MixLocalFeature(...)100%11100%
File 2: .ctor(...)100%11100%
File 2: get_Current()100%11100%
File 2: System.Collections.IEnumerator.get_Current()100%11100%
File 2: MoveNext()100%66100%
File 2: Reset()100%11100%
File 2: Dispose()100%11100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Contacts/3D/ContactManifold.cs

#LineLine coverage
 1//=======================================================================
 2// ContactManifold.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System.Collections;
 9using System.Collections.Generic;
 10using System.Runtime.CompilerServices;
 11using FixedMathSharp;
 12using Gravitas.Materials;
 13
 14namespace Gravitas.CollisionHandling;
 15
 16/// <summary>
 17/// Pair-owned deterministic contact manifold with up to four samples per
 18/// geometric surface group and no fixed pair-wide group or contact limit.
 19/// </summary>
 20/// <remarks>
 21/// Inspection flattens canonical structural group order, then ascending contact
 22/// identity within each group. Index zero is not necessarily the deepest contact;
 23/// use <see cref="PrimaryContact"/> for that purpose. Overflow capacity is retained
 24/// across updates and resets; reaching a new high-water mark can allocate.
 25/// </remarks>
 26public sealed partial class ContactManifold : IEnumerable<ManifoldContact>
 27{
 28    /// <summary>Maximum number of point samples retained per geometric surface group.</summary>
 29    public const int MaxContactsPerGroup = 4;
 30
 31    private ContactGroup _firstGroup;
 32    private SwiftCollections.SwiftList<ContactGroup>? _additionalGroups;
 33    private int _count;
 7368634    private long _lastUpdatedFrame = -1;
 35
 36    /// <summary>Number of independent surface regions currently retained; this has no fixed pair-wide cap.</summary>
 37    public int GroupCount { get; private set; }
 38
 39    /// <summary>Gets the first flattened point index of a group in canonical structural order.</summary>
 40    public int GetGroupStartIndex(int groupIndex)
 41    {
 5442        ChronicleGuard.ThrowIfListIndexInvalid(groupIndex, GroupCount);
 5243        int start = 0;
 55444        for (int i = 0; i < groupIndex; i++)
 22545            start += GetGroup(i).Count;
 5246        return start;
 47    }
 48
 49    /// <summary>Gets the number of retained samples in a group, from one through <see cref="MaxContactsPerGroup"/>.</su
 50    public int GetGroupContactCount(int groupIndex)
 51    {
 8552        ChronicleGuard.ThrowIfListIndexInvalid(groupIndex, GroupCount);
 8353        return GetGroup(groupIndex).Count;
 54    }
 55
 56    internal ref ContactGroup GetGroup(int index)
 57    {
 684760258        if (index == 0) return ref _firstGroup;
 70318459        return ref _additionalGroups!.InnerArray[index - 1];
 60    }
 61
 62    internal int FindGroup(in ContactGroupKey key)
 63    {
 15877664        int low = 0, high = GroupCount - 1;
 9602265        while (low <= high)
 66        {
 9470967            int middle = low + ((high - low) >> 1);
 9470968            int order = GetGroup(middle).Key.CompareTo(key);
 17278469            if (order == 0) return middle;
 2994170            if (order < 0) low = middle + 1;
 332771            else high = middle - 1;
 72        }
 131373        return -1;
 74    }
 75
 76    internal void ReserveGroups(int capacity)
 77    {
 13705478        ChronicleGuard.ThrowIfNegative(capacity, nameof(capacity));
 25265379        if (capacity <= 1) return;
 2145180        _additionalGroups ??= new SwiftCollections.SwiftList<ContactGroup>(capacity - 1);
 2145181        _additionalGroups.EnsureCapacity(capacity - 1);
 2145182    }
 83
 84    /// <summary>
 85    /// Total number of active samples across all groups, without a fixed pair-wide cap.
 86    /// </summary>
 87    public int Count
 88    {
 89        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 20882090        get => _count;
 91    }
 92
 93    /// <summary>
 94    /// Gets whether this manifold currently contains narrow-phase contact data.
 95    /// </summary>
 96    public bool HasContact
 97    {
 98        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 45351899        get => _count > 0;
 100    }
 101
 102    /// <summary>
 103    /// Simulation frame in which the active contacts were last rebuilt.
 104    /// </summary>
 105    public long LastUpdatedFrame
 106    {
 107        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1688108        get => _lastUpdatedFrame;
 109    }
 110
 111    /// <summary>
 112    /// Deepest contact in the manifold. Ties use the lowest contact identity.
 113    /// </summary>
 114    public ManifoldContact PrimaryContact
 115    {
 116        get
 117        {
 26826118            ChronicleGuard.ThrowIfListIndexInvalid(0, _count);
 119
 26826120            ManifoldContact best = _firstGroup[0];
 162164121            foreach (ManifoldContact candidate in this)
 122            {
 54256123                if (candidate.Depth > best.Depth
 54256124                    || candidate.Depth == best.Depth && candidate.ContactId < best.ContactId)
 125                {
 984126                    best = candidate;
 127                }
 128            }
 129
 26826130            return best;
 131        }
 132    }
 133
 134    /// <summary>Gets a contact in flattened structural-group/ascending-contact-identity order.</summary>
 135    public ManifoldContact this[int index]
 136    {
 137        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 138        get
 139        {
 1767140            ChronicleGuard.ThrowIfListIndexInvalid(index, _count);
 7162141            for (int group = 0; ; group++)
 142            {
 7162143                ref ContactGroup current = ref GetGroup(group);
 8927144                if (index < current.Count) return current[index];
 5397145                index -= current.Count;
 146            }
 147        }
 148    }
 149
 150    /// <summary>
 151    /// Clears contacts and records the frame for a new narrow-phase pass.
 152    /// </summary>
 153    public void BeginUpdate(long frame)
 154    {
 138212155        ClearContacts();
 138212156        _lastUpdatedFrame = frame;
 138212157    }
 158
 159    /// <summary>
 160    /// Clears all contact data.
 161    /// </summary>
 162    public void Reset()
 163    {
 44520164        ClearContacts();
 44520165        _lastUpdatedFrame = -1;
 44520166    }
 167
 168    /// <summary>
 169    /// Replaces the manifold with one contact.
 170    /// </summary>
 171    public void SetContact(Vector3d pointA, Vector3d pointB, Fixed64 depth, Vector3d normal)
 172    {
 145173        ClearContacts();
 145174        AddContact(pointA, pointB, depth, normal);
 145175    }
 176
 177    /// <summary>
 178    /// Replaces the manifold with one rigid-frame contact.
 179    /// </summary>
 180    public void SetContact(
 181        ContactAnchor anchorA,
 182        ContactAnchor anchorB,
 183        Fixed64 depth,
 184        Vector3d normal,
 185        bool depthIsClamped = false)
 186    {
 12303187        ClearContacts();
 12303188        AddContact(anchorA, anchorB, depth, normal, depthIsClamped);
 12303189    }
 190
 191    /// <summary>
 192    /// Adds a contact, keeping up to four samples in the default surface group and exposing them by stable contact iden
 193    /// </summary>
 194    public void AddContact(Vector3d pointA, Vector3d pointB, Fixed64 depth, Vector3d normal)
 195    {
 5774196        AddContact(
 5774197            ContactAnchor.FromWorldPoint(pointA),
 5774198            ContactAnchor.FromWorldPoint(pointB),
 5774199            depth,
 5774200            normal);
 5774201    }
 202
 203    /// <summary>
 204    /// Adds a rigid-frame contact, keeping up to four samples in the default surface group and
 205    /// exposing them by stable anchor identity.
 206    /// </summary>
 207    public void AddContact(
 208        ContactAnchor anchorA,
 209        ContactAnchor anchorB,
 210        Fixed64 depth,
 211        Vector3d normal,
 212        bool depthIsClamped = false)
 213    {
 41685214        AddContactCore(
 41685215            anchorA,
 41685216            anchorB,
 41685217            depth,
 41685218            normal,
 41685219            hasMaterialOverride: false,
 41685220            default,
 41685221            default,
 41685222            depthIsClamped,
 41685223            featureNamespaceA: 0,
 41685224            featureNamespaceB: 0);
 41685225    }
 226
 227    internal void AddContact(
 228        Vector3d pointA,
 229        Vector3d pointB,
 230        Fixed64 depth,
 231        Vector3d normal,
 232        PhysicsMaterial materialA,
 233        PhysicsMaterial materialB,
 234        bool depthIsClamped = false)
 235    {
 1236        AddContactCore(
 1237            ContactAnchor.FromWorldPoint(pointA),
 1238            ContactAnchor.FromWorldPoint(pointB),
 1239            depth,
 1240            normal,
 1241            hasMaterialOverride: true,
 1242            materialA,
 1243            materialB,
 1244            depthIsClamped,
 1245            featureNamespaceA: 0,
 1246            featureNamespaceB: 0);
 1247    }
 248
 249    internal void AddContact(
 250        ContactAnchor anchorA,
 251        ContactAnchor anchorB,
 252        Fixed64 depth,
 253        Vector3d normal,
 254        PhysicsMaterial materialA,
 255        PhysicsMaterial materialB,
 256        bool depthIsClamped = false,
 257        int featureNamespaceA = 0,
 258        int featureNamespaceB = 0,
 259        ContactGroupKey group = default,
 260        int sampleIdentity = 0,
 261        ulong? contactIdentity = null)
 262    {
 173516263        AddContactCore(
 173516264            anchorA,
 173516265            anchorB,
 173516266            depth,
 173516267            normal,
 173516268            hasMaterialOverride: true,
 173516269            materialA,
 173516270            materialB,
 173516271            depthIsClamped,
 173516272            featureNamespaceA,
 173516273            featureNamespaceB,
 173516274            group, sampleIdentity, contactIdentity);
 173516275    }
 276
 277    private void AddContactCore(
 278        ContactAnchor anchorA,
 279        ContactAnchor anchorB,
 280        Fixed64 depth,
 281        Vector3d normal,
 282        bool hasMaterialOverride,
 283        PhysicsMaterial materialA,
 284        PhysicsMaterial materialB,
 285        bool depthIsClamped,
 286        int featureNamespaceA,
 287        int featureNamespaceB,
 288        ContactGroupKey group = default,
 289        int sampleIdentity = 0,
 290        ulong? contactIdentity = null)
 291    {
 215202292        ulong contactId = contactIdentity ?? CreateContactId(
 215202293            anchorA,
 215202294            featureNamespaceA,
 215202295            anchorB,
 215202296            featureNamespaceB);
 297        // A continuous normal family can share paired anchors at zero depth.
 298        // Keep its reduced directions as distinct rows inside one feature group.
 216148299        if (sampleIdentity != 0) Mix(ref contactId, sampleIdentity);
 215202300        var contact = new ManifoldContact(
 215202301            contactId,
 215202302            anchorA,
 215202303            anchorB,
 215202304            depth,
 215202305            normal,
 215202306            hasMaterialOverride,
 215202307            materialA,
 215202308            materialB,
 215202309            depthIsClamped,
 215202310            featureNamespaceA,
 215202311            featureNamespaceB);
 312
 215202313        AddContact(group.Remap(featureNamespaceA, featureNamespaceB, reverse: false), contact);
 215202314    }
 315
 316    internal void AddContact(in ContactGroupKey key, in ManifoldContact contact)
 317    {
 257823318        int group = 0;
 322443319        while (group < GroupCount && GetGroup(group).Key.CompareTo(key) < 0)
 64620320            group++;
 257823321        if (group == GroupCount || GetGroup(group).Key.CompareTo(key) != 0)
 322        {
 113741323            ReserveGroups(GroupCount + 1);
 113741324            if (GroupCount > 0)
 325            {
 20450326                _additionalGroups!.Add(default);
 108256327                for (int i = GroupCount; i > group; i--)
 33678328                    GetGroup(i) = GetGroup(i - 1);
 329            }
 113741330            GetGroup(group) = new ContactGroup { Key = key };
 113741331            GroupCount++;
 332        }
 257823333        _count += GetGroup(group).Add(contact);
 257823334    }
 335
 336    internal void CopyFrom(ContactManifold source, long frame)
 337    {
 17606338        if (ReferenceEquals(this, source)) return;
 17596339        BeginUpdate(frame);
 17596340        ReserveGroups(source.GroupCount);
 69404341        for (int i = 0; i < source.GroupCount; i++)
 342        {
 33181343            if (i == 0) _firstGroup = source.GetGroup(i);
 1031344            else _additionalGroups!.Add(source.GetGroup(i));
 345        }
 17596346        GroupCount = source.GroupCount;
 17596347        _count = source._count;
 17596348    }
 349
 350    internal bool HasSameContacts(ContactManifold source)
 351    {
 51352        if (GroupCount != source.GroupCount) return false;
 106353        for (int group = 0; group < GroupCount; group++)
 354        {
 45355            ref ContactGroup previous = ref GetGroup(group);
 45356            ref ContactGroup incoming = ref source.GetGroup(group);
 52357            if (previous.Key.CompareTo(incoming.Key) != 0 || previous.Count != incoming.Count) return false;
 96358            for (int index = 0; index < previous.Count; index++)
 70359                if (!SameConstraint(previous[index], incoming[index])) return false;
 360        }
 8361        return true;
 362    }
 363
 364    private static bool SameConstraint(in ManifoldContact previous, in ManifoldContact incoming) =>
 40365        previous.ContactId == incoming.ContactId && previous.FeatureNamespaceA == incoming.FeatureNamespaceA
 40366        && previous.FeatureNamespaceB == incoming.FeatureNamespaceB && previous.Normal == incoming.Normal
 40367        && previous.Depth == incoming.Depth && previous.DepthIsClamped == incoming.DepthIsClamped
 40368        && previous.HasMaterialOverride == incoming.HasMaterialOverride
 40369        && previous.MaterialA == incoming.MaterialA && previous.MaterialB == incoming.MaterialB
 40370        && SamePoint(previous.AnchorA, incoming.AnchorA) && SamePoint(previous.AnchorB, incoming.AnchorB);
 371
 372    private static bool SamePoint(in ContactAnchor previous, in ContactAnchor incoming)
 373    {
 38374        ExactLever3D delta = previous.GetLeverFrom(incoming);
 38375        return delta.XNumerator.IsZero && delta.YNumerator.IsZero && delta.ZNumerator.IsZero;
 376    }
 377
 378    internal bool ReferencesSuppliers(SwiftCollections.SwiftHashSet<int> suppliers, bool first, int fallbackSource)
 379    {
 450380        for (int group = 0; group < GroupCount; group++)
 381        {
 127382            ContactGroupKey key = GetGroup(group).Key;
 127383            int source = first ? key.SourceIdA : key.SourceIdB;
 241384            if (suppliers.Contains(source == 0 ? fallbackSource : source)) return true;
 385        }
 98386        return false;
 387    }
 388
 389    private void ClearContacts()
 390    {
 195180391        _count = GroupCount = 0;
 195180392        _firstGroup = default;
 195180393        _additionalGroups?.FastClear();
 35383394    }
 395
 396    /// <summary>Returns an allocation-free enumerator over the active contacts.</summary>
 46476397    public Enumerator GetEnumerator() => new(this);
 398
 328399    IEnumerator<ManifoldContact> IEnumerable<ManifoldContact>.GetEnumerator() => GetEnumerator();
 100400    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 401
 402    internal static ulong RemapContactIdentity(ulong contactId, int namespaceA, int namespaceB)
 403    {
 404        // Group provenance carries the ordered owners. Identity remains
 405        // invariant when compound dispatch reverses the paired anchors.
 25730406        Mix(ref contactId, System.Math.Min(namespaceA, namespaceB));
 25730407        Mix(ref contactId, System.Math.Max(namespaceA, namespaceB));
 25730408        return contactId;
 409    }
 410
 411    internal static ulong CreateContactId(
 412        ContactAnchor anchorA,
 413        int featureNamespaceA,
 414        ContactAnchor anchorB,
 415        int featureNamespaceB)
 416    {
 200228417        if (CompareLocalFeature(
 200228418                featureNamespaceB,
 200228419                anchorB,
 200228420                featureNamespaceA,
 200228421                anchorA) < 0)
 422        {
 93165423            (anchorA, anchorB) = (anchorB, anchorA);
 93165424            (featureNamespaceA, featureNamespaceB) =
 93165425                (featureNamespaceB, featureNamespaceA);
 426        }
 427
 200228428        ulong hash = 14695981039346656037UL;
 200228429        Mix(ref hash, featureNamespaceA);
 200228430        MixLocalFeature(ref hash, anchorA);
 200228431        Mix(ref hash, featureNamespaceB);
 200228432        MixLocalFeature(ref hash, anchorB);
 200228433        return hash;
 434    }
 435
 436    private static int CompareLocalFeature(
 437        int leftNamespace,
 438        ContactAnchor left,
 439        int rightNamespace,
 440        ContactAnchor right)
 441    {
 200228442        int comparison = leftNamespace.CompareTo(rightNamespace);
 200228443        return comparison != 0
 200228444            ? comparison
 200228445            : left.CompareLocalFeature(right);
 446    }
 447
 448    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 449    private static void Mix(ref ulong hash, long value)
 450    {
 451        unchecked
 452        {
 853318453            hash ^= (ulong)value;
 853318454            hash *= 1099511628211UL;
 455        }
 853318456    }
 457
 458    private static void MixLocalFeature(
 459        ref ulong hash,
 460        ContactAnchor anchor)
 461    {
 400456462        Mix(
 400456463            ref hash,
 400456464            unchecked((long)anchor.GetLocalFeatureHash64()));
 400456465    }
 466
 467
 468}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Contacts/3D/ContactManifold.Enumerator.cs

#LineLine coverage
 1//=======================================================================
 2// ContactManifold.Enumerator.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System.Collections;
 9using System.Collections.Generic;
 10
 11namespace Gravitas.CollisionHandling;
 12
 13/// <content>Defines the nested Enumerator type.</content>
 14public sealed partial class ContactManifold
 15{
 16    /// <summary>Enumerates the active contacts in deterministic order.</summary>
 17    public struct Enumerator : IEnumerator<ManifoldContact>
 18    {
 19        private readonly ContactManifold _manifold;
 20        private int _group, _point;
 21        private int _index;
 22
 23        internal Enumerator(ContactManifold manifold)
 24        {
 4647625            _manifold = manifold;
 4647626            _group = _point = 0;
 4647627            _index = -1;
 4647628        }
 29
 30        /// <summary>Gets the current contact.</summary>
 31        public ManifoldContact Current
 32        {
 33            get
 34            {
 8760435                ChronicleGuard.ThrowIfListIndexInvalid(_index, _manifold.Count);
 8760336                return _manifold.GetGroup(_group)[_point];
 37            }
 38        }
 39
 740        object IEnumerator.Current => Current;
 41
 42        /// <summary>Advances to the next active contact.</summary>
 43        public bool MoveNext()
 44        {
 11868145            int next = _index + 1;
 11868146            if (next >= _manifold._count)
 3091047                return false;
 48
 8777149            if (_index >= 0 && ++_point >= _manifold.GetGroup(_group).Count)
 50            {
 541451                _group++;
 541452                _point = 0;
 53            }
 8777154            _index = next;
 8777155            return true;
 56        }
 57
 58        /// <summary>Resets the enumerator to its initial position.</summary>
 59        public void Reset()
 60        {
 361            _group = _point = 0;
 362            _index = -1;
 363        }
 64
 65        /// <summary>Releases enumerator resources.</summary>
 4647366        public void Dispose() { }
 67    }
 68}

Methods/Properties

.ctor()
GetGroupStartIndex(System.Int32)
GetGroupContactCount(System.Int32)
GetGroup(System.Int32)
FindGroup(Gravitas.CollisionHandling.ContactGroupKey&)
ReserveGroups(System.Int32)
get_Count()
get_HasContact()
get_LastUpdatedFrame()
get_PrimaryContact()
get_Item(System.Int32)
BeginUpdate(System.Int64)
Reset()
SetContact(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d)
SetContact(Gravitas.CollisionHandling.ContactAnchor,Gravitas.CollisionHandling.ContactAnchor,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,System.Boolean)
AddContact(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d)
AddContact(Gravitas.CollisionHandling.ContactAnchor,Gravitas.CollisionHandling.ContactAnchor,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,System.Boolean)
AddContact(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Materials.PhysicsMaterial,Gravitas.Materials.PhysicsMaterial,System.Boolean)
AddContact(Gravitas.CollisionHandling.ContactAnchor,Gravitas.CollisionHandling.ContactAnchor,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,Gravitas.Materials.PhysicsMaterial,Gravitas.Materials.PhysicsMaterial,System.Boolean,System.Int32,System.Int32,Gravitas.CollisionHandling.ContactGroupKey,System.Int32,System.Nullable`1<System.UInt64>)
AddContactCore(Gravitas.CollisionHandling.ContactAnchor,Gravitas.CollisionHandling.ContactAnchor,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,System.Boolean,Gravitas.Materials.PhysicsMaterial,Gravitas.Materials.PhysicsMaterial,System.Boolean,System.Int32,System.Int32,Gravitas.CollisionHandling.ContactGroupKey,System.Int32,System.Nullable`1<System.UInt64>)
AddContact(Gravitas.CollisionHandling.ContactGroupKey&,Gravitas.CollisionHandling.ManifoldContact&)
CopyFrom(Gravitas.CollisionHandling.ContactManifold,System.Int64)
HasSameContacts(Gravitas.CollisionHandling.ContactManifold)
SameConstraint(Gravitas.CollisionHandling.ManifoldContact&,Gravitas.CollisionHandling.ManifoldContact&)
SamePoint(Gravitas.CollisionHandling.ContactAnchor&,Gravitas.CollisionHandling.ContactAnchor&)
ReferencesSuppliers(SwiftCollections.SwiftHashSet`1<System.Int32>,System.Boolean,System.Int32)
ClearContacts()
GetEnumerator()
System.Collections.Generic.IEnumerable<Gravitas.CollisionHandling.ManifoldContact>.GetEnumerator()
System.Collections.IEnumerable.GetEnumerator()
RemapContactIdentity(System.UInt64,System.Int32,System.Int32)
CreateContactId(Gravitas.CollisionHandling.ContactAnchor,System.Int32,Gravitas.CollisionHandling.ContactAnchor,System.Int32)
CompareLocalFeature(System.Int32,Gravitas.CollisionHandling.ContactAnchor,System.Int32,Gravitas.CollisionHandling.ContactAnchor)
Mix(System.UInt64&,System.Int64)
MixLocalFeature(System.UInt64&,Gravitas.CollisionHandling.ContactAnchor)
.ctor(Gravitas.CollisionHandling.ContactManifold)
get_Current()
System.Collections.IEnumerator.get_Current()
MoveNext()
Reset()
Dispose()