daily update on 20240528 by nitload youmu

源代码/StgSharp/Math/Linear/vec2d.cs

@@ -102,6 +102,10 @@ namespace StgSharp.Math
         {
             return new vec2d(vec.v / value);
         }
+        public static vec2d operator *(float value, vec2d vec)
+        {
+            return new vec2d(vec.v * value);
+        }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static vec2d operator +(vec2d left, vec2d right)

源代码/StgSharp/Math/Linear/vec3d.cs

@@ -28,7 +28,7 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Controlling;
+
 using StgSharp.Data;
 
 using System;

源代码/StgSharp/Math/Linear/vec4d.cs

@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-//     file="vec4d.cs"
+//     file="Vec4d.cs"
 //     Project: StgSharp
 //     AuthorGroup: Nitload Space
 //     Copyright (c) Nitload Space. All rights reserved.
@@ -28,7 +28,8 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Controlling;
+
+using StgSharp.Data;
 using StgSharp.Math;
 
 using System;
@@ -42,26 +43,41 @@ namespace StgSharp.Math
     public static class Vec4d
     {
 
+        public static vec4d One
+        {
+            get => new vec4d(Vector4.One);
+        }
+        public static vec4d Zero
+        {
+            get => new vec4d(Vector4.Zero);
+        }
+
     }
 
     [StructLayout(LayoutKind.Explicit, Size = 16, Pack = 16)]
-    public struct vec4d
+    public struct vec4d : IEquatable<vec4d>, IVector
     {
 
+        [FieldOffset(0)] internal unsafe fixed float num[4];
+
         [FieldOffset(0)] internal M128 reg;
 
         [FieldOffset(0)] internal Vector4 vec;
-
-        [FieldOffset(0)] internal unsafe fixed float num[4];
+        [FieldOffset(12)] public float W;
 
         [FieldOffset(0)] public float X;
         [FieldOffset(4)] public float Y;
         [FieldOffset(8)] public float Z;
-        [FieldOffset(12)] public float W;
 
-        public override string ToString()
+        internal vec4d(Vector4 v)
         {
-            return vec.ToString();
+            vec = v;
+        }
+
+        public vec4d(vec3d v, float w)
+        {
+            vec = v.vec;
+            W = w;
         }
 
         public vec4d(float x, float y, float z, float w)
@@ -69,22 +85,95 @@ namespace StgSharp.Math
             vec = new Vector4(x, y, z, w);
         }
 
+        public unsafe vec3d XYZ
+        {
+            get => new vec3d(vec);
+            set
+            {
+                float w = W;
+                vec = value.vec;
+                W = w;
+            }
+        }
+        public unsafe vec2d XY
+        {
+            get => new vec2d(vec);
+            set
+            {
+                X = value.X;
+                Y = value.Y;
+            }
+        }
+
+        public override bool Equals(object obj)
+        {
+            return (obj is vec4d v) ? (v == this) : false;
+        }
+
+        public override int GetHashCode()
+        {
+            return vec.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return vec.ToString();
+        }
+
+        public static bool operator !=(vec4d left, vec4d right)
+        {
+            return !(left == right);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static vec4d operator *(Matrix44 mat, vec4d vec)
+        {
+            mat.InternalTranspose();
+            return new vec4d(
+                Vector4.Dot(mat.transpose.colum0, vec.vec),
+                Vector4.Dot(mat.transpose.colum1, vec.vec),
+                Vector4.Dot(mat.transpose.colum2, vec.vec),
+                Vector4.Dot(mat.transpose.colum3, vec.vec)
+                );
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static vec4d operator +(vec4d left, vec4d right)
+        {
+            return new vec4d(left.vec + right.vec);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static vec4d operator -(vec4d left, vec4d right)
+        {
+            return new vec4d(left.vec - right.vec);
+        }
+
+        public static bool operator ==(vec4d left, vec4d right)
+        {
+            return left.vec == right.vec;
+        }
+
         public static implicit operator M128(vec4d vec)
         {
             return vec.reg;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static vec4d operator *(Matrix44 mat, vec4d vec) 
+        bool IEquatable<vec4d>.Equals(vec4d other)
         {
-            mat.InternalTranspose();
-            return new vec4d(
-                Vector4.Dot( mat.transpose.colum0,vec.vec),
-                Vector4.Dot( mat.transpose.colum1, vec.vec),
-                Vector4.Dot( mat.transpose.colum2, vec.vec),
-                Vector4.Dot( mat.transpose.colum3, vec.vec)
-                );
+            return vec == other.vec;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static vec4d Subtract(vec4d left, vec4d right)
+        {
+            return left - right;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static vec4d Add(vec4d left, vec4d right)
+        {
+            return left + right;
+        }
     }
 }