OpenGL rebuild project start!

2023-04-29 03:06:32 +08:00
parent 7dba067146
commit 4dd3f4f6d1
263 changed files with 51374 additions and 1522 deletions
@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Calc
+    {
+
+
+        public static unsafe float ACos(float 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 = Calc.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;
+        }
+    }
+}
@@ -0,0 +1,94 @@
+//
+// 
+// some of the code is rewritten from the AMD code:
+// https://github.com/amd/aocl-libm-ose/blob/a43e092b03213eb0e129a1cc129900e6e4475778/src/ref/asinf.c
+
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Calc
+    {
+
+        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 )
+        {
+            
+            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 = Calc.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;
+
+        }
+    }
+}
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Calc
+    {
+        public static unsafe float ATan(float 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;
+
+        }
+    }
+}
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Numerics;
+using System.Globalization;
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Calc
+    {
+
+        public static unsafe float Abs(float x)
+        {
+            uint* a = (uint*)&x;
+            *a &= 0b_0111_1111_1111_1111_1111_1111_1111_1111;
+            return *(float*)a;
+        }
+
+        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;
+        }
+
+    }
+}
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Math
+{
+    public static partial class Calc
+    {
+
+        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);
+        }
+    }
+}
@@ -0,0 +1,27 @@
+using StgSharp.Optimization;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Math
+{
+    public unsafe delegate float ScalarCalcHandler(float* x);
+
+    public static unsafe partial class Calc 
+    {
+        [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);
+
+        const uint MEM_COMMIT = 0x1000;
+        const uint MEM_RESERVE = 0x2000;
+        const uint PAGE_EXECUTE_READWRITE = 0x40;
+        const uint MEM_RELEASE = 0x8000;
+
+        static Calc()
+        {
+        }
+    }
+}
@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Math
+{
+    public static unsafe partial class Calc
+    {
+
+        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
+            {
+                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;
+        }
+    }
+}
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Math
+{
+    public class Function
+    {
+        
+
+    }
+}
@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Sockets;
+using System.Text;
+using static System.Net.WebRequestMethods;
+
+namespace StgSharp.Math
+{
+    public static partial class Calc
+    {
+
+        static private 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 unsafe static float Log(float x)
+        {
+            if (x<0)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+            uint input = *(uint*)&x;
+
+            uint f = input;
+            f >>= 23;
+            f -= 127;
+            input <<= 9;
+            input >>= 9;
+            input += 0b_0011_1111_1000_0000_0000_0000_0000_0000;
+            float result = *(float*)&input;
+            int order = (int)(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);
+        }
+
+
+    }
+}
@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Math
+{ 
+    public static unsafe partial class Calc
+    {
+        /// <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 1.0f / 0;
+            }
+            z = Calc.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;
+        }
+    }
+}
@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Math
+{
+    public static partial class Calc
+    {
+        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,
+
+
+        };
+        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,
+
+
+        };
+
+        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);
+        }
+    }
+}
@@ -0,0 +1,88 @@
+using StgSharp.Optimization;
+using System;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Math
+{
+    public static partial class Calc
+    {
+        private static m128 sqrtCache;
+
+        public static unsafe float Sqrt(float x)
+        {
+            /*
+             * 本方法采用分别对指数和小数处理的方法计算平方根
+             * 将指数除以2即可获得结果的指数
+             * （补充：指数最低位被加到小数位中以抵消一个多余的2 ^ 1的影响）
+             * 小数部分则统一乘以2 ^ 16后由y = Sqrt(x)在1.5 * 2 ^ 16处的切线近似
+             * 为简化操作，提高计算速度，切线左界被移动到远点
+             * 在进一步简化操作后，计算精度达到0.5%，速度约为.Net库函数的3倍
+             */
+
+            if (x < 0)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+            if (x == 0)
+            {
+                return 0;
+            }
+            /*
+            * 提取指数位并减半
+            * 由于平方根仅对正数有效
+            * 故不考虑正负号
+            */
+
+            if (x < 0)
+            {
+                throw new ArgumentOutOfRangeException();
+            }
+            if (x == 0)
+            {
+                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;
+            /**/
+            /*
+            fixed (m128* p = &sqrtCache)
+            {
+                sqrtCache.float0 = x;
+                return (SSE.Sqrtss(p)).float0;
+            }
+            */
+        }
+
+        [DllImport("xmmintrin.h",EntryPoint = "_mm_sqrt_ss")]
+        public static extern m128 Sqrtss(m128 a);
+
+    }
+}
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Math
+{
+    public static partial class Calc
+    {
+
+        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 );
+        }
+    }
+}