Daily update on 20230806 by nitload youmu

源代码/StgSharp/Geometries/PlainGeometry/Parallelogram.cs

@@ -23,16 +23,22 @@ namespace StgSharp.Geometries
         }
 
         /// <summary>
-        /// 移动平行四边形的第三个顶点，是一个多余的方法，调用会引发多余变量异常
+        /// Move the third vertix. this is a useless method for Parallelograms.
         /// </summary>
-        /// <param name="tick">当前游戏刻</param>
+        /// <param name="tick">Current time tick</param>
         /// <returns></returns>
-        /// <exception cref="UnusedVertexException">几何体过定义</exception>
+        /// <exception cref="UnusedVertexException">Geometry overdefined</exception>
         public sealed override Vec3d MovVertex03(uint tick)
         {
             throw new UnusedVertexException();
         }
 
+        /// <summary>
+        /// Move the third vertix. This method is useless for Parallelograms.
+        /// </summary>
+        /// <param name="tick">Current time tick</param>
+        /// <returns></returns>
+        /// <exception cref="UnusedVertexException">Geometry overdefined</exception>
         public sealed override Vec3d MovVertex04(uint tick)
         {
             throw new UnusedVertexException();

源代码/StgSharp/Math/IO/LinearIO.cs

@@ -14,6 +14,10 @@ namespace StgSharp
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr load_internal(float x,float y, float z, float w);
 
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "load_cpy",
+            CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr load_cpy_internal(IntPtr ptr);
+
         [DllImport("StgSharpGraphic.dll", EntryPoint = "addps",
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr addps_internal(IntPtr ptr1, IntPtr ptr2);

源代码/StgSharp/Math/Linear/Vector.Multiple.cs

@@ -32,31 +32,174 @@ namespace StgSharp.Math
                 m128.single_3;
         }
 
-        public static Matrix4x4 Multiple(
+        public static Matrix2x2 Multiple(Matrix2x2 matrix1, Matrix2x2 matrix2)
-            Matrix4x4 matrix1, Matrix4x4 matrix2
-            )
         {
-            Matrix4x4 transpose = matrix2.Transpose(TransposeMode.Copy);
+            Matrix2x2 trans = matrix1.Transpose(TransposeMode.Copy);
-            return new Matrix4x4(
+
-                internalIO.mulps_sum_internal(matrix1._row0Ptr, transpose._row0Ptr),
+            return new Matrix2x2(
-                internalIO.mulps_sum_internal(matrix1._row0Ptr, transpose._row1Ptr),
+                internalIO.mulps_sum_internal(trans._colum0Ptr, matrix2._colum0Ptr),
-                internalIO.mulps_sum_internal(matrix1._row0Ptr, transpose._row2Ptr),
+                internalIO.mulps_sum_internal(trans._colum0Ptr, matrix2._colum1Ptr),
-                internalIO.mulps_sum_internal(matrix1._row0Ptr, transpose._row3Ptr),
+
-                internalIO.mulps_sum_internal(matrix1._row1Ptr, transpose._row0Ptr),
+                internalIO.mulps_sum_internal(trans._colum1Ptr, matrix2._colum0Ptr),
-                internalIO.mulps_sum_internal(matrix1._row1Ptr, transpose._row1Ptr),
+                internalIO.mulps_sum_internal(trans._colum1Ptr, matrix2._colum1Ptr)
-                internalIO.mulps_sum_internal(matrix1._row1Ptr, transpose._row2Ptr),
-                internalIO.mulps_sum_internal(matrix1._row1Ptr, transpose._row3Ptr),
-                internalIO.mulps_sum_internal(matrix1._row2Ptr, transpose._row0Ptr),
-                internalIO.mulps_sum_internal(matrix1._row2Ptr, transpose._row1Ptr),
-                internalIO.mulps_sum_internal(matrix1._row2Ptr, transpose._row2Ptr),
-                internalIO.mulps_sum_internal(matrix1._row2Ptr, transpose._row3Ptr),
-                internalIO.mulps_sum_internal(matrix1._row3Ptr, transpose._row0Ptr),
-                internalIO.mulps_sum_internal(matrix1._row3Ptr, transpose._row1Ptr),
-                internalIO.mulps_sum_internal(matrix1._row3Ptr, transpose._row2Ptr),
-                internalIO.mulps_sum_internal(matrix1._row3Ptr, transpose._row3Ptr)
                 );
         }
 
+        public static Matrix2x2 Multiple(Matrix2x4 matrix1, Matrix4x2 matrix2)
+        {
+            Matrix4x2 trans = matrix1.Transpose(TransposeMode.Copy);
+
+            return new Matrix2x2(
+                internalIO.mulps_sum_internal(trans._colum0Ptr, matrix2._colum0Ptr),
+                internalIO.mulps_sum_internal(trans._colum0Ptr, matrix2._colum1Ptr),
+
+                internalIO.mulps_sum_internal(trans._colum1Ptr, matrix2._colum0Ptr),
+                internalIO.mulps_sum_internal(trans._colum1Ptr, matrix2._colum1Ptr)
+                );
+        }
+
+        public static Matrix2x4 Multiple(Matrix2x2 matrix1, Matrix2x4 matrix2)
+        {
+            Matrix2x2 trans = matrix1.Transpose(TransposeMode.Copy);
+
+            return new Matrix2x4(
+                internalIO.mulps_sum_internal(trans._colum0Ptr, matrix2._colum0Ptr),
+                internalIO.mulps_sum_internal(trans._colum0Ptr, matrix2._colum1Ptr),
+                internalIO.mulps_sum_internal(trans._colum0Ptr, matrix2._colum2Ptr),
+                internalIO.mulps_sum_internal(trans._colum0Ptr, matrix2._colum3Ptr),
+
+                internalIO.mulps_sum_internal(trans._colum1Ptr, matrix2._colum0Ptr),
+                internalIO.mulps_sum_internal(trans._colum1Ptr, matrix2._colum1Ptr),
+                internalIO.mulps_sum_internal(trans._colum1Ptr, matrix2._colum2Ptr),
+                internalIO.mulps_sum_internal(trans._colum1Ptr, matrix2._colum3Ptr)
+                );
+        }
+
+        public static Matrix3x3 Multiple(Matrix3x3 matrix1, Matrix3x3 matrix2)
+        {
+            Matrix3x3 transpose = matrix2.Transpose(TransposeMode.Copy);
+
+            return new Matrix3x3(
+                internalIO.mulps_sum_internal(matrix1._colum0Ptr,transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum0Ptr,transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum0Ptr,transpose._colum2Ptr),
+
+                internalIO.mulps_sum_internal(matrix1._colum1Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum1Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum1Ptr, transpose._colum2Ptr),
+
+                internalIO.mulps_sum_internal(matrix1._colum2Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum2Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum2Ptr, transpose._colum2Ptr)
+                );
+        }
+
+        public static Matrix3x3 Multiple(Matrix3x4 matrix1, Matrix4x3 matrix2)
+        {
+            Matrix3x4 transpose = matrix2.Transpose(TransposeMode.Copy);
+
+            return new Matrix3x3(
+                internalIO.mulps_sum_internal(matrix1._colum0Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum0Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum0Ptr, transpose._colum2Ptr),
+
+                internalIO.mulps_sum_internal(matrix1._colum1Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum1Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum1Ptr, transpose._colum2Ptr),
+
+                internalIO.mulps_sum_internal(matrix1._colum2Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum2Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix1._colum2Ptr, transpose._colum2Ptr)
+                );
+        }
+
+        public static Matrix4x2 Multiple(Matrix4x2 matrix1, Matrix2x2 matrix2)
+        {
+            Matrix2x4 trans = matrix1.Transpose(TransposeMode.Copy);
+
+
+        }
+
+        public static Matrix4x4 Multiple(Matrix4x2 matrix1, Matrix2x4 matrix2)
+        {
+            Matrix2x4 transpose = matrix1.Transpose(TransposeMode.Copy);
+            return new Matrix4x4(
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr, transpose._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr, transpose._colum3Ptr),
+
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr, transpose._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr, transpose._colum3Ptr),
+
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr, transpose._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr, transpose._colum3Ptr),
+
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr, transpose._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr, transpose._colum3Ptr)
+                );
+        }
+
+        public static Matrix4x4 Multiple( Matrix4x3 matrix1, Matrix3x4 matrix2 )
+        {
+            Matrix3x4 trans = matrix1.Transpose(TransposeMode.Copy);
+
+            return new Matrix4x4(
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr,trans._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr,trans._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr,trans._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr,trans._colum3Ptr),
+
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr,trans._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr,trans._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr,trans._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr,trans._colum3Ptr),
+
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr,trans._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr,trans._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr,trans._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr,trans._colum3Ptr),
+
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr,trans._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr,trans._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr,trans._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr,trans._colum3Ptr)
+                );
+        }
+
+        public static Matrix4x4 Multiple( Matrix4x4 matrix1, Matrix4x4 matrix2 )
+        {
+            Matrix4x4 transpose = matrix1.Transpose(TransposeMode.Copy);
+            return new Matrix4x4(
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr, transpose._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum0Ptr, transpose._colum3Ptr),
+
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr, transpose._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum1Ptr, transpose._colum3Ptr),
+
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr, transpose._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum2Ptr, transpose._colum3Ptr),
+
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr, transpose._colum0Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr, transpose._colum1Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr, transpose._colum2Ptr),
+                internalIO.mulps_sum_internal(matrix2._colum3Ptr, transpose._colum3Ptr)
+                );
+        }
+        
+
         /*
         private static float getMatrixMember(float* p1, float* p2)
         {

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

@@ -3,91 +3,110 @@ using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
-    [StructLayout(LayoutKind.Explicit)]
+    public class Matrix2x2
-    public struct matrix2x2 : IEquatable<matrix2x2>
     {
-        [FieldOffset(0)]
+        internal M128Map _map;
-        public vec2d row1;
-        [FieldOffset(8)]
-        public vec2d row2;
 
+        internal IntPtr _colum0Ptr;
+        internal IntPtr _colum1Ptr;
 
-        public matrix2x2(vec2d c0, vec2d c1)
+        private bool _isTranpsed;
-        {
+        private Matrix2x2 _transpose;
-            row1 = c0;
-            row2 = c1;
-        }
 
-        public matrix2x2(
+        public Matrix2x2(
-            float a11,
+            float a00, float a01,
-            float a12,
+            float a10, float a11
-            float a21,
-            float a22
             )
         {
-            row1 = new vec2d(a11, a12);
+            _colum0Ptr = internalIO.load_internal(a00, a10, 0, 0);
-            row2 = new vec2d(a21, a22);
+            _colum0Ptr = internalIO.load_internal(a01, a11, 0, 0);
+
+            _transpose = new Matrix2x2(this);
         }
 
-        bool IEquatable<matrix2x2>.Equals(matrix2x2 other)
+        internal Matrix2x2(
+            IntPtr colum0Ptr,
+            IntPtr colum1Ptr
+            )
         {
-            if (this.GetHashCode() != other.GetHashCode())
+            _colum0Ptr = colum0Ptr;
+            _colum1Ptr = colum1Ptr;
+        }
+
+        internal Matrix2x2(Matrix2x2 transpose)
+        {
+            _transpose = transpose;
+        }
+
+        public unsafe Matrix2x2 Transpose(TransposeMode transposeMode)
+        {
+            if (_isTranpsed)
             {
-                return false;
+                (*(M128*)_transpose._colum0Ptr).single_0 = (*(M128*)_colum0Ptr).single_0;
+                (*(M128*)_transpose._colum1Ptr).single_0 = (*(M128*)_colum0Ptr).single_1;
+
+                (*(M128*)_transpose._colum0Ptr).single_1 = (*(M128*)_colum1Ptr).single_0;
+                (*(M128*)_transpose._colum1Ptr).single_1 = (*(M128*)_colum1Ptr).single_1;
             }
-            else
+
+            switch (transposeMode)
             {
-                return
+                case TransposeMode.New:
-                    this.row1 == other.row1
+                    return new Matrix2x2(
-                    && this.row2 == other.row2;
+                        internalIO.load_cpy_internal(_transpose._colum0Ptr),
+                        internalIO.load_cpy_internal(_transpose._colum1Ptr)
+                        );
+                    break;
+                case TransposeMode.Copy:
+                    return _transpose;
+                    break;
+                default:
+                    throw new Exception();
+                    break;
             }
         }
 
-        public override bool Equals(object obj)
+        public static Matrix2x2 operator +(Matrix2x2 matrix1, Matrix2x2 matrix2)
         {
-            if (obj == null)
+            return new Matrix2x2(
-            {
+                internalIO.addps_internal(matrix1._colum0Ptr, matrix2._colum0Ptr),
-                return false;
+                internalIO.addps_internal(matrix1._colum1Ptr, matrix2._colum1Ptr)
-            }
-            else if (obj.GetType() != typeof(matrix2x2))
-            {
-                return false;
-            }
-            else
-            {
-                return this.Equals((Vec3d)obj);
-            }
-        }
-
-        public override int GetHashCode()
-        {
-            return HashCode.Combine(row1, row2);
-        }
-
-        public override string ToString()
-        {
-            return $"{row1}\n{row2}";
-        }
-
-        public static matrix2x2 operator +(matrix2x2 matrix1, matrix2x2 matrix2)
-        {
-            return new matrix2x2(
-                matrix1.row1 + matrix2.row1,
-                matrix1.row2 + matrix2.row2
                 );
         }
 
-        public static matrix2x2 operator -(matrix2x2 matrix1, matrix2x2 matrix2)
+        public static Matrix2x2 operator -(Matrix2x2 matrix1, Matrix2x2 matrix2)
         {
-            return new matrix2x2(
+            return new Matrix2x2(
-                matrix1.row1 - matrix2.row1,
+                internalIO.subps_internal(matrix1._colum0Ptr, matrix2._colum0Ptr),
-                matrix1.row2 - matrix2.row2
+                internalIO.subps_internal(matrix1._colum1Ptr, matrix2._colum1Ptr)
+                );
+        }
+
+        public static Matrix2x2 operator *(Matrix2x2 matrix1, float value)
+        {
+            return new Matrix2x2(
+                internalIO.mulps_const_internal(matrix1._colum0Ptr, value),
+                internalIO.mulps_const_internal(matrix1._colum1Ptr, value)
+                );
+        }
+
+        public static Matrix2x2 operator /(Matrix2x2 matrix1, float value)
+        {
+            return new Matrix2x2(
+                internalIO.divps_const_internal(matrix1._colum0Ptr, value),
+                internalIO.divps_const_internal(matrix1._colum1Ptr, value)
                 );
         }
 
 
-
+        ~Matrix2x2()
-
+        {
+            if (_map == null)
+            {
+                internalIO.deinitM128_internal(_colum0Ptr);
+                internalIO.deinitM128_internal(_colum1Ptr);
+            }
+        }
 
     }
 }

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

@@ -3,4 +3,126 @@ using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
+
+    public class Matrix2x4
+    {
+        internal M128Map _map;
+
+        internal IntPtr _colum0Ptr;
+        internal IntPtr _colum1Ptr;
+        internal IntPtr _colum2Ptr;
+        internal IntPtr _colum3Ptr;
+
+        private bool _isTranposed;
+        private Matrix4x2 _transpose;
+
+        public Matrix2x4(
+            float a00, float a01, float a02, float a03,
+            float a10, float a11, float a12, float a13
+            )
+        {
+            _colum0Ptr = internalIO.load_internal(a00, a10, 0, 0);
+            _colum1Ptr = internalIO.load_internal(a01, a11, 0, 0);
+            _colum2Ptr = internalIO.load_internal(a02, a12, 0, 0);
+            _colum3Ptr = internalIO.load_internal(a03, a13, 0, 0);
+
+            _transpose = new Matrix4x2(this);
+        }
+
+        internal Matrix2x4(
+            IntPtr colum0Ptr,
+            IntPtr colum1Ptr,
+            IntPtr colum2Ptr,
+            IntPtr colum3Ptr
+            )
+        {
+            _colum0Ptr = colum0Ptr;
+            _colum1Ptr = colum1Ptr;
+            _colum2Ptr = colum2Ptr;
+            _colum3Ptr = colum3Ptr;
+
+            _transpose = new Matrix4x2(this);
+        }
+
+        public unsafe Matrix4x2 Transpose(TransposeMode transposeMode)
+        {
+            if (_isTranposed)
+            {
+                (*(M128*)_transpose._colum0Ptr).single_0 = (*(M128*)_colum0Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_1 = (*(M128*)_colum1Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_2 = (*(M128*)_colum2Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_3 = (*(M128*)_colum3Ptr).single_0;
+
+                (*(M128*)_transpose._colum1Ptr).single_0 = (*(M128*)_colum0Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_1 = (*(M128*)_colum1Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_2 = (*(M128*)_colum2Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_3 = (*(M128*)_colum3Ptr).single_1;
+            
+                _isTranposed = true;
+            }
+            switch (transposeMode)
+            {
+                case TransposeMode.New:
+                    return new Matrix4x2(
+                        internalIO.load_cpy_internal(_transpose._colum0Ptr),
+                        internalIO.load_cpy_internal(_transpose._colum1Ptr)
+                        );
+                    break;
+                case TransposeMode.Copy:
+                    return _transpose;
+                    break;
+                default:
+                    throw new Exception();
+                    break;
+            }
+        }
+
+        public static Matrix2x4 operator +(Matrix2x4 matrix1,Matrix2x4 matrix2)
+        {
+            return new Matrix2x4(
+                internalIO.addps_internal(matrix1._colum0Ptr, matrix2._colum0Ptr),
+                internalIO.addps_internal(matrix1._colum1Ptr, matrix2._colum1Ptr),
+                internalIO.addps_internal(matrix1._colum2Ptr, matrix2._colum2Ptr),
+                internalIO.addps_internal(matrix1._colum3Ptr, matrix2._colum3Ptr)
+                );
+        }
+
+        public static Matrix2x4 operator -(Matrix2x4 matrix1, Matrix2x4 matrix2)
+        {
+            return new Matrix2x4(
+                internalIO.subps_internal(matrix1._colum0Ptr, matrix2._colum0Ptr),
+                internalIO.subps_internal(matrix1._colum1Ptr, matrix2._colum1Ptr),
+                internalIO.subps_internal(matrix1._colum2Ptr, matrix2._colum2Ptr),
+                internalIO.subps_internal(matrix1._colum3Ptr, matrix2._colum3Ptr)
+                );
+        }
+
+        public static Matrix2x4 operator *(Matrix2x4 matrix, float value)
+        {
+            return new Matrix2x4(
+                internalIO.mulps_const_internal(matrix._colum0Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum1Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum2Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum3Ptr,value)
+                );
+        }
+
+        public static Matrix2x4 operator /(Matrix2x4 matrix, float value)
+        {
+            return new Matrix2x4(
+                internalIO.divps_const_internal(matrix._colum0Ptr, value),
+                internalIO.divps_const_internal(matrix._colum1Ptr, value),
+                internalIO.divps_const_internal(matrix._colum2Ptr, value),
+                internalIO.divps_const_internal(matrix._colum3Ptr, value)
+                );
+        }
+
+        internal Matrix2x4(
+            Matrix4x2 transpose)
+        {
+            _transpose = transpose;
+        }
+
+    }
+
 }

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

@@ -3,139 +3,133 @@ using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
-    [StructLayout(LayoutKind.Explicit)]
+    public class Matrix3x3
-    public struct matrix3x3 : IEquatable<matrix3x3>
     {
-        [FieldOffset(0)]
+        internal M128Map map;
-        public Vec3d row1;
-        [FieldOffset(12)]
-        public Vec3d row2;
-        [FieldOffset(24)]
-        public Vec3d row3;
 
-        public matrix3x3(Vec3d r0, Vec3d r1, Vec3d r2)
+        internal IntPtr _colum0Ptr;
-        {
+        internal IntPtr _colum1Ptr;
-            row1 = r0;
+        internal IntPtr _colum2Ptr;
-            row2 = r1;
-            row3 = r2;
-        }
 
-        public matrix3x3(
+        private bool _isDisposed;
-            float a11, float a12, float a13,
+        private Matrix3x3 _transpose;
-            float a21, float a22, float a23,
+
-            float a31, float a32, float a33
+        public Matrix3x3(
+            float a00, float a01, float a02,
+            float a10, float a11, float a12,
+            float a20, float a21, float a22
             )
         {
-            row1 = new Vec3d(a11, a12, a13);
+            _colum0Ptr = internalIO.load_internal(a00,a10,a20,0);
-            row2 = new Vec3d(a21, a22, a23);
+            _colum1Ptr = internalIO.load_internal(a01,a11,a21,0);
-            row3 = new Vec3d(a31, a32, a33);
+            _colum2Ptr = internalIO.load_internal(a02,a12,a22,0);
+
+            _transpose = new Matrix3x3(this);
         }
 
-        public override int GetHashCode()
+        internal Matrix3x3(Matrix3x3 transpose)
         {
-            return HashCode.Combine(row1, row2, row3);
+            _transpose = transpose;
         }
 
-        bool IEquatable<matrix3x3>.Equals(matrix3x3 other)
+        internal Matrix3x3(
+            IntPtr colum0Ptr,
+            IntPtr colum1Ptr,
+            IntPtr colum2Ptr
+            )
         {
-            if (this.GetHashCode() != other.GetHashCode())
+            _colum0Ptr= colum0Ptr;
+            _colum1Ptr= colum1Ptr;
+            _colum2Ptr= colum2Ptr;
+
+            _transpose = new Matrix3x3(this);
+        }
+
+        public unsafe Matrix3x3 Transpose(TransposeMode transposeMode)
+        {
+            if (!_isDisposed)
             {
-                return false;
+                (*(M128*)_transpose._colum0Ptr).single_0 = (*(M128*)_colum0Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_1 = (*(M128*)_colum1Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_2 = (*(M128*)_colum2Ptr).single_0;
+
+                (*(M128*)_transpose._colum1Ptr).single_0 = (*(M128*)_colum0Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_1 = (*(M128*)_colum1Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_2 = (*(M128*)_colum2Ptr).single_1;
+
+                (*(M128*)_transpose._colum2Ptr).single_0 = (*(M128*)_colum0Ptr).single_2;
+                (*(M128*)_transpose._colum2Ptr).single_1 = (*(M128*)_colum1Ptr).single_2;
+                (*(M128*)_transpose._colum2Ptr).single_2 = (*(M128*)_colum2Ptr).single_2;
+
+                _isDisposed = true; 
             }
-            else
+
+            switch (transposeMode)
             {
-                return
+                case TransposeMode.New:
-                    this.row1 == other.row1
+                    return new Matrix3x3(
-                    && this.row2 == other.row2
+                        internalIO.load_cpy_internal(_transpose._colum0Ptr),
-                    && this.row3 == other.row3;
+                        internalIO.load_cpy_internal(_transpose._colum1Ptr),
+                        internalIO.load_cpy_internal(_transpose._colum2Ptr)
+                        );
+                    break;
+                case TransposeMode.Copy:
+                    return _transpose;
+                    break;
+                default:
+                    throw new Exception();
+                    break;
             }
+
         }
 
-        public override bool Equals(object obj)
+        public static Matrix3x3 operator +(Matrix3x3 matrix1, Matrix3x3 matrix2)
         {
-            if (obj == null)
+            return new Matrix3x3(
-            {
+                internalIO.addps_internal(matrix1._colum0Ptr,matrix2._colum0Ptr),
-                return false;
+                internalIO.addps_internal(matrix1._colum1Ptr,matrix2._colum1Ptr),
-            }
+                internalIO.addps_internal(matrix1._colum2Ptr,matrix2._colum2Ptr)
-            else if (obj.GetType() != typeof(matrix3x3))
-            {
-                return false;
-            }
-            else
-            {
-                return this.Equals((matrix3x3)obj);
-            }
-        }
-
-        public override string ToString()
-        {
-            return $"{row1}\n{row2}\n{row3}";
-        }
-
-
-
-        public static bool operator ==(matrix3x3 matrix1, matrix3x3 matrix2)
-        {
-            return matrix1.Equals(matrix2);
-        }
-
-        public static bool operator !=(matrix3x3 matrix1, matrix3x3 matrix2)
-        {
-            return !matrix1.Equals(matrix2);
-        }
-
-        public static matrix3x3 operator +(matrix3x3 matrix1, matrix3x3 matrix2)
-        {
-            return new matrix3x3(
-                matrix1.row1.X + matrix2.row1.X,
-                matrix1.row1.Y + matrix2.row1.Y,
-                matrix1.row1.Z + matrix2.row1.Z,
-
-                matrix1.row2.X + matrix2.row2.X,
-                matrix1.row2.Y + matrix2.row2.Y,
-                matrix1.row2.Z + matrix2.row2.Z,
-
-                matrix1.row3.X + matrix2.row3.X,
-                matrix1.row3.Y + matrix2.row3.Y,
-                matrix1.row3.Z + matrix2.row3.Z
                 );
         }
 
-        public static matrix3x3 operator -(matrix3x3 matrix1, matrix3x3 matrix2)
+        public static Matrix3x3 operator -(Matrix3x3 matrix1, Matrix3x3 matrix2)
         {
-            return new matrix3x3(
+            return new Matrix3x3(
-                matrix1.row1.X - matrix2.row1.X,
+                internalIO.subps_internal(matrix1._colum0Ptr,matrix2._colum0Ptr),
-                matrix1.row1.Y - matrix2.row1.Y,
+                internalIO.subps_internal(matrix1._colum1Ptr,matrix2._colum1Ptr),
-                matrix1.row1.Z - matrix2.row1.Z,
+                internalIO.subps_internal(matrix1._colum2Ptr,matrix2._colum2Ptr)
-
-                matrix1.row2.X - matrix2.row2.X,
-                matrix1.row2.Y - matrix2.row2.Y,
-                matrix1.row2.Z - matrix2.row2.Z,
-
-                matrix1.row3.X - matrix2.row3.X,
-                matrix1.row3.Y - matrix2.row3.Y,
-                matrix1.row3.Z - matrix2.row3.Z
                 );
         }
 
-
+        public static Matrix3x3 operator *(Matrix3x3 matrix, float value)
-
-        public static matrix3x3 operator *(matrix3x3 array, float x)
         {
-            return new matrix3x3(
+            return new Matrix3x3(
-                array.row1 * x,
+                internalIO.mulps_const_internal(matrix._colum0Ptr,value),
-                array.row2 * x,
+                internalIO.mulps_const_internal(matrix._colum1Ptr,value),
-                array.row3 * x
+                internalIO.mulps_const_internal(matrix._colum2Ptr,value)
                 );
         }
 
-        public static matrix3x3 operator /(matrix3x3 array, float x)
+        public static Matrix3x3 operator /(Matrix3x3 matrix, float value)
         {
-            return new matrix3x3(
+            return new Matrix3x3(
-                array.row1 / x,
+                internalIO.divps_const_internal(matrix._colum0Ptr, value),
-                array.row2 / x,
+                internalIO.divps_const_internal(matrix._colum1Ptr, value),
-                array.row3 / x
+                internalIO.divps_const_internal(matrix._colum2Ptr, value)
                 );
         }
+
+        ~Matrix3x3()
+        {
+            if (map==null)
+            {
+                internalIO.deinitM128_internal(_colum0Ptr);
+                internalIO.deinitM128_internal(_colum1Ptr);
+                internalIO.deinitM128_internal(_colum2Ptr);
+            }
+        }
+
+        
+
     }
 }

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

@@ -6,9 +6,12 @@ namespace StgSharp.Math
 {
     public class Matrix3x4
     {
-        internal IntPtr _row0Ptr;
+        internal M128Map map;
-        internal IntPtr _row1Ptr;
+
-        internal IntPtr _row2Ptr;
+        internal IntPtr _colum0Ptr;
+        internal IntPtr _colum1Ptr;
+        internal IntPtr _colum2Ptr;
+        internal IntPtr _colum3Ptr;
 
         private bool _isTransposed;
         private Matrix4x3 _transpose;
@@ -19,13 +22,27 @@ namespace StgSharp.Math
             float a20, float a21, float a22, float a23
             )
         {
-            _row0Ptr = internalIO.load_internal(a00,a01,a02,a03);
+            _colum0Ptr = internalIO.load_internal(a00,a10,a20,0);
-            _row1Ptr = internalIO.load_internal(a10,a11,a12,a13);
+            _colum1Ptr = internalIO.load_internal(a01,a11,a21,0);
-            _row2Ptr = internalIO.load_internal(a20,a21,a22,a23);
+            _colum2Ptr = internalIO.load_internal(a02,a12,a22,0);
+            _colum2Ptr = internalIO.load_internal(a03,a13,a23,0);
 
             _transpose = new Matrix4x3(this);
         }
 
+        internal Matrix3x4(
+            IntPtr colum0Ptr,
+            IntPtr colum1Ptr,
+            IntPtr colum2Ptr,
+            IntPtr colum3Ptr
+            )
+        {
+            _colum0Ptr = colum0Ptr;
+            _colum1Ptr = colum1Ptr;
+            _colum2Ptr = colum2Ptr;
+            _colum3Ptr = colum3Ptr;
+        }
+
         internal Matrix3x4()
         {
             _transpose = new Matrix4x3(this);
@@ -36,15 +53,38 @@ namespace StgSharp.Math
             _transpose = transpose;
         }
 
-        public Matrix4x3 Transpose(TransposeMode transposeMode)
+        public unsafe Matrix4x3 Transpose(TransposeMode transposeMode)
         {
+            if (!_isTransposed)
+            {
+
+                (*(M128*)_transpose._colum0Ptr).single_0 = (*(M128*)_colum0Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_1 = (*(M128*)_colum1Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_2 = (*(M128*)_colum2Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_2 = (*(M128*)_colum3Ptr).single_0;
+                
+                (*(M128*)_transpose._colum1Ptr).single_0 = (*(M128*)_colum0Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_1 = (*(M128*)_colum1Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_2 = (*(M128*)_colum2Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_2 = (*(M128*)_colum3Ptr).single_1;
+                
+                (*(M128*)_transpose._colum2Ptr).single_0 = (*(M128*)_colum0Ptr).single_2;
+                (*(M128*)_transpose._colum2Ptr).single_1 = (*(M128*)_colum1Ptr).single_2;
+                (*(M128*)_transpose._colum2Ptr).single_2 = (*(M128*)_colum2Ptr).single_2;
+                (*(M128*)_transpose._colum2Ptr).single_2 = (*(M128*)_colum3Ptr).single_2;
+
+            }
             switch (transposeMode)
             {
                 case TransposeMode.New:
-                    return new Matrix4x3();
+                    return new Matrix4x3(
+                        internalIO.load_cpy_internal(_transpose._colum0Ptr),
+                        internalIO.load_cpy_internal(_transpose._colum1Ptr),
+                        internalIO.load_cpy_internal(_transpose._colum2Ptr)
+                        ) ;
                     break;
                 case TransposeMode.Copy:
-
+                    return _transpose;
                     break;
                 default:
                     throw new Exception();
@@ -52,6 +92,59 @@ namespace StgSharp.Math
             }
         }
 
+        public static Matrix3x4 operator +(Matrix3x4 matrix1, Matrix3x4 matrix2)
+        {
+            return new Matrix3x4(
+                internalIO.addps_internal(matrix1._colum0Ptr,matrix1._colum0Ptr),
+                internalIO.addps_internal(matrix1._colum1Ptr,matrix1._colum1Ptr),
+                internalIO.addps_internal(matrix1._colum2Ptr,matrix1._colum2Ptr),
+                internalIO.addps_internal(matrix1._colum2Ptr,matrix1._colum2Ptr)
+                );
+        }
+
+        public static Matrix3x4 operator -(Matrix4x3 matrix1, Matrix3x4 matrix2)
+        {
+            return new Matrix3x4(
+                internalIO.subps_internal(matrix1._colum0Ptr,matrix2._colum0Ptr),
+                internalIO.subps_internal(matrix1._colum1Ptr,matrix2._colum1Ptr),
+                internalIO.subps_internal(matrix1._colum2Ptr,matrix2._colum2Ptr),
+                internalIO.subps_internal(matrix1._colum2Ptr,matrix2._colum2Ptr)
+                );
+        }
+
+        public static Matrix3x4 operator *(Matrix3x4 matrix, float value)
+        {
+            return new Matrix3x4(
+                internalIO.mulps_const_internal(matrix._colum0Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum1Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum2Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum3Ptr,value)
+                );
+        }
+
+        public static Matrix3x4 operator /(Matrix3x4 matrix, float value)
+        {
+            return new Matrix3x4(
+                internalIO.divps_const_internal(matrix._colum0Ptr,value),
+                internalIO.divps_const_internal(matrix._colum1Ptr,value),
+                internalIO.divps_const_internal(matrix._colum2Ptr,value),
+                internalIO.divps_const_internal(matrix._colum3Ptr,value)
+                );
+        }
+
+        ~Matrix3x4()
+        {
+            if (map == null)
+            {
+                internalIO.deinitM128_internal(_colum0Ptr);
+                internalIO.deinitM128_internal(_colum1Ptr);
+                internalIO.deinitM128_internal(_colum2Ptr);
+            }
+            else
+            {
+
+            }
+        }
 
 
 

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

@@ -3,80 +3,126 @@ using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
-    [StructLayout(LayoutKind.Explicit)]
+    public class Matrix4x2
-    public struct matrix4x2 : IEquatable<matrix4x2>
     {
-        [FieldOffset(0)]
+        internal M128Map _map;
-        public vec2d row1;
-        [FieldOffset(8)]
-        public vec2d row2;
-        [FieldOffset(16)]
-        public vec2d row3;
-        [FieldOffset(24)]
-        public vec2d row4;
 
-        public matrix4x2(vec2d r1, vec2d r2, vec2d r3, vec2d r4)
+        internal IntPtr _colum0Ptr;
-        {
+        internal IntPtr _colum1Ptr;
-            row1 = r1;
-            row2 = r2;
-            row3 = r3;
-            row4 = r4;
-        }
 
-        public matrix4x2(
+        private bool _isTransposed;
-            float a11, float a12,
+        private Matrix2x4 _transpose;
-            float a21, float a22,
+
-            float a31, float a32,
+        public Matrix4x2(
-            float a41, float a42
+            float a00, float a01,
+            float a10, float a11,
+            float a20, float a21,
+            float a30, float a31
             )
         {
-            row1 = new vec2d(a11, a12);
+            _colum0Ptr = internalIO.load_internal(a00,a10,a20,a30);
-            row2 = new vec2d(a21, a22);
+            _colum0Ptr = internalIO.load_internal(a01,a11,a21,a31);
-            row3 = new vec2d(a31, a32);
+
-            row4 = new vec2d(a41, a42);
+            _transpose = new Matrix2x4(this);
         }
 
-        public override bool Equals(object obj)
+        public Matrix4x2(
+            IntPtr colum0Ptr,
+            IntPtr colum1Ptr
+            )
         {
-            if (obj == null)
+            _colum0Ptr = colum0Ptr;
-            {
+            _colum1Ptr = colum1Ptr;
-                return false;
+
-            }
+            _transpose = new Matrix2x4(this);
-            else if (obj.GetType() == typeof(matrix4x2))
-            {
-                return false;
-            }
-            else
-            {
-                return this.Equals((matrix4x2)obj);
-            }
         }
 
-        public override int GetHashCode()
+        public Matrix4x2(Matrix2x4 transpose)
         {
-            return HashCode.Combine(row1, row2, row3, row4);
+            _transpose = transpose;
         }
 
-        public override string ToString()
+        public unsafe Matrix2x4 Transpose(TransposeMode transposeMode )
         {
-            return $"{row1}\n{row2}\n{row3}\n{row4}";
+            if (!_isTransposed)
-        }
-
-        bool IEquatable<matrix4x2>.Equals(matrix4x2 other)
-        {
-            if (this.GetHashCode() != other.GetHashCode())
             {
-                return false;
+                (*(M128*)_transpose._colum0Ptr).single_0 = (*(M128*)_colum0Ptr).single_0;
+                (*(M128*)_transpose._colum1Ptr).single_0 = (*(M128*)_colum0Ptr).single_1;
+                (*(M128*)_transpose._colum2Ptr).single_0 = (*(M128*)_colum0Ptr).single_2;
+                (*(M128*)_transpose._colum3Ptr).single_0 = (*(M128*)_colum0Ptr).single_3;
+
+                (*(M128*)_transpose._colum0Ptr).single_1 = (*(M128*)_colum1Ptr).single_0;
+                (*(M128*)_transpose._colum1Ptr).single_1 = (*(M128*)_colum1Ptr).single_1;
+                (*(M128*)_transpose._colum2Ptr).single_1 = (*(M128*)_colum1Ptr).single_2;
+                (*(M128*)_transpose._colum3Ptr).single_1 = (*(M128*)_colum1Ptr).single_3;
+
+                _isTransposed = true;
+
             }
-            else
+
+            switch (transposeMode)
             {
-                return this.row1 == other.row1
+                case TransposeMode.New:
-                    && this.row2 == other.row2
+                    return new Matrix2x4(
-                    && this.row3 == other.row3
+                        internalIO.load_cpy_internal(_transpose._colum0Ptr),
-                    && this.row4 == other.row4;
+                        internalIO.load_cpy_internal(_transpose._colum1Ptr),
+                        internalIO.load_cpy_internal(_transpose._colum2Ptr),
+                        internalIO.load_cpy_internal(_transpose._colum3Ptr)
+                        );
+                    break;
+                case TransposeMode.Copy:
+                    return _transpose;
+                    break;
+                default:
+                    throw new Exception();
+                    break;
+            }
+
+        }
+
+        public static Matrix4x2 operator +(Matrix4x2 matrix1, Matrix4x2 matrix2)
+        {
+            return new Matrix4x2(
+                internalIO.addps_internal(matrix1._colum0Ptr,matrix2._colum0Ptr),
+                internalIO.addps_internal(matrix1._colum1Ptr,matrix2._colum1Ptr)
+                );
+        }
+
+        public static Matrix4x2 operator -(Matrix4x2 matrix1, Matrix4x2 matrix2)
+        {
+            return new Matrix4x2(
+                internalIO.subps_internal(matrix1._colum0Ptr, matrix2._colum0Ptr),
+                internalIO.subps_internal(matrix1._colum1Ptr, matrix2._colum1Ptr)
+                );
+        }
+
+        public static Matrix4x2 operator *(Matrix4x2 matrix,float value)
+        {
+            return new Matrix4x2(
+                internalIO.mulps_const_internal(matrix._colum0Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum1Ptr,value)
+                );
+        }
+
+        public static Matrix4x2 operator /(Matrix4x2 matrix, float value)
+        {
+            return new Matrix4x2(
+                internalIO.divps_const_internal(matrix._colum0Ptr,value),
+                internalIO.divps_const_internal(matrix._colum1Ptr,value)
+                );
+        }
+
+        ~Matrix4x2()
+        {
+            if (_map == null)
+            {
+                internalIO.deinitM128_internal(_colum0Ptr);
+                internalIO.deinitM128_internal(_colum1Ptr);
             }
         }
 
 
     }
+
+
 }

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

@@ -5,10 +5,11 @@ namespace StgSharp.Math
 {
     public class Matrix4x3
     {
-        internal IntPtr _row0Ptr;
+        internal M128Map map;
-        internal IntPtr _row1Ptr;
+
-        internal IntPtr _row2Ptr;
+        internal IntPtr _colum0Ptr = IntPtr.Zero;
-        internal IntPtr _row3Ptr;
+        internal IntPtr _colum1Ptr;
+        internal IntPtr _colum2Ptr;
 
         private bool _isTransposed;
         private Matrix3x4 _transpose;
@@ -20,10 +21,22 @@ namespace StgSharp.Math
             float a30, float a31, float a32
             )
         {
-            _row0Ptr = internalIO.load_internal(a00,a01,a02,0);
+            _colum0Ptr = internalIO.load_internal(a00,a10,a20,a30);
-            _row1Ptr = internalIO.load_internal(a10,a11,a12,0);
+            _colum1Ptr = internalIO.load_internal(a01,a11,a21,a31);
-            _row2Ptr = internalIO.load_internal(a20,a21,a22,0);
+            _colum2Ptr = internalIO.load_internal(a02,a12,a22,a32);
-            _row3Ptr = internalIO.load_internal(a30,a31,a32,0);
+
+            _transpose = new Matrix3x4(this);
+        }
+
+        internal Matrix4x3(
+            IntPtr colum0Ptr,
+            IntPtr colum1Ptr,
+            IntPtr colum2Ptr
+            )
+        {
+            _colum0Ptr = colum0Ptr;
+            _colum1Ptr = colum1Ptr;
+            _colum2Ptr = colum2Ptr;
 
             _transpose = new Matrix3x4(this);
         }
@@ -34,74 +47,97 @@ namespace StgSharp.Math
         }
 
 
-    }
+        public unsafe Matrix3x4 Transpose(TransposeMode transposeMode)
-
-    [StructLayout(LayoutKind.Explicit)]
-    public struct matrix4x3 : IEquatable<matrix4x3>
-    {
-        [FieldOffset(0)]
-        public Vec3d row1;
-        [FieldOffset(12)]
-        public Vec3d row2;
-        [FieldOffset(24)]
-        public Vec3d row3;
-        [FieldOffset(36)]
-        public Vec3d row4;
-
-        public matrix4x3(
-            float a11, float a12, float a13,
-            float a21, float a22, float a23,
-            float a31, float a32, float a33,
-            float a41, float a42, float a43
-            )
         {
-            row1 = new Vec3d(a11, a12, a13);
+            if (!_isTransposed)
-            row2 = new Vec3d(a21, a22, a23);
+            {
-            row3 = new Vec3d(a31, a32, a33);
+                (*(M128*)_transpose._colum0Ptr).single_0 = (*(M128*)_colum0Ptr).single_0;
-            row4 = new Vec3d(a41, a42, a43);
+                (*(M128*)_transpose._colum0Ptr).single_1 = (*(M128*)_colum1Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_2 = (*(M128*)_colum2Ptr).single_0;
+
+                (*(M128*)_transpose._colum1Ptr).single_0 = (*(M128*)_colum0Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_1 = (*(M128*)_colum1Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_2 = (*(M128*)_colum2Ptr).single_1;
+
+                (*(M128*)_transpose._colum2Ptr).single_0 = (*(M128*)_colum0Ptr).single_2;
+                (*(M128*)_transpose._colum2Ptr).single_1 = (*(M128*)_colum1Ptr).single_2;
+                (*(M128*)_transpose._colum2Ptr).single_2 = (*(M128*)_colum2Ptr).single_2;
+
+                (*(M128*)_transpose._colum3Ptr).single_0 = (*(M128*)_colum0Ptr).single_3;
+                (*(M128*)_transpose._colum3Ptr).single_1 = (*(M128*)_colum1Ptr).single_3;
+                (*(M128*)_transpose._colum3Ptr).single_2 = (*(M128*)_colum2Ptr).single_3;
+
+                _isTransposed = true;
+            }
+            switch (transposeMode)
+            {
+                case TransposeMode.New:
+                    return new Matrix3x4(
+                        _transpose._colum0Ptr,
+                        _transpose._colum1Ptr,
+                        _transpose._colum2Ptr,
+                        _transpose._colum3Ptr
+                        );
+                    break;
+                case TransposeMode.Copy:
+                    return _transpose;
+                    break;
+                default:
+                    throw new Exception();
+                    break;
+            }
         }
 
-        public override bool Equals(object obj)
+        public static Matrix4x3 operator +(Matrix4x3 matrix1, Matrix4x3 matrix2)
         {
-            if (obj == null)
+            return new Matrix4x3(
+                internalIO.addps_internal(matrix1._colum0Ptr, matrix2._colum0Ptr),
+                internalIO.addps_internal(matrix1._colum1Ptr, matrix2._colum1Ptr),
+                internalIO.addps_internal(matrix1._colum2Ptr, matrix2._colum2Ptr)
+                );
+        }
+
+        public static Matrix4x3 operator -(Matrix4x3 matrix1, Matrix4x3 matrix2)
+        {
+            return new Matrix4x3(
+                internalIO.subps_internal(matrix1._colum0Ptr, matrix2._colum0Ptr),
+                internalIO.subps_internal(matrix1._colum1Ptr, matrix2._colum1Ptr),
+                internalIO.subps_internal(matrix1._colum2Ptr, matrix2._colum2Ptr)
+                ) ;
+        }
+
+        public static Matrix4x3 operator *(Matrix4x3 matrix, float value)
+        {
+            return new Matrix4x3(
+                internalIO.mulps_const_internal(matrix._colum0Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum1Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum2Ptr,value)
+                );
+        }
+
+        public static Matrix4x3 operator /(Matrix4x3 matrix, float value)
+        {
+            return new Matrix4x3(
+                internalIO.divps_const_internal(matrix._colum0Ptr,value),
+                internalIO.divps_const_internal(matrix._colum1Ptr,value),
+                internalIO.divps_const_internal(matrix._colum2Ptr,value)
+                );
+        }
+
+
+        ~Matrix4x3()
+        {
+            if (map == null)
             {
-                return false;
+                internalIO.deinitM128_internal(_colum0Ptr);
-            }
+                internalIO.deinitM128_internal(_colum1Ptr);
-            else if (obj.GetType() != typeof(matrix4x3))
+                internalIO.deinitM128_internal(_colum2Ptr);
-            {
-                return false;
             }
             else
             {
-                return this.Equals((matrix4x3)obj);
+
             }
         }
 
-        bool IEquatable<matrix4x3>.Equals(matrix4x3 other)
-        {
-            if (this.GetHashCode() != other.GetHashCode())
-            {
-                return false;
-            }
-            else
-            {
-                return this.row1 == other.row1
-                    && this.row2 == other.row2
-                    && this.row3 == other.row3
-                    && this.row4 == other.row4;
-            }
-        }
-
-        public override int GetHashCode()
-        {
-            return base.GetHashCode();
-        }
-
-        public override string ToString()
-        {
-            return base.ToString();
-        }
-
-
     }
 }

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

@@ -25,10 +25,10 @@ namespace StgSharp.Math
 
         internal M128Map map;
 
-        internal IntPtr _row0Ptr;
+        internal IntPtr _colum0Ptr;
-        internal IntPtr _row1Ptr;
+        internal IntPtr _colum1Ptr;
-        internal IntPtr _row2Ptr;
+        internal IntPtr _colum2Ptr;
-        internal IntPtr _row3Ptr;
+        internal IntPtr _colum3Ptr;
 
 
         private bool isTransposed=false;
@@ -40,10 +40,10 @@ namespace StgSharp.Math
 
         internal Matrix4x4()
         {
-            _row0Ptr = internalIO.load_internal(0,0,0,0);
+            _colum0Ptr = internalIO.load_internal(0,0,0,0);
-            _row1Ptr = internalIO.load_internal(0,0,0,0);
+            _colum1Ptr = internalIO.load_internal(0,0,0,0);
-            _row2Ptr = internalIO.load_internal(0,0,0,0);
+            _colum2Ptr = internalIO.load_internal(0,0,0,0);
-            _row3Ptr = internalIO.load_internal(0,0,0,0);
+            _colum3Ptr = internalIO.load_internal(0,0,0,0);
 
             _transpose = new Matrix4x4(this);
         }
@@ -51,10 +51,10 @@ namespace StgSharp.Math
         //Ctor used for the matixes of transposed matrix
         internal Matrix4x4(Matrix4x4 transpose)
         {
-            _row0Ptr = internalIO.load_internal(0, 0, 0, 0);
+            _colum0Ptr = internalIO.load_internal(0, 0, 0, 0);
-            _row1Ptr = internalIO.load_internal(0, 0, 0, 0);
+            _colum1Ptr = internalIO.load_internal(0, 0, 0, 0);
-            _row2Ptr = internalIO.load_internal(0, 0, 0, 0);
+            _colum2Ptr = internalIO.load_internal(0, 0, 0, 0);
-            _row3Ptr = internalIO.load_internal(0, 0, 0, 0);
+            _colum3Ptr = internalIO.load_internal(0, 0, 0, 0);
 
             _transpose = transpose;
             this.isTransposed=true;
@@ -67,11 +67,10 @@ namespace StgSharp.Math
             IntPtr row3Ptr
             )
         {
-
+            _colum0Ptr= row0Ptr;
-            _row0Ptr = row0Ptr;
+            _colum1Ptr= row1Ptr;
-            _row1Ptr = row1Ptr;
+            _colum2Ptr= row2Ptr;
-            _row2Ptr = row2Ptr;
+            _colum3Ptr= row3Ptr;
-            _row3Ptr = row3Ptr;
 
             _transpose = new Matrix4x4(this);
         }
@@ -84,53 +83,51 @@ namespace StgSharp.Math
             )
         {
 
-            _row0Ptr = internalIO.load_internal(a00,a01,a02,a03);
+            _colum0Ptr = internalIO.load_internal(a00,a10,a20,a30);
-            _row1Ptr = internalIO.load_internal(a10,a11,a12,a13);
+            _colum1Ptr = internalIO.load_internal(a01,a11,a21,a31);
-            _row2Ptr = internalIO.load_internal(a20,a21,a22,a23);
+            _colum2Ptr = internalIO.load_internal(a02,a12,a22,a32);
-            _row3Ptr = internalIO.load_internal(a30,a31,a32,a33);
+            _colum3Ptr = internalIO.load_internal(a03,a13,a23,a33);
 
             _transpose = new Matrix4x4(this);
         }
 
-        internal void internalTranspose()
-        {
-            if (!isTransposed)
-            {
-                (*(M128*)_transpose._row0Ptr).single_0 = (*(M128*)_row0Ptr).single_0;
-                (*(M128*)_transpose._row0Ptr).single_1 = (*(M128*)_row1Ptr).single_0;
-                (*(M128*)_transpose._row0Ptr).single_2 = (*(M128*)_row2Ptr).single_0;
-                (*(M128*)_transpose._row0Ptr).single_3 = (*(M128*)_row3Ptr).single_0;
 
-                (*(M128*)_transpose._row1Ptr).single_0 = (*(M128*)_row0Ptr).single_1;
-                (*(M128*)_transpose._row1Ptr).single_1 = (*(M128*)_row1Ptr).single_1;
-                (*(M128*)_transpose._row1Ptr).single_2 = (*(M128*)_row2Ptr).single_1;
-                (*(M128*)_transpose._row1Ptr).single_3 = (*(M128*)_row3Ptr).single_1;
-
-                (*(M128*)_transpose._row2Ptr).single_0 = (*(M128*)_row0Ptr).single_2;
-                (*(M128*)_transpose._row2Ptr).single_1 = (*(M128*)_row1Ptr).single_2;
-                (*(M128*)_transpose._row2Ptr).single_2 = (*(M128*)_row2Ptr).single_2;
-                (*(M128*)_transpose._row2Ptr).single_3 = (*(M128*)_row3Ptr).single_2;
-
-                (*(M128*)_transpose._row3Ptr).single_0 = (*(M128*)_row0Ptr).single_3;
-                (*(M128*)_transpose._row3Ptr).single_1 = (*(M128*)_row1Ptr).single_3;
-                (*(M128*)_transpose._row3Ptr).single_2 = (*(M128*)_row2Ptr).single_3;
-                (*(M128*)_transpose._row3Ptr).single_3 = (*(M128*)_row3Ptr).single_3;
-
-                isTransposed = true;
-            }
-        }
 
         public unsafe Matrix4x4 Transpose(TransposeMode transposeMode)
         {
-            this.internalTranspose();
+
+            if (!isTransposed)
+            {
+                (*(M128*)_transpose._colum0Ptr).single_0 = (*(M128*)_colum0Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_1 = (*(M128*)_colum1Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_2 = (*(M128*)_colum2Ptr).single_0;
+                (*(M128*)_transpose._colum0Ptr).single_3 = (*(M128*)_colum3Ptr).single_0;
+
+                (*(M128*)_transpose._colum1Ptr).single_0 = (*(M128*)_colum0Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_1 = (*(M128*)_colum1Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_2 = (*(M128*)_colum2Ptr).single_1;
+                (*(M128*)_transpose._colum1Ptr).single_3 = (*(M128*)_colum3Ptr).single_1;
+
+                (*(M128*)_transpose._colum2Ptr).single_0 = (*(M128*)_colum0Ptr).single_2;
+                (*(M128*)_transpose._colum2Ptr).single_1 = (*(M128*)_colum1Ptr).single_2;
+                (*(M128*)_transpose._colum2Ptr).single_2 = (*(M128*)_colum2Ptr).single_2;
+                (*(M128*)_transpose._colum2Ptr).single_3 = (*(M128*)_colum3Ptr).single_2;
+
+                (*(M128*)_transpose._colum3Ptr).single_0 = (*(M128*)_colum0Ptr).single_3;
+                (*(M128*)_transpose._colum3Ptr).single_1 = (*(M128*)_colum1Ptr).single_3;
+                (*(M128*)_transpose._colum3Ptr).single_2 = (*(M128*)_colum2Ptr).single_3;
+                (*(M128*)_transpose._colum3Ptr).single_3 = (*(M128*)_colum3Ptr).single_3;
+
+                isTransposed = true;
+            }
             switch (transposeMode)
             {
                 case TransposeMode.New:
                     return new Matrix4x4(
-                        _transpose._row0Ptr,
+                        internalIO.load_cpy_internal(_transpose._colum0Ptr),
-                        _transpose._row1Ptr,
+                        internalIO.load_cpy_internal(_transpose._colum1Ptr),
-                        _transpose._row2Ptr,
+                        internalIO.load_cpy_internal(_transpose._colum2Ptr),
-                        _transpose._row3Ptr
+                        internalIO.load_cpy_internal(_transpose._colum3Ptr)
                         );
                     break;
                 case TransposeMode.Copy:
@@ -146,20 +143,20 @@ namespace StgSharp.Math
         public static Matrix4x4 operator +(Matrix4x4 matrix1, Matrix4x4 matrix2)
         {
             return new Matrix4x4(
-                internalIO.addps_internal(matrix1._row0Ptr, matrix2._row0Ptr),
+                internalIO.addps_internal(matrix1._colum0Ptr, matrix2._colum0Ptr),
-                internalIO.addps_internal(matrix1._row1Ptr, matrix2._row1Ptr),
+                internalIO.addps_internal(matrix1._colum1Ptr, matrix2._colum1Ptr),
-                internalIO.addps_internal(matrix1._row2Ptr, matrix2._row2Ptr),
+                internalIO.addps_internal(matrix1._colum2Ptr, matrix2._colum2Ptr),
-                internalIO.addps_internal(matrix1._row3Ptr, matrix2._row3Ptr)
+                internalIO.addps_internal(matrix1._colum3Ptr, matrix2._colum3Ptr)
                 ) ;
         }
 
         public static Matrix4x4 operator -(Matrix4x4 matrix1, Matrix4x4 matrix2)
         {
             return new Matrix4x4(
-                internalIO.subps_internal(matrix1._row0Ptr, matrix2._row0Ptr),
+                internalIO.subps_internal(matrix1._colum0Ptr, matrix2._colum0Ptr),
-                internalIO.subps_internal(matrix1._row1Ptr, matrix2._row1Ptr),
+                internalIO.subps_internal(matrix1._colum1Ptr, matrix2._colum1Ptr),
-                internalIO.subps_internal(matrix1._row2Ptr, matrix2._row2Ptr),
+                internalIO.subps_internal(matrix1._colum2Ptr, matrix2._colum2Ptr),
-                internalIO.subps_internal(matrix1._row3Ptr, matrix2._row3Ptr)
+                internalIO.subps_internal(matrix1._colum3Ptr, matrix2._colum3Ptr)
                 );
         }
 
@@ -167,17 +164,17 @@ namespace StgSharp.Math
         public static Matrix4x4 operator *(Matrix4x4 matrix, float value)
         {
             return new Matrix4x4(
-                internalIO.mulps_const_internal(matrix._row0Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum0Ptr,value),
-                internalIO.mulps_const_internal(matrix._row1Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum1Ptr,value),
-                internalIO.mulps_const_internal(matrix._row2Ptr,value),
+                internalIO.mulps_const_internal(matrix._colum2Ptr,value),
-                internalIO.mulps_const_internal(matrix._row3Ptr,value)
+                internalIO.mulps_const_internal(matrix._colum3Ptr,value)
                 );
         }
 
 
         public override string ToString()
         {
-            return $"{*(M128*)_row0Ptr}\n{*(M128*)_row1Ptr}\n{*(M128*)_row2Ptr}\n{*(M128*)_row3Ptr}";
+            return $"{*(M128*)_colum0Ptr}\n{*(M128*)_colum1Ptr}\n{*(M128*)_colum2Ptr}\n{*(M128*)_colum3Ptr}";
         }
 
 
@@ -186,10 +183,10 @@ namespace StgSharp.Math
         {
             if (map==null)
             {
-                internalIO.deinitM128_internal(_row0Ptr);
+                internalIO.deinitM128_internal(_colum0Ptr);
-                internalIO.deinitM128_internal(_row1Ptr);
+                internalIO.deinitM128_internal(_colum1Ptr);
-                internalIO.deinitM128_internal(_row2Ptr);
+                internalIO.deinitM128_internal(_colum2Ptr);
-                internalIO.deinitM128_internal(_row3Ptr);
+                internalIO.deinitM128_internal(_colum3Ptr);
             }
             else
             {

源代码/StgShqrpGraphic/StgSharpGraphic.h

@@ -20,6 +20,7 @@ SSGC_API int initGLAD(void);
 
 
 SSGC_API __m128* __cdecl load(float x, float y, float z, float w);
+SSGC_API __m128* __cdecl load_cpy(__m128* ptr);
 SSGC_API __m128* __cdecl addps(__m128* ptr1, __m128* ptr2);
 SSGC_API __m128* __cdecl subps(__m128* ptr1, __m128* ptr2);
 SSGC_API __m128* __cdecl mulps_const(__m128* ptr, float value);

源代码/StgShqrpGraphic/linear.c

@@ -24,6 +24,18 @@ SSGC_API __m128* __cdecl load(float x, float y, float z, float w)
     }
 }
 
+SSGC_API __m128* __cdecl load_cpy(__m128* ptr)
+{
+    __m128* ret = _aligned_malloc(sizeof(__m128*),16);
+
+    if (NULL != ret)
+    {
+        *ret = *ptr;
+    }
+
+    return ret;
+}
+
 SSGC_API __m128* __cdecl addps(__m128* ptr1, __m128* ptr2)
 {
     

源代码/StgShqrpGraphic/x64/Debug/linear.cod

@@ -35,6 +35,7 @@ __AD80FFF0_pmmintrin@h DB 01H
 __B5461FF6_linear@c DB 01H
 msvcjmc	ENDS
 PUBLIC	load
+PUBLIC	load_cpy
 PUBLIC	addps
 PUBLIC	subps
 PUBLIC	mulps_const
@@ -56,6 +57,12 @@ $pdata$load DD	imagerel $LN6
 pdata	ENDS
 ;	COMDAT pdata
 pdata	SEGMENT
+$pdata$load_cpy DD imagerel $LN6
+	DD	imagerel $LN6+52
+	DD	imagerel $unwind$load_cpy
+pdata	ENDS
+;	COMDAT pdata
+pdata	SEGMENT
 $pdata$addps DD	imagerel $LN6
 	DD	imagerel $LN6+85
 	DD	imagerel $unwind$addps
@@ -151,6 +158,11 @@ $unwind$addps DD 040a01H
 xdata	ENDS
 ;	COMDAT xdata
 xdata	SEGMENT
+$unwind$load_cpy DD 020601H
+	DD	030023206H
+xdata	ENDS
+;	COMDAT xdata
+xdata	SEGMENT
 $unwind$load DD	092701H
 	DD	039827H
 	DD	04881eH
@@ -172,7 +184,7 @@ _TEXT	SEGMENT
 ptr$ = 48
 deinitM128 PROC						; COMDAT
 
-; 142  : {
+; 154  : {
 
 $LN4:
   00000	40 53		 push	 rbx
@@ -183,8 +195,8 @@ $LN4:
   00010	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
   00015	48 8b cb	 mov	 rcx, rbx
 
-; 143  :     free(ptr);
+; 155  :     free(ptr);
-; 144  : }
+; 156  : }
 
   00018	48 83 c4 20	 add	 rsp, 32			; 00000020H
   0001c	5b		 pop	 rbx
@@ -200,7 +212,7 @@ ptr1$ = 48
 ptr2$ = 56
 divps	PROC						; COMDAT
 
-; 120  : {
+; 132  : {
 
 $LN6:
   00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
@@ -218,23 +230,23 @@ $LN6:
   00029	48 85 c0	 test	 rax, rax
   0002c	74 14		 je	 SHORT $LN2@divps
 
-; 121  :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);
+; 133  :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);
-; 122  : 
+; 134  : 
-; 123  :     if (NULL != ret)
+; 135  :     if (NULL != ret)
-; 124  :     {
+; 136  :     {
-; 125  :         *ret = _mm_div_ps(*ptr1, *ptr2);
+; 137  :         *ret = _mm_div_ps(*ptr1, *ptr2);
 
   0002e	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
   00031	0f 5e 03	 divps	 xmm0, XMMWORD PTR [rbx]
   00034	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0
 
-; 126  :         return ret;
+; 138  :         return ret;
-; 127  :     }
+; 139  :     }
-; 128  :     else
+; 140  :     else
-; 129  :     {
+; 141  :     {
-; 130  :         return -1;
+; 142  :         return -1;
-; 131  :     }
+; 143  :     }
-; 132  : }
+; 144  : }
 
   00037	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
   0003c	48 83 c4 20	 add	 rsp, 32			; 00000020H
@@ -258,7 +270,7 @@ ptr$ = 80
 value$ = 88
 divps_const PROC					; COMDAT
 
-; 101  : {
+; 113  : {
 
 $LN6:
   00000	40 53		 push	 rbx
@@ -278,28 +290,28 @@ $LN6:
   00033	48 85 c0	 test	 rax, rax
   00036	74 17		 je	 SHORT $LN2@divps_cons
 
-; 102  : 
+; 114  : 
-; 103  :     float c[4] = { value, value, value, value };
+; 115  :     float c[4] = { value, value, value, value };
-; 104  :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);
+; 116  :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);
-; 105  : 
+; 117  : 
-; 106  :     __m128 valueVec = _mm_loadu_ps(&c);
+; 118  :     __m128 valueVec = _mm_loadu_ps(&c);
-; 107  : 
+; 119  : 
-; 108  :     if (NULL != ret)
+; 120  :     if (NULL != ret)
-; 109  :     {
+; 121  :     {
-; 110  :         *ret = _mm_div_ps(*ptr, valueVec);
+; 122  :         *ret = _mm_div_ps(*ptr, valueVec);
 
   00038	0f 10 0b	 movups	 xmm1, XMMWORD PTR [rbx]
   0003b	0f 10 c6	 movups	 xmm0, xmm6
   0003e	0f 5e ce	 divps	 xmm1, xmm6
   00041	0f 11 08	 movups	 XMMWORD PTR [rax], xmm1
 
-; 111  :         return ret;
+; 123  :         return ret;
-; 112  :     }
+; 124  :     }
-; 113  :     else
+; 125  :     else
-; 114  :     {
+; 126  :     {
-; 115  :         return -1;
+; 127  :         return -1;
-; 116  :     }
+; 128  :     }
-; 117  : }
+; 129  : }
 
   00044	0f 28 74 24 30	 movaps	 xmm6, XMMWORD PTR [rsp+48]
   00049	48 83 c4 40	 add	 rsp, 64			; 00000040H
@@ -322,7 +334,7 @@ ptr1$ = 48
 ptr2$ = 56
 mulps_sum PROC						; COMDAT
 
-; 93   : {
+; 105  : {
 
 $LN4:
   00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
@@ -339,11 +351,11 @@ $LN4:
   00027	f2 0f 7c c0	 haddps	 xmm0, xmm0
   0002b	f2 0f 7c c0	 haddps	 xmm0, xmm0
 
-; 94   :     __m128 ret = _mm_mul_ps(*ptr1,*ptr2);
+; 106  :     __m128 ret = _mm_mul_ps(*ptr1,*ptr2);
-; 95   :     ret = _mm_hadd_ps(ret,ret);
+; 107  :     ret = _mm_hadd_ps(ret,ret);
-; 96   :     ret = _mm_hadd_ps(ret,ret);
+; 108  :     ret = _mm_hadd_ps(ret,ret);
-; 97   :     return *(float*)&ret;
+; 109  :     return *(float*)&ret;
-; 98   : }
+; 110  : }
 
   0002f	48 83 c4 20	 add	 rsp, 32			; 00000020H
   00033	5f		 pop	 rdi
@@ -358,7 +370,7 @@ ptr1$ = 48
 ptr2$ = 56
 mulps	PROC						; COMDAT
 
-; 78   : {
+; 90   : {
 
 $LN6:
   00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
@@ -376,23 +388,23 @@ $LN6:
   00029	48 85 c0	 test	 rax, rax
   0002c	74 14		 je	 SHORT $LN2@mulps
 
-; 79   :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);
+; 91   :     __m128* ret = _aligned_malloc(sizeof(__m128), 16);
-; 80   : 
+; 92   : 
-; 81   :     if (NULL != ret)
+; 93   :     if (NULL != ret)
-; 82   :     {
+; 94   :     {
-; 83   :         *ret = _mm_mul_ps(*ptr1, *ptr2);
+; 95   :         *ret = _mm_mul_ps(*ptr1, *ptr2);
 
   0002e	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
   00031	0f 59 03	 mulps	 xmm0, XMMWORD PTR [rbx]
   00034	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0
 
-; 84   :         return ret;
+; 96   :         return ret;
-; 85   :     }
+; 97   :     }
-; 86   :     else
+; 98   :     else
-; 87   :     {
+; 99   :     {
-; 88   :         return -1;
+; 100  :         return -1;
-; 89   :     }
+; 101  :     }
-; 90   : }
+; 102  : }
 
   00037	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
   0003c	48 83 c4 20	 add	 rsp, 32			; 00000020H
@@ -416,7 +428,7 @@ ptr$ = 80
 value$ = 88
 mulps_const PROC					; COMDAT
 
-; 60   : {
+; 72   : {
 
 $LN6:
   00000	40 53		 push	 rbx
@@ -436,26 +448,26 @@ $LN6:
   00033	48 85 c0	 test	 rax, rax
   00036	74 14		 je	 SHORT $LN2@mulps_cons
 
-; 61   :     float c[4] = { value, value, value, value };
+; 73   :     float c[4] = { value, value, value, value };
-; 62   :     __m128* ret = _aligned_malloc(sizeof(__m128),16);
+; 74   :     __m128* ret = _aligned_malloc(sizeof(__m128),16);
-; 63   : 
+; 75   : 
-; 64   :     __m128 valueVec = _mm_loadu_ps(&c);
+; 76   :     __m128 valueVec = _mm_loadu_ps(&c);
-; 65   : 
+; 77   : 
-; 66   :     if (NULL != ret)
+; 78   :     if (NULL != ret)
-; 67   :     {
+; 79   :     {
-; 68   :         *ret = _mm_mul_ps(*ptr,valueVec);
+; 80   :         *ret = _mm_mul_ps(*ptr,valueVec);
 
   00038	0f 10 c6	 movups	 xmm0, xmm6
   0003b	0f 59 03	 mulps	 xmm0, XMMWORD PTR [rbx]
   0003e	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0
 
-; 69   :         return ret;
+; 81   :         return ret;
-; 70   :     }
+; 82   :     }
-; 71   :     else
+; 83   :     else
-; 72   :     {
+; 84   :     {
-; 73   :         return -1;
+; 85   :         return -1;
-; 74   :     }
+; 86   :     }
-; 75   : }
+; 87   : }
 
   00041	0f 28 74 24 30	 movaps	 xmm6, XMMWORD PTR [rsp+48]
   00046	48 83 c4 40	 add	 rsp, 64			; 00000040H
@@ -478,7 +490,7 @@ ptr1$ = 48
 ptr2$ = 56
 subps	PROC						; COMDAT
 
-; 45   : {
+; 57   : {
 
 $LN6:
   00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
@@ -496,23 +508,23 @@ $LN6:
   0002a	48 85 c0	 test	 rax, rax
   0002d	74 14		 je	 SHORT $LN2@subps
 
-; 46   :     __m128* ret = _aligned_malloc(sizeof(__m128*), 16);
+; 58   :     __m128* ret = _aligned_malloc(sizeof(__m128*), 16);
-; 47   : 
+; 59   : 
-; 48   :     if (NULL != ret)
+; 60   :     if (NULL != ret)
-; 49   :     {
+; 61   :     {
-; 50   :         *ret = _mm_sub_ps(*ptr1, *ptr2);
+; 62   :         *ret = _mm_sub_ps(*ptr1, *ptr2);
 
   0002f	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
   00032	0f 5c 03	 subps	 xmm0, XMMWORD PTR [rbx]
   00035	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0
 
-; 51   :         return ret;
+; 63   :         return ret;
-; 52   :     }
+; 64   :     }
-; 53   :     else
+; 65   :     else
-; 54   :     {
+; 66   :     {
-; 55   :         return -1;
+; 67   :         return -1;
-; 56   :     }
+; 68   :     }
-; 57   : }
+; 69   : }
 
   00038	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
   0003d	48 83 c4 20	 add	 rsp, 32			; 00000020H
@@ -535,7 +547,7 @@ ptr1$ = 48
 ptr2$ = 56
 addps	PROC						; COMDAT
 
-; 28   : {
+; 40   : {
 
 $LN6:
   00000	48 89 5c 24 08	 mov	 QWORD PTR [rsp+8], rbx
@@ -553,25 +565,25 @@ $LN6:
   0002a	48 85 c0	 test	 rax, rax
   0002d	74 14		 je	 SHORT $LN2@addps
 
-; 29   :     
+; 41   :     
-; 30   :     __m128* ret = _aligned_malloc(sizeof(__m128*),16);
+; 42   :     __m128* ret = _aligned_malloc(sizeof(__m128*),16);
-; 31   : 
+; 43   : 
-; 32   :     if (NULL != ret)
+; 44   :     if (NULL != ret)
-; 33   :     {
+; 45   :     {
-; 34   :         *ret = _mm_add_ps(*ptr1, *ptr2);
+; 46   :         *ret = _mm_add_ps(*ptr1, *ptr2);
 
   0002f	0f 10 07	 movups	 xmm0, XMMWORD PTR [rdi]
   00032	0f 58 03	 addps	 xmm0, XMMWORD PTR [rbx]
   00035	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0
 
-; 35   :         return ret;
+; 47   :         return ret;
-; 36   :     }
+; 48   :     }
-; 37   :     else
+; 49   :     else
-; 38   :     {
+; 50   :     {
-; 39   :         return -1;
+; 51   :         return -1;
-; 40   :     }
+; 52   :     }
-; 41   : 
+; 53   : 
-; 42   : }
+; 54   : }
 
   00038	48 8b 5c 24 30	 mov	 rbx, QWORD PTR [rsp+48]
   0003d	48 83 c4 20	 add	 rsp, 32			; 00000020H
@@ -588,6 +600,49 @@ addps	ENDP
 _TEXT	ENDS
 ; Function compile flags: /Ogtpy
 ; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgShqrpGraphic\linear.c
+;	COMDAT load_cpy
+_TEXT	SEGMENT
+ptr$ = 48
+load_cpy PROC						; COMDAT
+
+; 28   : {
+
+$LN6:
+  00000	40 53		 push	 rbx
+  00002	48 83 ec 20	 sub	 rsp, 32			; 00000020H
+  00006	48 8b d9	 mov	 rbx, rcx
+  00009	48 8d 0d 00 00
+	00 00		 lea	 rcx, OFFSET FLAT:__B5461FF6_linear@c
+  00010	e8 00 00 00 00	 call	 __CheckForDebuggerJustMyCode
+  00015	ba 10 00 00 00	 mov	 edx, 16
+  0001a	8d 4a f8	 lea	 ecx, QWORD PTR [rdx-8]
+  0001d	ff 15 00 00 00
+	00		 call	 QWORD PTR __imp__aligned_malloc
+  00023	48 85 c0	 test	 rax, rax
+  00026	74 06		 je	 SHORT $LN4@load_cpy
+
+; 29   :     __m128* ret = _aligned_malloc(sizeof(__m128*),16);
+; 30   : 
+; 31   :     if (NULL != ret)
+; 32   :     {
+; 33   :         *ret = *ptr;
+
+  00028	0f 10 03	 movups	 xmm0, XMMWORD PTR [rbx]
+  0002b	0f 11 00	 movups	 XMMWORD PTR [rax], xmm0
+$LN4@load_cpy:
+
+; 34   :     }
+; 35   : 
+; 36   :     return ret;
+; 37   : }
+
+  0002e	48 83 c4 20	 add	 rsp, 32			; 00000020H
+  00032	5b		 pop	 rbx
+  00033	c3		 ret	 0
+load_cpy ENDP
+_TEXT	ENDS
+; Function compile flags: /Ogtpy
+; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgShqrpGraphic\linear.c
 ;	COMDAT load
 _TEXT	SEGMENT
 array$ = 32