< Summary

Information
Class: FixedMathSharp.WideVector2dTransform
Assembly: FixedMathSharp
File(s): /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Numerics/Wide/WideVector2dTransform.cs
Line coverage
100%
Covered lines: 408
Uncovered lines: 0
Coverable lines: 408
Total lines: 607
Line coverage: 100%
Branch coverage
100%
Covered branches: 22
Total branches: 22
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
TryTransformScaledPoint(...)100%66100%
TryInverseTransformScaledPoint(...)100%22100%
TryComposeScaledLocalPoints(...)100%22100%
TryTransformPoint(...)100%11100%
TryTransformCompositePoint(...)100%22100%
TryTransformPoint(...)100%22100%
TryGetRelativeOffset(...)100%22100%
TryGetLocalPointIn(...)100%22100%
TryGetRelativeOffset(...)100%11100%
TryGetRelativeOffset(...)100%22100%
GetRotationNumerators(...)100%11100%
GetRotationNumerators(...)100%11100%
GetScaledRotationNumerators(...)100%11100%
GetRelativeNumerator(...)100%11100%
GetRelativeNumerator(...)100%11100%
GetTransformNumerator(...)100%11100%
Scale(...)100%22100%
Product(...)100%11100%
TryInverseTransformScaledCoordinate(...)100%11100%
TryRoundCoordinate(...)100%11100%

File(s)

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Numerics/Wide/WideVector2dTransform.cs

#LineLine coverage
 1//=======================================================================
 2// WideVector2dTransform.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2024-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8namespace FixedMathSharp;
 9
 10/// <summary>
 11/// Provides methods for transforming two-dimensional points and
 12/// vectors using wide arithmetic to avoid overflow and maintain precision.
 13/// </summary>
 14internal static class WideVector2dTransform
 15{
 16    internal static bool TryTransformScaledPoint(
 17        Vector2d origin,
 18        Vector2d localPoint,
 19        Vector2d scale,
 20        Vector2d localDisplacement,
 21        Fixed64 angleInRadians,
 22        out Vector2d result)
 23    {
 24        // Both rotated numerators are zero, so the exact final ratio is the origin.
 23925        if (localPoint == Vector2d.Zero && localDisplacement == Vector2d.Zero)
 26        {
 16827            result = origin;
 16828            return true;
 29        }
 30
 7131        Fixed64 cosine = FixedMath.Cos(angleInRadians);
 7132        Fixed64 sine = FixedMath.Sin(angleInRadians);
 7133        Signed320 denominatorWide = Product(Fixed64.One, Fixed64.One);
 7134        Signed576 denominator =
 7135            Signed576.ExtendValue(denominatorWide);
 7136        GetScaledRotationNumerators(
 7137            localPoint,
 7138            scale,
 7139            localDisplacement,
 7140            cosine,
 7141            sine,
 7142            out Signed576 rotatedX,
 7143            out Signed576 rotatedY);
 7144        bool representable = Fixed64.TryGetSignedRawRatio(
 7145                WideArithmetic.AddSigned576(
 7146                    WideArithmetic.MultiplySigned320(
 7147                        Signed320.ExtendValue(Signed192.Raw(origin.X)),
 7148                        denominatorWide),
 7149                    rotatedX),
 7150                denominator,
 7151                out Fixed64 x)
 7152            & Fixed64.TryGetSignedRawRatio(
 7153                WideArithmetic.AddSigned576(
 7154                    WideArithmetic.MultiplySigned320(
 7155                        Signed320.ExtendValue(Signed192.Raw(origin.Y)),
 7156                        denominatorWide),
 7157                    rotatedY),
 7158                denominator,
 7159                out Fixed64 y);
 7160        if (!representable)
 61        {
 262            result = default;
 263            return false;
 64        }
 65
 6966        result = new Vector2d(x, y);
 6967        return true;
 68    }
 69
 70    internal static bool TryInverseTransformScaledPoint(
 71        Vector2d origin,
 72        Vector2d worldPoint,
 73        Vector2d scale,
 74        Fixed64 angleInRadians,
 75        out Vector2d localPoint)
 76    {
 7177        Fixed64 cosine = FixedMath.Cos(angleInRadians);
 7178        Fixed64 sine = FixedMath.Sin(angleInRadians);
 7179        Signed192 offsetX = WideArithmetic.SubtractSigned192(
 7180            Signed192.Raw(worldPoint.X),
 7181            Signed192.Raw(origin.X));
 7182        Signed192 offsetY = WideArithmetic.SubtractSigned192(
 7183            Signed192.Raw(worldPoint.Y),
 7184            Signed192.Raw(origin.Y));
 7185        Signed320 projectionX = WideArithmetic.AddSigned320(
 7186            WideArithmetic.MultiplySigned192(
 7187                offsetX,
 7188                Signed192.Raw(cosine)),
 7189            WideArithmetic.MultiplySigned192(
 7190                offsetY,
 7191                Signed192.Raw(sine)));
 7192        Signed320 projectionY = WideArithmetic.SubtractSigned320(
 7193            WideArithmetic.MultiplySigned192(
 7194                offsetY,
 7195                Signed192.Raw(cosine)),
 7196            WideArithmetic.MultiplySigned192(
 7197                offsetX,
 7198                Signed192.Raw(sine)));
 7199        Signed320 rotationDenominator = WideArithmetic.AddSigned320(
 71100            Product(cosine, cosine),
 71101            Product(sine, sine));
 71102        bool representable = TryInverseTransformScaledCoordinate(
 71103                projectionX,
 71104                rotationDenominator,
 71105                scale.X,
 71106                out Fixed64 x)
 71107            & TryInverseTransformScaledCoordinate(
 71108                projectionY,
 71109                rotationDenominator,
 71110                scale.Y,
 71111                out Fixed64 y);
 71112        if (!representable)
 113        {
 2114            localPoint = default;
 2115            return false;
 116        }
 117
 69118        localPoint = new Vector2d(x, y);
 69119        return true;
 120    }
 121
 122    internal static bool TryComposeScaledLocalPoints(
 123        Vector2d outerLocalPoint,
 124        Vector2d outerScale,
 125        Vector2d innerFrameOffset,
 126        Vector2d innerFrameScale,
 127        Vector2d innerLocalDisplacement,
 128        Fixed64 innerAngleInRadians,
 129        out Vector2d result)
 130    {
 68131        Fixed64 cosine = FixedMath.Cos(innerAngleInRadians);
 68132        Fixed64 sine = FixedMath.Sin(innerAngleInRadians);
 68133        Signed320 one =
 68134            Signed320.ExtendValue(Signed192.One);
 68135        Signed576 denominator = Signed576.ExtendValue(
 68136            Product(Fixed64.One, Fixed64.One));
 68137        GetScaledRotationNumerators(
 68138            Vector2d.Zero,
 68139            Vector2d.One,
 68140            innerLocalDisplacement,
 68141            cosine,
 68142            sine,
 68143            out Signed576 rotatedX,
 68144            out Signed576 rotatedY);
 68145        Signed576 outerX = WideArithmetic.MultiplySigned320(
 68146            Product(outerLocalPoint.X, outerScale.X),
 68147            one);
 68148        Signed576 outerY = WideArithmetic.MultiplySigned320(
 68149            Product(outerLocalPoint.Y, outerScale.Y),
 68150            one);
 68151        Signed576 innerX = WideArithmetic.MultiplySigned320(
 68152            Product(innerFrameOffset.X, innerFrameScale.X),
 68153            one);
 68154        Signed576 innerY = WideArithmetic.MultiplySigned320(
 68155            Product(innerFrameOffset.Y, innerFrameScale.Y),
 68156            one);
 68157        bool representable = Fixed64.TryGetSignedRawRatio(
 68158                WideArithmetic.AddSigned576(
 68159                    WideArithmetic.AddSigned576(outerX, innerX),
 68160                    rotatedX),
 68161                denominator,
 68162                out Fixed64 x)
 68163            & Fixed64.TryGetSignedRawRatio(
 68164                WideArithmetic.AddSigned576(
 68165                    WideArithmetic.AddSigned576(outerY, innerY),
 68166                    rotatedY),
 68167                denominator,
 68168                out Fixed64 y);
 68169        if (!representable)
 170        {
 1171            result = default;
 1172            return false;
 173        }
 174
 67175        result = new Vector2d(x, y);
 67176        return true;
 177    }
 178
 179    internal static bool TryTransformPoint(
 180        Vector2d origin,
 181        Vector2d localPoint,
 182        Fixed64 angleInRadians,
 183        out Vector2d result) =>
 35184        TryTransformCompositePoint(
 35185            origin,
 35186            localPoint,
 35187            Vector2d.Zero,
 35188            angleInRadians,
 35189            out result);
 190
 191    internal static bool TryTransformCompositePoint(
 192        Vector2d origin,
 193        Vector2d localPoint,
 194        Vector2d localDisplacement,
 195        Fixed64 angleInRadians,
 196        out Vector2d result)
 197    {
 358198        Fixed64 cosine = FixedMath.Cos(angleInRadians);
 358199        Fixed64 sine = FixedMath.Sin(angleInRadians);
 358200        Signed576 denominator = Signed576.One;
 358201        GetRotationNumerators(
 358202            localPoint,
 358203            localDisplacement,
 358204            cosine,
 358205            sine,
 358206            out Signed320 rotatedX,
 358207            out Signed320 rotatedY);
 358208        bool representable = TryRoundCoordinate(
 358209                WideArithmetic.AddSigned320(
 358210                    Scale(origin.X),
 358211                    rotatedX),
 358212                denominator,
 358213                out Fixed64 x)
 358214            & TryRoundCoordinate(
 358215                WideArithmetic.AddSigned320(
 358216                    Scale(origin.Y),
 358217                    rotatedY),
 358218                denominator,
 358219                out Fixed64 y);
 358220        if (!representable)
 221        {
 17222            result = default;
 17223            return false;
 224        }
 225
 341226        result = new Vector2d(x, y);
 341227        return true;
 228    }
 229
 230    internal static bool TryTransformPoint(
 231        Vector2d firstOrigin,
 232        Vector2d secondOrigin,
 233        Vector2d localPoint,
 234        Fixed64 angleInRadians,
 235        out Vector2d result)
 236    {
 69237        Fixed64 cosine = FixedMath.Cos(angleInRadians);
 69238        Fixed64 sine = FixedMath.Sin(angleInRadians);
 69239        Signed576 denominator = Signed576.One;
 69240        GetRotationNumerators(
 69241            localPoint,
 69242            cosine,
 69243            sine,
 69244            out Signed320 rotatedX,
 69245            out Signed320 rotatedY);
 69246        bool representable = TryRoundCoordinate(
 69247                GetTransformNumerator(
 69248                    firstOrigin.X,
 69249                    secondOrigin.X,
 69250                    rotatedX),
 69251                denominator,
 69252                out Fixed64 x)
 69253            & TryRoundCoordinate(
 69254                GetTransformNumerator(
 69255                    firstOrigin.Y,
 69256                    secondOrigin.Y,
 69257                    rotatedY),
 69258                denominator,
 69259                out Fixed64 y);
 69260        if (!representable)
 261        {
 1262            result = default;
 1263            return false;
 264        }
 265
 68266        result = new Vector2d(x, y);
 68267        return true;
 268    }
 269
 270    internal static bool TryGetRelativeOffset(
 271        Vector2d firstOrigin,
 272        Vector2d firstOffset,
 273        Vector2d secondOrigin,
 274        Vector2d secondLocalPoint,
 275        Fixed64 angleInRadians,
 276        out Vector2d result)
 277    {
 35278        Fixed64 cosine = FixedMath.Cos(angleInRadians);
 35279        Fixed64 sine = FixedMath.Sin(angleInRadians);
 35280        Signed576 denominator = Signed576.One;
 35281        GetRotationNumerators(
 35282            secondLocalPoint,
 35283            cosine,
 35284            sine,
 35285            out Signed320 rotatedX,
 35286            out Signed320 rotatedY);
 35287        bool representable = TryRoundCoordinate(
 35288                GetRelativeNumerator(
 35289                    firstOrigin.X,
 35290                    firstOffset.X,
 35291                    secondOrigin.X,
 35292                    rotatedX),
 35293                denominator,
 35294                out Fixed64 x)
 35295            & TryRoundCoordinate(
 35296                GetRelativeNumerator(
 35297                    firstOrigin.Y,
 35298                    firstOffset.Y,
 35299                    secondOrigin.Y,
 35300                    rotatedY),
 35301                denominator,
 35302                out Fixed64 y);
 35303        if (!representable)
 304        {
 1305            result = default;
 1306            return false;
 307        }
 308
 34309        result = new Vector2d(x, y);
 34310        return true;
 311    }
 312
 313    internal static bool TryGetLocalPointIn(
 314        Vector2d pointOrigin,
 315        Vector2d pointLocalPoint,
 316        Vector2d pointLocalDisplacement,
 317        Fixed64 pointAngleInRadians,
 318        Vector2d frameOrigin,
 319        Fixed64 frameAngleInRadians,
 320        out Vector2d localPoint)
 321    {
 73322        Fixed64 pointCosine = FixedMath.Cos(pointAngleInRadians);
 73323        Fixed64 pointSine = FixedMath.Sin(pointAngleInRadians);
 73324        Fixed64 frameCosine = FixedMath.Cos(frameAngleInRadians);
 73325        Fixed64 frameSine = FixedMath.Sin(frameAngleInRadians);
 73326        GetRotationNumerators(
 73327            pointLocalPoint,
 73328            pointLocalDisplacement,
 73329            pointCosine,
 73330            pointSine,
 73331            out Signed320 pointX,
 73332            out Signed320 pointY);
 73333        Signed320 deltaX = WideArithmetic.AddSigned320(
 73334            WideArithmetic.SubtractSigned320(
 73335                Scale(pointOrigin.X),
 73336                Scale(frameOrigin.X)),
 73337            pointX);
 73338        Signed320 deltaY = WideArithmetic.AddSigned320(
 73339            WideArithmetic.SubtractSigned320(
 73340                Scale(pointOrigin.Y),
 73341                Scale(frameOrigin.Y)),
 73342            pointY);
 73343        Signed576 xNumerator = WideArithmetic.AddSigned576(
 73344            WideArithmetic.MultiplySigned576(
 73345                Signed576.ExtendValue(deltaX),
 73346                Signed192.Raw(frameCosine)),
 73347            WideArithmetic.MultiplySigned576(
 73348                Signed576.ExtendValue(deltaY),
 73349                Signed192.Raw(frameSine)));
 73350        Signed576 yNumerator = WideArithmetic.SubtractSigned576(
 73351            WideArithmetic.MultiplySigned576(
 73352                Signed576.ExtendValue(deltaY),
 73353                Signed192.Raw(frameCosine)),
 73354            WideArithmetic.MultiplySigned576(
 73355                Signed576.ExtendValue(deltaX),
 73356                Signed192.Raw(frameSine)));
 73357        Signed576 denominator = Signed576.ExtendValue(
 73358            WideArithmetic.AddSigned320(
 73359                Product(frameCosine, frameCosine),
 73360                Product(frameSine, frameSine)));
 73361        bool representable =
 73362            Fixed64.TryGetSignedRawRatio(
 73363                xNumerator,
 73364                denominator,
 73365                out Fixed64 x)
 73366            & Fixed64.TryGetSignedRawRatio(
 73367                yNumerator,
 73368                denominator,
 73369                out Fixed64 y);
 73370        localPoint = representable ? new Vector2d(x, y) : default;
 73371        return representable;
 372    }
 373
 374    internal static bool TryGetRelativeOffset(
 375        Vector2d firstOrigin,
 376        Vector2d firstLocalPoint,
 377        Fixed64 firstAngleInRadians,
 378        Vector2d secondOrigin,
 379        Vector2d secondLocalPoint,
 380        Fixed64 secondAngleInRadians,
 381        out Vector2d result) =>
 35382        TryGetRelativeOffset(
 35383            firstOrigin,
 35384            firstLocalPoint,
 35385            Vector2d.Zero,
 35386            firstAngleInRadians,
 35387            secondOrigin,
 35388            secondLocalPoint,
 35389            Vector2d.Zero,
 35390            secondAngleInRadians,
 35391            out result);
 392
 393    internal static bool TryGetRelativeOffset(
 394        Vector2d firstOrigin,
 395        Vector2d firstLocalPoint,
 396        Vector2d firstLocalDisplacement,
 397        Fixed64 firstAngleInRadians,
 398        Vector2d secondOrigin,
 399        Vector2d secondLocalPoint,
 400        Vector2d secondLocalDisplacement,
 401        Fixed64 secondAngleInRadians,
 402        out Vector2d result)
 403    {
 77404        Fixed64 firstCosine = FixedMath.Cos(firstAngleInRadians);
 77405        Fixed64 firstSine = FixedMath.Sin(firstAngleInRadians);
 77406        Fixed64 secondCosine = FixedMath.Cos(secondAngleInRadians);
 77407        Fixed64 secondSine = FixedMath.Sin(secondAngleInRadians);
 77408        Signed576 denominator = Signed576.One;
 77409        GetRotationNumerators(
 77410            firstLocalPoint,
 77411            firstLocalDisplacement,
 77412            firstCosine,
 77413            firstSine,
 77414            out Signed320 firstRotatedX,
 77415            out Signed320 firstRotatedY);
 77416        GetRotationNumerators(
 77417            secondLocalPoint,
 77418            secondLocalDisplacement,
 77419            secondCosine,
 77420            secondSine,
 77421            out Signed320 secondRotatedX,
 77422            out Signed320 secondRotatedY);
 77423        bool representable = TryRoundCoordinate(
 77424                GetRelativeNumerator(
 77425                    firstOrigin.X,
 77426                    firstRotatedX,
 77427                    secondOrigin.X,
 77428                    secondRotatedX),
 77429                denominator,
 77430                out Fixed64 x)
 77431            & TryRoundCoordinate(
 77432                GetRelativeNumerator(
 77433                    firstOrigin.Y,
 77434                    firstRotatedY,
 77435                    secondOrigin.Y,
 77436                    secondRotatedY),
 77437                denominator,
 77438                out Fixed64 y);
 77439        if (!representable)
 440        {
 2441            result = default;
 2442            return false;
 443        }
 444
 75445        result = new Vector2d(x, y);
 75446        return true;
 447    }
 448
 449    internal static void GetRotationNumerators(
 450        Vector2d localPoint,
 451        Vector2d localDisplacement,
 452        Fixed64 cosine,
 453        Fixed64 sine,
 454        out Signed320 x,
 455        out Signed320 y)
 456    {
 775457        GetRotationNumerators(
 775458            localPoint,
 775459            cosine,
 775460            sine,
 775461            out x,
 775462            out y);
 775463        GetRotationNumerators(
 775464            localDisplacement,
 775465            cosine,
 775466            sine,
 775467            out Signed320 displacementX,
 775468            out Signed320 displacementY);
 775469        x = WideArithmetic.AddSigned320(x, displacementX);
 775470        y = WideArithmetic.AddSigned320(y, displacementY);
 775471    }
 472
 473    private static void GetRotationNumerators(
 474        Vector2d localPoint,
 475        Fixed64 cosine,
 476        Fixed64 sine,
 477        out Signed320 x,
 478        out Signed320 y)
 479    {
 1654480        x = WideArithmetic.SubtractSigned320(
 1654481            Product(localPoint.X, cosine),
 1654482            Product(localPoint.Y, sine));
 1654483        y = WideArithmetic.AddSigned320(
 1654484            Product(localPoint.X, sine),
 1654485            Product(localPoint.Y, cosine));
 1654486    }
 487
 488    private static void GetScaledRotationNumerators(
 489        Vector2d localPoint,
 490        Vector2d scale,
 491        Vector2d localDisplacement,
 492        Fixed64 cosine,
 493        Fixed64 sine,
 494        out Signed576 x,
 495        out Signed576 y)
 496    {
 139497        Signed320 localX = Product(localPoint.X, scale.X);
 139498        Signed320 localY = Product(localPoint.Y, scale.Y);
 139499        Signed320 one =
 139500            Signed320.ExtendValue(Signed192.One);
 139501        Signed576 displacementX = WideArithmetic.MultiplySigned320(
 139502            WideArithmetic.SubtractSigned320(
 139503                Product(localDisplacement.X, cosine),
 139504                Product(localDisplacement.Y, sine)),
 139505            one);
 139506        Signed576 displacementY = WideArithmetic.MultiplySigned320(
 139507            WideArithmetic.AddSigned320(
 139508                Product(localDisplacement.X, sine),
 139509                Product(localDisplacement.Y, cosine)),
 139510            one);
 139511        x = WideArithmetic.AddSigned576(
 139512            WideArithmetic.SubtractSigned576(
 139513                WideArithmetic.MultiplySigned320(
 139514                    localX,
 139515                    Signed320.ExtendValue(Signed192.Raw(cosine))),
 139516                WideArithmetic.MultiplySigned320(
 139517                    localY,
 139518                    Signed320.ExtendValue(Signed192.Raw(sine)))),
 139519            displacementX);
 139520        y = WideArithmetic.AddSigned576(
 139521            WideArithmetic.AddSigned576(
 139522                WideArithmetic.MultiplySigned320(
 139523                    localX,
 139524                    Signed320.ExtendValue(Signed192.Raw(sine))),
 139525                WideArithmetic.MultiplySigned320(
 139526                    localY,
 139527                    Signed320.ExtendValue(Signed192.Raw(cosine)))),
 139528            displacementY);
 139529    }
 530
 531    private static Signed320 GetRelativeNumerator(
 532        Fixed64 firstOrigin,
 533        Fixed64 firstOffset,
 534        Fixed64 secondOrigin,
 535        Signed320 rotatedLocalPoint) =>
 70536        WideArithmetic.SubtractSigned320(
 70537            WideArithmetic.SubtractSigned320(
 70538                WideArithmetic.AddSigned320(
 70539                    Scale(firstOrigin),
 70540                    Scale(firstOffset)),
 70541                Scale(secondOrigin)),
 70542            rotatedLocalPoint);
 543
 544    private static Signed320 GetRelativeNumerator(
 545        Fixed64 firstOrigin,
 546        Signed320 firstRotatedLocalPoint,
 547        Fixed64 secondOrigin,
 548        Signed320 secondRotatedLocalPoint) =>
 154549        WideArithmetic.SubtractSigned320(
 154550            WideArithmetic.AddSigned320(
 154551                WideArithmetic.SubtractSigned320(
 154552                    Scale(firstOrigin),
 154553                    Scale(secondOrigin)),
 154554                firstRotatedLocalPoint),
 154555            secondRotatedLocalPoint);
 556
 557    private static Signed320 GetTransformNumerator(
 558        Fixed64 firstOrigin,
 559        Fixed64 secondOrigin,
 560        Signed320 rotatedLocalPoint) =>
 138561        WideArithmetic.AddSigned320(
 138562            WideArithmetic.AddSigned320(
 138563                Scale(firstOrigin),
 138564                Scale(secondOrigin)),
 138565            rotatedLocalPoint);
 566
 567    internal static Signed320 Scale(Fixed64 value)
 568    {
 2182569        long raw = value.m_rawValue;
 2182570        ulong extension = raw < 0L ? ulong.MaxValue : 0UL;
 2182571        ulong unsignedRaw = unchecked((ulong)raw);
 2182572        return new Signed320(
 2182573            extension,
 2182574            extension,
 2182575            extension,
 2182576            (unsignedRaw >> FixedMath.SHIFT_AMOUNT_I)
 2182577                | (extension << FixedMath.SHIFT_AMOUNT_I),
 2182578            unsignedRaw << FixedMath.SHIFT_AMOUNT_I);
 579    }
 580
 581    private static Signed320 Product(Fixed64 left, Fixed64 right) =>
 8291582        WideArithmetic.MultiplySigned192(Signed192.Raw(left), Signed192.Raw(right));
 583
 584    private static bool TryInverseTransformScaledCoordinate(
 585        Signed320 projection,
 586        Signed320 rotationDenominator,
 587        Fixed64 scale,
 588        out Fixed64 result) =>
 142589        Fixed64.TryGetSignedRawRatio(
 142590            WideArithmetic.MultiplySigned320(
 142591                projection,
 142592                Product(Fixed64.One, Fixed64.One)),
 142593            WideArithmetic.MultiplySigned320(
 142594                rotationDenominator,
 142595                Signed320.ExtendValue(Signed192.Raw(scale))),
 142596            out result);
 597
 598    private static bool TryRoundCoordinate(
 599        Signed320 numerator,
 600        Signed576 denominator,
 601        out Fixed64 result) =>
 1078602        Fixed64.TryGetSignedRawRatio(
 1078603            Signed576.ExtendValue(numerator),
 1078604            denominator,
 1078605            out result);
 606
 607}
Generated by: ReportGenerator 5.5.12.0
11/04/2026 - 16:26:30
GitHub | reportgenerator.io

Methods/Properties

TryTransformScaledPoint(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
TryInverseTransformScaledPoint(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
TryComposeScaledLocalPoints(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
TryTransformPoint(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
TryTransformCompositePoint(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
TryTransformPoint(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
TryGetRelativeOffset(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
TryGetLocalPointIn(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
TryGetRelativeOffset(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
TryGetRelativeOffset(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Vector2d&)
GetRotationNumerators(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Signed320&,FixedMathSharp.Signed320&)
GetRotationNumerators(FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Signed320&,FixedMathSharp.Signed320&)
GetScaledRotationNumerators(FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Vector2d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Signed576&,FixedMathSharp.Signed576&)
GetRelativeNumerator(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Signed320)
GetRelativeNumerator(FixedMathSharp.Fixed64,FixedMathSharp.Signed320,FixedMathSharp.Fixed64,FixedMathSharp.Signed320)
GetTransformNumerator(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Signed320)
Scale(FixedMathSharp.Fixed64)
Product(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
TryInverseTransformScaledCoordinate(FixedMathSharp.Signed320,FixedMathSharp.Signed320,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64&)
TryRoundCoordinate(FixedMathSharp.Signed320,FixedMathSharp.Signed576,FixedMathSharp.Fixed64&)