< 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: 405
Uncovered lines: 0
Coverable lines: 405
Total lines: 600
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
TryTransformScaledPoint(...)100%22100%
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    {
 6924        Fixed64 cosine = FixedMath.Cos(angleInRadians);
 6925        Fixed64 sine = FixedMath.Sin(angleInRadians);
 6926        Signed320 denominatorWide = Product(Fixed64.One, Fixed64.One);
 6927        Signed576 denominator =
 6928            Signed576.ExtendValue(denominatorWide);
 6929        GetScaledRotationNumerators(
 6930            localPoint,
 6931            scale,
 6932            localDisplacement,
 6933            cosine,
 6934            sine,
 6935            out Signed576 rotatedX,
 6936            out Signed576 rotatedY);
 6937        bool representable = Fixed64.TryGetSignedRawRatio(
 6938                WideArithmetic.AddSigned576(
 6939                    WideArithmetic.MultiplySigned320(
 6940                        Signed320.ExtendValue(Signed192.Raw(origin.X)),
 6941                        denominatorWide),
 6942                    rotatedX),
 6943                denominator,
 6944                out Fixed64 x)
 6945            & Fixed64.TryGetSignedRawRatio(
 6946                WideArithmetic.AddSigned576(
 6947                    WideArithmetic.MultiplySigned320(
 6948                        Signed320.ExtendValue(Signed192.Raw(origin.Y)),
 6949                        denominatorWide),
 6950                    rotatedY),
 6951                denominator,
 6952                out Fixed64 y);
 6953        if (!representable)
 54        {
 155            result = default;
 156            return false;
 57        }
 58
 6859        result = new Vector2d(x, y);
 6860        return true;
 61    }
 62
 63    internal static bool TryInverseTransformScaledPoint(
 64        Vector2d origin,
 65        Vector2d worldPoint,
 66        Vector2d scale,
 67        Fixed64 angleInRadians,
 68        out Vector2d localPoint)
 69    {
 7170        Fixed64 cosine = FixedMath.Cos(angleInRadians);
 7171        Fixed64 sine = FixedMath.Sin(angleInRadians);
 7172        Signed192 offsetX = WideArithmetic.SubtractSigned192(
 7173            Signed192.Raw(worldPoint.X),
 7174            Signed192.Raw(origin.X));
 7175        Signed192 offsetY = WideArithmetic.SubtractSigned192(
 7176            Signed192.Raw(worldPoint.Y),
 7177            Signed192.Raw(origin.Y));
 7178        Signed320 projectionX = WideArithmetic.AddSigned320(
 7179            WideArithmetic.MultiplySigned192(
 7180                offsetX,
 7181                Signed192.Raw(cosine)),
 7182            WideArithmetic.MultiplySigned192(
 7183                offsetY,
 7184                Signed192.Raw(sine)));
 7185        Signed320 projectionY = WideArithmetic.SubtractSigned320(
 7186            WideArithmetic.MultiplySigned192(
 7187                offsetY,
 7188                Signed192.Raw(cosine)),
 7189            WideArithmetic.MultiplySigned192(
 7190                offsetX,
 7191                Signed192.Raw(sine)));
 7192        Signed320 rotationDenominator = WideArithmetic.AddSigned320(
 7193            Product(cosine, cosine),
 7194            Product(sine, sine));
 7195        bool representable = TryInverseTransformScaledCoordinate(
 7196                projectionX,
 7197                rotationDenominator,
 7198                scale.X,
 7199                out Fixed64 x)
 71100            & TryInverseTransformScaledCoordinate(
 71101                projectionY,
 71102                rotationDenominator,
 71103                scale.Y,
 71104                out Fixed64 y);
 71105        if (!representable)
 106        {
 2107            localPoint = default;
 2108            return false;
 109        }
 110
 69111        localPoint = new Vector2d(x, y);
 69112        return true;
 113    }
 114
 115    internal static bool TryComposeScaledLocalPoints(
 116        Vector2d outerLocalPoint,
 117        Vector2d outerScale,
 118        Vector2d innerFrameOffset,
 119        Vector2d innerFrameScale,
 120        Vector2d innerLocalDisplacement,
 121        Fixed64 innerAngleInRadians,
 122        out Vector2d result)
 123    {
 68124        Fixed64 cosine = FixedMath.Cos(innerAngleInRadians);
 68125        Fixed64 sine = FixedMath.Sin(innerAngleInRadians);
 68126        Signed320 one =
 68127            Signed320.ExtendValue(Signed192.One);
 68128        Signed576 denominator = Signed576.ExtendValue(
 68129            Product(Fixed64.One, Fixed64.One));
 68130        GetScaledRotationNumerators(
 68131            Vector2d.Zero,
 68132            Vector2d.One,
 68133            innerLocalDisplacement,
 68134            cosine,
 68135            sine,
 68136            out Signed576 rotatedX,
 68137            out Signed576 rotatedY);
 68138        Signed576 outerX = WideArithmetic.MultiplySigned320(
 68139            Product(outerLocalPoint.X, outerScale.X),
 68140            one);
 68141        Signed576 outerY = WideArithmetic.MultiplySigned320(
 68142            Product(outerLocalPoint.Y, outerScale.Y),
 68143            one);
 68144        Signed576 innerX = WideArithmetic.MultiplySigned320(
 68145            Product(innerFrameOffset.X, innerFrameScale.X),
 68146            one);
 68147        Signed576 innerY = WideArithmetic.MultiplySigned320(
 68148            Product(innerFrameOffset.Y, innerFrameScale.Y),
 68149            one);
 68150        bool representable = Fixed64.TryGetSignedRawRatio(
 68151                WideArithmetic.AddSigned576(
 68152                    WideArithmetic.AddSigned576(outerX, innerX),
 68153                    rotatedX),
 68154                denominator,
 68155                out Fixed64 x)
 68156            & Fixed64.TryGetSignedRawRatio(
 68157                WideArithmetic.AddSigned576(
 68158                    WideArithmetic.AddSigned576(outerY, innerY),
 68159                    rotatedY),
 68160                denominator,
 68161                out Fixed64 y);
 68162        if (!representable)
 163        {
 1164            result = default;
 1165            return false;
 166        }
 167
 67168        result = new Vector2d(x, y);
 67169        return true;
 170    }
 171
 172    internal static bool TryTransformPoint(
 173        Vector2d origin,
 174        Vector2d localPoint,
 175        Fixed64 angleInRadians,
 176        out Vector2d result) =>
 35177        TryTransformCompositePoint(
 35178            origin,
 35179            localPoint,
 35180            Vector2d.Zero,
 35181            angleInRadians,
 35182            out result);
 183
 184    internal static bool TryTransformCompositePoint(
 185        Vector2d origin,
 186        Vector2d localPoint,
 187        Vector2d localDisplacement,
 188        Fixed64 angleInRadians,
 189        out Vector2d result)
 190    {
 80191        Fixed64 cosine = FixedMath.Cos(angleInRadians);
 80192        Fixed64 sine = FixedMath.Sin(angleInRadians);
 80193        Signed576 denominator = Signed576.One;
 80194        GetRotationNumerators(
 80195            localPoint,
 80196            localDisplacement,
 80197            cosine,
 80198            sine,
 80199            out Signed320 rotatedX,
 80200            out Signed320 rotatedY);
 80201        bool representable = TryRoundCoordinate(
 80202                WideArithmetic.AddSigned320(
 80203                    Scale(origin.X),
 80204                    rotatedX),
 80205                denominator,
 80206                out Fixed64 x)
 80207            & TryRoundCoordinate(
 80208                WideArithmetic.AddSigned320(
 80209                    Scale(origin.Y),
 80210                    rotatedY),
 80211                denominator,
 80212                out Fixed64 y);
 80213        if (!representable)
 214        {
 6215            result = default;
 6216            return false;
 217        }
 218
 74219        result = new Vector2d(x, y);
 74220        return true;
 221    }
 222
 223    internal static bool TryTransformPoint(
 224        Vector2d firstOrigin,
 225        Vector2d secondOrigin,
 226        Vector2d localPoint,
 227        Fixed64 angleInRadians,
 228        out Vector2d result)
 229    {
 69230        Fixed64 cosine = FixedMath.Cos(angleInRadians);
 69231        Fixed64 sine = FixedMath.Sin(angleInRadians);
 69232        Signed576 denominator = Signed576.One;
 69233        GetRotationNumerators(
 69234            localPoint,
 69235            cosine,
 69236            sine,
 69237            out Signed320 rotatedX,
 69238            out Signed320 rotatedY);
 69239        bool representable = TryRoundCoordinate(
 69240                GetTransformNumerator(
 69241                    firstOrigin.X,
 69242                    secondOrigin.X,
 69243                    rotatedX),
 69244                denominator,
 69245                out Fixed64 x)
 69246            & TryRoundCoordinate(
 69247                GetTransformNumerator(
 69248                    firstOrigin.Y,
 69249                    secondOrigin.Y,
 69250                    rotatedY),
 69251                denominator,
 69252                out Fixed64 y);
 69253        if (!representable)
 254        {
 1255            result = default;
 1256            return false;
 257        }
 258
 68259        result = new Vector2d(x, y);
 68260        return true;
 261    }
 262
 263    internal static bool TryGetRelativeOffset(
 264        Vector2d firstOrigin,
 265        Vector2d firstOffset,
 266        Vector2d secondOrigin,
 267        Vector2d secondLocalPoint,
 268        Fixed64 angleInRadians,
 269        out Vector2d result)
 270    {
 35271        Fixed64 cosine = FixedMath.Cos(angleInRadians);
 35272        Fixed64 sine = FixedMath.Sin(angleInRadians);
 35273        Signed576 denominator = Signed576.One;
 35274        GetRotationNumerators(
 35275            secondLocalPoint,
 35276            cosine,
 35277            sine,
 35278            out Signed320 rotatedX,
 35279            out Signed320 rotatedY);
 35280        bool representable = TryRoundCoordinate(
 35281                GetRelativeNumerator(
 35282                    firstOrigin.X,
 35283                    firstOffset.X,
 35284                    secondOrigin.X,
 35285                    rotatedX),
 35286                denominator,
 35287                out Fixed64 x)
 35288            & TryRoundCoordinate(
 35289                GetRelativeNumerator(
 35290                    firstOrigin.Y,
 35291                    firstOffset.Y,
 35292                    secondOrigin.Y,
 35293                    rotatedY),
 35294                denominator,
 35295                out Fixed64 y);
 35296        if (!representable)
 297        {
 1298            result = default;
 1299            return false;
 300        }
 301
 34302        result = new Vector2d(x, y);
 34303        return true;
 304    }
 305
 306    internal static bool TryGetLocalPointIn(
 307        Vector2d pointOrigin,
 308        Vector2d pointLocalPoint,
 309        Vector2d pointLocalDisplacement,
 310        Fixed64 pointAngleInRadians,
 311        Vector2d frameOrigin,
 312        Fixed64 frameAngleInRadians,
 313        out Vector2d localPoint)
 314    {
 73315        Fixed64 pointCosine = FixedMath.Cos(pointAngleInRadians);
 73316        Fixed64 pointSine = FixedMath.Sin(pointAngleInRadians);
 73317        Fixed64 frameCosine = FixedMath.Cos(frameAngleInRadians);
 73318        Fixed64 frameSine = FixedMath.Sin(frameAngleInRadians);
 73319        GetRotationNumerators(
 73320            pointLocalPoint,
 73321            pointLocalDisplacement,
 73322            pointCosine,
 73323            pointSine,
 73324            out Signed320 pointX,
 73325            out Signed320 pointY);
 73326        Signed320 deltaX = WideArithmetic.AddSigned320(
 73327            WideArithmetic.SubtractSigned320(
 73328                Scale(pointOrigin.X),
 73329                Scale(frameOrigin.X)),
 73330            pointX);
 73331        Signed320 deltaY = WideArithmetic.AddSigned320(
 73332            WideArithmetic.SubtractSigned320(
 73333                Scale(pointOrigin.Y),
 73334                Scale(frameOrigin.Y)),
 73335            pointY);
 73336        Signed576 xNumerator = WideArithmetic.AddSigned576(
 73337            WideArithmetic.MultiplySigned576(
 73338                Signed576.ExtendValue(deltaX),
 73339                Signed192.Raw(frameCosine)),
 73340            WideArithmetic.MultiplySigned576(
 73341                Signed576.ExtendValue(deltaY),
 73342                Signed192.Raw(frameSine)));
 73343        Signed576 yNumerator = WideArithmetic.SubtractSigned576(
 73344            WideArithmetic.MultiplySigned576(
 73345                Signed576.ExtendValue(deltaY),
 73346                Signed192.Raw(frameCosine)),
 73347            WideArithmetic.MultiplySigned576(
 73348                Signed576.ExtendValue(deltaX),
 73349                Signed192.Raw(frameSine)));
 73350        Signed576 denominator = Signed576.ExtendValue(
 73351            WideArithmetic.AddSigned320(
 73352                Product(frameCosine, frameCosine),
 73353                Product(frameSine, frameSine)));
 73354        bool representable =
 73355            Fixed64.TryGetSignedRawRatio(
 73356                xNumerator,
 73357                denominator,
 73358                out Fixed64 x)
 73359            & Fixed64.TryGetSignedRawRatio(
 73360                yNumerator,
 73361                denominator,
 73362                out Fixed64 y);
 73363        localPoint = representable ? new Vector2d(x, y) : default;
 73364        return representable;
 365    }
 366
 367    internal static bool TryGetRelativeOffset(
 368        Vector2d firstOrigin,
 369        Vector2d firstLocalPoint,
 370        Fixed64 firstAngleInRadians,
 371        Vector2d secondOrigin,
 372        Vector2d secondLocalPoint,
 373        Fixed64 secondAngleInRadians,
 374        out Vector2d result) =>
 35375        TryGetRelativeOffset(
 35376            firstOrigin,
 35377            firstLocalPoint,
 35378            Vector2d.Zero,
 35379            firstAngleInRadians,
 35380            secondOrigin,
 35381            secondLocalPoint,
 35382            Vector2d.Zero,
 35383            secondAngleInRadians,
 35384            out result);
 385
 386    internal static bool TryGetRelativeOffset(
 387        Vector2d firstOrigin,
 388        Vector2d firstLocalPoint,
 389        Vector2d firstLocalDisplacement,
 390        Fixed64 firstAngleInRadians,
 391        Vector2d secondOrigin,
 392        Vector2d secondLocalPoint,
 393        Vector2d secondLocalDisplacement,
 394        Fixed64 secondAngleInRadians,
 395        out Vector2d result)
 396    {
 77397        Fixed64 firstCosine = FixedMath.Cos(firstAngleInRadians);
 77398        Fixed64 firstSine = FixedMath.Sin(firstAngleInRadians);
 77399        Fixed64 secondCosine = FixedMath.Cos(secondAngleInRadians);
 77400        Fixed64 secondSine = FixedMath.Sin(secondAngleInRadians);
 77401        Signed576 denominator = Signed576.One;
 77402        GetRotationNumerators(
 77403            firstLocalPoint,
 77404            firstLocalDisplacement,
 77405            firstCosine,
 77406            firstSine,
 77407            out Signed320 firstRotatedX,
 77408            out Signed320 firstRotatedY);
 77409        GetRotationNumerators(
 77410            secondLocalPoint,
 77411            secondLocalDisplacement,
 77412            secondCosine,
 77413            secondSine,
 77414            out Signed320 secondRotatedX,
 77415            out Signed320 secondRotatedY);
 77416        bool representable = TryRoundCoordinate(
 77417                GetRelativeNumerator(
 77418                    firstOrigin.X,
 77419                    firstRotatedX,
 77420                    secondOrigin.X,
 77421                    secondRotatedX),
 77422                denominator,
 77423                out Fixed64 x)
 77424            & TryRoundCoordinate(
 77425                GetRelativeNumerator(
 77426                    firstOrigin.Y,
 77427                    firstRotatedY,
 77428                    secondOrigin.Y,
 77429                    secondRotatedY),
 77430                denominator,
 77431                out Fixed64 y);
 77432        if (!representable)
 433        {
 2434            result = default;
 2435            return false;
 436        }
 437
 75438        result = new Vector2d(x, y);
 75439        return true;
 440    }
 441
 442    internal static void GetRotationNumerators(
 443        Vector2d localPoint,
 444        Vector2d localDisplacement,
 445        Fixed64 cosine,
 446        Fixed64 sine,
 447        out Signed320 x,
 448        out Signed320 y)
 449    {
 418450        GetRotationNumerators(
 418451            localPoint,
 418452            cosine,
 418453            sine,
 418454            out x,
 418455            out y);
 418456        GetRotationNumerators(
 418457            localDisplacement,
 418458            cosine,
 418459            sine,
 418460            out Signed320 displacementX,
 418461            out Signed320 displacementY);
 418462        x = WideArithmetic.AddSigned320(x, displacementX);
 418463        y = WideArithmetic.AddSigned320(y, displacementY);
 418464    }
 465
 466    private static void GetRotationNumerators(
 467        Vector2d localPoint,
 468        Fixed64 cosine,
 469        Fixed64 sine,
 470        out Signed320 x,
 471        out Signed320 y)
 472    {
 940473        x = WideArithmetic.SubtractSigned320(
 940474            Product(localPoint.X, cosine),
 940475            Product(localPoint.Y, sine));
 940476        y = WideArithmetic.AddSigned320(
 940477            Product(localPoint.X, sine),
 940478            Product(localPoint.Y, cosine));
 940479    }
 480
 481    private static void GetScaledRotationNumerators(
 482        Vector2d localPoint,
 483        Vector2d scale,
 484        Vector2d localDisplacement,
 485        Fixed64 cosine,
 486        Fixed64 sine,
 487        out Signed576 x,
 488        out Signed576 y)
 489    {
 137490        Signed320 localX = Product(localPoint.X, scale.X);
 137491        Signed320 localY = Product(localPoint.Y, scale.Y);
 137492        Signed320 one =
 137493            Signed320.ExtendValue(Signed192.One);
 137494        Signed576 displacementX = WideArithmetic.MultiplySigned320(
 137495            WideArithmetic.SubtractSigned320(
 137496                Product(localDisplacement.X, cosine),
 137497                Product(localDisplacement.Y, sine)),
 137498            one);
 137499        Signed576 displacementY = WideArithmetic.MultiplySigned320(
 137500            WideArithmetic.AddSigned320(
 137501                Product(localDisplacement.X, sine),
 137502                Product(localDisplacement.Y, cosine)),
 137503            one);
 137504        x = WideArithmetic.AddSigned576(
 137505            WideArithmetic.SubtractSigned576(
 137506                WideArithmetic.MultiplySigned320(
 137507                    localX,
 137508                    Signed320.ExtendValue(Signed192.Raw(cosine))),
 137509                WideArithmetic.MultiplySigned320(
 137510                    localY,
 137511                    Signed320.ExtendValue(Signed192.Raw(sine)))),
 137512            displacementX);
 137513        y = WideArithmetic.AddSigned576(
 137514            WideArithmetic.AddSigned576(
 137515                WideArithmetic.MultiplySigned320(
 137516                    localX,
 137517                    Signed320.ExtendValue(Signed192.Raw(sine))),
 137518                WideArithmetic.MultiplySigned320(
 137519                    localY,
 137520                    Signed320.ExtendValue(Signed192.Raw(cosine)))),
 137521            displacementY);
 137522    }
 523
 524    private static Signed320 GetRelativeNumerator(
 525        Fixed64 firstOrigin,
 526        Fixed64 firstOffset,
 527        Fixed64 secondOrigin,
 528        Signed320 rotatedLocalPoint) =>
 70529        WideArithmetic.SubtractSigned320(
 70530            WideArithmetic.SubtractSigned320(
 70531                WideArithmetic.AddSigned320(
 70532                    Scale(firstOrigin),
 70533                    Scale(firstOffset)),
 70534                Scale(secondOrigin)),
 70535            rotatedLocalPoint);
 536
 537    private static Signed320 GetRelativeNumerator(
 538        Fixed64 firstOrigin,
 539        Signed320 firstRotatedLocalPoint,
 540        Fixed64 secondOrigin,
 541        Signed320 secondRotatedLocalPoint) =>
 154542        WideArithmetic.SubtractSigned320(
 154543            WideArithmetic.AddSigned320(
 154544                WideArithmetic.SubtractSigned320(
 154545                    Scale(firstOrigin),
 154546                    Scale(secondOrigin)),
 154547                firstRotatedLocalPoint),
 154548            secondRotatedLocalPoint);
 549
 550    private static Signed320 GetTransformNumerator(
 551        Fixed64 firstOrigin,
 552        Fixed64 secondOrigin,
 553        Signed320 rotatedLocalPoint) =>
 138554        WideArithmetic.AddSigned320(
 138555            WideArithmetic.AddSigned320(
 138556                Scale(firstOrigin),
 138557                Scale(secondOrigin)),
 138558            rotatedLocalPoint);
 559
 560    internal static Signed320 Scale(Fixed64 value)
 561    {
 1468562        long raw = value.m_rawValue;
 1468563        ulong extension = raw < 0L ? ulong.MaxValue : 0UL;
 1468564        ulong unsignedRaw = unchecked((ulong)raw);
 1468565        return new Signed320(
 1468566            extension,
 1468567            extension,
 1468568            extension,
 1468569            (unsignedRaw >> FixedMath.SHIFT_AMOUNT_I)
 1468570                | (extension << FixedMath.SHIFT_AMOUNT_I),
 1468571            unsignedRaw << FixedMath.SHIFT_AMOUNT_I);
 572    }
 573
 574    private static Signed320 Product(Fixed64 left, Fixed64 right) =>
 5421575        WideArithmetic.MultiplySigned192(Signed192.Raw(left), Signed192.Raw(right));
 576
 577    private static bool TryInverseTransformScaledCoordinate(
 578        Signed320 projection,
 579        Signed320 rotationDenominator,
 580        Fixed64 scale,
 581        out Fixed64 result) =>
 142582        Fixed64.TryGetSignedRawRatio(
 142583            WideArithmetic.MultiplySigned320(
 142584                projection,
 142585                Product(Fixed64.One, Fixed64.One)),
 142586            WideArithmetic.MultiplySigned320(
 142587                rotationDenominator,
 142588                Signed320.ExtendValue(Signed192.Raw(scale))),
 142589            out result);
 590
 591    private static bool TryRoundCoordinate(
 592        Signed320 numerator,
 593        Signed576 denominator,
 594        out Fixed64 result) =>
 522595        Fixed64.TryGetSignedRawRatio(
 522596            Signed576.ExtendValue(numerator),
 522597            denominator,
 522598            out result);
 599
 600}
Generated by: ReportGenerator 5.5.11.0
08/04/2026 - 20:34:44
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&)