daily update on 20240315 by nitload youmu

2024-03-16 03:09:00 +08:00
parent a770bbe685
commit 15bf989285
84 changed files with 1064 additions and 1981 deletions
@@ -15,10 +15,10 @@ namespace StgSharp.Graphics
 {
    internal unsafe partial class GLonUpdate : IglFunc
    {
-        private static FrameOperationBuffer frameOpBuffer;
        private GLcontext* api;
        private IntPtr SwapBufferPtr = (IntPtr)(delegate*<IntPtr, void>)&InternalIO.glfwSwapBuffers;
        private glSHandle unupdatedFrame = glSHandle.Alloc(0);
+        private FrameOperationBuffer frameOpBuffer;

        internal GLonUpdate(GLcontext* context)
        {
@@ -42,8 +42,8 @@ namespace StgSharp.Graphics

        void IglFunc.ActiveTexture(uint type)
        {
-            frameOpBuffer.Enqueue(type);
-            frameOpBuffer.Enqueue(ActiveTexturePtr);
+            frameOpBuffer.ParamEnqueue(type);
+            frameOpBuffer.MethodEnqueue(ActiveTexturePtr);
        }

        void IglFunc.AfterAlign(Form form, Action action)
@@ -59,8 +59,8 @@ namespace StgSharp.Graphics
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        unsafe void IglFunc.AttachShader(glHandle program, glHandle shader)
        {
-            frameOpBuffer.Enqueue(program, shader);
-            frameOpBuffer.Enqueue(AttachShaderPtr);
+            frameOpBuffer.ParamEnqueue(program, shader);
+            frameOpBuffer.MethodEnqueue(AttachShaderPtr);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -69,8 +69,8 @@ namespace StgSharp.Graphics
            M128 m = default;
            m.Write<uint>(0, (uint)bufferType);
            m.Write<ulong>(1, (ulong)handle.valuePtr);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(BindBufferPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(BindBufferPtr);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -79,49 +79,49 @@ namespace StgSharp.Graphics
            M128 m = default;
            m.Write<uint>(0, (uint)type);
            m.Write<ulong>(1, (ulong)texture.valuePtr);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(BindTexturePtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(BindTexturePtr);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        void IglFunc.BindVertexArray(glHandle index)
        {
-            frameOpBuffer.Enqueue(index);
-            frameOpBuffer.Enqueue(BindVertexArrayPtr);
+            frameOpBuffer.ParamEnqueue(index);
+            frameOpBuffer.MethodEnqueue(BindVertexArrayPtr);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        void IglFunc.Clear(MaskBufferBit mask)
        {
-            frameOpBuffer.Enqueue((int)mask);
-            frameOpBuffer.Enqueue(ClearPtr);
+            frameOpBuffer.ParamEnqueue((int)mask);
+            frameOpBuffer.MethodEnqueue(ClearPtr);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        void IglFunc.ClearColor(float R, float G, float B, float A)
        {
-            frameOpBuffer.Enqueue(R, G, B, A);
-            frameOpBuffer.Enqueue(ClearColorPtr);
+            frameOpBuffer.ParamEnqueue(R, G, B, A);
+            frameOpBuffer.MethodEnqueue(ClearColorPtr);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        void IglFunc.ClearGraphicError()
        {
-            frameOpBuffer.Enqueue(ClearGraphicErrorPtr);
+            frameOpBuffer.MethodEnqueue(ClearGraphicErrorPtr);
        }

        unsafe void IglFunc.CompileShader(glHandle shaderhandle)
        {
-            frameOpBuffer.Enqueue((IntPtr)shaderhandle.valuePtr);
-            frameOpBuffer.Enqueue(CompileShaderPtr);
+            frameOpBuffer.ParamEnqueue((IntPtr)shaderhandle.valuePtr);
+            frameOpBuffer.MethodEnqueue(CompileShaderPtr);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        glHandle IglFunc.CreateProgram()
        {
            glHandle h = glHandle.Alloc(1);
-            frameOpBuffer.Enqueue(h);
-            frameOpBuffer.Enqueue(CreateProgramPtr);
+            frameOpBuffer.ParamEnqueue(h);
+            frameOpBuffer.MethodEnqueue(CreateProgramPtr);
            return h;
        }

@@ -132,8 +132,8 @@ namespace StgSharp.Graphics
            glHandleSet h = new glHandleSet(count);
            m.Write<ulong>(0, (ulong)h.handle);
            m.Write<int>(2, count);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(CreateProgramSetPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(CreateProgramSetPtr);
            return h;
        }

@@ -144,8 +144,8 @@ namespace StgSharp.Graphics
            m.Write<int>(0, count);
            m.Write<uint>(1, (uint)type);
            m.Write<ulong>(1, (ulong)ret.handle);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(CreateShaderPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(CreateShaderPtr);
            return ret;
        }

@@ -178,8 +178,8 @@ namespace StgSharp.Graphics
        glHandle IglFunc.CreatGraphicProgram()
        {
            glHandle h = glHandle.Alloc(1);
-            frameOpBuffer.Enqueue(h);
-            frameOpBuffer.Enqueue(CreateProgramPtr);
+            frameOpBuffer.ParamEnqueue(h);
+            frameOpBuffer.MethodEnqueue(CreateProgramPtr);
            return h;
        }

@@ -189,8 +189,8 @@ namespace StgSharp.Graphics
            M128 m = default;
            m.Write<ulong>(0, (ulong)handle.valuePtr);
            m.Write(2, 1);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(DeleBufferPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(DeleBufferPtr);
        }

        unsafe void IglFunc.DeleteBuffers(glHandleSet handle)
@@ -198,16 +198,16 @@ namespace StgSharp.Graphics
            M128 m = default;
            m.Write<ulong>(0, (ulong)handle.handle);
            m.Write<uint>(2, (uint)handle.length);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(DeleBufferPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(DeleBufferPtr);
        }

        unsafe void IglFunc.DeleteVertexArrays(glHandleSet arrays)
        {
            M128 m = default; m.Write<ulong>(1, (ulong)arrays.handle);
            m.Write<int>(0, arrays.length);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(DeleteVertexArrayPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(DeleteVertexArrayPtr);
        }

        void IglFunc.DrawElements(GepmetryType mode, uint count, TypeCode type, IntPtr ptr)
@@ -234,17 +234,17 @@ namespace StgSharp.Graphics
                        LogType.Error);
                    return;
            }
-            frameOpBuffer.Enqueue((uint)mode, count, a);
-            frameOpBuffer.Enqueue(ptr);
-            frameOpBuffer.Enqueue(DrawElementsPtr);
+            frameOpBuffer.ParamEnqueue((uint)mode, count, a);
+            frameOpBuffer.ParamEnqueue(ptr);
+            frameOpBuffer.MethodEnqueue(DrawElementsPtr);
        }

        unsafe glHandleSet IglFunc.GenBuffers(int count)
        {
            glHandleSet h = new glHandleSet(count);
            M128 m = default; m.Write<uint>(2, (uint)count); m.Write<ulong>(0, (ulong)h.handle);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(GenBufferPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(GenBufferPtr);
            return h;
        }

@@ -252,8 +252,8 @@ namespace StgSharp.Graphics
        {
            glHandleSet h = new glHandleSet(count);
            M128 m = default; m.Write<uint>(2, (uint)count); m.Write<ulong>(0, (ulong)h.handle);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(GenTexturesPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(GenTexturesPtr);
            return h;
        }

@@ -261,8 +261,8 @@ namespace StgSharp.Graphics
        {
            glHandleSet h = new glHandleSet(count);
            M128 m = default; m.Write<uint>(2, (uint)count); m.Write<ulong>(0, (ulong)h.handle);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(GenTexturesPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(GenTexturesPtr);
            return h;
        }

@@ -273,9 +273,9 @@ namespace StgSharp.Graphics
            M128 m = default;
            m.Write<ulong>(0, (ulong)program.Handle);
            m.Write<ulong>(1, (ulong)GCHandle.Alloc(Encoding.UTF8.GetBytes(ptr), GCHandleType.Pinned).AddrOfPinnedObject());
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue((IntPtr)h.valuePtr);
-            frameOpBuffer.Enqueue(GetUniformLocationPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.ParamEnqueue((IntPtr)h.valuePtr);
+            frameOpBuffer.MethodEnqueue(GetUniformLocationPtr);
            return h;
        }

@@ -296,9 +296,9 @@ namespace StgSharp.Graphics

        void IglFunc.LoadShaderSource(glHandle shaderHandle, string codeStream)
        {
-            frameOpBuffer.Enqueue(shaderHandle);
-            frameOpBuffer.Enqueue(codeStream);
-            frameOpBuffer.Enqueue(ShaderSourcePtr);
+            frameOpBuffer.ParamEnqueue(shaderHandle);
+            frameOpBuffer.ParamEnqueue(codeStream);
+            frameOpBuffer.MethodEnqueue(ShaderSourcePtr);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -313,40 +313,38 @@ namespace StgSharp.Graphics

        void IglFunc.SetBufferData<T>(BufferType bufferType, T bufferData, BufferUsage usage)
        {
-            frameOpBuffer.Enqueue((uint)bufferType, (uint)usage);
-            frameOpBuffer.Enqueue((IntPtr)sizeof(T));
-            frameOpBuffer.Enqueue<T>(new T[] { bufferData });
-            frameOpBuffer.Enqueue(BufferDataPtr);
+            frameOpBuffer.ParamEnqueue((uint)bufferType, (uint)usage);
+            frameOpBuffer.ParamEnqueue((IntPtr)sizeof(T));
+            frameOpBuffer.ParamEnqueue<T>(new T[] { bufferData });
+            frameOpBuffer.MethodEnqueue(BufferDataPtr);
        }

        void IglFunc.SetBufferData<T>(BufferType bufferType, T[] bufferArray, BufferUsage usage)
        {
-            frameOpBuffer.Enqueue((uint)bufferType, (uint)usage);
-            frameOpBuffer.Enqueue((IntPtr)(Marshal.SizeOf<T>() * bufferArray.Length));
-            frameOpBuffer.Enqueue<T>(bufferArray);
-            frameOpBuffer.Enqueue(BufferDataPtr);
+            frameOpBuffer.ParamEnqueue((uint)bufferType, (uint)usage);
+            frameOpBuffer.ParamEnqueue((IntPtr)(Marshal.SizeOf<T>() * bufferArray.Length));
+            frameOpBuffer.ParamEnqueue<T>(bufferArray);
+            frameOpBuffer.MethodEnqueue(BufferDataPtr);
        }

        void IglFunc.SetVertexAttribute(uint index, int size, TypeCode t, bool normalized, uint stride, int pointer)
        {
            uint type = InternalIO.GLtype[t];
-            frameOpBuffer.Enqueue(index, type, stride);
-            frameOpBuffer.Enqueue(size, normalized ? 1 : 0, pointer);
-            frameOpBuffer.Enqueue(SetVertexArrayPtr);
+            frameOpBuffer.ParamEnqueue(index, type, stride);
+            frameOpBuffer.ParamEnqueue(size, normalized ? 1 : 0, pointer);
+            frameOpBuffer.MethodEnqueue(SetVertexArrayPtr);
        }

-        //TODO:双线程，换运行环境
        void IglFunc.SwitchContext()
        {
-            frameOpBuffer.context = api;
        }

        unsafe void IglFunc.TextureImage2d<T>(int target, int level, uint internalformat, uint width, uint height, uint format, uint type, glHandle pixels)
        {
-            frameOpBuffer.Enqueue(pixels);
-            frameOpBuffer.Enqueue((uint)level, internalformat, width, height);
-            frameOpBuffer.Enqueue((uint)target, format, type);
-            frameOpBuffer.Enqueue(textureImage2dPtr);
+            frameOpBuffer.ParamEnqueue(pixels);
+            frameOpBuffer.ParamEnqueue((uint)level, internalformat, width, height);
+            frameOpBuffer.ParamEnqueue((uint)target, format, type);
+            frameOpBuffer.MethodEnqueue(textureImage2dPtr);
        }

        void IglFunc.TextureParameter(int target, uint pname, int param)
@@ -355,21 +353,21 @@ namespace StgSharp.Graphics
            m.Write<int>(0, target);
            m.Write<uint>(2, pname);
            m.Write<int>(3, param);
-            frameOpBuffer.Enqueue(m);
-            frameOpBuffer.Enqueue(TextureParameterPtr);
+            frameOpBuffer.ParamEnqueue(m);
+            frameOpBuffer.MethodEnqueue(TextureParameterPtr);
        }

        void IglFunc.UseProgram(glHandle program)
        {
-            frameOpBuffer.Enqueue((IntPtr)program.valuePtr);
-            frameOpBuffer.Enqueue(UseProgramPtr);
+            frameOpBuffer.ParamEnqueue((IntPtr)program.valuePtr);
+            frameOpBuffer.MethodEnqueue(UseProgramPtr);
        }

        void IglFunc.Viewport(int x, int y, uint width, uint height)
        {
            Vec4d v = new Vec4d(x, y, (int)width, (int)height);
-            frameOpBuffer.Enqueue(v);
-            frameOpBuffer.Enqueue(ViewPortPtr);
+            frameOpBuffer.ParamEnqueue(v);
+            frameOpBuffer.MethodEnqueue(ViewPortPtr);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -377,27 +375,9 @@ namespace StgSharp.Graphics
        {
            foreach (M128 item in param)
            {
-                frameOpBuffer.Enqueue(item);
-            }
-            frameOpBuffer.Enqueue(methodHandle);
-        }
-
-        bool IglFunc.FrameCanUpdate
-        {
-            get
-            {
-                if (unupdatedFrame.DirectValue > 5)
-                {
-                    return false;
-                }
-                else
-                {
-                    *unupdatedFrame.valuePtr += 1;
-                    frameOpBuffer.Enqueue((IntPtr)unupdatedFrame.valuePtr);
-                    frameOpBuffer.Enqueue(CanUpdatePtr);
-                    return true;
-                }
+                frameOpBuffer.ParamEnqueue(item);
            }
+            frameOpBuffer.ParamEnqueue(methodHandle);
        }
    }
 }