daily update on 20231016 by nitload youmu, vao,vbo,ebo struct added

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

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Math
+{
+    public interface IMat
+    {
+    }
+}

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

@@ -8,9 +8,9 @@
             return vec1.X * vec2.Y - vec1.Y * vec2.X;
         }
 
-        public static Vec3d Cross(Vec3d vec1, Vec3d vec2)
+        public static vec3d Cross(vec3d vec1, vec3d vec2)
         {
-            return new Vec3d(
+            return new vec3d(
                 vec1.Y * vec2.Z - vec1.Z * vec2.Y,
                 vec1.X * vec2.Z - vec1.Z * vec2.X,
                 vec1.X * vec2.Y - vec1.Y * vec2.X

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

@@ -1,39 +0,0 @@
-namespace StgSharp.Math
-{
-    public static unsafe partial class Vector
-    {
-        /*
-        public static float Det(Matrix2x2 array)
-        {
-            return Cross(array.row1, array.row2);
-        }
-        /**/
-
-        /*
-        public static unsafe float Det(matrix3x3 array)
-        {
-            float* p = &array.row1.X;
-
-            matrix2x2 matrix1 = new matrix2x2(
-                *(p + 4), *(p + 5),
-                *(p + 7), *(p + 8)
-                );
-            matrix2x2 matrix2 = new matrix2x2(
-                *(p + 3), *(p + 5),
-                *(p + 6), *(p + 8)
-                );
-            matrix2x2 matrix3 = new matrix2x2(
-                *(p + 3), *(p + 4),
-                *(p + 6), *(p + 7)
-                );
-
-            return
-                *p * Det(matrix1)
-                - *(p + 1) * Det(matrix2)
-                + *(p + 2) * Det(matrix3)
-                ;
-        }
-
-        */
-    }
-}

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

@@ -10,7 +10,7 @@
                 );
         }
 
-        public static float GetAngle(Vec3d vec1, Vec3d vec2)
+        public static float GetAngle(vec3d vec1, vec3d vec2)
         {
             return Calc.ACos(
                 vec1 * vec2

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

@@ -2,7 +2,7 @@
 {
     public static unsafe partial class Vector
     {
-        public static float GetLength(this Vec3d vec)
+        public static float GetLength(this vec3d vec)
         {
             return Calc.Sqrt(
                 vec.X * vec.X +

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

@@ -7,7 +7,7 @@ namespace StgSharp.Math
     {
         /*
 
-        public static unsafe float Multiple(Vec3d vec1, Vec3d vec2)
+        public static unsafe float Multiple(vec3d vec1, vec3d vec2)
         {
             IntPtr retPtr = internalIO.mulps_internal(vec1._Vector4Ptr,vec2._Vector4Ptr);
 
@@ -19,7 +19,7 @@ namespace StgSharp.Math
                 Vector4.single_2;
         }
 
-        public static unsafe float Multiple(Vec4d vec1,Vec3d vec2)
+        public static unsafe float Multiple(Vec4d vec1,vec3d vec2)
         {
             IntPtr retPtr = internalIO.mulps_internal(vec1._Vector4Ptr,vec2._Vector4Ptr);
             Vector4 Vector4 = *(Vector4*)retPtr;

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

@@ -5,12 +5,12 @@ namespace StgSharp.Math
 {
     public unsafe static partial class VectorCalc
     {
-        public static Vec3d To3D(Vec2d vec)
+        public static vec3d To3D(Vec2d vec)
         {
-            return new Vec3d(vec.X, vec.Y, 0.0f);
+            return new vec3d(vec.X, vec.Y, 0.0f);
         }
 
-        public static Vec2d To2D(Vec3d vec, CordinatePlain plain)
+        public static Vec2d To2D(vec3d vec, CordinatePlain plain)
         {
             switch (plain)
             {
@@ -30,9 +30,9 @@ namespace StgSharp.Math
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static Vec3d To3D(Vector4 vector)
+        internal static vec3d To3D(Vector4 vector)
         {
-            return new Vec3d(vector);
+            return new vec3d(vector);
         }
     }
 

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

@@ -42,7 +42,7 @@ namespace StgSharp
 namespace StgSharp.Math
 {
     [StructLayout(LayoutKind.Explicit, Size = 12 * sizeof(float), Pack = 16)]
-    internal struct Mat3 : IEquatable<Mat3>
+    public struct Mat3 : IEquatable<Mat3>
     {
 
         [FieldOffset(0)] internal Vector4 colum0;

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

@@ -55,7 +55,7 @@ namespace StgSharp.Math
 
 
     [StructLayout(LayoutKind.Explicit, Size = 16 * sizeof(float))]
-    internal struct Mat4 : IEquatable<Mat4>
+    public struct Mat4 : IEquatable<Mat4>, IMat
     {
         [FieldOffset(0)] internal Vector4 colum0;
         [FieldOffset(16)] internal Vector4 colum1;

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

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Math.Linear
+{
+    [StructLayout(LayoutKind.Explicit, Size = 5 * 4 * sizeof(float))]
+    public struct mat5 : IMat
+    {
+        [FieldOffset(0 * 4 * sizeof(float))] internal Vector4 vec0;
+        [FieldOffset(1 * 4 * sizeof(float))] internal Vector4 vec1;
+        [FieldOffset(2 * 4 * sizeof(float))] internal Vector4 vec2;
+        [FieldOffset(3 * 4 * sizeof(float))] internal Vector4 vec3;
+        [FieldOffset(4 * 4 * sizeof(float))] internal Vector4 vec4;
+    }
+}

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

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Math.Linear
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct mat6 : IMat
+    {
+        internal Vector4 vec0;
+        internal Vector4 vec1;
+        internal Vector4 vec2;
+        internal Vector4 vec3;
+        internal Vector4 vec4;
+        internal Vector4 vec5;
+    }
+}

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

@@ -5,7 +5,7 @@ using System.Runtime.InteropServices;
 namespace StgSharp.Math
 {
     [StructLayout(LayoutKind.Explicit, Size = 2 * 2 * 4 * sizeof(float) + sizeof(bool), Pack = 16)]
-    public struct Matrix2x2
+    public struct Matrix2x2 : IMat
     {
         [FieldOffset(0)]
         internal Mat2 mat;
@@ -17,16 +17,16 @@ namespace StgSharp.Math
         public Matrix2x2(
             float a00, float a01,
             float a10, float a11
-            ) 
+            )
         {
-            mat.colum0 = new Vector4(a00,a10,0,0);
-            mat.colum1 = new Vector4(a01,a11,0,0);
+            mat.colum0 = new Vector4(a00, a10, 0, 0);
+            mat.colum1 = new Vector4(a01, a11, 0, 0);
         }
 
         internal Matrix2x2(
             Vector4 c0,
             Vector4 c1
-            ) 
+            )
         {
             mat.colum0 = c0;
             mat.colum1 = c1;
@@ -41,7 +41,7 @@ namespace StgSharp.Math
 
         public Matrix2x2 Transpose
         {
-            get 
+            get
             {
                 InternalTranspose();
                 return new Matrix2x2(this.transpose);
@@ -104,11 +104,11 @@ namespace StgSharp.Math
         {
             left.InternalTranspose();
             return new Matrix2x2(
-                Vector4.Dot( left.transpose.colum0, right.mat.colum0), 
-                Vector4.Dot( left.transpose.colum0, right.mat.colum1), 
+                Vector4.Dot(left.transpose.colum0, right.mat.colum0),
+                Vector4.Dot(left.transpose.colum0, right.mat.colum1),
 
-                Vector4.Dot( left.transpose.colum1, right.mat.colum0), 
-                Vector4.Dot( left.transpose.colum1, right.mat.colum1) 
+                Vector4.Dot(left.transpose.colum1, right.mat.colum0),
+                Vector4.Dot(left.transpose.colum1, right.mat.colum1)
                 );
         }
 
@@ -117,13 +117,13 @@ namespace StgSharp.Math
         {
             left.InternalTranspose();
             return new Matrix2x3(
-                Vector4.Dot( left.transpose.colum0, right.mat.colum0), 
-                Vector4.Dot( left.transpose.colum0, right.mat.colum1), 
-                Vector4.Dot( left.transpose.colum0, right.mat.colum2), 
+                Vector4.Dot(left.transpose.colum0, right.mat.colum0),
+                Vector4.Dot(left.transpose.colum0, right.mat.colum1),
+                Vector4.Dot(left.transpose.colum0, right.mat.colum2),
 
-                Vector4.Dot( left.transpose.colum1, right.mat.colum0), 
-                Vector4.Dot( left.transpose.colum1, right.mat.colum1), 
-                Vector4.Dot( left.transpose.colum1, right.mat.colum2) 
+                Vector4.Dot(left.transpose.colum1, right.mat.colum0),
+                Vector4.Dot(left.transpose.colum1, right.mat.colum1),
+                Vector4.Dot(left.transpose.colum1, right.mat.colum2)
                 );
         }
 
@@ -132,15 +132,15 @@ namespace StgSharp.Math
         {
             left.InternalTranspose();
             return new Matrix2x4(
-                Vector4.Dot( left.transpose.colum0, right.mat.colum0), 
-                Vector4.Dot( left.transpose.colum0, right.mat.colum1), 
-                Vector4.Dot( left.transpose.colum0, right.mat.colum2), 
-                Vector4.Dot( left.transpose.colum0, right.mat.colum3), 
+                Vector4.Dot(left.transpose.colum0, right.mat.colum0),
+                Vector4.Dot(left.transpose.colum0, right.mat.colum1),
+                Vector4.Dot(left.transpose.colum0, right.mat.colum2),
+                Vector4.Dot(left.transpose.colum0, right.mat.colum3),
 
-                Vector4.Dot( left.transpose.colum1, right.mat.colum0), 
-                Vector4.Dot( left.transpose.colum1, right.mat.colum1), 
-                Vector4.Dot( left.transpose.colum1, right.mat.colum2), 
-                Vector4.Dot( left.transpose.colum1, right.mat.colum3) 
+                Vector4.Dot(left.transpose.colum1, right.mat.colum0),
+                Vector4.Dot(left.transpose.colum1, right.mat.colum1),
+                Vector4.Dot(left.transpose.colum1, right.mat.colum2),
+                Vector4.Dot(left.transpose.colum1, right.mat.colum3)
                 );
         }
 

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

@@ -11,9 +11,9 @@ namespace StgSharp.Math
         [FieldOffset(0)] internal Mat3 mat;
         [FieldOffset(3 * 4 * sizeof(float))] internal Mat3 transpose;
         [FieldOffset(6 * 4 * sizeof(float))] internal bool isTransposed;
-        [FieldOffset(0 * 4 * sizeof(float))] public Vec3d Colum0;
-        [FieldOffset(1 * 4 * sizeof(float))] public Vec3d Colum1;
-        [FieldOffset(2 * 4 * sizeof(float))] public Vec3d Colum2;
+        [FieldOffset(0 * 4 * sizeof(float))] public vec3d Colum0;
+        [FieldOffset(1 * 4 * sizeof(float))] public vec3d Colum1;
+        [FieldOffset(2 * 4 * sizeof(float))] public vec3d Colum2;
 
         public Matrix3x3(
             float a00, float a01, float a02,
@@ -66,7 +66,10 @@ namespace StgSharp.Math
                 }
                 if (columNum > 2 || columNum < 0)
                 {
-                    throw new ArgumentOutOfRangeException(nameof(columNum));
+                    internalIO.InternalWriteLog(
+                        $"Attempt to write unused space in {GetType().Name} {nameof(mat)}",
+                        LogType.Error
+                        );
                 }
                 InternalTranspose();
                 fixed (float* p = &this.transpose.m00)
@@ -142,6 +145,17 @@ namespace StgSharp.Math
                 );
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static vec3d operator *(Matrix3x3 left, vec3d right)
+        {
+            left.InternalTranspose();
+            return new vec3d(
+                Vector4.Dot(left.transpose.colum0, right.vec),
+                Vector4.Dot(left.transpose.colum1, right.vec),
+                Vector4.Dot(left.transpose.colum2, right.vec)
+                );
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Matrix3x2 operator *(Matrix3x3 left, Matrix3x2 right)
         {

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

@@ -14,10 +14,10 @@ namespace StgSharp.Math
         [FieldOffset(4 * 4 * sizeof(float))] internal Mat3 transpose;
         [FieldOffset(7 * 4 * sizeof(float))] internal bool isTransposed;
 
-        [FieldOffset(0 * 4 * sizeof(float))] public Vec3d Colum0;
-        [FieldOffset(1 * 4 * sizeof(float))] public Vec3d Colum1;
-        [FieldOffset(2 * 4 * sizeof(float))] public Vec3d Colum2;
-        [FieldOffset(3 * 4 * sizeof(float))] public Vec3d Colum3;
+        [FieldOffset(0 * 4 * sizeof(float))] public vec3d Colum0;
+        [FieldOffset(1 * 4 * sizeof(float))] public vec3d Colum1;
+        [FieldOffset(2 * 4 * sizeof(float))] public vec3d Colum2;
+        [FieldOffset(3 * 4 * sizeof(float))] public vec3d Colum3;
 
         public Matrix3x4(
             float a00, float a01, float a02, float a03,

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

@@ -1,13 +1,19 @@
 using StgSharp.Controlling;
+using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace StgSharp.Math
 {
+    public static class Vec3d
+    {
+        public static vec3d Zero => new vec3d(0, 0, 0);
+        public static vec3d Unit => new vec3d(1, 1, 1);
+    }
 
     [StructLayout(LayoutKind.Explicit, Size = 16, Pack = 16)]
-    public struct Vec3d
+    public struct vec3d : IEquatable<vec3d>
     {
         [FieldOffset(0)]
         internal Vector4 vec;
@@ -16,42 +22,67 @@ namespace StgSharp.Math
         [FieldOffset(4)] public float Y;
         [FieldOffset(8)] public float Z;
 
-        public Vec3d(
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public vec3d Zero()
+        {
+            return new vec3d(0, 0, 0);
+        }
+
+        public vec3d(
             float x, float y, float z)
         {
             X = x; Y = y; Z = z;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal Vec3d(Vector4 vector)
+        public float Dot(vec3d right)
+        {
+            Vector4 vector4 = this.vec * right.vec;
+            return vector4.X
+                + vector4.Y
+                + vector4.Z;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public vec3d Cross(vec3d right)
+        {
+            return new vec3d(
+                this.Y * right.Z - this.Z * right.Y,
+                this.X * right.Z - this.Z * right.X,
+                this.X * right.Y - this.Y * right.X
+                );
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal vec3d(Vector4 vector)
         {
             vec = vector;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vec3d operator +(Vec3d vec1, Vec3d vec2)
+        public static vec3d operator +(vec3d left, vec3d right)
         {
-            return new Vec3d(
-                vec1.X + vec2.X,
-                vec1.Y + vec2.Y,
-                vec1.Z + vec2.Z
+            return new vec3d(
+                left.X + right.X,
+                left.Y + right.Y,
+                left.Z + right.Z
                 );
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vec3d operator -(Vec3d vec1, Vec3d vec2)
+        public static vec3d operator -(vec3d left, vec3d right)
         {
-            return new Vec3d(
-                vec1.X - vec2.X,
-                vec1.Y - vec2.Y,
-                vec1.Z - vec2.Z
+            return new vec3d(
+                left.X - right.X,
+                left.Y - right.Y,
+                left.Z - right.Z
                 );
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vec3d operator *(Vec3d vec, float value)
+        public static vec3d operator *(vec3d vec, float value)
         {
-            return new Vec3d(
+            return new vec3d(
                 vec.X * value,
                 vec.Y * value,
                 vec.Z * value
@@ -59,9 +90,9 @@ namespace StgSharp.Math
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vec3d operator /(Vec3d vec, float value)
+        public static vec3d operator /(vec3d vec, float value)
         {
-            return new Vec3d(
+            return new vec3d(
                 vec.X / value,
                 vec.Y / value,
                 vec.Z / value
@@ -69,12 +100,28 @@ namespace StgSharp.Math
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float operator *(Vec3d vec1, Vec3d vec2)
+        public static float operator *(vec3d left, vec3d right)
         {
             return
-                vec1.X * vec2.X +
-                vec1.Y * vec2.Y +
-                vec1.Z * vec2.Z;
+                left.X * right.X +
+                left.Y * right.Y +
+                left.Z * right.Z;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator ==(vec3d left, vec3d right)
+        {
+            return left.X == right.X
+                && left.Y == right.Y
+                && left.Z == right.Z;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator !=(vec3d left, vec3d right)
+        {
+            return left.X != right.X
+                && left.Y != right.Y
+                && left.Z != right.Z;
         }
 
         public string ToString(string sample)
@@ -82,7 +129,32 @@ namespace StgSharp.Math
             return $"{this.X}\t{this.Y}\t{this.Z}\t";
         }
 
+        public bool Equals(vec3d other)
+        {
+            return this.vec == other.vec;
+        }
 
+        public override bool Equals(object obj)
+        {
+            if (obj is vec3d)
+            {
+                return this == (vec3d)obj;
+            }
+            else
+            {
+                return false;
+            }
+        }
 
+        public unsafe override int GetHashCode()
+        {
+            fixed (float* add = &X)
+                return HashCode.Combine(X, Y, Z, (ulong)add);
+        }
+
+        public override string ToString()
+        {
+            return $"[{X},{Y},{Z}]";
+        }
     }
 }