//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="glFunction.v4_5"
// Project: StgSharp
// AuthorGroup: Nitload
// Copyright (c) Nitload. All rights reserved.
//     
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//     
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
// <auto-generated>
// Generated by StgSharp.GenerateGL on 2025-12-30 02:54:41Z
// Version: 4.5
// </auto-generated>
using StgSharp.Graphics.OpenGL;
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace StgSharp.Graphics.OpenGL
{
    public unsafe partial class OpenGLFunction
    {

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void BindTextureUnit(
                    uint unit,
                    GlHandle texture
        )
        {
            Context.glBindTextureUnit(unit, texture.Value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void BlitNamedFramebuffer(
                    GlHandle readFramebuffer,
                    GlHandle drawFramebuffer,
                    int srcX0,
                    int srcY0,
                    int srcX1,
                    int srcY1,
                    int dstX0,
                    int dstY0,
                    int dstX1,
                    int dstY1,
                    uint mask,
                    uint filter
        )
        {
            Context.glBlitNamedFramebuffer(readFramebuffer.Value, drawFramebuffer.Value, srcX0,
                                           srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
                                           filter);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public uint CheckNamedFramebufferStatus(
                    GlHandle framebuffer,
                    uint target
        )
        {
            return Context.glCheckNamedFramebufferStatus(framebuffer.Value, target);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearNamedBufferData(
                    GlHandle buffer,
                    uint internalformat,
                    uint format,
                    ShaderType type,
                    ReadOnlySpan<IntPtr> data
        )
        {
            fixed (IntPtr* dataPtr = data) {
                Context.glClearNamedBufferData(buffer.Value, internalformat, format, (uint)type,
                                               dataPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearNamedBufferSubData(
                    GlHandle buffer,
                    uint internalformat,
                    nint offset,
                    nuint size,
                    uint format,
                    ShaderType type,
                    ReadOnlySpan<IntPtr> data
        )
        {
            fixed (IntPtr* dataPtr = data) {
                Context.glClearNamedBufferSubData(buffer.Value, internalformat, offset, size,
                                                  format, (uint)type, dataPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearNamedFramebufferfi(
                    GlHandle framebuffer,
                    uint buffer,
                    int drawbuffer,
                    float depth,
                    int stencil
        )
        {
            Context.glClearNamedFramebufferfi(framebuffer.Value, buffer, drawbuffer, depth,
                                              stencil);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearNamedFramebufferfv(
                    GlHandle framebuffer,
                    uint buffer,
                    int drawbuffer,
                    ReadOnlySpan<float> value
        )
        {
            fixed (float* valuePtr = value) {
                Context.glClearNamedFramebufferfv(framebuffer.Value, buffer, drawbuffer, valuePtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearNamedFramebufferiv(
                    GlHandle framebuffer,
                    uint buffer,
                    int drawbuffer,
                    ReadOnlySpan<int> value
        )
        {
            fixed (int* valuePtr = value) {
                Context.glClearNamedFramebufferiv(framebuffer.Value, buffer, drawbuffer, valuePtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearNamedFramebufferuiv(
                    GlHandle framebuffer,
                    uint buffer,
                    int drawbuffer,
                    ReadOnlySpan<uint> value
        )
        {
            fixed (uint* valuePtr = value) {
                Context.glClearNamedFramebufferuiv(framebuffer.Value, buffer, drawbuffer, valuePtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClipControl(
                    uint origin,
                    uint depth
        )
        {
            Context.glClipControl(origin, depth);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CompressedTextureSubImage1D(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int width,
                    uint format,
                    int imageSize,
                    ReadOnlySpan<IntPtr> data
        )
        {
            fixed (IntPtr* dataPtr = data) {
                Context.glCompressedTextureSubImage1D(texture.Value, level, xoffset, width, format,
                                                      imageSize, dataPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CompressedTextureSubImage2D(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int yoffset,
                    int width,
                    int height,
                    uint format,
                    int imageSize,
                    ReadOnlySpan<IntPtr> data
        )
        {
            fixed (IntPtr* dataPtr = data) {
                Context.glCompressedTextureSubImage2D(texture.Value, level, xoffset, yoffset, width,
                                                      height, format, imageSize, dataPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CompressedTextureSubImage3D(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int yoffset,
                    int zoffset,
                    int width,
                    int height,
                    int depth,
                    uint format,
                    int imageSize,
                    ReadOnlySpan<IntPtr> data
        )
        {
            fixed (IntPtr* dataPtr = data) {
                Context.glCompressedTextureSubImage3D(texture.Value, level, xoffset, yoffset,
                                                      zoffset, width, height, depth, format,
                                                      imageSize, dataPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CopyNamedBufferSubData(
                    GlHandle readBuffer,
                    GlHandle writeBuffer,
                    nint readOffset,
                    nint writeOffset,
                    nuint size
        )
        {
            Context.glCopyNamedBufferSubData(readBuffer.Value, writeBuffer.Value, readOffset,
                                             writeOffset, size);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CopyTextureSubImage1D(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int x,
                    int y,
                    int width
        )
        {
            Context.glCopyTextureSubImage1D(texture.Value, level, xoffset, x, y, width);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CopyTextureSubImage2D(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int yoffset,
                    int x,
                    int y,
                    int width,
                    int height
        )
        {
            Context.glCopyTextureSubImage2D(texture.Value, level, xoffset, yoffset, x, y, width,
                                            height);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CopyTextureSubImage3D(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int yoffset,
                    int zoffset,
                    int x,
                    int y,
                    int width,
                    int height
        )
        {
            Context.glCopyTextureSubImage3D(texture.Value, level, xoffset, yoffset, zoffset, x, y,
                                            width, height);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateBuffers(
                    int n,
                    uint* buffers
        )
        {
            Context.glCreateBuffers(n, buffers);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateFramebuffers(
                    int n,
                    uint* framebuffers
        )
        {
            Context.glCreateFramebuffers(n, framebuffers);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateProgramPipelines(
                    int n,
                    uint* pipelines
        )
        {
            Context.glCreateProgramPipelines(n, pipelines);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateQueries(
                    uint target,
                    int n,
                    uint* ids
        )
        {
            Context.glCreateQueries(target, n, ids);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateRenderbuffers(
                    int n,
                    uint* renderbuffers
        )
        {
            Context.glCreateRenderbuffers(n, renderbuffers);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateSamplers(
                    int n,
                    uint* samplers
        )
        {
            Context.glCreateSamplers(n, samplers);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateTextures(
                    uint target,
                    int n,
                    uint* textures
        )
        {
            Context.glCreateTextures(target, n, textures);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateTransformFeedbacks(
                    int n,
                    uint* ids
        )
        {
            Context.glCreateTransformFeedbacks(n, ids);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateVertexArrays(
                    int n,
                    uint* arrays
        )
        {
            Context.glCreateVertexArrays(n, arrays);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void DisableVertexArrayAttrib(
                    uint vaobj,
                    uint index
        )
        {
            Context.glDisableVertexArrayAttrib(vaobj, index);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void EnableVertexArrayAttrib(
                    uint vaobj,
                    uint index
        )
        {
            Context.glEnableVertexArrayAttrib(vaobj, index);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void FlushMappedNamedBufferRange(
                    GlHandle buffer,
                    nint offset,
                    nuint length
        )
        {
            Context.glFlushMappedNamedBufferRange(buffer.Value, offset, length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GenerateTextureMipmap(
                    GlHandle texture
        )
        {
            Context.glGenerateTextureMipmap(texture.Value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetCompressedTextureImage(
                    GlHandle texture,
                    int level,
                    int bufSize,
                    IntPtr* pixels
        )
        {
            Context.glGetCompressedTextureImage(texture.Value, level, bufSize, pixels);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetCompressedTextureSubImage(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int yoffset,
                    int zoffset,
                    int width,
                    int height,
                    int depth,
                    int bufSize,
                    IntPtr* pixels
        )
        {
            Context.glGetCompressedTextureSubImage(texture.Value, level, xoffset, yoffset, zoffset,
                                                   width, height, depth, bufSize, pixels);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public uint GetGraphicsResetStatus()
        {
            return Context.glGetGraphicsResetStatus();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetNamedBufferParameteri64v(
                    GlHandle buffer,
                    uint pname,
                    IntPtr* @params
        )
        {
            Context.glGetNamedBufferParameteri64v(buffer.Value, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetNamedBufferParameteriv(
                    GlHandle buffer,
                    uint pname,
                    int* @params
        )
        {
            Context.glGetNamedBufferParameteriv(buffer.Value, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetNamedBufferPointerv(
                    GlHandle buffer,
                    uint pname,
                    IntPtr* @params
        )
        {
            Context.glGetNamedBufferPointerv(buffer.Value, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetNamedBufferSubData(
                    GlHandle buffer,
                    nint offset,
                    nuint size,
                    IntPtr* data
        )
        {
            Context.glGetNamedBufferSubData(buffer.Value, offset, size, data);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetNamedFramebufferAttachmentParameteriv(
                    GlHandle framebuffer,
                    uint attachment,
                    uint pname,
                    int* @params
        )
        {
            Context.glGetNamedFramebufferAttachmentParameteriv(framebuffer.Value, attachment, pname,
                                                               @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetNamedFramebufferParameteriv(
                    GlHandle framebuffer,
                    uint pname,
                    int* param
        )
        {
            Context.glGetNamedFramebufferParameteriv(framebuffer.Value, pname, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetNamedRenderbufferParameteriv(
                    GlHandle renderbuffer,
                    uint pname,
                    int* @params
        )
        {
            Context.glGetNamedRenderbufferParameteriv(renderbuffer.Value, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetnCompressedTexImage(
                    uint target,
                    int lod,
                    int bufSize,
                    IntPtr* pixels
        )
        {
            Context.glGetnCompressedTexImage(target, lod, bufSize, pixels);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetnTexImage(
                    uint target,
                    int level,
                    uint format,
                    ShaderType type,
                    int bufSize,
                    IntPtr* pixels
        )
        {
            Context.glGetnTexImage(target, level, format, (uint)type, bufSize, pixels);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetnUniformdv(
                    GlHandle program,
                    int location,
                    int bufSize,
                    double* @params
        )
        {
            Context.glGetnUniformdv(program.Value, location, bufSize, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetnUniformfv(
                    GlHandle program,
                    int location,
                    int bufSize,
                    float* @params
        )
        {
            Context.glGetnUniformfv(program.Value, location, bufSize, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetnUniformiv(
                    GlHandle program,
                    int location,
                    int bufSize,
                    int* @params
        )
        {
            Context.glGetnUniformiv(program.Value, location, bufSize, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetnUniformuiv(
                    GlHandle program,
                    int location,
                    int bufSize,
                    uint* @params
        )
        {
            Context.glGetnUniformuiv(program.Value, location, bufSize, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetQueryBufferObjecti64v(
                    uint id,
                    GlHandle buffer,
                    uint pname,
                    nint offset
        )
        {
            Context.glGetQueryBufferObjecti64v(id, buffer.Value, pname, offset);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetQueryBufferObjectiv(
                    uint id,
                    GlHandle buffer,
                    uint pname,
                    nint offset
        )
        {
            Context.glGetQueryBufferObjectiv(id, buffer.Value, pname, offset);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetQueryBufferObjectui64v(
                    uint id,
                    GlHandle buffer,
                    uint pname,
                    nint offset
        )
        {
            Context.glGetQueryBufferObjectui64v(id, buffer.Value, pname, offset);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetQueryBufferObjectuiv(
                    uint id,
                    GlHandle buffer,
                    uint pname,
                    nint offset
        )
        {
            Context.glGetQueryBufferObjectuiv(id, buffer.Value, pname, offset);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTextureImage(
                    GlHandle texture,
                    int level,
                    uint format,
                    ShaderType type,
                    int bufSize,
                    IntPtr* pixels
        )
        {
            Context.glGetTextureImage(texture.Value, level, format, (uint)type, bufSize, pixels);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTextureLevelParameterfv(
                    GlHandle texture,
                    int level,
                    uint pname,
                    float* @params
        )
        {
            Context.glGetTextureLevelParameterfv(texture.Value, level, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTextureLevelParameteriv(
                    GlHandle texture,
                    int level,
                    uint pname,
                    int* @params
        )
        {
            Context.glGetTextureLevelParameteriv(texture.Value, level, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTextureParameterfv(
                    GlHandle texture,
                    uint pname,
                    float* @params
        )
        {
            Context.glGetTextureParameterfv(texture.Value, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTextureParameterIiv(
                    GlHandle texture,
                    uint pname,
                    int* @params
        )
        {
            Context.glGetTextureParameterIiv(texture.Value, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTextureParameterIuiv(
                    GlHandle texture,
                    uint pname,
                    uint* @params
        )
        {
            Context.glGetTextureParameterIuiv(texture.Value, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTextureParameteriv(
                    GlHandle texture,
                    uint pname,
                    int* @params
        )
        {
            Context.glGetTextureParameteriv(texture.Value, pname, @params);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTextureSubImage(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int yoffset,
                    int zoffset,
                    int width,
                    int height,
                    int depth,
                    uint format,
                    ShaderType type,
                    int bufSize,
                    IntPtr* pixels
        )
        {
            Context.glGetTextureSubImage(texture.Value, level, xoffset, yoffset, zoffset, width,
                                         height, depth, format, (uint)type, bufSize, pixels);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTransformFeedbacki_v(
                    uint xfb,
                    uint pname,
                    uint index,
                    int* param
        )
        {
            Context.glGetTransformFeedbacki_v(xfb, pname, index, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTransformFeedbacki64_v(
                    uint xfb,
                    uint pname,
                    uint index,
                    IntPtr* param
        )
        {
            Context.glGetTransformFeedbacki64_v(xfb, pname, index, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTransformFeedbackiv(
                    uint xfb,
                    uint pname,
                    int* param
        )
        {
            Context.glGetTransformFeedbackiv(xfb, pname, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetVertexArrayIndexed64iv(
                    uint vaobj,
                    uint index,
                    uint pname,
                    IntPtr* param
        )
        {
            Context.glGetVertexArrayIndexed64iv(vaobj, index, pname, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetVertexArrayIndexediv(
                    uint vaobj,
                    uint index,
                    uint pname,
                    int* param
        )
        {
            Context.glGetVertexArrayIndexediv(vaobj, index, pname, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetVertexArrayiv(
                    uint vaobj,
                    uint pname,
                    int* param
        )
        {
            Context.glGetVertexArrayiv(vaobj, pname, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void InvalidateNamedFramebufferData(
                    GlHandle framebuffer,
                    int numAttachments,
                    ReadOnlySpan<uint> attachments
        )
        {
            fixed (uint* attachmentsPtr = attachments) {
                Context.glInvalidateNamedFramebufferData(framebuffer.Value, numAttachments, attachmentsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void InvalidateNamedFramebufferSubData(
                    GlHandle framebuffer,
                    int numAttachments,
                    ReadOnlySpan<uint> attachments,
                    int x,
                    int y,
                    int width,
                    int height
        )
        {
            fixed (uint* attachmentsPtr = attachments) {
                Context.glInvalidateNamedFramebufferSubData(framebuffer.Value, numAttachments,
                                                            attachmentsPtr, x, y, width, height);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void MapNamedBuffer(
                    GlHandle buffer,
                    uint access
        )
        {
            Context.glMapNamedBuffer(buffer.Value, access);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void MapNamedBufferRange(
                    GlHandle buffer,
                    nint offset,
                    nuint length,
                    uint access
        )
        {
            Context.glMapNamedBufferRange(buffer.Value, offset, length, access);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void MemoryBarrierByRegion(
                    uint barriers
        )
        {
            Context.glMemoryBarrierByRegion(barriers);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedBufferData(
                    GlHandle buffer,
                    nuint size,
                    ReadOnlySpan<IntPtr> data,
                    uint usage
        )
        {
            fixed (IntPtr* dataPtr = data) {
                Context.glNamedBufferData(buffer.Value, size, dataPtr, usage);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedBufferStorage(
                    GlHandle buffer,
                    nuint size,
                    ReadOnlySpan<IntPtr> data,
                    uint flags
        )
        {
            fixed (IntPtr* dataPtr = data) {
                Context.glNamedBufferStorage(buffer.Value, size, dataPtr, flags);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedBufferSubData(
                    GlHandle buffer,
                    nint offset,
                    nuint size,
                    ReadOnlySpan<IntPtr> data
        )
        {
            fixed (IntPtr* dataPtr = data) {
                Context.glNamedBufferSubData(buffer.Value, offset, size, dataPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedFramebufferDrawBuffer(
                    GlHandle framebuffer,
                    uint buf
        )
        {
            Context.glNamedFramebufferDrawBuffer(framebuffer.Value, buf);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedFramebufferDrawBuffers(
                    GlHandle framebuffer,
                    int n,
                    ReadOnlySpan<uint> bufs
        )
        {
            fixed (uint* bufsPtr = bufs) {
                Context.glNamedFramebufferDrawBuffers(framebuffer.Value, n, bufsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedFramebufferParameteri(
                    GlHandle framebuffer,
                    uint pname,
                    int param
        )
        {
            Context.glNamedFramebufferParameteri(framebuffer.Value, pname, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedFramebufferReadBuffer(
                    GlHandle framebuffer,
                    uint src
        )
        {
            Context.glNamedFramebufferReadBuffer(framebuffer.Value, src);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedFramebufferRenderbuffer(
                    GlHandle framebuffer,
                    uint attachment,
                    uint renderbuffertarget,
                    GlHandle renderbuffer
        )
        {
            Context.glNamedFramebufferRenderbuffer(framebuffer.Value, attachment,
                                                   renderbuffertarget, renderbuffer.Value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedFramebufferTexture(
                    GlHandle framebuffer,
                    uint attachment,
                    GlHandle texture,
                    int level
        )
        {
            Context.glNamedFramebufferTexture(framebuffer.Value, attachment, texture.Value, level);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedFramebufferTextureLayer(
                    GlHandle framebuffer,
                    uint attachment,
                    GlHandle texture,
                    int level,
                    int layer
        )
        {
            Context.glNamedFramebufferTextureLayer(framebuffer.Value, attachment, texture.Value,
                                                   level, layer);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedRenderbufferStorage(
                    GlHandle renderbuffer,
                    uint internalformat,
                    int width,
                    int height
        )
        {
            Context.glNamedRenderbufferStorage(renderbuffer.Value, internalformat, width, height);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedRenderbufferStorageMultisample(
                    GlHandle renderbuffer,
                    int samples,
                    uint internalformat,
                    int width,
                    int height
        )
        {
            Context.glNamedRenderbufferStorageMultisample(renderbuffer.Value, samples,
                                                          internalformat, width, height);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ReadnPixels(
                    int x,
                    int y,
                    int width,
                    int height,
                    uint format,
                    ShaderType type,
                    int bufSize,
                    IntPtr* data
        )
        {
            Context.glReadnPixels(x, y, width, height, format, (uint)type, bufSize, data);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureBarrier()
        {
            Context.glTextureBarrier();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureBuffer(
                    GlHandle texture,
                    uint internalformat,
                    GlHandle buffer
        )
        {
            Context.glTextureBuffer(texture.Value, internalformat, buffer.Value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureBufferRange(
                    GlHandle texture,
                    uint internalformat,
                    GlHandle buffer,
                    nint offset,
                    nuint size
        )
        {
            Context.glTextureBufferRange(texture.Value, internalformat, buffer.Value, offset, size);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureParameterf(
                    GlHandle texture,
                    uint pname,
                    float param
        )
        {
            Context.glTextureParameterf(texture.Value, pname, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureParameterfv(
                    GlHandle texture,
                    uint pname,
                    ReadOnlySpan<float> param
        )
        {
            fixed (float* paramPtr = param) {
                Context.glTextureParameterfv(texture.Value, pname, paramPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureParameteri(
                    GlHandle texture,
                    uint pname,
                    int param
        )
        {
            Context.glTextureParameteri(texture.Value, pname, param);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureParameterIiv(
                    GlHandle texture,
                    uint pname,
                    ReadOnlySpan<int> @params
        )
        {
            fixed (int* @paramsPtr = @params) {
                Context.glTextureParameterIiv(texture.Value, pname, @paramsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureParameterIuiv(
                    GlHandle texture,
                    uint pname,
                    ReadOnlySpan<uint> @params
        )
        {
            fixed (uint* @paramsPtr = @params) {
                Context.glTextureParameterIuiv(texture.Value, pname, @paramsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureParameteriv(
                    GlHandle texture,
                    uint pname,
                    ReadOnlySpan<int> param
        )
        {
            fixed (int* paramPtr = param) {
                Context.glTextureParameteriv(texture.Value, pname, paramPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureStorage1D(
                    GlHandle texture,
                    int levels,
                    uint internalformat,
                    int width
        )
        {
            Context.glTextureStorage1D(texture.Value, levels, internalformat, width);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureStorage2D(
                    GlHandle texture,
                    int levels,
                    uint internalformat,
                    int width,
                    int height
        )
        {
            Context.glTextureStorage2D(texture.Value, levels, internalformat, width, height);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureStorage2DMultisample(
                    GlHandle texture,
                    int samples,
                    uint internalformat,
                    int width,
                    int height,
                    byte fixedsamplelocations
        )
        {
            Context.glTextureStorage2DMultisample(texture.Value, samples, internalformat, width,
                                                  height, fixedsamplelocations);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureStorage3D(
                    GlHandle texture,
                    int levels,
                    uint internalformat,
                    int width,
                    int height,
                    int depth
        )
        {
            Context.glTextureStorage3D(texture.Value, levels, internalformat, width, height, depth);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureStorage3DMultisample(
                    GlHandle texture,
                    int samples,
                    uint internalformat,
                    int width,
                    int height,
                    int depth,
                    byte fixedsamplelocations
        )
        {
            Context.glTextureStorage3DMultisample(texture.Value, samples, internalformat, width,
                                                  height, depth, fixedsamplelocations);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureSubImage1D(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int width,
                    uint format,
                    ShaderType type,
                    ReadOnlySpan<IntPtr> pixels
        )
        {
            fixed (IntPtr* pixelsPtr = pixels) {
                Context.glTextureSubImage1D(texture.Value, level, xoffset, width, format,
                                            (uint)type, pixelsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureSubImage2D(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int yoffset,
                    int width,
                    int height,
                    uint format,
                    ShaderType type,
                    ReadOnlySpan<IntPtr> pixels
        )
        {
            fixed (IntPtr* pixelsPtr = pixels) {
                Context.glTextureSubImage2D(texture.Value, level, xoffset, yoffset, width, height,
                                            format, (uint)type, pixelsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureSubImage3D(
                    GlHandle texture,
                    int level,
                    int xoffset,
                    int yoffset,
                    int zoffset,
                    int width,
                    int height,
                    int depth,
                    uint format,
                    ShaderType type,
                    ReadOnlySpan<IntPtr> pixels
        )
        {
            fixed (IntPtr* pixelsPtr = pixels) {
                Context.glTextureSubImage3D(texture.Value, level, xoffset, yoffset, zoffset, width,
                                            height, depth, format, (uint)type, pixelsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TransformFeedbackBufferBase(
                    uint xfb,
                    uint index,
                    GlHandle buffer
        )
        {
            Context.glTransformFeedbackBufferBase(xfb, index, buffer.Value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TransformFeedbackBufferRange(
                    uint xfb,
                    uint index,
                    GlHandle buffer,
                    nint offset,
                    nuint size
        )
        {
            Context.glTransformFeedbackBufferRange(xfb, index, buffer.Value, offset, size);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public byte UnmapNamedBuffer(
                    GlHandle buffer
        )
        {
            return Context.glUnmapNamedBuffer(buffer.Value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexArrayAttribBinding(
                    uint vaobj,
                    uint attribindex,
                    uint bindingindex
        )
        {
            Context.glVertexArrayAttribBinding(vaobj, attribindex, bindingindex);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexArrayAttribFormat(
                    uint vaobj,
                    uint attribindex,
                    int size,
                    ShaderType type,
                    byte normalized,
                    uint relativeoffset
        )
        {
            Context.glVertexArrayAttribFormat(vaobj, attribindex, size, (uint)type, normalized,
                                              relativeoffset);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexArrayAttribIFormat(
                    uint vaobj,
                    uint attribindex,
                    int size,
                    ShaderType type,
                    uint relativeoffset
        )
        {
            Context.glVertexArrayAttribIFormat(vaobj, attribindex, size, (uint)type,
                                               relativeoffset);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexArrayAttribLFormat(
                    uint vaobj,
                    uint attribindex,
                    int size,
                    ShaderType type,
                    uint relativeoffset
        )
        {
            Context.glVertexArrayAttribLFormat(vaobj, attribindex, size, (uint)type,
                                               relativeoffset);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexArrayBindingDivisor(
                    uint vaobj,
                    uint bindingindex,
                    uint divisor
        )
        {
            Context.glVertexArrayBindingDivisor(vaobj, bindingindex, divisor);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexArrayElementBuffer(
                    uint vaobj,
                    GlHandle buffer
        )
        {
            Context.glVertexArrayElementBuffer(vaobj, buffer.Value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexArrayVertexBuffer(
                    uint vaobj,
                    uint bindingindex,
                    GlHandle buffer,
                    nint offset,
                    int stride
        )
        {
            Context.glVertexArrayVertexBuffer(vaobj, bindingindex, buffer.Value, offset, stride);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexArrayVertexBuffers(
                    uint vaobj,
                    uint first,
                    int count,
                    ReadOnlySpan<uint> buffers,
                    ReadOnlySpan<nint> offsets,
                    ReadOnlySpan<int> strides
        )
        {
            fixed (uint* buffersPtr = buffers)
            {
                fixed (nint* offsetsPtr = offsets)
                {
                    fixed (int* stridesPtr = strides) {
                        Context.glVertexArrayVertexBuffers(vaobj, first, count, buffersPtr,
                                                           offsetsPtr, stridesPtr);
                    }
                }
            }
        }

    }
}