Add UnmanagedFunctionPointer

5 years ago · 6d506a65b6
3 changed files with 120 additions and 36 deletions
--- a/src/Avalonia.OpenGL/Egl/EglInterface.cs
+++ b/src/Avalonia.OpenGL/Egl/EglInterface.cs
@ -46,93 +46,114 @@ namespace Avalonia.OpenGL.Egl
        }

        // ReSharper disable UnassignedGetOnlyAutoProperty
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate int EglGetError();
        [GlEntryPoint("eglGetError")]
        public EglGetError GetError { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr EglGetDisplay(IntPtr nativeDisplay);
        [GlEntryPoint("eglGetDisplay")]
        public EglGetDisplay GetDisplay { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr EglGetPlatformDisplayEXT(int platform, IntPtr nativeDisplay, int[] attrs);
        [GlEntryPoint("eglGetPlatformDisplayEXT")]
        [GlOptionalEntryPoint]
        public EglGetPlatformDisplayEXT GetPlatformDisplayEXT { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglInitialize(IntPtr display, out int major, out int minor);
        [GlEntryPoint("eglInitialize")]
-        public EglInitialize Initialize { get; }        
-        
+        public EglInitialize Initialize { get; }
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr EglGetProcAddress(Utf8Buffer proc);
        [GlEntryPoint("eglGetProcAddress")]
        public EglGetProcAddress GetProcAddress { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglBindApi(int api);
        [GlEntryPoint("eglBindAPI")]
        public EglBindApi BindApi { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglChooseConfig(IntPtr display, int[] attribs,
            out IntPtr surfaceConfig, int numConfigs, out int choosenConfig);
        [GlEntryPoint("eglChooseConfig")]
        public EglChooseConfig ChooseConfig { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr EglCreateContext(IntPtr display, IntPtr config,
            IntPtr share, int[] attrs);
        [GlEntryPoint("eglCreateContext")]
        public EglCreateContext CreateContext { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglDestroyContext(IntPtr display, IntPtr context);
        [GlEntryPoint("eglDestroyContext")]
        public EglDestroyContext DestroyContext { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr EglCreatePBufferSurface(IntPtr display, IntPtr config, int[] attrs);
        [GlEntryPoint("eglCreatePbufferSurface")]
        public EglCreatePBufferSurface CreatePBufferSurface { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglMakeCurrent(IntPtr display, IntPtr draw, IntPtr read, IntPtr context);
        [GlEntryPoint("eglMakeCurrent")]
        public EglMakeCurrent MakeCurrent { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr EglGetCurrentContext();
        [GlEntryPoint("eglGetCurrentContext")]
        public EglGetCurrentContext GetCurrentContext { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr EglGetCurrentDisplay();
        [GlEntryPoint("eglGetCurrentDisplay")]
        public EglGetCurrentContext GetCurrentDisplay { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr EglGetCurrentSurface(int readDraw);
        [GlEntryPoint("eglGetCurrentSurface")] 
        public EglGetCurrentSurface GetCurrentSurface { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void EglDisplaySurfaceVoidDelegate(IntPtr display, IntPtr surface);
        [GlEntryPoint("eglDestroySurface")]
        public EglDisplaySurfaceVoidDelegate DestroySurface { get; }
        
        [GlEntryPoint("eglSwapBuffers")]
        public EglDisplaySurfaceVoidDelegate SwapBuffers { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr
            EglCreateWindowSurface(IntPtr display, IntPtr config, IntPtr window, int[] attrs);
        [GlEntryPoint("eglCreateWindowSurface")]
        public EglCreateWindowSurface CreateWindowSurface { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglGetConfigAttrib(IntPtr display, IntPtr config, int attr, out int rv);
        [GlEntryPoint("eglGetConfigAttrib")]
        public EglGetConfigAttrib GetConfigAttrib { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglWaitGL();
        [GlEntryPoint("eglWaitGL")]
        public EglWaitGL WaitGL { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglWaitClient();
        [GlEntryPoint("eglWaitClient")]
        public EglWaitGL WaitClient { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglWaitNative(int engine);
        [GlEntryPoint("eglWaitNative")]
        public EglWaitNative WaitNative { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr EglQueryString(IntPtr display, int i);
        
        [GlEntryPoint("eglQueryString")]
@ -145,17 +166,20 @@ namespace Avalonia.OpenGL.Egl
                return null;
            return Marshal.PtrToStringAnsi(rv);
        }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr EglCreatePbufferFromClientBuffer(IntPtr display, int buftype, IntPtr buffer, IntPtr config, int[] attrib_list);
        [GlEntryPoint("eglCreatePbufferFromClientBuffer")]

        public EglCreatePbufferFromClientBuffer CreatePbufferFromClientBuffer { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglQueryDisplayAttribEXT(IntPtr display, int attr, out IntPtr res);

        [GlEntryPoint("eglQueryDisplayAttribEXT"), GlOptionalEntryPoint]
        public EglQueryDisplayAttribEXT QueryDisplayAttribExt { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate bool EglQueryDeviceAttribEXT(IntPtr display, int attr, out IntPtr res);

        [GlEntryPoint("eglQueryDeviceAttribEXT"), GlOptionalEntryPoint]
--- a/src/Avalonia.OpenGL/GlBasicInfoInterface.cs
+++ b/src/Avalonia.OpenGL/GlBasicInfoInterface.cs
@ -15,9 +15,12 @@ namespace Avalonia.OpenGL
        public GlBasicInfoInterface(Func<Utf8Buffer, IntPtr> nativeGetProcAddress) : base(nativeGetProcAddress, null)
        {
        }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlGetIntegerv(int name, out int rv);
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr GlGetString(int v);
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr GlGetStringi(int v, int v1);
    }
    
--- a/src/Avalonia.OpenGL/GlInterface.cs
+++ b/src/Avalonia.OpenGL/GlInterface.cs
@ -60,22 +60,27 @@ namespace Avalonia.OpenGL
        public T GetProcAddress<T>(string proc) => Marshal.GetDelegateForFunctionPointer<T>(GetProcAddress(proc));

        // ReSharper disable UnassignedGetOnlyAutoProperty
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate int GlGetError();
        [GlEntryPoint("glGetError")]
        public GlGetError GetError { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlClearStencil(int s);
        [GlEntryPoint("glClearStencil")]
        public GlClearStencil ClearStencil { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlClearColor(float r, float g, float b, float a);
        [GlEntryPoint("glClearColor")]
        public GlClearColor ClearColor { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlClear(int bits);
        [GlEntryPoint("glClear")]
        public GlClear Clear { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlViewport(int x, int y, int width, int height);
        [GlEntryPoint("glViewport")]
        public GlViewport Viewport { get; }
@ -86,6 +91,7 @@ namespace Avalonia.OpenGL
        [GlEntryPoint("glFinish")]
        public Action Finish { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate IntPtr GlGetString(int v);
        [GlEntryPoint("glGetString")]
        public GlGetString GetStringNative { get; }
@ -98,26 +104,32 @@ namespace Avalonia.OpenGL
            return null;
        }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlGetIntegerv(int name, out int rv);
        [GlEntryPoint("glGetIntegerv")]
        public GlGetIntegerv GetIntegerv { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlGenFramebuffers(int count, int[] res);
        [GlEntryPoint("glGenFramebuffers")]
        public GlGenFramebuffers GenFramebuffers { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlDeleteFramebuffers(int count, int[] framebuffers);
        [GlEntryPoint("glDeleteFramebuffers")]
        public GlDeleteFramebuffers DeleteFramebuffers { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlBindFramebuffer(int target, int fb);
        [GlEntryPoint("glBindFramebuffer")]
        public GlBindFramebuffer BindFramebuffer { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate int GlCheckFramebufferStatus(int target);
        [GlEntryPoint("glCheckFramebufferStatus")]
        public GlCheckFramebufferStatus CheckFramebufferStatus { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlBlitFramebuffer(int srcX0,
            int srcY0,
            int srcX1,
@ -130,69 +142,84 @@ namespace Avalonia.OpenGL
            int filter);
        [GlMinVersionEntryPoint("glBlitFramebuffer", 3, 0), GlOptionalEntryPoint]
        public GlBlitFramebuffer BlitFramebuffer { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlGenRenderbuffers(int count, int[] res);
        [GlEntryPoint("glGenRenderbuffers")]
        public GlGenRenderbuffers GenRenderbuffers { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlDeleteRenderbuffers(int count, int[] renderbuffers);
        [GlEntryPoint("glDeleteRenderbuffers")]
        public GlDeleteTextures DeleteRenderbuffers { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlBindRenderbuffer(int target, int fb);
        [GlEntryPoint("glBindRenderbuffer")]
        public GlBindRenderbuffer BindRenderbuffer { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlRenderbufferStorage(int target, int internalFormat, int width, int height);
        [GlEntryPoint("glRenderbufferStorage")]
        public GlRenderbufferStorage RenderbufferStorage { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlFramebufferRenderbuffer(int target, int attachment,
            int renderbufferTarget, int renderbuffer);
        [GlEntryPoint("glFramebufferRenderbuffer")]
        public GlFramebufferRenderbuffer FramebufferRenderbuffer { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlGenTextures(int count, int[] res);
        [GlEntryPoint("glGenTextures")]
        public GlGenTextures GenTextures { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlBindTexture(int target, int fb);
        [GlEntryPoint("glBindTexture")]
        public GlBindTexture BindTexture { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlActiveTexture(int texture);
        [GlEntryPoint("glActiveTexture")]
        public GlActiveTexture ActiveTexture { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlDeleteTextures(int count, int[] textures);
        [GlEntryPoint("glDeleteTextures")]
        public GlDeleteTextures DeleteTextures { get; }


+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlTexImage2D(int target, int level, int internalFormat, int width, int height, int border,
            int format, int type, IntPtr data);
        [GlEntryPoint("glTexImage2D")]
        public GlTexImage2D TexImage2D { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlCopyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y,
            int width, int height);
        
        [GlEntryPoint("glCopyTexSubImage2D")]
        public GlCopyTexSubImage2D CopyTexSubImage2D { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlTexParameteri(int target, int name, int value);
        [GlEntryPoint("glTexParameteri")]
        public GlTexParameteri TexParameteri { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlFramebufferTexture2D(int target, int attachment,
            int texTarget, int texture, int level);
        [GlEntryPoint("glFramebufferTexture2D")]
        public GlFramebufferTexture2D FramebufferTexture2D { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate int GlCreateShader(int shaderType);
        [GlEntryPoint("glCreateShader")]
        public GlCreateShader CreateShader { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlShaderSource(int shader, int count, IntPtr strings, IntPtr lengths);
        [GlEntryPoint("glShaderSource")]
        public GlShaderSource ShaderSource { get; }
@ -207,14 +234,17 @@ namespace Avalonia.OpenGL
            }
        }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlCompileShader(int shader);
        [GlEntryPoint("glCompileShader")]
        public GlCompileShader CompileShader { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlGetShaderiv(int shader, int name, int* parameters);
        [GlEntryPoint("glGetShaderiv")]
        public GlGetShaderiv GetShaderiv { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlGetShaderInfoLog(int shader, int maxLength, out int length, void*infoLog);
        [GlEntryPoint("glGetShaderInfoLog")]
        public GlGetShaderInfoLog GetShaderInfoLog { get; }
@ -237,23 +267,28 @@ namespace Avalonia.OpenGL
                GetShaderInfoLog(shader, logLength, out len, ptr);
            return Encoding.UTF8.GetString(logData,0, len);
        }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate int GlCreateProgram();
        [GlEntryPoint("glCreateProgram")]
        public GlCreateProgram CreateProgram { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlAttachShader(int program, int shader);
        [GlEntryPoint("glAttachShader")]
        public GlAttachShader AttachShader { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlLinkProgram(int program);
        [GlEntryPoint("glLinkProgram")]
        public GlLinkProgram LinkProgram { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlGetProgramiv(int program, int name, int* parameters);
        [GlEntryPoint("glGetProgramiv")]
        public GlGetProgramiv GetProgramiv { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlGetProgramInfoLog(int program, int maxLength, out int len, void* infoLog);
        [GlEntryPoint("glGetProgramInfoLog")]
        public GlGetProgramInfoLog GetProgramInfoLog { get; }
@ -274,6 +309,7 @@ namespace Avalonia.OpenGL
            return Encoding.UTF8.GetString(logData,0, len);
        }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlBindAttribLocation(int program, int index, IntPtr name);
        [GlEntryPoint("glBindAttribLocation")]
        public GlBindAttribLocation BindAttribLocation { get; }
@ -283,7 +319,8 @@ namespace Avalonia.OpenGL
            using (var b = new Utf8Buffer(name))
                BindAttribLocation(program, index, b.DangerousGetHandle());
        }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlGenBuffers(int len, int[] rv);
        [GlEntryPoint("glGenBuffers")]
        public GlGenBuffers GenBuffers { get; }
@ -294,15 +331,18 @@ namespace Avalonia.OpenGL
            GenBuffers(1, rv);
            return rv[0];
        }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlBindBuffer(int target, int buffer);
        [GlEntryPoint("glBindBuffer")]
        public GlBindBuffer BindBuffer { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlBufferData(int target, IntPtr size, IntPtr data, int usage);
        [GlEntryPoint("glBufferData")]
        public GlBufferData BufferData { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate int GlGetAttribLocation(int program, IntPtr name);
        [GlEntryPoint("glGetAttribLocation")]
        public GlGetAttribLocation GetAttribLocation { get; }
@ -313,27 +353,33 @@ namespace Avalonia.OpenGL
                return GetAttribLocation(program, b.DangerousGetHandle());
        }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlVertexAttribPointer(int index, int size, int type,
            int normalized, int stride, IntPtr pointer);
        [GlEntryPoint("glVertexAttribPointer")]
        public GlVertexAttribPointer VertexAttribPointer { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlEnableVertexAttribArray(int index);
        [GlEntryPoint("glEnableVertexAttribArray")]
        public GlEnableVertexAttribArray EnableVertexAttribArray { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlUseProgram(int program);
        [GlEntryPoint("glUseProgram")]
        public GlUseProgram UseProgram { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlDrawArrays(int mode, int first, IntPtr count);
        [GlEntryPoint("glDrawArrays")]
        public GlDrawArrays DrawArrays { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlDrawElements(int mode, int count, int type, IntPtr indices);
        [GlEntryPoint("glDrawElements")]
        public GlDrawElements DrawElements { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate int GlGetUniformLocation(int program, IntPtr name);
        [GlEntryPoint("glGetUniformLocation")]
        public GlGetUniformLocation GetUniformLocation { get; }
@ -343,31 +389,42 @@ namespace Avalonia.OpenGL
            using (var b = new Utf8Buffer(name))
                return GetUniformLocation(program, b.DangerousGetHandle());
        }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlUniform1f(int location, float falue);
        [GlEntryPoint("glUniform1f")]
        public GlUniform1f Uniform1f { get; }

-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlUniformMatrix4fv(int location, int count, bool transpose, void* value);
        [GlEntryPoint("glUniformMatrix4fv")]
        public GlUniformMatrix4fv UniformMatrix4fv { get; }
-        
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlEnable(int what);
        [GlEntryPoint("glEnable")]
        public GlEnable Enable { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlDeleteBuffers(int count, int[] buffers);
        [GlEntryPoint("glDeleteBuffers")]
        public GlDeleteBuffers DeleteBuffers { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlDeleteProgram(int program);
        [GlEntryPoint("glDeleteProgram")]
        public GlDeleteProgram DeleteProgram { get; }

+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate void GlDeleteShader(int shader);
        [GlEntryPoint("glDeleteShader")]
        public GlDeleteShader DeleteShader { get; }
+        
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        public delegate void GLGetRenderbufferParameteriv(int target, int name, int[] value);
+        [GlEntryPoint("glGetRenderbufferParameteriv")]
+        public GLGetRenderbufferParameteriv GetRenderbufferParameteriv { get; }
        // ReSharper restore UnassignedGetOnlyAutoProperty
    }
 }