< Summary

Information
Class: Gravitas.Colliders.MeshCheckedMath
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/Colliders/Mesh/MeshCheckedMath.cs
Line coverage
100%
Covered lines: 64
Uncovered lines: 0
Coverable lines: 64
Total lines: 124
Line coverage: 100%
Branch coverage
100%
Covered branches: 8
Total branches: 8
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
TryCreateParallelAxisTensor(...)100%22100%
TryAdd(...)100%11100%
TrySubtract(...)100%11100%
TryMultiply(...)100%22100%
TryAdd(...)100%11100%
TrySubtract(...)100%11100%
TryAdd(...)100%11100%
TrySubtract(...)100%11100%
TryMultiply(...)100%11100%
TryNegate(...)100%11100%
TryCreateMatrix(...)100%22100%
TryCombine(...)100%22100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Colliders/Mesh/MeshCheckedMath.cs

#LineLine coverage
 1//=======================================================================
 2// MeshCheckedMath.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 FixedMathSharp;
 9
 10namespace Gravitas.Colliders;
 11
 12/// <summary>
 13/// Provides checked fixed-point arithmetic for mesh mass properties and inertia shifts.
 14/// </summary>
 15internal static class MeshCheckedMath
 16{
 17    internal static bool TryCreateParallelAxisTensor(Vector3d offset, out Fixed3x3 tensor)
 18    {
 13519        tensor = default;
 13520        bool valid = TryMultiply(offset.X, offset.X, out Fixed64 xx);
 13521        valid &= TryMultiply(offset.Y, offset.Y, out Fixed64 yy);
 13522        valid &= TryMultiply(offset.Z, offset.Z, out Fixed64 zz);
 13523        valid &= TryMultiply(offset.X, offset.Y, out Fixed64 xyProduct);
 13524        valid &= TryMultiply(offset.X, offset.Z, out Fixed64 xzProduct);
 13525        valid &= TryMultiply(offset.Y, offset.Z, out Fixed64 yzProduct);
 13526        valid &= TryAdd(yy, zz, out Fixed64 diagonalX);
 13527        valid &= TryAdd(xx, zz, out Fixed64 diagonalY);
 13528        valid &= TryAdd(xx, yy, out Fixed64 diagonalZ);
 13529        valid &= TryNegate(xyProduct, out Fixed64 xy);
 13530        valid &= TryNegate(xzProduct, out Fixed64 xz);
 13531        valid &= TryNegate(yzProduct, out Fixed64 yz);
 13532        if (!valid)
 333            return false;
 34
 13235        tensor = new Fixed3x3(diagonalX, xy, xz, xy, diagonalY, yz, xz, yz, diagonalZ);
 13236        return true;
 37    }
 38
 39    internal static bool TryAdd(Vector3d first, Vector3d second, out Vector3d result) =>
 140        Vector3d.TryAdd(first, second, out result);
 41
 42    internal static bool TrySubtract(Vector3d first, Vector3d second, out Vector3d result) =>
 13543        Vector3d.TrySubtract(first, second, out result);
 44
 45    internal static bool TryMultiply(Vector3d first, Vector3d second, out Vector3d result)
 46    {
 13547        result = default;
 13548        bool valid = Fixed64.TryMultiplyDivide(
 13549            first.X,
 13550            second.X,
 13551            Fixed64.One,
 13552            out Fixed64 x);
 13553        valid &= Fixed64.TryMultiplyDivide(
 13554            first.Y,
 13555            second.Y,
 13556            Fixed64.One,
 13557            out Fixed64 y);
 13558        valid &= Fixed64.TryMultiplyDivide(
 13559            first.Z,
 13560            second.Z,
 13561            Fixed64.One,
 13562            out Fixed64 z);
 13563        if (!valid)
 164            return false;
 65
 13466        result = new Vector3d(x, y, z);
 13467        return true;
 68    }
 69
 70    internal static bool TryAdd(Fixed3x3 first, Fixed3x3 second, out Fixed3x3 result) =>
 6871        TryCreateMatrix(first, second, add: true, out result);
 72
 73    internal static bool TrySubtract(Fixed3x3 first, Fixed3x3 second, out Fixed3x3 result) =>
 6774        TryCreateMatrix(first, second, add: false, out result);
 75
 76    internal static bool TryAdd(
 77        Fixed64 first,
 78        Fixed64 second,
 79        out Fixed64 result) =>
 141980        Fixed64.TryAdd(first, second, out result);
 81
 82    internal static bool TrySubtract(
 83        Fixed64 first,
 84        Fixed64 second,
 85        out Fixed64 result) =>
 80486        Fixed64.TrySubtract(first, second, out result);
 87
 88    internal static bool TryMultiply(
 89        Fixed64 first,
 90        Fixed64 second,
 91        out Fixed64 result) =>
 202892        Fixed64.TryMultiplyDivide(
 202893            first,
 202894            second,
 202895            Fixed64.One,
 202896            out result);
 97
 98    internal static bool TryNegate(
 99        Fixed64 value,
 100        out Fixed64 result) =>
 807101        Fixed64.TrySubtract(Fixed64.Zero, value, out result);
 102
 103    private static bool TryCreateMatrix(Fixed3x3 first, Fixed3x3 second, bool add, out Fixed3x3 result)
 104    {
 135105        result = default;
 135106        bool valid = TryCombine(first.M11, second.M11, add, out Fixed64 m11);
 135107        valid &= TryCombine(first.M12, second.M12, add, out Fixed64 m12);
 135108        valid &= TryCombine(first.M13, second.M13, add, out Fixed64 m13);
 135109        valid &= TryCombine(first.M21, second.M21, add, out Fixed64 m21);
 135110        valid &= TryCombine(first.M22, second.M22, add, out Fixed64 m22);
 135111        valid &= TryCombine(first.M23, second.M23, add, out Fixed64 m23);
 135112        valid &= TryCombine(first.M31, second.M31, add, out Fixed64 m31);
 135113        valid &= TryCombine(first.M32, second.M32, add, out Fixed64 m32);
 135114        valid &= TryCombine(first.M33, second.M33, add, out Fixed64 m33);
 135115        if (!valid)
 1116            return false;
 117
 134118        result = new Fixed3x3(m11, m12, m13, m21, m22, m23, m31, m32, m33);
 134119        return true;
 120    }
 121
 122    private static bool TryCombine(Fixed64 first, Fixed64 second, bool add, out Fixed64 result) =>
 1215123        add ? TryAdd(first, second, out result) : TrySubtract(first, second, out result);
 124}