Vector3DInt.cs

using System;
using System.Runtime.Serialization;
 
namespace MPewsey.Common.Mathematics
{
    [DataContract(Namespace = Constants.DataContractNamespace)]
    public struct Vector3DInt : IEquatable<Vector3DInt>, IComparable<Vector3DInt>
    {
        public static Vector3DInt Zero => new Vector3DInt();
 
        public static Vector3DInt One => new Vector3DInt(1, 1, 1);
 
        [DataMember(Order = 0)]
        public int X { get; private set; }
 
        [DataMember(Order = 1)]
        public int Y { get; private set; }
 
        [DataMember(Order = 2)]
        public int Z { get; private set; }
 
        public Vector3DInt(int x, int y, int z)
        {
            X = x;
            Y = y;
            Z = z;
        }
 
        public Vector2DInt To2D() => new Vector2DInt(X, Y);
 
        public override string ToString()
        {
            return $"Vector3DInt({X}, {Y}, {Z})";
        }
 
        public override bool Equals(object obj)
        {
            return obj is Vector3DInt vector && Equals(vector);
        }
 
        public bool Equals(Vector3DInt other)
        {
            return X == other.X &&
                   Y == other.Y &&
                   Z == other.Z;
        }
 
        public int CompareTo(Vector3DInt other)
        {
            var comparison = X.CompareTo(other.X);
 
            if (comparison != 0)
                return comparison;
 
            comparison = Y.CompareTo(other.Y);
 
            if (comparison != 0)
                return comparison;
 
            return Z.CompareTo(other.Z);
        }
 
        public override int GetHashCode()
        {
            int hashCode = -307843816;
            hashCode = hashCode * -1521134295 + X.GetHashCode();
            hashCode = hashCode * -1521134295 + Y.GetHashCode();
            hashCode = hashCode * -1521134295 + Z.GetHashCode();
            return hashCode;
        }
 
        public static bool operator ==(Vector3DInt left, Vector3DInt right)
        {
            return left.Equals(right);
        }
 
        public static bool operator !=(Vector3DInt left, Vector3DInt right)
        {
            return !(left == right);
        }
 
        public static Vector3DInt operator +(Vector3DInt left, Vector3DInt right)
        {
            return new Vector3DInt(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
        }
 
        public static Vector3DInt operator -(Vector3DInt left, Vector3DInt right)
        {
            return new Vector3DInt(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
        }
 
        public static Vector3DInt operator -(Vector3DInt vector)
        {
            return new Vector3DInt(-vector.X, -vector.Y, -vector.Z);
        }
 
        public static Vector3DInt Max(Vector3DInt value1, Vector3DInt value2)
        {
            return new Vector3DInt(Math.Max(value1.X, value2.X), Math.Max(value1.Y, value2.Y), Math.Max(value1.Z, value2.Z));
        }
 
        public static Vector3DInt Min(Vector3DInt value1, Vector3DInt value2)
        {
            return new Vector3DInt(Math.Min(value1.X, value2.X), Math.Min(value1.Y, value2.Y), Math.Min(value1.Z, value2.Z));
        }
 
        public static Vector3DInt Sign(Vector3DInt vector)
        {
            return new Vector3DInt(Math.Sign(vector.X), Math.Sign(vector.Y), Math.Sign(vector.Z));
        }
 
        public static int Dot(Vector3DInt value1, Vector3DInt value2)
        {
            return value1.X * value2.X + value1.Y * value2.Y + value1.Z * value2.Z;
        }
    }
}