< Summary

Information
Class: Gravitas.GravitasConstraint3DService
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/Constraints/3D/GravitasConstraint3DService.cs
Line coverage
100%
Covered lines: 364
Uncovered lines: 0
Coverable lines: 364
Total lines: 645
Line coverage: 100%
Branch coverage
100%
Covered branches: 148
Total branches: 148
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Constraints/3D/GravitasConstraint3DService.cs

#LineLine coverage
 1//=======================================================================
 2// GravitasConstraint3DService.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;
 9using Chronicler.Hashing;
 10using FixedMathSharp;
 11using Gravitas.Colliders;
 12using Gravitas.Constraints;
 13using SwiftCollections;
 14
 15namespace Gravitas;
 16
 17/// <summary>
 18/// Owns deterministic 3D joints and ragdoll articulation state for one world context.
 19/// </summary>
 20public sealed class GravitasConstraint3DService
 21{
 22    private const int DefaultJointCapacity = 64;
 23
 24    private readonly GravitasWorldContext _context;
 1019125    private readonly ConstraintEndpointJointIndex<SolidBody> _jointIdsByBody = new();
 1019126    private readonly SwiftDictionary<SolidBody, RagdollRuntime3D> _ragdollByBody = new();
 1019127    private readonly SwiftDictionary<int, RagdollRuntime3D> _ragdollsById = new();
 1019128    private readonly SwiftDictionary<ulong, int> _suppressedColliderPairs = new();
 1019129    private Joint3D?[] _joints = new Joint3D?[DefaultJointCapacity];
 30    private RagdollRuntime3D? _firstRagdoll;
 31    private RagdollRuntime3D? _lastRagdoll;
 32    private int _nextRagdollId;
 33    private int _registeredRagdollCount;
 34    private int _enabledJointCount;
 35
 1019136    internal GravitasConstraint3DService(GravitasWorldContext context)
 37    {
 1019138        ChronicleGuard.ThrowIfNull(context, nameof(context));
 1019139        _context = context;
 1019140    }
 41
 42    /// <summary>
 43    /// Gets the owning world context.
 44    /// </summary>
 37245    public GravitasWorldContext Context => _context;
 46
 47    /// <summary>
 48    /// Gets the highest joint ID allocated in this context.
 49    /// </summary>
 50    public int PeakJointCount { get; private set; }
 51
 52    /// <summary>
 53    /// Gets the number of registered active joints.
 54    /// </summary>
 55    public int RegisteredJointCount { get; private set; }
 56
 57    /// <summary>
 58    /// Gets the number of registered ragdoll runtimes.
 59    /// </summary>
 1160    public int RegisteredRagdollCount => _registeredRagdollCount;
 61
 1262    internal int EnabledJointCount => _enabledJointCount;
 63
 6306664    internal bool HasActiveJoints => _enabledJointCount > 0;
 65
 66    internal void ClearSolverCachesForBody(SolidBody body)
 67    {
 79068        if (!_jointIdsByBody.TryGetLast(body, out int jointId))
 75869            return;
 70
 171        while (true)
 72        {
 3373            _joints[jointId]!.ClearSolverCache();
 3374            if (!_jointIdsByBody.TryGetPrevious(body, jointId, out int previousJointId))
 3275                return;
 76
 177            jointId = previousJointId;
 78        }
 79    }
 80
 81    /// <summary>
 82    /// Registers a context-owned deterministic 3D joint.
 83    /// </summary>
 84    public Joint3D RegisterJoint(in JointDefinition3D definition)
 85    {
 38186        _context.ThrowIfDisposed();
 38087        ValidateDefinition(definition);
 37288        JointFrame3D frameA = JointFrame3D.FromTransform(definition.LocalFrameA, nameof(definition.LocalFrameA));
 37289        JointFrame3D frameB = JointFrame3D.FromTransform(definition.LocalFrameB, nameof(definition.LocalFrameB));
 90
 37291        int id = ++PeakJointCount;
 37292        EnsureJointCapacity(id + 1);
 37293        var joint = new Joint3D(this, id, definition, frameA, frameB);
 37294        _joints[id] = joint;
 37295        _jointIdsByBody.Add(joint.BodyA, joint.BodyB, id);
 37296        RegisteredJointCount++;
 37297        _enabledJointCount++;
 98
 37299        if (joint.CollisionPolicy == JointCollisionPolicy.SuppressLinked)
 340100            AddSuppressedColliderPair(joint.BodyA.Collider, joint.BodyB.Collider);
 101
 372102        _context.Diagnostics.EmitJointRegistered(joint);
 372103        return joint;
 104    }
 105
 106    /// <summary>
 107    /// Removes a context-owned joint and releases its filter state.
 108    /// </summary>
 109    public bool RemoveJoint(int jointId)
 110    {
 14111        _context.ThrowIfDisposed();
 13112        if (!TryGetJoint(jointId, out Joint3D? joint))
 1113            return false;
 114
 12115        ChronicleGuard.ThrowIfTrue(
 12116            joint!.OwningRagdoll?.IsRegistered == true,
 12117            nameof(jointId),
 12118            "Ragdoll-owned joints cannot be removed independently. Remove the owning ragdoll instead.");
 11119        return RemoveJointCore(joint);
 120    }
 121
 122    private bool RemoveJointCore(Joint3D joint)
 123    {
 29124        int jointId = joint.Id;
 29125        _joints[jointId] = null;
 29126        _jointIdsByBody.Remove(jointId);
 29127        RegisteredJointCount--;
 29128        if (joint.IsEnabled)
 28129            _enabledJointCount--;
 29130        joint.IsActive = false;
 29131        joint.ClearSolverCache();
 29132        if (joint.CollisionPolicy == JointCollisionPolicy.SuppressLinked)
 28133            RemoveSuppressedColliderPair(joint.BodyA.Collider, joint.BodyB.Collider);
 134
 29135        _context.Diagnostics.EmitJointRemoved(joint);
 29136        return true;
 137    }
 138
 139    /// <summary>
 140    /// Gets a registered joint by context-local ID.
 141    /// </summary>
 142    public Joint3D GetJoint(int jointId)
 143    {
 18144        if (!TryGetJoint(jointId, out Joint3D? joint))
 1145            throw new ArgumentOutOfRangeException(nameof(jointId), "No active joint exists with the supplied ID.");
 146
 17147        return joint!;
 148    }
 149
 150    /// <summary>
 151    /// Tries to get a registered joint by context-local ID.
 152    /// </summary>
 153    public bool TryGetJoint(int jointId, out Joint3D? joint)
 154    {
 36125155        if ((uint)jointId >= (uint)_joints.Length)
 156        {
 4157            joint = null;
 4158            return false;
 159        }
 160
 36121161        joint = _joints[jointId];
 36121162        return joint != null && joint.IsActive;
 163    }
 164
 165    /// <summary>
 166    /// Registers a ragdoll articulation and its owned joints.
 167    /// </summary>
 168    public RagdollRuntime3D RegisterRagdoll(RagdollDefinition3D definition)
 169    {
 45170        _context.ThrowIfDisposed();
 45171        ValidateRagdollDefinition(definition);
 172
 41173        int linkCount = definition.Links.Length;
 41174        var links = new SolidBody[linkCount];
 296175        for (int i = 0; i < linkCount; i++)
 107176            links[i] = definition.Links[i].Body;
 177
 41178        int jointCount = definition.Joints.Length;
 41179        var joints = new Joint3D[jointCount];
 214180        for (int i = 0; i < jointCount; i++)
 181        {
 66182            RagdollJointDefinition3D authoredJoint = definition.Joints[i];
 66183            SolidBody bodyA = ResolveRagdollLink(definition.Links, authoredJoint.LinkAId);
 66184            SolidBody bodyB = ResolveRagdollLink(definition.Links, authoredJoint.LinkBId);
 66185            JointCollisionPolicy collisionPolicy = definition.SelfCollisionPolicy == RagdollSelfCollisionPolicy.CollideA
 66186                ? JointCollisionPolicy.Collide
 66187                : authoredJoint.CollisionPolicy;
 188
 66189            joints[i] = RegisterJoint(new JointDefinition3D(
 66190                bodyA,
 66191                bodyB,
 66192                authoredJoint.LocalFrameA,
 66193                authoredJoint.LocalFrameB,
 66194                authoredJoint.Type,
 66195                authoredJoint.Limits,
 66196                authoredJoint.Motor,
 66197                collisionPolicy));
 198        }
 199
 41200        if (definition.SelfCollisionPolicy == RagdollSelfCollisionPolicy.SuppressAllLinks)
 10201            AddAllRagdollPairSuppressions(links);
 202
 41203        var runtime = new RagdollRuntime3D(
 41204            this,
 41205            ++_nextRagdollId,
 41206            links,
 41207            joints,
 41208            definition.SelfCollisionPolicy,
 41209            startsActive: !HasKinematicLink(links));
 41210        AppendRagdoll(runtime);
 41211        _ragdollsById.Add(runtime.Id, runtime);
 296212        for (int i = 0; i < links.Length; i++)
 107213            _ragdollByBody.Add(links[i], runtime);
 214214        for (int i = 0; i < joints.Length; i++)
 66215            joints[i].OwningRagdoll = runtime;
 41216        return runtime;
 217    }
 218
 219    /// <summary>
 220    /// Removes a registered ragdoll and every joint and collision suppression it owns.
 221    /// </summary>
 222    public bool RemoveRagdoll(int ragdollId)
 223    {
 9224        _context.ThrowIfDisposed();
 9225        if (!_ragdollsById.TryGetValue(ragdollId, out RagdollRuntime3D? ragdoll))
 2226            return false;
 227
 7228        RemoveRagdollCore(ragdoll);
 7229        return true;
 230    }
 231
 232    /// <summary>
 233    /// Updates a joint motor target while preserving the joint's authored motor gains and impulse cap.
 234    /// </summary>
 235    public bool SetJointMotorTarget(int jointId, FixedQuaternion targetLocalRotation)
 236    {
 2237        _context.ThrowIfDisposed();
 2238        if (!TryGetJoint(jointId, out Joint3D? joint))
 1239            return false;
 240
 1241        JointMotor3D current = joint!.Motor;
 1242        joint.SetMotor(new JointMotor3D(
 1243            targetLocalRotation,
 1244            current.AngularDriveStrength,
 1245            current.AngularDriveDamping,
 1246            current.MaximumMotorImpulse));
 1247        return true;
 248    }
 249
 250    /// <summary>
 251    /// Disables a joint motor target and clears its cached solver impulses.
 252    /// </summary>
 253    public bool ClearJointMotorTarget(int jointId)
 254    {
 2255        _context.ThrowIfDisposed();
 2256        if (!TryGetJoint(jointId, out Joint3D? joint))
 1257            return false;
 258
 1259        joint!.ClearMotor();
 1260        return true;
 261    }
 262
 263    /// <summary>
 264    /// Applies caller-owned motor payloads to every joint in a ragdoll runtime.
 265    /// </summary>
 266    public void SetRagdollPoseTargets(RagdollRuntime3D ragdoll, ReadOnlySpan<JointMotor3D> motors)
 267    {
 4268        _context.ThrowIfDisposed();
 4269        ChronicleGuard.ThrowIfNull(ragdoll, nameof(ragdoll));
 4270        ChronicleGuard.ThrowIfArgument(
 4271            !ReferenceEquals(ragdoll.Service, this),
 4272            nameof(ragdoll),
 4273            "Ragdoll targets must be applied through the owning constraint service.");
 3274        ChronicleGuard.ThrowIfTrue(
 3275            !ragdoll.IsRegistered,
 3276            nameof(ragdoll),
 3277            "Removed ragdolls cannot mutate simulation state.");
 1278        ChronicleGuard.ThrowIfArgument(
 1279            motors.Length != ragdoll.JointCount,
 1280            nameof(motors),
 1281            "Ragdoll pose target count must match the ragdoll joint count.");
 282
 4283        for (int i = 0; i < motors.Length; i++)
 284        {
 1285            Joint3D joint = ragdoll.GetJoint(i);
 1286            joint.SetMotor(motors[i]);
 287        }
 1288    }
 289
 290    /// <summary>
 291    /// Gets whether the supplied 3D colliders should be excluded because a registered articulation links them.
 292    /// </summary>
 293    public bool ShouldExcludeLinkedCollision(LSCollider colliderA, LSCollider colliderB)
 294    {
 3069616295        if (colliderA == null || colliderB == null)
 2296            return false;
 3069614297        if (colliderA.Id < 0 || colliderB.Id < 0 || colliderA.Id == colliderB.Id)
 7748298            return false;
 299
 3061866300        return _suppressedColliderPairs.ContainsKey(CreateColliderPairKey(colliderA.Id, colliderB.Id));
 301    }
 302
 303    internal bool TryGetJointForSolver(int jointId, out Joint3D? joint)
 304    {
 34529305        if (!TryGetJoint(jointId, out joint))
 12306            return false;
 307
 34517308        if (!joint!.IsEnabled || !joint.HasSolverParticipant())
 309        {
 4310            joint = null;
 4311            return false;
 312        }
 313
 34513314        return true;
 315    }
 316
 317    internal void RemoveJointsForBody(SolidBody body)
 318    {
 168319        if (_ragdollByBody.TryGetValue(body, out RagdollRuntime3D? ragdoll))
 3320            RemoveRagdollCore(ragdoll);
 321
 180322        while (_jointIdsByBody.TryGetLast(body, out int jointId))
 12323            RemoveJointCore(GetJoint(jointId));
 168324    }
 325
 326    internal void UpdateJointCollisionPolicy(
 327        Joint3D joint,
 328        JointCollisionPolicy oldPolicy,
 329        JointCollisionPolicy newPolicy)
 330    {
 8331        if (!joint.IsActive || oldPolicy == newPolicy)
 3332            return;
 333
 5334        if (oldPolicy == JointCollisionPolicy.SuppressLinked)
 4335            RemoveSuppressedColliderPair(joint.BodyA.Collider, joint.BodyB.Collider);
 5336        if (newPolicy == JointCollisionPolicy.SuppressLinked)
 1337            AddSuppressedColliderPair(joint.BodyA.Collider, joint.BodyB.Collider);
 5338    }
 339
 340    internal void UpdateJointEnabledState(
 341        Joint3D joint,
 342        bool oldEnabled,
 343        bool newEnabled)
 344    {
 22345        if (!joint.IsActive || oldEnabled == newEnabled)
 1346            return;
 347
 21348        _enabledJointCount += newEnabled ? 1 : -1;
 21349    }
 350
 351    internal void Reset()
 352    {
 10304353        RagdollRuntime3D? ragdoll = _firstRagdoll;
 10335354        while (ragdoll != null)
 355        {
 31356            RagdollRuntime3D? next = ragdoll.NextRegistered;
 31357            ragdoll.Invalidate();
 31358            ragdoll = next;
 359        }
 360
 21352361        for (int i = 1; i <= PeakJointCount && i < _joints.Length; i++)
 362        {
 372363            Joint3D? joint = _joints[i];
 372364            if (joint == null)
 365                continue;
 366
 343367            joint.IsActive = false;
 343368            joint.ClearSolverCache();
 343369            joint.OwningRagdoll = null;
 343370            _joints[i] = null;
 371        }
 372
 10304373        _suppressedColliderPairs.Clear();
 10304374        _jointIdsByBody.Clear();
 10304375        _ragdollByBody.Clear();
 10304376        _ragdollsById.Clear();
 10304377        _firstRagdoll = null;
 10304378        _lastRagdoll = null;
 10304379        PeakJointCount = 0;
 10304380        RegisteredJointCount = 0;
 10304381        _registeredRagdollCount = 0;
 10304382        _enabledJointCount = 0;
 10304383        _nextRagdollId = 0;
 10304384    }
 385
 386    internal void ContributeReplayHash(
 387        ref ChronicleHashWriter writer,
 388        GravitasReplayHashMode mode)
 389    {
 3877390        writer.WriteSection("constraints.3d", 1);
 3877391        writer.WriteInt32(PeakJointCount);
 3877392        writer.WriteInt32(RegisteredJointCount);
 10852393        for (int jointId = 1; jointId <= PeakJointCount; jointId++)
 394        {
 1549395            bool hasJoint = TryGetJoint(jointId, out Joint3D? joint);
 1549396            writer.WriteBool(hasJoint);
 1549397            if (hasJoint)
 1544398                joint!.ContributeReplayHash(ref writer, mode);
 399        }
 400
 3877401        writer.WriteInt32(_registeredRagdollCount);
 3877402        for (RagdollRuntime3D? ragdoll = _firstRagdoll;
 3950403             ragdoll != null;
 73404             ragdoll = ragdoll.NextRegistered)
 405        {
 73406            writer.WriteInt32(ragdoll.Id);
 73407            writer.WriteEnum(ragdoll.SelfCollisionPolicy);
 73408            writer.WriteBool(ragdoll.IsActive);
 73409            writer.WriteInt32(ragdoll.LinkCount);
 73410            writer.WriteInt32(ragdoll.JointCount);
 411        }
 3877412    }
 413
 414    internal static ulong CreateColliderPairKey(int colliderAId, int colliderBId)
 415    {
 3062324416        uint min = (uint)(colliderAId <= colliderBId ? colliderAId : colliderBId);
 3062324417        uint max = (uint)(colliderAId <= colliderBId ? colliderBId : colliderAId);
 3062324418        return ((ulong)min << 32) | max;
 419    }
 420
 421    private void EnsureJointCapacity(int required)
 422    {
 372423        if (required <= _joints.Length)
 371424            return;
 425
 1426        int newSize = _joints.Length;
 2427        while (newSize < required)
 1428            newSize *= 2;
 429
 1430        Array.Resize(ref _joints, newSize);
 1431    }
 432
 433    private void ValidateDefinition(in JointDefinition3D definition)
 434    {
 448435        ChronicleGuard.ThrowIfNull(definition.BodyA, nameof(definition.BodyA));
 448436        ChronicleGuard.ThrowIfNull(definition.BodyB, nameof(definition.BodyB));
 448437        ChronicleGuard.ThrowIfNull(definition.LocalFrameA, nameof(definition.LocalFrameA));
 447438        ChronicleGuard.ThrowIfNull(definition.LocalFrameB, nameof(definition.LocalFrameB));
 447439        ChronicleGuard.ThrowIfArgument(
 447440            ReferenceEquals(definition.BodyA, definition.BodyB),
 447441            nameof(definition),
 447442            "A joint cannot link a body to itself.");
 446443        ChronicleGuard.ThrowIfArgument(
 446444            !ReferenceEquals(definition.BodyA.Context, _context) || !ReferenceEquals(definition.BodyB.Context, _context)
 446445            nameof(definition),
 446446            "Both joint bodies must belong to this constraint service context.");
 444447        ChronicleGuard.ThrowIfArgument(
 444448            !definition.BodyA.Active || !definition.BodyB.Active,
 444449            nameof(definition),
 444450            "Joint bodies must be active before registration.");
 442451        ChronicleGuard.ThrowIfArgument(
 442452            !Joint3D.IsSupportedType(definition.Type),
 442453            nameof(definition.Type),
 442454            "Unsupported 3D joint type.");
 442455        ChronicleGuard.ThrowIfArgument(
 442456            definition.CollisionPolicy != JointCollisionPolicy.SuppressLinked
 442457                && definition.CollisionPolicy != JointCollisionPolicy.Collide,
 442458            nameof(definition.CollisionPolicy),
 442459            "Unsupported joint collision policy.");
 441460        definition.Limits.Validate();
 441461        definition.Motor.Validate();
 441462        Joint3D.ValidatePayload(definition.Type, definition.Limits);
 439463    }
 464
 465    private void ValidateRagdollDefinition(RagdollDefinition3D definition)
 466    {
 45467        ChronicleGuard.ThrowIfNull(definition, nameof(definition));
 45468        ChronicleGuard.ThrowIfNull(definition.Links, nameof(definition.Links));
 45469        ChronicleGuard.ThrowIfNull(definition.Joints, nameof(definition.Joints));
 45470        ChronicleGuard.ThrowIfArgument(definition.Links.Length == 0, nameof(definition.Links), "A ragdoll must contain a
 45471        ChronicleGuard.ThrowIfArgument(
 45472            definition.SelfCollisionPolicy != RagdollSelfCollisionPolicy.SuppressAdjacentLinks
 45473                && definition.SelfCollisionPolicy != RagdollSelfCollisionPolicy.CollideAllLinks
 45474                && definition.SelfCollisionPolicy != RagdollSelfCollisionPolicy.SuppressAllLinks,
 45475            nameof(definition.SelfCollisionPolicy),
 45476            "Unsupported ragdoll self-collision policy.");
 477
 314478        for (int i = 0; i < definition.Links.Length; i++)
 479        {
 114480            RagdollLinkDefinition3D link = definition.Links[i];
 114481            ChronicleGuard.ThrowIfNull(link.Body, nameof(definition.Links));
 114482            ChronicleGuard.ThrowIfNull(link.Collider, nameof(definition.Links));
 114483            ChronicleGuard.ThrowIfArgument(
 114484                !ReferenceEquals(link.Body.Context, _context),
 114485                nameof(definition.Links),
 114486                "All ragdoll links must belong to this context.");
 114487            ChronicleGuard.ThrowIfArgument(
 114488                !link.Body.Active,
 114489                nameof(definition.Links),
 114490                "Ragdoll links must have active 3D colliders.");
 114491            ChronicleGuard.ThrowIfArgument(
 114492                !ReferenceEquals(link.Body.Collider, link.Collider),
 114493                nameof(definition.Links),
 114494                "Ragdoll link collider must match the link body's collider.");
 114495            ChronicleGuard.ThrowIfArgument(
 114496                _ragdollByBody.ContainsKey(link.Body),
 114497                nameof(definition.Links),
 114498                "A body cannot belong to more than one registered ragdoll.");
 499
 532500            for (int j = i + 1; j < definition.Links.Length; j++)
 501            {
 154502                ChronicleGuard.ThrowIfArgument(
 154503                    link.LinkId == definition.Links[j].LinkId,
 154504                    nameof(definition.Links),
 154505                    "Ragdoll link IDs must be unique.");
 154506                ChronicleGuard.ThrowIfArgument(
 154507                    ReferenceEquals(link.Body, definition.Links[j].Body),
 154508                    nameof(definition.Links),
 154509                    "Ragdoll bodies must be unique.");
 510            }
 511        }
 512
 220513        for (int i = 0; i < definition.Joints.Length; i++)
 514        {
 69515            RagdollJointDefinition3D joint = definition.Joints[i];
 69516            SolidBody bodyA = ResolveRagdollLink(definition.Links, joint.LinkAId);
 69517            SolidBody bodyB = ResolveRagdollLink(definition.Links, joint.LinkBId);
 68518            ChronicleGuard.ThrowIfArgument(
 68519                joint.LinkAId == joint.LinkBId,
 68520                nameof(definition.Joints),
 68521                "A ragdoll joint cannot link a body to itself.");
 68522            JointCollisionPolicy collisionPolicy = definition.SelfCollisionPolicy == RagdollSelfCollisionPolicy.CollideA
 68523                ? JointCollisionPolicy.Collide
 68524                : joint.CollisionPolicy;
 68525            ValidateDefinition(new JointDefinition3D(
 68526                bodyA,
 68527                bodyB,
 68528                joint.LocalFrameA,
 68529                joint.LocalFrameB,
 68530                joint.Type,
 68531                joint.Limits,
 68532                joint.Motor,
 68533                collisionPolicy));
 534        }
 41535    }
 536
 537    private static SolidBody ResolveRagdollLink(RagdollLinkDefinition3D[] links, int linkId)
 538    {
 1360539        for (int i = 0; i < links.Length; i++)
 540        {
 679541            if (links[i].LinkId == linkId)
 269542                return links[i].Body;
 543        }
 544
 1545        throw new ArgumentException("Ragdoll joint references an unknown link ID.", nameof(linkId));
 546    }
 547
 548    private static bool HasKinematicLink(SolidBody[] links)
 549    {
 282550        for (int i = 0; i < links.Length; i++)
 551        {
 104552            if (links[i].IsKinematic)
 4553                return true;
 554        }
 555
 37556        return false;
 557    }
 558
 559    private void AddAllRagdollPairSuppressions(SolidBody[] links)
 560    {
 102561        for (int i = 0; i < links.Length; i++)
 562        {
 246563            for (int j = i + 1; j < links.Length; j++)
 82564                AddSuppressedColliderPair(links[i].Collider, links[j].Collider);
 565        }
 10566    }
 567
 568    private void RemoveRagdollCore(RagdollRuntime3D ragdoll)
 569    {
 10570        _ragdollsById.Remove(ragdoll.Id);
 52571        for (int i = 0; i < ragdoll.LinkCount; i++)
 16572            _ragdollByBody.Remove(ragdoll.GetLink(i));
 573
 10574        if (ragdoll.SelfCollisionPolicy == RagdollSelfCollisionPolicy.SuppressAllLinks)
 575        {
 8576            for (int i = 0; i < ragdoll.LinkCount; i++)
 577            {
 12578                for (int j = i + 1; j < ragdoll.LinkCount; j++)
 579                {
 3580                    RemoveSuppressedColliderPair(
 3581                        ragdoll.GetLink(i).Collider,
 3582                        ragdoll.GetLink(j).Collider);
 583                }
 584            }
 585        }
 586
 10587        UnlinkRagdoll(ragdoll);
 10588        ragdoll.Invalidate();
 589
 32590        for (int i = 0; i < ragdoll.JointCount; i++)
 591        {
 6592            Joint3D joint = ragdoll.GetJoint(i);
 6593            joint.OwningRagdoll = null;
 6594            RemoveJointCore(joint);
 595        }
 10596    }
 597
 598    private void AppendRagdoll(RagdollRuntime3D ragdoll)
 599    {
 41600        ragdoll.PreviousRegistered = _lastRagdoll;
 41601        if (_lastRagdoll == null)
 34602            _firstRagdoll = ragdoll;
 603        else
 7604            _lastRagdoll.NextRegistered = ragdoll;
 605
 41606        _lastRagdoll = ragdoll;
 41607        _registeredRagdollCount++;
 41608    }
 609
 610    private void UnlinkRagdoll(RagdollRuntime3D ragdoll)
 611    {
 10612        if (ragdoll.PreviousRegistered == null)
 9613            _firstRagdoll = ragdoll.NextRegistered;
 614        else
 1615            ragdoll.PreviousRegistered.NextRegistered = ragdoll.NextRegistered;
 616
 10617        if (ragdoll.NextRegistered == null)
 5618            _lastRagdoll = ragdoll.PreviousRegistered;
 619        else
 5620            ragdoll.NextRegistered.PreviousRegistered = ragdoll.PreviousRegistered;
 621
 10622        _registeredRagdollCount--;
 10623    }
 624
 625    private void AddSuppressedColliderPair(LSCollider colliderA, LSCollider colliderB)
 626    {
 423627        ulong key = CreateColliderPairKey(colliderA.Id, colliderB.Id);
 423628        if (_suppressedColliderPairs.TryGetValue(key, out int count))
 110629            _suppressedColliderPairs[key] = count + 1;
 630        else
 313631            _suppressedColliderPairs.Add(key, 1);
 313632    }
 633
 634    private void RemoveSuppressedColliderPair(LSCollider colliderA, LSCollider colliderB)
 635    {
 35636        ulong key = CreateColliderPairKey(colliderA.Id, colliderB.Id);
 35637        if (!_suppressedColliderPairs.TryGetValue(key, out int count))
 1638            return;
 639
 34640        if (count <= 1)
 27641            _suppressedColliderPairs.Remove(key);
 642        else
 7643            _suppressedColliderPairs[key] = count - 1;
 7644    }
 645}

Methods/Properties

.ctor(Gravitas.GravitasWorldContext)
get_Context()
get_RegisteredRagdollCount()
get_EnabledJointCount()
get_HasActiveJoints()
ClearSolverCachesForBody(Gravitas.SolidBody)
RegisterJoint(Gravitas.Constraints.JointDefinition3D&)
RemoveJoint(System.Int32)
RemoveJointCore(Gravitas.Constraints.Joint3D)
GetJoint(System.Int32)
TryGetJoint(System.Int32,Gravitas.Constraints.Joint3D&)
RegisterRagdoll(Gravitas.Constraints.RagdollDefinition3D)
RemoveRagdoll(System.Int32)
SetJointMotorTarget(System.Int32,FixedMathSharp.FixedQuaternion)
ClearJointMotorTarget(System.Int32)
SetRagdollPoseTargets(Gravitas.Constraints.RagdollRuntime3D,System.ReadOnlySpan`1<Gravitas.Constraints.JointMotor3D>)
ShouldExcludeLinkedCollision(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider)
TryGetJointForSolver(System.Int32,Gravitas.Constraints.Joint3D&)
RemoveJointsForBody(Gravitas.SolidBody)
UpdateJointCollisionPolicy(Gravitas.Constraints.Joint3D,Gravitas.Constraints.JointCollisionPolicy,Gravitas.Constraints.JointCollisionPolicy)
UpdateJointEnabledState(Gravitas.Constraints.Joint3D,System.Boolean,System.Boolean)
Reset()
ContributeReplayHash(Chronicler.Hashing.ChronicleHashWriter&,Gravitas.GravitasReplayHashMode)
CreateColliderPairKey(System.Int32,System.Int32)
EnsureJointCapacity(System.Int32)
ValidateDefinition(Gravitas.Constraints.JointDefinition3D&)
ValidateRagdollDefinition(Gravitas.Constraints.RagdollDefinition3D)
ResolveRagdollLink(Gravitas.Constraints.RagdollLinkDefinition3D[],System.Int32)
HasKinematicLink(Gravitas.SolidBody[])
AddAllRagdollPairSuppressions(Gravitas.SolidBody[])
RemoveRagdollCore(Gravitas.Constraints.RagdollRuntime3D)
AppendRagdoll(Gravitas.Constraints.RagdollRuntime3D)
UnlinkRagdoll(Gravitas.Constraints.RagdollRuntime3D)
AddSuppressedColliderPair(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider)
RemoveSuppressedColliderPair(Gravitas.Colliders.LSCollider,Gravitas.Colliders.LSCollider)