[Serialization] WIP;

Author: LittleCodingFox

Engine/Core/Math/Vector3Int.cs

@@ -0,0 +1,80 @@
+using System.Runtime.InteropServices;
+using System;
+using MessagePack;
+
+namespace Staple;
+
+/// <summary>
+/// 3D Vector that uses ints instead of floats
+/// </summary>
+[Serializable]
+[StructLayout(LayoutKind.Sequential, Pack = 0)]
+[MessagePackObject]
+public struct Vector3Int
+{
+    [Key(0)]
+    public int X;
+
+    [Key(1)]
+    public int Y;
+
+    [Key(2)]
+    public int Z;
+
+    public Vector3Int()
+    {
+    }
+
+    public Vector3Int(int X, int Y, int Z)
+    {
+        this.X = X;
+        this.Y = Y;
+        this.Z = Z;
+    }
+
+    [IgnoreMember]
+    public static readonly Vector3Int Zero = new();
+
+    [IgnoreMember]
+    public static readonly Vector3Int One = new(1, 1, 1);
+
+    public static Vector3Int operator +(Vector3Int a, Vector3Int b) => new(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
+
+    public static Vector3Int operator -(Vector3Int a, Vector3Int b) => new(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
+
+    public static Vector3Int operator *(Vector3Int a, Vector3Int b) => new(a.X * b.X, a.Y * b.Y, a.Z * b.Z);
+
+    public static Vector3Int operator *(Vector3Int a, int b) => new(a.X * b, a.Y * b, a.Z * b);
+
+    public static Vector3Int operator *(Vector3Int a, float b) => new((int)(a.X * b), (int)(a.Y * b), (int)(a.Z * b));
+
+    public static Vector3Int operator /(Vector3Int a, Vector3Int b) => new(a.X / b.X, a.Y / b.Y, a.Z / b.Z);
+
+    public static Vector3Int operator /(Vector3Int a, int b) => new(a.X / b, a.Y / b, a.Z / b);
+
+    public static Vector3Int operator /(Vector3Int a, float b) => new((int)(a.X / b), (int)(a.Y / b), (int)(a.Z / b));
+
+    public static bool operator ==(Vector3Int a, Vector3Int b) => a.X == b.X && a.Y == b.Y && a.Z == b.Z;
+
+    public static bool operator !=(Vector3Int a, Vector3Int b) => a.X != b.X || a.Y != b.Y || a.Z != b.Z;
+
+    public override readonly int GetHashCode()
+    {
+        return HashCode.Combine(X, Y, Z);
+    }
+
+    public override readonly bool Equals(object obj)
+    {
+        if (obj == null || obj is not Vector3Int v)
+        {
+            return false;
+        }
+
+        return X == v.X && Y == v.Y && Z == v.Z;
+    }
+
+    public override readonly string ToString()
+    {
+        return $"({X}, {Y}, {Z})";
+    }
+}

Engine/Core/Math/Vector4Int.cs

@@ -0,0 +1,84 @@
+using System.Runtime.InteropServices;
+using System;
+using MessagePack;
+
+namespace Staple;
+
+/// <summary>
+/// 3D Vector that uses ints instead of floats
+/// </summary>
+[Serializable]
+[StructLayout(LayoutKind.Sequential, Pack = 0)]
+[MessagePackObject]
+public struct Vector4Int
+{
+    [Key(0)]
+    public int X;
+
+    [Key(1)]
+    public int Y;
+
+    [Key(2)]
+    public int Z;
+
+    [Key(3)]
+    public int W;
+
+    public Vector4Int()
+    {
+    }
+
+    public Vector4Int(int X, int Y, int Z, int W)
+    {
+        this.X = X;
+        this.Y = Y;
+        this.Z = Z;
+        this.W = W;
+    }
+
+    [IgnoreMember]
+    public static readonly Vector4Int Zero = new();
+
+    [IgnoreMember]
+    public static readonly Vector4Int One = new(1, 1, 1, 1);
+
+    public static Vector4Int operator +(Vector4Int a, Vector4Int b) => new(a.X + b.X, a.Y + b.Y, a.Z + b.Z, a.W + b.W);
+
+    public static Vector4Int operator -(Vector4Int a, Vector4Int b) => new(a.X - b.X, a.Y - b.Y, a.Z - b.Z, a.W - b.W);
+
+    public static Vector4Int operator *(Vector4Int a, Vector4Int b) => new(a.X * b.X, a.Y * b.Y, a.Z * b.Z, a.W * b.W);
+
+    public static Vector4Int operator *(Vector4Int a, int b) => new(a.X * b, a.Y * b, a.Z * b, a.W * b);
+
+    public static Vector4Int operator *(Vector4Int a, float b) => new((int)(a.X * b), (int)(a.Y * b), (int)(a.Z * b), (int)(a.W * b));
+
+    public static Vector4Int operator /(Vector4Int a, Vector4Int b) => new(a.X / b.X, a.Y / b.Y, a.Z / b.Z, a.W / b.W);
+
+    public static Vector4Int operator /(Vector4Int a, int b) => new(a.X / b, a.Y / b, a.Z / b, a.W / b);
+
+    public static Vector4Int operator /(Vector4Int a, float b) => new((int)(a.X / b), (int)(a.Y / b), (int)(a.Z / b), (int)(a.W / b));
+
+    public static bool operator ==(Vector4Int a, Vector4Int b) => a.X == b.X && a.Y == b.Y && a.Z == b.Z && a.W == b.W;
+
+    public static bool operator !=(Vector4Int a, Vector4Int b) => a.X != b.X || a.Y != b.Y || a.Z != b.Z || a.W != b.W;
+
+    public override readonly int GetHashCode()
+    {
+        return HashCode.Combine(X, Y, Z, W);
+    }
+
+    public override readonly bool Equals(object obj)
+    {
+        if (obj == null || obj is not Vector4Int v)
+        {
+            return false;
+        }
+
+        return X == v.X && Y == v.Y && Z == v.Z && W == v.W;
+    }
+
+    public override readonly string ToString()
+    {
+        return $"({X}, {Y}, {Z}, {W})";
+    }
+}