daily update on 20240312 by nitload youmu

2024-03-12 16:17:01 +08:00
parent 6a0cccae79
commit a770bbe685
62 changed files with 1080 additions and 2346 deletions
@@ -15,24 +15,17 @@ namespace StgSharp.Graphics
 {
    internal unsafe partial class GLonUpdate : IglFunc
    {
-        private static ConcurrentQueue<IntPtr> glActionQueue;
-        private static GLparamQueue paramQueue;
+        private static FrameOperationBuffer frameOpBuffer;
        private GLcontext* api;
-        private FrameTimeoutException refreshSignal = new();
        private IntPtr SwapBufferPtr = (IntPtr)(delegate*<IntPtr, void>)&InternalIO.glfwSwapBuffers;
-
-        internal void ShowDequeueStream()
-        {
-            paramQueue.ShowDequeueLog();
-        }
+        private glSHandle unupdatedFrame = glSHandle.Alloc(0);

        internal GLonUpdate(GLcontext* context)
        {
-            if (paramQueue == null)
+            if (frameOpBuffer == null)
            {
-                paramQueue = new GLparamQueue();
+                frameOpBuffer = new FrameOperationBuffer();
            }
-            glActionQueue = new ConcurrentQueue<IntPtr>();
            api = context;
        }

@@ -41,23 +34,16 @@ namespace StgSharp.Graphics
            get => api;
        }

-        internal static GLparamQueue ParamQueue
+        public FrameOperationBuffer ActivatedOperationBuffer
        {
-            get { return paramQueue; }
-        }
-
-        internal ConcurrentQueue<IntPtr> GLactionQueue
-        {
-            get
-            {
-                return glActionQueue;
-            }
+            get { return frameOpBuffer; }
+            set { frameOpBuffer = value; }
        }

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

        void IglFunc.AfterAlign(Form form, Action action)
@@ -67,20 +53,14 @@ namespace StgSharp.Graphics

        void IglFunc.AlignFrame(Form form)
        {
-            if (form.timer.alignSign.byte0 > 0)
-            {
-                throw new InvalidOperationException();
-            }
-            form.timer.alignSign.byte0++;
-            form.timer.WaitNextFrame();
-            throw refreshSignal;
+            throw new NotImplementedException();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        unsafe void IglFunc.AttachShader(glHandle program, glHandle shader)
        {
-            paramQueue.Enqueue(program, shader);
-            glActionQueue.Enqueue(AttachShaderPtr);
+            frameOpBuffer.Enqueue(program, shader);
+            frameOpBuffer.Enqueue(AttachShaderPtr);
        }

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

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

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

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

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

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

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

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

-        //TODO
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        glHandleSet IglFunc.CreateProgram(int count)
        {
@@ -153,8 +132,8 @@ namespace StgSharp.Graphics
            glHandleSet h = new glHandleSet(count);
            m.Write<ulong>(0, (ulong)h.handle);
            m.Write<int>(2, count);
-            paramQueue.Enqueue(m);
-            glActionQueue.Enqueue(CreateProgramSetPtr);
+            frameOpBuffer.Enqueue(m);
+            frameOpBuffer.Enqueue(CreateProgramSetPtr);
            return h;
        }

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

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

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

        unsafe void IglFunc.DeleteBuffers(glHandleSet handle)
        {
            M128 m = default;
-            m.Write<uint>(2, (uint)handle.length);
            m.Write<ulong>(0, (ulong)handle.handle);
-            paramQueue.Enqueue(m);
-            glActionQueue.Enqueue(DeleBufferPtr);
+            m.Write<uint>(2, (uint)handle.length);
+            frameOpBuffer.Enqueue(m);
+            frameOpBuffer.Enqueue(DeleBufferPtr);
        }

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

        void IglFunc.DrawElements(GepmetryType mode, uint count, TypeCode type, IntPtr ptr)
@@ -255,17 +234,17 @@ namespace StgSharp.Graphics
                        LogType.Error);
                    return;
            }
-            paramQueue.Enqueue((uint)mode, count, a);
-            paramQueue.Enqueue(ptr);
-            glActionQueue.Enqueue(DrawElementsPtr);
+            frameOpBuffer.Enqueue((uint)mode, count, a);
+            frameOpBuffer.Enqueue(ptr);
+            frameOpBuffer.Enqueue(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);
-            paramQueue.Enqueue(m);
-            glActionQueue.Enqueue(GenBufferPtr);
+            frameOpBuffer.Enqueue(m);
+            frameOpBuffer.Enqueue(GenBufferPtr);
            return h;
        }

@@ -273,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);
-            paramQueue.Enqueue(m);
-            glActionQueue.Enqueue(GenTexturesPtr);
+            frameOpBuffer.Enqueue(m);
+            frameOpBuffer.Enqueue(GenTexturesPtr);
            return h;
        }

@@ -282,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);
-            paramQueue.Enqueue(m);
-            glActionQueue.Enqueue(GenTexturesPtr);
+            frameOpBuffer.Enqueue(m);
+            frameOpBuffer.Enqueue(GenTexturesPtr);
            return h;
        }

@@ -293,10 +272,10 @@ namespace StgSharp.Graphics
            glSHandle h = glSHandle.Alloc(0);
            M128 m = default;
            m.Write<ulong>(0, (ulong)program.Handle);
-            m.Write<ulong>(1, (ulong)GCHandle.Alloc(Encoding.UTF8.GetBytes(ptr)).AddrOfPinnedObject());
-            paramQueue.Enqueue(m);
-            paramQueue.Enqueue((IntPtr)h.valuePtr);
-            glActionQueue.Enqueue(GetUniformLocationPtr);
+            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);
            return h;
        }

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

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

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

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

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

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

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

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

        void IglFunc.TextureParameter(int target, uint pname, int param)
@@ -374,31 +355,49 @@ namespace StgSharp.Graphics
            m.Write<int>(0, target);
            m.Write<uint>(2, pname);
            m.Write<int>(3, param);
-            paramQueue.Enqueue(m);
-            glActionQueue.Enqueue(TextureParameterPtr);
+            frameOpBuffer.Enqueue(m);
+            frameOpBuffer.Enqueue(TextureParameterPtr);
        }

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

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void frameworkHandleEnqueue(IntPtr methodHandle, params M128[] param)
+        void IglFunc.frameworkHandleEnqueue(IntPtr methodHandle, params M128[] param)
        {
            foreach (M128 item in param)
            {
-                paramQueue.Enqueue(item);
+                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;
+                }
            }
-            glActionQueue.Enqueue(methodHandle);
        }
    }
 }