< Summary

Information
Class: FixedMathSharp.Geometry.FixedPointAnchor
Assembly: FixedMathSharp
File(s): /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Anchors/FixedPointAnchor.cs
Line coverage
100%
Covered lines: 266
Uncovered lines: 0
Coverable lines: 266
Total lines: 596
Line coverage: 100%
Branch coverage
100%
Covered branches: 86
Total branches: 86
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%
.ctor(...)100%11100%
FromValidatedFrame(...)100%11100%
FromTranslatedPoint(...)100%1010100%
.ctor(...)100%44100%
WithLocalTranslation(...)100%11100%
TryGetPoint(...)100%22100%
TryGetPointInFrame(...)100%22100%
TryGetOffsetFrom(...)100%11100%
TryGetScaledOffsetFrom(...)100%66100%
TryGetProjectedOffsetFrom(...)100%44100%
ProjectNonNegativeOffsetFrom(...)100%44100%
CompareSquaredDistance(...)100%66100%
TryGetLocalPointIn(...)100%44100%
TryReframe(...)100%1212100%
CompareLocalFeature(...)100%1616100%
GetLocalFeatureHash64()100%11100%
Equals(...)100%1010100%
Equals(...)100%22100%
GetHashCode()100%22100%
op_Equality(...)100%11100%
op_Inequality(...)100%11100%
CompareRaw(...)100%22100%
KeepHash(...)100%11100%

File(s)

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Anchors/FixedPointAnchor.cs

#LineLine coverage
 1//=======================================================================
 2// FixedPointAnchor.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
 8using System;
 9
 10namespace FixedMathSharp.Geometry;
 11
 12/// <summary>
 13/// Represents a 3D point as a local coordinate in one rigid world-space frame.
 14/// </summary>
 15/// <remarks>
 16/// Keeping the frame components separate allows full-domain geometry to retain
 17/// points whose rotated offset or absolute world coordinate is not representable
 18/// as an intermediate <see cref="Fixed64"/> value.
 19/// Relation-produced anchors can also retain an exact sub-lattice feature term
 20/// that is intentionally not exposed as a public wide-arithmetic primitive.
 21/// Consequently, anchors with identical rounded public local components can
 22/// still compare unequal when they identify distinct exact features.
 23/// </remarks>
 24public readonly struct FixedPointAnchor : IEquatable<FixedPointAnchor>
 25{
 26    /// <summary>
 27    /// Initializes a point anchor from a world origin, normalized local-to-world
 28    /// rotation, and local point.
 29    /// </summary>
 30    /// <exception cref="ArgumentException">
 31    /// <paramref name="rotation"/> is not normalized.
 32    /// </exception>
 33    public FixedPointAnchor(
 34        Vector3d origin,
 35        FixedQuaternion rotation,
 36        Vector3d localPoint)
 1456337        : this(origin, rotation, localPoint, Vector3d.Zero)
 1456238    { }
 39
 40    /// <summary>
 41    /// Initializes a point anchor from a world origin, normalized local-to-world
 42    /// rotation, and two additive local-space feature components.
 43    /// </summary>
 44    /// <exception cref="ArgumentException">
 45    /// <paramref name="rotation"/> is not normalized.
 46    /// </exception>
 47    public FixedPointAnchor(
 48        Vector3d origin,
 49        FixedQuaternion rotation,
 50        Vector3d localPoint,
 51        Vector3d localDisplacement)
 1640052        : this(
 1640053            origin,
 1640054            rotation,
 1640055            localPoint,
 1640056            localDisplacement,
 1640057            Vector3d.Zero,
 1640058            default,
 1640059            validateRotation: true)
 1639960    { }
 61
 62    internal FixedPointAnchor(
 63        Vector3d origin,
 64        FixedQuaternion rotation,
 65        Vector3d localPoint,
 66        Vector3d localDisplacement,
 67        FixedPointAnchorTerm3d exactLocalTerm)
 987468        : this(
 987469            origin,
 987470            rotation,
 987471            localPoint,
 987472            localDisplacement,
 987473            Vector3d.Zero,
 987474            exactLocalTerm,
 987475            validateRotation: true)
 987476    { }
 77
 78    internal static FixedPointAnchor FromValidatedFrame(
 79        Vector3d origin,
 80        FixedQuaternion rotation,
 81        Vector3d localPoint) =>
 74282        new(
 74283            origin,
 74284            rotation,
 74285            localPoint,
 74286            Vector3d.Zero,
 74287            Vector3d.Zero,
 74288            default,
 74289            validateRotation: false);
 90
 91    /// <summary>Retains an already rounded common-frame point under another world origin without narrowing its offset.<
 92    internal static FixedPointAnchor FromTranslatedPoint(Vector3d anchorOrigin, Vector3d samplingOrigin, Vector3d rounde
 93    {
 34494        if (Vector3d.TryAddSubtract(samplingOrigin, roundedOffset, anchorOrigin, out Vector3d localPoint))
 22395            return FromValidatedFrame(anchorOrigin, FixedQuaternion.Identity, localPoint);
 96
 12197        Span<Vector3d> components = stackalloc Vector3d[3];
 12198        Vector3d residual = Vector3d.Zero;
 96899        for (int axis = 0; axis < 3; axis++)
 100        {
 363101            Signed192 remaining = WideArithmetic.SubtractSigned192(WideArithmetic.AddSigned192(
 363102                Signed192.Raw(samplingOrigin[axis]), Signed192.Raw(roundedOffset[axis])), Signed192.Raw(anchorOrigin[axi
 2904103            for (int term = 0; term < 3; term++)
 104            {
 1089105                long raw = WideArithmetic.SubtractSigned192(remaining, Signed192.Signed(long.MaxValue)).Sign > 0 ? long.
 1089106                    : WideArithmetic.SubtractSigned192(remaining, Signed192.Signed(long.MinValue)).Sign < 0 ? long.MinVa
 1089107                    : unchecked((long)remaining.Low);
 1089108                components[term][axis] = Fixed64.FromRaw(raw);
 1089109                remaining = WideArithmetic.SubtractSigned192(remaining, Signed192.Signed(raw));
 110            }
 111            // This is a decomposition, not a clamp: all remainders are retained.
 112            // The exact three-term sum is in [3*Min+1,3*Max+1]. Signed scalar
 113            // asymmetry can leave one positive raw unit after three Max terms;
 114            // the existing feature residual stores that unit without a new field.
 363115            residual[axis] = Fixed64.FromRaw(unchecked((long)remaining.Low));
 116        }
 121117        return new FixedPointAnchor(anchorOrigin, FixedQuaternion.Identity, components[0], components[1], components[2],
 121118            FixedPointAnchorTerm3d.CreateRadialSupport(residual, Fixed64.One, Vector3d.Zero), validateRotation: false);
 119    }
 120
 121    private FixedPointAnchor(
 122        Vector3d origin,
 123        FixedQuaternion rotation,
 124        Vector3d localPoint,
 125        Vector3d localDisplacement,
 126        Vector3d localTranslation,
 127        FixedPointAnchorTerm3d exactLocalTerm,
 128        bool validateRotation)
 129    {
 27144130        if (validateRotation && !rotation.IsNormalized())
 1131            throw new ArgumentException("The point-anchor rotation must be normalized.", nameof(rotation));
 132
 27143133        Origin = origin;
 27143134        Rotation = rotation;
 27143135        LocalPoint = localPoint;
 27143136        LocalDisplacement = localDisplacement;
 27143137        LocalTranslation = localTranslation;
 27143138        ExactLocalTerm = exactLocalTerm;
 27143139    }
 140
 141    /// <summary>
 142    /// The world-space origin of the rigid frame.
 143    /// </summary>
 144    public Vector3d Origin { get; }
 145
 146    /// <summary>
 147    /// The normalized local-to-world rotation of the rigid frame.
 148    /// </summary>
 149    public FixedQuaternion Rotation { get; }
 150
 151    /// <summary>
 152    /// The point in the rigid frame's local coordinates.
 153    /// </summary>
 154    public Vector3d LocalPoint { get; }
 155
 156    /// <summary>
 157    /// An additional local-space feature displacement that exact operations
 158    /// add to <see cref="LocalPoint"/> without a scalar intermediate.
 159    /// </summary>
 160    public Vector3d LocalDisplacement { get; }
 161
 162    /// <summary>
 163    /// An independent local-space translation applied to the complete anchored
 164    /// point without merging it into either feature component.
 165    /// </summary>
 166    public Vector3d LocalTranslation { get; }
 167
 168    internal FixedPointAnchorTerm3d ExactLocalTerm { get; }
 169
 170    /// <summary>
 171    /// Returns an anchor for the same exact local feature with the specified
 172    /// independent local-space translation.
 173    /// </summary>
 174    public FixedPointAnchor WithLocalTranslation(
 175        Vector3d localTranslation) =>
 7176        new(
 7177            Origin,
 7178            Rotation,
 7179            LocalPoint,
 7180            LocalDisplacement,
 7181            localTranslation,
 7182            ExactLocalTerm,
 7183            validateRotation: true);
 184
 185    /// <summary>
 186    /// Attempts to materialize the absolute world point.
 187    /// </summary>
 188    public bool TryGetPoint(out Vector3d point)
 189    {
 5144190        if (!Rotation.IsNormalized())
 191        {
 1192            point = default;
 1193            return false;
 194        }
 195
 5143196        return WidePointAnchor3d.TryGetPoint(
 5143197            Origin,
 5143198            Rotation,
 5143199            LocalPoint,
 5143200            LocalDisplacement,
 5143201            LocalTranslation,
 5143202            ExactLocalTerm,
 5143203            out point);
 204    }
 205
 206    /// <summary>Rounds on the world lattice before expressing the point relative to a sampling origin.</summary>
 207    internal bool TryGetPointInFrame(Vector3d samplingOrigin, out Vector3d point)
 208    {
 354209        if (!Rotation.IsNormalized())
 210        {
 1211            point = default;
 1212            return false;
 213        }
 353214        return WidePointAnchor3d.TryGetPointInFrame(this, samplingOrigin, out point);
 215    }
 216
 217    /// <summary>
 218    /// Attempts to materialize this point's world-space offset from
 219    /// <paramref name="other"/>.
 220    /// </summary>
 221    public bool TryGetOffsetFrom(
 222        in FixedPointAnchor other,
 223        out Vector3d offset) =>
 1563224        TryGetScaledOffsetFrom(other, Fixed64.One, out offset);
 225
 226    /// <summary>
 227    /// Attempts to materialize this point's world-space offset from
 228    /// <paramref name="other"/> after applying <paramref name="scale"/>.
 229    /// </summary>
 230    /// <remarks>
 231    /// The scale is applied to the complete conceptual difference before its
 232    /// final round-half-to-even conversion.
 233    /// </remarks>
 234    public bool TryGetScaledOffsetFrom(
 235        in FixedPointAnchor other,
 236        Fixed64 scale,
 237        out Vector3d offset)
 238    {
 1838239        if (!Rotation.IsNormalized() || !other.Rotation.IsNormalized())
 240        {
 2241            offset = default;
 2242            return false;
 243        }
 1836244        if (scale == Fixed64.Zero)
 245        {
 2246            offset = Vector3d.Zero;
 2247            return true;
 248        }
 249
 1834250        return WidePointAnchor3d.TryGetRelativeOffset(
 1834251            Origin,
 1834252            Rotation,
 1834253            LocalPoint,
 1834254            LocalDisplacement,
 1834255            LocalTranslation,
 1834256            ExactLocalTerm,
 1834257            other.Origin,
 1834258            other.Rotation,
 1834259            other.LocalPoint,
 1834260            other.LocalDisplacement,
 1834261            other.LocalTranslation,
 1834262            other.ExactLocalTerm,
 1834263            scale,
 1834264            out offset);
 265    }
 266
 267    /// <summary>
 268    /// Attempts to project this point minus <paramref name="other"/> onto
 269    /// <paramref name="direction"/> with one final round-half-to-even
 270    /// conversion.
 271    /// </summary>
 272    public bool TryGetProjectedOffsetFrom(
 273        in FixedPointAnchor other,
 274        Vector3d direction,
 275        out Fixed64 projection)
 276    {
 280277        if (!Rotation.IsNormalized() || !other.Rotation.IsNormalized())
 278        {
 2279            projection = default;
 2280            return false;
 281        }
 282
 278283        return WidePointAnchor3d.TryGetProjectedOffset(
 278284            Origin,
 278285            Rotation,
 278286            LocalPoint,
 278287            LocalDisplacement,
 278288            LocalTranslation,
 278289            ExactLocalTerm,
 278290            other.Origin,
 278291            other.Rotation,
 278292            other.LocalPoint,
 278293            other.LocalDisplacement,
 278294            other.LocalTranslation,
 278295            other.ExactLocalTerm,
 278296            direction,
 278297            out projection);
 298    }
 299
 300    /// <summary>
 301    /// Projects this point minus <paramref name="other"/> onto
 302    /// <paramref name="direction"/> and returns zero for nonpositive results,
 303    /// the positive projection floored to Q32.32, or
 304    /// <see cref="Fixed64.MaxValue"/> when only the final result is
 305    /// unrepresentable.
 306    /// </summary>
 307    /// <exception cref="InvalidOperationException">
 308    /// This anchor does not contain a normalized rotation.
 309    /// </exception>
 310    /// <exception cref="ArgumentException">
 311    /// <paramref name="other"/> does not contain a normalized rotation.
 312    /// </exception>
 313    public Fixed64 ProjectNonNegativeOffsetFrom(
 314        in FixedPointAnchor other,
 315        Vector3d direction)
 316    {
 291317        if (!Rotation.IsNormalized())
 318        {
 1319            throw new InvalidOperationException(
 1320                "The point anchor must have a normalized rotation.");
 321        }
 290322        if (!other.Rotation.IsNormalized())
 323        {
 1324            throw new ArgumentException(
 1325                "The other point anchor must have a normalized rotation.",
 1326                nameof(other));
 327        }
 328
 289329        return WidePointAnchor3d.ProjectNonNegativeOffset(
 289330            Origin,
 289331            Rotation,
 289332            LocalPoint,
 289333            LocalDisplacement,
 289334            LocalTranslation,
 289335            ExactLocalTerm,
 289336            other.Origin,
 289337            other.Rotation,
 289338            other.LocalPoint,
 289339            other.LocalDisplacement,
 289340            other.LocalTranslation,
 289341            other.ExactLocalTerm,
 289342            direction);
 343    }
 344
 345    /// <summary>
 346    /// Compares the exact squared distance from this point to two other
 347    /// anchored points.
 348    /// </summary>
 349    /// <returns>
 350    /// A negative value when <paramref name="first"/> is closer, zero when the
 351    /// distances are equal, or a positive value when
 352    /// <paramref name="second"/> is closer.
 353    /// </returns>
 354    public int CompareSquaredDistance(
 355        in FixedPointAnchor first,
 356        in FixedPointAnchor second)
 357    {
 45358        if (!Rotation.IsNormalized())
 359        {
 1360            throw new InvalidOperationException(
 1361                "The reference point anchor must have a normalized rotation.");
 362        }
 44363        if (!first.Rotation.IsNormalized())
 364        {
 1365            throw new ArgumentException(
 1366                "The first point anchor must have a normalized rotation.",
 1367                nameof(first));
 368        }
 43369        if (!second.Rotation.IsNormalized())
 370        {
 1371            throw new ArgumentException(
 1372                "The second point anchor must have a normalized rotation.",
 1373                nameof(second));
 374        }
 375
 42376        return WidePointAnchor3d.CompareSquaredDistances(
 42377            this,
 42378            first,
 42379            second);
 380    }
 381
 382    /// <summary>
 383    /// Attempts to express this point in another rigid frame's local
 384    /// coordinates without first materializing its absolute world position.
 385    /// </summary>
 386    public bool TryGetLocalPointIn(
 387        Vector3d frameOrigin,
 388        FixedQuaternion frameRotation,
 389        out Vector3d localPoint)
 390    {
 4812391        if (!frameRotation.IsNormalized())
 392        {
 1393            localPoint = default;
 1394            return false;
 395        }
 4811396        if (!Rotation.IsNormalized())
 397        {
 1398            localPoint = default;
 1399            return false;
 400        }
 401
 4810402        return WidePointAnchor3d.TryGetLocalPointIn(
 4810403            Origin,
 4810404            Rotation,
 4810405            LocalPoint,
 4810406            LocalDisplacement,
 4810407            LocalTranslation,
 4810408            ExactLocalTerm,
 4810409            frameOrigin,
 4810410            frameRotation,
 4810411            out localPoint);
 412    }
 413
 414    /// <summary>
 415    /// Attempts to express this exact conceptual point in another rigid frame
 416    /// without discarding any sub-lattice feature information.
 417    /// </summary>
 418    /// <remarks>
 419    /// The operation fails when the target frame would require a general
 420    /// rational local coordinate that a compact point anchor cannot retain.
 421    /// </remarks>
 422    public bool TryReframe(
 423        Vector3d frameOrigin,
 424        FixedQuaternion frameRotation,
 425        out FixedPointAnchor anchor)
 426    {
 7427        if (!Rotation.IsNormalized()
 7428            || !frameRotation.IsNormalized())
 429        {
 2430            anchor = default;
 2431            return false;
 432        }
 5433        if (Origin == frameOrigin && Rotation == frameRotation)
 434        {
 1435            anchor = this;
 1436            return true;
 437        }
 4438        if (!TryGetLocalPointIn(
 4439                frameOrigin,
 4440                frameRotation,
 4441                out Vector3d localPoint))
 442        {
 1443            anchor = default;
 1444            return false;
 445        }
 446
 3447        var candidate = new FixedPointAnchor(
 3448            frameOrigin,
 3449            frameRotation,
 3450            localPoint);
 3451        if (!WidePointAnchor3d.RepresentsSamePoint(this, candidate))
 452        {
 1453            anchor = default;
 1454            return false;
 455        }
 456
 2457        anchor = candidate;
 2458        return true;
 459    }
 460
 461    /// <summary>
 462    /// Compares the complete local feature identity of this anchor with
 463    /// <paramref name="other"/> in deterministic component order.
 464    /// </summary>
 465    /// <remarks>
 466    /// Frame origin, rotation, and <see cref="LocalTranslation"/> are
 467    /// intentionally excluded because they move a feature without changing
 468    /// its local identity. Exact sub-lattice centered-axis residuals are
 469    /// included after the public feature components, so distinct features
 470    /// cannot collapse when their rounded local coordinates are equal.
 471    /// </remarks>
 472    public int CompareLocalFeature(in FixedPointAnchor other)
 473    {
 266474        int comparison = CompareRaw(
 266475            LocalPoint.X.m_rawValue,
 266476            other.LocalPoint.X.m_rawValue);
 266477        if (comparison != 0)
 2478            return comparison;
 264479        comparison = CompareRaw(
 264480            LocalPoint.Y.m_rawValue,
 264481            other.LocalPoint.Y.m_rawValue);
 264482        if (comparison != 0)
 2483            return comparison;
 262484        comparison = CompareRaw(
 262485            LocalPoint.Z.m_rawValue,
 262486            other.LocalPoint.Z.m_rawValue);
 262487        if (comparison != 0)
 2488            return comparison;
 260489        comparison = CompareRaw(
 260490            LocalDisplacement.X.m_rawValue,
 260491            other.LocalDisplacement.X.m_rawValue);
 260492        if (comparison != 0)
 2493            return comparison;
 258494        comparison = CompareRaw(
 258495            LocalDisplacement.Y.m_rawValue,
 258496            other.LocalDisplacement.Y.m_rawValue);
 258497        if (comparison != 0)
 2498            return comparison;
 256499        comparison = CompareRaw(
 256500            LocalDisplacement.Z.m_rawValue,
 256501            other.LocalDisplacement.Z.m_rawValue);
 256502        if (comparison != 0)
 2503            return comparison;
 254504        comparison = CompareRaw(
 254505            ExactLocalTerm.X,
 254506            other.ExactLocalTerm.X);
 254507        if (comparison != 0)
 7508            return comparison;
 247509        comparison = CompareRaw(
 247510            ExactLocalTerm.Y,
 247511            other.ExactLocalTerm.Y);
 247512        return comparison != 0
 247513            ? comparison
 247514            : CompareRaw(
 247515                ExactLocalTerm.Z,
 247516                other.ExactLocalTerm.Z);
 517    }
 518
 519    /// <summary>
 520    /// Returns a stable 64-bit hash of the complete local feature identity.
 521    /// </summary>
 522    public ulong GetLocalFeatureHash64()
 523    {
 24524        ulong hash = 14695981039346656037UL;
 24525        KeepHash(ref hash, LocalPoint.X.m_rawValue);
 24526        KeepHash(ref hash, LocalPoint.Y.m_rawValue);
 24527        KeepHash(ref hash, LocalPoint.Z.m_rawValue);
 24528        KeepHash(ref hash, LocalDisplacement.X.m_rawValue);
 24529        KeepHash(ref hash, LocalDisplacement.Y.m_rawValue);
 24530        KeepHash(ref hash, LocalDisplacement.Z.m_rawValue);
 24531        KeepHash(ref hash, ExactLocalTerm.X);
 24532        KeepHash(ref hash, ExactLocalTerm.Y);
 24533        KeepHash(ref hash, ExactLocalTerm.Z);
 24534        return hash;
 535    }
 536
 537    /// <summary>
 538    /// Returns whether both anchors have identical frames, rounded local
 539    /// components, and any retained exact feature identity.
 540    /// </summary>
 541    public bool Equals(FixedPointAnchor other) =>
 830542        Origin.Equals(other.Origin)
 830543        && Rotation.Equals(other.Rotation)
 830544        && LocalPoint.Equals(other.LocalPoint)
 830545        && LocalDisplacement.Equals(other.LocalDisplacement)
 830546        && LocalTranslation.Equals(other.LocalTranslation)
 830547        && ExactLocalTerm.Equals(other.ExactLocalTerm);
 548
 549    /// <summary>
 550    /// Returns a hash code for the complete frame and exact feature identity.
 551    /// </summary>
 552    public override bool Equals(object? obj) =>
 438553        obj is FixedPointAnchor other && Equals(other);
 554
 555    /// <inheritdoc />
 556    public override int GetHashCode()
 557    {
 558        unchecked
 559        {
 5560            int hash = 17;
 5561            hash = (hash * 31) + Origin.GetHashCode();
 5562            hash = (hash * 31) + Rotation.GetHashCode();
 5563            hash = (hash * 31) + LocalPoint.GetHashCode();
 5564            hash = (hash * 31) + LocalDisplacement.GetHashCode();
 5565            hash = (hash * 31) + LocalTranslation.GetHashCode();
 5566            if (!ExactLocalTerm.IsZero)
 2567                hash = (hash * 31) + ExactLocalTerm.GetHashCode();
 5568            return hash;
 569        }
 570    }
 571
 572    /// <summary>
 573    /// Returns whether two point anchors have identical frame components.
 574    /// </summary>
 575    public static bool operator ==(
 576        FixedPointAnchor left,
 577        FixedPointAnchor right) =>
 289578        left.Equals(right);
 579
 580    /// <summary>
 581    /// Returns whether two point anchors have different frame components.
 582    /// </summary>
 583    public static bool operator !=(
 584        FixedPointAnchor left,
 585        FixedPointAnchor right) =>
 1586        !left.Equals(right);
 587
 588    private static int CompareRaw(long left, long right) =>
 2307589        left < right ? -1 : left > right ? 1 : 0;
 590
 591    private static void KeepHash(ref ulong hash, long value)
 592    {
 216593        hash ^= unchecked((ulong)value);
 216594        hash *= 1099511628211UL;
 216595    }
 596}
Generated by: ReportGenerator 5.5.12.0
11/04/2026 - 16:26:30
GitHub | reportgenerator.io

Methods/Properties

.ctor(FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Vector3d)
.ctor(FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
.ctor(FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Geometry.FixedPointAnchorTerm3d)
FromValidatedFrame(FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Vector3d)
FromTranslatedPoint(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
.ctor(FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Geometry.FixedPointAnchorTerm3d,System.Boolean)
WithLocalTranslation(FixedMathSharp.Vector3d)
TryGetPoint(FixedMathSharp.Vector3d&)
TryGetPointInFrame(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d&)
TryGetOffsetFrom(FixedMathSharp.Geometry.FixedPointAnchor&,FixedMathSharp.Vector3d&)
TryGetScaledOffsetFrom(FixedMathSharp.Geometry.FixedPointAnchor&,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&)
TryGetProjectedOffsetFrom(FixedMathSharp.Geometry.FixedPointAnchor&,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64&)
ProjectNonNegativeOffsetFrom(FixedMathSharp.Geometry.FixedPointAnchor&,FixedMathSharp.Vector3d)
CompareSquaredDistance(FixedMathSharp.Geometry.FixedPointAnchor&,FixedMathSharp.Geometry.FixedPointAnchor&)
TryGetLocalPointIn(FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Vector3d&)
TryReframe(FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Geometry.FixedPointAnchor&)
CompareLocalFeature(FixedMathSharp.Geometry.FixedPointAnchor&)
GetLocalFeatureHash64()
Equals(FixedMathSharp.Geometry.FixedPointAnchor)
Equals(System.Object)
GetHashCode()
op_Equality(FixedMathSharp.Geometry.FixedPointAnchor,FixedMathSharp.Geometry.FixedPointAnchor)
op_Inequality(FixedMathSharp.Geometry.FixedPointAnchor,FixedMathSharp.Geometry.FixedPointAnchor)
CompareRaw(System.Int64,System.Int64)
KeepHash(System.UInt64&,System.Int64)