// <auto-generated>
// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
// Version: 4.5
// </auto-generated>
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using StgSharp.Graphics.OpenGL;

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, uint type, void* data)
        {
            Context.glClearNamedBufferData(buffer.Value, internalformat, format, type, data);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearNamedBufferSubData(GlHandle buffer, uint internalformat, nint offset, nint size, uint format, uint type, void* data)
        {
            Context.glClearNamedBufferSubData(buffer.Value, internalformat, offset, size, format, type, data);
        }

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearNamedFramebuffer(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 ClearNamedFramebuffer(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 ClearNamedFramebuffer(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, void* data)
        {
            Context.glCompressedTextureSubImage1D(texture.Value, level, xoffset, width, format, imageSize, data);
        }

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

        [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, void* data)
        {
            Context.glCompressedTextureSubImage3D(texture.Value, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CopyNamedBufferSubData(GlHandle readBuffer, GlHandle writeBuffer, nint readOffset, nint writeOffset, nint 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(Span<uint> buffers)
        {
            fixed (uint* buffersPtr = buffers)
            {
                Context.glCreateBuffers(checked((int)buffers.Length), buffersPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateFramebuffers(Span<uint> framebuffers)
        {
            fixed (uint* framebuffersPtr = framebuffers)
            {
                Context.glCreateFramebuffers(checked((int)framebuffers.Length), framebuffersPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateProgramPipelines(Span<uint> pipelines)
        {
            fixed (uint* pipelinesPtr = pipelines)
            {
                Context.glCreateProgramPipelines(checked((int)pipelines.Length), pipelinesPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateQueries(uint target, Span<uint> ids)
        {
            fixed (uint* idsPtr = ids)
            {
                Context.glCreateQueries(target, checked((int)ids.Length), idsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateRenderbuffers(Span<uint> renderbuffers)
        {
            fixed (uint* renderbuffersPtr = renderbuffers)
            {
                Context.glCreateRenderbuffers(checked((int)renderbuffers.Length), renderbuffersPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateSamplers(Span<uint> samplers)
        {
            fixed (uint* samplersPtr = samplers)
            {
                Context.glCreateSamplers(checked((int)samplers.Length), samplersPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateTextures(uint target, Span<uint> textures)
        {
            fixed (uint* texturesPtr = textures)
            {
                Context.glCreateTextures(target, checked((int)textures.Length), texturesPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateTransformFeedbacks(Span<uint> ids)
        {
            fixed (uint* idsPtr = ids)
            {
                Context.glCreateTransformFeedbacks(checked((int)ids.Length), idsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void CreateVertexArrays(Span<uint> arrays)
        {
            fixed (uint* arraysPtr = arrays)
            {
                Context.glCreateVertexArrays(checked((int)arrays.Length), arraysPtr);
            }
        }

        [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, nint 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, void* 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, void* 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 GetNamedBufferParameter(GlHandle buffer, uint pname, Span<long> @params)
        {
            fixed (long* @paramsPtr = @params)
            {
                Context.glGetNamedBufferParameteri64v(buffer.Value, pname, @paramsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetNamedBufferParameter(GlHandle buffer, uint pname, Span<int> @params)
        {
            fixed (int* @paramsPtr = @params)
            {
                Context.glGetNamedBufferParameteriv(buffer.Value, pname, @paramsPtr);
            }
        }

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

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

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

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

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetQueryBufferObject(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, uint type, int bufSize, void* pixels)
        {
            Context.glGetTextureImage(texture.Value, level, format, type, bufSize, pixels);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTextureLevelParameter(GlHandle texture, int level, uint pname, Span<float> @params)
        {
            fixed (float* @paramsPtr = @params)
            {
                Context.glGetTextureLevelParameterfv(texture.Value, level, pname, @paramsPtr);
            }
        }

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

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

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

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

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

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTransformFeedbacki64_v(uint xfb, uint pname, uint index, Span<long> param)
        {
            fixed (long* paramPtr = param)
            {
                Context.glGetTransformFeedbacki64_v(xfb, pname, index, paramPtr);
            }
        }

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetTransformFeedbackiv(uint xfb, uint pname, Span<int> param)
        {
            fixed (int* paramPtr = param)
            {
                Context.glGetTransformFeedbackiv(xfb, pname, paramPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetVertexArrayIndexed64iv(uint vaobj, uint index, uint pname, Span<long> param)
        {
            fixed (long* paramPtr = param)
            {
                Context.glGetVertexArrayIndexed64iv(vaobj, index, pname, paramPtr);
            }
        }

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetVertexArrayiv(uint vaobj, uint pname, Span<int> param)
        {
            fixed (int* paramPtr = param)
            {
                Context.glGetVertexArrayiv(vaobj, pname, paramPtr);
            }
        }

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

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetnUniform(GlHandle program, int location, int bufSize, Span<double> @params)
        {
            if (@params.Length < checked((int)bufSize / 8)) {
                throw new ArgumentException("Span is shorter than the OpenGL length expression 'bufSize / 8'.", nameof(@params));
            }
            fixed (double* @paramsPtr = @params)
            {
                Context.glGetnUniformdv(program.Value, location, bufSize, @paramsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetnUniform(GlHandle program, int location, int bufSize, Span<float> @params)
        {
            if (@params.Length < checked((int)bufSize / 4)) {
                throw new ArgumentException("Span is shorter than the OpenGL length expression 'bufSize / 4'.", nameof(@params));
            }
            fixed (float* @paramsPtr = @params)
            {
                Context.glGetnUniformfv(program.Value, location, bufSize, @paramsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetnUniform(GlHandle program, int location, int bufSize, Span<int> @params)
        {
            if (@params.Length < checked((int)bufSize / 4)) {
                throw new ArgumentException("Span is shorter than the OpenGL length expression 'bufSize / 4'.", nameof(@params));
            }
            fixed (int* @paramsPtr = @params)
            {
                Context.glGetnUniformiv(program.Value, location, bufSize, @paramsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetnUniform(GlHandle program, int location, int bufSize, Span<uint> @params)
        {
            if (@params.Length < checked((int)bufSize / 4)) {
                throw new ArgumentException("Span is shorter than the OpenGL length expression 'bufSize / 4'.", nameof(@params));
            }
            fixed (uint* @paramsPtr = @params)
            {
                Context.glGetnUniformuiv(program.Value, location, bufSize, @paramsPtr);
            }
        }

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

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

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void* MapNamedBufferRange(GlHandle buffer, nint offset, nint length, uint access)
        {
            return 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, nint size, void* data, uint usage)
        {
            Context.glNamedBufferData(buffer.Value, size, data, usage);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedBufferStorage(GlHandle buffer, nint size, void* data, uint flags)
        {
            Context.glNamedBufferStorage(buffer.Value, size, data, flags);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedBufferSubData(GlHandle buffer, nint offset, nint size, void* data)
        {
            Context.glNamedBufferSubData(buffer.Value, offset, size, data);
        }

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

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void NamedFramebufferParameter(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, uint type, int bufSize, void* data)
        {
            Context.glReadnPixels(x, y, width, height, format, 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, nint size)
        {
            Context.glTextureBufferRange(texture.Value, internalformat, buffer.Value, offset, size);
        }

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

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

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

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

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureParameter(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, uint type, void* pixels)
        {
            Context.glTextureSubImage1D(texture.Value, level, xoffset, width, format, type, pixels);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void TextureSubImage2D(GlHandle texture, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, void* pixels)
        {
            Context.glTextureSubImage2D(texture.Value, level, xoffset, yoffset, width, height, format, type, pixels);
        }

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

        [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, nint 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, uint type, byte normalized, uint relativeoffset)
        {
            Context.glVertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
        }

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexArrayAttribLFormat(uint vaobj, uint attribindex, int size, uint type, uint relativeoffset)
        {
            Context.glVertexArrayAttribLFormat(vaobj, attribindex, size, 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, ReadOnlySpan<uint> buffers, ReadOnlySpan<nint> offsets, ReadOnlySpan<int> strides)
        {
            if (offsets.Length != buffers.Length) {
                throw new ArgumentException("Span lengths controlled by count must match.", nameof(offsets));
            }
            if (strides.Length != buffers.Length) {
                throw new ArgumentException("Span lengths controlled by count must match.", nameof(strides));
            }
            fixed (uint* buffersPtr = buffers)
            {
                fixed (nint* offsetsPtr = offsets)
                {
                    fixed (int* stridesPtr = strides)
                    {
                        Context.glVertexArrayVertexBuffers(vaobj, first, checked((int)buffers.Length), buffersPtr, offsetsPtr, stridesPtr);
                    }
                }
            }
        }

    }
}