daily update on 20230804 by nitload youmu

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

@@ -43,8 +43,8 @@ namespace StgSharp.Geometries
             uint nowTick = TimeLine.tickCounter._value;
             this.vertex01.Position = RefOrigin.Position + movVertex01Operation(nowTick);
             this.vertex02.Position = RefOrigin.Position + movVertex02Operation(nowTick);
-            this.vertex03.Position = 2 * center.Position - vertex01.Position;
-            this.vertex04.Position = 2 * center.Position - vertex02.Position;
+            this.vertex03.Position = center.Position * 2 - vertex01.Position;
+            this.vertex04.Position = center.Position * 2 - vertex02.Position;
         }
 
     }

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

@@ -1,6 +1,7 @@
 using StgSharp.Math;
 using System;
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.InteropServices;
 
 
@@ -29,6 +30,24 @@ namespace StgSharp
             CallingConvention = CallingConvention.Cdecl)]
         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",
+            CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr divps_internal(IntPtr ptr1, IntPtr ptr2);
+
+        [DllImport("StgSharpGraphic.dll", EntryPoint = "divps_const",
+            CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr divps_const_internal(IntPtr ptr, float value);
+
+
+
+
+
+
+
 
 
         [DllImport("StgSharpGraphic.dll", EntryPoint = "deinitM128",

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

@@ -1,35 +1,60 @@
 using System;
+using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
     public static unsafe partial class VectorCalc
     {
 
-        public static unsafe float Multiple(Vec3d vec1, Vec4d vec2)
+        public static unsafe float Multiple(Vec3d vec1, Vec3d vec2)
         {
-            M128* retPtr = (M128*)internalIO.mulps_internal(vec1._m128Ptr,vec2._m128Ptr);
+            IntPtr retPtr = internalIO.mulps_internal(vec1._m128Ptr,vec2._m128Ptr);
 
+            M128 m128 = *(M128*)retPtr;
+            Marshal.FreeHGlobal(retPtr);
             return
-                retPtr->single_0 +
-                retPtr->single_1 +
-                retPtr->single_2;
+                m128.single_0 +
+                m128.single_1 +
+                m128.single_2;
         }
 
-        public static unsafe float Multiple(Vec4d vec1,Vec4d vec2)
+        
+
+        public static unsafe float Multiple(Vec4d vec1,Vec3d vec2)
         {
-            M128* retPtr = (M128*)internalIO.mulps_internal(vec1._m128Ptr,vec2._m128Ptr);
+            IntPtr retPtr = internalIO.mulps_internal(vec1._m128Ptr,vec2._m128Ptr);
+            M128 m128 = *(M128*)retPtr;
+            Marshal.FreeHGlobal(retPtr);
             return
-                retPtr->single_0 +
-                retPtr->single_1 +
-                retPtr->single_2 +
-                retPtr->single_3;
+                m128.single_0 +
+                m128.single_1 +
+                m128.single_2 +
+                m128.single_3;
         }
 
-        public static unsafe Matrix4x4 Multiple(
+        public static Matrix4x4 Multiple(
             Matrix4x4 matrix1, Matrix4x4 matrix2
             )
         {
-            return default;
+            Matrix4x4 transpose = matrix2.Transpose(TransposeMode.Copy);
+            return new Matrix4x4(
+                internalIO.mulps_sum_internal(matrix1._row0Ptr, transpose._row0Ptr),
+                internalIO.mulps_sum_internal(matrix1._row0Ptr, transpose._row1Ptr),
+                internalIO.mulps_sum_internal(matrix1._row0Ptr, transpose._row2Ptr),
+                internalIO.mulps_sum_internal(matrix1._row0Ptr, transpose._row3Ptr),
+                internalIO.mulps_sum_internal(matrix1._row1Ptr, transpose._row0Ptr),
+                internalIO.mulps_sum_internal(matrix1._row1Ptr, transpose._row1Ptr),
+                internalIO.mulps_sum_internal(matrix1._row1Ptr, transpose._row2Ptr),
+                internalIO.mulps_sum_internal(matrix1._row1Ptr, transpose._row3Ptr),
+                internalIO.mulps_sum_internal(matrix1._row2Ptr, transpose._row0Ptr),
+                internalIO.mulps_sum_internal(matrix1._row2Ptr, transpose._row1Ptr),
+                internalIO.mulps_sum_internal(matrix1._row2Ptr, transpose._row2Ptr),
+                internalIO.mulps_sum_internal(matrix1._row2Ptr, transpose._row3Ptr),
+                internalIO.mulps_sum_internal(matrix1._row3Ptr, transpose._row0Ptr),
+                internalIO.mulps_sum_internal(matrix1._row3Ptr, transpose._row1Ptr),
+                internalIO.mulps_sum_internal(matrix1._row3Ptr, transpose._row2Ptr),
+                internalIO.mulps_sum_internal(matrix1._row3Ptr, transpose._row3Ptr)
+                );
         }
 
         /*

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

@@ -1,10 +1,59 @@
 using System;
+using System.Reflection.Emit;
 using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
     public class Matrix3x4
     {
-        
+        internal IntPtr _row0Ptr;
+        internal IntPtr _row1Ptr;
+        internal IntPtr _row2Ptr;
+
+        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
+            )
+        {
+            _row0Ptr = internalIO.load_internal(a00,a01,a02,a03);
+            _row1Ptr = internalIO.load_internal(a10,a11,a12,a13);
+            _row2Ptr = internalIO.load_internal(a20,a21,a22,a23);
+
+            _transpose = new Matrix4x3(this);
+        }
+
+        internal Matrix3x4()
+        {
+            _transpose = new Matrix4x3(this);
+        }
+
+        internal Matrix3x4(Matrix4x3 transpose)
+        {
+            _transpose = transpose;
+        }
+
+        public Matrix4x3 Transpose(TransposeMode transposeMode)
+        {
+            switch (transposeMode)
+            {
+                case TransposeMode.New:
+                    return new Matrix4x3();
+                    break;
+                case TransposeMode.Copy:
+
+                    break;
+                default:
+                    throw new Exception();
+                    break;
+            }
+        }
+
+
+
+
     }
 }

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

@@ -3,6 +3,38 @@ using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
+    public class Matrix4x3
+    {
+        internal IntPtr _row0Ptr;
+        internal IntPtr _row1Ptr;
+        internal IntPtr _row2Ptr;
+        internal IntPtr _row3Ptr;
+
+        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
+            )
+        {
+            _row0Ptr = internalIO.load_internal(a00,a01,a02,0);
+            _row1Ptr = internalIO.load_internal(a10,a11,a12,0);
+            _row2Ptr = internalIO.load_internal(a20,a21,a22,0);
+            _row3Ptr = internalIO.load_internal(a30,a31,a32,0);
+
+            _transpose = new Matrix3x4(this);
+        }
+
+        internal Matrix4x3(Matrix3x4 transpose)
+        {
+            this._transpose = transpose;
+        }
+
+
+    }
 
     [StructLayout(LayoutKind.Explicit)]
     public struct matrix4x3 : IEquatable<matrix4x3>

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

@@ -22,6 +22,7 @@ namespace StgSharp.Math
                 );
 
 
+
         internal M128Map map;
 
         internal IntPtr _row0Ptr;
@@ -34,6 +35,9 @@ namespace StgSharp.Math
 
         private Matrix4x4 _transpose;
 
+
+
+
         internal Matrix4x4()
         {
             _row0Ptr = internalIO.load_internal(0,0,0,0);
@@ -60,7 +64,8 @@ namespace StgSharp.Math
             IntPtr row0Ptr, 
             IntPtr row1Ptr, 
             IntPtr row2Ptr, 
-            IntPtr row3Ptr)
+            IntPtr row3Ptr
+            )
         {
 
             _row0Ptr = row0Ptr;

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

@@ -220,6 +220,18 @@ namespace StgSharp.Math
                 );
         }
 
+        public static Vec3d operator /(Vec3d vec, float value)
+        {
+            return new Vec3d(
+                internalIO.divps_const_internal(vec._m128Ptr,value)
+                );
+        }
+
+        public static float operator *(Vec3d vec1, Vec3d vec2)
+        {
+            return VectorCalc.Multiple(vec1,vec2);
+        }
+
         public unsafe override string ToString()
         {
             return (*(M128*)_m128Ptr).ToString();

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

@@ -94,6 +94,13 @@ namespace StgSharp.Math
                 );
         }
 
+        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}";