daily update on 20230822 by nitload youmu

源代码/StgSharp/Control/IO/InternalIO.cs

@@ -1,10 +1,20 @@
-using StgSharp.Geometries;
+//
+#define WINDOWS
+//#define LINUX
+//#define MACOS
+//#define IOS
+//#define ANDROID
+
+using StgSharp.Geometries;
+using System;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
+
+
+
 namespace StgSharp
 {
-    
-
     internal static unsafe partial class internalIO
     {
 

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

@@ -11,10 +11,18 @@ namespace StgSharp
 {
     internal static partial class internalIO
     {
-        [DllImport("StgSharpGraphic.dll", EntryPoint = "load",
+
+        #region load
+
+        [DllImport(dllName: "StgSharpGraphic.dll", EntryPoint = "load",
             CallingConvention = CallingConvention.Cdecl)]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static extern IntPtr load_internal(float x,float y, float z, float w);
+        internal static extern ref M128 load_internal(float x,float y, float z, float w);
+
+        [DllImport(dllName: "StgSharpGraphic.dll", EntryPoint = "load",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe extern M128* loadptr_internal(float x, float y, float z, float w);
 
         [DllImport("StgSharpGraphic.dll",EntryPoint = "load_matmap",
             CallingConvention = CallingConvention.Cdecl)]
@@ -24,6 +32,11 @@ namespace StgSharp
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr load_cpy_internal(IntPtr ptr);
 
+
+        #endregion
+
+        #region add sub
+
         [DllImport("StgSharpGraphic.dll", EntryPoint = "addps",
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr addps_internal(IntPtr ptr1, IntPtr ptr2);
@@ -32,18 +45,33 @@ namespace StgSharp
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr subps_internal(IntPtr ptr1, IntPtr ptr2);
 
+        #endregion
+
+        #region mulps
+
         [DllImport("StgSharpGraphic.dll", EntryPoint = "mulps",
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr mulps_internal(IntPtr ptr1, IntPtr ptr2);
 
         [DllImport("StgSharpGraphic.dll", EntryPoint = "mulps_const",
             CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static extern IntPtr mulps_const_internal(IntPtr ptr, float value);
 
+
         [DllImport("StgSharpGraphic.dll", EntryPoint = "mulps_sum",
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern float mulps_sum_internal(IntPtr ptr1, IntPtr ptr2);
 
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "mulps_sum",
+            CallingConvention = CallingConvention.Cdecl)]
+        internal static extern unsafe float mulps_sum_internal(M128* ptr1, M128* ptr2);
+
+        #endregion
+
+        #region div
+
+
         [DllImport("StgSharpGraphic.dll", EntryPoint = "mulps",
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr divps_internal(IntPtr ptr1, IntPtr ptr2);
@@ -52,14 +80,12 @@ namespace StgSharp
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr divps_const_internal(IntPtr ptr, float value);
 
+        #endregion
+
         [DllImport("StgSharpGraphic.dll", EntryPoint = "sqrtss_const",
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern float sqrtss_const_internal(float a);
 
-        [DllImport("StgSharpGraphic.dll",EntryPoint = "test_addps_mat",
-            CallingConvention = CallingConvention.Cdecl)]
-        internal static extern IntPtr addps_mat_internal_test(IntPtr ptr1, IntPtr ptr2);
-
 
 
 
@@ -67,21 +93,56 @@ namespace StgSharp
             CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr set_m128ptr_default_internal();
 
-        [DllImport("StgSharpGraphic.dll", EntryPoint = "transpose_ssemat_2",
+
+
+
+
+
+        #region deinit m128
+
+        [DllImport(
+            "msvcrt.dll",
+            EntryPoint = "_aligned_free",
             CallingConvention = CallingConvention.Cdecl)]
-        internal static extern ref M128matMap transpose_ssemat2_internal(ref M128matMap matMap);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern unsafe void deinit_internal(M128* ptr);
 
-        [DllImport("StgSharpGraphic.dll",EntryPoint = "transpose_ssemat_3",
+        [DllImport(
+            "msvcrt.dll",
+            EntryPoint = "_aligned_free",
             CallingConvention = CallingConvention.Cdecl)]
-        internal static extern ref M128matMap transpose_ssemat3_internal(ref M128matMap matMap);
-
-
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern unsafe void deinit_internal(Mat2* ptr);
 
+        /*
+        [DllImport(
+            "msvcrt.dll",
+            EntryPoint = "_aligned_free",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern unsafe void deinit_internal(Mat3* ptr);
+        */
 
+        [DllImport(
+            "msvcrt.dll",
+            EntryPoint = "_aligned_free",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern unsafe void deinit_internal(Mat4* ptr);
 
         [DllImport("StgSharpGraphic.dll", EntryPoint = "deinitM128",
             CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void deinitM128_internal(IntPtr M128Ptr);
+        internal static extern void deinitM128_internal(ref M128 vec);
+
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "deinitM128",
+            CallingConvention = CallingConvention.Cdecl)]
+        internal static extern unsafe void deinitM128_internal(M128* vec);
+
+        #endregion
+
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "deinit_matmapPtr_sse",
+            CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void deinitMatmapPtr_sse_internal(ref M128matMap mapPtr);
 
         [DllImport("StgSharpGraphic.dll", EntryPoint = "deinit_matmap_sse",
             CallingConvention = CallingConvention.Cdecl)]

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

@@ -6,20 +6,11 @@ using System.Text;
 
 namespace StgSharp.Math
 {
-    [StructLayout(LayoutKind.Explicit)]
-    internal struct MatSize
-    {
-        [FieldOffset(0)]
-        internal ushort sizePair;
-
-        [FieldOffset(0)]
-        internal byte width;
-        [FieldOffset(1)]
-        internal byte height;
-    }
 
     public static unsafe partial class SSE
     {
+        public static int M128Size = 16;
+
         internal static IntPtr defaultM128Ptr = 
             internalIO.set_m128ptr_default_internal();
 
@@ -43,11 +34,5 @@ namespace StgSharp.Math
         {
         }
 
-        public static Vec4d addps(Vec4d vec1, Vec4d vec2)
-        {
-            return new Vec4d(
-                internalIO.addps_internal(vec1._m128Ptr,vec2._m128Ptr)
-                ) ;
-        }
     }
 }

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

@@ -3,7 +3,7 @@ using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
-    public static unsafe partial class VectorCalc
+    public static partial class VectorCalc
     {
         /*
 
@@ -527,30 +527,34 @@ namespace StgSharp.Math
                 );
         }
 
+        /*
+
         public static Matrix4x4 Multiple( Matrix4x4 matrix1, Matrix4x4 matrix2)
         {
-            Matrix4x4 transpose = matrix1.Transpose(TransposeMode.Copy);
+            matrix1.InternalTranspose();
+
             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(matrix1._transpose.colum0Ptr,matrix2._matMap.colum0Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum0Ptr,matrix2._matMap.colum1Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum0Ptr,matrix2._matMap.colum2Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum0Ptr,matrix2._matMap.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(matrix1._transpose.colum1Ptr,matrix2._matMap.colum0Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum1Ptr,matrix2._matMap.colum1Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum1Ptr,matrix2._matMap.colum2Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum1Ptr,matrix2._matMap.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(matrix1._transpose.colum2Ptr,matrix2._matMap.colum0Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum2Ptr,matrix2._matMap.colum1Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum2Ptr,matrix2._matMap.colum2Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum2Ptr,matrix2._matMap.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)
+                internalIO.mulps_sum_internal(matrix1._transpose.colum3Ptr,matrix2._matMap.colum0Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum3Ptr,matrix2._matMap.colum1Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum3Ptr,matrix2._matMap.colum2Ptr),
+                internalIO.mulps_sum_internal(matrix1._transpose.colum3Ptr,matrix2._matMap.colum3Ptr)
                 );
+
         }
         
 

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

@@ -1,84 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace StgSharp.Math
-{
-    [StructLayout(LayoutKind.Explicit)]
-    public struct colum2 : IEquatable<colum2>
-    {
-        [FieldOffset(0)]
-        public float X;
-        [FieldOffset(4)]
-        public float Y;
-
-        public colum2(float x, float y)
-        {
-            X = x;
-            Y = y;
-        }
-
-        public override bool Equals(object obj)
-        {
-            if (obj == null)
-            {
-                return false;
-            }
-            else if (obj.GetType() != typeof(colum2))
-            {
-                return false;
-            }
-            else
-            {
-                return this.Equals((colum2)obj);
-            }
-        }
-
-        bool IEquatable<colum2>.Equals(colum2 other)
-        {
-            if (this.GetHashCode() != other.GetHashCode())
-            {
-                return false;
-            }
-            else
-            {
-                return X == other.X && Y == other.Y;
-            }
-        }
-
-        public override int GetHashCode()
-        {
-            return HashCode.Combine(X, Y);
-        }
-
-        public override string ToString()
-        {
-            return $"{X}\n{Y}";
-        }
-
-        public static colum2 operator +(colum2 c1, colum2 c2)
-        {
-            return new colum2(
-                c1.X + c2.X,
-                c1.Y + c2.Y
-                );
-        }
-
-        public static colum2 operator -(colum2 c1, colum2 c2)
-        {
-            return new colum2(
-                c1.X - c2.X,
-                c1.Y - c2.Y
-                );
-        }
-
-        public static colum2 operator *(colum2 colum, float x)
-        {
-            return new colum2(colum.X * x, colum.Y * x);
-        }
-
-        public static colum2 operator /(colum2 colum, float x)
-        {
-            return new colum2(colum.X / x, colum.Y / x);
-        }
-    }
-}

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

@@ -1,121 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace StgSharp.Math
-{
-    [StructLayout(LayoutKind.Explicit)]
-    public struct colum3 : IEquatable<colum3>
-    {
-        [FieldOffset(0)]
-        public float X;
-        [FieldOffset(4)]
-        public float Y;
-        [FieldOffset(8)]
-        public float Z;
-
-        public colum3(float x, float y, float z)
-        {
-            X = x;
-            Y = y;
-            Z = z;
-        }
-
-        bool IEquatable<colum3>.Equals(colum3 other)
-        {
-            if (this.GetHashCode() != other.GetHashCode())
-            {
-                return false;
-            }
-            else
-            {
-                return this.X == other.X
-                    && this.Y == other.Y
-                    && this.Z == other.Z;
-            }
-        }
-
-        public override bool Equals(object obj)
-        {
-            if (obj == null)
-            {
-                return false;
-            }
-            else if (obj.GetType() != typeof(colum3))
-            {
-                return false;
-            }
-            else
-            {
-                return this.Equals((colum3)obj);
-            }
-        }
-
-        public override int GetHashCode()
-        {
-            return HashCode.Combine(X, Y, Z);
-        }
-
-        public override string ToString()
-        {
-            return $"{X}\t{Y}\t{Z}";
-        }
-
-        public static bool operator ==(colum3 vec1, colum3 vec2)
-        {
-            return vec1.X == vec2.X
-                && vec1.Y == vec2.Y
-                && vec1.Z == vec2.Z;
-        }
-
-        public static bool operator !=(colum3 vec1, colum3 vec2)
-        {
-            return !(vec1.X == vec2.X
-                && vec1.Y == vec2.Y
-                && vec1.Z == vec2.Z);
-        }
-
-        public static colum3 operator +(colum3 vec1, colum3 vec2)
-        {
-            return new colum3(
-                vec1.X + vec2.X,
-                vec1.Y + vec2.Y,
-                vec1.Z + vec2.Z
-                );
-        }
-
-        public static colum3 operator -(colum3 vec1, colum3 vec2)
-        {
-            return new colum3(
-                vec1.X - vec2.X,
-                vec1.Y - vec2.Y,
-                vec1.Z - vec2.Z
-                );
-        }
-
-        public static float operator *(colum3 vec1, colum3 vec2)
-        {
-            return
-                vec1.X * vec2.X
-                + vec1.Y + vec2.Y
-                + vec1.Z + vec2.Z;
-        }
-
-        public static colum3 operator *(colum3 vec, float x)
-        {
-            return new colum3(
-                vec.X * x,
-                vec.Y * x,
-                vec.Z * x
-                );
-        }
-
-        public static colum3 operator /(colum3 vec, float x)
-        {
-            return new colum3(
-                vec.X / x,
-                vec.Y / x,
-                vec.Z / x
-                );
-        }
-    }
-}

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

@@ -1,46 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace StgSharp.Math
-{
-    [StructLayout(LayoutKind.Explicit)]
-    public struct colum4 : IEquatable<colum4>
-    {
-        [FieldOffset(0)]
-        public float X;
-        [FieldOffset(4)]
-        public float Y;
-        [FieldOffset(8)]
-        public float Z;
-        [FieldOffset(12)]
-        public float W;
-
-        public colum4(float x, float y, float z, float w)
-        {
-            X = x;
-            Y = y;
-            Z = z;
-            W = w;
-        }
-
-        public bool Equals(colum4 other)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override bool Equals(object obj)
-        {
-            return base.Equals(obj);
-        }
-
-        public override int GetHashCode()
-        {
-            return base.GetHashCode();
-        }
-
-        public override string ToString()
-        {
-            return base.ToString();
-        }
-    }
-}

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

@@ -0,0 +1,73 @@
+using StgSharp.Math;
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+
+namespace StgSharp
+{
+    internal static unsafe partial class internalIO
+    {
+        #region add
+
+        [DllImport("StgsharpGraphic", EntryPoint = "add_Mat2",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern Mat2* add_mat2(Mat2* left, Mat2* right);
+
+
+        #endregion
+
+        #region sub
+
+        [DllImport("StgsharpGraphic", EntryPoint = "sub_mat2",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern unsafe Mat2* sub_mat2(Mat2* left, Mat2* right);
+
+        #endregion
+
+
+        #region transpose
+
+
+        [DllImport("StgsharpGraphic", EntryPoint = "transmpose2to4",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern unsafe void Transpose2to4_internal(Mat2* source, Mat4* target);
+
+        #endregion
+
+        #region deinit mat2
+
+        [DllImport("StgsharpGraphic", EntryPoint = "deinit_mat2",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern unsafe void deinit_mat2(Mat2* mat);
+
+        #endregion
+
+    }
+}
+
+namespace StgSharp.Math
+{
+    [StructLayout(LayoutKind.Explicit, Size = 12 * sizeof(float), Pack = 16)]
+    internal struct Mat2
+    {
+
+        [FieldOffset(0)] internal M128 colum0;
+        [FieldOffset(4 * sizeof(float))] internal M128 colum1;
+
+        [FieldOffset(0 * sizeof(float))] internal float m00;
+        [FieldOffset(1 * sizeof(float))] internal float m10;
+        [FieldOffset(2 * sizeof(float))] internal float m20;
+        [FieldOffset(3 * sizeof(float))] internal float m30;
+
+        [FieldOffset(4 * sizeof(float))] internal float m01;
+        [FieldOffset(5 * sizeof(float))] internal float m11;
+        [FieldOffset(6 * sizeof(float))] internal float m21;
+        [FieldOffset(7 * sizeof(float))] internal float m31;
+
+    }
+}

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

@@ -0,0 +1,33 @@
+using StgSharp.Math;
+using System;
+using System.Runtime.InteropServices;
+
+
+
+namespace StgSharp.Math
+{
+    [StructLayout(LayoutKind.Explicit, Size = 12*sizeof(float),Pack = 16)]
+    internal struct mat3
+    {
+
+        [FieldOffset(0)] internal M128 colum0;
+        [FieldOffset(4 * sizeof(float))] internal M128 colum1;
+        [FieldOffset(8 * sizeof(float))] internal M128 colum2;
+
+        [FieldOffset(0 * sizeof(float))] internal float m00;
+        [FieldOffset(1 * sizeof(float))] internal float m10;
+        [FieldOffset(2 * sizeof(float))] internal float m20;
+        [FieldOffset(3 * sizeof(float))] internal float m30;
+
+        [FieldOffset(4 * sizeof(float))] internal float m01;
+        [FieldOffset(5 * sizeof(float))] internal float m11;
+        [FieldOffset(6 * sizeof(float))] internal float m21;
+        [FieldOffset(7 * sizeof(float))] internal float m31;
+
+        [FieldOffset(8 * sizeof(float))] internal float m02;
+        [FieldOffset(9 * sizeof(float))] internal float m12;
+        [FieldOffset(10 * sizeof(float))] internal float m22;
+        [FieldOffset(11 * sizeof(float))] internal float m32;
+
+    }
+}

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

@@ -0,0 +1,142 @@
+using StgSharp;
+using StgSharp.Math;
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp
+{
+    internal static unsafe partial class internalIO
+    {
+
+        #region add_mat4
+
+#if NET7_0_OR_GREATER
+#else
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "addmat4",
+#endif
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern unsafe StgSharp.Math.Mat4* add_mat4(
+            ref StgSharp.Math.Mat4 mat1, ref StgSharp.Math.Mat4 Mat2);
+
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "addmat4",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern unsafe StgSharp.Math.Mat4* add_mat4(
+            StgSharp.Math.Mat4* mat1, StgSharp.Math.Mat4* Mat2);
+
+        #endregion
+
+        #region sub_mat4
+
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "sub_mat4",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe extern StgSharp.Math.Mat4* sub_mat4(
+            ref StgSharp.Math.Mat4 mat1, ref StgSharp.Math.Mat4 Mat2);
+
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "StgSharp.Math.Mat4",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe extern StgSharp.Math.Mat4* sub_mat4(
+            StgSharp.Math.Mat4* mat1, StgSharp.Math.Mat4* Mat2);
+
+
+        #endregion
+
+        #region mul
+
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "mul_const",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe extern StgSharp.Math.Mat4* mul_const(
+            StgSharp.Math.Mat4* mat, float value);
+
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "mul_const",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe extern StgSharp.Math.Mat4* mul_const(
+            ref StgSharp.Math.Mat4 mat, float value);
+
+        [DllImport("StgsharpGraphic", EntryPoint = "mul_4_4",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern unsafe Mat4* mul_4_4(Mat4* left, Mat4* right);
+
+        #endregion
+
+        #region transpose
+
+        [DllImport("StgsharpGraphic.dll", EntryPoint = "transpose4to4",
+            CallingConvention = CallingConvention.Cdecl)]
+        internal static extern unsafe void Transpose4to4_internal(Mat4* source, Mat4* target);
+
+        [DllImport("StgsharpGraphic.dll", EntryPoint = "transpose4to4",
+            CallingConvention = CallingConvention.Cdecl)]
+        internal static extern unsafe void Transpose4to4_internal(ref Mat4* source, ref Mat4* target);
+
+
+        #endregion
+
+        #region det
+
+        [DllImport("StgsharpGraphic", EntryPoint = "det_mat4",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static unsafe extern float det_mat4(Matrix4x4* matPtr);
+
+        #endregion
+
+        #region deinit_mat4
+
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "deinit_mat4",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern void deinit_mat4(ref StgSharp.Math.Mat4 mat);
+
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "deinit_mat4",
+            CallingConvention = CallingConvention.Cdecl)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static extern void deinit_mat4(StgSharp.Math.Mat4* mat);
+
+        #endregion
+
+
+
+    }
+}
+namespace StgSharp.Math
+{
+
+
+    [StructLayout(LayoutKind.Explicit, Size = 16 * sizeof(float))]
+    public struct Mat4
+    {
+        [FieldOffset(0)] internal M128 colum0;
+        [FieldOffset(16)] internal M128 colum1;
+        [FieldOffset(32)] internal M128 colum2;
+        [FieldOffset(48)] internal M128 colum3;
+
+        [FieldOffset(0)] public float a00;
+        [FieldOffset(4)] public float a10;
+        [FieldOffset(8)] public float a20;
+        [FieldOffset(12)] public float a30;
+
+        [FieldOffset(16)] public float a01;
+        [FieldOffset(20)] public float a11;
+        [FieldOffset(24)] public float a21;
+        [FieldOffset(28)] public float a31;
+
+        [FieldOffset(32)] public float a02;
+        [FieldOffset(36)] public float a12;
+        [FieldOffset(40)] public float a22;
+        [FieldOffset(44)] public float a32;
+
+        [FieldOffset(48)] public float a03;
+        [FieldOffset(52)] public float a13;
+        [FieldOffset(56)] public float a23;
+        [FieldOffset(60)] public float a33;
+
+    }
+}

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

@@ -3,6 +3,7 @@ using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
+    /*
     public class Matrix2x2
     {
         public static Matrix2x2 Unit
@@ -115,4 +116,7 @@ namespace StgSharp.Math
         }
 
     }
+
+    /**/
+
 }

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

@@ -3,6 +3,8 @@ using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
+
+    /*
     public class Matrix2x3
     {
         internal M128Map _map;
@@ -126,4 +128,6 @@ namespace StgSharp.Math
             }
         }
     }
+
+    /**/
 }

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

@@ -4,124 +4,8 @@ using System.Runtime.InteropServices;
 namespace StgSharp.Math
 {
 
-    public class Matrix2x4
+    public struct 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/matrix3x2.cs

@@ -3,86 +3,5 @@ using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
-    public class Matrix3x2
-    {
-        internal M128Map _map;
 
-        internal IntPtr _colum0Ptr;
-        internal IntPtr _colum1Ptr;
-
-        private bool _isTransposed;
-        private Matrix2x3 _transpose;
-
-        public Matrix3x2(
-            float a00,float a01,
-            float a10,float a11,
-            float a20,float a21
-            )
-        {
-            _colum0Ptr = internalIO.load_internal(a00,a10,a20,0);
-            _colum0Ptr = internalIO.load_internal(a01,a11,a21,0);
-
-            _transpose = new Matrix2x3(this);
-        }
-
-        internal Matrix3x2(
-            IntPtr colum0Ptr,
-            IntPtr colum1Ptr
-            )
-        {
-            _colum0Ptr = colum0Ptr;
-            _colum1Ptr = colum1Ptr;
-
-            _transpose = new Matrix2x3(this);
-        }
-
-        internal Matrix3x2(Matrix2x3 transpose)
-        {
-            _transpose = transpose;
-        }
-
-        public unsafe Matrix2x3 Transpose(TransposeMode transposeMode)
-        {
-            if (_isTransposed)
-            {
-                (*(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._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;
-
-                _isTransposed = true;
-
-            }
-            switch (transposeMode)
-            {
-                case TransposeMode.New:
-                    return new Matrix2x3(
-                        _transpose._colum0Ptr,
-                        _transpose._colum0Ptr,
-                        _transpose._colum0Ptr
-                        );
-                    break;
-                case TransposeMode.Copy:
-                    return _transpose;
-                    break;
-                default:
-                    throw new Exception();
-                    break;
-            }
-
-        }
-
-        ~Matrix3x2()
-        {
-            if (_map==null)
-            {
-                internalIO.deinitM128_internal(_colum0Ptr);
-                internalIO.deinitM128_internal(_colum1Ptr);
-            }
-        }
-
-    }
 }

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

@@ -5,138 +5,6 @@ namespace StgSharp.Math
 {
     public class Matrix3x3
     {
-        public static Matrix3x3 Unit
-            = new Matrix3x3(
-                1,0,0,
-                0,1,0,
-                0,0,1
-                );
-
-        internal M128Map map;
-
-        internal IntPtr _colum0Ptr;
-        internal IntPtr _colum1Ptr;
-        internal IntPtr _colum2Ptr;
-
-        private bool _isDisposed;
-        private Matrix3x3 _transpose;
-
-        public Matrix3x3(
-            float a00, float a01, float a02,
-            float a10, float a11, float a12,
-            float a20, float a21, float a22
-            )
-        {
-            _colum0Ptr = internalIO.load_internal(a00,a10,a20,0);
-            _colum1Ptr = internalIO.load_internal(a01,a11,a21,0);
-            _colum2Ptr = internalIO.load_internal(a02,a12,a22,0);
-
-            _transpose = new Matrix3x3(this);
-        }
-
-        internal Matrix3x3(Matrix3x3 transpose)
-        {
-            _transpose = transpose;
-        }
-
-        internal Matrix3x3(
-            IntPtr colum0Ptr,
-            IntPtr colum1Ptr,
-            IntPtr colum2Ptr
-            )
-        {
-            _colum0Ptr= colum0Ptr;
-            _colum1Ptr= colum1Ptr;
-            _colum2Ptr= colum2Ptr;
-
-            _transpose = new Matrix3x3(this);
-        }
-
-        public unsafe Matrix3x3 Transpose(TransposeMode transposeMode)
-        {
-            if (!_isDisposed)
-            {
-                (*(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; 
-            }
-
-            switch (transposeMode)
-            {
-                case TransposeMode.New:
-                    return new Matrix3x3(
-                        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();
-                    break;
-            }
-
-        }
-
-        public static Matrix3x3 operator +(Matrix3x3 matrix1, Matrix3x3 matrix2)
-        {
-            return new Matrix3x3(
-                internalIO.addps_internal(matrix1._colum0Ptr,matrix2._colum0Ptr),
-                internalIO.addps_internal(matrix1._colum1Ptr,matrix2._colum1Ptr),
-                internalIO.addps_internal(matrix1._colum2Ptr,matrix2._colum2Ptr)
-                );
-        }
-
-        public static Matrix3x3 operator -(Matrix3x3 matrix1, Matrix3x3 matrix2)
-        {
-            return new Matrix3x3(
-                internalIO.subps_internal(matrix1._colum0Ptr,matrix2._colum0Ptr),
-                internalIO.subps_internal(matrix1._colum1Ptr,matrix2._colum1Ptr),
-                internalIO.subps_internal(matrix1._colum2Ptr,matrix2._colum2Ptr)
-                );
-        }
-
-        public static Matrix3x3 operator *(Matrix3x3 matrix, float value)
-        {
-            return new Matrix3x3(
-                internalIO.mulps_const_internal(matrix._colum0Ptr,value),
-                internalIO.mulps_const_internal(matrix._colum1Ptr,value),
-                internalIO.mulps_const_internal(matrix._colum2Ptr,value)
-                );
-        }
-
-        public static Matrix3x3 operator /(Matrix3x3 matrix, float value)
-        {
-            return new Matrix3x3(
-                internalIO.divps_const_internal(matrix._colum0Ptr, value),
-                internalIO.divps_const_internal(matrix._colum1Ptr, value),
-                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

@@ -1,151 +1,10 @@
 using System;
-using System.Reflection.Emit;
 using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
     public class Matrix3x4
     {
-        internal M128Map map;
-
-        internal IntPtr _colum0Ptr;
-        internal IntPtr _colum1Ptr;
-        internal IntPtr _colum2Ptr;
-        internal IntPtr _colum3Ptr;
-
-        private bool _isTransposed;
-        private Matrix4x3 _transpose;
-
-        public Matrix3x4(
-            float a00, float a01, float a02, float a03,
-            float a10, float a11, float a12, float a13,
-            float a20, float a21, float a22, float a23
-            )
-        {
-            _colum0Ptr = internalIO.load_internal(a00,a10,a20,0);
-            _colum1Ptr = internalIO.load_internal(a01,a11,a21,0);
-            _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);
-        }
-
-        internal Matrix3x4(Matrix4x3 transpose)
-        {
-            _transpose = transpose;
-        }
-
-        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(
-                        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();
-                    break;
-            }
-        }
-
-        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

@@ -1,127 +1,77 @@
 using System;
+using System.Drawing;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using static StgSharp.Graphics.GLFWwndconfig;
 
 namespace StgSharp.Math
 {
-    public class Matrix4x2
+    
+
+    [StructLayout(LayoutKind.Explicit,Size = (16 + 8) * sizeof(float) + sizeof(bool), Pack = 16)]
+    public struct Matrix4x2
     {
-        internal M128Map _map;
+        [FieldOffset(0)] internal Mat2 mat;
+        [FieldOffset(8 * sizeof(float))] internal Mat4 transpose;
+        [FieldOffset((16 + 8) * sizeof(float))] internal bool isTranspose;
 
-        internal IntPtr _colum0Ptr;
-        internal IntPtr _colum1Ptr;
 
-        private bool _isTransposed;
-        private Matrix2x4 _transpose;
-
-        public Matrix4x2(
-            float a00, float a01,
-            float a10, float a11,
-            float a20, float a21,
-            float a30, float a31
+        unsafe public Matrix4x2(
+            float a00,float a01,
+            float a10,float a11,
+            float a20,float a21,
+            float a30,float a31
             )
         {
-            _colum0Ptr = internalIO.load_internal(a00,a10,a20,a30);
-            _colum0Ptr = internalIO.load_internal(a01,a11,a21,a31);
+            M128* c0ref = internalIO.loadptr_internal(a00, a10, a20, a30);
+            M128* c1ref = internalIO.loadptr_internal(a01, a11, a21, a31);
 
-            _transpose = new Matrix2x4(this);
+            mat.colum0 = *c0ref;
+            mat.colum1 = *c1ref;
+
+            /**/
+            internalIO.deinitM128_internal(c0ref);
+            internalIO.deinitM128_internal(c1ref);
         }
 
-        public Matrix4x2(
-            IntPtr colum0Ptr,
-            IntPtr colum1Ptr
-            )
+        unsafe internal Matrix4x2(Mat2 mat)
         {
-            _colum0Ptr = colum0Ptr;
-            _colum1Ptr = colum1Ptr;
-
-            _transpose = new Matrix2x4(this);
+            this.mat = mat;
         }
 
-        public Matrix4x2(Matrix2x4 transpose)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Matrix4x2 operator +(Matrix4x2 left, Matrix4x2 right)
         {
-            _transpose = transpose;
+            Mat2* p = internalIO.add_mat2(&left.mat, &right.mat);
+            Matrix4x2 ret = new Matrix4x2(*p);
+            internalIO.deinit_mat2(p);
+            return ret;
         }
 
-        public unsafe Matrix2x4 Transpose(TransposeMode transposeMode )
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Matrix4x2 operator -(Matrix4x2 left, Matrix4x2 right)
         {
-            if (!_isTransposed)
+            Mat2* p = internalIO.sub_mat2(&left.mat, &right.mat);
+            Matrix4x2 ret = new Matrix4x2(*p);
+            internalIO.deinit_mat2(p);
+            return ret;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void InternalTranspose()
+        {
+            if (!isTranspose)
             {
-                (*(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;
+                fixed (Mat2* source = &this.mat)
+                fixed (Mat4* target = &this.transpose)
+                {
+                    internalIO.Transpose2to4_internal(source, target);
+                }
 
-                (*(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;
-
-            }
-
-            switch (transposeMode)
-            {
-                case TransposeMode.New:
-                    return new Matrix2x4(
-                        internalIO.load_cpy_internal(_transpose._colum0Ptr),
-                        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);
+                isTranspose = true;
             }
         }
 
-
     }
 
 

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

@@ -5,139 +5,7 @@ namespace StgSharp.Math
 {
     public class Matrix4x3
     {
-        internal M128Map map;
 
-        internal IntPtr _colum0Ptr = IntPtr.Zero;
-        internal IntPtr _colum1Ptr;
-        internal IntPtr _colum2Ptr;
-
-        private bool _isTransposed;
-        private Matrix3x4 _transpose;
-
-        public Matrix4x3(
-            float a00, float a01, float a02,
-            float a10, float a11, float a12,
-            float a20, float a21, float a22,
-            float a30, float a31, float a32
-            )
-        {
-            _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);
-        }
-
-        internal Matrix4x3(Matrix3x4 transpose)
-        {
-            this._transpose = transpose;
-        }
-
-
-        public unsafe Matrix3x4 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._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 static Matrix4x3 operator +(Matrix4x3 matrix1, Matrix4x3 matrix2)
-        {
-            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)
-            {
-                internalIO.deinitM128_internal(_colum0Ptr);
-                internalIO.deinitM128_internal(_colum1Ptr);
-                internalIO.deinitM128_internal(_colum2Ptr);
-            }
-            else
-            {
-
-            }
-        }
 
     }
 }

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

@@ -1,145 +1,191 @@
 using System;
+using System.Drawing;
+using System.Numerics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
+
+
 namespace StgSharp.Math
 {
-    public enum TransposeMode
-    {
-        New,
-        Copy
-    }
-
     
 
-    public unsafe class Matrix4x4:IDisposable
+    [StructLayout(LayoutKind.Explicit, Size = 2*16*sizeof(float)+sizeof(bool), Pack = 16)]
+    public struct Matrix4x4 : IEquatable<Matrix4x4>
     {
+        [FieldOffset(0)] internal Mat4 mat;
+        [FieldOffset(64*sizeof(float))] internal Mat4 transpose;
+        [FieldOffset(2*64*sizeof(float))]internal bool isTransposed;
+        
 
-
-        public static readonly Matrix4x4 Unit
-            = new Matrix4x4(
-                1,0,0,0,
-                0,1,0,0,
-                0,0,1,0,
-                0,0,0,1
-                );
-
-
-        internal M128Map M128Map;
-
-        //pointers of 4 colums are collected
-        //in the array referred by these pointer.
-        internal M128matMap _matMap;
-
-
-        //define if this matrix has correctly stored its transpose matrix
-        internal bool isTransposed = false;
-
-        //store the transpose mat of this one to avoid calculate again
-        internal M128matMap _transpose;
-
-        private bool disposedValue;
-
-        internal Matrix4x4()
-        {
-            _matMap = new M128matMap(
-                internalIO.load_internal(0, 0, 0, 0),
-                internalIO.load_internal(0, 0, 0, 0),
-                internalIO.load_internal(0, 0, 0, 0),
-                internalIO.load_internal(0, 0, 0, 0)
-                );
-
-        }
-
-        //constructor used to transform a matMap from C to a Matrix class,
-        //the original matMap will be cleaned up after transformation
-        internal Matrix4x4(
-            ref M128matMap matMap
+        public unsafe Matrix4x4(
+            float a00, float a01, float a02, float a03,
+            float a10, float a11, float a12, float a13,
+            float a20, float a21, float a22, float a23,
+            float a30, float a31, float a32, float a33
             )
         {
-            _matMap = matMap;
-            internalIO .deinitMatmap_sse_internal( ref matMap );
+            M128* c0ref = internalIO.loadptr_internal(a00, a10, a20, a30);
+            M128* c1ref = internalIO.loadptr_internal(a01, a11, a21, a31);
+            M128* c2ref = internalIO.loadptr_internal(a02, a12, a22, a32);
+            M128* c3ref = internalIO.loadptr_internal(a03, a13, a23, a33);
+
+            mat.colum0 = *c0ref;
+            mat.colum1 = *c1ref;
+            mat.colum2 = *c2ref;
+            mat.colum3 = *c3ref;
+
+            /**/
+            internalIO.deinitM128_internal(c0ref);
+            internalIO.deinitM128_internal(c1ref);
+            internalIO.deinitM128_internal(c2ref);
+            internalIO.deinitM128_internal(c3ref);
+            /**/
 
         }
 
-        internal Matrix4x4(
-            IntPtr c0Ptr,
-            IntPtr c1Ptr,
-            IntPtr c2Ptr,
-            IntPtr c3Ptr
-            )
+        public unsafe float this[int rowNum, int columNum]
         {
-            _matMap = new M128matMap(c0Ptr,c1Ptr,c2Ptr,c3Ptr);
-        }
-
-        public Matrix4x4(
-            float a00,float a01,float a02,float a03,
-            float a10,float a11,float a12,float a13,
-            float a20,float a21,float a22,float a23,
-            float a30,float a31,float a32,float a33
-            )
-        {
-            _matMap = new M128matMap(
-                internalIO.load_internal(a00, a10, a20, a30),
-                internalIO.load_internal(a01, a11, a21, a31),
-                internalIO.load_internal(a02, a12, a22, a32),
-                internalIO.load_internal(a03, a13, a23, a33)
-                );
-        }
-
-
-
-
-
-
-        public Matrix4x4 Transpose
-        {
-            get {
-                if (isTransposed)
-                {
-                    internalIO.deinitMatmap_sse_internal(ref _transpose);
-
-                }
-                return new Matrix4x4(
-                    internalIO.load_cpy_internal(_transpose.colum0Ptr),
-                    internalIO.load_cpy_internal(_transpose.colum1Ptr),
-                    internalIO.load_cpy_internal(_transpose.colum2Ptr),
-                    internalIO.load_cpy_internal(_transpose.colum3Ptr)
-                ); 
-            }
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (!disposedValue)
+            get
             {
-                if (disposing)
+                if (rowNum>3||rowNum<0)
                 {
-                    // TODO: 释放托管状态(托管对象)
+                    throw new ArgumentOutOfRangeException(nameof(columNum));
+                }
+                if (columNum>3||columNum<0)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(columNum));
+                }
+                InternalTranspose();
+                fixed (float* p = &this.transpose.a00 )
+                {
+                    ulong pbit = (ulong)p 
+                        + (ulong)sizeof(M128) * (ulong)rowNum 
+                        + (ulong)sizeof(float) * (ulong)columNum;
+                    return *(float*)pbit;
                 }
 
-                // TODO: 释放未托管的资源(未托管的对象)并重写终结器
-                // TODO: 将大型字段设置为 null
-                disposedValue = true;
             }
         }
 
-        // // TODO: 仅当“Dispose(bool disposing)”拥有用于释放未托管资源的代码时才替代终结器
-        // ~Matrix4x4()
-        // {
-        //     // 不要更改此代码。请将清理代码放入“Dispose(bool disposing)”方法中
-        //     Dispose(disposing: false);
-        // }
-
-        public void Dispose()
+        internal Matrix4x4(
+            ref M128 vec0,
+            ref M128 vec1,
+            ref M128 vec2,
+            ref M128 vec3
+            )
         {
-            // 不要更改此代码。请将清理代码放入“Dispose(bool disposing)”方法中
-            Dispose(disposing: true);
-            GC.SuppressFinalize(this);
+            mat.colum0 = vec0;
+            mat.colum1 = vec1;
+            mat.colum2 = vec2;
+            mat.colum3 = vec3;
+        }
+
+        internal Matrix4x4(Mat4 mat)
+        {
+            this.mat = mat;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Matrix4x4 operator +(Matrix4x4 mat1, Matrix4x4 Mat2)
+        {
+            Mat4* refret = internalIO.add_mat4(ref mat1.mat, ref Mat2.mat);
+            Matrix4x4 ret = new Matrix4x4(*refret);
+            internalIO.deinit_mat4(refret);
+            return ret;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Matrix4x4 operator -(Matrix4x4 mat1, Matrix4x4 Mat2)
+        {
+            Mat4* refret = internalIO.sub_mat4(ref mat1.mat, ref Mat2.mat);
+            Matrix4x4 ret = new Matrix4x4(*refret);
+            internalIO.deinit_mat4(refret);
+            return ret;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Matrix4x4 operator *(Matrix4x4 mat, float value)
+        {
+            Mat4* refret = internalIO.mul_const(ref mat.mat, value);
+            Matrix4x4 ret = new Matrix4x4(*refret);
+            internalIO.deinit_mat4(refret);
+            return ret;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Matrix4x2 operator *(Matrix4x4 left, Matrix4x2 right)
+        {
+            left.InternalTranspose();
+            Mat4 tr = left.transpose;
+            return new Matrix4x2(
+                internalIO.mulps_sum_internal(&tr.colum0, &right.mat.colum0),
+                internalIO.mulps_sum_internal(&tr.colum0, &right.mat.colum1),
+                internalIO.mulps_sum_internal(&tr.colum1, &right.mat.colum0),
+                internalIO.mulps_sum_internal(&tr.colum1, &right.mat.colum1),
+                internalIO.mulps_sum_internal(&tr.colum2, &right.mat.colum0),
+                internalIO.mulps_sum_internal(&tr.colum2, &right.mat.colum1),
+                internalIO.mulps_sum_internal(&tr.colum3, &right.mat.colum0),
+                internalIO.mulps_sum_internal(&tr.colum3, &right.mat.colum1)
+                );
+
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Matrix4x4 operator *(Matrix4x4 left, Matrix4x4 right)
+        {
+            left.InternalTranspose();
+            Mat4* p = internalIO.mul_4_4(&left.transpose, &right.mat);
+            Matrix4x4 ret = new Matrix4x4(*p);
+            internalIO.deinit_mat4(p);
+            return ret;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe float Det()
+        {
+            InternalTranspose();
+            fixed (Matrix4x4* _this = &this)
+            {
+                return internalIO.det_mat4(_this);
+            }
+        }
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void InternalTranspose()
+        {
+            if (!isTransposed)
+            {
+                fixed (Mat4* source = &this.mat, target = &this.transpose)
+                {
+                    internalIO.Transpose4to4_internal(source, target);
+                }
+
+                isTransposed = true;
+            }
+        }
+
+        public override string ToString()
+        {
+            InternalTranspose();
+            return
+                $"{transpose.colum0}\n" +
+                $"{transpose.colum1}\n" +
+                $"{transpose.colum2}\n" +
+                $"{transpose.colum3}"; 
+
+        }
+
+        public bool Equals(Matrix4x4 other)
+        {
+            throw new NotImplementedException();
         }
     }
 
 
+
 }

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

@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
@@ -8,67 +9,58 @@ namespace StgSharp.Math
     /// A two dimension vector defined by two elements.
     /// Vec2Ds in StgSharp are defaultly usaed as colum vector. 
     /// </summary>
-    public class Vec2d
+
+    [StructLayout(LayoutKind.Explicit, Size = 16,Pack = 16)]
+    public struct Vec2d
     {
 
-        internal M128Map _map;
-        internal IntPtr _m128Ptr;
+        [FieldOffset(0)]
+        public float X;
+        [FieldOffset(4)]
+        public float Y;
 
-        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; }
-        }
+        [FieldOffset(0)]
+        internal M128 vec;
 
         public Vec2d(float x, float y)
         {
-            _m128Ptr = internalIO.load_internal(x, y, 0, 0);
-        }
-
-        internal Vec2d(IntPtr value)
-        {
-            _m128Ptr = value;
+            X = x; Y = y;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vec2d operator +(Vec2d vec1, Vec2d vec2)
         {
             return new Vec2d(
-                internalIO.addps_internal(vec1._m128Ptr,vec2._m128Ptr)
+                vec1.X + vec2.X,
+                vec1.Y + vec2.Y
                 );
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vec2d operator -(Vec2d vec1, Vec2d vec2)
         {
             return new Vec2d(
-                internalIO.subps_internal(vec1._m128Ptr,vec2._m128Ptr)
+                vec1.X - vec2.X,
+                vec1.Y - vec2.Y
                 );
         }
 
         public static Vec2d operator *(Vec2d vec, float value)
         {
             return new Vec2d(
-                internalIO.mulps_const_internal(vec._m128Ptr,value)
+                vec.X * value,
+                vec.Y * value
                 );
         }
 
         public static Vec2d operator /(Vec2d vec, float value)
         {
             return new Vec2d(
-                internalIO.divps_const_internal(vec._m128Ptr, value)
+                vec.X / value,
+                vec.Y / value
                 );
         }
 
-        public static float operator *(Vec2d vec1, Vec2d vec2)
-        {
-            return internalIO.mulps_sum_internal(vec1._m128Ptr, vec2._m128Ptr);
-        }
-
 
 
     }

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

@@ -1,125 +1,75 @@
 using StgSharp.Control;
 using System;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
 
-    public class Vec3d
+    [StructLayout(LayoutKind.Explicit,Size = 16,Pack = 16)]
+    public struct Vec3d
     {
-        public static Vec3d defaultValue =
-            new Vec3d(0, 0, 0);
-         
+        [FieldOffset(0)]
+        internal M128 vec;
 
-        internal M128Map _map;
-        internal IntPtr _m128Ptr;
+        [FieldOffset(0)] public float X;
+        [FieldOffset(4)] public float Y;
+        [FieldOffset(8)] public float Z;
 
-        public unsafe float X
+        public Vec3d(
+            float x, float y, float z)
         {
-            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;
+            X = x; Y = y; Z = z;
         }
 
+        
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vec3d operator +(Vec3d vec1, Vec3d vec2)
         {
             return new Vec3d(
-                internalIO.addps_internal(vec1._m128Ptr, vec2._m128Ptr)
+                vec1.X + vec2.X,
+                vec1.Y + vec2.Y,
+                vec1.Z + vec2.Z
                 );
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vec3d operator -(Vec3d vec1, Vec3d vec2)
         {
             return new Vec3d(
-                internalIO.subps_internal(vec1._m128Ptr, vec2._m128Ptr)
+                vec1.X - vec2.X,
+                vec1.Y - vec2.Y,
+                vec1.Z - vec2.Z
                 );
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vec3d operator *(Vec3d vec, float value)
         {
             return new Vec3d(
-                internalIO.mulps_const_internal(vec._m128Ptr,value)
+                vec.X * value,
+                vec.Y * value,
+                vec.Z * value
                 );
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vec3d operator /(Vec3d vec, float value)
         {
             return new Vec3d(
-                internalIO.divps_const_internal(vec._m128Ptr,value)
+                vec.X/value,
+                vec.Y/value,
+                vec.Z/value
                 );
         }
-        /**/
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float operator *(Vec3d vec1, Vec3d vec2)
         {
-            //return VectorCalc.Multiple(vec1,vec2);
-
-            return 0;
-        }
-        /**/
-        public unsafe override string ToString()
-        {
-            return (*(M128*)_m128Ptr).ToString();
-        }
-
-        public unsafe string ToString(string sample)
-        {
-            return $"{(*(M128*)_m128Ptr).single_0.ToString(sample)}\t"+
-                $"{(*(M128*)_m128Ptr).single_1.ToString(sample)}\t"+
-                $"{(*(M128*)_m128Ptr).single_2.ToString(sample)}\t"+
-                $"{(*(M128*)_m128Ptr).single_3.ToString(sample)}\t";
-        }
-
-        ~Vec3d()
-        {
-            if (_map == null)
-            {
-                if (_m128Ptr != defaultValue._m128Ptr)
-                {
-                    internalIO.deinitM128_internal(this._m128Ptr);
-                }
-                else
-                {
-                    _m128Ptr = IntPtr.Zero;
-                }
-            }
-            else
-            {
-
-            }
+            return
+                vec1.X * vec2.X +
+                vec1.Y * vec2.Y +
+                vec1.Z * vec2.Z;
         }
 
     }

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

@@ -6,126 +6,20 @@ using System.Runtime.InteropServices;
 namespace StgSharp.Math
 {
 
-
-    public class Vec4d
+    [StructLayout(LayoutKind.Explicit, Size = 16, Pack = 16)]
+    public struct Vec4d
     {
-        internal static readonly Vec4d defaultValue
-            = new Vec4d( 0,0,0,0 );
+        [FieldOffset(0)] internal M128 vec;
 
-        internal M128Map _map;
-        internal IntPtr _m128Ptr;
+        [FieldOffset(0)]public float X;
+        [FieldOffset(4)]public float Y;
+        [FieldOffset(8)]public float Z;
+        [FieldOffset(12)]public float W;
 
-
-        public unsafe float X
+        unsafe public Vec4d(
+            float x, float y, float z, float w)
         {
-            get { return (*(M128*)_m128Ptr).single_0; }
-            set { (*(M128*)_m128Ptr).single_0 = value; }
+            X = x; Y = y; Z = z; W = w;
         }
-
-        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; }
-        }
-
-        public unsafe float W
-        {
-            get { return (*(M128*)_m128Ptr).single_3; }
-            set { (*(M128*)_m128Ptr).single_3 = value; }
-        }
-
-        public Vec4d(float x, float y, float z, float w)
-        {
-            IntPtr a = internalIO.load_internal(x,y,z,w);
-            if ((ulong)a>=0)
-            {
-                this._m128Ptr = a;
-            }
-
-        }
-
-        /// <summary>
-        /// internal constructor to recive a pointer of the M128 value
-        /// </summary>
-        /// <param name="value"></param>
-        internal Vec4d(IntPtr value)
-        {
-            if ((long)value == -1)
-            {
-                throw new Exception("Failed to init M128 pointer!");
-            }
-            else
-            {
-                _m128Ptr = value;
-            }
-        }
-
-        public Vec4d()
-        {
-            _m128Ptr = defaultValue._m128Ptr;
-        }
-
-        public static unsafe Vec4d operator +(Vec4d vec1,Vec4d vec2)
-        {
-            return new Vec4d(
-                internalIO.addps_internal(vec1._m128Ptr,vec2._m128Ptr)
-                ) ;
-        }
-
-        /**/
-        public static Vec4d operator -(Vec4d vec1, Vec4d vec2)
-        {
-            return new Vec4d(
-                internalIO.subps_internal(vec1._m128Ptr,vec2._m128Ptr)
-                );
-        }
-        /**/
-
-        public static Vec4d operator *(Vec4d vec, float value)
-        {
-            return new Vec4d(
-                internalIO.mulps_const_internal(vec._m128Ptr,value)
-                );
-        }
-
-        public static Vec4d operator /(Vec4d vec, float value)
-        {
-            return new Vec4d(
-                internalIO.divps_const_internal(vec._m128Ptr, value)
-                );
-        }
-
-        public unsafe override string ToString()
-        {
-            return $"{*(M128*)_m128Ptr}";
-        }
-
-        ~Vec4d()
-        {
-            if (_map == null)
-            {
-                if (_m128Ptr != defaultValue._m128Ptr)
-                {
-                    internalIO.deinitM128_internal(this._m128Ptr);
-                }
-                else
-                {
-                    _m128Ptr = IntPtr.Zero;
-                }
-            }
-            else
-            {
-
-            }
-        }
-
-
-
     }
 }

源代码/StgSharp/StgSharp.csproj

@@ -43,8 +43,11 @@
     <NoWarn>1701;1702;0649;1591;0169</NoWarn>
   </PropertyGroup>
 
-
-  <ItemGroup>
+   <PropertyGroup Condition=" '$(OS)' == 'Windows_NT' ">
+      <DefineConstants>_WINDOWS</DefineConstants>
+   </PropertyGroup>
+   
+   <ItemGroup>
     <PackageReference Include="Microsoft.Bcl.HashCode" Version="1.1.1" />
     <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
   </ItemGroup>

源代码/StgSharp/bin/x64/Debug/netstandard2.1/StgSharp.xml

@@ -162,12 +162,6 @@
             Vec2Ds in StgSharp are defaultly usaed as colum vector. 
             </summary>
         </member>
-        <member name="M:StgSharp.Math.Vec4d.#ctor(System.IntPtr)">
-            <summary>
-            internal constructor to recive a pointer of the M128 value
-            </summary>
-            <param name="value"></param>
-        </member>
         <member name="M:StgSharp.Math.Calc.ASin(System.Single)">
             <summary>
             Reurns the value of ArcSin(x)

源代码/StgSharp/obj/x64/Debug/netstandard2.1/StgSharp.csproj.CoreCompileInputs.cache

@@ -1 +1 @@
-df9c40a56cc9cdbf0d2d8e2746396f8c7fbcaaf3
+affa619bf07b05c035efee881282f4490e2b3fd5

源代码/StgSharp/obj/x64/Debug/netstandard2.1/StgSharp.xml

@@ -162,12 +162,6 @@
             Vec2Ds in StgSharp are defaultly usaed as colum vector. 
             </summary>
         </member>
-        <member name="M:StgSharp.Math.Vec4d.#ctor(System.IntPtr)">
-            <summary>
-            internal constructor to recive a pointer of the M128 value
-            </summary>
-            <param name="value"></param>
-        </member>
         <member name="M:StgSharp.Math.Calc.ASin(System.Single)">
             <summary>
             Reurns the value of ArcSin(x)

源代码/StgSharpDebug/Debug.cs

@@ -1,25 +1,70 @@
 using StgSharp.Math;
 using System;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
 
 namespace StgSharp
 {
 
     internal static class Program
     {
+
         internal unsafe static void Main(string[] args)
         {
-            Matrix4x4 m = new Matrix4x4(
-                0,1,2,3,
-                4,5,6,7,
-                0,1,2,3,
-                4,5,6,7
+
+            /**/
+            Matrix4x4 matrix = new Matrix4x4(
+                1,1,-1,2,
+                -1,-1,-4,1,
+                2,4,-6,1,
+                1,2,4,2
                 );
-            for (int i = 0; i < 1000; i++)
+
+            Console.WriteLine(matrix.Det());
+
+            /*
+            System.Numerics.Matrix4x4 m = new System.Numerics.Matrix4x4(
+                0,1,2,3,
+                0,0,1,2,
+                0,0,0,0,
+                1,2,5,6
+                );
+
+            int cycle = 1000;
+            int time = 10000;
+
+            
+
+            for (int t = 0; t < cycle; t++)
             {
-                Matrix4x4 ret = m;
+                Stopwatch sw = Stopwatch.StartNew();
+                sw.Start();
+                for (int i = 0; i < time; i++)
+                {
+                    Matrix4x4 mat = matrix * matrix;
+                }
+                sw.Stop();
+
+                TimeSpan timeSpan = sw.Elapsed;
+                Console.WriteLine(timeSpan.TotalMilliseconds);
+
+                Stopwatch sw2 = new Stopwatch();
+                sw2.Start();
+                for (int i = 0; i < time; i++)
+                {
+                    System.Numerics.Matrix4x4 mat = m * m;
+                }
+                sw2.Stop();
+
+                TimeSpan timeSpan1 = sw2.Elapsed;
+                Console.WriteLine(timeSpan1.TotalMilliseconds);
+                Console.WriteLine();
             }
-            //Console.WriteLine(m + m);
+            
+
+
+            /**/
 
             /*
             System.Numerics.Matrix4x4 smt1 = new System.Numerics.Matrix4x4(
@@ -42,11 +87,13 @@ namespace StgSharp
 
             for (int t = 0; t < 1000; t++)
             {
+
                 s.Reset();
                 s.Start();
+
                 for (int i = 0; i < cycle; i++)
                 {
-                    System.Numerics.Matrix4x4 ret = smt1* smt1;
+                    System.Numerics.Matrix4x4 ret = smt1 * smt1;
                 }
                 s.Stop();
 
@@ -58,13 +105,14 @@ namespace StgSharp
 
                 for (int i = 0; i < cycle; i++)
                 {
-                    Matrix4x4 ret = VectorCalc.Multiple(gmt1,gmt1);
+                    Matrix4x4 ret = VectorCalc.Multiple(gmt1, gmt1);
                 }
                 s.Stop();
 
                 TimeSpan span1 = s.Elapsed;
                 Console.WriteLine(span1.TotalMilliseconds);
 
+                Console.WriteLine(t);
                 Console.WriteLine();
 
 

源代码/StgSharpDebug/obj/x64/Debug/net6.0/StgSharpDebug.csproj.CoreCompileInputs.cache

@@ -1 +1 @@
-075d88573ab31945065a5d479a17cfb28f3bce57
+1be9af1044b775e9c8191a9195ea3b3e03344c42

源代码/StgSharpDebug/obj/x64/Release/net6.0/.NETCoreApp,Version=v6.0.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]

源代码/StgSharpDebug/obj/x64/Release/net6.0/StgSharpDebug.AssemblyInfo.cs

@@ -0,0 +1,23 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     此代码由工具生成。
+//     运行时版本:4.0.30319.42000
+//
+//     对此文件的更改可能会导致不正确的行为，并且如果
+//     重新生成代码，这些更改将会丢失。
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("StgSharpDebug")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Release")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0")]
+[assembly: System.Reflection.AssemblyProductAttribute("StgSharpDebug")]
+[assembly: System.Reflection.AssemblyTitleAttribute("StgSharpDebug")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+
+// 由 MSBuild WriteCodeFragment 类生成。
+

源代码/StgSharpDebug/obj/x64/Release/net6.0/StgSharpDebug.AssemblyInfoInputs.cache

@@ -0,0 +1 @@
+c240d4b9dd7134ccd2554a8eb3a5407fd9a8d4f8

源代码/StgSharpDebug/obj/x64/Release/net6.0/StgSharpDebug.GeneratedMSBuildEditorConfig.editorconfig

@@ -0,0 +1,11 @@
+is_global = true
+build_property.TargetFramework = net6.0
+build_property.TargetPlatformMinVersion = 
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.ProjectTypeGuids = 
+build_property.InvariantGlobalization = 
+build_property.PlatformNeutralAssembly = 
+build_property.EnforceExtendedAnalyzerRules = 
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property.RootNamespace = StgSharp
+build_property.ProjectDir = D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgSharpDebug\

源代码/StgShqrpGraphic/SSGinternal.h

@@ -5,42 +5,3 @@
 #include "StgSharpGraphic.h"
 #include <xmmintrin.h>
 
-extern __m128* defaultVecPtr;
-
-
-
-typedef struct sse_matmap
-{
-    __m128* c0ptr;
-    __m128* c1ptr;
-    __m128* c2ptr;
-    __m128* c3ptr;
-}sse_matmap;
-
-
-
-typedef struct glIOPack
-{
-    //these are gl functions used to create a new window
-    GLFWwindow* (*createWindow)(
-        int width,
-        int height,
-        const char* title,
-        GLFWmonitor* monitor,
-        GLFWwindow* share);
-    void(*makeContextCurrent)(GLFWwindow* window);
-    void(*swapInterval)(int interval);
-    void(*clearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    int(*windowShouldClose)(GLFWwindow* window);
-    void(*swapBuffer)(GLFWwindow* window);
-
-
-    //these are gl functions used to set a callback
-
-    GLFWframebuffersizefun(*SetFramebufferSizeCallback)
-        (GLFWwindow* window, GLFWframebuffersizefun callback);
-
-}glIOpackage;
-
-
-glIOpackage pack;

源代码/StgShqrpGraphic/StgSharpGraphic.c

@@ -6,7 +6,7 @@
 #include "GLenv/include/GLFW/glfw3.h"
 #include "framework.h"
 #include "StgSharpGraphic.h"
-#include "SSGinternal.h"
+
 
 
 extern glIOpackage pack;

源代码/StgShqrpGraphic/StgSharpGraphic.h

@@ -12,15 +12,60 @@
 
 #include "GLenv/include/glad/glad.h"
 #include "GLenv/include/GLFW/glfw3.h"
-#include "SSGinternal.h"
 #include <immintrin.h>
 
+#pragma region Internal
+
+extern __m128* defaultVecPtr;
+#define ALIGN(simdVec) _mm_loadu_ps((float*)&simdVec)
+
+typedef struct glIOPack
+{
+    //these are gl functions used to create a new window
+    GLFWwindow* (*createWindow)(
+        int width,
+        int height,
+        const char* title,
+        GLFWmonitor* monitor,
+        GLFWwindow* share);
+    void(*makeContextCurrent)(GLFWwindow* window);
+    void(*swapInterval)(int interval);
+    void(*clearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+    int(*windowShouldClose)(GLFWwindow* window);
+    void(*swapBuffer)(GLFWwindow* window);
+
+
+    //these are gl functions used to set a callback
+
+    GLFWframebuffersizefun(*SetFramebufferSizeCallback)
+        (GLFWwindow* window, GLFWframebuffersizefun callback);
+
+}glIOpackage;
+typedef struct sse_matmap
+{
+    __m128* c0ptr;
+    __m128* c1ptr;
+    __m128* c2ptr;
+    __m128* c3ptr;
+}sse_matmap;
+
+glIOpackage pack;
+ 
+SSGC_API _inline float __cdecl mulps_sum_internal(__m128 left, __m128 right);
+SSGC_API _inline float __cdecl mulps_total_internal(__m128 vec);
+
+#pragma endregion
+
+
+
+
+
+
 SSGC_API glIOpackage loadGLApi(void);
 SSGC_API void initGL(void);
 SSGC_API int initGLAD(void);
 
-
-
+//linear related function
 
 SSGC_API __m128* __cdecl load(float x, float y, float z, float w);
 SSGC_API __m128* __cdecl load_cpy(__m128* ptr);
@@ -28,19 +73,96 @@ 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);
 SSGC_API __m128* __cdecl mulps(__m128* ptr1, __m128* ptr2);
-SSGC_API float   __cdecl mulps_sum(__m128* ptr1, __m128* ptr2);
+SSGC_API _inline float   __cdecl mulps_sum(__m128* ptr1, __m128* ptr2);
 SSGC_API __m128* __cdecl divps_const(__m128* ptr, float value);
 SSGC_API __m128* __cdecl divps(__m128* ptr1, __m128* ptr2);
 SSGC_API float   __cdecl sqrtss_const(float a);
 
 
 SSGC_API __m128* __cdecl set_m128ptr_default();
-SSGC_API sse_matmap* __cdecl transpose_ssemat_2(sse_matmap* matPtr);
-SSGC_API sse_matmap* __cdecl transpose_ssemat_3(sse_matmap* matPtr);
+
 
 
 
 SSGC_API void __cdecl deinitM128(__m128* ptr);
-SSGC_API void __cdecl deinit_matmap_sse(sse_matmap* mapptr);
+
+
+#pragma region mat define
+
+typedef union matrix2map
+{
+    __m128 colum[2];
+    float m[4][2];
+}matrix2map;
+
+typedef struct matrix3map
+{
+    __m128 colum[3];
+    float m[4][3];
+};
+
+typedef union matrix4map {
+    __m128 colum[4];
+    float m[4][4];
+}matrix4map;
+
+typedef struct matrix4 {
+    matrix4map matrix;
+    matrix4map transpose;
+}matrix4;
+
+#pragma endregion
+
+
+
+
+#pragma region mat2
+
+SSGC_API __inline matrix2map* __cdecl add_mat2(matrix2map* mat1, matrix2map* mat2);
+SSGC_API __inline matrix2map* __cdecl sub_mat2(matrix2map* mat1, matrix2map* mat2);
+
+SSGC_API __inline void __cdecl transmpose2to4(matrix2map* source, matrix4map* target);
+
+SSGC_API _inline void __cdecl deinit_mat2(matrix2map* mat);
+
+#pragma endregion
+
+
+#pragma region mat3
+
+SSGC_API __inline float det_mat3_internal(__m128 const c1, __m128 const c2, __m128 const c3);
+
+#pragma endregion
+
+
+
+
+#pragma region mat4
+//type and function for 4 colum matrix
+
+SSGC_API __inline matrix4map* __cdecl add_mat4(matrix4map* mat1, matrix4map* mat2);
+SSGC_API __inline matrix4map* __cdecl sub_mat4(matrix4map* mat1, matrix4map* mat2);
+SSGC_API __inline matrix4map* __cdecl mul_const(matrix4map* mat, float value);
+SSGC_API __inline matrix4* __cdecl mul_4_4(matrix4map* left, matrix4map* right);
+
+SSGC_API __inline void __cdecl transpose4to2(matrix4map* source, matrix4map* target);
+SSGC_API __inline void __cdecl transpose4to4(matrix4map* matrix, matrix4map* target);
+
+SSGC_API __inline float __cdecl det_mat4(matrix4* matPtr);
+
+SSGC_API __inline void __cdecl deinit_mat4(matrix4map* matPtr);
+
+#pragma endregion
+
+
+
+
+
+
+
+
+
+
+
 #endif // !SSG
 

源代码/StgShqrpGraphic/StgShqrpGraphic.vcxproj

@@ -160,6 +160,12 @@
       <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>
       <CompileAs>CompileAsC</CompileAs>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
+      <ModuleOutputFile>$(IntDir)</ModuleOutputFile>
+      <ModuleDependenciesFile>$(IntDir)</ModuleDependenciesFile>
+      <ObjectFileName>$(IntDir)</ObjectFileName>
+      <ProgramDataBaseFileName>$(IntDir)vc$(PlatformToolsetVersion).pdb</ProgramDataBaseFileName>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -175,13 +181,15 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="framework.h" />
-    <ClInclude Include="SSGinternal.h" />
     <ClInclude Include="StgSharpGraphic.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\..\..\..\..\..\Programmer\GLenv\glad.c" />
     <ClCompile Include="dllmain.c" />
     <ClCompile Include="linear.c" />
+    <ClCompile Include="mat2.c" />
+    <ClCompile Include="mat3.c" />
+    <ClCompile Include="mat4.c" />
     <ClCompile Include="StgSharpGraphic.c" />
   </ItemGroup>
   <ItemGroup>

源代码/StgShqrpGraphic/StgShqrpGraphic.vcxproj.filters

@@ -21,9 +21,6 @@
     <ClInclude Include="StgSharpGraphic.h">
       <Filter>头文件</Filter>
     </ClInclude>
-    <ClInclude Include="SSGinternal.h">
-      <Filter>头文件</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="StgSharpGraphic.c">
@@ -38,6 +35,15 @@
     <ClCompile Include="linear.c">
       <Filter>源文件</Filter>
     </ClCompile>
+    <ClCompile Include="mat4.c">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="mat2.c">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="mat3.c">
+      <Filter>源文件</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <Library Include="GLenv\glfw3.lib">

源代码/StgShqrpGraphic/dllmain.c

@@ -7,7 +7,7 @@
 
 
 #include "StgSharpGraphic.h"
-#include "SSGinternal.h"
+
 
 #ifdef _WIN32
 BOOL APIENTRY DllMain(HMODULE hModule,

源代码/StgShqrpGraphic/linear.c

@@ -1,7 +1,8 @@
 #pragma once
 
+#include "GLenv/include/glad/glad.h"
 #include "StgSharpGraphic.h"
-#include "SSGinternal.h"
+
 #include <stdio.h>
 #include <stdalign.h>
 
@@ -56,7 +57,7 @@ SSGC_API __m128* __cdecl addps(__m128* ptr1, __m128* ptr2)
     }
     else
     {
-        return -1;
+        return (__m128*) - 1;
     }
 
 }
@@ -109,7 +110,7 @@ SSGC_API __m128* __cdecl mulps(__m128* ptr1, __m128* ptr2)
     }
 }
 
-SSGC_API float __cdecl mulps_sum(__m128* ptr1, __m128* ptr2)
+SSGC_API _inline float __cdecl mulps_sum(__m128* ptr1, __m128* ptr2)
 {
     __m128 ret = _mm_mul_ps(*ptr1,*ptr2);
     ret = _mm_hadd_ps(ret,ret);
@@ -117,6 +118,19 @@ SSGC_API float __cdecl mulps_sum(__m128* ptr1, __m128* ptr2)
     return *(float*)&ret;
 }
 
+_inline float __cdecl mulps_sum_internal(__m128 left, __m128 right)
+{
+    __m128 ret = _mm_mul_ps(left, right);
+    ret = _mm_hadd_ps(ret, ret);
+    ret = _mm_hadd_ps(ret, ret);
+    return *(float*)&ret;
+}
+
+_inline float __cdecl mulps_total_internal(__m128 vec)
+{
+    
+}
+
 SSGC_API __m128* __cdecl divps_const(__m128* ptr, float value)
 {
 
@@ -156,17 +170,12 @@ SSGC_API float __cdecl sqrtss_const(float a)
     __m128 ret = _mm_sqrt_ss(*(__m128*) & a);
 
     return ret.m128_f32[0];
-
-    
-
 }
 
 
 
 /*
-
 Some complex functions for matrix calculations.
-
 */
 
 SSGC_API __m256i* __cdecl load_matmap(uint64_t c0, uint64_t c1, uint64_t c2, uint64_t c3)
@@ -184,134 +193,29 @@ SSGC_API __m256i* __cdecl load_matmap(uint64_t c0, uint64_t c1, uint64_t c2, uin
 
 }
 
-SSGC_API __m256i* __cdecl tranpose_4x4matmap(__m256i* matPtr)
-{
 
-    __m256i* ret = _aligned_malloc(sizeof(__m256i),sizeof(__m256i));
-
-    printf("%llu\n",(uint64_t)ret);
-
-    __m128* columPtr[4];
-    columPtr[0] = _aligned_malloc(sizeof(__m128),16);
-    columPtr[1] = _aligned_malloc(sizeof(__m128),16);
-    columPtr[2] = _aligned_malloc(sizeof(__m128),16);
-    columPtr[3] = _aligned_malloc(sizeof(__m128),16);
-
-    if (NULL != ret)
-    {
-        *ret = _mm256_loadu_epi64(*(uint64_t*)&columPtr);
-    }
-
-    __m128* c0Ptr = (__m128*) (matPtr->m256i_i64[0]);
-    __m128* c1Ptr = (__m128*) (matPtr->m256i_i64[1]);
-    __m128* c2Ptr = (__m128*)(matPtr->m256i_i64[2]);
-    __m128* c3Ptr = (__m128*)(matPtr->m256i_i64[3]);
-
-    __m128 cache0Ptr = _mm_shuffle_ps(*c0Ptr,*c1Ptr,0b00010001);
-    __m128 cache1Ptr = _mm_shuffle_ps(*c0Ptr,*c1Ptr,0b01110111);
-    __m128 cache2Ptr = _mm_shuffle_ps(*c2Ptr, *c3Ptr, 0b00010001);
-    __m128 cache3Ptr = _mm_shuffle_ps(*c2Ptr, *c3Ptr, 0b01110111);
-
-    *(columPtr[0]) = _mm_shuffle_ps(cache0Ptr, cache2Ptr, 0b00100010);
-    *(columPtr[1]) = _mm_shuffle_ps(cache0Ptr, cache2Ptr, 0b01110111);
-    *(columPtr[2]) = _mm_shuffle_ps(cache1Ptr, cache3Ptr, 0b00100010);
-    *(columPtr[3]) = _mm_shuffle_ps(cache1Ptr, cache3Ptr, 0b01110111);
-
-    return ret;
-}
 
 SSGC_API __m128* __cdecl set_m128ptr_default()
 {
     return defaultVecPtr;
 }
 
-sse_matmap* __cdecl transpose_ssemat_2(sse_matmap* matPtr)
-{
-    sse_matmap* ret = malloc(sizeof(sse_matmap));
-    if (NULL != ret)
-        {
-            ret->c0ptr = _aligned_malloc(sizeof(__m128), 16);
-            ret->c1ptr = _aligned_malloc(sizeof(__m128), 16);
-            ret->c2ptr = defaultVecPtr;
-            ret->c3ptr = defaultVecPtr;
-        }
-
-
-    __m128 t0 = _mm_shuffle_ps(*(matPtr->c0ptr), *(matPtr->c1ptr), _MM_SHUFFLE(0,1,0,1));
-    __m128 t1 = _mm_shuffle_ps(*(matPtr->c2ptr), *(matPtr->c3ptr), _MM_SHUFFLE(0, 1, 0, 1));
-
-    if (NULL != ret->c0ptr)
-    {
-        *(ret->c0ptr) = _mm_shuffle_ps(t0, t1, _MM_SHUFFLE(0, 2, 0, 2));
-    }
-    if (NULL != ret->c1ptr)
-    {
-        *(ret->c1ptr) = _mm_shuffle_ps(t0, t1, _MM_SHUFFLE(1, 3, 1, 3));
-    }
-
-    return ret;
-
-
-}
-
-sse_matmap* __cdecl transpose_ssemat_3(sse_matmap* matPtr)
-{
-    sse_matmap* ret = malloc(sizeof(sse_matmap));
-
-    if (NULL != ret )
-    {
-        ret->c0ptr = _aligned_malloc(sizeof(__m128),16);
-        ret->c1ptr = _aligned_malloc(sizeof(__m128),16);
-        ret->c2ptr = _aligned_malloc(sizeof(__m128),16);
-        ret->c3ptr = defaultVecPtr;
-
-        __m128 t0 = _mm_shuffle_ps( *(matPtr->c0ptr), *(matPtr->c1ptr), _MM_SHUFFLE(0, 1, 0, 1));
-        __m128 t1 = _mm_shuffle_ps( *(matPtr->c0ptr), *(matPtr->c1ptr), _MM_shuffle(2, 3, 2, 3));
-
-        if (defaultVecPtr == matPtr->c2ptr)
-        {
-            __m128 t2 = _mm_shuffle_ps( *(matPtr->c2ptr), *(matPtr->c3ptr), _MM_SHUFFLE(0, 1, 0, 1));
-            __m128 t3 = _mm_shuffle_ps( *(matPtr->c2ptr), *(matPtr->c3ptr), _MM_SHUFFLE(2, 3, 2, 3));
-
-            *(ret->c0ptr) = _mm_shuffle_ps(t0, t2, _MM_SHUFFLE(0, 2, 0, 2));
-            *(ret->c1ptr) = _mm_shuffle_ps(t0, t2, _MM_SHUFFLE(1, 3, 1, 3));
-            *(ret->c3ptr) = _mm_shuffle_ps(t1, t3, _MM_SHUFFLE(0, 2, 0, 2));
-
-        }
-        else
-        {
-            *(ret->c0ptr) = _mm_shuffle_ps(t0, *defaultVecPtr, _MM_SHUFFLE(0, 2, 0, 2));
-            *(ret->c1ptr) = _mm_shuffle_ps(t0, *defaultVecPtr, _MM_SHUFFLE(1, 3, 1, 3));
-            *(ret->c2ptr) = _mm_shuffle_ps(t1, *defaultVecPtr, _MM_SHUFFLE(0, 2, 0, 2));
-        }
-
-    }
-    return ret;
-}
-
-
-
-
 
 
 
 
 /*
-
 Functions to clean up colum and matrix resources
-
 */
 
 SSGC_API void __cdecl deinitM128(__m128* ptr)
 {
-    free(ptr);
-}
-
-void __cdecl deinit_matmap_sse(sse_matmap* mapptr)
-{
-    free(mapptr);
+    _aligned_free(ptr);
 }
 
 
 
 
+
+
+

源代码/StgShqrpGraphic/mat2.c

@@ -0,0 +1,45 @@
+#include "StgSharpGraphic.h"
+
+
+SSGC_API _inline matrix2map* __cdecl add_mat2(matrix2map* mat1, matrix2map* mat2)
+{
+	matrix2map* ret = _aligned_malloc(sizeof(matrix2map), 16);
+
+	if (ret != 0)
+	{
+		ret->colum[0] = _mm_add_ps(mat1->colum[0], mat2->colum[0]);
+		ret->colum[1] = _mm_add_ps(mat1->colum[1], mat2->colum[1]);
+	}
+
+	return ret;
+}
+
+SSGC_API _inline matrix2map* __cdecl sub_mat2(matrix2map* mat1, matrix2map* mat2)
+{
+	matrix2map* ret = _aligned_malloc(sizeof(matrix2map), 16);
+
+	if (ret != 0)
+	{
+		ret->colum[0] = _mm_sub_ps(mat1->colum[0], mat2->colum[0]);
+		ret->colum[1] = _mm_sub_ps(mat1->colum[1], mat2->colum[1]);
+	}
+
+	return ret;
+}
+
+
+SSGC_API _inline void __cdecl transmpose2to4(matrix2map* source, matrix4map* target)
+{
+    __m128 t0 = _mm_shuffle_ps(ALIGN(source->colum[0]), ALIGN(source->colum[1]), _MM_SHUFFLE(1, 0, 1, 0));
+    __m128 t1 = _mm_shuffle_ps(ALIGN(source->colum[0]), ALIGN(source->colum[1]), _MM_SHUFFLE(3, 2, 3, 2));
+
+    target->colum[0] = _mm_shuffle_ps(t0, *defaultVecPtr, _MM_SHUFFLE(2, 0, 2, 0));
+    target->colum[1] = _mm_shuffle_ps(t0, *defaultVecPtr, _MM_SHUFFLE(3, 1, 3, 1));
+    target->colum[2] = _mm_shuffle_ps(t1, *defaultVecPtr, _MM_SHUFFLE(2, 0, 2, 0));
+    target->colum[3] = _mm_shuffle_ps(t1, *defaultVecPtr, _MM_SHUFFLE(3, 1, 3, 1));
+}
+
+SSGC_API _inline void __cdecl deinit_mat2(matrix2map* mat)
+{
+	_aligned_free(mat);
+}

源代码/StgShqrpGraphic/mat3.c

@@ -0,0 +1,38 @@
+#include "StgSharpGraphic.h"
+#include <stdio.h>
+
+float det_mat3_internal(__m128 const c0, __m128 const c1, __m128 const c2)
+{
+    //let adding row aligned
+    __m128 addc1 = _mm_shuffle_ps(c1, c1, _MM_SHUFFLE(3, 0, 2, 1));
+    __m128 addc2 = _mm_shuffle_ps(c2, c1, _MM_SHUFFLE(3, 1, 0, 2));
+
+    printf("%f\t%f\t%f\n", addc1.m128_f32[0], addc1.m128_f32[1], addc1.m128_f32[2]);
+    printf("%f\t%f\t%f\n\n", addc2.m128_f32[0], addc2.m128_f32[1], addc2.m128_f32[2]);
+
+    //let sub row aligned
+    __m128 subc1 = _mm_shuffle_ps(c1, c1, _MM_SHUFFLE(3, 1, 0, 2));
+    __m128 subc2 = _mm_shuffle_ps(c2, c2, _MM_SHUFFLE(3, 0, 2, 1));
+
+    //multple all add row
+    __m128 cache = _mm_mul_ps(c0,addc1);
+    cache = _mm_mul_ps(cache,addc2);
+
+    printf("%f\t%f\t%f\n\n", cache.m128_f32[0], cache.m128_f32[1], cache.m128_f32[2]);
+
+    //multiple all sub row
+    __m128 sub = _mm_mul_ps(c0, subc1);
+    sub = _mm_mul_ps(sub, subc1);
+    
+    printf("%f\t%f\t%f\n\n", sub.m128_f32[0], sub.m128_f32[1], sub.m128_f32[2]);
+
+    //main-corner sub sub-corner
+    cache = _mm_sub_ps(cache,sub);
+
+    __m128 ret = _mm_hadd_ps(cache,cache);    //element 1 add element 2
+    ret = _mm_add_ps(ret, cache);    //(e1 add e2) add element 3
+
+    int a = *(int*)0;    //for debug, all an excepotion
+
+    return ret.m128_f32[3] + a;
+}

源代码/StgShqrpGraphic/mat4.c

@@ -0,0 +1,118 @@
+#include "StgSharpGraphic.h"
+#include <stdio.h>
+#include <pmmintrin.h>
+
+
+SSGC_API matrix4map* add_mat4(matrix4map* mat1, matrix4map* mat2)
+{
+    matrix4map* ret = _aligned_malloc(sizeof(matrix4), 16);
+
+	if (ret != 0)
+	{
+		ret->colum[0] = _mm_add_ps(mat1->colum[0], mat2->colum[0]);
+		ret->colum[1] = _mm_add_ps(mat1->colum[1], mat2->colum[1]);
+		ret->colum[2] = _mm_add_ps(mat1->colum[2], mat2->colum[2]);
+		ret->colum[3] = _mm_add_ps(mat1->colum[3], mat2->colum[3]);
+	}
+
+	return ret;
+}
+
+SSGC_API matrix4map* sub_mat4(matrix4map* mat1, matrix4map* mat2)
+{
+	matrix4map* ret = _aligned_malloc(sizeof(matrix4), 16);
+
+	if (ret != 0)
+	{
+		ret->colum[0] = _mm_sub_ps(mat1->colum[0], mat2->colum[0]);
+		ret->colum[1] = _mm_sub_ps(mat1->colum[1], mat2->colum[1]);
+		ret->colum[2] = _mm_sub_ps(mat1->colum[2], mat2->colum[2]);
+		ret->colum[3] = _mm_sub_ps(mat1->colum[3], mat2->colum[3]);
+	}
+
+	return ret;
+}
+
+SSGC_API __inline matrix4map* __cdecl mul_const(matrix4map* mat, float value)
+{
+	matrix4map* ret = _aligned_malloc(sizeof(matrix4),16);
+
+	if (NULL != ret)
+	{
+		float cstarray[4] = { value, value, value, value };
+
+		__m128 cst128 = _mm_loadu_ps(&cstarray);
+
+		ret->colum[0] = _mm_mul_ps(mat->colum[0], cst128);
+		ret->colum[1] = _mm_mul_ps(mat->colum[1], cst128);
+		ret->colum[2] = _mm_mul_ps(mat->colum[2], cst128);
+		ret->colum[3] = _mm_mul_ps(mat->colum[3], cst128);
+	}
+
+	return ret;
+
+}
+
+//left is the transposed matrix of real left
+SSGC_API __inline matrix4* __cdecl mul_4_4(matrix4map* left, matrix4map* right)
+{
+	matrix4map* retPtr = _aligned_malloc(sizeof(matrix4map), 16);
+	if (NULL != retPtr)
+	{
+		for (size_t i = 0; i < 4; i++)
+		{
+			for (size_t t = 0; t < 4; t++)
+			{
+				retPtr->m[i][t] = mulps_sum_internal(
+					ALIGN( left->colum[i]),ALIGN(right->colum[t]));
+			}
+		}
+	}
+	return retPtr;
+}
+
+SSGC_API __inline void __cdecl transpose4to2(matrix4map* source, matrix4map* target)
+{
+	__m128 t0 = _mm_shuffle_ps(ALIGN(source->colum[0]), ALIGN(source->colum[1]), _MM_SHUFFLE(1, 0, 1, 0));
+	__m128 t2 = _mm_shuffle_ps(ALIGN(source->colum[2]), ALIGN(source->colum[3]), _MM_SHUFFLE(1, 0, 1, 0));
+
+	target->colum[0] = _mm_shuffle_ps(t0, t2, _MM_SHUFFLE(2, 0, 2, 0));
+	target->colum[1] = _mm_shuffle_ps(t0, t2, _MM_SHUFFLE(3, 1, 3, 1));
+}
+
+SSGC_API __inline void __cdecl transpose4to4(matrix4map* source, matrix4map* target)
+{
+	__m128 t0 = _mm_shuffle_ps(ALIGN(source->colum[0]), ALIGN(source->colum[1]), _MM_SHUFFLE(1, 0, 1, 0));
+	__m128 t1 = _mm_shuffle_ps(ALIGN(source->colum[0]), ALIGN(source->colum[1]), _MM_SHUFFLE(3, 2, 3, 2));
+	__m128 t2 = _mm_shuffle_ps(ALIGN(source->colum[2]), ALIGN(source->colum[3]), _MM_SHUFFLE(1, 0, 1, 0));
+	__m128 t3 = _mm_shuffle_ps(ALIGN(source->colum[2]), ALIGN(source->colum[3]), _MM_SHUFFLE(3, 2, 3, 2));
+
+	target->colum[0] = _mm_shuffle_ps(t0, t2, _MM_SHUFFLE(2, 0, 2, 0));
+	target->colum[1] = _mm_shuffle_ps(t0, t2, _MM_SHUFFLE(3, 1, 3, 1));
+	target->colum[2] = _mm_shuffle_ps(t1, t3, _MM_SHUFFLE(2, 0, 2, 0));
+	target->colum[3] = _mm_shuffle_ps(t1, t3, _MM_SHUFFLE(3, 1, 3, 1));
+
+}
+
+SSGC_API __inline float __cdecl det_mat4(matrix4* matPtr)
+{
+	__m128 cogeneration = _mm_set_ps(
+		det_mat3_internal(matPtr->matrix.colum[1], matPtr->matrix.colum[2], matPtr->matrix.colum[3]),
+		det_mat3_internal(matPtr->matrix.colum[0], matPtr->matrix.colum[2], matPtr->matrix.colum[3]),
+		det_mat3_internal(matPtr->matrix.colum[0], matPtr->matrix.colum[1], matPtr->matrix.colum[3]),
+		det_mat3_internal(matPtr->matrix.colum[0], matPtr->matrix.colum[1], matPtr->matrix.colum[2])
+		);
+
+	printf("%f\n\n", det_mat3_internal(matPtr->matrix.colum[1], matPtr->matrix.colum[2], matPtr->matrix.colum[3]));
+
+	__m128 retvec = _mm_mul_ps((matPtr->transpose).colum[3],cogeneration);
+	retvec = _mm_hsub_ps(retvec,retvec);
+	retvec = _mm_hadd_ps(retvec,retvec);
+	return -retvec.m128_f32[0];
+
+}
+
+SSGC_API __inline void __cdecl deinit_mat4(matrix4map* matPtr)
+{
+	_aligned_free(matPtr);
+}

源代码/StgShqrpGraphic/x64/Release/StgSharpGraphic.Build.CppClean.log

@@ -1,22 +1,27 @@
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\vc143.pdb
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.obj
+d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\mat4.obj
+d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\mat2.obj
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\linear.obj
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\dllmain.obj
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\glad.obj
+d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgsharpgraphic.lib
+d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgsharpgraphic.exp
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgsharpgraphic.dll
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\glad.cod
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\dllmain.cod
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\linear.cod
+d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\mat2.cod
+d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\mat4.cod
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.cod
-d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.ipdb
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgsharpgraphic.pdb
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.iobj
-d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgsharpgraphic.lib
-d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgsharpgraphic.exp
+d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.ipdb
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.tlog\cl.command.1.tlog
+d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.tlog\cl.items.tlog
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.tlog\cl.read.1.tlog
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.tlog\cl.write.1.tlog
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.tlog\link.command.1.tlog
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.tlog\link.read.1.tlog
 d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.tlog\link.write.1.tlog
-d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.tlog\stgsharpgraphic.write.1u.tlog
+d:\nitloadindustry\研究项目\1-flagship\th2020\projectfile\源代码\stgshqrpgraphic\x64\release\stgsharpgraphic.tlog\link.write.2u.tlog

源代码/StgShqrpGraphic/x64/Release/StgSharpGraphic.cod

@@ -18,142 +18,11 @@ PUBLIC	initGL
 PUBLIC	loadGLApi
 ;	COMDAT pdata
 pdata	SEGMENT
-$pdata$initGL DD imagerel $LN4
-	DD	imagerel $LN4+58
+$pdata$initGL DD imagerel $LN4@initGL
+	DD	imagerel $LN4@initGL+58
 	DD	imagerel $unwind$initGL
 pdata	ENDS
 ;	COMDAT xdata
 xdata	SEGMENT
-$unwind$initGL DD 010401H
-	DD	04204H
-; Function compile flags: /Ogtpy
-; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgShqrpGraphic\StgSharpGraphic.c
-;	COMDAT loadGLApi
-_TEXT	SEGMENT
-__$ReturnAddress$ = 8
-loadGLApi PROC						; COMDAT
-
-; 16   : 
-; 17   :     pack.createWindow = glfwCreateWindow;
-
-  00000	48 8d 05 00 00
-	00 00		 lea	 rax, OFFSET FLAT:glfwCreateWindow
-  00007	48 89 05 00 00
-	00 00		 mov	 QWORD PTR pack, rax
-
-; 18   :     pack.makeContextCurrent = glfwMakeContextCurrent;
-
-  0000e	48 8d 05 00 00
-	00 00		 lea	 rax, OFFSET FLAT:glfwMakeContextCurrent
-  00015	48 89 05 08 00
-	00 00		 mov	 QWORD PTR pack+8, rax
-
-; 19   :     pack.swapInterval = glfwSwapInterval;
-
-  0001c	48 8d 05 00 00
-	00 00		 lea	 rax, OFFSET FLAT:glfwSwapInterval
-
-; 20   :     pack.clearColor = glClearColor;
-; 21   :     pack.windowShouldClose = glfwWindowShouldClose;
-; 22   :     pack.swapBuffer = glfwSwapBuffers;
-; 23   : 
-; 24   :     //these are for callback
-; 25   :     pack.SetFramebufferSizeCallback = glfwSetFramebufferSizeCallback;
-; 26   : 
-; 27   : 
-; 28   :     return pack;
-
-  00023	0f 10 05 00 00
-	00 00		 movups	 xmm0, XMMWORD PTR pack
-  0002a	48 89 05 10 00
-	00 00		 mov	 QWORD PTR pack+16, rax
-  00031	48 8b 05 00 00
-	00 00		 mov	 rax, QWORD PTR glad_glClearColor
-  00038	48 89 05 18 00
-	00 00		 mov	 QWORD PTR pack+24, rax
-  0003f	48 8d 05 00 00
-	00 00		 lea	 rax, OFFSET FLAT:glfwWindowShouldClose
-  00046	0f 10 0d 10 00
-	00 00		 movups	 xmm1, XMMWORD PTR pack+16
-  0004d	48 89 05 20 00
-	00 00		 mov	 QWORD PTR pack+32, rax
-  00054	48 8d 05 00 00
-	00 00		 lea	 rax, OFFSET FLAT:glfwSwapBuffers
-  0005b	0f 11 01	 movups	 XMMWORD PTR [rcx], xmm0
-  0005e	48 89 05 28 00
-	00 00		 mov	 QWORD PTR pack+40, rax
-  00065	48 8d 05 00 00
-	00 00		 lea	 rax, OFFSET FLAT:glfwSetFramebufferSizeCallback
-  0006c	0f 10 05 20 00
-	00 00		 movups	 xmm0, XMMWORD PTR pack+32
-  00073	48 89 05 30 00
-	00 00		 mov	 QWORD PTR pack+48, rax
-  0007a	48 8b c1	 mov	 rax, rcx
-  0007d	0f 11 49 10	 movups	 XMMWORD PTR [rcx+16], xmm1
-  00081	f2 0f 10 0d 30
-	00 00 00	 movsd	 xmm1, QWORD PTR pack+48
-  00089	0f 11 41 20	 movups	 XMMWORD PTR [rcx+32], xmm0
-  0008d	f2 0f 11 49 30	 movsd	 QWORD PTR [rcx+48], xmm1
-
-; 29   : }
-
-  00092	c3		 ret	 0
-loadGLApi ENDP
-_TEXT	ENDS
-; Function compile flags: /Ogtpy
-; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgShqrpGraphic\StgSharpGraphic.c
-;	COMDAT initGL
-_TEXT	SEGMENT
-initGL	PROC						; COMDAT
-
-; 32   : {
-
-$LN4:
-  00000	48 83 ec 28	 sub	 rsp, 40			; 00000028H
-
-; 33   :     glfwInit();
-
-  00004	e8 00 00 00 00	 call	 glfwInit
-
-; 34   :     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-
-  00009	ba 03 00 00 00	 mov	 edx, 3
-  0000e	b9 02 20 02 00	 mov	 ecx, 139266		; 00022002H
-  00013	e8 00 00 00 00	 call	 glfwWindowHint
-
-; 35   :     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-
-  00018	ba 03 00 00 00	 mov	 edx, 3
-  0001d	b9 03 20 02 00	 mov	 ecx, 139267		; 00022003H
-  00022	e8 00 00 00 00	 call	 glfwWindowHint
-
-; 36   :     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-
-  00027	ba 01 20 03 00	 mov	 edx, 204801		; 00032001H
-  0002c	b9 08 20 02 00	 mov	 ecx, 139272		; 00022008H
-
-; 37   : 
-; 38   : #ifdef  __APPLE__
-; 39   :     glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
-; 40   : #endif //  __APPLE__
-; 41   : }
-
-  00031	48 83 c4 28	 add	 rsp, 40			; 00000028H
-
-; 36   :     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-
-  00035	e9 00 00 00 00	 jmp	 glfwWindowHint
-initGL	ENDP
-_TEXT	ENDS
-; Function compile flags: /Ogtpy
-; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgShqrpGraphic\StgSharpGraphic.c
-;	COMDAT initGLAD
-_TEXT	SEGMENT
-initGLAD PROC						; COMDAT
-
-; 46   :     return gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
-
-  00000	e9 00 00 00 00	 jmp	 gladLoadGLLoader
-initGLAD ENDP
-_TEXT	ENDS
+$unwind$initGL DQ 00000420400010401r		; 3.58617e-310
 END

源代码/StgShqrpGraphic/x64/Release/StgSharpGraphic.tlog/Cl.items.tlog

@@ -1,4 +1,7 @@
 D:\Programmer\GLenv\glad.c;D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\x64\Release\glad.obj
 D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\dllmain.c;D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\x64\Release\dllmain.obj
 D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\linear.c;D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\x64\Release\linear.obj
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\mat2.c;D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\x64\Release\mat2.obj
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\mat3.c;D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\x64\Release\mat3.obj
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\mat4.c;D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\x64\Release\mat4.obj
 D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\StgSharpGraphic.c;D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\源代码\StgShqrpGraphic\x64\Release\StgSharpGraphic.obj

源代码/StgShqrpGraphic/x64/Release/dllmain.cod

@@ -12,74 +12,10 @@ _BSS	ENDS
 PUBLIC	DllMain
 ;	COMDAT pdata
 pdata	SEGMENT
-$pdata$DllMain DD imagerel $LN22
-	DD	imagerel $LN22+51
+$pdata$DllMain DD imagerel $LN22@DllMain
+	DD	imagerel $LN22@DllMain+51
 	DD	imagerel $unwind$DllMain
 ;	COMDAT xdata
 xdata	SEGMENT
-$unwind$DllMain DD 010401H
-	DD	04204H
-; Function compile flags: /Ogtpy
-; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgShqrpGraphic\dllmain.c
-;	COMDAT DllMain
-_TEXT	SEGMENT
-hModule$ = 48
-ul_reason_for_call$ = 56
-lpReserved$ = 64
-DllMain	PROC						; COMDAT
-
-; 17   : {
-
-$LN22:
-  00000	48 83 ec 28	 sub	 rsp, 40			; 00000028H
-
-; 18   :     switch (ul_reason_for_call)
-
-  00004	83 fa 01	 cmp	 edx, 1
-  00007	75 20		 jne	 SHORT $LN20@DllMain
-  00009	0f 1f 80 00 00
-	00 00		 npad	 7
-$LL6@DllMain:
-
-; 19   :     {
-; 20   :     case DLL_PROCESS_ATTACH:
-; 21   :         do
-; 22   :         {
-; 23   :             defaultVecPtr = _aligned_malloc(sizeof(__m128),16);
-
-  00010	ba 10 00 00 00	 mov	 edx, 16
-  00015	8b ca		 mov	 ecx, edx
-  00017	ff 15 00 00 00
-	00		 call	 QWORD PTR __imp__aligned_malloc
-  0001d	48 89 05 00 00
-	00 00		 mov	 QWORD PTR defaultVecPtr, rax
-
-; 24   :         } while (defaultVecPtr == NULL);
-
-  00024	48 85 c0	 test	 rax, rax
-  00027	74 e7		 je	 SHORT $LL6@DllMain
-$LN20@DllMain:
-
-; 25   : 
-; 26   : 
-; 27   :     case DLL_THREAD_ATTACH:
-; 28   : 
-; 29   : 
-; 30   :     case DLL_THREAD_DETACH:
-; 31   : 
-; 32   : 
-; 33   :     case DLL_PROCESS_DETACH:
-; 34   : 
-; 35   : 
-; 36   : 
-; 37   :         break;
-; 38   :     }
-; 39   :     return TRUE;
-; 40   : }
-
-  00029	b8 01 00 00 00	 mov	 eax, 1
-  0002e	48 83 c4 28	 add	 rsp, 40			; 00000028H
-  00032	c3		 ret	 0
-DllMain	ENDP
-_TEXT	ENDS
+$unwind$DllMain DQ 00000420400010401r		; 3.58617e-310
 END