Daily update on 20230803 by nitload youmu, problem of parameter displacement solved, rewriting other linear math

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

@@ -1,10 +1,13 @@
-using System;
+using StgSharp.Control;
+using System;
 using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
+
+    /*
     [StructLayout(LayoutKind.Explicit, Size = 12, Pack = 16)]
-    public struct vec3d : IEquatable<vec3d>
+    public struct Vec3d : IEquatable<Vec3d>
     {
         [FieldOffset(0)]
         public float X;
@@ -13,14 +16,14 @@ namespace StgSharp.Math
         [FieldOffset(8)]
         public float Z;
 
-        public vec3d(float x, float y, float z)
+        public Vec3d(float x, float y, float z)
         {
             X = x;
             Y = y;
             Z = z;
         }
 
-        bool IEquatable<vec3d>.Equals(vec3d other)
+        bool IEquatable<Vec3d>.Equals(Vec3d other)
         {
             if (this.GetHashCode() != other.GetHashCode())
             {
@@ -40,13 +43,13 @@ namespace StgSharp.Math
             {
                 return false;
             }
-            else if (obj.GetType() != typeof(vec3d))
+            else if (obj.GetType() != typeof(Vec3d))
             {
                 return false;
             }
             else
             {
-                return this.Equals((vec3d)obj);
+                return this.Equals((Vec3d)obj);
             }
         }
 
@@ -65,39 +68,39 @@ namespace StgSharp.Math
             return $"{X.ToString(sample)}\t{Y.ToString(sample)}\t{Z.ToString(sample)}";
         }
 
-        public static bool operator ==(vec3d vec1, vec3d vec2)
+        public static bool operator ==(Vec3d vec1, Vec3d vec2)
         {
             return vec1.X == vec2.X
                 && vec1.Y == vec2.Y
                 && vec1.Z == vec2.Z;
         }
 
-        public static bool operator !=(vec3d vec1, vec3d vec2)
+        public static bool operator !=(Vec3d vec1, Vec3d vec2)
         {
             return !(vec1.X == vec2.X
                 && vec1.Y == vec2.Y
                 && vec1.Z == vec2.Z);
         }
 
-        public static vec3d operator +(vec3d vec1, vec3d vec2)
+        public static Vec3d operator +(Vec3d vec1, Vec3d vec2)
         {
-            return new vec3d(
+            return new Vec3d(
                 vec1.X + vec2.X,
                 vec1.Y + vec2.Y,
                 vec1.Z + vec2.Z
                 );
         }
 
-        public static vec3d operator -(vec3d vec1, vec3d vec2)
+        public static Vec3d operator -(Vec3d vec1, Vec3d vec2)
         {
-            return new vec3d(
+            return new Vec3d(
                 vec1.X - vec2.X,
                 vec1.Y - vec2.Y,
                 vec1.Z - vec2.Z
                 );
         }
 
-        public static float operator *(vec3d vec1, vec3d vec2)
+        public static float operator *(Vec3d vec1, Vec3d vec2)
         {
             return
                 vec1.X * vec2.X
@@ -105,41 +108,141 @@ namespace StgSharp.Math
                 + vec1.Z + vec2.Z;
         }
 
-        public static vec3d operator *(vec3d vec, float x)
+        public static Vec3d operator *(Vec3d vec, float x)
         {
-            return new vec3d(
+            return new Vec3d(
                 vec.X * x,
                 vec.Y * x,
                 vec.Z * x
                 );
         }
 
-        public static vec3d operator *(float x, vec3d vec)
+        public static Vec3d operator *(float x, Vec3d vec)
         {
-            return new vec3d(
+            return new Vec3d(
                 vec.X * x,
                 vec.Y * x,
                 vec.Z * x
                 );
         }
 
-        public static vec3d operator /(vec3d vec, float x)
+        public static Vec3d operator /(Vec3d vec, float x)
         {
-            return new vec3d(
+            return new Vec3d(
                 vec.X / x,
                 vec.Y / x,
                 vec.Z / x
                 );
         }
 
-        public static implicit operator float[](vec3d vec)
+        public static implicit operator float[](Vec3d vec)
         {
             return new float[3] { vec.X, vec.Y, vec.Y };
         }
 
-        public static implicit operator vec3d(float[] floatArray)
+        public static implicit operator Vec3d(float[] floatArray)
         {
-            return new vec3d(floatArray[0], floatArray[1], floatArray[2]);
+            return new Vec3d(floatArray[0], floatArray[1], floatArray[2]);
         }
     }
+
+    /**/
+
+
+    public class Vec3d
+    {
+        public static Vec3d defaultValue =
+            new Vec3d(0, 0, 0);
+         
+
+        internal M128Map _map;
+        internal IntPtr _m128Ptr;
+
+        public unsafe float X
+        {
+            get { return ((M128*)_m128Ptr)->single_0; }
+            set { ((M128*)_m128Ptr)->single_0 = value; }
+        }
+
+        public unsafe float Y
+        {
+            get { return ((M128*)_m128Ptr)->single_1; }
+            set { ((M128*)_m128Ptr)->single_1 = value; }
+        }
+
+        public unsafe float Z
+        {
+            get { return ((M128*)_m128Ptr)->single_2; }
+            set { ((M128*)_m128Ptr)->single_2 = value; }
+        }
+
+
+        internal Vec3d(IntPtr value)
+        {
+            if ((long)value == -1)
+            {
+                throw new Exception("Failed to creat M128 pointer");
+            }
+            else
+            {
+                _m128Ptr = value;
+            }
+        }
+
+        public Vec3d(float x, float y, float z)
+        {
+            _m128Ptr = internalIO.load_internal(x,y,z,0);
+        }
+
+        internal Vec3d()
+        {
+            _m128Ptr = defaultValue._m128Ptr;
+        }
+
+        public static Vec3d operator +(Vec3d vec1, Vec3d vec2)
+        {
+            return new Vec3d(
+                internalIO.addps_internal(vec1._m128Ptr, vec2._m128Ptr)
+                );
+        }
+
+        public static Vec3d operator -(Vec3d vec1, Vec3d vec2)
+        {
+            return new Vec3d(
+                internalIO.subps_internal(vec1._m128Ptr, vec2._m128Ptr)
+                );
+        }
+
+        public static Vec3d operator *(Vec3d vec, float value)
+        {
+            return new Vec3d(
+                internalIO.mulps_const_internal(vec._m128Ptr,value)
+                );
+        }
+
+        public unsafe override string ToString()
+        {
+            return (*(M128*)_m128Ptr).ToString();
+        }
+
+        ~Vec3d()
+        {
+            if (_map == null)
+            {
+                if (_m128Ptr != defaultValue._m128Ptr)
+                {
+                    internalIO.deinitM128_internal(this._m128Ptr);
+                }
+                else
+                {
+                    _m128Ptr = IntPtr.Zero;
+                }
+            }
+            else
+            {
+
+            }
+        }
+
+    }
 }