daily update on 20240213 by nitload youmu. 逐步弃用GLFW，正在使用wgl重写glfw底层，相关实现转移到C#实现，SSC彻底变成线性代数计算器。

源代码/StgSharp/Graphics/GL/ShaderEdit/Uniform.cs

@@ -139,69 +139,111 @@ namespace StgSharp.Graphics
 
     internal unsafe partial class GLonUpdate
     {
+        private IntPtr UniformVal1fPtr = (IntPtr)(delegate*<void>)&UniformVal1f;
+        private IntPtr UniformVal1fvPtr = (IntPtr)(delegate*<void>)&UniformVal1fv;
+        private IntPtr UniformVal1iPtr = (IntPtr)(delegate*<void>)&UniformVal1i;
+        private IntPtr UniformVal2fPtr = (IntPtr)(delegate*<void>)&UniformVal2f;
         private IntPtr UniformVal3fPtr = (IntPtr)(delegate*<void>)&UniformVal3f;
-        //TODO xontinue here
-        private static void UniformVal3f()
-        {
+        private IntPtr UniformVal4fPtr = (IntPtr)(delegate*<void>)&UniformVal4f;
 
-            paramQueue.
+        unsafe void IglFunc.SetValue(Uniform<float, float, float> uniform, float f0, float f1, float f2)
+        {
+            paramQueue.Enqueue((IntPtr)uniform.id.valuePtr);
+            paramQueue.Enqueue(f0, f1, f2);
+            glActionQueue.Enqueue(UniformVal3fPtr);
         }
 
-        unsafe void IglFunc.SetValue(Uniform<float, float, float> uniform, float v0, float v1, float v2)
+        unsafe void IglFunc.SetValue(Uniform<float, float> uniform, float f0, float f1)
         {
-            glActionQueue.Enqueue(
-                () => { api->glUniform3f(uniform.id, v0, v1, v2); }
-                );
+            M128 m = default;
+            m.UInt64[0] = (ulong)uniform.id.valuePtr;
+            m.Single[2] = f0; m.Single[3] = f1;
+            paramQueue.Enqueue(m);
+            glActionQueue.Enqueue(UniformVal2fPtr);
         }
 
-        unsafe void IglFunc.SetValue(Uniform<float, float> uniform, float v0, float v1)
+        unsafe void IglFunc.SetValue(Uniform<float, float, float, float> uniform, float f0, float f1, float f2, float f3)
         {
-            glActionQueue.Enqueue(
-                () => { api->glUniform2f(uniform.id, v0, v1); }
-                );
-        }
-
-        unsafe void IglFunc.SetValue(Uniform<float, float, float, float> uniform, float v0, float v1, float v2, float v3)
-        {
-            glActionQueue.Enqueue(
-                () => { api->glUniform4f(uniform.id, v0, v1, v2, v3); }
-                );
+            paramQueue.Enqueue((IntPtr)uniform.id.valuePtr);
+            paramQueue.Enqueue(f0, f1, f2, f3);
+            glActionQueue.Enqueue(UniformVal4fPtr);
         }
 
         unsafe void IglFunc.SetValue(Uniform<float, float, float, float> uniform, Vec4d vec)
         {
-            glActionQueue.Enqueue(
-                () =>
-                {
-                    Vec4d cache = vec;
-                    api->glUniform1fv(uniform.id, 4, &cache);
-                }
-                );
+            Vec4d m = vec;
+            paramQueue.Enqueue((IntPtr)uniform.id.valuePtr, (IntPtr)(Vec4d*)&m);
+            glActionQueue.Enqueue(UniformVal1fvPtr);
         }
 
-        unsafe void IglFunc.SetValue(Uniform<float> uniform, float v0)
+        unsafe void IglFunc.SetValue(Uniform<float> uniform, float f0)
         {
-            glActionQueue.Enqueue(
-                () => { api->glUniform1f(uniform.id, v0); }
-                );
+            M128 m = default;
+            m.UInt64[0] = (ulong)uniform.id.valuePtr;
+            m.Single[2] = f0;
+            paramQueue.Enqueue(m);
+            glActionQueue.Enqueue(UniformVal1fPtr);
         }
 
         unsafe void IglFunc.SetValue(Uniform<int> uniform, int i0)
         {
-            glActionQueue.Enqueue(
-                () => { api->glUniform1d(uniform.id, i0); }
-                );
+            M128 m = default;
+            m.UInt64[0] = (ulong)uniform.id.valuePtr;
+            m.Int32[2] = i0;
+            paramQueue.Enqueue(m);
+            glActionQueue.Enqueue(UniformVal1fPtr);
         }
 
         unsafe void IglFunc.SetValue(Uniform<Vec4d> uniform, Vec4d vec)
         {
-            glActionQueue.Enqueue(
-                () =>
-                {
-                    Vec4d cache = vec;
-                    api->glUniform1fv(uniform.id, 4, &cache);
-                }
-                );
+            Vec4d m = vec;
+            paramQueue.Enqueue((IntPtr)uniform.id.valuePtr, (IntPtr)(Vec4d*)&m);
+            glActionQueue.Enqueue(UniformVal1fvPtr);
+        }
+
+        private static void UniformVal1f()
+        {
+            M128 m = default;
+            paramQueue.TryDequeue(out m);
+            paramQueue.context->glUniform1f(*(int*)m.UInt64[0], m.Single[2]);
+        }
+
+        private static unsafe void UniformVal1fv()
+        {
+            M128 m = default;
+            paramQueue.TryDequeue(out m);
+            paramQueue.context->glUniform1fv(*(int*)m.UInt64[0], 4, (Vec4d*)m.UInt64[0]);
+        }
+
+        private static void UniformVal1i()
+        {
+            M128 m = default;
+            paramQueue.TryDequeue(out m);
+            paramQueue.context->glUniform1i(*(int*)m.UInt64[0], m.Int32[2]);
+        }
+
+        private static void UniformVal2f()
+        {
+            M128 m = default;
+            paramQueue.TryDequeue(out m);
+            paramQueue.context->glUniform2f(*(int*)m.UInt64[0], m.Single[2], m.Single[3]);
+        }
+
+        private static void UniformVal3f()
+        {
+            IntPtr handle = IntPtr.Zero;
+            M128 m = default;
+            paramQueue.TryDequeue(out handle);
+            paramQueue.TryDequeue(out m);
+            paramQueue.context->glUniform3f(*(int*)handle, m.Single[0], m.Single[1], m.Single[2]);
+        }
+        private static void UniformVal4f()
+        {
+            IntPtr handle = IntPtr.Zero;
+            M128 m = default;
+            paramQueue.TryDequeue(out handle);
+            paramQueue.TryDequeue(out m);
+            paramQueue.context->glUniform4f(*(int*)handle, m.Single[0], m.Single[1], m.Single[2], m.Single[2]);
         }
     }
 }