Vector3F

public struct Vector3F : IPosition
{
    // Returns true if <paramref name="a"/> does not equal <paramref name="b"/>
    public static bool operator !=(Vector3F a, Vector3F b);

    // Returns true if all components of <paramref name="a"/> are greater than or equal to those of <paramref name="b"/>
    public static bool operator >=(Vector3F a, Vector3F b);

    // Returns true if all components of <paramref name="a"/> are greater than those of <paramref name="b"/>
    public static bool operator >(Vector3F a, Vector3F b);

    // Returns the cross product of <paramref name="a"/> and <paramref name="b"/>
    public static Vector3F Cross(Vector3F a, Vector3F b);

    // Returns the dot product of <paramref name="a"/> and <paramref name="b"/>
    public static float Dot(Vector3F a, Vector3F b);

    public override bool Equals(object obj);

    // Gets or sets a component by index (0=X, 1=Y, 2=Z)
    public float this[int index];

    // Creates a direction vector from pitch and yaw angles in radians
    public static Vector3F FromPitchYaw(float pitch, float yaw);

    public override int GetHashCode();

    // IPosition implementation, returns itself
    public Vector3F GetPosition();

    // Returns true if any component of this vector is greater than the corresponding component in the other vector
    public bool GreaterAny(Vector3F v);

    // Returns true if any component of this vector is greater than or equal to the corresponding component in the other vector
    public bool GreaterEqualAny(Vector3F v);

    // Returns true if all components of this vector equal those of <paramref name="other"/>
    public bool IsEqual(Vector3F other);

    // Interpolates from one vector to another
    public static Vector3F Lerp(Vector3F a, Vector3F b, float c);

    // Returns true if any component of this vector is less than the corresponding component in the other vector
    public bool LessAny(Vector3F v);

    // Returns true if any component of this vector is less than or equal to the corresponding component in the other vector
    public bool LessEqualAny(Vector3F v);

    // The length of this vector
    public float Magnitude;

    // Returns the component-wise maximum of <paramref name="a"/> and <paramref name="b"/>
    public static Vector3F Max(Vector3F a, Vector3F b);

    // A vector with all components set to MaxValue
    public static Vector3F MAX = new(float.MaxValue);

    // Returns the component-wise minimum of <paramref name="a"/> and <paramref name="b"/>
    public static Vector3F Min(Vector3F a, Vector3F b);

    // A vector with all components set to MinValue
    public static Vector3F MIN = new(float.MinValue);

    // Transforms a vector by a matrix, ignoring translation
    public Vector3F MultiplyOnly(Matrix4F b);

    // Normalizes this vector in place
    public void Normalize();

    // Returns a normalized copy of this vector
    public Vector3F Normalized;

    // A vector with all components set to one
    public static Vector3F One = new(1);

    // Returns true if all components of <paramref name="a"/> are less than those of <paramref name="b"/>
    public static bool operator <(Vector3F a, Vector3F b);

    // Returns true if all components of <paramref name="a"/> are less than or equal to those of <paramref name="b"/>
    public static bool operator <=(Vector3F a, Vector3F b);

    // Returns true if <paramref name="a"/> equals <paramref name="b"/>
    public static bool operator ==(Vector3F a, Vector3F b);

    // Converts to Vector3
    public System.Numerics.Vector3 ToNumerics();

    public override string ToString();

    // Transforms a normal vector by a matrix, ignoring translation
    public static Vector3F TransformNormal(Vector3F a, Matrix4F b);

    // A unit vector pointing upward (0, 1, 0)
    public static Vector3F Up = new(0, 1, 0);

    // Scales <paramref name="a"/> by scalar <paramref name="b"/>
    public static Vector3F operator *(float b, Vector3F a);

    // Scales <paramref name="a"/> by scalar <paramref name="b"/>
    public static Vector3F operator *(Vector3F a, float b);

    // Transforms a vector by a matrix, including translation
    public static Vector3F operator *(Vector3F a, Matrix4F b);

    // Returns the component-wise product of <paramref name="a"/> and <paramref name="b"/>
    public static Vector3F operator *(Vector3F a, Vector3F b);

    // Returns the component-wise sum of <paramref name="a"/> and <paramref name="b"/>
    public static Vector3F operator +(Vector3F a, Vector3F b);

    // Returns the negation of <paramref name="a"/>
    public static Vector3F operator -(Vector3F a);

    // Returns the component-wise difference of <paramref name="a"/> and <paramref name="b"/>
    public static Vector3F operator -(Vector3F a, Vector3F b);

    // Divides scalar <paramref name="b"/> by each component of <paramref name="a"/>
    public static Vector3F operator /(float b, Vector3F a);

    // Divides <paramref name="a"/> by scalar <paramref name="b"/>
    public static Vector3F operator /(Vector3F a, float b);

    // Returns the component-wise quotient of <paramref name="a"/> and <paramref name="b"/>
    public static Vector3F operator /(Vector3F a, Vector3F b);

    // Creates a vector with all components set to <paramref name="v"/>
    public Vector3F(float v);

    // Creates a vector with the specified components
    public Vector3F(float x, float y, float z);

    // Creates a vector from a Vector3
    public Vector3F(System.Numerics.Vector3 v);

    // The X component
    public float X;

    // The Y component
    public float Y;

    // The Z component
    public float Z;

    // A vector with all components set to zero
    public static Vector3F Zero = new(0);
}