< Summary

Line coverage
100%
Covered lines: 214
Uncovered lines: 0
Coverable lines: 214
Total lines: 536
Line coverage: 100%
Branch coverage
100%
Covered branches: 106
Total branches: 106
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%1414100%
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%22100%
File 1: AddContact(...)100%1212100%
File 1: CopyFrom(...)100%66100%
File 1: HasSameContacts(...)100%1414100%
File 1: SameConstraint(...)100%2020100%
File 1: SamePoint(...)100%22100%
File 1: ReferencesSuppliers(...)100%88100%
File 1: ClearContacts()100%22100%
File 1: GetEnumerator()100%11100%
File 1: System.Collections.Generic.IEnumerable<Gravitas.CollisionHandling.ManifoldContact2D>.GetEnumerator()100%11100%
File 1: System.Collections.IEnumerable.GetEnumerator()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/2D/ContactManifold2D.cs

#LineLine coverage
 1//=======================================================================
 2// ContactManifold2D.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 two 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 ContactManifold2D : IEnumerable<ManifoldContact2D>
 27{
 28    /// <summary>Maximum number of point samples retained per geometric surface group.</summary>
 29    public const int MaxContactsPerGroup = 2;
 30
 31    /// <summary>Maximum samples in the default group; independent groups have no pair-wide cap.</summary>
 32    public const int MaxContactCount = MaxContactsPerGroup;
 33
 34    private ContactGroup2D _firstGroup;
 35    private SwiftCollections.SwiftList<ContactGroup2D>? _additionalGroups;
 36    private int _count;
 37    internal bool NeedsSurfaceRecovery;
 189838    private long _lastUpdatedFrame = -1;
 39
 40    /// <summary>Number of independent surface regions currently retained; this has no fixed pair-wide cap.</summary>
 41    public int GroupCount { get; private set; }
 42
 43    /// <summary>Gets the first flattened point index of a group in canonical structural order.</summary>
 44    public int GetGroupStartIndex(int groupIndex)
 45    {
 646        ChronicleGuard.ThrowIfListIndexInvalid(groupIndex, GroupCount);
 647        int start = 0;
 2448        for (int i = 0; i < groupIndex; i++)
 649            start += GetGroup(i).Count;
 650        return start;
 51    }
 52
 53    /// <summary>Gets the number of retained samples in a group, from one through <see cref="MaxContactsPerGroup"/>.</su
 54    public int GetGroupContactCount(int groupIndex)
 55    {
 656        ChronicleGuard.ThrowIfListIndexInvalid(groupIndex, GroupCount);
 657        return GetGroup(groupIndex).Count;
 58    }
 59
 60    internal ref ContactGroup2D GetGroup(int index)
 61    {
 16329662        if (index == 0) return ref _firstGroup;
 1074863        return ref _additionalGroups!.InnerArray[index - 1];
 64    }
 65
 66    internal int FindGroup(in ContactGroupKey key)
 67    {
 1881068        int low = 0, high = GroupCount - 1;
 964869        while (low <= high)
 70        {
 963971            int middle = low + ((high - low) >> 1);
 963972            int order = GetGroup(middle).Key.CompareTo(key);
 1903573            if (order == 0) return middle;
 40674            if (order < 0) low = middle + 1;
 8075            else high = middle - 1;
 76        }
 977        return -1;
 78    }
 79
 80    internal void ReserveGroups(int capacity)
 81    {
 92682        ChronicleGuard.ThrowIfNegative(capacity, nameof(capacity));
 112483        if (capacity <= 1) return;
 72884        _additionalGroups ??= new SwiftCollections.SwiftList<ContactGroup2D>(capacity - 1);
 72885        _additionalGroups.EnsureCapacity(capacity - 1);
 72886    }
 87
 88    /// <summary>
 89    /// Total number of active samples across all groups, without a fixed pair-wide cap.
 90    /// </summary>
 91    public int Count
 92    {
 93        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1407694        get => _count;
 95    }
 96
 97    /// <summary>
 98    /// Gets whether this manifold currently contains narrow-phase contact data.
 99    /// </summary>
 100    public bool HasContact
 101    {
 102        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 37331103        get => _count > 0;
 104    }
 105
 106    /// <summary>
 107    /// Simulation frame in which the active contacts were last rebuilt.
 108    /// </summary>
 109    public long LastUpdatedFrame
 110    {
 111        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 6336112        get => _lastUpdatedFrame;
 113    }
 114
 115    /// <summary>
 116    /// Deepest contact in the manifold. Ties use the lowest contact identity.
 117    /// </summary>
 118    public ManifoldContact2D PrimaryContact
 119    {
 120        get
 121        {
 180122            ChronicleGuard.ThrowIfListIndexInvalid(0, _count);
 123
 180124            ManifoldContact2D best = _firstGroup[0];
 776125            foreach (ManifoldContact2D candidate in this)
 126            {
 208127                if (candidate.Depth > best.Depth
 208128                    || candidate.Depth == best.Depth && (candidate.DepthIsClamped && !best.DepthIsClamped
 208129                    || candidate.DepthIsClamped == best.DepthIsClamped && candidate.ContactId < best.ContactId))
 130                {
 4131                    best = candidate;
 132                }
 133            }
 134
 180135            return best;
 136        }
 137    }
 138
 139    /// <summary>Gets a contact in flattened structural-group/ascending-contact-identity order.</summary>
 140    public ManifoldContact2D this[int index]
 141    {
 142        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 143        get
 144        {
 7172145            ChronicleGuard.ThrowIfListIndexInvalid(index, _count);
 7756146            for (int group = 0; ; group++)
 147            {
 7756148                ref ContactGroup2D current = ref GetGroup(group);
 14928149                if (index < current.Count) return current[index];
 584150                index -= current.Count;
 151            }
 152        }
 153    }
 154
 155    /// <summary>
 156    /// Clears contacts and records the frame for a new narrow-phase pass.
 157    /// </summary>
 158    public void BeginUpdate(long frame)
 159    {
 8066160        ClearContacts();
 8066161        _lastUpdatedFrame = frame;
 8066162    }
 163
 164    /// <summary>
 165    /// Clears all contact data.
 166    /// </summary>
 167    public void Reset()
 168    {
 3384169        ClearContacts();
 3384170        _lastUpdatedFrame = -1;
 3384171    }
 172
 173    /// <summary>
 174    /// Replaces the manifold with one contact.
 175    /// </summary>
 176    public void SetContact(Vector2d pointA, Vector2d pointB, Fixed64 depth, Vector2d normal)
 177    {
 151178        ClearContacts();
 151179        AddContact(pointA, pointB, depth, normal);
 151180    }
 181
 182    /// <summary>
 183    /// Replaces the manifold with one rigid-frame contact.
 184    /// </summary>
 185    public void SetContact(
 186        ContactAnchor2D anchorA,
 187        ContactAnchor2D anchorB,
 188        Fixed64 depth,
 189        Vector2d normal,
 190        bool depthIsClamped = false)
 191    {
 14192        ClearContacts();
 14193        AddContact(anchorA, anchorB, depth, normal, depthIsClamped);
 14194    }
 195
 196    /// <summary>
 197    /// Adds a contact, keeping up to two samples in the default surface group and exposing them by stable contact ident
 198    /// </summary>
 199    public void AddContact(Vector2d pointA, Vector2d pointB, Fixed64 depth, Vector2d normal)
 200    {
 218201        AddContact(
 218202            ContactAnchor2D.FromWorldPoint(pointA),
 218203            ContactAnchor2D.FromWorldPoint(pointB),
 218204            depth,
 218205            normal);
 218206    }
 207
 208    /// <summary>
 209    /// Adds a rigid-frame contact, keeping up to two samples in the default surface group and
 210    /// exposing them by stable anchor identity.
 211    /// </summary>
 212    public void AddContact(
 213        ContactAnchor2D anchorA,
 214        ContactAnchor2D anchorB,
 215        Fixed64 depth,
 216        Vector2d normal,
 217        bool depthIsClamped = false)
 218    {
 239219        AddContactCore(
 239220            anchorA,
 239221            anchorB,
 239222            depth,
 239223            normal,
 239224            hasMaterialOverride: false,
 239225            default,
 239226            default,
 239227            depthIsClamped,
 239228            featureNamespaceA: 0,
 239229            featureNamespaceB: 0);
 239230    }
 231
 232    internal void AddContact(
 233        Vector2d pointA,
 234        Vector2d pointB,
 235        Fixed64 depth,
 236        Vector2d normal,
 237        PhysicsMaterial materialA,
 238        PhysicsMaterial materialB,
 239        bool depthIsClamped = false)
 240    {
 2241        AddContactCore(
 2242            ContactAnchor2D.FromWorldPoint(pointA),
 2243            ContactAnchor2D.FromWorldPoint(pointB),
 2244            depth,
 2245            normal,
 2246            hasMaterialOverride: true,
 2247            materialA,
 2248            materialB,
 2249            depthIsClamped,
 2250            featureNamespaceA: 0,
 2251            featureNamespaceB: 0);
 2252    }
 253
 254    internal void AddContact(
 255        ContactAnchor2D anchorA,
 256        ContactAnchor2D anchorB,
 257        Fixed64 depth,
 258        Vector2d normal,
 259        PhysicsMaterial materialA,
 260        PhysicsMaterial materialB,
 261        bool depthIsClamped = false,
 262        int featureNamespaceA = 0,
 263        int featureNamespaceB = 0,
 264        ContactGroupKey group = default)
 265    {
 10947266        AddContactCore(
 10947267            anchorA,
 10947268            anchorB,
 10947269            depth,
 10947270            normal,
 10947271            hasMaterialOverride: true,
 10947272            materialA,
 10947273            materialB,
 10947274            depthIsClamped,
 10947275            featureNamespaceA,
 10947276            featureNamespaceB,
 10947277            group);
 10947278    }
 279
 280    private void AddContactCore(
 281        ContactAnchor2D anchorA,
 282        ContactAnchor2D anchorB,
 283        Fixed64 depth,
 284        Vector2d normal,
 285        bool hasMaterialOverride,
 286        PhysicsMaterial materialA,
 287        PhysicsMaterial materialB,
 288        bool depthIsClamped,
 289        int featureNamespaceA,
 290        int featureNamespaceB,
 291        ContactGroupKey group = default)
 292    {
 11188293        ulong contactId = CreateContactId(
 11188294            anchorA,
 11188295            featureNamespaceA,
 11188296            anchorB,
 11188297            featureNamespaceB);
 11188298        var contact = new ManifoldContact2D(
 11188299            contactId,
 11188300            anchorA,
 11188301            anchorB,
 11188302            depth,
 11188303            normal,
 11188304            hasMaterialOverride,
 11188305            materialA,
 11188306            materialB,
 11188307            depthIsClamped,
 11188308            featureNamespaceA,
 11188309            featureNamespaceB);
 310
 311        // Ordinary compound parts share the established two-sample owner pool;
 312        // only declared structural groups retain independent constraints.
 11188313        AddContact(group.CompareTo(default) == 0 ? default
 11188314            : group.Remap(featureNamespaceA, featureNamespaceB, reverse: false), contact);
 11188315    }
 316
 317    internal void AddContact(in ContactGroupKey key, in ManifoldContact2D contact)
 318    {
 11308319        if (GroupCount == 0)
 320        {
 321            // BeginUpdate already cleared the inline group; avoid clearing its
 322            // two large anchors again on every ordinary first contact.
 9046323            _firstGroup.Key = key;
 9046324            _count = _firstGroup.Add(contact);
 9046325            GroupCount = 1;
 9046326            return;
 327        }
 2262328        int group = 0;
 3557329        while (group < GroupCount && GetGroup(group).Key.CompareTo(key) < 0)
 1295330            group++;
 2262331        if (group == GroupCount || GetGroup(group).Key.CompareTo(key) != 0)
 332        {
 642333            ReserveGroups(GroupCount + 1);
 642334            _additionalGroups!.Add(default);
 1334335            for (int i = GroupCount; i > group; i--)
 25336                GetGroup(i) = GetGroup(i - 1);
 642337            GetGroup(group) = new ContactGroup2D { Key = key };
 642338            GroupCount++;
 339        }
 2262340        _count += GetGroup(group).Add(contact);
 2262341    }
 342
 343    internal void CopyFrom(ContactManifold2D source, long frame)
 344    {
 288345        if (ReferenceEquals(this, source)) return;
 284346        BeginUpdate(frame);
 284347        ReserveGroups(source.GroupCount);
 1546348        for (int i = 0; i < source.GroupCount; i++)
 349        {
 769350            if (i == 0) _firstGroup = source.GetGroup(i);
 209351            else _additionalGroups!.Add(source.GetGroup(i));
 352        }
 284353        GroupCount = source.GroupCount;
 284354        _count = source._count;
 284355        NeedsSurfaceRecovery = source.NeedsSurfaceRecovery;
 284356    }
 357
 358    internal bool HasSameContacts(ContactManifold2D source)
 359    {
 51360        if (GroupCount != source.GroupCount || NeedsSurfaceRecovery != source.NeedsSurfaceRecovery) return false;
 100361        for (int group = 0; group < GroupCount; group++)
 362        {
 39363            ref ContactGroup2D previous = ref GetGroup(group);
 39364            ref ContactGroup2D incoming = ref source.GetGroup(group);
 43365            if (previous.Key.CompareTo(incoming.Key) != 0 || previous.Count != incoming.Count) return false;
 88366            for (int index = 0; index < previous.Count; index++)
 61367                if (!SameConstraint(previous[index], incoming[index])) return false;
 368        }
 11369        return true;
 370    }
 371
 372    private static bool SameConstraint(in ManifoldContact2D previous, in ManifoldContact2D incoming) =>
 35373        previous.ContactId == incoming.ContactId && previous.FeatureNamespaceA == incoming.FeatureNamespaceA
 35374        && previous.FeatureNamespaceB == incoming.FeatureNamespaceB && previous.Normal == incoming.Normal
 35375        && previous.Depth == incoming.Depth && previous.DepthIsClamped == incoming.DepthIsClamped
 35376        && previous.HasMaterialOverride == incoming.HasMaterialOverride
 35377        && previous.MaterialA == incoming.MaterialA && previous.MaterialB == incoming.MaterialB
 35378        && SamePoint(previous.AnchorA, incoming.AnchorA) && SamePoint(previous.AnchorB, incoming.AnchorB);
 379
 380    private static bool SamePoint(in ContactAnchor2D previous, in ContactAnchor2D incoming)
 381    {
 30382        ExactLever3D delta = previous.GetXZLeverFrom(incoming);
 30383        return delta.XNumerator.IsZero && delta.ZNumerator.IsZero;
 384    }
 385
 386    internal bool ReferencesSuppliers(SwiftCollections.SwiftHashSet<int> suppliers, bool first, int fallbackSource)
 387    {
 164388        for (int group = 0; group < GroupCount; group++)
 389        {
 68390            ContactGroupKey key = GetGroup(group).Key;
 68391            int source = first ? key.SourceIdA : key.SourceIdB;
 128392            if (suppliers.Contains(source == 0 ? fallbackSource : source)) return true;
 393        }
 14394        return false;
 395    }
 396
 397    private void ClearContacts()
 398    {
 11615399        _count = GroupCount = 0;
 11615400        NeedsSurfaceRecovery = false;
 11615401        _firstGroup = default;
 11615402        _additionalGroups?.FastClear();
 1764403    }
 404
 405    /// <summary>Returns an allocation-free enumerator over the active contacts.</summary>
 511406    public Enumerator GetEnumerator() => new(this);
 407
 107408    IEnumerator<ManifoldContact2D> IEnumerable<ManifoldContact2D>.GetEnumerator() => GetEnumerator();
 10409    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 410
 411    private static ulong CreateContactId(
 412        ContactAnchor2D anchorA,
 413        int featureNamespaceA,
 414        ContactAnchor2D anchorB,
 415        int featureNamespaceB)
 416    {
 11188417        if (CompareLocalFeature(
 11188418                featureNamespaceB,
 11188419                anchorB,
 11188420                featureNamespaceA,
 11188421                anchorA) < 0)
 422        {
 6416423            (anchorA, anchorB) = (anchorB, anchorA);
 6416424            (featureNamespaceA, featureNamespaceB) =
 6416425                (featureNamespaceB, featureNamespaceA);
 426        }
 427
 11188428        ulong hash = 14695981039346656037UL;
 11188429        Mix(ref hash, featureNamespaceA);
 11188430        MixLocalFeature(ref hash, anchorA);
 11188431        Mix(ref hash, featureNamespaceB);
 11188432        MixLocalFeature(ref hash, anchorB);
 11188433        return hash;
 434    }
 435
 436    private static int CompareLocalFeature(
 437        int leftNamespace,
 438        ContactAnchor2D left,
 439        int rightNamespace,
 440        ContactAnchor2D right)
 441    {
 11188442        int comparison = leftNamespace.CompareTo(rightNamespace);
 11188443        return comparison != 0
 11188444            ? comparison
 11188445            : left.CompareLocalFeature(right);
 446    }
 447
 448    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 449    private static void Mix(ref ulong hash, long value)
 450    {
 451        unchecked
 452        {
 44752453            hash ^= (ulong)value;
 44752454            hash *= 1099511628211UL;
 455        }
 44752456    }
 457
 458    private static void MixLocalFeature(
 459        ref ulong hash,
 460        ContactAnchor2D anchor)
 461    {
 22376462        Mix(
 22376463            ref hash,
 22376464            unchecked((long)anchor.GetLocalFeatureHash64()));
 22376465    }
 466
 467
 468}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Contacts/2D/ContactManifold2D.Enumerator.cs

#LineLine coverage
 1//=======================================================================
 2// ContactManifold2D.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 ContactManifold2D
 15{
 16    /// <summary>Enumerates the active contacts in deterministic order.</summary>
 17    public struct Enumerator : IEnumerator<ManifoldContact2D>
 18    {
 19        private readonly ContactManifold2D _manifold;
 20        private int _group, _point;
 21        private int _index;
 22
 23        internal Enumerator(ContactManifold2D manifold)
 24        {
 51125            _manifold = manifold;
 51126            _group = _point = 0;
 51127            _index = -1;
 51128        }
 29
 30        /// <summary>Gets the current contact.</summary>
 31        public ManifoldContact2D Current
 32        {
 33            get
 34            {
 65735                ChronicleGuard.ThrowIfListIndexInvalid(_index, _manifold.Count);
 65736                return _manifold.GetGroup(_group)[_point];
 37            }
 38        }
 39
 340        object IEnumerator.Current => Current;
 41
 42        /// <summary>Advances to the next active contact.</summary>
 43        public bool MoveNext()
 44        {
 103345            int next = _index + 1;
 103346            if (next >= _manifold._count)
 39247                return false;
 48
 64149            if (_index >= 0 && ++_point >= _manifold.GetGroup(_group).Count)
 50            {
 5951                _group++;
 5952                _point = 0;
 53            }
 64154            _index = next;
 64155            return true;
 56        }
 57
 58        /// <summary>Resets the enumerator to its initial position.</summary>
 59        public void Reset()
 60        {
 161            _group = _point = 0;
 162            _index = -1;
 163        }
 64
 65        /// <summary>Releases enumerator resources.</summary>
 51066        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.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d)
SetContact(Gravitas.CollisionHandling.ContactAnchor2D,Gravitas.CollisionHandling.ContactAnchor2D,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,System.Boolean)
AddContact(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d)
AddContact(Gravitas.CollisionHandling.ContactAnchor2D,Gravitas.CollisionHandling.ContactAnchor2D,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,System.Boolean)
AddContact(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,Gravitas.Materials.PhysicsMaterial,Gravitas.Materials.PhysicsMaterial,System.Boolean)
AddContact(Gravitas.CollisionHandling.ContactAnchor2D,Gravitas.CollisionHandling.ContactAnchor2D,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,Gravitas.Materials.PhysicsMaterial,Gravitas.Materials.PhysicsMaterial,System.Boolean,System.Int32,System.Int32,Gravitas.CollisionHandling.ContactGroupKey)
AddContactCore(Gravitas.CollisionHandling.ContactAnchor2D,Gravitas.CollisionHandling.ContactAnchor2D,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,System.Boolean,Gravitas.Materials.PhysicsMaterial,Gravitas.Materials.PhysicsMaterial,System.Boolean,System.Int32,System.Int32,Gravitas.CollisionHandling.ContactGroupKey)
AddContact(Gravitas.CollisionHandling.ContactGroupKey&,Gravitas.CollisionHandling.ManifoldContact2D&)
CopyFrom(Gravitas.CollisionHandling.ContactManifold2D,System.Int64)
HasSameContacts(Gravitas.CollisionHandling.ContactManifold2D)
SameConstraint(Gravitas.CollisionHandling.ManifoldContact2D&,Gravitas.CollisionHandling.ManifoldContact2D&)
SamePoint(Gravitas.CollisionHandling.ContactAnchor2D&,Gravitas.CollisionHandling.ContactAnchor2D&)
ReferencesSuppliers(SwiftCollections.SwiftHashSet`1<System.Int32>,System.Boolean,System.Int32)
ClearContacts()
GetEnumerator()
System.Collections.Generic.IEnumerable<Gravitas.CollisionHandling.ManifoldContact2D>.GetEnumerator()
System.Collections.IEnumerable.GetEnumerator()
CreateContactId(Gravitas.CollisionHandling.ContactAnchor2D,System.Int32,Gravitas.CollisionHandling.ContactAnchor2D,System.Int32)
CompareLocalFeature(System.Int32,Gravitas.CollisionHandling.ContactAnchor2D,System.Int32,Gravitas.CollisionHandling.ContactAnchor2D)
Mix(System.UInt64&,System.Int64)
MixLocalFeature(System.UInt64&,Gravitas.CollisionHandling.ContactAnchor2D)
.ctor(Gravitas.CollisionHandling.ContactManifold2D)
get_Current()
System.Collections.IEnumerator.get_Current()
MoveNext()
Reset()
Dispose()