< Summary

Information
Class: Gravitas.Colliders.LSCircleCollider2D
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/Colliders/2D/Shapes/LSCircleCollider2D.cs
Line coverage
100%
Covered lines: 106
Uncovered lines: 0
Coverable lines: 106
Total lines: 201
Line coverage: 100%
Branch coverage
100%
Covered branches: 18
Total branches: 18
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
.ctor(...)100%11100%
get_Shape()100%11100%
get_Radius()100%11100%
set_Radius(...)100%22100%
get_ScaledRadius()100%11100%
ContainsPoint(...)100%11100%
GetClosestPoint(...)100%44100%
GetSupportPoint(...)100%66100%
CalculateAreaForMassProperties()100%11100%
CalculatePreparedAreaForMassProperties()100%11100%
CalculateCenterOfMassMoment(...)100%22100%
GetMassPropertyRadius()100%22100%
PrepareShape(...)100%11100%
PublishShape()100%11100%
CopyPreparedReconfiguration(...)100%11100%
RecordShapeData(...)100%22100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Colliders/2D/Shapes/LSCircleCollider2D.cs

#LineLine coverage
 1//=======================================================================
 2// LSCircleCollider2D.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.Runtime.CompilerServices;
 9using Chronicler;
 10using FixedMathSharp;
 11using FixedMathSharp.Geometry;
 12
 13namespace Gravitas.Colliders;
 14
 15/// <summary>
 16/// Pure 2D circle collider.
 17/// </summary>
 18public sealed class LSCircleCollider2D : LSCollider2D
 19{
 20    private Fixed64 _radius;
 21    private Fixed64 _scaledRadius;
 22    private Fixed64 _preparedRadius;
 23
 24    /// <summary>Creates a pure 2D circle with an authored radius.</summary>
 417625    public LSCircleCollider2D(Fixed64 radius)
 26    {
 417627        Radius = radius;
 417628    }
 29
 30    /// <summary>Creates a runtime circle from an authored shape definition.</summary>
 29931    public LSCircleCollider2D(ColliderShapeDefinition2D definition)
 32    {
 29933        definition.EnsureKind(ColliderShapeDefinition2DKind.Circle);
 29834        Material = definition.Material;
 29835        Radius = definition.Radius;
 29836    }
 37
 38    /// <inheritdoc/>
 6880039    public override ColliderType2D Shape => ColliderType2D.Circle;
 40
 41    /// <summary>Gets or sets the unscaled circle radius.</summary>
 42    public Fixed64 Radius
 43    {
 44        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 146445        get => _radius;
 46        set
 47        {
 451548            ChronicleGuard.ThrowIfArgument(value <= Fixed64.Zero, nameof(value), "2D circle radius must be greater than 
 451549            if (_radius == value)
 250                return;
 51
 451352            ValidateGeometryMutation(radius: value);
 450953            _radius = value;
 450954            MarkShapeDirty();
 450955        }
 56    }
 57
 58    /// <summary>Gets the radius after owner and compound-part scaling.</summary>
 59    public Fixed64 ScaledRadius
 60    {
 61        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 13264362        get => GetMassPropertyRadius();
 63    }
 64
 65    /// <inheritdoc/>
 66    public override bool ContainsPoint(Vector2d point) =>
 188067        FixedSegment2d.ContainsPointInCenteredCapsule(
 188068            point,
 188069            Center,
 188070            Vector2d.Forward,
 188071            Fixed64.Zero,
 188072            ScaledRadius,
 188073            Fixed64.Zero);
 74
 75    /// <inheritdoc/>
 76    public override Vector2d GetClosestPoint(Vector2d point)
 77    {
 378        if (TryGetClosestBoundaryAnchor(
 379                point,
 380                out FixedPointAnchor2d anchor)
 381            && anchor.TryGetPoint(out Vector2d closest))
 82        {
 283            return closest;
 84        }
 85
 186        throw new System.InvalidOperationException(
 187            "The closest circle surface point is outside the Fixed64 coordinate domain.");
 88    }
 89
 90    /// <inheritdoc/>
 91    public override Vector2d GetSupportPoint(Vector2d direction)
 92    {
 793        if (direction == Vector2d.Zero)
 194            direction = Vector2d.Right;
 95
 796        if (Vector2d.TryRotate(
 797                direction.Normalized,
 798                -Rotation,
 799                out Vector2d localDirection))
 100        {
 7101            FixedPointAnchor2d anchor =
 7102                FixedSegment2d.GetCenteredCapsuleSupportAnchor(
 7103                Center,
 7104                Rotation,
 7105                Vector2d.Forward,
 7106                Fixed64.Zero,
 7107                ScaledRadius,
 7108                localDirection);
 7109            if (anchor.TryGetPoint(out Vector2d support))
 5110                return support;
 111        }
 112
 2113        throw new System.InvalidOperationException(
 2114            "The circle support point is outside the Fixed64 coordinate domain.");
 115    }
 116
 117    internal override ExactMassWeight CalculateAreaForMassProperties()
 118    {
 525119        Fixed64 radius = GetMassPropertyRadius();
 525120        return ExactMassWeight.FromProduct(
 525121            Fixed64.Pi,
 525122            radius,
 525123            radius);
 124    }
 125
 126    internal override ExactMassWeight CalculatePreparedAreaForMassProperties() =>
 858127        ExactMassWeight.FromProduct(
 858128            Fixed64.Pi,
 858129            _preparedRadius,
 858130            _preparedRadius);
 131
 132    internal override Fixed64 CalculateCenterOfMassMoment(Fixed64 mass)
 133    {
 10174134        Fixed64 radius = GetMassPropertyRadius();
 10174135        return Fixed64.TryMultiplyDivide(
 10174136            mass,
 10174137            radius,
 10174138            radius,
 10174139            Fixed64.Two,
 10174140            out Fixed64 moment)
 10174141            ? moment
 10174142            : Fixed64.MaxValue;
 143    }
 144
 145    private Fixed64 GetMassPropertyRadius()
 146    {
 143342147        if (HasCommittedShape)
 138852148            return _scaledRadius;
 149
 4490150        GetCurrentScaleFactors(
 4490151            out Vector2d ownerScale,
 4490152            out Vector2d partScale);
 4490153        Fixed64 radiusX = ColliderScalePolicy.Scale(
 4490154            _radius,
 4490155            ownerScale.X,
 4490156            partScale.X);
 4490157        Fixed64 radiusY = ColliderScalePolicy.Scale(
 4490158            _radius,
 4490159            ownerScale.Y,
 4490160            partScale.Y);
 4490161        return FixedMath.Max(radiusX, radiusY);
 162    }
 163
 164    private protected override void PrepareShape(in ColliderShapeSnapshot2D snapshot)
 165    {
 14039166        Fixed64 radiusX = ColliderScalePolicy.ScalePositive(
 14039167            _radius,
 14039168            snapshot.OwnerScale.X,
 14039169            snapshot.PartScale.X);
 14037170        Fixed64 radiusY = ColliderScalePolicy.ScalePositive(
 14037171            _radius,
 14037172            snapshot.OwnerScale.Y,
 14037173            snapshot.PartScale.Y);
 14037174        _preparedRadius = FixedMath.Max(radiusX, radiusY);
 14037175        SetPreparedGeometryReach(_preparedRadius);
 14037176        SetPreparedBounds(FixedBoundArea.FromCenterAndScopeClippedToDomain(
 14037177            snapshot.Center,
 14037178            new Vector2d(_preparedRadius, _preparedRadius)));
 14037179    }
 180
 181    private protected override void PublishShape() =>
 12962182        _scaledRadius = _preparedRadius;
 183
 184    internal void CopyPreparedReconfiguration(LSCircleCollider2D candidate)
 185    {
 35186        _radius = candidate._radius;
 35187        _preparedRadius = candidate._preparedRadius;
 35188    }
 189
 190    /// <inheritdoc/>
 191    protected override void RecordShapeData(IChronicler chronicler)
 192    {
 175193        Fixed64 radius = _radius;
 175194        RecordValues.Look(chronicler, ref radius, "Radius", Fixed64.Half);
 175195        if (chronicler.Mode == SerializationMode.Loading)
 196        {
 99197            ChronicleGuard.ThrowIfArgument(radius <= Fixed64.Zero, nameof(radius), "2D circle radius must be greater tha
 99198            _radius = radius;
 199        }
 175200    }
 201}