diff --git a/src/Avalonia.OpenGL/Egl/EglInterface.cs b/src/Avalonia.OpenGL/Egl/EglInterface.cs
index cadd7cc1f22..6148e58440a 100644
--- a/src/Avalonia.OpenGL/Egl/EglInterface.cs
+++ b/src/Avalonia.OpenGL/Egl/EglInterface.cs
@@ -46,93 +46,114 @@ static Func<string, IntPtr> Load(string library)
         }
 
         // 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 @@ public string QueryString(IntPtr display, int i)
                 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]
diff --git a/src/Avalonia.OpenGL/GlBasicInfoInterface.cs b/src/Avalonia.OpenGL/GlBasicInfoInterface.cs
index a3383ac5ae3..aaba2ec09ca 100644
--- a/src/Avalonia.OpenGL/GlBasicInfoInterface.cs
+++ b/src/Avalonia.OpenGL/GlBasicInfoInterface.cs
@@ -15,9 +15,12 @@ public GlBasicInfoInterface(Func<string, IntPtr> getProcAddress) : base(getProcA
         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);
     }
     
diff --git a/src/Avalonia.OpenGL/GlInterface.cs b/src/Avalonia.OpenGL/GlInterface.cs
index cae245732f0..3d947998af9 100644
--- a/src/Avalonia.OpenGL/GlInterface.cs
+++ b/src/Avalonia.OpenGL/GlInterface.cs
@@ -60,22 +60,27 @@ public static GlInterface FromNativeUtf8GetProcAddress(GlVersion version, Func<U
         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 @@ public static GlInterface FromNativeUtf8GetProcAddress(GlVersion version, Func<U
         [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 @@ public string GetString(int v)
             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 @@ public delegate void GlBlitFramebuffer(int srcX0,
             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 @@ public void ShaderSourceString(int shader, string source)
             }
         }
 
+        [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 @@ public unsafe string CompileShaderAndGetError(int shader, string source)
                 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 @@ public unsafe string LinkProgramAndGetError(int program)
             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 @@ public void BindAttribLocationString(int program, int index, string name)
             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 @@ public int GenBuffer()
             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 @@ public int GetAttribLocationString(int program, string name)
                 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 @@ public int GetUniformLocationString(int program, string name)
             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
     }
 }