Daily update 2 on 20240228 by nitload youmu

StgSharp.Common/Math/Graphic/Camera.cs

@@ -0,0 +1,309 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Camera.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Graphics;
+using StgSharp.Graphics.OpenGL;
+using StgSharp.Graphics.ShaderEdit;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public sealed class Camera : IglConvertable
+    {
+
+        private bool _isLookAtAvailable;
+        internal Matrix44 _lookAt;
+        internal Matrix44 _projection;
+        internal Matrix44 cameraAtt;
+        internal Matrix44 rotation;
+        internal Matrix44 rotationAtt;
+        internal Radius _pitch;
+        internal Radius _row;
+        internal Radius _yaw;
+        internal Uniform<Matrix44> convertedUniform;
+        internal Vec3 _target, up;
+
+        public Camera()
+        {
+            cameraAtt = Matrix44.Unit;
+            _target = Vec3.Zero;
+            up = Vec3.Zero;
+            _isLookAtAvailable = false;
+            _lookAt = Matrix44.Unit;
+            rotationAtt = Matrix44.Unit;
+            _projection = new Matrix44();
+        }
+
+        public Camera( Vec3 position, Vec3 target, Vec3 up )
+            : this()
+        {
+            rotationAtt = Matrix44.Unit;
+            cameraAtt = new Matrix44();
+            SetViewDirection( position, target, up );
+            _pitch = Radius.Zero;
+            _row = Radius.Zero;
+            _yaw = Radius.Zero;
+        }
+
+        public Matrix44 Projection => _projection;
+
+        public Matrix44 View
+        {
+            get
+            {
+                if( _isLookAtAvailable ) {
+                    return _lookAt;
+                }
+                Matrix44 move = Matrix44.Unit;
+                move.colum3.vec -= cameraAtt.colum3.vec;
+                _lookAt = rotationAtt.Transpose * move;
+                _isLookAtAvailable = true;
+                return _lookAt;
+            }
+        }
+
+        public void DisplayGLtypeDefinition()
+        {
+            Console.WriteLine( "uniform matrix4x4 cameraName;" );
+        }
+
+        /// <summary>
+        /// Get all uniform related to this <see cref="Camera" />.
+        /// </summary>
+        /// <param _name="source"> Shader program requires this camera. </param>
+        /// <param _name="uniformName">
+        /// ContextName of all related uniforms. If you fallow form from <see
+        /// cref="IglConvertable.DisplayGLtypeDefinition" />
+        /// </param>
+        /// <exception cref="ArgumentException"></exception>
+        public unsafe void GainAllUniforms(
+            ShaderProgram source,
+            params string[] uniformName )
+        {
+            if( uniformName.Length != 1 ) {
+                throw new ArgumentException(
+                    "Camera needs only one uniform.", nameof( uniformName ) );
+            }
+            convertedUniform = source.GetUniform<Matrix44>( uniformName[ 0 ] );
+        }
+
+        public void MoveNear( float distance )
+        {
+            cameraAtt.colum3.Z -= distance;
+            _isLookAtAvailable = false;
+        }
+
+        public void MoveRight( float distance )
+        {
+            cameraAtt.colum3.X -= distance;
+            _isLookAtAvailable = false;
+        }
+
+        public void MoveUp( float distance )
+        {
+            cameraAtt.colum3.Y -= distance;
+            _isLookAtAvailable = false;
+        }
+
+        public unsafe void SetAllUniforms()
+        {
+            //Console.WriteLine(Projection * ViewBase);
+            OpenGL.OpenGLFunction.CurrentGL
+                .SetUniformValue( convertedUniform, Projection * View );
+        }
+
+        public void SetViewDirection( Vec3 position, Vec3 target, Vec3 up )
+        {
+            Vec3 direction = position - target;
+            if( ( position.vec == cameraAtt.colum3.vec ) && ( this.up == up ) && ( cameraAtt.colum2.vec == direction.vec ) ) {
+                //no difference with precious value
+                return;
+            }
+            if( direction.GetLength() == 0 ) {
+                //deadlock
+                throw new ArgumentException();
+            }
+            if( Vec3.IsParallel( direction, up ) ) {
+                throw new ArgumentException();
+            }
+            _target = direction;
+            this.up = up;
+
+            _isLookAtAvailable = false;
+
+            Linear.Orthogonalize( ref direction, ref up );
+
+            Vec3 right = Linear.Orthogonalize( Linear.Cross( up, direction ) );
+
+            cameraAtt.colum0.vec = right.vec;
+            cameraAtt.colum1.vec = up.vec;
+            cameraAtt.colum2.vec = direction.vec;
+            cameraAtt.colum3.vec = position.vec;
+
+            InternalPitch();
+            InternalRow();
+            InternalYaw();
+        }
+
+        public void SetViewRange(
+            Radius fovRadius,
+            Vec2 size,
+            Vec2 offset,
+            (float front, float back) dephRange )
+        {
+            float
+                distance = _target.GetLength(),
+                near = distance - dephRange.front,
+                far = distance + dephRange.back,
+                offsetX = offset.X,
+                offsetY = offset.Y,
+                width = Scaler.Abs(
+                GeometryScaler.Tan( fovRadius / 2 ) * near * 2 ),
+                height = ( width * size.Y ) / size.X;
+
+            _projection.colum0.X = ( 2 * near ) / width;
+            _projection.colum1.Y = ( 2 * near ) / height;
+            _projection.colum2.X = ( 2 * offsetX ) / width;
+            _projection.colum2.Y = ( 2 * offsetY ) / height;
+            _projection.colum2.Z = ( far + near ) / ( near - far );
+            _projection.colum2.W = -1;
+            _projection.colum3.Z = ( 2 * near * far ) / ( near - far );
+        }
+
+        public void Test( params Vec4[] vec )
+        {
+            Console.WriteLine( View );
+            Console.WriteLine( Projection );
+            Console.WriteLine( Projection * View );
+            Console.WriteLine( View );
+            foreach( Vec4 item in vec ) {
+                Console.Write( $"{Projection * View * item};" );
+            }
+        }
+
+        ShaderStruct IglConvertable.GetConvertedGLtype()
+        {
+            throw new NotImplementedException();
+        }
+
+        ~Camera() { }
+
+        #region rotation
+
+        public void Yaw( Radius r )
+        {
+            _yaw -= r;
+
+            //Console.WriteLine(_yaw._radius);
+            //Console.WriteLine(rotationAtt);
+            InternalYaw();
+        }
+
+        public void Pitch( Radius r )
+        {
+            _pitch -= r;
+
+            //Console.WriteLine(_pitch._radius);
+            //Console.WriteLine(rotationAtt);
+            InternalPitch();
+        }
+
+        public void Row( Radius r )
+        {
+            _row -= r;
+
+            //Console.WriteLine(_row._radius);
+            //Console.WriteLine(rotationAtt);
+            InternalRow();
+        }
+
+        internal void InternalPitch()
+        {
+            _isLookAtAvailable = false;
+
+            Matrix32 partialCoord = new Matrix32(
+                cameraAtt.colum1.vec, cameraAtt.colum2.vec );
+            float angle = _pitch._radius;
+
+            Matrix22 rotation = new Matrix22(
+                Scaler.Cos( angle ), -Scaler.Sin( angle ), Scaler.Sin( angle ),
+                Scaler.Cos( angle ) );
+
+            partialCoord *= rotation;
+            rotationAtt.colum1.vec = partialCoord.colum0.vec;
+            rotationAtt.colum2.vec = partialCoord.colum1.vec;
+            rotationAtt.isTransposed = false;
+        }
+
+        internal void InternalRow()
+        {
+            _isLookAtAvailable = false;
+
+            Matrix32 partialCoord = new Matrix32(
+                cameraAtt.colum0.vec, cameraAtt.colum1.vec );
+            float angle = _row._radius;
+
+            Matrix22 rotation = new Matrix22(
+                Scaler.Cos( angle ), -Scaler.Sin( angle ), Scaler.Sin( angle ),
+                Scaler.Cos( angle ) );
+
+            partialCoord *= rotation;
+            rotationAtt.colum0.vec = partialCoord.colum0.vec;
+            rotationAtt.colum1.vec = partialCoord.colum1.vec;
+            rotationAtt.isTransposed = false;
+        }
+
+        internal void InternalYaw()
+        {
+            _isLookAtAvailable = false;
+
+            Matrix32 partialCoord = new Matrix32(
+                cameraAtt.colum0.vec, cameraAtt.colum2.vec );
+            float angle = _yaw._radius;
+            Matrix22 rotation = new Matrix22(
+                Scaler.Cos( angle ), -Scaler.Sin( angle ), Scaler.Sin( angle ),
+                Scaler.Cos( angle ) );
+
+            partialCoord *= rotation;
+            rotationAtt.colum0.vec = partialCoord.colum0.vec;
+            rotationAtt.colum2.vec = partialCoord.colum1.vec;
+            rotationAtt.isTransposed = false;
+        }
+
+        #endregion
+    }
+}

StgSharp.Common/Math/Linear/Cordination.cs

@@ -0,0 +1,41 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Cordination.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp.Math
+{
+    public enum CoordinatePlain
+    {
+
+        XY,
+        YZ,
+        XZ,
+
+    }
+}

StgSharp.Common/Math/Linear/IVector.cs

@@ -0,0 +1,50 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IVector.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Math
+{
+    public interface IVector
+    {
+        /*
+        public static TItem Create<TItem>(Vector4 source) where TItem : IVector
+        {
+            return TItem
+        }
+        /**/
+
+    }
+}

StgSharp.Common/Math/Linear/Matrix22.cs

@@ -0,0 +1,181 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Matrix22.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal.Intrinsic;
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    [StructLayout(
+        LayoutKind.Explicit,
+        Size = ( 2 * 2 * 4 * sizeof( float ) ) + sizeof( bool ),
+        Pack = 16 )]
+    public struct Matrix22 : IMat
+    {
+        [FieldOffset( 2 * 2 * 4 * sizeof( float ) )]
+        internal bool isTransposed = false;
+
+        [FieldOffset( 0 )]
+        internal ColumnSet2 _mat;
+        [FieldOffset( 2 * 4 * sizeof( float ) )]
+        internal ColumnSet2 _transpose;
+
+        public Matrix22()
+        {
+            Unsafe.SkipInit( out this );
+            isTransposed = false;
+        }
+
+        internal Matrix22( ColumnSet2 mat )
+        {
+            this._mat = mat;
+        }
+
+        internal Matrix22( Vector4 c0, Vector4 c1 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            _mat.colum0 = c0;
+            _mat.colum1 = c1;
+        }
+
+        public Matrix22( float a00, float a01, float a10, float a11 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            _mat.colum0 = new Vector4( a00, a10, 0, 0 );
+            _mat.colum1 = new Vector4( a01, a11, 0, 0 );
+        }
+
+        public Matrix22 Transpose
+        {
+            get
+            {
+                InternalTranspose();
+                return new Matrix22( this._transpose );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public float Det()
+        {
+            return ( _mat.m00 * _mat.m11 ) - ( _mat.m10 * _mat.m01 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        internal void InternalTranspose()
+        {
+            if( !isTransposed ) {
+                _transpose = _mat;
+                float cache = _transpose.m10;
+                _transpose.m10 = _transpose.m01;
+                _transpose.m01 = cache;
+
+                isTransposed = true;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe Matrix22 operator +(Matrix22 left, Matrix22 right)
+        {
+            Matrix22 ret = new Matrix22();
+            InternalIO.Intrinsic.add_mat_2( &left._mat, &right._mat, &ret._mat );
+            return ret;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix22 operator -( Matrix22 left, Matrix22 right )
+        {
+            return new Matrix22(
+                left._mat.colum0 + right._mat.colum0,
+                left._mat.colum1 + right._mat.colum1 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix22 operator *( Matrix22 mat, float value )
+        {
+            return new Matrix22(
+                mat._mat.colum0 * value, mat._mat.colum1 * value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix22 operator *( Matrix22 left, Matrix22 right )
+        {
+            left.InternalTranspose();
+            return new Matrix22(
+                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 ));
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix23 operator *( Matrix22 left, Matrix23 right )
+        {
+            left.InternalTranspose();
+            return new Matrix23(
+                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 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix24 operator *( Matrix22 left, Matrix24 right )
+        {
+            left.InternalTranspose();
+            return new Matrix24(
+                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 ));
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix22 operator /( Matrix22 mat, float value )
+        {
+            return new Matrix22(
+                mat._mat.colum0 / value, mat._mat.colum1 / value );
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Matrix23.cs

@@ -0,0 +1,200 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Matrix23.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal.Intrinsic;
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    [StructLayout(
+        LayoutKind.Explicit,
+        Size = ( ( 3 + 2 ) * 4 * sizeof( float ) ) + sizeof( bool ),
+        Pack = 16 )]
+    public struct Matrix23 : IMat
+    {
+
+        [FieldOffset( 5 * 4 * sizeof( float ) )] internal bool isTransposed = false;
+        [FieldOffset( 3 * 4 * sizeof( float ) )] internal ColumnSet2 _transpose;
+        [FieldOffset( 0 )] internal ColumnSet3 _mat;
+
+        public Matrix23()
+        {
+            Unsafe.SkipInit( out _mat);
+            Unsafe.SkipInit(out _transpose);
+        }
+
+        internal Matrix23( Vector4 c0, Vector4 c1, Vector4 c2 )
+        {
+            _mat.colum0 = c0;
+            _mat.colum1 = c1;
+            _mat.colum2 = c2;
+        }
+
+        public Matrix23(
+            float a00,
+            float a01,
+            float a02,
+            float a10,
+            float a11,
+            float a12 )
+        {
+            _mat.colum0 = new Vector4( a00, a10, 0, 0 );
+            _mat.colum1 = new Vector4( a01, a11, 0, 0 );
+            _mat.colum2 = new Vector4( a02, a12, 0, 0 );
+        }
+
+        public unsafe float this[ int rowNum, int columNum ]
+        {
+            get
+            {
+                if( ( rowNum > 1 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 2 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this._transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    return *( float* )pbit;
+                }
+            }
+            set
+            {
+                if( ( rowNum > 1 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 2 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this._transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    *( float* )pbit = value;
+                }
+                isTransposed = false;
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        internal unsafe void InternalTranspose()
+        {
+            if( !isTransposed ) {
+                fixed( ColumnSet3* source = &this._mat ) {
+                    fixed( ColumnSet2* target = &this._transpose ) {
+                        InternalIO.Intrinsic.transpose32( source, target );
+                    }
+                }
+
+                isTransposed = true;
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix23 operator -( Matrix23 left, Matrix23 right )
+        {
+            return new Matrix23(
+                left._mat.colum0 - right._mat.colum0,
+                left._mat.colum1 - right._mat.colum1,
+                left._mat.colum2 - right._mat.colum2 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix23 operator *( Matrix23 mat, float value )
+        {
+            return new Matrix23(
+                mat._mat.colum0 * value, mat._mat.colum1 * value,
+                mat._mat.colum2 * value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix22 operator *( Matrix23 left, Matrix32 right )
+        {
+            left.InternalTranspose();
+            return new Matrix22(
+                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 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix23 operator *( Matrix23 left, Matrix33 right )
+        {
+            left.InternalTranspose();
+            return new Matrix23(
+                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 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix24 operator *( Matrix23 left, Matrix34 right )
+        {
+            left.InternalTranspose();
+            return new Matrix24(
+                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 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix23 operator /( Matrix23 mat, float value )
+        {
+            return new Matrix23(
+                mat._mat.colum0 / value, mat._mat.colum1 / value,
+                mat._mat.colum2 / value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix23 operator +( Matrix23 left, Matrix23 right )
+        {
+            Matrix23 ret = new Matrix23();
+            InternalIO.Intrinsic.add_mat_3(&left._mat, &right._mat, &ret._mat);
+            return ret;
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Matrix24.cs

@@ -0,0 +1,220 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Matrix24.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal.Intrinsic;
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    [StructLayout(
+        LayoutKind.Explicit,
+        Size = ( ( 4 + 2 ) * 4 * sizeof( float ) ) + sizeof( bool ),
+        Pack = 16 )]
+    public struct Matrix24 : IMat
+    {
+        [FieldOffset( 6 * 4 * sizeof( float ) )] internal bool isTransposed;
+        [FieldOffset( 4 * 4 * sizeof( float ) )] internal ColumnSet2 transpose;
+
+        [FieldOffset( 0 )] internal ColumnSet4 mat;
+
+        [FieldOffset( 0 )] public Vec2 Colum0;
+        [FieldOffset( 16 )] public Vec2 Colum1;
+        [FieldOffset( 32 )] public Vec2 Colum2;
+        [FieldOffset( 48 )] public Vec2 Colum3;
+
+        public Matrix24()
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+        }
+
+        internal Matrix24( Vector4 c0, Vector4 c1, Vector4 c2, Vector4 c3 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = c0;
+            mat.colum1 = c1;
+            mat.colum2 = c2;
+            mat.colum3 = c3;
+        }
+
+        public Matrix24(
+            float a00,
+            float a01,
+            float a02,
+            float a03,
+            float a10,
+            float a11,
+            float a12,
+            float a13 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = new Vector4( a00, a10, 0, 0 );
+            mat.colum1 = new Vector4( a01, a11, 0, 0 );
+            mat.colum2 = new Vector4( a02, a12, 0, 0 );
+            mat.colum3 = new Vector4( a03, a13, 0, 0 );
+        }
+
+        public unsafe float this[ int rowNum, int columNum ]
+        {
+            get
+            {
+                if( ( rowNum > 1 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 3 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    return *( float* )pbit;
+                }
+            }
+            set
+            {
+                if( ( rowNum > 1 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 3 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    *( float* )pbit = value;
+                }
+                isTransposed = false;
+            }
+        }
+
+        public override string ToString()
+        {
+            InternalTranspose();
+            return $"{$"[{mat.m00},{mat.m01},{mat.m02},{mat.m03}],"}{$"[{mat.m10},{mat.m11},{mat.m12},{mat.m13}]"}";
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        internal unsafe void InternalTranspose()
+        {
+            if( !isTransposed ) {
+                fixed( ColumnSet4* source = &this.mat ) {
+                    fixed( ColumnSet2* target = &this.transpose ) {
+                        InternalIO.Intrinsic.transpose42( source, target );
+                    }
+                }
+
+                isTransposed = true;
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix24 operator -( Matrix24 left, Matrix24 right )
+        {
+            return new Matrix24(
+                left.mat.colum0 - right.mat.colum0,
+                left.mat.colum1 - right.mat.colum1,
+                left.mat.colum2 - right.mat.colum2,
+                left.mat.colum3 - right.mat.colum3 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix24 operator *( Matrix24 mat, float value )
+        {
+            return new Matrix24(
+                mat.mat.colum0 * value, mat.mat.colum1 * value,
+                mat.mat.colum2 * value, mat.mat.colum3 * value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix22 operator *( Matrix24 left, Matrix42 right )
+        {
+            left.InternalTranspose();
+            return new Matrix22(
+                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 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix23 operator *( Matrix24 left, Matrix43 right )
+        {
+            left.InternalTranspose();
+            return new Matrix23(
+                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 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix24 operator *( Matrix24 left, Matrix44 right )
+        {
+            left.InternalTranspose();
+            return new Matrix24(
+                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 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix24 operator /( Matrix24 mat, float value )
+        {
+            return new Matrix24(
+                mat.mat.colum0 / value, mat.mat.colum1 / value,
+                mat.mat.colum2 / value, mat.mat.colum3 / value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix24 operator +( Matrix24 left, Matrix24 right )
+        {
+            Matrix24 ret = new Matrix24();
+            InternalIO.Intrinsic.add_mat_4(&left.mat,&right.mat,&ret.mat);
+            return ret;
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Matrix32.cs

@@ -0,0 +1,220 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Matrix32.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal.Intrinsic;
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    [StructLayout(
+        LayoutKind.Explicit,
+        Size = ( 5 * 4 * sizeof( float ) ) + sizeof( bool ),
+        Pack = 16 )]
+    public struct Matrix32 : IMat
+    {
+
+        [FieldOffset( 5 * 4 * sizeof( float ) )] internal bool isTransposed;
+
+        [FieldOffset( 0 )] internal ColumnSet2 mat;
+        [FieldOffset( 2 * 4 * sizeof( float ) )] internal ColumnSet3 transpose;
+
+        [FieldOffset( 0 )] internal Vec3 colum0;
+        [FieldOffset( 4 * 4 )] internal Vec3 colum1;
+
+        public Matrix32()
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+        }
+
+        internal Matrix32( Vector4 c0, Vector4 c1 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = c0;
+            mat.colum1 = c1;
+        }
+
+        public unsafe Matrix32(
+            float a00,
+            float a01,
+            float a10,
+            float a11,
+            float a20,
+            float a21 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = new Vector4( a00, a10, a20, 0 );
+            mat.colum1 = new Vector4( a01, a11, a21, 0 );
+        }
+
+        public unsafe float this[ int rowNum, int columNum ]
+        {
+            get
+            {
+                if( ( rowNum > 2 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 1 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    return *( float* )pbit;
+                }
+            }
+            set
+            {
+                if( ( rowNum > 2 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 1 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    *( float* )pbit = value;
+                }
+                isTransposed = false;
+            }
+        }
+
+        public Vec3 VerticalVecMultiply( Vec2 vec )
+        {
+            return ( colum0 * vec.X ) + ( colum1 * vec.Y );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        internal unsafe void InternalTranspose()
+        {
+            if( !isTransposed ) {
+                fixed( ColumnSet2* source = &this.mat ) {
+                    fixed( ColumnSet3* target = &this.transpose ) {
+                        InternalIO.Intrinsic.transpose23( source, target );
+                    }
+                }
+
+                isTransposed = true;
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix32 operator -( Matrix32 left, Matrix32 right )
+        {
+            return new Matrix32(
+                left.mat.colum0 - right.mat.colum0,
+                left.mat.colum1 - right.mat.colum1 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix32 operator *( Matrix32 mat, float value )
+        {
+            return new Matrix32(
+                mat.mat.colum0 * value, mat.mat.colum1 * value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix32 operator *( Matrix32 left, Matrix22 right )
+        {
+            left.InternalTranspose();
+            return new Matrix32(
+                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.colum2, right._mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right._mat.colum1 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix33 operator *( Matrix32 left, Matrix23 right )
+        {
+            left.InternalTranspose();
+            return new Matrix33(
+                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.colum2, right._mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right._mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right._mat.colum2 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix34 operator *( Matrix32 left, Matrix24 right )
+        {
+            left.InternalTranspose();
+            return new Matrix34(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum2 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum3 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix32 operator /( Matrix32 mat, float value )
+        {
+            return new Matrix32(
+                mat.mat.colum0 / value, mat.mat.colum1 / value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix32 operator +( Matrix32 left, Matrix32 right )
+        {
+            Matrix32 ret = new Matrix32();
+            InternalIO.Intrinsic.add_mat_2(&left.mat, &right.mat, &ret.mat);
+            return ret;
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Matrix33.cs

@@ -0,0 +1,240 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Matrix33.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal.Intrinsic;
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    [StructLayout(
+        LayoutKind.Explicit,
+        Size = ( 6 * 4 * sizeof( float ) ) + sizeof( bool ),
+        Pack = 16 )]
+    public struct Matrix33 : IMat
+    {
+
+        [FieldOffset( 6 * 4 * sizeof( float ) )] internal bool isTransposed;
+
+        [FieldOffset( 0 )] internal ColumnSet3 mat;
+        [FieldOffset( 3 * 4 * sizeof( float ) )] internal ColumnSet3 transpose;
+        [FieldOffset( 0 * 4 * sizeof( float ) )] public Vec3 Colum0;
+        [FieldOffset( 1 * 4 * sizeof( float ) )] public Vec3 Colum1;
+        [FieldOffset( 2 * 4 * sizeof( float ) )] public Vec3 Colum2;
+
+        public Matrix33()
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+        }
+
+        internal Matrix33( Vector4 c0, Vector4 c1, Vector4 c2 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = c0;
+            mat.colum1 = c1;
+            mat.colum2 = c2;
+        }
+
+        public Matrix33(
+            float a00,
+            float a01,
+            float a02,
+            float a10,
+            float a11,
+            float a12,
+            float a20,
+            float a21,
+            float a22 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = new Vector4( a00, a10, a20, 0 );
+            mat.colum1 = new Vector4( a01, a11, a21, 0 );
+            mat.colum2 = new Vector4( a02, a12, a22, 0 );
+        }
+
+        public unsafe float this[ int rowNum, int columNum ]
+        {
+            get
+            {
+                if( ( rowNum > 2 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 2 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    return *( float* )pbit;
+                }
+            }
+            set
+            {
+                if( ( rowNum > 2 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 2 ) || ( columNum < 0 ) ) {
+                    InternalIO.InternalWriteLog(
+                        $"Attempt to write unused space in {GetType().Name} {nameof(mat)}",
+                        LogType.Error );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    *( float* )pbit = value;
+                }
+                isTransposed = false;
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe float Det()
+        {
+            fixed( ColumnSet3* mat = &this.mat ) {
+                return InternalIO.Intrinsic.det_mat_3( mat, ( ColumnSet3* )0 );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        internal unsafe void InternalTranspose()
+        {
+            if( !isTransposed ) {
+                fixed( ColumnSet3* source = &this.mat, target = &this.transpose ) {
+                    InternalIO.Intrinsic.transpose33( source, target );
+                }
+                isTransposed = true;
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix33 operator -( Matrix33 left, Matrix33 right )
+        {
+            return new Matrix33(
+                left.mat.colum0 - right.mat.colum0,
+                left.mat.colum1 - right.mat.colum1,
+                left.mat.colum2 + right.mat.colum2 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix33 operator *( Matrix33 mat, float value )
+        {
+            return new Matrix33(
+                mat.mat.colum0 * value, mat.mat.colum1 * value,
+                mat.mat.colum2 * value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec3 operator *( Matrix33 left, Vec3 right )
+        {
+            left.InternalTranspose();
+            return new Vec3(
+                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 Matrix32 operator *( Matrix33 left, Matrix32 right )
+        {
+            left.InternalTranspose();
+            return new Matrix32(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix33 operator *( Matrix33 left, Matrix33 right )
+        {
+            left.InternalTranspose();
+            return new Matrix33(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum2 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix34 operator *( Matrix33 left, Matrix34 right )
+        {
+            left.InternalTranspose();
+            return new Matrix34(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum2 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum3 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix33 operator /( Matrix33 mat, float value )
+        {
+            return new Matrix33(
+                mat.mat.colum0 / value, mat.mat.colum1 / value,
+                mat.mat.colum2 / value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix33 operator +( Matrix33 left, Matrix33 right )
+        {
+            Matrix33 ret = new Matrix33();
+            InternalIO.Intrinsic.add_mat_3(&left.mat, &right.mat, &ret.mat);
+            return ret;
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Matrix34.cs

@@ -0,0 +1,239 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Matrix34.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal.Intrinsic;
+
+using System;
+using System.Drawing;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    [StructLayout(
+        LayoutKind.Explicit,
+        Size = ( 7 * 4 * sizeof( float ) ) + sizeof( bool ),
+        Pack = 16 )]
+    public struct Matrix34 : IMat
+    {
+
+        [FieldOffset( 7 * 4 * sizeof( float ) )] internal bool isTransposed;
+        [FieldOffset( 4 * 4 * sizeof( float ) )] internal ColumnSet3 transpose;
+
+        [FieldOffset( 0 )] internal ColumnSet4 mat;
+
+        [FieldOffset( 0 * 4 * sizeof( float ) )] public Vec3 Colum0;
+        [FieldOffset( 1 * 4 * sizeof( float ) )] public Vec3 Colum1;
+        [FieldOffset( 2 * 4 * sizeof( float ) )] public Vec3 Colum2;
+        [FieldOffset( 3 * 4 * sizeof( float ) )] public Vec3 Colum3;
+
+        public Matrix34()
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+        }
+
+        internal Matrix34( ColumnSet4 mat )
+        {
+            Unsafe.SkipInit( out this );
+            isTransposed = false;
+            this.mat = mat;
+        }
+
+        internal Matrix34( Vector4 c0, Vector4 c1, Vector4 c2, Vector4 c3 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = c0;
+            mat.colum1 = c1;
+            mat.colum2 = c2;
+            mat.colum3 = c3;
+        }
+
+        public Matrix34(
+            float a00,
+            float a01,
+            float a02,
+            float a03,
+            float a10,
+            float a11,
+            float a12,
+            float a13,
+            float a20,
+            float a21,
+            float a22,
+            float a23 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = new Vector4( a00, a10, a20, 0 );
+            mat.colum0 = new Vector4( a01, a11, a21, 0 );
+            mat.colum0 = new Vector4( a02, a12, a22, 0 );
+            mat.colum0 = new Vector4( a03, a13, a23, 0 );
+        }
+
+        public unsafe float this[ int rowNum, int columNum ]
+        {
+            get
+            {
+                if( ( rowNum > 2 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 3 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    return *( float* )pbit;
+                }
+            }
+            set
+            {
+                if( ( rowNum > 2 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 3 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    *( float* )pbit = value;
+                }
+                isTransposed = false;
+            }
+        }
+
+        internal unsafe void InternalTranspose()
+        {
+            if( !isTransposed ) {
+                fixed( ColumnSet4* source = &this.mat ) {
+                    fixed( ColumnSet3* target = &this.transpose ) {
+                        InternalIO.Intrinsic.transpose43( source, target );
+                    }
+                }
+
+                isTransposed = true;
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix34 operator -( Matrix34 left, Matrix34 right )
+        {
+            return new Matrix34(
+                left.mat.colum0 - right.mat.colum0,
+                left.mat.colum1 - right.mat.colum1,
+                left.mat.colum2 - right.mat.colum2,
+                left.mat.colum3 - right.mat.colum3 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix34 operator *( Matrix34 mat, float value )
+        {
+            return new Matrix34(
+                mat.mat.colum0 * value, mat.mat.colum1 * value,
+                mat.mat.colum2 * value, mat.mat.colum3 * value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix32 operator *( Matrix34 left, Matrix42 right )
+        {
+            left.InternalTranspose();
+            return new Matrix32(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix33 operator *( Matrix34 left, Matrix43 right )
+        {
+            left.InternalTranspose();
+            return new Matrix33(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum2 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix34 operator *( Matrix34 left, Matrix44 right )
+        {
+            left.InternalTranspose();
+            return new Matrix34(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum2 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum3 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix34 operator /( Matrix34 mat, float value )
+        {
+            return new Matrix34(
+                mat.mat.colum0 / value, mat.mat.colum1 / value,
+                mat.mat.colum2 / value, mat.mat.colum3 / value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix34 operator +( Matrix34 left, Matrix34 right )
+        {
+            Matrix34 ret = new Matrix34();
+            InternalIO.Intrinsic.add_mat_4(&left.mat,&right.mat,&ret.mat);
+            return ret;
+
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Matrix42.cs

@@ -0,0 +1,243 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Matrix42.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal.Intrinsic;
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    [StructLayout(
+        LayoutKind.Explicit,
+        Size = ( ( 16 + 8 ) * sizeof( float ) ) + sizeof( bool ),
+        Pack = 16 )]
+    public struct Matrix42 : IMat
+    {
+
+        [FieldOffset( ( 16 + 8 ) * sizeof( float ) )] internal bool isTransposed;
+
+        [FieldOffset( 0 )] internal ColumnSet2 mat;
+        [FieldOffset( 8 * sizeof( float ) )] internal ColumnSet4 transpose;
+
+        public Matrix42()
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+        }
+
+        internal Matrix42( ColumnSet2 mat )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            this.mat = mat;
+        }
+
+        internal Matrix42( Vector4 c0, Vector4 c1 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed= false;
+            mat.colum0 = c0;
+            mat.colum1 = c1;
+        }
+
+        public Matrix42(
+            float a00,
+            float a01,
+            float a10,
+            float a11,
+            float a20,
+            float a21,
+            float a30,
+            float a31 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = new Vector4( a00, a10, a20, a30 );
+            mat.colum1 = new Vector4( a01, a11, a21, a31 );
+        }
+
+        public unsafe float this[ int rowNum, int columNum ]
+        {
+            get
+            {
+                if( ( rowNum > 3 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 1 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    return *( float* )pbit;
+                }
+            }
+            set
+            {
+                if( ( rowNum > 3 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 1 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    *( float* )pbit = value;
+                }
+                isTransposed = false;
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(
+                mat.colum0.GetHashCode(), mat.colum1.GetHashCode() );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        internal unsafe void InternalTranspose()
+        {
+            if( !isTransposed ) {
+                fixed( ColumnSet2* source = &this.mat ) {
+                    fixed( ColumnSet4* target = &this.transpose ) {
+                        InternalIO.Intrinsic.transpose24( source, target );
+                    }
+                }
+
+                isTransposed = true;
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix42 operator -(
+            Matrix42 left,
+            Matrix42 right )
+        {
+            return new Matrix42(
+                left.mat.colum0 - right.mat.colum0,
+                left.mat.colum0 - right.mat.colum0 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix42 operator *( Matrix42 mat, float value )
+        {
+            return new Matrix42(
+                mat.mat.colum0 * value, mat.mat.colum1 * value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix42 operator *( Matrix42 left, Matrix22 right )
+        {
+            left.InternalTranspose();
+            return new Matrix42(
+                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.colum2, right._mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right._mat.colum1 ),
+
+                Vector4.Dot( left.transpose.colum3, right._mat.colum0 ),
+                Vector4.Dot( left.transpose.colum3, right._mat.colum1 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix43 operator *( Matrix42 left, Matrix23 right )
+        {
+            left.InternalTranspose();
+            return new Matrix43(
+                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.colum2, right._mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right._mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right._mat.colum2 ),
+
+                Vector4.Dot( left.transpose.colum3, right._mat.colum0 ),
+                Vector4.Dot( left.transpose.colum3, right._mat.colum1 ),
+                Vector4.Dot( left.transpose.colum3, right._mat.colum2 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix44 operator *( Matrix42 left, Matrix24 right )
+        {
+            left.InternalTranspose();
+            return new Matrix44(
+                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.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.colum2 ),
+
+                Vector4.Dot( left.transpose.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum2 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum2 ),
+
+                Vector4.Dot( left.transpose.colum3, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum2 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum2 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix42 operator /( Matrix42 mat, float value )
+        {
+            return new Matrix42(
+                mat.mat.colum0 / value, mat.mat.colum1 / value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix42 operator +(
+            Matrix42 left,
+            Matrix42 right )
+        {
+            return new Matrix42(
+                left.mat.colum0 + right.mat.colum0,
+                left.mat.colum0 + right.mat.colum0 );
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Matrix43.cs

@@ -0,0 +1,266 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Matrix43.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal.Intrinsic;
+
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security.AccessControl;
+
+namespace StgSharp.Math
+{
+    [StructLayout(
+        layoutKind: LayoutKind.Explicit,
+        Size = ( 7 * 4 * sizeof( float ) ) + sizeof( bool ),
+        Pack = 16 )]
+    public struct Matrix43 : IEquatable<Matrix43>, IMat
+    {
+
+        [FieldOffset( 7 * 4 * sizeof( float ) )]
+        internal bool isTransposed;
+
+        [FieldOffset( 0 )]
+        internal ColumnSet3 mat;
+        [FieldOffset( 3 * 4 * sizeof( float ) )]
+        internal ColumnSet4 transpose;
+
+        public Matrix43()
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+        }
+
+        internal Matrix43( Vector4 c0, Vector4 c1, Vector4 c2 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = c0;
+            mat.colum1 = c1;
+            mat.colum2 = c2;
+        }
+
+        public Matrix43(
+            float a00,
+            float a01,
+            float a02,
+            float a10,
+            float a11,
+            float a12,
+            float a20,
+            float a21,
+            float a22,
+            float a30,
+            float a31,
+            float a32 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = new Vector4( a00, a10, a20, a30 );
+            mat.colum1 = new Vector4( a01, a11, a21, a31 );
+            mat.colum2 = new Vector4( a02, a12, a22, a32 );
+        }
+
+        public unsafe float this[ int rowNum, int columNum ]
+        {
+            get
+            {
+                if( ( rowNum > 3 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 2 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    return *( float* )pbit;
+                }
+            }
+            set
+            {
+                if( ( rowNum > 3 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 2 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    *( float* )pbit = value;
+                }
+                isTransposed = false;
+            }
+        }
+
+        public override bool Equals( object? obj )
+        {
+            return ( obj is Matrix43 x ) && Equals( x );
+        }
+
+        public bool Equals( Matrix43 other )
+        {
+            return EqualityComparer<ColumnSet3>.Default.Equals( mat,
+                                                                other.mat );
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(
+                mat.colum0.GetHashCode(), mat.colum1.GetHashCode(),
+                mat.colum2.GetHashCode() );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        internal unsafe void InternalTranspose()
+        {
+            if( !isTransposed ) {
+                fixed( ColumnSet3* source = &this.mat )
+                fixed( ColumnSet4* target = &this.transpose ) {
+                    InternalIO.Intrinsic.transpose34( source, target );
+                }
+                isTransposed = true;
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix43 operator -( Matrix43 left, Matrix43 right )
+        {
+            return new Matrix43(
+                left.mat.colum0 - right.mat.colum0,
+                left.mat.colum1 - right.mat.colum1,
+                left.mat.colum2 - right.mat.colum2 );
+        }
+
+        public static bool operator !=( Matrix43 left, Matrix43 right )
+        {
+            return !( left == right );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix43 operator *( Matrix43 mat, float value )
+        {
+            return new Matrix43(
+                mat.mat.colum0 * value, mat.mat.colum1 * value,
+                mat.mat.colum2 * value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix42 operator *( Matrix43 left, Matrix32 right )
+        {
+            left.InternalTranspose();
+            return new Matrix42(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ),
+
+                Vector4.Dot( left.transpose.colum3, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum1 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix43 operator *( Matrix43 left, Matrix33 right )
+        {
+            left.InternalTranspose();
+            return new Matrix43(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum2 ),
+
+                Vector4.Dot( left.transpose.colum3, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum2 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix44 operator *( Matrix43 left, Matrix34 right )
+        {
+            left.InternalTranspose();
+            return new Matrix44(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum2 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum3 ),
+
+                Vector4.Dot( left.transpose.colum3, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum2 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum3 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix43 operator /( Matrix43 mat, float value )
+        {
+            return new Matrix43(
+                mat.mat.colum0 / value, mat.mat.colum1 / value,
+                mat.mat.colum2 / value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix43 operator +( Matrix43 left, Matrix43 right )
+        {
+            Matrix43 ret = new Matrix43();
+            InternalIO.Intrinsic.add_mat_3(&left.mat, &right.mat, &ret.mat);
+            return ret;
+        }
+
+        public static bool operator ==( Matrix43 left, Matrix43 right )
+        {
+            return left.Equals( right );
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Matrix44.cs

@@ -0,0 +1,324 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Matrix44.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal.Intrinsic;
+
+using System;
+using System.ComponentModel;
+using System.Drawing;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    [StructLayout(
+        LayoutKind.Explicit,
+        Size = ( 2 * 16 * sizeof( float ) ) + sizeof( bool ),
+        Pack = 16 )]
+    public unsafe struct Matrix44 : IEquatable<Matrix44>, IMat
+    {
+
+        [FieldOffset( 2 * 64 * sizeof( float ) )] internal bool isTransposed;
+
+        [FieldOffset( 0 )] internal ColumnSet4 mat;
+        [FieldOffset( 16 * sizeof( float ) )] internal ColumnSet4 transpose;
+        [FieldOffset( 0 * sizeof( float ) )] internal Vec4 colum0;
+        [FieldOffset( 4 * sizeof( float ) )] internal Vec4 colum1;
+        [FieldOffset( 8 * sizeof( float ) )] internal Vec4 colum2;
+        [FieldOffset( 12 * sizeof( float ) )] internal Vec4 colum3;
+
+        public Matrix44()
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+        }
+
+        internal Matrix44( ColumnSet4 mat )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            this.mat = mat;
+        }
+
+        internal Matrix44(
+            Vector4 vec0,
+            Vector4 vec1,
+            Vector4 vec2,
+            Vector4 vec3 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = vec0;
+            mat.colum1 = vec1;
+            mat.colum2 = vec2;
+            mat.colum3 = vec3;
+        }
+
+        public unsafe Matrix44(
+            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 )
+        {
+            Unsafe.SkipInit(out this);
+            isTransposed = false;
+            mat.colum0 = new Vector4( a00, a10, a20, a30 );
+            mat.colum1 = new Vector4( a01, a11, a21, a31 );
+            mat.colum2 = new Vector4( a02, a12, a22, a32 );
+            mat.colum3 = new Vector4( a03, a13, a23, a33 );
+        }
+
+        public unsafe float this[ int rowNum, int columNum ]
+        {
+            get
+            {
+                #if DEBUG
+                if( ( rowNum > 3 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 3 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                #endif
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    return *( float* )pbit;
+                }
+            }
+            set
+            {
+                #if DEBUG
+                if( ( rowNum > 3 ) || ( rowNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                if( ( columNum > 3 ) || ( columNum < 0 ) ) {
+                    throw new ArgumentOutOfRangeException( nameof( columNum ) );
+                }
+                #endif
+                InternalTranspose();
+                fixed( float* p = &this.transpose.m00 ) {
+                    ulong pbit = ( ( ulong )p ) + ( ( ( ulong )sizeof( Vector4 ) ) * ( ( ulong )rowNum ) ) + ( ( ( ulong )sizeof( float ) ) * ( ( ulong )columNum ) );
+                    *( float* )pbit = value;
+                }
+                isTransposed = false;
+            }
+        }
+
+        public Matrix44 Transpose
+        {
+            get
+            {
+                InternalTranspose();
+                return new Matrix44( this.transpose );
+            }
+        }
+
+        public static Matrix44 Unit => new Matrix44(
+            1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 );
+
+        public static Matrix44 WNegativeUnit => new Matrix44(
+            1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1 );
+
+        public static Matrix44 XNegativeUnit => new Matrix44(
+            -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 );
+
+        public static Matrix44 YNegativeUnit => new Matrix44(
+            1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 );
+
+        public static Matrix44 ZNegativeUnit => new Matrix44(
+            1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1 );
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe float Det()
+        {
+            InternalTranspose();
+            fixed( ColumnSet4* _this = &mat, _trans = &transpose ) {
+                return InternalIO.Intrinsic.det_mat_4( _this, _trans );
+            }
+        }
+
+        public override bool Equals( object? obj )
+        {
+            return ( obj is Matrix44 x ) && Equals( x );
+        }
+
+        public bool Equals( Matrix44 other )
+        {
+            return mat.Equals( other.mat );
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(
+                mat.colum0.GetHashCode(), mat.colum1.GetHashCode(),
+                mat.colum2.GetHashCode(), mat.colum3.GetHashCode() );
+        }
+
+        public override string ToString()
+        {
+            InternalTranspose();
+            return $"{transpose.colum0}{transpose.colum1}{transpose.colum2}{transpose.colum3}";
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        internal unsafe void InternalTranspose()
+        {
+            if( !isTransposed ) {
+                fixed( ColumnSet4* source = &mat, target = &transpose ) {
+                    InternalIO.Intrinsic.transpose44( source, target );
+                }
+                isTransposed = true;
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix44 operator -(
+            Matrix44 left,
+            Matrix44 right )
+        {
+            return new Matrix44(
+                right.mat.colum0 - left.mat.colum0,
+                right.mat.colum1 - left.mat.colum1,
+                right.mat.colum2 - left.mat.colum2,
+                right.mat.colum3 - left.mat.colum3 );
+        }
+
+        public static bool operator !=( Matrix44 left, Matrix44 right )
+        {
+            return !( left == right );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix44 operator *( Matrix44 mat, float value )
+        {
+            return new Matrix44(
+                mat.mat.colum0 * value, mat.mat.colum1 * value,
+                mat.mat.colum2 * value, mat.mat.colum3 * value );
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe Matrix42 Multiple(in Matrix42 right)
+        {
+            InternalTranspose();
+            Matrix42 ans = new Matrix42();
+            fixed (ColumnSet4* lptr = &transpose)
+            fixed (Vector4* rptr = &right.mat.colum0)
+            {
+                InternalIO.Intrinsic.dot_42(lptr,rptr, &ans.mat.colum0);
+            }
+            return ans;
+        }
+
+        [Obsolete("The operand may cause performance loss, use Matrix.Multiple() method instead.",false)]
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix42 operator *(
+            Matrix44 left,
+            Matrix42 right )
+        {
+            return left.Multiple(right);
+        }
+
+        public unsafe Matrix43 Multiple(in Matrix43 right)
+        {
+            InternalTranspose();
+
+            Matrix43 ans = new Matrix43();
+
+            fixed(Vector4* rptr = &right.mat.colum0)
+            fixed (ColumnSet4* lptr = &transpose)
+            {
+                InternalIO.Intrinsic.dot_43(lptr,rptr,&ans.mat.colum0);
+            }
+            return ans;
+        }
+
+        [Obsolete("The operand may cause performance loss, use Matrix.Multiple() method instead.", false)]
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix43 operator *( Matrix44 left, Matrix43 right )
+        {
+            return left.Multiple(in right);
+        }
+
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Matrix44 operator *( Matrix44 left, Matrix44 right )
+        {
+            left.InternalTranspose();
+            return new Matrix44(
+                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.colum2, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum2 ),
+                Vector4.Dot( left.transpose.colum2, right.mat.colum3 ),
+
+                Vector4.Dot( left.transpose.colum3, right.mat.colum0 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum1 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum2 ),
+                Vector4.Dot( left.transpose.colum3, right.mat.colum3 ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe Matrix44 operator +(Matrix44 left, Matrix44 right )
+        {
+            Matrix44 ret = new Matrix44();
+            InternalIO.Intrinsic.add_mat_4(&left.mat, &right.mat, &ret.mat);
+            return ret;
+        }
+
+        public static bool operator ==( Matrix44 left, Matrix44 right )
+        {
+            return left.Equals( right );
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Vec2.cs

@@ -0,0 +1,133 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Vec2.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    /// <summary>
+    /// A two dimension vector defined by two elements. Vec2Ds in StgSharp are default used as colum
+    /// vector.
+    /// </summary>
+    [StructLayout( LayoutKind.Explicit, Size = 16, Pack = 16 )]
+    public struct Vec2 : IVector
+    {
+
+        [FieldOffset( 0 )] internal unsafe fixed float num[ 2 ];
+
+        [FieldOffset( 0 )]
+        internal Vector2 v;
+
+        [FieldOffset( 0 )]
+        internal Vector4 vec;
+
+        [FieldOffset( 0 )]
+        public float X;
+        [FieldOffset( 4 )]
+        public float Y;
+
+        internal Vec2( Vector2 vec )
+        {
+            v = vec;
+        }
+
+        internal Vec2( Vector4 vec )
+        {
+            this.vec = vec;
+        }
+
+        public Vec2( float x, float y )
+        {
+            v = new Vector2( x, y );
+        }
+
+        public static Vec2 Unit => new Vec2( 1, 1 );
+
+        public static Vec2 Zero => new Vec2( 0, 0 );
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public float Cross( Vec2 right )
+        {
+            return ( X * right.Y ) - ( Y * right.X );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public float Dot( Vec2 vec )
+        {
+            return Vector2.Dot( v, vec.v );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec2 operator -( Vec2 left, Vec2 right )
+        {
+            return new Vec2( left.v - right.v );
+        }
+
+        public static bool operator !=( Vec2 left, Vec2 right )
+        {
+            return !( left == right );
+        }
+
+        public static Vec2 operator *( Vec2 vec, float value )
+        {
+            return new Vec2( vec.v * value );
+        }
+        public static Vec2 operator *( float value, Vec2 vec )
+        {
+            return new Vec2( vec.v * value );
+        }
+
+        public static Vec2 operator /( Vec2 vec, float value )
+        {
+            return new Vec2( vec.v / value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec2 operator +( Vec2 left, Vec2 right )
+        {
+            return new Vec2( left.v + right.v );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static bool operator ==( Vec2 left, Vec2 right )
+        {
+            return left.v == right.v;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static implicit operator Vec2( (float, float) tuple )
+        {
+            return new Vec2( tuple.Item1, tuple.Item2 );
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Vec3.cs

@@ -0,0 +1,226 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Vec3.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+
+using StgSharp.HighPerformance;
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    [StructLayout( LayoutKind.Explicit, Size = 16, Pack = 16 )]
+    public struct Vec3 : IEquatable<Vec3>, IVector
+    {
+
+        [FieldOffset( 0 )] internal unsafe fixed float num[ 3 ];
+        [FieldOffset( 0 )]
+        internal M128 reg;
+
+        [FieldOffset( 0 )]
+        internal Vector3 v;
+
+        [FieldOffset( 0 )]
+        internal Vector4 vec;
+
+        [FieldOffset( 0 )] public float X;
+        [FieldOffset( 4 )] public float Y;
+        [FieldOffset( 8 )] public float Z;
+
+        internal Vec3( Vector4 vector )
+        {
+            vec = vector;
+        }
+
+        internal Vec3( Vector3 vector )
+        {
+            v = vector;
+        }
+
+        public Vec3( Vec2 xy, float z )
+        {
+            vec = xy.vec;
+            Z = z;
+        }
+
+        public Vec3( float x, float y, float z )
+        {
+            #if NET5_0_OR_GREATER
+            Unsafe.SkipInit( out vec );
+            #endif
+            v = new Vector3( x, y, z );
+        }
+
+        public unsafe Vec2 XY
+        {
+            get => new Vec2( this.vec );
+            set
+            {
+                fixed( Vector3* vptr = &v ) {
+                    *( Vector2* )vptr = value.v;
+                }
+            }
+        }
+
+        public Vec3 XYZ
+        {
+            get { return new Vec3( v ); }
+        }
+
+        public static Vec3 Zero
+        {
+            get => new Vec3( 0, 0, 0 );
+        }
+
+        public static Vec3 One => new Vec3( 1, 1, 1 );
+
+        public static Vec3 UnitX => new Vec3( 1, 0, 0 );
+
+        public static Vec3 UnitY => new Vec3( 0, 1, 0 );
+
+        public static Vec3 UnitZ => new Vec3( 0, 0, 1 );
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec3 Cross( Vec3 left, Vec3 right )
+        {
+            return Linear.Cross( left, right );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public float Dot( Vec3 right )
+        {
+            return Vector3.Dot( v, right.v );
+        }
+
+        public bool Equals( Vec3 other )
+        {
+            return this.vec == other.vec;
+        }
+
+        public override bool Equals( object obj )
+        {
+            if( obj is Vec3 ) {
+                return this == ( Vec3 )obj;
+            } else {
+                return false;
+            }
+        }
+
+        public override unsafe int GetHashCode()
+        {
+            fixed( float* add = &X ) {
+                return HashCode.Combine( X, Y, Z, ( ulong )add );
+            }
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public float GetMaxValue()
+        {
+            float ret = X;
+            ret = ( ret > Y ) ? ret : Y;
+            ret = ( ret > Z ) ? ret : Z;
+            return ret;
+        }
+
+        public static bool IsParallel( Vec3 left, Vec3 right )
+        {
+            return Cross( left, right ) == Zero;
+        }
+
+        public override string ToString()
+        {
+            return $"[{X},{Y},{Z}]";
+        }
+
+        public string ToString( string sample )
+        {
+            return $"[{X.ToString(sample)},{Y.ToString(sample)},{Z.ToString(sample)}]";
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec3 operator -( Vec3 vec )
+        {
+            return new Vec3( -vec.vec );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec3 operator -( Vec3 left, Vec3 right )
+        {
+            return new Vec3( left.v - right.v );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static bool operator !=( Vec3 left, Vec3 right )
+        {
+            return left.v != right.v;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec3 operator *( Vec3 vec, float value )
+        {
+            return new Vec3( vec.v * value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static float operator *( Vec3 left, Vec3 right )
+        {
+            return Vector3.Dot( left.v, right.v );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec3 operator /( Vec3 vec, float value )
+        {
+            return new Vec3( vec.v / value );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec3 operator +( Vec3 left, Vec3 right )
+        {
+            return new Vec3( left.vec + right.vec );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static bool operator ==( Vec3 left, Vec3 right )
+        {
+            return left.v == right.v;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe implicit operator Vec3(
+                                                       (float, float, float) tuple )
+        {
+            Vec3 v = *( Vec3* )&tuple;
+            v.vec.W = 0.0f;
+            return v;
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Vec4.cs

@@ -0,0 +1,171 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Vec4.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.HighPerformance;
+using StgSharp.Internal.Intrinsic;
+using StgSharp.Math;
+
+using System;
+using System.Data.Common;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    [StructLayout( LayoutKind.Explicit, Size = 16, Pack = 16 )]
+    public struct Vec4 : IEquatable<Vec4>, IVector
+    {
+
+        [FieldOffset( 0 )] internal unsafe fixed float num[ 4 ];
+
+        [FieldOffset( 0 )] internal M128 reg;
+
+        [FieldOffset( 0 )] internal Vector4 vec;
+        [FieldOffset( 12 )] public float W;
+
+        [FieldOffset( 0 )] public float X;
+        [FieldOffset( 4 )] public float Y;
+        [FieldOffset( 8 )] public float Z;
+
+        internal Vec4( Vector4 v )
+        {
+            vec = v;
+        }
+
+        public Vec4( Vec3 v, float w )
+        {
+            vec = v.vec;
+            W = w;
+        }
+
+        public Vec4( float x, float y, float z, float w )
+        {
+            vec = new Vector4( x, y, z, w );
+        }
+
+        public unsafe Vec2 XY
+        {
+            get => new Vec2( vec );
+            set
+            {
+                X = value.X;
+                Y = value.Y;
+            }
+        }
+
+        public unsafe Vec3 XYZ
+        {
+            get => new Vec3( vec );
+            set
+            {
+                float w = W;
+                vec = value.vec;
+                W = w;
+            }
+        }
+
+        public static Vec4 One
+        {
+            get => new Vec4( Vector4.One );
+        }
+
+        public static Vec4 Zero
+        {
+            get => new Vec4( Vector4.Zero );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec4 Add( Vec4 left, Vec4 right )
+        {
+            return left + right;
+        }
+
+        public override bool Equals( object obj )
+        {
+            return ( obj is Vec4 v ) ? ( v == this ) : false;
+        }
+
+        public override int GetHashCode()
+        {
+            return vec.GetHashCode();
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec4 Subtract( Vec4 left, Vec4 right )
+        {
+            return left - right;
+        }
+
+        public override string ToString()
+        {
+            return vec.ToString();
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec4 operator -( Vec4 left, Vec4 right )
+        {
+            return new Vec4( left.vec - right.vec );
+        }
+
+        public static bool operator !=( Vec4 left, Vec4 right )
+        {
+            return !( left == right );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec4 operator *( Matrix44 mat, Vec4 vec )
+        {
+            mat.InternalTranspose();
+            return new Vec4(
+                Vector4.Dot( mat.transpose.colum0, vec.vec ),
+                Vector4.Dot( mat.transpose.colum1, vec.vec ),
+                Vector4.Dot( mat.transpose.colum2, vec.vec ),
+                Vector4.Dot( mat.transpose.colum3, vec.vec ) );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec4 operator +( Vec4 left, Vec4 right )
+        {
+            return new Vec4( left.vec + right.vec );
+        }
+
+        public static bool operator ==( Vec4 left, Vec4 right )
+        {
+            return left.vec == right.vec;
+        }
+
+        bool IEquatable<Vec4>.Equals( Vec4 other )
+        {
+            return vec == other.vec;
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Vector.Cross.cs

@@ -0,0 +1,50 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Vector.Cross.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp.Math
+{
+    public static unsafe partial class Linear
+    {
+
+        public static float Cross( Vec2 vec1, Vec2 vec2 )
+        {
+            return ( vec1.X * vec2.Y ) - ( vec1.Y * vec2.X );
+        }
+
+        public static Vec3 Cross( Vec3 vec1, Vec3 vec2 )
+        {
+            return new Vec3(
+                ( 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.Common/Math/Linear/Vector.GetAngle.cs

@@ -0,0 +1,51 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Vector.GetAngle.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp.Math
+{
+    public static unsafe partial class Linear
+    {
+
+        public static float GetAngle( Vec2 vec1, Vec2 vec2 )
+        {
+            return Scaler.ACos(
+                1
+ //vec1.multiple(vec2)
+ / ( vec1.GetLength() * vec2.GetLength() ) );
+        }
+
+        public static float GetAngle( Vec3 vec1, Vec3 vec2 )
+        {
+            return Scaler.ACos(
+                ( vec1 * vec2 ) / ( vec1.GetLength() * vec2.GetLength() ) );
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Vector.GetLength.cs

@@ -0,0 +1,47 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Vector.GetLength.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp.Math
+{
+    public static unsafe partial class Linear
+    {
+
+        public static float GetLength( this Vec3 vec )
+        {
+            return Scaler.Sqrt( vec.Dot( vec ) );
+        }
+
+        public static float GetLength( this Vec2 vec )
+        {
+            return Scaler.Sqrt( vec.Dot( vec ) );
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Vector.Normalize.cs

@@ -0,0 +1,89 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Vector.Normalize.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Math
+{
+    public static partial class Linear
+    {
+
+        public static Vec4 Normalize( Vec4 vec )
+        {
+            return new Vec4 { vec = Vector4.Normalize( vec.vec ) };
+        }
+
+        public static Vec3 Normalize( Vec3 vec )
+        {
+            return new Vec3 { vec = Vector4.Normalize( vec.vec ) };
+        }
+
+        public static unsafe void Normalize( ref Vec4 source, ref Vec4 target )
+        {
+            Vector4 s = source.vec;
+            Vector4 t = target.vec;
+
+            s = Vector4.Normalize( s );
+
+            float dotProduct = Vector4.Dot( s, t );
+            Vector4 projection = Vector4.Multiply( s, t );
+
+            t -= projection;
+
+            source.vec = s;
+            target.vec = t;
+        }
+
+        public static unsafe void Normalize( ref Vec3 source, ref Vec3 target )
+        {
+            Vector3 s = source.v;
+            Vector3 t = target.v;
+
+            s = Vector3.Normalize( s );
+            Vector3 projection = ( Vector3.Dot( t, s ) / Vector3.Dot( s,
+                                                                      s ) ) * s;
+            t -= projection;
+            t = Vector3.Normalize( t );
+
+            source.v = s;
+            target.v = t;
+        }
+
+    }
+}

StgSharp.Common/Math/Linear/Vector.Orthogonalize.cs

@@ -0,0 +1,99 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Vector.Orthogonalize.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Internal.Intrinsic;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Math
+{
+    public static partial class Linear
+    {
+
+        public static Vec4 Orthogonalize( Vec4 vec )
+        {
+            return new Vec4 { vec = Vector4.Normalize( vec.vec ) };
+        }
+
+        public static Vec3 Orthogonalize( Vec3 vec )
+        {
+            return new Vec3 { vec = Vector4.Normalize( vec.vec ) };
+        }
+
+        public static unsafe void Orthogonalize(
+            ref Vec4 source,
+            ref Vec4 target )
+        {
+            Vector4 s = source.vec;
+            Vector4 t = target.vec;
+
+            s = Vector4.Normalize( s );
+
+            float dotProduct = Vector4.Dot( s, t );
+            Vector4 projection = Vector4.Multiply( s, t );
+
+            t -= projection;
+
+            source.vec = s;
+            target.vec = t;
+        }
+
+        /// <summary>
+        /// Orthogonalize two <see cref="Vec3" />s, let their length be 1 and perpendicular to each
+        /// other.
+        /// </summary>
+        /// <param _name="source"></param>
+        /// <param _name="target"></param>
+        public static unsafe void Orthogonalize(
+            ref Vec3 source,
+            ref Vec3 target )
+        {
+            Vector3 s = source.v;
+            Vector3 t = target.v;
+
+            s = Vector3.Normalize( s );
+            Vector3 projection = ( Vector3.Dot( t, s ) / Vector3.Dot( s,
+                                                                      s ) ) * s;
+            t -= projection;
+            t = Vector3.Normalize( t );
+
+            source.v = s;
+            target.v = t;
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/ACos.cs

@@ -0,0 +1,110 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ACos.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Scaler
+    {
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe float ACos( float x )
+        {
+            return MathF.Acos( x );
+
+            /*
+                        int sign = 1;
+                        float y;
+
+                        if (x < 0)
+                        {
+                            sign = -1;
+                            y = -x;
+                        }
+                        else
+                        {
+                            y = x;
+                        }
+
+                        if (x > 1)
+                        {
+                            throw new ArgumentException();
+                        }
+
+                        float r, s, u, v = 0.0f;
+                        bool transform = (y >= 0.5f);
+
+                        if (transform)
+                        {
+                            r = 0.5f * (1.0f - y);
+                            s = Scaler.Sqrt(r);
+                            y = s;
+                        }
+                        else
+                        {
+                            r = y * y;
+                        }
+                        u = r * (0.184161606965100694821398249421F +
+                               (-0.0565298683201845211985026327361F +
+                               (-0.0133819288943925804214011424456F -
+                               0.00396137437848476485201154797087F * r) * r) * r) /
+                              (1.10496961524520294485512696706F -
+                               0.836411276854206731913362287293F * r);
+                        /*
+
+            if (transform)
+            {
+                float c, s1, p, q;
+                uint us;
+
+                us = *(uint*)&s;
+                uint uss = us & 0xffff0000;
+                s1 = *(float*)&uss;
+
+                c = (r - s1 * s1) / (s + s1);
+                p = 2.0F * s * u - (piby2_tail - 2.0F * c);
+                q = hpiby2_head - 2.0F * s1;
+                v = hpiby2_head - (p - q);
+            }
+            else
+            {
+                v = y + y * u;
+            }
+
+            v = sign * v;
+
+            return piby2 - v;
+            */
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/ASin.cs

@@ -0,0 +1,116 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ASin.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Scaler
+    {
+
+        private const float
+        piby2_tail = 7.5497894159e-08f, /* 0x33a22168 */
+        hpiby2_head = 7.8539812565e-01f, /* 0x3f490fda */
+        piby2 = 1.5707963705e+00f; /* 0x3fc90fdb */
+
+        /// <summary>
+        /// Reurns the value of ArcSin(x)
+        /// </summary>
+        /// <param _name="x"> The sine value of the angle </param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentException"></exception>
+        public static float ASin( float x )
+        {
+            return MathF.Asin( x );
+            /*
+            int sign = 1;
+            float y;
+
+            if (x < 0)
+            {
+                sign = -1;
+                y = -x;
+            }
+            else
+            {
+                y = x;
+            }
+
+            if (x > 1)
+            {
+                throw new ArgumentException();
+            }
+
+            float r, s, u, v = 0.0f;
+            bool transform = (y >= 0.5f);
+
+            if (transform)
+            {
+                r = 0.5f * (1.0f - y);
+                s = Scaler.Sqrt(r);
+                y = s;
+            }
+            else
+            {
+                r = y * y;
+            }
+            u = r * (0.184161606965100694821398249421F +
+                   (-0.0565298683201845211985026327361F +
+                   (-0.0133819288943925804214011424456F -
+                   0.00396137437848476485201154797087F * r) * r) * r) /
+                  (1.10496961524520294485512696706F -
+                   0.836411276854206731913362287293F * r);
+            /*
+
+            if (transform)
+            {
+                float c, s1, p, q;
+                uint us;
+
+                us = *(uint*)&s;
+                uint uss = us & 0xffff0000;
+                s1 = *(float*)&uss;
+
+                c = (r - s1 * s1) / (s + s1);
+                p = 2.0F * s * u - (piby2_tail - 2.0F * c);
+                q = hpiby2_head - 2.0F * s1;
+                v = hpiby2_head - (p - q);
+            }
+            else
+            {
+                v = y + y * u;
+            }/*
+
+            return sign * v;
+            */
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/ATan.cs

@@ -0,0 +1,119 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ATan.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Scaler
+    {
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe float ATan( float x )
+        {
+            return MathF.Atan( x );
+            /*
+            float sign = 1, angle = 0;
+            if (x < 0)
+            {
+                sign = -1;
+                x = -x;
+            }
+            uint xBit = *(uint*)&x;
+            int xExp = (int)(xBit >> 23) - 127;
+            if (xExp >= 26)
+            {
+                return 1;
+            }
+            if (xExp <= -15)
+            {
+                return x;
+            }
+            if (xExp >= 0)
+            {
+                x = (x - 1) / (x + 1);
+                angle = 0.7853981634f;
+            }
+
+            float v = 0.7853981634f * x + x * (1 - x) * (0.2447f + 0.0663f * x);
+            v += angle;
+            v *= sign;
+
+            return v;
+
+
+        }
+
+
+        public static unsafe float ATan(float x, float y)
+        {
+
+
+            float z = y / x;
+
+            float sign = 1, angle = 0, angle2 = 0;
+            if (x < 0)
+            {
+                angle = -3.1415926535f;
+            }
+            if (z < 0)
+            {
+                sign = -1;
+                z = -z;
+            }
+            uint zBit = *(uint*)&z;
+            int zExp = (int)(zBit >> 23) - 127;
+            if (zExp >= 26)
+            {
+                return 1;
+            }
+            if (zExp <= -15)
+            {
+                return z;
+            }
+            if (zExp >= 0)
+            {
+                z = (z - 1) / (z + 1);
+                angle2 = 0.7853981634f;
+            }
+
+            float v = 0.7853981634f * z + z * (1 - z) * (0.2447f + 0.0663f * z);
+            v *= 57.29577951f;
+            v += angle2;
+            v += angle;
+            v *= sign;
+
+            return v;
+            */
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/BasicOps.cs

@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BasicOps.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Scaler
+    {
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe float Abs( float x )
+        {
+            uint* a = ( uint* )&x;
+            *a &= 0b_0111_1111_1111_1111_1111_1111_1111_1111;
+            return *( float* )a;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe int Abs( int x )
+        {
+            uint* a = ( uint* )&x;
+            *a &= 0b_0111_1111_1111_1111_1111_1111_1111_1111;
+            return *( int* )a;
+        }
+
+        internal static string GetListSeparator(
+            IFormatProvider formatProvider )
+        {
+            if( formatProvider is CultureInfo cultureInfo ) {
+                return cultureInfo.TextInfo.ListSeparator;
+            }
+
+            if( formatProvider?.GetFormat( typeof( TextInfo ) ) is TextInfo textInfo ) {
+                return textInfo.ListSeparator;
+            }
+
+            return CultureInfo.CurrentCulture.TextInfo.ListSeparator;
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/Compare.cs

@@ -0,0 +1,65 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Compare.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Math
+{
+    public static partial class Scaler
+    {
+
+        public static float MaxOf( params float[] stream )
+        {
+            float ret = stream[ 0 ];
+            foreach( float num in stream ) {
+                if( ret < num ) {
+                    ret = num;
+                }
+            }
+            return ret;
+        }
+
+        public static float MinOf( params float[] stream )
+        {
+            float ret = stream[ 0 ];
+            foreach( float num in stream ) {
+                if( ret > num ) {
+                    ret = num;
+                }
+            }
+            return ret;
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/Cos.cs

@@ -0,0 +1,60 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Cos.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Math
+{
+    public static partial class Scaler
+    {
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static float Cos( float x )
+        {
+            /*
+            float refer = x / 360.0f;
+            refer -= (int)refer;
+
+            refer *= 40;
+            int a = (int)refer;   //大分度，查表
+            refer -= a;    //小分度，拟合
+
+            float refer2 = refer * refer;
+
+
+            return ((-sinData[a]) * ((0.1570796327f * refer) - (6.459640975e-4f * refer * refer2)))
+                + (cosData[a] * ((1 - (0.0123370055f * refer2)) + (2.536695709e-5f * refer2 * refer2)));
+            */
+            return MathF.Cos( x );
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/Ctor.cs

@@ -0,0 +1,62 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Ctor.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    public unsafe delegate float ScalarCalcHandler( float* x );
+
+    public static unsafe partial class Scaler
+    {
+
+        private const uint MEM_COMMIT = 0x1000;
+        private const uint MEM_RELEASE = 0x8000;
+        private const uint MEM_RESERVE = 0x2000;
+        private const uint PAGE_EXECUTE_READWRITE = 0x40;
+
+        static Scaler() { }
+
+        [DllImport( "Kernel32.dll", EntryPoint = "VirtualAlloc" )]
+        private static extern IntPtr VirtualAlloc(
+            IntPtr address,
+            int size,
+            uint allocType,
+            uint protect );
+
+        [DllImport( "Kernel32.dll", EntryPoint = "VirtualFree" )]
+        private static extern bool VirtualFree(
+            IntPtr address,
+            int size,
+            uint freeType );
+
+    }
+}

StgSharp.Common/Math/Scalar/Exp.cs

@@ -0,0 +1,89 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Exp.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp.Math
+{
+    public static unsafe partial class Scaler
+    {
+
+        public const float E = 2.718281828f;
+
+        /// <summary>
+        /// Get the value of E ^ x;
+        /// </summary>
+        /// <param _name="x"></param>
+        /// <returns></returns>
+        public static unsafe float Exp( float x )
+        {
+            if( x == 1 ) {
+                return E;
+            }
+            if( x == 0 ) {
+                return 1;
+            }
+
+            bool sign = false;
+            if( x < 0 ) {
+                sign = true;
+                x = -x;
+            }
+
+            float z = x, t;
+            if( x < 0.5f ) {
+                t = 1.0f + ( x * ( 1.0f + ( x * ( 0.5f + ( x * ( 0.1666666667f + ( x * ( 0.0416666666667f + ( x * 8.333333333e-3f ) ) ) ) ) ) ) ) );
+            } else {
+                /*
+                 * define z =  n * 2 ^ m
+                 * n is between 0 and 0.5
+                 */
+                uint zBit = *( uint* )&z;
+                uint zBitAbs = zBit & 0b_0111_1111_1111_1111_1111_1111_1111_1111;
+                uint uintm = zBitAbs >> 23;
+                int m = ( *( int* )&uintm ) - 126;
+
+
+                uint nBit = ( zBitAbs & 0b_0000_0000_0111_1111_1111_1111_1111_1111 ) + 0b_0011_1111_0000_0000_0000_0000_0000_0000;
+                float n = ( *( float* )&nBit ) - 1;
+
+                t = 2.718281828f + ( n * ( 2.718281828f + ( n * ( 1.359140914f + ( n * ( 0.4530469714f + ( n * ( 0.1132617429f + ( n * 0.02265234857f ) ) ) ) ) ) ) ) );
+
+                for( int i = 0; i < m; i++ ) {
+                    t = t * t;
+                }
+            }
+
+            if( sign ) {
+                t = 1 / t;
+            }
+            return t;
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/Function.cs

@@ -0,0 +1,34 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Function.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp.Math
+{
+    public class Function { }
+}

StgSharp.Common/Math/Scalar/Log.cs

@@ -0,0 +1,81 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Log.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+
+namespace StgSharp.Math
+{
+    public static partial class Scaler
+    {
+
+        private static readonly float[] logArray = {
+            0f, 0.00995033085316809f, 0.0198026272961797f, 0.0295588022415444f, 0.0392207131532813f, 0.048790164169432f, 0.0582689081239758f, 0.0676586484738149f, 0.0769610411361284f, 0.0861776962410524f, 0.0953101798043249f, 0.104360015324243f, 0.113328685307003f, 0.122217632724249f, 0.131028262406404f, 0.139761942375159f, 0.148420005118273f, 0.157003748809665f, 0.165514438477573f, 0.173953307123438f, 0.182321556793955f, 0.19062035960865f, 0.198850858745165f, 0.207014169384326f, 0.215111379616945f, 0.22314355131421f, 0.231111720963387f, 0.2390169004705f, 0.246860077931526f, 0.254642218373581f, 0.262364264467491f, 0.27002713721306f, 0.27763173659828f, 0.285178942233662f, 0.29266961396282f, 0.300104592450338f, 0.307484699747961f, 0.314810739840034f, 0.322083499169113f, 0.3293037471426f, 0.336472236621213f, 0.343589704390077f, 0.350656871613169f, 0.357674444271816f, 0.364643113587909f, 0.371563556432483f, 0.378436435720245f, 0.385262400790645f, 0.392042087776024f, 0.398776119957368f, 0.405465108108164f, 0.412109650826833f, 0.418710334858185f, 0.425267735404344f, 0.431782416425538f, 0.438254930931155f, 0.444685821261446f, 0.451075619360217f, 0.457424847038875f, 0.46373401623214f, 0.470003629245736f, 0.476234178996372f, 0.482426149244293f, 0.488580014818671f, 0.494696241836107f, 0.500775287912489f, 0.506817602368452f, 0.512823626428664f, 0.518793793415168f, 0.524728528934982f, 0.53062825106217f, 0.536493370514568f, 0.542324290825362f, 0.548121408509688f, 0.553885113226438f, 0.559615787935423f, 0.56531380905006f, 0.570979546585738f, 0.576613364303994f, 0.582215619852664f, 0.587786664902119f, 0.593326845277734f, 0.598836501088704f, 0.60431596685333f, 0.609765571620894f, 0.615185639090233f, 0.62057648772511f, 0.625938430866495f, 0.631271776841858f, 0.636576829071551f, 0.641853886172395f, 0.647103242058538f, 0.65232518603969f, 0.657520002916794f, 0.662687973075237f, 0.667829372575655f, 0.672944473242426f, 0.678033542749897f, 0.683096844706444f, 0.688134638736401f,
+        };
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param _name="x"></param>
+        /// <returns>
+        /// Returns the value of ln(x).
+        /// </returns>
+        public static unsafe float Log( float x )
+        {
+            if( x < 0 ) {
+                throw new ArgumentOutOfRangeException();
+            }
+            uint input = *( uint* )&x;
+
+            int f = ( int )input;
+            f >>= 23;
+            f -= 127;
+            input <<= 9;
+            input >>= 9;
+            input += 0b_0011_1111_1000_0000_0000_0000_0000_0000;
+            float result = *( float* )&input;
+            uint order = ( ( uint )( result * 100 ) ) - 100;
+
+            float cache = ( result / ( 1f + ( 0.01f * order ) ) ) - 1;
+            result = ( cache * ( -0.25f ) ) + 0.3333333333333f;
+            result = ( result * cache ) - 0.5f;
+            result = ( result * cache ) + 1.0f;
+            result *= cache;
+
+            return
+                ( f * 0.6931471806f ) + result + logArray[ order ];
+        }
+
+        public static float Log( float x, float y )
+        {
+            return Log( x ) / Log( y );
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/Pow.cs

@@ -0,0 +1,101 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Pow.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp.Math
+{
+    public static unsafe partial class Scaler
+    {
+
+        /// <summary>
+        /// calculate the value of x^y
+        /// </summary>
+        /// <param _name="x"></param>
+        /// <param _name="y"></param>
+        /// <returns> Returns the value of x^y </returns>
+        public static unsafe float Pow( float x, float y )
+        {
+            /* 
+             * x^y = E ^ ( log( x ) * y )
+             * Now define z = | log(x) * y | = m * n  
+             * and m is an integer, and 0.5 < |n| < 1
+             * then E ^ z = ( E ^ n ) ^ m
+             * 
+             * 
+             * As a float number can be expressed in (1+e)*(2^f)
+             * n = (1+e)/2
+             * m = 2 ^ (f + 1)
+             * 
+             */
+            float z, t;
+            if( ( x == 1 ) || ( y == 0 ) ) {
+                return 1;
+            }
+            if( ( x == 1 ) && ( y == 0 ) ) {
+                return float.PositiveInfinity;
+            }
+            if( ( x == 0 ) && ( y != 0 ) ) {
+                return 0;
+            }
+
+            z = Scaler.Log( x ) * y;
+
+            bool sign = false;
+            if( z < 0 ) {
+                sign = true;
+                z = -z;
+            }
+
+            if( z < 0.5f ) {
+                t = 1.0f + ( z * ( 1.0f + ( z * ( 0.5f + ( z * ( 0.1666666667f + ( z * ( 0.0416666666667f + ( z * 8.333333333e-3f ) ) ) ) ) ) ) ) );
+            } else {
+                uint zBit = *( uint* )&z;
+                uint zBitAbs = zBit & 0b_0111_1111_1111_1111_1111_1111_1111_1111;
+                uint uintm = zBitAbs >> 23;
+                int m = ( *( int* )&uintm ) - 126;
+
+
+                uint nBit = ( zBitAbs & 0b_0000_0000_0111_1111_1111_1111_1111_1111 ) + 0b_0011_1111_0000_0000_0000_0000_0000_0000;
+                float n = ( *( float* )&nBit ) - 1;
+
+                t = 2.718281828f + ( n * ( 2.718281828f + ( n * ( 1.359140914f + ( n * ( 0.4530469714f + ( n * ( 0.1132617429f + ( n * 0.02265234857f ) ) ) ) ) ) ) ) );
+
+                for( int i = 0; i < m; i++ ) {
+                    t = t * t;
+                }
+            }
+            if( sign ) {
+                t = 1 / t;
+            }
+
+            return t;
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/Random.cs

@@ -0,0 +1,127 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Random.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Numerics;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Scaler
+    {
+
+        private static byte[] randomSeed;
+
+        internal static float currentSeed
+#if DEBUG    
+            = 0.5f;
+
+        #else
+        = Abs(System.DateTime.UtcNow.GetHashCode());
+        #endif
+
+        /// <summary>
+        /// returns a random float number between 0 and 1.
+        /// </summary>
+        /// <returns></returns>
+        public static unsafe float LowProceisionRandom()
+        {
+            float seed = currentSeed;
+
+            float sample = Scaler.Pow( Scaler.SeedSqrt( seed ), 2 );
+            float sample2 = ( sample - seed ) / seed;
+            sample2 = Scaler.Abs( sample2 );
+
+            if( sample == 1 ) {
+                sample = sample2;
+            }
+
+            currentSeed = sample;
+            sample2 *= 1000000;
+
+            float result = sample2 - ( ( int )sample2 );
+            if( result == 0 ) {
+                currentSeed = sample2 + 0.1f;
+                result = Scaler.LowProceisionRandom();
+            }
+            return result;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static T Random<T>() where T: struct, IConvertible, INumber<T>
+
+        {
+            if( randomSeed == null ) {
+                randomSeed = new byte[64];
+                string originSeed =
+                    ( $"{((Assembly.GetEntryAssembly() == null) ? (Assembly.GetAssembly(typeof(StgSharp))!) :
+                    Assembly.GetEntryAssembly())}" ) + ( $"{DateTime.UtcNow.ToString("o")}" );
+                using( SHA256 sha = SHA256.Create() ) {
+                    randomSeed = sha.ComputeHash(
+                        Encoding.UTF8.GetBytes( originSeed ) );
+                }
+            }
+            using( SHA256 sha = SHA256.Create() ) {
+                randomSeed = sha.ComputeHash( randomSeed );
+            }
+            fixed( byte* bptr = randomSeed ) {
+                return *( T* )bptr;
+            }
+        }
+
+        /// <summary>
+        /// Generates a random seed in int value.
+        /// </summary>
+        /// <returns></returns>
+        public static unsafe int RandomSeed()
+        {
+            float seedValue1 = LowProceisionRandom();
+            float seedValue2 = LowProceisionRandom();
+            uint seedValueBits = *( uint* )&seedValue1;
+
+            float seedValue = seedValueBits * seedValue2;
+
+            return *( int* )&seedValue;
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/SignOf.cs

@@ -0,0 +1,68 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="SignOf.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Scaler
+    {
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe int SignOf( float x )
+        {
+            if( x == 0 ) {
+                return 0;
+            }
+            if( x > 0 ) {
+                return 1;
+            }
+            return -1;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe int SignOf( int x )
+        {
+            if( x == 0 ) {
+                return 0;
+            }
+            if( x > 0 ) {
+                return 1;
+            }
+            return -1;
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/Sin.cs

@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Sin.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Net.NetworkInformation;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Math
+{
+    public static partial class Scaler
+    {
+
+        public const float Pi = 3.1415926f;
+
+        private static readonly float[] cosData = {
+            1f, 0.987688341014302f, 0.951056517951169f, 0.891006527837756f, 0.809017000674805f, 0.707106790659974f, 0.587785265298989f, 0.453990516451646f, 0.309017014761716f, 0.156434488858737f, 2.67948965850537E-08f, -0.156434435928723f, -0.309016963794794f, -0.453990468702791f, -0.587785221943935f, -0.707106752766267f, -0.809016969175515f, -0.891006503508499f, -0.951056501391011f, -0.98768833263101f, -0.999999999999999f, -0.987688349397591f, -0.951056534511324f, -0.891006552167012f, -0.809017032174094f, -0.707106828553679f, -0.587785308654041f, -0.4539905642005f, -0.309017065728638f, -0.156434541788751f, -8.03846893110719E-08f, 0.156434382998709f, 0.309016912827872f, 0.453990420953934f, 0.58778517858888f, 0.707106714872559f, 0.809016937676222f, 0.891006479179238f, 0.951056484830851f, 0.987688324247716f,
+        };
+
+        private static readonly float[] sinData = {
+            0f, 0.15643446239373f, 0.309016989278255f, 0.453990492577218f, 0.587785243621462f, 0.707106771713121f, 0.80901698492516f, 0.891006515673128f, 0.951056509671091f, 0.987688336822657f, 1f, 0.987688345205947f, 0.951056526231247f, 0.891006540002384f, 0.80901701642445f, 0.707106809606826f, 0.587785286976515f, 0.453990540326073f, 0.309017040245177f, 0.156434515323744f, 5.35897931701074E-08f, -0.156434409463716f, -0.309016938311333f, -0.453990444828362f, -0.587785200266408f, -0.707106733819413f, -0.809016953425868f, -0.891006491343869f, -0.951056493110931f, -0.987688328439363f, -0.999999999999997f, -0.987688353589235f, -0.951056542791401f, -0.891006564331638f, -0.809017047923737f, -0.70710684750053f, -0.587785330331566f, -0.453990588074927f, -0.309017091212098f, -0.156434568253757f,
+        };
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static unsafe float Sin( float x )
+        {
+            /*
+            float refer = x / 360.0f;
+            refer -= (int)refer;
+
+            refer *= 40;
+            int a = (int)refer;   //大分度，查表
+            refer -= a;    //小分度，拟合
+
+            float refer2 = refer * refer;
+
+
+            return (sinData[a] * ((1 - (0.0123370055f * refer2)) + (2.536695709e-5f * refer2 * refer2)))
+                + (cosData[a] * ((0.1570796327f * refer) - (6.459640975e-4f * refer * refer2)));
+            */
+            return MathF.Sin( x );
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/Sqrt.cs

@@ -0,0 +1,109 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Sqrt.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Math
+{
+    public static partial class Scaler
+    {
+
+        public static unsafe float SeedSqrt( float x )
+        {
+            /*
+             * 本方法采用分别对指数和小数处理的方法计算平方根
+             * 将指数除以2即可获得结果的指数
+             * （补充：指数最低位被加到小数位中以抵消一个多余的2 ^ 1的影响）
+             * 小数部分则统一乘以2 ^ 16后由y = Sqrt(x)在1.5 * 2 ^ 16处的切线近似
+             * 为简化操作，提高计算速度，切线左界被移动到远点
+             * 在进一步简化操作后，计算精度达到0.5%，速度约为.Net库函数的3倍
+             */
+
+            if( x < 0 ) {
+                throw new ArgumentOutOfRangeException(
+                    "Input is smaller than zero!" );
+            }
+            if( x == 0 ) {
+                return 0;
+            }
+            /*
+            * 提取指数位并减半
+            * 由于平方根仅对正数有效
+            * 故不考虑正负号
+            */
+
+            if( x < 0 ) {
+                throw new ArgumentOutOfRangeException();
+            }
+            if( x <= 1e-12 ) {
+                return 0;
+            }
+
+            //提取指数位并减去指数位中的127
+            //由于平方根仅对正数有效
+            //故不考虑正负号
+            uint a = *( uint* )&x;
+            uint f = a;
+            f >>= 23;
+            f /= 2;
+            f += 64;
+
+            //提取小数位
+            //由于平方根仅对正数有效
+            //故不考虑正负号
+
+            a -= 0b_0011_1111_0000_0000_0000_0000_0000_0000;
+            uint e = a << 8;
+            e >>= 8;
+
+            //线性近似
+            e *= 0b_1101_0001;
+            e >>= 24;
+            e += 0b_0000_0000_0001_0000_1010_1000_1110_0010;
+
+            //还原指数
+            f <<= 23;
+            e += f;
+
+            float result = *( float* )&e;
+            result = ( result + ( x / result ) ) / 2;
+            return ( result + ( x / result ) ) / 2;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static float Sqrt( float x )
+        {
+            return MathF.Sqrt( x );
+            /**/
+        }
+
+    }
+}

StgSharp.Common/Math/Scalar/Tan.cs

@@ -0,0 +1,55 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Tan.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp.Math
+{
+    public static partial class Scaler
+    {
+
+        public static float Tan( float x )
+        {
+            float refer = x / 360.0f;
+            refer -= ( int )refer;
+
+            refer *= 40;
+            int a = ( int )refer;   //大分度，查表
+            refer -= a;    //小分度，拟合
+
+            float refer2 = refer * refer;
+
+            float sin = ( 0.1570796327f * refer ) - ( 6.459640975e-4f * refer * refer2 );
+            float cos = ( 1 - ( 0.0123370055f * refer2 ) ) + ( 2.536695709e-5f * refer2 * refer2 );
+
+            return ( ( sinData[ a ] * cos ) + ( cosData[ a ] * sin ) ) / ( ( cosData[
+                a ] * cos ) - ( sinData[ a ] * sin ) );
+        }
+
+    }
+}