// <auto-generated>
// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
// Version: 4.1
// </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 ActiveShaderProgram(uint pipeline, GlHandle program)
        {
            Context.glActiveShaderProgram(pipeline, program.Value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void BindProgramPipeline(uint pipeline)
        {
            Context.glBindProgramPipeline(pipeline);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ClearDepth(float d)
        {
            Context.glClearDepthf(d);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public GlHandle CreateShaderProgramv(uint type, int count, byte** strings)
        {
            return GlHandle.Create(Context.glCreateShaderProgramv(type, count, strings));
        }

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void DepthRangeArrayv(uint first, int count, ReadOnlySpan<double> v)
        {
            fixed (double* vPtr = v)
            {
                Context.glDepthRangeArrayv(first, count, vPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void DepthRangeIndexed(uint index, double n, double f)
        {
            Context.glDepthRangeIndexed(index, n, f);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void DepthRange(float n, float f)
        {
            Context.glDepthRangef(n, f);
        }

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

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetDoublei_v(uint target, uint index, Span<double> data)
        {
            fixed (double* dataPtr = data)
            {
                Context.glGetDoublei_v(target, index, dataPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetFloati_v(uint target, uint index, Span<float> data)
        {
            fixed (float* dataPtr = data)
            {
                Context.glGetFloati_v(target, index, dataPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetProgramBinary(GlHandle program, int bufSize, out int length, out uint binaryFormat, void* binary)
        {
            length = default;
            binaryFormat = default;
            fixed (int* lengthPtr = &length)
            {
                fixed (uint* binaryFormatPtr = &binaryFormat)
                {
                    Context.glGetProgramBinary(program.Value, bufSize, lengthPtr, binaryFormatPtr, binary);
                }
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetProgramPipelineInfoLog(uint pipeline, out int length, Span<byte> infoLog)
        {
            length = default;
            fixed (int* lengthPtr = &length)
            {
                fixed (byte* infoLogPtr = infoLog)
                {
                    Context.glGetProgramPipelineInfoLog(pipeline, checked((int)infoLog.Length), lengthPtr, infoLogPtr);
                }
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetProgramPipelineiv(uint pipeline, uint pname, Span<int> @params)
        {
            fixed (int* @paramsPtr = @params)
            {
                Context.glGetProgramPipelineiv(pipeline, pname, @paramsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetShaderPrecisionFormat(uint shadertype, uint precisiontype, Span<int> range, out int precision)
        {
            precision = default;
            if (range.Length < 2) {
                throw new ArgumentException("Span is shorter than the OpenGL length expression '2'.", nameof(range));
            }
            fixed (int* rangePtr = range)
            {
                fixed (int* precisionPtr = &precision)
                {
                    Context.glGetShaderPrecisionFormat(shadertype, precisiontype, rangePtr, precisionPtr);
                }
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void GetVertexAttribLdv(uint index, uint pname, Span<double> @params)
        {
            fixed (double* @paramsPtr = @params)
            {
                Context.glGetVertexAttribLdv(index, pname, @paramsPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public byte IsProgramPipeline(uint pipeline)
        {
            return Context.glIsProgramPipeline(pipeline);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ProgramBinary(GlHandle program, uint binaryFormat, void* binary, int length)
        {
            Context.glProgramBinary(program.Value, binaryFormat, binary, length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ProgramParameter(GlHandle program, uint pname, int value)
        {
            Context.glProgramParameteri(program.Value, pname, value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ReleaseShaderCompiler()
        {
            Context.glReleaseShaderCompiler();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ScissorArrayv(uint first, int count, ReadOnlySpan<int> v)
        {
            fixed (int* vPtr = v)
            {
                Context.glScissorArrayv(first, count, vPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ScissorIndexed(uint index, int left, int bottom, int width, int height)
        {
            Context.glScissorIndexed(index, left, bottom, width, height);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ScissorIndexed(uint index, ReadOnlySpan<int> v)
        {
            if (v.Length < 4) {
                throw new ArgumentException("Span is shorter than the OpenGL length expression '4'.", nameof(v));
            }
            fixed (int* vPtr = v)
            {
                Context.glScissorIndexedv(index, vPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ShaderBinary(ReadOnlySpan<uint> shaders, uint binaryFormat, void* binary, int length)
        {
            fixed (uint* shadersPtr = shaders)
            {
                Context.glShaderBinary(checked((int)shaders.Length), shadersPtr, binaryFormat, binary, length);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void UseProgramStages(uint pipeline, uint stages, GlHandle program)
        {
            Context.glUseProgramStages(pipeline, stages, program.Value);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ValidateProgramPipeline(uint pipeline)
        {
            Context.glValidateProgramPipeline(pipeline);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexAttribL(uint index, double x)
        {
            Context.glVertexAttribL1d(index, x);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexAttribL(uint index, double x, double y)
        {
            Context.glVertexAttribL2d(index, x, y);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexAttribL(uint index, double x, double y, double z)
        {
            Context.glVertexAttribL3d(index, x, y, z);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexAttribL(uint index, double x, double y, double z, double w)
        {
            Context.glVertexAttribL4d(index, x, y, z, w);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void VertexAttribLPointer(uint index, int size, uint type, int stride, void* pointer)
        {
            Context.glVertexAttribLPointer(index, size, type, stride, pointer);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ViewportArrayv(uint first, int count, ReadOnlySpan<float> v)
        {
            fixed (float* vPtr = v)
            {
                Context.glViewportArrayv(first, count, vPtr);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ViewportIndexed(uint index, float x, float y, float w, float h)
        {
            Context.glViewportIndexedf(index, x, y, w, h);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void ViewportIndexed(uint index, ReadOnlySpan<float> v)
        {
            if (v.Length < 4) {
                throw new ArgumentException("Span is shorter than the OpenGL length expression '4'.", nameof(v));
            }
            fixed (float* vPtr = v)
            {
                Context.glViewportIndexedfv(index, vPtr);
            }
        }

    }
}