Daily update on 20230806 by nitload youmu

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

@@ -5,10 +5,11 @@ namespace StgSharp.Math
 {
     public class Matrix4x3
     {
-        internal IntPtr _row0Ptr;
-        internal IntPtr _row1Ptr;
-        internal IntPtr _row2Ptr;
-        internal IntPtr _row3Ptr;
+        internal M128Map map;
+
+        internal IntPtr _colum0Ptr = IntPtr.Zero;
+        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);
-            _row1Ptr = internalIO.load_internal(a10,a11,a12,0);
-            _row2Ptr = internalIO.load_internal(a20,a21,a22,0);
-            _row3Ptr = internalIO.load_internal(a30,a31,a32,0);
+            _colum0Ptr = internalIO.load_internal(a00,a10,a20,a30);
+            _colum1Ptr = internalIO.load_internal(a01,a11,a21,a31);
+            _colum2Ptr = internalIO.load_internal(a02,a12,a22,a32);
+
+            _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
         }
 
 
-    }
-
-    [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
-            )
+        public unsafe Matrix3x4 Transpose(TransposeMode transposeMode)
         {
-            row1 = new Vec3d(a11, a12, a13);
-            row2 = new Vec3d(a21, a22, a23);
-            row3 = new Vec3d(a31, a32, a33);
-            row4 = new Vec3d(a41, a42, a43);
+            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._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;
-            }
-            else if (obj.GetType() != typeof(matrix4x3))
-            {
-                return false;
+                internalIO.deinitM128_internal(_colum0Ptr);
+                internalIO.deinitM128_internal(_colum1Ptr);
+                internalIO.deinitM128_internal(_colum2Ptr);
             }
             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();
-        }
-
-
     }
 }