refactor(math): Vector4

Author: isHarryh

UnityPy/math/Vector4.py

@@ -1,155 +1,112 @@
+from dataclasses import dataclass
+from math import sqrt
+from typing import Sequence
+
+
+kEpsilon = 0.00001
+
+
+@dataclass
 class Vector4:
-    X: float
-    Y: float
-    Z: float
-    W: float
+    '''https://github.com/Unity-Technologies/UnityCsReference/blob/master/Runtime/Export/Math/Vector4.cs'''
+
+    X: float = 0.0
+    Y: float = 0.0
+    Z: float = 0.0
+    W: float = 0.0
 
     def __init__(self, *args):
-        if len(args) == 4:  # float x, float y, float z, float w
-            self.X = args[0]
-            self.Y = args[1]
-            self.Z = args[2]
-            self.W = args[3]
-        elif len(args) == 2:  # Vector3 value, float w
-            self.X = args[0].X
-            self.Y = args[0].Y
-            self.Z = args[0].Z
-            self.W = args[1]
-
-    """
-        public float this[int index]
-        {
-            get
-            {
-                switch (index)
-                {
-                    case 0: return X;
-                    case 1: return Y;
-                    case 2: return Z;
-                    case 3: return W;
-                    default: throw new ArgumentOutOfRangeException(nameof(index), "Invalid Vector4 index!");
-                }
-            }
-
-            set
-            {
-                switch (index)
-                {
-                    case 0: X = value; break;
-                    case 1: Y = value; break;
-                    case 2: Z = value; break;
-                    case 3: W = value; break;
-                    default: throw new ArgumentOutOfRangeException(nameof(index), "Invalid Vector4 index!");
-                }
-            }
-        }
-
-
-        public override int GetHashCode()
-        {
-            return X.GetHashCode() ^ (Y.GetHashCode() << 2) ^ (Z.GetHashCode() >> 2) ^ (W.GetHashCode() >> 1);
-        }
-
-        public override bool Equals(object other)
-        {
-            if (!(other is Vector4))
-                return false;
-            return Equals((Vector4)other);
-        }
-
-        public bool Equals(Vector4 other)
-        {
-            return X.Equals(other.X) && Y.Equals(other.Y) && Z.Equals(other.Z) && W.Equals(other.W);
-        }
-
-        public void Normalize()
-        {
-            var length = Length();
-            if (length > kEpsilon)
-            {
-                var invNorm = 1.0f / length;
-                X *= invNorm;
-                Y *= invNorm;
-                Z *= invNorm;
-                W *= invNorm;
-            }
-            else
-            {
-                X = 0;
-                Y = 0;
-                Z = 0;
-                W = 0;
-            }
-        }
-
-        public float Length()
-        {
-            return (float)Math.Sqrt(LengthSquared());
-        }
-
-        public float LengthSquared()
-        {
-            return X * X + Y * Y + Z * Z + W * W;
-        }
-
-        public static Vector4 Zero => new Vector4();
-
-        public static Vector4 operator +(Vector4 a, Vector4 b)
-        {
-            return new Vector4(a.X + b.X, a.Y + b.Y, a.Z + b.Z, a.W + b.W);
-        }
-
-        public static Vector4 operator -(Vector4 a, Vector4 b)
-        {
-            return new Vector4(a.X - b.X, a.Y - b.Y, a.Z - b.Z, a.W - b.W);
-        }
-
-        public static Vector4 operator -(Vector4 a)
-        {
-            return new Vector4(-a.X, -a.Y, -a.Z, -a.W);
-        }
-
-        public static Vector4 operator *(Vector4 a, float d)
-        {
-            return new Vector4(a.X * d, a.Y * d, a.Z * d, a.W * d);
-        }
-
-        public static Vector4 operator *(float d, Vector4 a)
-        {
-            return new Vector4(a.X * d, a.Y * d, a.Z * d, a.W * d);
-        }
-
-        public static Vector4 operator /(Vector4 a, float d)
-        {
-            return new Vector4(a.X / d, a.Y / d, a.Z / d, a.W / d);
-        }
-
-        public static bool operator ==(Vector4 lhs, Vector4 rhs)
-        {
-            return (lhs - rhs).LengthSquared() < kEpsilon * kEpsilon;
-        }
-
-        public static bool operator !=(Vector4 lhs, Vector4 rhs)
-        {
-            return !(lhs == rhs);
-        }
-
-        public static implicit operator Vector2(Vector4 v)
-        {
-            return new Vector2(v.X, v.Y);
-        }
-
-        public static implicit operator Vector3(Vector4 v)
-        {
-            return new Vector3(v.X, v.Y, v.Z);
-        }
-
-        public static implicit operator Color(Vector4 v)
-        {
-            return new Color(v.X, v.Y, v.Z, v.W);
-        }
-
-        private const float kEpsilon = 0.00001F;
-    }
-}
-"""
+        if len(args) == 1:
+            args = args[0]
+
+        if isinstance(args, Sequence):
+            if len(args) == 4:  # args=(x, y, z, w)
+                self.X, self.Y, self.Z, self.W = args
+                return
+            if len(args) == 2:  # args=(Vector3, w)
+                self.X, self.Y, self.Z = args[0]
+                self.W = args[1]
+            if len(args) == 0:  # args=()
+                self.X = self.Y = self.Z = self.W = 0.0
+                return
+
+        raise TypeError("Invalid arguments for Vector4")
+
+    def __getitem__(self, index):
+        return (self.X, self.Y, self.Z, self.W)[index]
+
+    def __setitem__(self, index, value):
+        if index == 0:
+            self.X = value
+        elif index == 1:
+            self.Y = value
+        elif index == 2:
+            self.Z = value
+        elif index == 3:
+            self.W = value
+        else:
+            raise IndexError("Index out of range")
+
+    def __hash__(self):
+        return (
+            self.X.__hash__() ^
+            (self.Y.__hash__() << 2) ^
+            (self.Z.__hash__() >> 2) ^
+            (self.W.__hash__() >> 1)
+        )
+
+    def normalize(self):
+        length = self.length()
+        if length > kEpsilon:
+            invNorm = 1.0 / length
+            self.X *= invNorm
+            self.Y *= invNorm
+            self.Z *= invNorm
+            self.W *= invNorm
+        else:
+            self.X = self.Y = self.Z = self.W = 0.0
+
+    Normalize = normalize
+
+    def length(self):
+        return sqrt(self.lengthSquared())
+
+    Length = length
+
+    def lengthSquared(self):
+        return self.X ** 2 + self.Y ** 2 + self.Z ** 2 + self.W ** 2
+
+    LengthSquared = lengthSquared
+
+    @staticmethod
+    def Zero():
+        return Vector4(0, 0, 0, 0)
+
+    @staticmethod
+    def One():
+        return Vector4(1, 1, 1, 1)
+
+    def __add__(a, b):
+        return Vector4(a.X + b.X, a.Y + b.Y, a.Z + b.Z, a.W + b.W)
+
+    def __sub__(a, b):
+        return Vector4(a.X - b.X, a.Y - b.Y, a.Z - b.Z, a.W - b.W)
+
+    def __mul__(a, d):
+        return Vector4(a.X * d, a.Y * d, a.Z * d, a.W * d)
+
+    def __truediv__(a, d):
+        return Vector4(a.X / d, a.Y / d, a.Z / d, a.W / d)
+
+    def __eq__(lhs, rhs):
+        if isinstance(rhs, Vector4):
+            diff = lhs - rhs
+            return diff.lengthSquared() < kEpsilon * kEpsilon
+        return False
+
+    def __ne__(lhs, rhs):
+        return not (lhs == rhs)
+
+    def Vector3(self):
+        from .Vector3 import Vector3
+        return Vector3(self.X, self.Y, self.Z)