Puppet2D.System/Vector2.cs - master - EugenyCh7/Puppet2D.Net

Puppet2D.System/Vector2.cs
319 строк11 KB
EugenyCh7
++Vector2
26 авг 2025, 21:18
26 авг 2025, 21:188f4cd8d
using System;
using System.Runtime.InteropServices;

namespace Puppet2D.System
{
    /// <summary>
    /// Vector2 is an utility class for manipulating 2 dimensional
    /// vectors with float components
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct Vector2 : IEquatable<Vector2>
    {
        /// <summary>X (horizontal) component of the vector</summary>
        public float X;

        /// <summary>Y (vertical) component of the vector</summary>
        public float Y;

        /// <summary>
        /// Construct the vector from its coordinates
        /// </summary>
        /// <param name="x">X coordinate</param>
        /// <param name="y">Y coordinate</param>
        public Vector2(float x, float y)
        {
            X = x;
            Y = y;
        }

        /// <summary>
        /// Construct the vector from its coordinates
        /// </summary>
        /// <param name="xy">X and Y coordinates</param>
        public Vector2(float xy)
        {
            X = xy;
            Y = xy;
        }

        /// <summary>
        /// Deconstructs a Vector2 into a tuple of floats
        /// </summary>
        /// <param name="x">X coordinate</param>
        /// <param name="y">Y coordinate</param>
        public void Deconstruct(out float x, out float y)
        {
            x = X;
            y = Y;
        }

        /// <summary>
        /// Operator - overload ; returns the opposite of a vector
        /// </summary>
        /// <param name="v">Vector to negate</param>
        /// <returns>-v</returns>
        public static Vector2 operator -(Vector2 v) => new Vector2(-v.X, -v.Y);

        /// <summary>
        /// Operator - overload ; subtracts two vectors
        /// </summary>
        /// <param name="v1">First vector</param>
        /// <param name="v2">Second vector</param>
        /// <returns>v1 - v2</returns>
        public static Vector2 operator -(Vector2 v1, Vector2 v2) => new Vector2(v1.X - v2.X, v1.Y - v2.Y);

        /// <summary>
        /// Operator + overload ; add two vectors
        /// </summary>
        /// <param name="v1">First vector</param>
        /// <param name="v2">Second vector</param>
        /// <returns>v1 + v2</returns>
        public static Vector2 operator +(Vector2 v1, Vector2 v2) => new Vector2(v1.X + v2.X, v1.Y + v2.Y);

        /// <summary>
        /// Operator * overload ; multiply two vectors
        /// </summary>
        /// <param name="v1">First vector</param>
        /// <param name="v2">Second vector</param>
        /// <returns>v1 * v2</returns>
        public static Vector2 operator *(Vector2 v1, Vector2 v2) => new Vector2(v1.X * v2.X, v1.Y * v2.Y);

        /// <summary>
        /// Operator * overload ; multiply a vector by a scalar value
        /// </summary>
        /// <param name="v">Vector</param>
        /// <param name="x">Scalar value</param>
        /// <returns>v * x</returns>
        public static Vector2 operator *(Vector2 v, float x) => new Vector2(v.X * x, v.Y * x);

        /// <summary>
        /// Operator * overload ; multiply a scalar value by a vector
        /// </summary>
        /// <param name="x">Scalar value</param>
        /// <param name="v">Vector</param>
        /// <returns>x * v</returns>
        public static Vector2 operator *(float x, Vector2 v) => new Vector2(v.X * x, v.Y * x);

        /// <summary>
        /// Operator / overload ; divide a vector by a scalar value
        /// </summary>
        /// <param name="v">Vector</param>
        /// <param name="x">Scalar value</param>
        /// <returns>v / x</returns>
        public static Vector2 operator /(Vector2 v, float x) => new Vector2(v.X / x, v.Y / x);

        /// <summary>
        /// Operator == overload ; check vector equality
        /// </summary>
        /// <param name="v1">First vector</param>
        /// <param name="v2">Second vector</param>
        /// <returns>v1 == v2</returns>
        public static bool operator ==(Vector2 v1, Vector2 v2) => v1.Equals(v2);

        /// <summary>
        /// Operator != overload ; check vector inequality
        /// </summary>
        /// <param name="v1">First vector</param>
        /// <param name="v2">Second vector</param>
        /// <returns>v1 != v2</returns>
        public static bool operator !=(Vector2 v1, Vector2 v2) => !v1.Equals(v2);

        /// <summary>
        /// Provide a string describing the object
        /// </summary>
        /// <returns>String description of the object</returns>
        public override string ToString() => $"[Vector2] X({X}) Y({Y})";

        /// <summary>
        /// Compare vector and object and checks if they are equal
        /// </summary>
        /// <param name="obj">Object to check</param>
        /// <returns>Object and vector are equal</returns>
        public override bool Equals(object obj) => obj is Vector2 && Equals((Vector2)obj);

        /// <summary>
        /// Compare two vectors and checks if they are equal
        /// </summary>
        /// <param name="other">Vector to check</param>
        /// <returns>Vectors are equal</returns>
        public bool Equals(Vector2 other) => X == other.X && Y == other.Y;

        /// <summary>
        /// Provide a integer describing the object
        /// </summary>
        /// <returns>Integer description of the object</returns>
        public override int GetHashCode() => X.GetHashCode() ^ Y.GetHashCode();

        /// <summary>
        /// Explicit casting to another vector type
        /// </summary>
        /// <param name="v">Vector being casted</param>
        /// <returns>Casting result</returns>
        public static explicit operator Vector2i(Vector2 v) => new Vector2i((int)v.X, (int)v.Y);

        /// <summary>
        /// Explicit casting to another vector type
        /// </summary>
        /// <param name="v">Vector being casted</param>
        /// <returns>Casting result</returns>
        public static explicit operator Vector2u(Vector2 v) => new Vector2u((uint)v.X, (uint)v.Y);

        /// <summary>
        /// Converts a tuple of floats to a Vector2
        /// </summary>
        /// <param name="tuple">The tuple to convert</param>
        public static implicit operator Vector2((float X, float Y) tuple) => new Vector2(tuple.X, tuple.Y);

        /// <summary>
        /// Zero vector (0, 0)
        /// </summary>
        public static Vector2 Zero => new Vector2(0f, 0f);

        /// <summary>
        /// One vector (1, 1)
        /// </summary>
        public static Vector2 One => new Vector2(1f, 1f);

        /// <summary>
        /// Unit vector along the X axis (1, 0)
        /// </summary>
        public static Vector2 UnitX => new Vector2(1f, 0f);

        /// <summary>
        /// Unit vector along the Y axis (0, 1)
        /// </summary>
        public static Vector2 UnitY => new Vector2(0f, 1f);

        /// <summary>
        /// Rotates the vector by a given angle in radians around the origin
        /// </summary>
        /// <param name="angle">Angle in radians</param>
        /// <returns>Rotated vector</returns>
        public Vector2 Rotate(float angle)
        {
            return new Vector2(
                X * MathF.Cos(angle) - Y * MathF.Sin(angle),
                X * MathF.Sin(angle) + Y * MathF.Cos(angle));
        }

        /// <summary>
        /// Rotates the vector by a given angle in radians around a specified origin point
        /// </summary>
        /// <param name="angle">Angle in radians</param>
        /// <param name="origin">Origin point to rotate around</param>
        /// <returns>Rotated vector</returns>
        public Vector2 Rotate(float angle, Vector2 origin)
        {
            return (this - origin).Rotate(angle) + origin;
        }

        /// <summary>
        /// Gets the length (magnitude) of the vector
        /// </summary>
        public float Length
        {
            get => MathF.Sqrt(X * X + Y * Y);
        }

        /// <summary>
        /// Gets a vector containing the absolute values of the current vector's components
        /// </summary>
        public Vector2 Abs
        {
            get => new Vector2(MathF.Abs(X), MathF.Abs(Y));
        }

        /// <summary>
        /// Gets the angle in radians between the positive X-axis and the vector
        /// </summary>
        public float Angle
        {
            get => MathF.Atan2(Y, X);
        }

        /// <summary>
        /// Gets the normalized (unit) vector of the current vector
        /// </summary>
        public Vector2 Unit
        {
            get => this / Length;
        }

        /// <summary>
        /// Calculates the Euclidean distance between two vectors
        /// </summary>
        /// <param name="v1">First vector</param>
        /// <param name="v2">Second vector</param>
        /// <returns>Distance between the two vectors</returns>
        public static float Distance(Vector2 v1, Vector2 v2)
        {
            Vector2 d = v2 - v1;
            return MathF.Sqrt(d.X * d.X + d.Y * d.Y);
        }

        /// <summary>
        /// Vector dot product
        /// </summary>
        /// <param name="v1">First vector</param>
        /// <param name="v2">Second vector</param>
        /// <returns>Dot product of the two vectors</returns>
        public static float Dot(Vector2 v1, Vector2 v2)
        {
            return v1.X * v2.X + v1.Y * v2.Y;
        }

        /// <summary>
        /// Vector cross product. In 2D this yields a scalar.
        /// </summary>
        /// <param name="v1">First vector</param>
        /// <param name="v2">Second vector</param>
        /// <returns>Cross product as a scalar value</returns>
        public static float Cross(Vector2 v1, Vector2 v2)
        {
            return v1.X * v2.Y - v1.Y * v2.X;
        }

        /// <summary>
        /// Perform the cross product on a vector and a scalar. In 2D this produces a vector.
        /// </summary>
        /// <param name="v">Vector</param>
        /// <param name="s">Scalar value</param>
        /// <returns>Resulting vector</returns>
        public static Vector2 Cross(Vector2 v, float s)
        {
            return new Vector2(s * v.Y, -s * v.X);
        }

        /// <summary>
        /// Perform the cross product on a scalar and a vector. In 2D this produces a vector.
        /// </summary>
        /// <param name="s">Scalar value</param>
        /// <param name="v">Vector</param>
        /// <returns>Resulting vector</returns>
        public static Vector2 Cross(float s, Vector2 v)
        {
            return new Vector2(-s * v.Y, s * v.X);
        }

        /// <summary>
        /// Get a left pointing perpendicular vector. Equivalent to Cross(1.0f, v)
        /// </summary>
        /// <param name="v">Input vector</param>
        /// <returns>Left perpendicular vector</returns>
        public static Vector2 LeftPerp(Vector2 v)
        {
            return new Vector2(-v.Y, v.X);
        }

        /// <summary>
        /// Get a right pointing perpendicular vector. Equivalent to Cross(v, 1.0f)
        /// </summary>
        /// <param name="v">Input vector</param>
        /// <returns>Right perpendicular vector</returns>
        public static Vector2 RightPerp(Vector2 v)
        {
            return new Vector2(v.Y, -v.X);
        }
    }
}