wrappers.odin

package gl 



when !ODIN_DEBUG {
	// VERSION_1_0
	CullFace               :: #force_inline proc "c" (mode: u32)                                                                                         {        impl_CullFace(mode);                                                                         }
	FrontFace              :: #force_inline proc "c" (mode: u32)                                                                                         {        impl_FrontFace(mode);                                                                        }
	Hint                   :: #force_inline proc "c" (target, mode: u32)                                                                                 {        impl_Hint(target, mode);                                                                     }
	LineWidth              :: #force_inline proc "c" (width: f32)                                                                                        {        impl_LineWidth(width);                                                                       }
	PointSize              :: #force_inline proc "c" (size: f32)                                                                                         {        impl_PointSize(size);                                                                        }
	PolygonMode            :: #force_inline proc "c" (face, mode: u32)                                                                                   {        impl_PolygonMode(face, mode);                                                                }
	Scissor                :: #force_inline proc "c" (x, y, width, height: i32)                                                                          {        impl_Scissor(x, y, width, height);                                                           }
	TexParameterf          :: #force_inline proc "c" (target, pname: u32, param: f32)                                                                    {        impl_TexParameterf(target, pname, param);                                                    }
	TexParameterfv         :: #force_inline proc "c" (target, pname: u32, params: ^f32)                                                                  {        impl_TexParameterfv(target, pname, params);                                                  }
	TexParameteri          :: #force_inline proc "c" (target, pname: u32, param: i32)                                                                    {        impl_TexParameteri(target, pname, param);                                                    }
	TexParameteriv         :: #force_inline proc "c" (target, pname: u32, params: ^i32)                                                                  {        impl_TexParameteriv(target, pname, params);                                                  }
	TexImage1D             :: #force_inline proc "c" (target: u32, level, internalformat, width, border: i32, format, type: u32, pixels: rawptr)         {        impl_TexImage1D(target, level, internalformat, width, border, format, type, pixels);         }
	TexImage2D             :: #force_inline proc "c" (target: u32, level, internalformat, width, height, border: i32, format, type: u32, pixels: rawptr) {        impl_TexImage2D(target, level, internalformat, width, height, border, format, type, pixels); }
	DrawBuffer             :: #force_inline proc "c" (buf: u32)                                                                                          {        impl_DrawBuffer(buf);                                                                        }
	Clear                  :: #force_inline proc "c" (mask: u32)                                                                                         {        impl_Clear(mask);                                                                            }
	ClearColor             :: #force_inline proc "c" (red, green, blue, alpha: f32)                                                                      {        impl_ClearColor(red, green, blue, alpha);                                                    }
	ClearStencil           :: #force_inline proc "c" (s: i32)                                                                                            {        impl_ClearStencil(s);                                                                        }
	ClearDepth             :: #force_inline proc "c" (depth: f64)                                                                                        {        impl_ClearDepth(depth);                                                                      }
	StencilMask            :: #force_inline proc "c" (mask: u32)                                                                                         {        impl_StencilMask(mask);                                                                      }
	ColorMask              :: #force_inline proc "c" (red, green, blue, alpha: u8)                                                                       {        impl_ColorMask(red, green, blue, alpha);                                                     }
	DepthMask              :: #force_inline proc "c" (flag: u8)                                                                                          {        impl_DepthMask(flag);                                                                        }
	Disable                :: #force_inline proc "c" (cap: u32)                                                                                          {        impl_Disable(cap);                                                                           }
	Enable                 :: #force_inline proc "c" (cap: u32)                                                                                          {        impl_Enable(cap);                                                                            }
	Finish                 :: #force_inline proc "c" ()                                                                                                  {        impl_Finish();                                                                               }
	Flush                  :: #force_inline proc "c" ()                                                                                                  {        impl_Flush();                                                                                }
	BlendFunc              :: #force_inline proc "c" (sfactor, dfactor: u32)                                                                             {        impl_BlendFunc(sfactor, dfactor);                                                            }
	LogicOp                :: #force_inline proc "c" (opcode: u32)                                                                                       {        impl_LogicOp(opcode);                                                                        }
	StencilFunc            :: #force_inline proc "c" (func: u32, ref: i32, mask: u32)                                                                    {        impl_StencilFunc(func, ref, mask);                                                           }
	StencilOp              :: #force_inline proc "c" (fail, zfail, zpass: u32)                                                                           {        impl_StencilOp(fail, zfail, zpass);                                                          }
	DepthFunc              :: #force_inline proc "c" (func: u32)                                                                                         {        impl_DepthFunc(func);                                                                        }
	PixelStoref            :: #force_inline proc "c" (pname: u32, param: f32)                                                                            {        impl_PixelStoref(pname, param);                                                              }
	PixelStorei            :: #force_inline proc "c" (pname: u32, param: i32)                                                                            {        impl_PixelStorei(pname, param);                                                              }
	ReadBuffer             :: #force_inline proc "c" (src: u32)                                                                                          {        impl_ReadBuffer(src);                                                                        }
	ReadPixels             :: #force_inline proc "c" (x, y, width, height: i32, format, type: u32, pixels: rawptr)                                       {        impl_ReadPixels(x, y, width, height, format, type, pixels);                                  }
	GetBooleanv            :: #force_inline proc "c" (pname: u32, data: ^u8)                                                                             {        impl_GetBooleanv(pname, data);                                                               }
	GetDoublev             :: #force_inline proc "c" (pname: u32, data: ^f64)                                                                            {        impl_GetDoublev(pname, data);                                                                }
	GetError               :: #force_inline proc "c" () -> u32                                                                                           { return impl_GetError();                                                                             }
	GetFloatv              :: #force_inline proc "c" (pname: u32, data: ^f32)                                                                            {        impl_GetFloatv(pname, data);                                                                 }
	GetIntegerv            :: #force_inline proc "c" (pname: u32, data: ^i32)                                                                            {        impl_GetIntegerv(pname, data);                                                               }
	GetString              :: #force_inline proc "c" (name: u32) -> cstring                                                                              { return impl_GetString(name);                                                                        }
	GetTexImage            :: #force_inline proc "c" (target: u32,  level: i32, format, type: u32, pixels: rawptr)                                       {        impl_GetTexImage(target,  level, format, type, pixels);                                      }
	GetTexParameterfv      :: #force_inline proc "c" (target, pname: u32, params: ^f32)                                                                  {        impl_GetTexParameterfv(target, pname, params);                                               }
	GetTexParameteriv      :: #force_inline proc "c" (target, pname: u32, params: ^i32)                                                                  {        impl_GetTexParameteriv(target, pname, params);                                               }
	GetTexLevelParameterfv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: ^f32)                                                 {        impl_GetTexLevelParameterfv(target, level, pname, params);                                   }
	GetTexLevelParameteriv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: ^i32)                                                 {        impl_GetTexLevelParameteriv(target, level, pname, params);                                   }
	IsEnabled              :: #force_inline proc "c" (cap: u32) -> u8                                                                                    { return impl_IsEnabled(cap);                                                                         }
	DepthRange             :: #force_inline proc "c" (near, far: f64)                                                                                    {        impl_DepthRange(near, far);                                                                  }
	Viewport               :: #force_inline proc "c" (x, y, width, height: i32)                                                                          {        impl_Viewport(x, y, width, height);                                                          }

	// VERSION_1_1
	DrawArrays        :: #force_inline proc "c" (mode: u32, first: i32, count: i32)                                                                                    {        impl_DrawArrays(mode, first, count);                                                      }
	DrawElements      :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr)                                                                    {        impl_DrawElements(mode, count, type, indices);                                            }
	PolygonOffset     :: #force_inline proc "c" (factor: f32, units: f32)                                                                                              {        impl_PolygonOffset(factor, units);                                                        }
	CopyTexImage1D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32)                                {        impl_CopyTexImage1D(target, level, internalformat, x, y, width, border);                  }
	CopyTexImage2D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32)                   {        impl_CopyTexImage2D(target, level, internalformat, x, y, width, height, border);          }
	CopyTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32)                                                    {        impl_CopyTexSubImage1D(target, level, xoffset, x, y, width);                              }
	CopyTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32)                         {        impl_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);             }
	TexSubImage1D     :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr)                            {        impl_TexSubImage1D(target, level, xoffset, width, format, type, pixels);                  }
	TexSubImage2D     :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr) {        impl_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); }
	BindTexture       :: #force_inline proc "c" (target: u32, texture: u32)                                                                                            {        impl_BindTexture(target, texture);                                                        }
	DeleteTextures    :: #force_inline proc "c" (n: i32, textures: ^u32)                                                                                               {        impl_DeleteTextures(n, textures);                                                         }
	GenTextures       :: #force_inline proc "c" (n: i32, textures: ^u32)                                                                                               {        impl_GenTextures(n, textures);                                                            }
	IsTexture         :: #force_inline proc "c" (texture: u32) -> u8                                                                                                   { return impl_IsTexture(texture);                                                                  }

	// VERSION_1_2
	DrawRangeElements :: #force_inline proc "c" (mode, start, end: u32, count: i32, type: u32, indices: rawptr)                                               { impl_DrawRangeElements(mode, start, end, count, type, indices);                                           }
	TexImage3D        :: #force_inline proc "c" (target: u32, level, internalformat, width, height, depth, border: i32, format, type: u32, pixels: rawptr)    { impl_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);       }
	TexSubImage3D     :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, width, height, depth: i32, format, type: u32, pixels: rawptr) { impl_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); }
	CopyTexSubImage3D :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, x, y, width, height: i32)                                     { impl_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);                    }

	// VERSION_1_3
	ActiveTexture           :: #force_inline proc "c" (texture: u32)                                                                                                                                      { impl_ActiveTexture(texture);                                                                                           }
	SampleCoverage          :: #force_inline proc "c" (value: f32, invert: u8)                                                                                                                            { impl_SampleCoverage(value, invert);                                                                                    }
	CompressedTexImage3D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: rawptr)                      { impl_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);               }
	CompressedTexImage2D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: rawptr)                                  { impl_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);                      }
	CompressedTexImage1D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: rawptr)                                               { impl_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);                              }
	CompressedTexSubImage3D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr) { impl_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); }
	CompressedTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr)                           { impl_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);                 }
	CompressedTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr)                                                      { impl_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);                                  }
	GetCompressedTexImage   :: #force_inline proc "c" (target: u32, level: i32, img: rawptr)                                                                                                              { impl_GetCompressedTexImage(target, level, img);                                                                        }

	// VERSION_1_4
    BlendFuncSeparate :: #force_inline proc "c" (sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32) { impl_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); }
    MultiDrawArrays   :: #force_inline proc "c" (mode: u32, first: ^i32, count: ^i32, drawcount: i32)                    { impl_MultiDrawArrays(mode, first, count, drawcount);                        }
    MultiDrawElements :: #force_inline proc "c" (mode: u32, count: ^i32, type_: u32, indices: ^rawptr, drawcount: i32)   { impl_MultiDrawElements(mode, count, type_, indices, drawcount);             }
    PointParameterf   :: #force_inline proc "c" (pname: u32, param: f32)                                                 { impl_PointParameterf(pname, param);                                         }
    PointParameterfv  :: #force_inline proc "c" (pname: u32, params: ^f32)                                               { impl_PointParameterfv(pname, params);                                       }
    PointParameteri   :: #force_inline proc "c" (pname: u32, param: i32)                                                 { impl_PointParameteri(pname, param);                                         }
    PointParameteriv  :: #force_inline proc "c" (pname: u32, params: ^i32)                                               { impl_PointParameteriv(pname, params);                                       }
    BlendColor        :: #force_inline proc "c" (red: f32, green: f32, blue: f32, alpha: f32)                            { impl_BlendColor(red, green, blue, alpha);                                   }
    BlendEquation     :: #force_inline proc "c" (mode: u32)                                                              { impl_BlendEquation(mode);                                                   }

    // VERSION_1_5
	GenQueries           :: #force_inline proc "c" (n: i32, ids: ^u32)                                 {        impl_GenQueries(n, ids);                                       }
	DeleteQueries        :: #force_inline proc "c" (n: i32, ids: ^u32)                                 {        impl_DeleteQueries(n, ids);                                    }
	IsQuery              :: #force_inline proc "c" (id: u32) -> u8                                     { ret := impl_IsQuery(id);                                  return ret; }
	BeginQuery           :: #force_inline proc "c" (target: u32, id: u32)                              {        impl_BeginQuery(target, id);                                   }
	EndQuery             :: #force_inline proc "c" (target: u32)                                       {        impl_EndQuery(target);                                         }
	GetQueryiv           :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32)             {        impl_GetQueryiv(target, pname, params);                        }
	GetQueryObjectiv     :: #force_inline proc "c" (id: u32, pname: u32, params: ^i32)                 {        impl_GetQueryObjectiv(id, pname, params);                      }
	GetQueryObjectuiv    :: #force_inline proc "c" (id: u32, pname: u32, params: ^u32)                 {        impl_GetQueryObjectuiv(id, pname, params);                     }
	BindBuffer           :: #force_inline proc "c" (target: u32, buffer: u32)                          {        impl_BindBuffer(target, buffer);                               }
	DeleteBuffers        :: #force_inline proc "c" (n: i32, buffers: ^u32)                             {        impl_DeleteBuffers(n, buffers);                                }
	GenBuffers           :: #force_inline proc "c" (n: i32, buffers: ^u32)                             {        impl_GenBuffers(n, buffers);                                   }
	IsBuffer             :: #force_inline proc "c" (buffer: u32) -> u8                                 { ret := impl_IsBuffer(buffer);                             return ret; }
	BufferData           :: #force_inline proc "c" (target: u32, size: int, data: rawptr, usage: u32)  {        impl_BufferData(target, size, data, usage);                    }
	BufferSubData        :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr) {        impl_BufferSubData(target, offset, size, data);                }
	GetBufferSubData     :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr) {        impl_GetBufferSubData(target, offset, size, data);             }
	MapBuffer            :: #force_inline proc "c" (target: u32, access: u32) -> rawptr                { ret := impl_MapBuffer(target, access);                    return ret; }
	UnmapBuffer          :: #force_inline proc "c" (target: u32) -> u8                                 { ret := impl_UnmapBuffer(target);                          return ret; }
	GetBufferParameteriv :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32)             {        impl_GetBufferParameteriv(target, pname, params);              }
	GetBufferPointerv    :: #force_inline proc "c" (target: u32, pname: u32, params: ^rawptr)          {        impl_GetBufferPointerv(target, pname, params);                 }

	// VERSION_2_0
	BlendEquationSeparate    :: #force_inline proc "c" (modeRGB: u32, modeAlpha: u32)                                                             {        impl_BlendEquationSeparate(modeRGB, modeAlpha);                                        }
	DrawBuffers              :: #force_inline proc "c" (n: i32, bufs: ^u32)                                                                       {        impl_DrawBuffers(n, bufs);                                                             }
	StencilOpSeparate        :: #force_inline proc "c" (face: u32, sfail: u32, dpfail: u32, dppass: u32)                                          {        impl_StencilOpSeparate(face, sfail, dpfail, dppass);                                   }
	StencilFuncSeparate      :: #force_inline proc "c" (face: u32, func: u32, ref: i32, mask: u32)                                                {        impl_StencilFuncSeparate(face, func, ref, mask);                                       }
	StencilMaskSeparate      :: #force_inline proc "c" (face: u32, mask: u32)                                                                     {        impl_StencilMaskSeparate(face, mask);                                                  }
	AttachShader             :: #force_inline proc "c" (program: u32, shader: u32)                                                                {        impl_AttachShader(program, shader);                                                    }
	BindAttribLocation       :: #force_inline proc "c" (program: u32, index: u32, name: ^u8)                                                      {        impl_BindAttribLocation(program, index, name);                                         }
	CompileShader            :: #force_inline proc "c" (shader: u32)                                                                              {        impl_CompileShader(shader);                                                            }
	CreateProgram            :: #force_inline proc "c" () -> u32                                                                                  { ret := impl_CreateProgram();                                                      return ret; }
	CreateShader             :: #force_inline proc "c" (type_: u32) -> u32                                                                        { ret := impl_CreateShader(type_);                                                  return ret; }
	DeleteProgram            :: #force_inline proc "c" (program: u32)                                                                             {        impl_DeleteProgram(program);                                                           }
	DeleteShader             :: #force_inline proc "c" (shader: u32)                                                                              {        impl_DeleteShader(shader);                                                             }
	DetachShader             :: #force_inline proc "c" (program: u32, shader: u32)                                                                {        impl_DetachShader(program, shader);                                                    }
	DisableVertexAttribArray :: #force_inline proc "c" (index: u32)                                                                               {        impl_DisableVertexAttribArray(index);                                                  }
	EnableVertexAttribArray  :: #force_inline proc "c" (index: u32)                                                                               {        impl_EnableVertexAttribArray(index);                                                   }
	GetActiveAttrib          :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type_: ^u32, name: ^u8) {        impl_GetActiveAttrib(program, index, bufSize, length, size, type_, name);              }
	GetActiveUniform         :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type_: ^u32, name: ^u8) {        impl_GetActiveUniform(program, index, bufSize, length, size, type_, name);             }
	GetAttachedShaders       :: #force_inline proc "c" (program: u32, maxCount: i32, count: ^i32, shaders: ^u32)                                  {        impl_GetAttachedShaders(program, maxCount, count, shaders);                            }
	GetAttribLocation        :: #force_inline proc "c" (program: u32, name: cstring) -> i32                                                       { ret := impl_GetAttribLocation(program, name);                                     return ret; }
	GetProgramiv             :: #force_inline proc "c" (program: u32, pname: u32, params: ^i32)                                                   {        impl_GetProgramiv(program, pname, params);                                             }
	GetProgramInfoLog        :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: ^u8)                                   {        impl_GetProgramInfoLog(program, bufSize, length, infoLog);                             }
	GetShaderiv              :: #force_inline proc "c" (shader: u32, pname: u32, params: ^i32)                                                    {        impl_GetShaderiv(shader, pname, params);                                               }
	GetShaderInfoLog         :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: ^u8)                                    {        impl_GetShaderInfoLog(shader, bufSize, length, infoLog);                               }
	GetShaderSource          :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, source: ^u8)                                     {        impl_GetShaderSource(shader, bufSize, length, source);                                 }
	GetUniformLocation       :: #force_inline proc "c" (program: u32, name: cstring) -> i32                                                       { ret := impl_GetUniformLocation(program, name);                                    return ret; }
	GetUniformfv             :: #force_inline proc "c" (program: u32, location: i32, params: ^f32)                                                {        impl_GetUniformfv(program, location, params);                                          }
	GetUniformiv             :: #force_inline proc "c" (program: u32, location: i32, params: ^i32)                                                {        impl_GetUniformiv(program, location, params);                                          }
	GetVertexAttribdv        :: #force_inline proc "c" (index: u32, pname: u32, params: ^f64)                                                     {        impl_GetVertexAttribdv(index, pname, params);                                          }
	GetVertexAttribfv        :: #force_inline proc "c" (index: u32, pname: u32, params: ^f32)                                                     {        impl_GetVertexAttribfv(index, pname, params);                                          }
	GetVertexAttribiv        :: #force_inline proc "c" (index: u32, pname: u32, params: ^i32)                                                     {        impl_GetVertexAttribiv(index, pname, params);                                          }
	GetVertexAttribPointerv  :: #force_inline proc "c" (index: u32, pname: u32, pointer: ^rawptr)                                                 {        impl_GetVertexAttribPointerv(index, pname, pointer);                                   }
	IsProgram                :: #force_inline proc "c" (program: u32) -> u8                                                                       { ret := impl_IsProgram(program);                                                   return ret; }
	IsShader                 :: #force_inline proc "c" (shader: u32) -> u8                                                                        { ret := impl_IsShader(shader);                                                     return ret; }
	LinkProgram              :: #force_inline proc "c" (program: u32)                                                                             {        impl_LinkProgram(program);                                                             }
	ShaderSource             :: #force_inline proc "c" (shader: u32, count: i32, string: ^^u8, length: ^i32)                                      {        impl_ShaderSource(shader, count, string, length);                                      }
	UseProgram               :: #force_inline proc "c" (program: u32)                                                                             {        impl_UseProgram(program);                                                              }
	Uniform1f                :: #force_inline proc "c" (location: i32, v0: f32)                                                                   {        impl_Uniform1f(location, v0);                                                          }
	Uniform2f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32)                                                          {        impl_Uniform2f(location, v0, v1);                                                      }
	Uniform3f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32)                                                 {        impl_Uniform3f(location, v0, v1, v2);                                                  }
	Uniform4f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32, v3: f32)                                        {        impl_Uniform4f(location, v0, v1, v2, v3);                                              }
	Uniform1i                :: #force_inline proc "c" (location: i32, v0: i32)                                                                   {        impl_Uniform1i(location, v0);                                                          }
	Uniform2i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32)                                                          {        impl_Uniform2i(location, v0, v1);                                                      }
	Uniform3i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32)                                                 {        impl_Uniform3i(location, v0, v1, v2);                                                  }
	Uniform4i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32)                                        {        impl_Uniform4i(location, v0, v1, v2, v3);                                              }
	Uniform1fv               :: #force_inline proc "c" (location: i32, count: i32, value: ^f32)                                                   {        impl_Uniform1fv(location, count, value);                                               }
	Uniform2fv               :: #force_inline proc "c" (location: i32, count: i32, value: ^f32)                                                   {        impl_Uniform2fv(location, count, value);                                               }
	Uniform3fv               :: #force_inline proc "c" (location: i32, count: i32, value: ^f32)                                                   {        impl_Uniform3fv(location, count, value);                                               }
	Uniform4fv               :: #force_inline proc "c" (location: i32, count: i32, value: ^f32)                                                   {        impl_Uniform4fv(location, count, value);                                               }
	Uniform1iv               :: #force_inline proc "c" (location: i32, count: i32, value: ^i32)                                                   {        impl_Uniform1iv(location, count, value);                                               }
	Uniform2iv               :: #force_inline proc "c" (location: i32, count: i32, value: ^i32)                                                   {        impl_Uniform2iv(location, count, value);                                               }
	Uniform3iv               :: #force_inline proc "c" (location: i32, count: i32, value: ^i32)                                                   {        impl_Uniform3iv(location, count, value);                                               }
	Uniform4iv               :: #force_inline proc "c" (location: i32, count: i32, value: ^i32)                                                   {        impl_Uniform4iv(location, count, value);                                               }
	UniformMatrix2fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32)                                    {        impl_UniformMatrix2fv(location, count, transpose, value);                              }
	UniformMatrix3fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32)                                    {        impl_UniformMatrix3fv(location, count, transpose, value);                              }
	UniformMatrix4fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32)                                    {        impl_UniformMatrix4fv(location, count, transpose, value);                              }
	ValidateProgram          :: #force_inline proc "c" (program: u32)                                                                             {        impl_ValidateProgram(program);                                                         }
	VertexAttrib1d           :: #force_inline proc "c" (index: u32, x: f64)                                                                       {        impl_VertexAttrib1d(index, x);                                                         }
	VertexAttrib1dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                                      {        impl_VertexAttrib1dv(index, v);                                                        }
	VertexAttrib1f           :: #force_inline proc "c" (index: u32, x: f32)                                                                       {        impl_VertexAttrib1f(index, x);                                                         }
	VertexAttrib1fv          :: #force_inline proc "c" (index: u32, v: ^f32)                                                                      {        impl_VertexAttrib1fv(index, v);                                                        }
	VertexAttrib1s           :: #force_inline proc "c" (index: u32, x: i16)                                                                       {        impl_VertexAttrib1s(index, x);                                                         }
	VertexAttrib1sv          :: #force_inline proc "c" (index: u32, v: ^i16)                                                                      {        impl_VertexAttrib1sv(index, v);                                                        }
	VertexAttrib2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64)                                                               {        impl_VertexAttrib2d(index, x, y);                                                      }
	VertexAttrib2dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                                      {        impl_VertexAttrib2dv(index, v);                                                        }
	VertexAttrib2f           :: #force_inline proc "c" (index: u32, x: f32, y: f32)                                                               {        impl_VertexAttrib2f(index, x, y);                                                      }
	VertexAttrib2fv          :: #force_inline proc "c" (index: u32, v: ^f32)                                                                      {        impl_VertexAttrib2fv(index, v);                                                        }
	VertexAttrib2s           :: #force_inline proc "c" (index: u32, x: i16, y: i16)                                                               {        impl_VertexAttrib2s(index, x, y);                                                      }
	VertexAttrib2sv          :: #force_inline proc "c" (index: u32, v: ^i16)                                                                      {        impl_VertexAttrib2sv(index, v);                                                        }
	VertexAttrib3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64)                                                       {        impl_VertexAttrib3d(index, x, y, z);                                                   }
	VertexAttrib3dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                                      {        impl_VertexAttrib3dv(index, v);                                                        }
	VertexAttrib3f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32)                                                       {        impl_VertexAttrib3f(index, x, y, z);                                                   }
	VertexAttrib3fv          :: #force_inline proc "c" (index: u32, v: ^f32)                                                                      {        impl_VertexAttrib3fv(index, v);                                                        }
	VertexAttrib3s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16)                                                       {        impl_VertexAttrib3s(index, x, y, z);                                                   }
	VertexAttrib3sv          :: #force_inline proc "c" (index: u32, v: ^i16)                                                                      {        impl_VertexAttrib3sv(index, v);                                                        }
	VertexAttrib4Nbv         :: #force_inline proc "c" (index: u32, v: ^i8)                                                                       {        impl_VertexAttrib4Nbv(index, v);                                                       }
	VertexAttrib4Niv         :: #force_inline proc "c" (index: u32, v: ^i32)                                                                      {        impl_VertexAttrib4Niv(index, v);                                                       }
	VertexAttrib4Nsv         :: #force_inline proc "c" (index: u32, v: ^i16)                                                                      {        impl_VertexAttrib4Nsv(index, v);                                                       }
	VertexAttrib4Nub         :: #force_inline proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8)                                                   {        impl_VertexAttrib4Nub(index, x, y, z, w);                                              }
	VertexAttrib4Nubv        :: #force_inline proc "c" (index: u32, v: ^u8)                                                                       {        impl_VertexAttrib4Nubv(index, v);                                                      }
	VertexAttrib4Nuiv        :: #force_inline proc "c" (index: u32, v: ^u32)                                                                      {        impl_VertexAttrib4Nuiv(index, v);                                                      }
	VertexAttrib4Nusv        :: #force_inline proc "c" (index: u32, v: ^u16)                                                                      {        impl_VertexAttrib4Nusv(index, v);                                                      }
	VertexAttrib4bv          :: #force_inline proc "c" (index: u32, v: ^i8)                                                                       {        impl_VertexAttrib4bv(index, v);                                                        }
	VertexAttrib4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64)                                               {        impl_VertexAttrib4d(index, x, y, z, w);                                                }
	VertexAttrib4dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                                      {        impl_VertexAttrib4dv(index, v);                                                        }
	VertexAttrib4f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32)                                               {        impl_VertexAttrib4f(index, x, y, z, w);                                                }
	VertexAttrib4fv          :: #force_inline proc "c" (index: u32, v: ^f32)                                                                      {        impl_VertexAttrib4fv(index, v);                                                        }
	VertexAttrib4iv          :: #force_inline proc "c" (index: u32, v: ^i32)                                                                      {        impl_VertexAttrib4iv(index, v);                                                        }
	VertexAttrib4s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16)                                               {        impl_VertexAttrib4s(index, x, y, z, w);                                                }
	VertexAttrib4sv          :: #force_inline proc "c" (index: u32, v: ^i16)                                                                      {        impl_VertexAttrib4sv(index, v);                                                        }
	VertexAttrib4ubv         :: #force_inline proc "c" (index: u32, v: ^u8)                                                                       {        impl_VertexAttrib4ubv(index, v);                                                       }
	VertexAttrib4uiv         :: #force_inline proc "c" (index: u32, v: ^u32)                                                                      {        impl_VertexAttrib4uiv(index, v);                                                       }
	VertexAttrib4usv         :: #force_inline proc "c" (index: u32, v: ^u16)                                                                      {        impl_VertexAttrib4usv(index, v);                                                       }
	VertexAttribPointer      :: #force_inline proc "c" (index: u32, size: i32, type_: u32, normalized: u8, stride: i32, pointer: rawptr)          {        impl_VertexAttribPointer(index, size, type_, normalized, stride, pointer);             }

	// VERSION_2_1
	UniformMatrix2x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32) { impl_UniformMatrix2x3fv(location, count, transpose, value); }
	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32) { impl_UniformMatrix3x2fv(location, count, transpose, value); }
	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32) { impl_UniformMatrix2x4fv(location, count, transpose, value); }
	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32) { impl_UniformMatrix4x2fv(location, count, transpose, value); }
	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32) { impl_UniformMatrix3x4fv(location, count, transpose, value); }
	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32) { impl_UniformMatrix4x3fv(location, count, transpose, value); }


	// VERSION_3_0
	ColorMaski                          :: #force_inline proc "c" (index: u32, r: u8, g: u8, b: u8, a: u8)                                                                                 {        impl_ColorMaski(index, r, g, b, a);                                                                     }
	GetBooleani_v                       :: #force_inline proc "c" (target: u32, index: u32, data: ^u8)                                                                                     {        impl_GetBooleani_v(target, index, data);                                                                }
	GetIntegeri_v                       :: #force_inline proc "c" (target: u32, index: u32, data: ^i32)                                                                                    {        impl_GetIntegeri_v(target, index, data);                                                                }
	Enablei                             :: #force_inline proc "c" (target: u32, index: u32)                                                                                                {        impl_Enablei(target, index);                                                                            }
	Disablei                            :: #force_inline proc "c" (target: u32, index: u32)                                                                                                {        impl_Disablei(target, index);                                                                           }
	IsEnabledi                          :: #force_inline proc "c" (target: u32, index: u32) -> u8                                                                                          { ret := impl_IsEnabledi(target, index);                                                             return ret; }
	BeginTransformFeedback              :: #force_inline proc "c" (primitiveMode: u32)                                                                                                     {        impl_BeginTransformFeedback(primitiveMode);                                                             }
	EndTransformFeedback                :: #force_inline proc "c" ()                                                                                                                       {        impl_EndTransformFeedback();                                                                            }
	BindBufferRange                     :: #force_inline proc "c" (target: u32, index: u32, buffer: u32, offset: int, size: int)                                                           {        impl_BindBufferRange(target, index, buffer, offset, size);                                              }
	BindBufferBase                      :: #force_inline proc "c" (target: u32, index: u32, buffer: u32)                                                                                   {        impl_BindBufferBase(target, index, buffer);                                                             }
	TransformFeedbackVaryings           :: #force_inline proc "c" (program: u32, count: i32, varyings: ^u8, bufferMode: u32)                                                               {        impl_TransformFeedbackVaryings(program, count, varyings, bufferMode);                                   }
	GetTransformFeedbackVarying         :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type_: ^u32, name: ^u8)                               {        impl_GetTransformFeedbackVarying(program, index, bufSize, length, size, type_, name);                   }
	ClampColor                          :: #force_inline proc "c" (target: u32, clamp: u32)                                                                                                {        impl_ClampColor(target, clamp);                                                                         }
	BeginConditionalRender              :: #force_inline proc "c" (id: u32, mode: u32)                                                                                                     {        impl_BeginConditionalRender(id, mode);                                                                  }
	EndConditionalRender                :: #force_inline proc "c" ()                                                                                                                       {        impl_EndConditionalRender();                                                                            }
	VertexAttribIPointer                :: #force_inline proc "c" (index: u32, size: i32, type_: u32, stride: i32, pointer: rawptr)                                                        {        impl_VertexAttribIPointer(index, size, type_, stride, pointer);                                         }
	GetVertexAttribIiv                  :: #force_inline proc "c" (index: u32, pname: u32, params: ^i32)                                                                                   {        impl_GetVertexAttribIiv(index, pname, params);                                                          }
	GetVertexAttribIuiv                 :: #force_inline proc "c" (index: u32, pname: u32, params: ^u32)                                                                                   {        impl_GetVertexAttribIuiv(index, pname, params);                                                         }
	VertexAttribI1i                     :: #force_inline proc "c" (index: u32, x: i32)                                                                                                     {        impl_VertexAttribI1i(index, x);                                                                         }
	VertexAttribI2i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32)                                                                                             {        impl_VertexAttribI2i(index, x, y);                                                                      }
	VertexAttribI3i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32)                                                                                     {        impl_VertexAttribI3i(index, x, y, z);                                                                   }
	VertexAttribI4i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32, w: i32)                                                                             {        impl_VertexAttribI4i(index, x, y, z, w);                                                                }
	VertexAttribI1ui                    :: #force_inline proc "c" (index: u32, x: u32)                                                                                                     {        impl_VertexAttribI1ui(index, x);                                                                        }
	VertexAttribI2ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32)                                                                                             {        impl_VertexAttribI2ui(index, x, y);                                                                     }
	VertexAttribI3ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32)                                                                                     {        impl_VertexAttribI3ui(index, x, y, z);                                                                  }
	VertexAttribI4ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32, w: u32)                                                                             {        impl_VertexAttribI4ui(index, x, y, z, w);                                                               }
	VertexAttribI1iv                    :: #force_inline proc "c" (index: u32, v: ^i32)                                                                                                    {        impl_VertexAttribI1iv(index, v);                                                                        }
	VertexAttribI2iv                    :: #force_inline proc "c" (index: u32, v: ^i32)                                                                                                    {        impl_VertexAttribI2iv(index, v);                                                                        }
	VertexAttribI3iv                    :: #force_inline proc "c" (index: u32, v: ^i32)                                                                                                    {        impl_VertexAttribI3iv(index, v);                                                                        }
	VertexAttribI4iv                    :: #force_inline proc "c" (index: u32, v: ^i32)                                                                                                    {        impl_VertexAttribI4iv(index, v);                                                                        }
	VertexAttribI1uiv                   :: #force_inline proc "c" (index: u32, v: ^u32)                                                                                                    {        impl_VertexAttribI1uiv(index, v);                                                                       }
	VertexAttribI2uiv                   :: #force_inline proc "c" (index: u32, v: ^u32)                                                                                                    {        impl_VertexAttribI2uiv(index, v);                                                                       }
	VertexAttribI3uiv                   :: #force_inline proc "c" (index: u32, v: ^u32)                                                                                                    {        impl_VertexAttribI3uiv(index, v);                                                                       }
	VertexAttribI4uiv                   :: #force_inline proc "c" (index: u32, v: ^u32)                                                                                                    {        impl_VertexAttribI4uiv(index, v);                                                                       }
	VertexAttribI4bv                    :: #force_inline proc "c" (index: u32, v: ^i8)                                                                                                     {        impl_VertexAttribI4bv(index, v);                                                                        }
	VertexAttribI4sv                    :: #force_inline proc "c" (index: u32, v: ^i16)                                                                                                    {        impl_VertexAttribI4sv(index, v);                                                                        }
	VertexAttribI4ubv                   :: #force_inline proc "c" (index: u32, v: ^u8)                                                                                                     {        impl_VertexAttribI4ubv(index, v);                                                                       }
	VertexAttribI4usv                   :: #force_inline proc "c" (index: u32, v: ^u16)                                                                                                    {        impl_VertexAttribI4usv(index, v);                                                                       }
	GetUniformuiv                       :: #force_inline proc "c" (program: u32, location: i32, params: ^u32)                                                                              {        impl_GetUniformuiv(program, location, params);                                                          }
	BindFragDataLocation                :: #force_inline proc "c" (program: u32, color: u32, name: ^u8)                                                                                    {        impl_BindFragDataLocation(program, color, name);                                                        }
	GetFragDataLocation                 :: #force_inline proc "c" (program: u32, name: ^u8) -> i32                                                                                         { ret := impl_GetFragDataLocation(program, name);                                                    return ret; }
	Uniform1ui                          :: #force_inline proc "c" (location: i32, v0: u32)                                                                                                 {        impl_Uniform1ui(location, v0);                                                                          }
	Uniform2ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32)                                                                                        {        impl_Uniform2ui(location, v0, v1);                                                                      }
	Uniform3ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32)                                                                               {        impl_Uniform3ui(location, v0, v1, v2);                                                                  }
	Uniform4ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32)                                                                      {        impl_Uniform4ui(location, v0, v1, v2, v3);                                                              }
	Uniform1uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: ^u32)                                                                                 {        impl_Uniform1uiv(location, count, value);                                                               }
	Uniform2uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: ^u32)                                                                                 {        impl_Uniform2uiv(location, count, value);                                                               }
	Uniform3uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: ^u32)                                                                                 {        impl_Uniform3uiv(location, count, value);                                                               }
	Uniform4uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: ^u32)                                                                                 {        impl_Uniform4uiv(location, count, value);                                                               }
	TexParameterIiv                     :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32)                                                                                  {        impl_TexParameterIiv(target, pname, params);                                                            }
	TexParameterIuiv                    :: #force_inline proc "c" (target: u32, pname: u32, params: ^u32)                                                                                  {        impl_TexParameterIuiv(target, pname, params);                                                           }
	GetTexParameterIiv                  :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32)                                                                                  {        impl_GetTexParameterIiv(target, pname, params);                                                         }
	GetTexParameterIuiv                 :: #force_inline proc "c" (target: u32, pname: u32, params: ^u32)                                                                                  {        impl_GetTexParameterIuiv(target, pname, params);                                                        }
	ClearBufferiv                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^i32)                                                                              {        impl_ClearBufferiv(buffer, drawbuffer, value);                                                          }
	ClearBufferuiv                      :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^u32)                                                                              {        impl_ClearBufferuiv(buffer, drawbuffer, value);                                                         }
	ClearBufferfv                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^f32)                                                                              {        impl_ClearBufferfv(buffer, drawbuffer, value);                                                          }
	ClearBufferfi                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, depth: f32, stencil: i32) -> rawptr                                                       { ret := impl_ClearBufferfi(buffer, drawbuffer, depth, stencil);                                     return ret; }
	GetStringi                          :: #force_inline proc "c" (name: u32, index: u32) -> cstring                                                                                            { ret := impl_GetStringi(name, index);                                                               return ret; }
	IsRenderbuffer                      :: #force_inline proc "c" (renderbuffer: u32) -> u8                                                                                                { ret := impl_IsRenderbuffer(renderbuffer);                                                          return ret; }
	BindRenderbuffer                    :: #force_inline proc "c" (target: u32, renderbuffer: u32)                                                                                         {        impl_BindRenderbuffer(target, renderbuffer);                                                            }
	DeleteRenderbuffers                 :: #force_inline proc "c" (n: i32, renderbuffers: ^u32)                                                                                            {        impl_DeleteRenderbuffers(n, renderbuffers);                                                             }
	GenRenderbuffers                    :: #force_inline proc "c" (n: i32, renderbuffers: ^u32)                                                                                            {        impl_GenRenderbuffers(n, renderbuffers);                                                                }
	RenderbufferStorage                 :: #force_inline proc "c" (target: u32, internalformat: u32, width: i32, height: i32)                                                              {        impl_RenderbufferStorage(target, internalformat, width, height);                                        }
	GetRenderbufferParameteriv          :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32)                                                                                  {        impl_GetRenderbufferParameteriv(target, pname, params);                                                 }
	IsFramebuffer                       :: #force_inline proc "c" (framebuffer: u32) -> u8                                                                                                 { ret := impl_IsFramebuffer(framebuffer);                                                            return ret; }
	BindFramebuffer                     :: #force_inline proc "c" (target: u32, framebuffer: u32)                                                                                          {        impl_BindFramebuffer(target, framebuffer);                                                              }
	DeleteFramebuffers                  :: #force_inline proc "c" (n: i32, framebuffers: ^u32)                                                                                             {        impl_DeleteFramebuffers(n, framebuffers);                                                               }
	GenFramebuffers                     :: #force_inline proc "c" (n: i32, framebuffers: ^u32)                                                                                             {        impl_GenFramebuffers(n, framebuffers);                                                                  }
	CheckFramebufferStatus              :: #force_inline proc "c" (target: u32) -> u32                                                                                                     { ret := impl_CheckFramebufferStatus(target);                                                        return ret; }
	FramebufferTexture1D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32)                                                 {        impl_FramebufferTexture1D(target, attachment, textarget, texture, level);                               }
	FramebufferTexture2D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32)                                                 {        impl_FramebufferTexture2D(target, attachment, textarget, texture, level);                               }
	FramebufferTexture3D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32)                                   {        impl_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);                      }
	FramebufferRenderbuffer             :: #force_inline proc "c" (target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32)                                               {        impl_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);                     }
	GetFramebufferAttachmentParameteriv :: #force_inline proc "c" (target: u32, attachment: u32, pname: u32, params: ^i32)                                                                 {        impl_GetFramebufferAttachmentParameteriv(target, attachment, pname, params);                            }
	GenerateMipmap                      :: #force_inline proc "c" (target: u32)                                                                                                            {        impl_GenerateMipmap(target);                                                                            }
	BlitFramebuffer                     :: #force_inline proc "c" (srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) {        impl_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);             }
	RenderbufferStorageMultisample      :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32)                                                {        impl_RenderbufferStorageMultisample(target, samples, internalformat, width, height);                    }
	FramebufferTextureLayer             :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32, layer: i32)                                                     {        impl_FramebufferTextureLayer(target, attachment, texture, level, layer);                                }
	MapBufferRange                      :: #force_inline proc "c" (target: u32, offset: int, length: int, access: u32) -> rawptr                                                           { ret := impl_MapBufferRange(target, offset, length, access);                                        return ret; }
	FlushMappedBufferRange              :: #force_inline proc "c" (target: u32, offset: int, length: int)                                                                                  {        impl_FlushMappedBufferRange(target, offset, length);                                                    }
	BindVertexArray                     :: #force_inline proc "c" (array: u32)                                                                                                             {        impl_BindVertexArray(array);                                                                            }
	DeleteVertexArrays                  :: #force_inline proc "c" (n: i32, arrays: ^u32)                                                                                                   {        impl_DeleteVertexArrays(n, arrays);                                                                     }
	GenVertexArrays                     :: #force_inline proc "c" (n: i32, arrays: ^u32)                                                                                                   {        impl_GenVertexArrays(n, arrays);                                                                        }
	IsVertexArray                       :: #force_inline proc "c" (array: u32) -> u8                                                                                                       { ret := impl_IsVertexArray(array);                                                                  return ret; }

	// VERSION_3_1
	DrawArraysInstanced       :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32)                                   {        impl_DrawArraysInstanced(mode, first, count, instancecount);                                               }
	DrawElementsInstanced     :: #force_inline proc "c" (mode: u32, count: i32, type_: u32, indices: rawptr, instancecount: i32)                  {        impl_DrawElementsInstanced(mode, count, type_, indices, instancecount);                                    }
	TexBuffer                 :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32)                                           {        impl_TexBuffer(target, internalformat, buffer);                                                            }
	PrimitiveRestartIndex     :: #force_inline proc "c" (index: u32)                                                                              {        impl_PrimitiveRestartIndex(index);                                                                         }
	CopyBufferSubData         :: #force_inline proc "c" (readTarget: u32, writeTarget: u32, readOffset: int, writeOffset: int, size: int)         {        impl_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);                            }
	GetUniformIndices         :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformNames: ^u8, uniformIndices: ^u32)                {        impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);                               }
	GetActiveUniformsiv       :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformIndices: ^u32, pname: u32, params: ^i32)         {        impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);                            }
	GetActiveUniformName      :: #force_inline proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: ^u8)           {        impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);                            }
	GetUniformBlockIndex      :: #force_inline proc "c" (program: u32, uniformBlockName: ^u8) -> u32                                              { ret := impl_GetUniformBlockIndex(program, uniformBlockName);                                          return ret; }
	GetActiveUniformBlockiv   :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: ^i32)                          {        impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);                                   }
	GetActiveUniformBlockName :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, bufSize: i32, length: ^i32, uniformBlockName: ^u8) {        impl_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);             }
	UniformBlockBinding       :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32)                          {        impl_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);                                 }

	// VERSION_3_2
	DrawElementsBaseVertex          :: #force_inline proc "c" (mode: u32, count: i32, type_: u32, indices: rawptr, basevertex: i32)                                           {        impl_DrawElementsBaseVertex(mode, count, type_, indices, basevertex);                                                }
	DrawRangeElementsBaseVertex     :: #force_inline proc "c" (mode: u32, start: u32, end: u32, count: i32, type_: u32, indices: rawptr, basevertex: i32)                     {        impl_DrawRangeElementsBaseVertex(mode, start, end, count, type_, indices, basevertex);                               }
	DrawElementsInstancedBaseVertex :: #force_inline proc "c" (mode: u32, count: i32, type_: u32, indices: rawptr, instancecount: i32, basevertex: i32)                       {        impl_DrawElementsInstancedBaseVertex(mode, count, type_, indices, instancecount, basevertex);                        }
	MultiDrawElementsBaseVertex     :: #force_inline proc "c" (mode: u32, count: ^i32, type_: u32, indices: ^rawptr, drawcount: i32, basevertex: ^i32)                        {        impl_MultiDrawElementsBaseVertex(mode, count, type_, indices, drawcount, basevertex);                                }
	ProvokingVertex                 :: #force_inline proc "c" (mode: u32)                                                                                                     {        impl_ProvokingVertex(mode);                                                                                          }
	FenceSync                       :: #force_inline proc "c" (condition: u32, flags: u32) -> sync_t                                                                          { ret := impl_FenceSync(condition, flags);                                                                        return ret; }
	IsSync                          :: #force_inline proc "c" (sync: sync_t) -> u8                                                                                            { ret := impl_IsSync(sync);                                                                                       return ret; }
	DeleteSync                      :: #force_inline proc "c" (sync: sync_t)                                                                                                  {        impl_DeleteSync(sync);                                                                                               }
	ClientWaitSync                  :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64) -> u32                                                                 { ret := impl_ClientWaitSync(sync, flags, timeout);                                                               return ret; }
	WaitSync                        :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64)                                                                        {        impl_WaitSync(sync, flags, timeout);                                                                                 }
	GetInteger64v                   :: #force_inline proc "c" (pname: u32, data: ^i64)                                                                                        {        impl_GetInteger64v(pname, data);                                                                                     }
	GetSynciv                       :: #force_inline proc "c" (sync: sync_t, pname: u32, bufSize: i32, length: ^i32, values: ^i32)                                            {        impl_GetSynciv(sync, pname, bufSize, length, values);                                                                }
	GetInteger64i_v                 :: #force_inline proc "c" (target: u32, index: u32, data: ^i64)                                                                           {        impl_GetInteger64i_v(target, index, data);                                                                           }
	GetBufferParameteri64v          :: #force_inline proc "c" (target: u32, pname: u32, params: ^i64)                                                                         {        impl_GetBufferParameteri64v(target, pname, params);                                                                  }
	FramebufferTexture              :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32)                                                        {        impl_FramebufferTexture(target, attachment, texture, level);                                                         }
	TexImage2DMultisample           :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8)             {        impl_TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);                    }
	TexImage3DMultisample           :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8) {        impl_TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);             }
	GetMultisamplefv                :: #force_inline proc "c" (pname: u32, index: u32, val: ^f32)                                                                             {        impl_GetMultisamplefv(pname, index, val);                                                                            }
	SampleMaski                     :: #force_inline proc "c" (maskNumber: u32, mask: u32)                                                                                    {        impl_SampleMaski(maskNumber, mask);                                                                                  }

	// VERSION_3_3
	BindFragDataLocationIndexed :: #force_inline proc "c" (program: u32, colorNumber: u32, index: u32, name: ^u8) {        impl_BindFragDataLocationIndexed(program, colorNumber, index, name);             }
	GetFragDataIndex            :: #force_inline proc "c" (program: u32, name: ^u8) -> i32                        { ret := impl_GetFragDataIndex(program, name);                                return ret; }
	GenSamplers                 :: #force_inline proc "c" (count: i32, samplers: ^u32)                            {        impl_GenSamplers(count, samplers);                                               }
	DeleteSamplers              :: #force_inline proc "c" (count: i32, samplers: ^u32)                            {        impl_DeleteSamplers(count, samplers);                                            }
	IsSampler                   :: #force_inline proc "c" (sampler: u32) -> u8                                    { ret := impl_IsSampler(sampler);                                             return ret; }
	BindSampler                 :: #force_inline proc "c" (unit: u32, sampler: u32)                               {        impl_BindSampler(unit, sampler);                                                 }
	SamplerParameteri           :: #force_inline proc "c" (sampler: u32, pname: u32, param: i32)                  {        impl_SamplerParameteri(sampler, pname, param);                                   }
	SamplerParameteriv          :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32)                 {        impl_SamplerParameteriv(sampler, pname, param);                                  }
	SamplerParameterf           :: #force_inline proc "c" (sampler: u32, pname: u32, param: f32)                  {        impl_SamplerParameterf(sampler, pname, param);                                   }
	SamplerParameterfv          :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^f32)                 {        impl_SamplerParameterfv(sampler, pname, param);                                  }
	SamplerParameterIiv         :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32)                 {        impl_SamplerParameterIiv(sampler, pname, param);                                 }
	SamplerParameterIuiv        :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^u32)                 {        impl_SamplerParameterIuiv(sampler, pname, param);                                }
	GetSamplerParameteriv       :: #force_inline proc "c" (sampler: u32, pname: u32, params: ^i32)                {        impl_GetSamplerParameteriv(sampler, pname, params);                              }
	GetSamplerParameterIiv      :: #force_inline proc "c" (sampler: u32, pname: u32, params: ^i32)                {        impl_GetSamplerParameterIiv(sampler, pname, params);                             }
	GetSamplerParameterfv       :: #force_inline proc "c" (sampler: u32, pname: u32, params: ^f32)                {        impl_GetSamplerParameterfv(sampler, pname, params);                              }
	GetSamplerParameterIuiv     :: #force_inline proc "c" (sampler: u32, pname: u32, params: ^u32)                {        impl_GetSamplerParameterIuiv(sampler, pname, params);                            }
	QueryCounter                :: #force_inline proc "c" (id: u32, target: u32)                                  {        impl_QueryCounter(id, target);                                                   }
	GetQueryObjecti64v          :: #force_inline proc "c" (id: u32, pname: u32, params: ^i64)                     {        impl_GetQueryObjecti64v(id, pname, params);                                      }
	GetQueryObjectui64v         :: #force_inline proc "c" (id: u32, pname: u32, params: ^u64)                     {        impl_GetQueryObjectui64v(id, pname, params);                                     }
	VertexAttribDivisor         :: #force_inline proc "c" (index: u32, divisor: u32)                              {        impl_VertexAttribDivisor(index, divisor);                                        }
	VertexAttribP1ui            :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: u32)    {        impl_VertexAttribP1ui(index, type_, normalized, value);                          }
	VertexAttribP1uiv           :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: ^u32)   {        impl_VertexAttribP1uiv(index, type_, normalized, value);                         }
	VertexAttribP2ui            :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: u32)    {        impl_VertexAttribP2ui(index, type_, normalized, value);                          }
	VertexAttribP2uiv           :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: ^u32)   {        impl_VertexAttribP2uiv(index, type_, normalized, value);                         }
	VertexAttribP3ui            :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: u32)    {        impl_VertexAttribP3ui(index, type_, normalized, value);                          }
	VertexAttribP3uiv           :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: ^u32)   {        impl_VertexAttribP3uiv(index, type_, normalized, value);                         }
	VertexAttribP4ui            :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: u32)    {        impl_VertexAttribP4ui(index, type_, normalized, value);                          }
	VertexAttribP4uiv           :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: ^u32)   {        impl_VertexAttribP4uiv(index, type_, normalized, value);                         }
	VertexP2ui                  :: #force_inline proc "c" (type_: u32, value: u32)                                {        impl_VertexP2ui(type_, value);                                                   }
	VertexP2uiv                 :: #force_inline proc "c" (type_: u32, value: ^u32)                               {        impl_VertexP2uiv(type_, value);                                                  }
	VertexP3ui                  :: #force_inline proc "c" (type_: u32, value: u32)                                {        impl_VertexP3ui(type_, value);                                                   }
	VertexP3uiv                 :: #force_inline proc "c" (type_: u32, value: ^u32)                               {        impl_VertexP3uiv(type_, value);                                                  }
	VertexP4ui                  :: #force_inline proc "c" (type_: u32, value: u32)                                {        impl_VertexP4ui(type_, value);                                                   }
	VertexP4uiv                 :: #force_inline proc "c" (type_: u32, value: ^u32)                               {        impl_VertexP4uiv(type_, value);                                                  }
	TexCoordP1ui                :: #force_inline proc "c" (type_: u32, coords: u32)                               {        impl_TexCoordP1ui(type_, coords);                                                }
	TexCoordP1uiv               :: #force_inline proc "c" (type_: u32, coords: ^u32)                              {        impl_TexCoordP1uiv(type_, coords);                                               }
	TexCoordP2ui                :: #force_inline proc "c" (type_: u32, coords: u32)                               {        impl_TexCoordP2ui(type_, coords);                                                }
	TexCoordP2uiv               :: #force_inline proc "c" (type_: u32, coords: ^u32)                              {        impl_TexCoordP2uiv(type_, coords);                                               }
	TexCoordP3ui                :: #force_inline proc "c" (type_: u32, coords: u32)                               {        impl_TexCoordP3ui(type_, coords);                                                }
	TexCoordP3uiv               :: #force_inline proc "c" (type_: u32, coords: ^u32)                              {        impl_TexCoordP3uiv(type_, coords);                                               }
	TexCoordP4ui                :: #force_inline proc "c" (type_: u32, coords: u32)                               {        impl_TexCoordP4ui(type_, coords);                                                }
	TexCoordP4uiv               :: #force_inline proc "c" (type_: u32, coords: ^u32)                              {        impl_TexCoordP4uiv(type_, coords);                                               }
	MultiTexCoordP1ui           :: #force_inline proc "c" (texture: u32, type_: u32, coords: u32)                 {        impl_MultiTexCoordP1ui(texture, type_, coords);                                  }
	MultiTexCoordP1uiv          :: #force_inline proc "c" (texture: u32, type_: u32, coords: ^u32)                {        impl_MultiTexCoordP1uiv(texture, type_, coords);                                 }
	MultiTexCoordP2ui           :: #force_inline proc "c" (texture: u32, type_: u32, coords: u32)                 {        impl_MultiTexCoordP2ui(texture, type_, coords);                                  }
	MultiTexCoordP2uiv          :: #force_inline proc "c" (texture: u32, type_: u32, coords: ^u32)                {        impl_MultiTexCoordP2uiv(texture, type_, coords);                                 }
	MultiTexCoordP3ui           :: #force_inline proc "c" (texture: u32, type_: u32, coords: u32)                 {        impl_MultiTexCoordP3ui(texture, type_, coords);                                  }
	MultiTexCoordP3uiv          :: #force_inline proc "c" (texture: u32, type_: u32, coords: ^u32)                {        impl_MultiTexCoordP3uiv(texture, type_, coords);                                 }
	MultiTexCoordP4ui           :: #force_inline proc "c" (texture: u32, type_: u32, coords: u32)                 {        impl_MultiTexCoordP4ui(texture, type_, coords);                                  }
	MultiTexCoordP4uiv          :: #force_inline proc "c" (texture: u32, type_: u32, coords: ^u32)                {        impl_MultiTexCoordP4uiv(texture, type_, coords);                                 }
	NormalP3ui                  :: #force_inline proc "c" (type_: u32, coords: u32)                               {        impl_NormalP3ui(type_, coords);                                                  }
	NormalP3uiv                 :: #force_inline proc "c" (type_: u32, coords: ^u32)                              {        impl_NormalP3uiv(type_, coords);                                                 }
	ColorP3ui                   :: #force_inline proc "c" (type_: u32, color: u32)                                {        impl_ColorP3ui(type_, color);                                                    }
	ColorP3uiv                  :: #force_inline proc "c" (type_: u32, color: ^u32)                               {        impl_ColorP3uiv(type_, color);                                                   }
	ColorP4ui                   :: #force_inline proc "c" (type_: u32, color: u32)                                {        impl_ColorP4ui(type_, color);                                                    }
	ColorP4uiv                  :: #force_inline proc "c" (type_: u32, color: ^u32)                               {        impl_ColorP4uiv(type_, color);                                                   }
	SecondaryColorP3ui          :: #force_inline proc "c" (type_: u32, color: u32)                                {        impl_SecondaryColorP3ui(type_, color);                                           }
	SecondaryColorP3uiv         :: #force_inline proc "c" (type_: u32, color: ^u32)                               {        impl_SecondaryColorP3uiv(type_, color);                                          }

	// VERSION_4_0
	MinSampleShading               :: #force_inline proc "c" (value: f32)                                                                        {        impl_MinSampleShading(value);                                                                        }
	BlendEquationi                 :: #force_inline proc "c" (buf: u32, mode: u32)                                                               {        impl_BlendEquationi(buf, mode);                                                                      }
	BlendEquationSeparatei         :: #force_inline proc "c" (buf: u32, modeRGB: u32, modeAlpha: u32)                                            {        impl_BlendEquationSeparatei(buf, modeRGB, modeAlpha);                                                }
	BlendFunci                     :: #force_inline proc "c" (buf: u32, src: u32, dst: u32)                                                      {        impl_BlendFunci(buf, src, dst);                                                                      }
	BlendFuncSeparatei             :: #force_inline proc "c" (buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32)                  {        impl_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);                                    }
	DrawArraysIndirect             :: #force_inline proc "c" (mode: u32, indirect: rawptr)                                                       {        impl_DrawArraysIndirect(mode, indirect);                                                             }
	DrawElementsIndirect           :: #force_inline proc "c" (mode: u32, type_: u32, indirect: rawptr)                                           {        impl_DrawElementsIndirect(mode, type_, indirect);                                                    }
	Uniform1d                      :: #force_inline proc "c" (location: i32, x: f64)                                                             {        impl_Uniform1d(location, x);                                                                         }
	Uniform2d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64)                                                     {        impl_Uniform2d(location, x, y);                                                                      }
	Uniform3d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64)                                             {        impl_Uniform3d(location, x, y, z);                                                                   }
	Uniform4d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64)                                     {        impl_Uniform4d(location, x, y, z, w);                                                                }
	Uniform1dv                     :: #force_inline proc "c" (location: i32, count: i32, value: ^f64)                                            {        impl_Uniform1dv(location, count, value);                                                             }
	Uniform2dv                     :: #force_inline proc "c" (location: i32, count: i32, value: ^f64)                                            {        impl_Uniform2dv(location, count, value);                                                             }
	Uniform3dv                     :: #force_inline proc "c" (location: i32, count: i32, value: ^f64)                                            {        impl_Uniform3dv(location, count, value);                                                             }
	Uniform4dv                     :: #force_inline proc "c" (location: i32, count: i32, value: ^f64)                                            {        impl_Uniform4dv(location, count, value);                                                             }
	UniformMatrix2dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64)                             {        impl_UniformMatrix2dv(location, count, transpose, value);                                            }
	UniformMatrix3dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64)                             {        impl_UniformMatrix3dv(location, count, transpose, value);                                            }
	UniformMatrix4dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64)                             {        impl_UniformMatrix4dv(location, count, transpose, value);                                            }
	UniformMatrix2x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64)                             {        impl_UniformMatrix2x3dv(location, count, transpose, value);                                          }
	UniformMatrix2x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64)                             {        impl_UniformMatrix2x4dv(location, count, transpose, value);                                          }
	UniformMatrix3x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64)                             {        impl_UniformMatrix3x2dv(location, count, transpose, value);                                          }
	UniformMatrix3x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64)                             {        impl_UniformMatrix3x4dv(location, count, transpose, value);                                          }
	UniformMatrix4x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64)                             {        impl_UniformMatrix4x2dv(location, count, transpose, value);                                          }
	UniformMatrix4x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64)                             {        impl_UniformMatrix4x3dv(location, count, transpose, value);                                          }
	GetUniformdv                   :: #force_inline proc "c" (program: u32, location: i32, params: ^f64)                                         {        impl_GetUniformdv(program, location, params);                                                        }
	GetSubroutineUniformLocation   :: #force_inline proc "c" (program: u32, shadertype_: u32, name: ^u8) -> i32                                  { ret := impl_GetSubroutineUniformLocation(program, shadertype_, name);                           return ret; }
	GetSubroutineIndex             :: #force_inline proc "c" (program: u32, shadertype_: u32, name: ^u8) -> u32                                  { ret := impl_GetSubroutineIndex(program, shadertype_, name);                                     return ret; }
	GetActiveSubroutineUniformiv   :: #force_inline proc "c" (program: u32, shadertype_: u32, index: u32, pname: u32, values: ^i32)              {        impl_GetActiveSubroutineUniformiv(program, shadertype_, index, pname, values);                       }
	GetActiveSubroutineUniformName :: #force_inline proc "c" (program: u32, shadertype_: u32, index: u32, bufsize: i32, length: ^i32, name: ^u8) {        impl_GetActiveSubroutineUniformName(program, shadertype_, index, bufsize, length, name);             }
	GetActiveSubroutineName        :: #force_inline proc "c" (program: u32, shadertype_: u32, index: u32, bufsize: i32, length: ^i32, name: ^u8) {        impl_GetActiveSubroutineName(program, shadertype_, index, bufsize, length, name);                    }
	UniformSubroutinesuiv          :: #force_inline proc "c" (shadertype_: u32, count: i32, indices: ^u32)                                       {        impl_UniformSubroutinesuiv(shadertype_, count, indices);                                             }
	GetUniformSubroutineuiv        :: #force_inline proc "c" (shadertype_: u32, location: i32, params: ^u32)                                     {        impl_GetUniformSubroutineuiv(shadertype_, location, params);                                         }
	GetProgramStageiv              :: #force_inline proc "c" (program: u32, shadertype_: u32, pname: u32, values: ^i32)                          {        impl_GetProgramStageiv(program, shadertype_, pname, values);                                         }
	PatchParameteri                :: #force_inline proc "c" (pname: u32, value: i32)                                                            {        impl_PatchParameteri(pname, value);                                                                  }
	PatchParameterfv               :: #force_inline proc "c" (pname: u32, values: ^f32)                                                          {        impl_PatchParameterfv(pname, values);                                                                }
	BindTransformFeedback          :: #force_inline proc "c" (target: u32, id: u32)                                                              {        impl_BindTransformFeedback(target, id);                                                              }
	DeleteTransformFeedbacks       :: #force_inline proc "c" (n: i32, ids: ^u32)                                                                 {        impl_DeleteTransformFeedbacks(n, ids);                                                               }
	GenTransformFeedbacks          :: #force_inline proc "c" (n: i32, ids: ^u32)                                                                 {        impl_GenTransformFeedbacks(n, ids);                                                                  }
	IsTransformFeedback            :: #force_inline proc "c" (id: u32) -> u8                                                                     { ret := impl_IsTransformFeedback(id);                                                            return ret; }
	PauseTransformFeedback         :: #force_inline proc "c" ()                                                                                  {        impl_PauseTransformFeedback();                                                                       }
	ResumeTransformFeedback        :: #force_inline proc "c" ()                                                                                  {        impl_ResumeTransformFeedback();                                                                      }
	DrawTransformFeedback          :: #force_inline proc "c" (mode: u32, id: u32)                                                                {        impl_DrawTransformFeedback(mode, id);                                                                }
	DrawTransformFeedbackStream    :: #force_inline proc "c" (mode: u32, id: u32, stream: u32)                                                   {        impl_DrawTransformFeedbackStream(mode, id, stream);                                                  }
	BeginQueryIndexed              :: #force_inline proc "c" (target: u32, index: u32, id: u32)                                                  {        impl_BeginQueryIndexed(target, index, id);                                                           }
	EndQueryIndexed                :: #force_inline proc "c" (target: u32, index: u32)                                                           {        impl_EndQueryIndexed(target, index);                                                                 }
	GetQueryIndexediv              :: #force_inline proc "c" (target: u32, index: u32, pname: u32, params: ^i32)                                 {        impl_GetQueryIndexediv(target, index, pname, params);                                                }

	// VERSION_4_1
	ReleaseShaderCompiler     :: #force_inline proc "c" ()                                                                             {        impl_ReleaseShaderCompiler();                                                             }
	ShaderBinary              :: #force_inline proc "c" (count: i32, shaders: ^u32, binaryformat: u32, binary: rawptr, length: i32)    {        impl_ShaderBinary(count, shaders, binaryformat, binary, length);                          }
	GetShaderPrecisionFormat  :: #force_inline proc "c" (shadertype_: u32, precisiontype_: u32, range: ^i32, precision: ^i32)          {        impl_GetShaderPrecisionFormat(shadertype_, precisiontype_, range, precision);             }
	DepthRangef               :: #force_inline proc "c" (n: f32, f: f32)                                                               {        impl_DepthRangef(n, f);                                                                   }
	ClearDepthf               :: #force_inline proc "c" (d: f32)                                                                       {        impl_ClearDepthf(d);                                                                      }
	GetProgramBinary          :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, binaryFormat: ^u32, binary: rawptr) {        impl_GetProgramBinary(program, bufSize, length, binaryFormat, binary);                    }
	ProgramBinary             :: #force_inline proc "c" (program: u32, binaryFormat: u32, binary: rawptr, length: i32)                 {        impl_ProgramBinary(program, binaryFormat, binary, length);                                }
	ProgramParameteri         :: #force_inline proc "c" (program: u32, pname: u32, value: i32)                                         {        impl_ProgramParameteri(program, pname, value);                                            }
	UseProgramStages          :: #force_inline proc "c" (pipeline: u32, stages: u32, program: u32)                                     {        impl_UseProgramStages(pipeline, stages, program);                                         }
	ActiveShaderProgram       :: #force_inline proc "c" (pipeline: u32, program: u32)                                                  {        impl_ActiveShaderProgram(pipeline, program);                                              }
	CreateShaderProgramv      :: #force_inline proc "c" (type_: u32, count: i32, strings: ^u8) -> u32                                  { ret := impl_CreateShaderProgramv(type_, count, strings);                             return ret; }
	BindProgramPipeline       :: #force_inline proc "c" (pipeline: u32)                                                                {        impl_BindProgramPipeline(pipeline);                                                       }
	DeleteProgramPipelines    :: #force_inline proc "c" (n: i32, pipelines: ^u32)                                                      {        impl_DeleteProgramPipelines(n, pipelines);                                                }
	GenProgramPipelines       :: #force_inline proc "c" (n: i32, pipelines: ^u32)                                                      {        impl_GenProgramPipelines(n, pipelines);                                                   }
	IsProgramPipeline         :: #force_inline proc "c" (pipeline: u32) -> u8                                                          { ret := impl_IsProgramPipeline(pipeline);                                             return ret; }
	GetProgramPipelineiv      :: #force_inline proc "c" (pipeline: u32, pname: u32, params: ^i32)                                      {        impl_GetProgramPipelineiv(pipeline, pname, params);                                       }
	ProgramUniform1i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32)                                         {        impl_ProgramUniform1i(program, location, v0);                                             }
	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^i32)                         {        impl_ProgramUniform1iv(program, location, count, value);                                  }
	ProgramUniform1f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32)                                         {        impl_ProgramUniform1f(program, location, v0);                                             }
	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f32)                         {        impl_ProgramUniform1fv(program, location, count, value);                                  }
	ProgramUniform1d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64)                                         {        impl_ProgramUniform1d(program, location, v0);                                             }
	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f64)                         {        impl_ProgramUniform1dv(program, location, count, value);                                  }
	ProgramUniform1ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32)                                         {        impl_ProgramUniform1ui(program, location, v0);                                            }
	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^u32)                         {        impl_ProgramUniform1uiv(program, location, count, value);                                 }
	ProgramUniform2i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32)                                {        impl_ProgramUniform2i(program, location, v0, v1);                                         }
	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^i32)                         {        impl_ProgramUniform2iv(program, location, count, value);                                  }
	ProgramUniform2f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32)                                {        impl_ProgramUniform2f(program, location, v0, v1);                                         }
	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f32)                         {        impl_ProgramUniform2fv(program, location, count, value);                                  }
	ProgramUniform2d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64)                                {        impl_ProgramUniform2d(program, location, v0, v1);                                         }
	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f64)                         {        impl_ProgramUniform2dv(program, location, count, value);                                  }
	ProgramUniform2ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32)                                {        impl_ProgramUniform2ui(program, location, v0, v1);                                        }
	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^u32)                         {        impl_ProgramUniform2uiv(program, location, count, value);                                 }
	ProgramUniform3i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2);                                     }
	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^i32)                         {        impl_ProgramUniform3iv(program, location, count, value);                                  }
	ProgramUniform3f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2);                                     }
	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f32)                         {        impl_ProgramUniform3fv(program, location, count, value);                                  }
	ProgramUniform3d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2);                                     }
	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f64)                         {        impl_ProgramUniform3dv(program, location, count, value);                                  }
	ProgramUniform3ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2);                                    }
	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^u32)                         {        impl_ProgramUniform3uiv(program, location, count, value);                                 }
	ProgramUniform4i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3);                                 }
	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^i32)                         {        impl_ProgramUniform4iv(program, location, count, value);                                  }
	ProgramUniform4f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3);                                 }
	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f32)                         {        impl_ProgramUniform4fv(program, location, count, value);                                  }
	ProgramUniform4d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3);                                 }
	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f64)                         {        impl_ProgramUniform4dv(program, location, count, value);                                  }
	ProgramUniform4ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3);                                }
	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^u32)                         {        impl_ProgramUniform4uiv(program, location, count, value);                                 }
	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32)          {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);                 }
	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32)          {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);                 }
	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32)          {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);                 }
	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64)          {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);                 }
	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64)          {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);                 }
	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64)          {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);                 }
	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32)          {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);               }
	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32)          {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);               }
	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32)          {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);               }
	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32)          {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);               }
	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32)          {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);               }
	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32)          {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);               }
	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64)          {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);               }
	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64)          {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);               }
	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64)          {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);               }
	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64)          {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);               }
	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64)          {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);               }
	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64)          {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);               }
	ValidateProgramPipeline   :: #force_inline proc "c" (pipeline: u32)                                                                {        impl_ValidateProgramPipeline(pipeline);                                                   }
	GetProgramPipelineInfoLog :: #force_inline proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: ^u8)                      {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);                       }
	VertexAttribL1d           :: #force_inline proc "c" (index: u32, x: f64)                                                           {        impl_VertexAttribL1d(index, x);                                                           }
	VertexAttribL2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64)                                                   {        impl_VertexAttribL2d(index, x, y);                                                        }
	VertexAttribL3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64)                                           {        impl_VertexAttribL3d(index, x, y, z);                                                     }
	VertexAttribL4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64)                                   {        impl_VertexAttribL4d(index, x, y, z, w);                                                  }
	VertexAttribL1dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                          {        impl_VertexAttribL1dv(index, v);                                                          }
	VertexAttribL2dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                          {        impl_VertexAttribL2dv(index, v);                                                          }
	VertexAttribL3dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                          {        impl_VertexAttribL3dv(index, v);                                                          }
	VertexAttribL4dv          :: #force_inline proc "c" (index: u32, v: ^f64)                                                          {        impl_VertexAttribL4dv(index, v);                                                          }
	VertexAttribLPointer      :: #force_inline proc "c" (index: u32, size: i32, type_: u32, stride: i32, pointer: rawptr)              {        impl_VertexAttribLPointer(index, size, type_, stride, pointer);                           }
	GetVertexAttribLdv        :: #force_inline proc "c" (index: u32, pname: u32, params: ^f64)                                         {        impl_GetVertexAttribLdv(index, pname, params);                                            }
	ViewportArrayv            :: #force_inline proc "c" (first: u32, count: i32, v: ^f32)                                              {        impl_ViewportArrayv(first, count, v);                                                     }
	ViewportIndexedf          :: #force_inline proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32)                                   {        impl_ViewportIndexedf(index, x, y, w, h);                                                 }
	ViewportIndexedfv         :: #force_inline proc "c" (index: u32, v: ^f32)                                                          {        impl_ViewportIndexedfv(index, v);                                                         }
	ScissorArrayv             :: #force_inline proc "c" (first: u32, count: i32, v: ^i32)                                              {        impl_ScissorArrayv(first, count, v);                                                      }
	ScissorIndexed            :: #force_inline proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32)                  {        impl_ScissorIndexed(index, left, bottom, width, height);                                  }
	ScissorIndexedv           :: #force_inline proc "c" (index: u32, v: ^i32)                                                          {        impl_ScissorIndexedv(index, v);                                                           }
	DepthRangeArrayv          :: #force_inline proc "c" (first: u32, count: i32, v: ^f64)                                              {        impl_DepthRangeArrayv(first, count, v);                                                   }
	DepthRangeIndexed         :: #force_inline proc "c" (index: u32, n: f64, f: f64)                                                   {        impl_DepthRangeIndexed(index, n, f);                                                      }
	GetFloati_v               :: #force_inline proc "c" (target: u32, index: u32, data: ^f32)                                          {        impl_GetFloati_v(target, index, data);                                                    }
	GetDoublei_v              :: #force_inline proc "c" (target: u32, index: u32, data: ^f64)                                          {        impl_GetDoublei_v(target, index, data);                                                   }

	// VERSION_4_2
	DrawArraysInstancedBaseInstance             :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, baseinstance: u32)                                   { impl_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);                                  }
	DrawElementsInstancedBaseInstance           :: #force_inline proc "c" (mode: u32, count: i32, type_: u32, indices: rawptr, instancecount: i32, baseinstance: u32)                  { impl_DrawElementsInstancedBaseInstance(mode, count, type_, indices, instancecount, baseinstance);                       }
	DrawElementsInstancedBaseVertexBaseInstance :: #force_inline proc "c" (mode: u32, count: i32, type_: u32, indices: rawptr, instancecount: i32, basevertex: i32, baseinstance: u32) { impl_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type_, indices, instancecount, basevertex, baseinstance); }
	GetInternalformativ                         :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: ^i32)                                   { impl_GetInternalformativ(target, internalformat, pname, bufSize, params);                                               }
	GetActiveAtomicCounterBufferiv              :: #force_inline proc "c" (program: u32, bufferIndex: u32, pname: u32, params: ^i32)                                                   { impl_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);                                               }
	BindImageTexture                            :: #force_inline proc "c" (unit: u32, texture: u32, level: i32, layered: u8, layer: i32, access: u32, format: u32)                     { impl_BindImageTexture(unit, texture, level, layered, layer, access, format);                                            }
	MemoryBarrier                               :: #force_inline proc "c" (barriers: u32)                                                                                              { impl_MemoryBarrier(barriers);                                                                                           }
	TexStorage1D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32)                                                  { impl_TexStorage1D(target, levels, internalformat, width);                                                               }
	TexStorage2D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32)                                     { impl_TexStorage2D(target, levels, internalformat, width, height);                                                       }
	TexStorage3D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32)                         { impl_TexStorage3D(target, levels, internalformat, width, height, depth);                                                }
	DrawTransformFeedbackInstanced              :: #force_inline proc "c" (mode: u32, id: u32, instancecount: i32)                                                                     { impl_DrawTransformFeedbackInstanced(mode, id, instancecount);                                                           }
	DrawTransformFeedbackStreamInstanced        :: #force_inline proc "c" (mode: u32, id: u32, stream: u32, instancecount: i32)                                                        { impl_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);                                             }

	// VERSION_4_3
	ClearBufferData                 :: #force_inline proc "c" (target: u32, internalformat: u32, format: u32, type_: u32, data: rawptr)                                                                                                                                  {        impl_ClearBufferData(target, internalformat, format, type_, data);                                                                                                }
	ClearBufferSubData              :: #force_inline proc "c" (target: u32, internalformat: u32, offset: int, size: int, format: u32, type_: u32, data: rawptr)                                                                                                          {        impl_ClearBufferSubData(target, internalformat, offset, size, format, type_, data);                                                                               }
	DispatchCompute                 :: #force_inline proc "c" (num_groups_x: u32, num_groups_y: u32, num_groups_z: u32)                                                                                                                                                  {        impl_DispatchCompute(num_groups_x, num_groups_y, num_groups_z);                                                                                                   }
	DispatchComputeIndirect         :: #force_inline proc "c" (indirect: int)                                                                                                                                                                                            {        impl_DispatchComputeIndirect(indirect);                                                                                                                           }
	CopyImageSubData                :: #force_inline proc "c" (srcName: u32, srcTarget: u32, srcLevel: i32, srcX: i32, srcY: i32, srcZ: i32, dstName: u32, dstTarget: u32, dstLevel: i32, dstX: i32, dstY: i32, dstZ: i32, srcWidth: i32, srcHeight: i32, srcDepth: i32) {        impl_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);             }
	FramebufferParameteri           :: #force_inline proc "c" (target: u32, pname: u32, param: i32)                                                                                                                                                                      {        impl_FramebufferParameteri(target, pname, param);                                                                                                                 }
	GetFramebufferParameteriv       :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32)                                                                                                                                                                    {        impl_GetFramebufferParameteriv(target, pname, params);                                                                                                            }
	GetInternalformati64v           :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: ^i64)                                                                                                                                 {        impl_GetInternalformati64v(target, internalformat, pname, bufSize, params);                                                                                       }
	InvalidateTexSubImage           :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32)                                                                                                  {        impl_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);                                                                      }
	InvalidateTexImage              :: #force_inline proc "c" (texture: u32, level: i32)                                                                                                                                                                                 {        impl_InvalidateTexImage(texture, level);                                                                                                                          }
	InvalidateBufferSubData         :: #force_inline proc "c" (buffer: u32, offset: int, length: int)                                                                                                                                                                    {        impl_InvalidateBufferSubData(buffer, offset, length);                                                                                                             }
	InvalidateBufferData            :: #force_inline proc "c" (buffer: u32)                                                                                                                                                                                              {        impl_InvalidateBufferData(buffer);                                                                                                                                }
	InvalidateFramebuffer           :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: ^u32)                                                                                                                                                      {        impl_InvalidateFramebuffer(target, numAttachments, attachments);                                                                                                  }
	InvalidateSubFramebuffer        :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: ^u32, x: i32, y: i32, width: i32, height: i32)                                                                                                             {        impl_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);                                                                          }
	MultiDrawArraysIndirect         :: #force_inline proc "c" (mode: u32, indirect: rawptr, drawcount: i32, stride: i32)                                                                                                                                                 {        impl_MultiDrawArraysIndirect(mode, indirect, drawcount, stride);                                                                                                  }
	MultiDrawElementsIndirect       :: #force_inline proc "c" (mode: u32, type_: u32, indirect: rawptr, drawcount: i32, stride: i32)                                                                                                                                     {        impl_MultiDrawElementsIndirect(mode, type_, indirect, drawcount, stride);                                                                                         }
	GetProgramInterfaceiv           :: #force_inline proc "c" (program: u32, programInterface: u32, pname: u32, params: ^i32)                                                                                                                                            {        impl_GetProgramInterfaceiv(program, programInterface, pname, params);                                                                                             }
	GetProgramResourceIndex         :: #force_inline proc "c" (program: u32, programInterface: u32, name: ^u8) -> u32                                                                                                                                                    { ret := impl_GetProgramResourceIndex(program, programInterface, name) ;                                                                                       return ret; }
	GetProgramResourceName          :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, bufSize: i32, length: ^i32, name: ^u8)                                                                                                                   {        impl_GetProgramResourceName(program, programInterface, index, bufSize, length, name);                                                                             }
	GetProgramResourceiv            :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, propCount: i32, props: ^u32, bufSize: i32, length: ^i32, params: ^i32)                                                                                   {        impl_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);                                                           }
	GetProgramResourceLocation      :: #force_inline proc "c" (program: u32, programInterface: u32, name: ^u8) -> i32                                                                                                                                                    { ret := impl_GetProgramResourceLocation(program, programInterface, name);                                                                                     return ret; }
	GetProgramResourceLocationIndex :: #force_inline proc "c" (program: u32, programInterface: u32, name: ^u8) -> i32                                                                                                                                                    { ret := impl_GetProgramResourceLocationIndex(program, programInterface, name);                                                                                return ret; }
	ShaderStorageBlockBinding       :: #force_inline proc "c" (program: u32, storageBlockIndex: u32, storageBlockBinding: u32)                                                                                                                                           {        impl_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);                                                                                  }
	TexBufferRange                  :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32, offset: int, size: int)                                                                                                                                    {        impl_TexBufferRange(target, internalformat, buffer, offset, size);                                                                                                }
	TexStorage2DMultisample         :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8)                                                                                                        {        impl_TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);                                                               }
	TexStorage3DMultisample         :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8)                                                                                            {        impl_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);                                                        }
	TextureView                     :: #force_inline proc "c" (texture: u32, target: u32, origtexture: u32, internalformat: u32, minlevel: u32, numlevels: u32, minlayer: u32, numlayers: u32)                                                                           {        impl_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);                                                         }
	BindVertexBuffer                :: #force_inline proc "c" (bindingindex: u32, buffer: u32, offset: int, stride: i32)                                                                                                                                                 {        impl_BindVertexBuffer(bindingindex, buffer, offset, stride);                                                                                                      }
	VertexAttribFormat              :: #force_inline proc "c" (attribindex: u32, size: i32, type_: u32, normalized: u8, relativeoffset: u32)                                                                                                                             {        impl_VertexAttribFormat(attribindex, size, type_, normalized, relativeoffset);                                                                                    }
	VertexAttribIFormat             :: #force_inline proc "c" (attribindex: u32, size: i32, type_: u32, relativeoffset: u32)                                                                                                                                             {        impl_VertexAttribIFormat(attribindex, size, type_, relativeoffset);                                                                                               }
	VertexAttribLFormat             :: #force_inline proc "c" (attribindex: u32, size: i32, type_: u32, relativeoffset: u32)                                                                                                                                             {        impl_VertexAttribLFormat(attribindex, size, type_, relativeoffset);                                                                                               }
	VertexAttribBinding             :: #force_inline proc "c" (attribindex: u32, bindingindex: u32)                                                                                                                                                                      {        impl_VertexAttribBinding(attribindex, bindingindex);                                                                                                              }
	VertexBindingDivisor            :: #force_inline proc "c" (bindingindex: u32, divisor: u32)                                                                                                                                                                          {        impl_VertexBindingDivisor(bindingindex, divisor);                                                                                                                 }
	DebugMessageControl             :: #force_inline proc "c" (source: u32, type_: u32, severity: u32, count: i32, ids: ^u32, enabled: u8)                                                                                                                               {        impl_DebugMessageControl(source, type_, severity, count, ids, enabled);                                                                                           }
	DebugMessageInsert              :: #force_inline proc "c" (source: u32, type_: u32, id: u32, severity: u32, length: i32, buf: ^u8)                                                                                                                                   {        impl_DebugMessageInsert(source, type_, id, severity, length, buf);                                                                                                }
	DebugMessageCallback            :: #force_inline proc "c" (callback: debug_proc_t, userParam: rawptr)                                                                                                                                                                {        impl_DebugMessageCallback(callback, userParam);                                                                                                                   }
	GetDebugMessageLog              :: #force_inline proc "c" (count: u32, bufSize: i32, sources: ^u32, types: ^u32, ids: ^u32, severities: ^u32, lengths: ^i32, messageLog: ^u8) -> u32                                                                                 { ret := impl_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                        return ret; }
	PushDebugGroup                  :: #force_inline proc "c" (source: u32, id: u32, length: i32, message: cstring)                                                                                                                                                          {        impl_PushDebugGroup(source, id, length, message);                                                                                                                 }
	PopDebugGroup                   :: #force_inline proc "c" ()                                                                                                                                                                                                         {        impl_PopDebugGroup();                                                                                                                                             }
	ObjectLabel                     :: #force_inline proc "c" (identifier: u32, name: u32, length: i32, label: ^u8)                                                                                                                                                      {        impl_ObjectLabel(identifier, name, length, label);                                                                                                                }
	GetObjectLabel                  :: #force_inline proc "c" (identifier: u32, name: u32, bufSize: i32, length: ^i32, label: ^u8)                                                                                                                                       {        impl_GetObjectLabel(identifier, name, bufSize, length, label);                                                                                                    }
	ObjectPtrLabel                  :: #force_inline proc "c" (ptr: rawptr, length: i32, label: ^u8)                                                                                                                                                                     {        impl_ObjectPtrLabel(ptr, length, label);                                                                                                                          }
	GetObjectPtrLabel               :: #force_inline proc "c" (ptr: rawptr, bufSize: i32, length: ^i32, label: ^u8)                                                                                                                                                      {        impl_GetObjectPtrLabel(ptr, bufSize, length, label);                                                                                                              }

	// VERSION_4_4
	BufferStorage     :: #force_inline proc "c" (target: u32, size: int, data: rawptr, flags: u32)                                                                                               { impl_BufferStorage(target, size, data, flags);                                                               }
	ClearTexImage     :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type_: u32, data: rawptr)                                                                                { impl_ClearTexImage(texture, level, format, type_, data);                                                     }
	ClearTexSubImage  :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type_: u32, data: rawptr) { impl_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, data); }
	BindBuffersBase   :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: ^u32)                                                                                             { impl_BindBuffersBase(target, first, count, buffers);                                                         }
	BindBuffersRange  :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: ^u32, offsets: ^int, sizes: ^int)                                                                 { impl_BindBuffersRange(target, first, count, buffers, offsets, sizes);                                        }
	BindTextures      :: #force_inline proc "c" (first: u32, count: i32, textures: ^u32)                                                                                                         { impl_BindTextures(first, count, textures);                                                                   }
	BindSamplers      :: #force_inline proc "c" (first: u32, count: i32, samplers: ^u32)                                                                                                         { impl_BindSamplers(first, count, samplers);                                                                   }
	BindImageTextures :: #force_inline proc "c" (first: u32, count: i32, textures: ^u32)                                                                                                         { impl_BindImageTextures(first, count, textures);                                                              }
	BindVertexBuffers :: #force_inline proc "c" (first: u32, count: i32, buffers: ^u32, offsets: ^int, strides: ^i32)                                                                            { impl_BindVertexBuffers(first, count, buffers, offsets, strides);                                             }

	// VERSION_4_5
	ClipControl                              :: #force_inline proc "c" (origin: u32, depth: u32)                                                                                                                                            {        impl_ClipControl(origin, depth);                                                                                                               }
	CreateTransformFeedbacks                 :: #force_inline proc "c" (n: i32, ids: ^u32)                                                                                                                                                  {        impl_CreateTransformFeedbacks(n, ids);                                                                                                         }
	TransformFeedbackBufferBase              :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32)                                                                                                                                  {        impl_TransformFeedbackBufferBase(xfb, index, buffer);                                                                                          }
	TransformFeedbackBufferRange             :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32, offset: int, size: int)                                                                                                          {        impl_TransformFeedbackBufferRange(xfb, index, buffer, offset, size);                                                                           }
	GetTransformFeedbackiv                   :: #force_inline proc "c" (xfb: u32, pname: u32, param: ^i32)                                                                                                                                  {        impl_GetTransformFeedbackiv(xfb, pname, param);                                                                                                }
	GetTransformFeedbacki_v                  :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i32)                                                                                                                      {        impl_GetTransformFeedbacki_v(xfb, pname, index, param);                                                                                        }
	GetTransformFeedbacki64_v                :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i64)                                                                                                                      {        impl_GetTransformFeedbacki64_v(xfb, pname, index, param);                                                                                      }
	CreateBuffers                            :: #force_inline proc "c" (n: i32, buffers: ^u32)                                                                                                                                              {        impl_CreateBuffers(n, buffers);                                                                                                                }
	NamedBufferStorage                       :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, flags: u32)                                                                                                                   {        impl_NamedBufferStorage(buffer, size, data, flags);                                                                                            }
	NamedBufferData                          :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, usage: u32)                                                                                                                   {        impl_NamedBufferData(buffer, size, data, usage);                                                                                               }
	NamedBufferSubData                       :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr)                                                                                                                  {        impl_NamedBufferSubData(buffer, offset, size, data);                                                                                           }
	CopyNamedBufferSubData                   :: #force_inline proc "c" (readBuffer: u32, writeBuffer: u32, readOffset: int, writeOffset: int, size: int)                                                                                    {        impl_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);                                                           }
	ClearNamedBufferData                     :: #force_inline proc "c" (buffer: u32, internalformat: u32, format: u32, type_: u32, data: rawptr)                                                                                            {        impl_ClearNamedBufferData(buffer, internalformat, format, type_, data);                                                                        }
	ClearNamedBufferSubData                  :: #force_inline proc "c" (buffer: u32, internalformat: u32, offset: int, size: int, format: u32, type_: u32, data: rawptr)                                                                    {        impl_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type_, data);                                                       }
	MapNamedBuffer                           :: #force_inline proc "c" (buffer: u32, access: u32) -> rawptr                                                                                                                                 { ret := impl_MapNamedBuffer(buffer, access);                                                                                               return ret; }
	MapNamedBufferRange                      :: #force_inline proc "c" (buffer: u32, offset: int, length: int, access: u32) -> rawptr                                                                                                       { ret := impl_MapNamedBufferRange(buffer, offset, length, access);                                                                          return ret; }
	UnmapNamedBuffer                         :: #force_inline proc "c" (buffer: u32) -> u8                                                                                                                                                  { ret := impl_UnmapNamedBuffer(buffer);                                                                                                     return ret; }
	FlushMappedNamedBufferRange              :: #force_inline proc "c" (buffer: u32, offset: int, length: int)                                                                                                                              {        impl_FlushMappedNamedBufferRange(buffer, offset, length);                                                                                      }
	GetNamedBufferParameteriv                :: #force_inline proc "c" (buffer: u32, pname: u32, params: ^i32)                                                                                                                              {        impl_GetNamedBufferParameteriv(buffer, pname, params);                                                                                         }
	GetNamedBufferParameteri64v              :: #force_inline proc "c" (buffer: u32, pname: u32, params: ^i64)                                                                                                                              {        impl_GetNamedBufferParameteri64v(buffer, pname, params);                                                                                       }
	GetNamedBufferPointerv                   :: #force_inline proc "c" (buffer: u32, pname: u32, params: ^rawptr)                                                                                                                           {        impl_GetNamedBufferPointerv(buffer, pname, params);                                                                                            }
	GetNamedBufferSubData                    :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr)                                                                                                                  {        impl_GetNamedBufferSubData(buffer, offset, size, data);                                                                                        }
	CreateFramebuffers                       :: #force_inline proc "c" (n: i32, framebuffers: ^u32)                                                                                                                                         {        impl_CreateFramebuffers(n, framebuffers);                                                                                                      }
	NamedFramebufferRenderbuffer             :: #force_inline proc "c" (framebuffer: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32)                                                                                      {        impl_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);                                                  }
	NamedFramebufferParameteri               :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: i32)                                                                                                                           {        impl_NamedFramebufferParameteri(framebuffer, pname, param);                                                                                    }
	NamedFramebufferTexture                  :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32)                                                                                                        {        impl_NamedFramebufferTexture(framebuffer, attachment, texture, level);                                                                         }
	NamedFramebufferTextureLayer             :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, layer: i32)                                                                                            {        impl_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);                                                             }
	NamedFramebufferDrawBuffer               :: #force_inline proc "c" (framebuffer: u32, buf: u32)                                                                                                                                         {        impl_NamedFramebufferDrawBuffer(framebuffer, buf);                                                                                             }
	NamedFramebufferDrawBuffers              :: #force_inline proc "c" (framebuffer: u32, n: i32, bufs: ^u32)                                                                                                                               {        impl_NamedFramebufferDrawBuffers(framebuffer, n, bufs);                                                                                        }
	NamedFramebufferReadBuffer               :: #force_inline proc "c" (framebuffer: u32, src: u32)                                                                                                                                         {        impl_NamedFramebufferReadBuffer(framebuffer, src);                                                                                             }
	InvalidateNamedFramebufferData           :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: ^u32)                                                                                                           {        impl_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);                                                                 }
	InvalidateNamedFramebufferSubData        :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: ^u32, x: i32, y: i32, width: i32, height: i32)                                                                  {        impl_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);                                         }
	ClearNamedFramebufferiv                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^i32)                                                                                                        {        impl_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);                                                                          }
	ClearNamedFramebufferuiv                 :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^u32)                                                                                                        {        impl_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);                                                                         }
	ClearNamedFramebufferfv                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^f32)                                                                                                        {        impl_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);                                                                          }
	ClearNamedFramebufferfi                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, depth: f32, stencil: i32)                                                                                           {        impl_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);                                                                 }
	BlitNamedFramebuffer                     :: #force_inline proc "c" (readFramebuffer: u32, drawFramebuffer: u32, srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32) {        impl_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);             }
	CheckNamedFramebufferStatus              :: #force_inline proc "c" (framebuffer: u32, target: u32) -> u32                                                                                                                               { ret := impl_CheckNamedFramebufferStatus(framebuffer, target);                                                                             return ret; }
	GetNamedFramebufferParameteriv           :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: ^i32)                                                                                                                          {        impl_GetNamedFramebufferParameteriv(framebuffer, pname, param);                                                                                }
	GetNamedFramebufferAttachmentParameteriv :: #force_inline proc "c" (framebuffer: u32, attachment: u32, pname: u32, params: ^i32)                                                                                                        {        impl_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);                                                         }
	CreateRenderbuffers                      :: #force_inline proc "c" (n: i32, renderbuffers: ^u32)                                                                                                                                        {        impl_CreateRenderbuffers(n, renderbuffers);                                                                                                    }
	NamedRenderbufferStorage                 :: #force_inline proc "c" (renderbuffer: u32, internalformat: u32, width: i32, height: i32)                                                                                                    {        impl_NamedRenderbufferStorage(renderbuffer, internalformat, width, height);                                                                    }
	NamedRenderbufferStorageMultisample      :: #force_inline proc "c" (renderbuffer: u32, samples: i32, internalformat: u32, width: i32, height: i32)                                                                                      {        impl_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);                                                }
	GetNamedRenderbufferParameteriv          :: #force_inline proc "c" (renderbuffer: u32, pname: u32, params: ^i32)                                                                                                                        {        impl_GetNamedRenderbufferParameteriv(renderbuffer, pname, params);                                                                             }
	CreateTextures                           :: #force_inline proc "c" (target: u32, n: i32, textures: ^u32)                                                                                                                                {        impl_CreateTextures(target, n, textures);                                                                                                      }
	TextureBuffer                            :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32)                                                                                                                     {        impl_TextureBuffer(texture, internalformat, buffer);                                                                                           }
	TextureBufferRange                       :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32, offset: int, size: int)                                                                                             {        impl_TextureBufferRange(texture, internalformat, buffer, offset, size);                                                                        }
	TextureStorage1D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32)                                                                                                         {        impl_TextureStorage1D(texture, levels, internalformat, width);                                                                                 }
	TextureStorage2D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32)                                                                                            {        impl_TextureStorage2D(texture, levels, internalformat, width, height);                                                                         }
	TextureStorage3D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32)                                                                                {        impl_TextureStorage3D(texture, levels, internalformat, width, height, depth);                                                                  }
	TextureStorage2DMultisample              :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8)                                                                 {        impl_TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);                                       }
	TextureStorage3DMultisample              :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8)                                                     {        impl_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);                                }
	TextureSubImage1D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, type_: u32, pixels: rawptr)                                                                        {        impl_TextureSubImage1D(texture, level, xoffset, width, format, type_, pixels);                                                                 }
	TextureSubImage2D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type_: u32, pixels: rawptr)                                             {        impl_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type_, pixels);                                                }
	TextureSubImage3D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type_: u32, pixels: rawptr)                   {        impl_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, pixels);                                }
	CompressedTextureSubImage1D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr)                                                                      {        impl_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);                                                     }
	CompressedTextureSubImage2D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr)                                           {        impl_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);                                    }
	CompressedTextureSubImage3D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr)                 {        impl_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);                    }
	CopyTextureSubImage1D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32)                                                                                                 {        impl_CopyTextureSubImage1D(texture, level, xoffset, x, y, width);                                                                              }
	CopyTextureSubImage2D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32)                                                                      {        impl_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);                                                             }
	CopyTextureSubImage3D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32)                                                        {        impl_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);                                                    }
	TextureParameterf                        :: #force_inline proc "c" (texture: u32, pname: u32, param: f32)                                                                                                                               {        impl_TextureParameterf(texture, pname, param);                                                                                                 }
	TextureParameterfv                       :: #force_inline proc "c" (texture: u32, pname: u32, param: ^f32)                                                                                                                              {        impl_TextureParameterfv(texture, pname, param);                                                                                                }
	TextureParameteri                        :: #force_inline proc "c" (texture: u32, pname: u32, param: i32)                                                                                                                               {        impl_TextureParameteri(texture, pname, param);                                                                                                 }
	TextureParameterIiv                      :: #force_inline proc "c" (texture: u32, pname: u32, params: ^i32)                                                                                                                             {        impl_TextureParameterIiv(texture, pname, params);                                                                                              }
	TextureParameterIuiv                     :: #force_inline proc "c" (texture: u32, pname: u32, params: ^u32)                                                                                                                             {        impl_TextureParameterIuiv(texture, pname, params);                                                                                             }
	TextureParameteriv                       :: #force_inline proc "c" (texture: u32, pname: u32, param: ^i32)                                                                                                                              {        impl_TextureParameteriv(texture, pname, param);                                                                                                }
	GenerateTextureMipmap                    :: #force_inline proc "c" (texture: u32)                                                                                                                                                       {        impl_GenerateTextureMipmap(texture);                                                                                                           }
	BindTextureUnit                          :: #force_inline proc "c" (unit: u32, texture: u32)                                                                                                                                            {        impl_BindTextureUnit(unit, texture);                                                                                                           }
	GetTextureImage                          :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type_: u32, bufSize: i32, pixels: rawptr)                                                                                    {        impl_GetTextureImage(texture, level, format, type_, bufSize, pixels);                                                                          }
	GetCompressedTextureImage                :: #force_inline proc "c" (texture: u32, level: i32, bufSize: i32, pixels: rawptr)                                                                                                             {        impl_GetCompressedTextureImage(texture, level, bufSize, pixels);                                                                               }
	GetTextureLevelParameterfv               :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: ^f32)                                                                                                                 {        impl_GetTextureLevelParameterfv(texture, level, pname, params);                                                                                }
	GetTextureLevelParameteriv               :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: ^i32)                                                                                                                 {        impl_GetTextureLevelParameteriv(texture, level, pname, params);                                                                                }
	GetTextureParameterfv                    :: #force_inline proc "c" (texture: u32, pname: u32, params: ^f32)                                                                                                                             {        impl_GetTextureParameterfv(texture, pname, params);                                                                                            }
	GetTextureParameterIiv                   :: #force_inline proc "c" (texture: u32, pname: u32, params: ^i32)                                                                                                                             {        impl_GetTextureParameterIiv(texture, pname, params);                                                                                           }
	GetTextureParameterIuiv                  :: #force_inline proc "c" (texture: u32, pname: u32, params: ^u32)                                                                                                                             {        impl_GetTextureParameterIuiv(texture, pname, params);                                                                                          }
	GetTextureParameteriv                    :: #force_inline proc "c" (texture: u32, pname: u32, params: ^i32)                                                                                                                             {        impl_GetTextureParameteriv(texture, pname, params);                                                                                            }
	CreateVertexArrays                       :: #force_inline proc "c" (n: i32, arrays: ^u32)                                                                                                                                               {        impl_CreateVertexArrays(n, arrays);                                                                                                            }
	DisableVertexArrayAttrib                 :: #force_inline proc "c" (vaobj: u32, index: u32)                                                                                                                                             {        impl_DisableVertexArrayAttrib(vaobj, index);                                                                                                   }
	EnableVertexArrayAttrib                  :: #force_inline proc "c" (vaobj: u32, index: u32)                                                                                                                                             {        impl_EnableVertexArrayAttrib(vaobj, index);                                                                                                    }
	VertexArrayElementBuffer                 :: #force_inline proc "c" (vaobj: u32, buffer: u32)                                                                                                                                            {        impl_VertexArrayElementBuffer(vaobj, buffer);                                                                                                  }
	VertexArrayVertexBuffer                  :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, buffer: u32, offset: int, stride: i32)                                                                                               {        impl_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);                                                                     }
	VertexArrayVertexBuffers                 :: #force_inline proc "c" (vaobj: u32, first: u32, count: i32, buffers: ^u32, offsets: ^int, strides: ^i32)                                                                                    {        impl_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);                                                                 }
	VertexArrayAttribBinding                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, bindingindex: u32)                                                                                                                    {        impl_VertexArrayAttribBinding(vaobj, attribindex, bindingindex);                                                                               }
	VertexArrayAttribFormat                  :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type_: u32, normalized: u8, relativeoffset: u32)                                                                           {        impl_VertexArrayAttribFormat(vaobj, attribindex, size, type_, normalized, relativeoffset);                                                     }
	VertexArrayAttribIFormat                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type_: u32, relativeoffset: u32)                                                                                           {        impl_VertexArrayAttribIFormat(vaobj, attribindex, size, type_, relativeoffset);                                                                }
	VertexArrayAttribLFormat                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type_: u32, relativeoffset: u32)                                                                                           {        impl_VertexArrayAttribLFormat(vaobj, attribindex, size, type_, relativeoffset);                                                                }
	VertexArrayBindingDivisor                :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, divisor: u32)                                                                                                                        {        impl_VertexArrayBindingDivisor(vaobj, bindingindex, divisor);                                                                                  }
	GetVertexArrayiv                         :: #force_inline proc "c" (vaobj: u32, pname: u32, param: ^i32)                                                                                                                                {        impl_GetVertexArrayiv(vaobj, pname, param);                                                                                                    }
	GetVertexArrayIndexediv                  :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i32)                                                                                                                    {        impl_GetVertexArrayIndexediv(vaobj, index, pname, param);                                                                                      }
	GetVertexArrayIndexed64iv                :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i64)                                                                                                                    {        impl_GetVertexArrayIndexed64iv(vaobj, index, pname, param);                                                                                    }
	CreateSamplers                           :: #force_inline proc "c" (n: i32, samplers: ^u32)                                                                                                                                             {        impl_CreateSamplers(n, samplers);                                                                                                              }
	CreateProgramPipelines                   :: #force_inline proc "c" (n: i32, pipelines: ^u32)                                                                                                                                            {        impl_CreateProgramPipelines(n, pipelines);                                                                                                     }
	CreateQueries                            :: #force_inline proc "c" (target: u32, n: i32, ids: ^u32)                                                                                                                                     {        impl_CreateQueries(target, n, ids);                                                                                                            }
	GetQueryBufferObjecti64v                 :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjecti64v(id, buffer, pname, offset);                                                                                      }
	GetQueryBufferObjectiv                   :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectiv(id, buffer, pname, offset);                                                                                        }
	GetQueryBufferObjectui64v                :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectui64v(id, buffer, pname, offset);                                                                                     }
	GetQueryBufferObjectuiv                  :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int)                                                                                                                      {        impl_GetQueryBufferObjectuiv(id, buffer, pname, offset);                                                                                       }
	MemoryBarrierByRegion                    :: #force_inline proc "c" (barriers: u32)                                                                                                                                                      {        impl_MemoryBarrierByRegion(barriers);                                                                                                          }
	GetTextureSubImage                       :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type_: u32, bufSize: i32, pixels: rawptr)     {        impl_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, bufSize, pixels);                      }
	GetCompressedTextureSubImage             :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, bufSize: i32, pixels: rawptr)                              {        impl_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);                           }
	GetGraphicsResetStatus                   :: #force_inline proc "c" () -> u32                                                                                                                                                            { ret := impl_GetGraphicsResetStatus();                                                                                                     return ret; }
	GetnCompressedTexImage                   :: #force_inline proc "c" (target: u32, lod: i32, bufSize: i32, pixels: rawptr)                                                                                                                {        impl_GetnCompressedTexImage(target, lod, bufSize, pixels);                                                                                     }
	GetnTexImage                             :: #force_inline proc "c" (target: u32, level: i32, format: u32, type_: u32, bufSize: i32, pixels: rawptr)                                                                                     {        impl_GetnTexImage(target, level, format, type_, bufSize, pixels);                                                                              }
	GetnUniformdv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: ^f64)                                                                                                            {        impl_GetnUniformdv(program, location, bufSize, params);                                                                                        }
	GetnUniformfv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: ^f32)                                                                                                            {        impl_GetnUniformfv(program, location, bufSize, params);                                                                                        }
	GetnUniformiv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: ^i32)                                                                                                            {        impl_GetnUniformiv(program, location, bufSize, params);                                                                                        }
	GetnUniformuiv                           :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: ^u32)                                                                                                            {        impl_GetnUniformuiv(program, location, bufSize, params);                                                                                       }
	ReadnPixels                              :: #force_inline proc "c" (x: i32, y: i32, width: i32, height: i32, format: u32, type_: u32, bufSize: i32, data: rawptr)                                                                       {        impl_ReadnPixels(x, y, width, height, format, type_, bufSize, data);                                                                           }
	GetnMapdv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^f64)                                                                                                                     {        impl_GetnMapdv(target, query, bufSize, v);                                                                                                     }
	GetnMapfv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^f32)                                                                                                                     {        impl_GetnMapfv(target, query, bufSize, v);                                                                                                     }
	GetnMapiv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^i32)                                                                                                                     {        impl_GetnMapiv(target, query, bufSize, v);                                                                                                     }
	GetnPixelMapusv                          :: #force_inline proc "c" (map_: u32, bufSize: i32, values: ^u16)                                                                                                                              {        impl_GetnPixelMapusv(map_, bufSize, values);                                                                                                   }
	GetnPixelMapfv                           :: #force_inline proc "c" (map_: u32, bufSize: i32, values: ^f32)                                                                                                                              {        impl_GetnPixelMapfv(map_, bufSize, values);                                                                                                    }
	GetnPixelMapuiv                          :: #force_inline proc "c" (map_: u32, bufSize: i32, values: ^u32)                                                                                                                              {        impl_GetnPixelMapuiv(map_, bufSize, values);                                                                                                   }
	GetnPolygonStipple                       :: #force_inline proc "c" (bufSize: i32, pattern: ^u8)                                                                                                                                         {        impl_GetnPolygonStipple(bufSize, pattern);                                                                                                     }
	GetnColorTable                           :: #force_inline proc "c" (target: u32, format: u32, type_: u32, bufSize: i32, table: rawptr)                                                                                                  {        impl_GetnColorTable(target, format, type_, bufSize, table);                                                                                    }
	GetnConvolutionFilter                    :: #force_inline proc "c" (target: u32, format: u32, type_: u32, bufSize: i32, image: rawptr)                                                                                                  {        impl_GetnConvolutionFilter(target, format, type_, bufSize, image);                                                                             }
	GetnSeparableFilter                      :: #force_inline proc "c" (target: u32, format: u32, type_: u32, rowBufSize: i32, row: rawptr, columnBufSize: i32, column: rawptr, span: rawptr)                                               {        impl_GetnSeparableFilter(target, format, type_, rowBufSize, row, columnBufSize, column, span);                                                 }
	GetnHistogram                            :: #force_inline proc "c" (target: u32, reset: u8, format: u32, type_: u32, bufSize: i32, values: rawptr)                                                                                      {        impl_GetnHistogram(target, reset, format, type_, bufSize, values);                                                                             }
	GetnMinmax                               :: #force_inline proc "c" (target: u32, reset: u8, format: u32, type_: u32, bufSize: i32, values: rawptr)                                                                                      {        impl_GetnMinmax(target, reset, format, type_, bufSize, values);                                                                                }
	TextureBarrier                           :: #force_inline proc "c" ()                                                                                                                                                                   {        impl_TextureBarrier();                                                                                                                         }
	GetUnsignedBytevEXT                      :: #force_inline proc "c" (pname: u32, data: ^byte)                                                                                                                                            {        impl_glGetUnsignedBytevEXT(pname, data);                                                                                                       }
	TexPageCommitmentARB                     :: #force_inline proc "c"(target: u32,
                                                        level: i32,
                                                        xoffset: i32,
                                                        yoffset: i32,
                                                        zoffset: i32,
                                                        width: i32,
                                                        height: i32,
                                                        depth: i32,
                                                        commit: b8) {impl_TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit); }

	// VERSION_4_6
	SpecializeShader               :: #force_inline proc "c" (shader: u32, pEntryPoint: ^u8, numSpecializationConstants: u32, pConstantIndex: ^u32, pConstantValue: ^u32) { impl_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); }
	MultiDrawArraysIndirectCount   :: #force_inline proc "c" (mode: i32, indirect: rawptr, drawcount: int, maxdrawcount, stride: i32)                                     { impl_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride);                     }
	MultiDrawElementsIndirectCount :: #force_inline proc "c" (mode: i32, type_: i32, indirect: rawptr, drawcount: int, maxdrawcount, stride: i32)                         { impl_MultiDrawElementsIndirectCount(mode, type_, indirect, drawcount, maxdrawcount, stride);            }
	PolygonOffsetClamp             :: #force_inline proc "c" (factor, units, clamp: f32)                                                                                  { impl_PolygonOffsetClamp(factor, units, clamp);                                                          }
} else {
	import "core:runtime"
	import "core:fmt"

	debug_helper :: #force_inline proc"c"(from_loc: runtime.Source_Code_Location, num_ret: int, args: ..any, loc := #caller_location) {
		context = runtime.default_context();

		Error_Enum :: enum {
			NO_ERROR = NO_ERROR,
			INVALID_VALUE = INVALID_VALUE,
			INVALID_ENUM = INVALID_ENUM,
			INVALID_OPERATION = INVALID_OPERATION,
			INVALID_FRAMEBUFFER_OPERATION = INVALID_FRAMEBUFFER_OPERATION,
			OUT_OF_MEMORY = OUT_OF_MEMORY,
			STACK_UNDERFLOW = STACK_UNDERFLOW,
			STACK_OVERFLOW = STACK_OVERFLOW,
			// TODO: What if the return enum is invalid?
		};

		// There can be multiple errors, so we're required to continuously call glGetError until there are no more errors
		for i := 0;; i += 1 {
			err := cast(Error_Enum)impl_GetError();
			if err == .NO_ERROR do break;

			fmt.printf("%d: glGetError() returned GL_%v\n", i, err);
		    
			// add function call
		    fmt.printf("   call: gl%s(", loc.procedure);
	    	
	    	{
			    // add input arguments
			    for arg, i in args[num_ret:] {
			    	if i > 0 do fmt.printf(", ");
			    	
			    	if v, ok := arg.(u32); ok { // TODO: Assumes all u32 are GLenum (they're not, GLbitfield and GLuint are also mapped to u32), fix later by better typing
			    		if err == .INVALID_ENUM {
			    			fmt.printf("INVALID_ENUM=%d", v);
		    			} else {
			    			fmt.printf("GL_%v=%d", GL_Enum(v), v);
		    			}
			    	} else {
			    		fmt.printf("%v", arg);
			    	}
			    }

			    // add return arguments
			    if num_ret == 1 {
			    	fmt.printf(") -> %v \n", args[0]);
				} else if num_ret > 1 {
			    	fmt.printf(") -> (");
					for arg, i in args[1:num_ret] {
						if i > 0 do fmt.printf(", ");
						fmt.printf("%v", arg);
					}
					fmt.printf(")\n");
				} else {
				    fmt.printf(")\n");
				}
	    	}

			// add location
		    fmt.printf("   in:   %s(%d:%d)\n", from_loc.file_path, from_loc.line, from_loc.column);
		}
	}

	CullFace               :: #force_inline proc "c" (mode: u32, loc := #caller_location)                                                                                         {        impl_CullFace(mode);                                                                         debug_helper(loc, 0, mode);                                                                                   }
	FrontFace              :: #force_inline proc "c" (mode: u32, loc := #caller_location)                                                                                         {        impl_FrontFace(mode);                                                                        debug_helper(loc, 0, mode);                                                                                   }
	Hint                   :: #force_inline proc "c" (target, mode: u32, loc := #caller_location)                                                                                 {        impl_Hint(target, mode);                                                                     debug_helper(loc, 0, target, mode);                                                                           }
	LineWidth              :: #force_inline proc "c" (width: f32, loc := #caller_location)                                                                                        {        impl_LineWidth(width);                                                                       debug_helper(loc, 0, width);                                                                                  }
	PointSize              :: #force_inline proc "c" (size: f32, loc := #caller_location)                                                                                         {        impl_PointSize(size);                                                                        debug_helper(loc, 0, size);                                                                                   }
	PolygonMode            :: #force_inline proc "c" (face, mode: u32, loc := #caller_location)                                                                                   {        impl_PolygonMode(face, mode);                                                                debug_helper(loc, 0, face, mode);                                                                             }
	Scissor                :: #force_inline proc "c" (x, y, width, height: i32, loc := #caller_location)                                                                          {        impl_Scissor(x, y, width, height);                                                           debug_helper(loc, 0, x, y, width, height);                                                                    }
	TexParameterf          :: #force_inline proc "c" (target, pname: u32, param: f32, loc := #caller_location)                                                                    {        impl_TexParameterf(target, pname, param);                                                    debug_helper(loc, 0, target, pname, param);                                                                   }
	TexParameterfv         :: #force_inline proc "c" (target, pname: u32, params: ^f32, loc := #caller_location)                                                                  {        impl_TexParameterfv(target, pname, params);                                                  debug_helper(loc, 0, target, pname, params);                                                                  }
	TexParameteri          :: #force_inline proc "c" (target, pname: u32, param: i32, loc := #caller_location)                                                                    {        impl_TexParameteri(target, pname, param);                                                    debug_helper(loc, 0, target, pname, param);                                                                   }
	TexParameteriv         :: #force_inline proc "c" (target, pname: u32, params: ^i32, loc := #caller_location)                                                                  {        impl_TexParameteriv(target, pname, params);                                                  debug_helper(loc, 0, target, pname, params);                                                                  }
	TexImage1D             :: #force_inline proc "c" (target: u32, level, internalformat, width, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location)         {        impl_TexImage1D(target, level, internalformat, width, border, format, type, pixels);         debug_helper(loc, 0, target, level, internalformat, width, border, format, type, pixels);                     }
	TexImage2D             :: #force_inline proc "c" (target: u32, level, internalformat, width, height, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location) {        impl_TexImage2D(target, level, internalformat, width, height, border, format, type, pixels); debug_helper(loc, 0, target, level, internalformat, width, height, border, format, type, pixels);             }
	DrawBuffer             :: #force_inline proc "c" (buf: u32, loc := #caller_location)                                                                                          {        impl_DrawBuffer(buf);                                                                        debug_helper(loc, 0, buf);                                                                                    }
	Clear                  :: #force_inline proc "c" (mask: u32, loc := #caller_location)                                                                                         {        impl_Clear(mask);                                                                            debug_helper(loc, 0, mask);                                                                                   }
	ClearColor             :: #force_inline proc "c" (red, green, blue, alpha: f32, loc := #caller_location)                                                                      {        impl_ClearColor(red, green, blue, alpha);                                                    debug_helper(loc, 0, red, green, blue, alpha);                                                                }
	ClearStencil           :: #force_inline proc "c" (s: i32, loc := #caller_location)                                                                                            {        impl_ClearStencil(s);                                                                        debug_helper(loc, 0, s);                                                                                      }
	ClearDepth             :: #force_inline proc "c" (depth: f64, loc := #caller_location)                                                                                        {        impl_ClearDepth(depth);                                                                      debug_helper(loc, 0, depth);                                                                                  }
	StencilMask            :: #force_inline proc "c" (mask: u32, loc := #caller_location)                                                                                         {        impl_StencilMask(mask);                                                                      debug_helper(loc, 0, mask);                                                                                   }
	ColorMask              :: #force_inline proc "c" (red, green, blue, alpha: u8, loc := #caller_location)                                                                       {        impl_ColorMask(red, green, blue, alpha);                                                     debug_helper(loc, 0, red, green, blue, alpha);                                                                }
	DepthMask              :: #force_inline proc "c" (flag: u8, loc := #caller_location)                                                                                          {        impl_DepthMask(flag);                                                                        debug_helper(loc, 0, flag);                                                                                   }
	Disable                :: #force_inline proc "c" (cap: u32, loc := #caller_location)                                                                                          {        impl_Disable(cap);                                                                           debug_helper(loc, 0, cap);                                                                                    }
	Enable                 :: #force_inline proc "c" (cap: u32, loc := #caller_location)                                                                                          {        impl_Enable(cap);                                                                            debug_helper(loc, 0, cap);                                                                                    }
	Finish                 :: #force_inline proc "c" (loc := #caller_location)                                                                                                    {        impl_Finish();                                                                               debug_helper(loc, 0);                                                                                         }
	Flush                  :: #force_inline proc "c" (loc := #caller_location)                                                                                                    {        impl_Flush();                                                                                debug_helper(loc, 0);                                                                                         }
	BlendFunc              :: #force_inline proc "c" (sfactor, dfactor: u32, loc := #caller_location)                                                                             {        impl_BlendFunc(sfactor, dfactor);                                                            debug_helper(loc, 0, sfactor, dfactor);                                                                       }
	LogicOp                :: #force_inline proc "c" (opcode: u32, loc := #caller_location)                                                                                       {        impl_LogicOp(opcode);                                                                        debug_helper(loc, 0, opcode);                                                                                 }
	StencilFunc            :: #force_inline proc "c" (func: u32, ref: i32, mask: u32, loc := #caller_location)                                                                    {        impl_StencilFunc(func, ref, mask);                                                           debug_helper(loc, 0, func, ref, mask);                                                                        }
	StencilOp              :: #force_inline proc "c" (fail, zfail, zpass: u32, loc := #caller_location)                                                                           {        impl_StencilOp(fail, zfail, zpass);                                                          debug_helper(loc, 0, fail, zfail, zpass);                                                                     }
	DepthFunc              :: #force_inline proc "c" (func: u32, loc := #caller_location)                                                                                         {        impl_DepthFunc(func);                                                                        debug_helper(loc, 0, func);                                                                                   }
	PixelStoref            :: #force_inline proc "c" (pname: u32, param: f32, loc := #caller_location)                                                                            {        impl_PixelStoref(pname, param);                                                              debug_helper(loc, 0, pname, param);                                                                           }
	PixelStorei            :: #force_inline proc "c" (pname: u32, param: i32, loc := #caller_location)                                                                            {        impl_PixelStorei(pname, param);                                                              debug_helper(loc, 0, pname, param);                                                                           }
	ReadBuffer             :: #force_inline proc "c" (src: u32, loc := #caller_location)                                                                                          {        impl_ReadBuffer(src);                                                                        debug_helper(loc, 0, src);                                                                                    }
	ReadPixels             :: #force_inline proc "c" (x, y, width, height: i32, format, type: u32, pixels: rawptr, loc := #caller_location)                                       {        impl_ReadPixels(x, y, width, height, format, type, pixels);                                  debug_helper(loc, 0, x, y, width, height, format, type, pixels);                                              }
	GetBooleanv            :: #force_inline proc "c" (pname: u32, data: ^u8, loc := #caller_location)                                                                             {        impl_GetBooleanv(pname, data);                                                               debug_helper(loc, 0, pname, data);                                                                            }
	GetDoublev             :: #force_inline proc "c" (pname: u32, data: ^f64, loc := #caller_location)                                                                            {        impl_GetDoublev(pname, data);                                                                debug_helper(loc, 0, pname, data);                                                                            }
	GetError               :: #force_inline proc "c" (loc := #caller_location) -> u32                                                                                             { ret := impl_GetError();                                                                             debug_helper(loc, 1, ret);                                                                        return ret; }
	GetFloatv              :: #force_inline proc "c" (pname: u32, data: ^f32, loc := #caller_location)                                                                            {        impl_GetFloatv(pname, data);                                                                 debug_helper(loc, 0, pname, data);                                                                            }
	GetIntegerv            :: #force_inline proc "c" (pname: u32, data: ^i32, loc := #caller_location)                                                                            {        impl_GetIntegerv(pname, data);                                                               debug_helper(loc, 0, pname, data);                                                                            }
	GetString              :: #force_inline proc "c" (name: u32, loc := #caller_location) -> cstring                                                                              { ret := impl_GetString(name);                                                                        debug_helper(loc, 1, ret, name);                                                                  return ret; }
	GetTexImage            :: #force_inline proc "c" (target: u32,  level: i32, format, type: u32, pixels: rawptr, loc := #caller_location)                                       {        impl_GetTexImage(target,  level, format, type, pixels);                                      debug_helper(loc, 0, target,  level, format, type, pixels);                                                   }
	GetTexParameterfv      :: #force_inline proc "c" (target, pname: u32, params: ^f32, loc := #caller_location)                                                                  {        impl_GetTexParameterfv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params);                                                                  }
	GetTexParameteriv      :: #force_inline proc "c" (target, pname: u32, params: ^i32, loc := #caller_location)                                                                  {        impl_GetTexParameteriv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params);                                                                  }
	GetTexLevelParameterfv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: ^f32, loc := #caller_location)                                                 {        impl_GetTexLevelParameterfv(target, level, pname, params);                                   debug_helper(loc, 0, target, level, pname, params);                                                           }
	GetTexLevelParameteriv :: #force_inline proc "c" (target: u32, level: i32, pname: u32, params: ^i32, loc := #caller_location)                                                 {        impl_GetTexLevelParameteriv(target, level, pname, params);                                   debug_helper(loc, 0, target, level, pname, params);                                                           }
	IsEnabled              :: #force_inline proc "c" (cap: u32, loc := #caller_location) -> u8                                                                                    { ret := impl_IsEnabled(cap);                                                                         debug_helper(loc, 1, ret, cap);                                                                   return ret; }
	DepthRange             :: #force_inline proc "c" (near, far: f64, loc := #caller_location)                                                                                    {        impl_DepthRange(near, far);                                                                  debug_helper(loc, 0, near, far);                                                                              }
	Viewport               :: #force_inline proc "c" (x, y, width, height: i32, loc := #caller_location)                                                                          {        impl_Viewport(x, y, width, height);                                                          debug_helper(loc, 0, x, y, width, height);                                                                    }

	// VERSION_1_1
	DrawArrays        :: #force_inline proc "c" (mode: u32, first: i32, count: i32, loc := #caller_location)                                                                                    {        impl_DrawArrays(mode, first, count);                                                      debug_helper(loc, 0, mode, first, count);                                                               }
	DrawElements      :: #force_inline proc "c" (mode: u32, count: i32, type: u32, indices: rawptr, loc := #caller_location)                                                                    {        impl_DrawElements(mode, count, type, indices);                                            debug_helper(loc, 0, mode, count, type, indices);                                                       }
	PolygonOffset     :: #force_inline proc "c" (factor: f32, units: f32, loc := #caller_location)                                                                                              {        impl_PolygonOffset(factor, units);                                                        debug_helper(loc, 0, factor, units);                                                                    }
	CopyTexImage1D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, border: i32, loc := #caller_location)                                {        impl_CopyTexImage1D(target, level, internalformat, x, y, width, border);                  debug_helper(loc, 0, target, level, internalformat, x, y, width, border);                               }
	CopyTexImage2D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, x: i32, y: i32, width: i32, height: i32, border: i32, loc := #caller_location)                   {        impl_CopyTexImage2D(target, level, internalformat, x, y, width, height, border);          debug_helper(loc, 0, target, level, internalformat, x, y, width, height, border);                       }
	CopyTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32, loc := #caller_location)                                                    {        impl_CopyTexSubImage1D(target, level, xoffset, x, y, width);                              debug_helper(loc, 0, target, level, xoffset, x, y, width);                                              }
	CopyTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                         {        impl_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);             debug_helper(loc, 0, target, level, xoffset, yoffset, x, y, width, height);                             }
	TexSubImage1D     :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location)                            {        impl_TexSubImage1D(target, level, xoffset, width, format, type, pixels);                  debug_helper(loc, 0, target, level, xoffset, width, format, type, pixels);                              }
	TexSubImage2D     :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type: u32, pixels: rawptr, loc := #caller_location) {        impl_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, yoffset, width, height, format, type, pixels);             }
	BindTexture       :: #force_inline proc "c" (target: u32, texture: u32, loc := #caller_location)                                                                                            {        impl_BindTexture(target, texture);                                                        debug_helper(loc, 0, target, texture);                                                                  }
	DeleteTextures    :: #force_inline proc "c" (n: i32, textures: ^u32, loc := #caller_location)                                                                                               {        impl_DeleteTextures(n, textures);                                                         debug_helper(loc, 0, n, textures);                                                                      }
	GenTextures       :: #force_inline proc "c" (n: i32, textures: ^u32, loc := #caller_location)                                                                                               {        impl_GenTextures(n, textures);                                                            debug_helper(loc, 0, n, textures);                                                                      }
	IsTexture         :: #force_inline proc "c" (texture: u32, loc := #caller_location) -> u8                                                                                                   { ret := impl_IsTexture(texture);                                                                  debug_helper(loc, 1, ret, texture);                                                         return ret; }

	// VERSION_1_2
	DrawRangeElements :: #force_inline proc "c" (mode, start, end: u32, count: i32, type: u32, indices: rawptr, loc := #caller_location)                                               { impl_DrawRangeElements(mode, start, end, count, type, indices);                                           debug_helper(loc, 0, mode, start, end, count, type, indices);                                               }
	TexImage3D        :: #force_inline proc "c" (target: u32, level, internalformat, width, height, depth, border: i32, format, type: u32, pixels: rawptr, loc := #caller_location)    { impl_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);       debug_helper(loc, 0, target, level, internalformat, width, height, depth, border, format, type, pixels);    }
	TexSubImage3D     :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, width, height, depth: i32, format, type: u32, pixels: rawptr, loc := #caller_location) { impl_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); }
	CopyTexSubImage3D :: #force_inline proc "c" (target: u32, level, xoffset, yoffset, zoffset, x, y, width, height: i32, loc := #caller_location)                                     { impl_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);                    debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, x, y, width, height);                        }

	// VERSION_1_3
	ActiveTexture           :: #force_inline proc "c" (texture: u32, loc := #caller_location)                                                                                                                                      { impl_ActiveTexture(texture);                                                                                           debug_helper(loc, 0, texture);                                                                                 }
	SampleCoverage          :: #force_inline proc "c" (value: f32, invert: u8, loc := #caller_location)                                                                                                                            { impl_SampleCoverage(value, invert);                                                                                    debug_helper(loc, 0, value, invert);                                                                           }
	CompressedTexImage3D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, depth: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                      { impl_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);               debug_helper(loc, 0, target, level, internalformat, width, height, depth, border, imageSize, data);            }
	CompressedTexImage2D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, height: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                                  { impl_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);                      debug_helper(loc, 0, target, level, internalformat, width, height, border, imageSize, data);                   }
	CompressedTexImage1D    :: #force_inline proc "c" (target: u32, level: i32, internalformat: u32, width: i32, border: i32, imageSize: i32, data: rawptr, loc := #caller_location)                                               { impl_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);                              debug_helper(loc, 0, target, level, internalformat, width, border, imageSize, data);                           }
	CompressedTexSubImage3D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location) { impl_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); }
	CompressedTexSubImage2D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                           { impl_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);                 debug_helper(loc, 0, target, level, xoffset, yoffset, width, height, format, imageSize, data);                 }
	CompressedTexSubImage1D :: #force_inline proc "c" (target: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                                      { impl_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);                                  debug_helper(loc, 0, target, level, xoffset, width, format, imageSize, data);                                  }
	GetCompressedTexImage   :: #force_inline proc "c" (target: u32, level: i32, img: rawptr, loc := #caller_location)                                                                                                              { impl_GetCompressedTexImage(target, level, img);                                                                        debug_helper(loc, 0, target, level, img);                                                                      }

	// VERSION_1_4
    BlendFuncSeparate :: #force_inline proc "c" (sfactorRGB: u32, dfactorRGB: u32, sfactorAlpha: u32, dfactorAlpha: u32, loc := #caller_location) { impl_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); debug_helper(loc, 0, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); }
    MultiDrawArrays   :: #force_inline proc "c" (mode: u32, first: ^i32, count: ^i32, drawcount: i32, loc := #caller_location)                    { impl_MultiDrawArrays(mode, first, count, drawcount);                        debug_helper(loc, 0, mode, first, count, drawcount);                      }
    MultiDrawElements :: #force_inline proc "c" (mode: u32, count: ^i32, type_: u32, indices: ^rawptr, drawcount: i32, loc := #caller_location)   { impl_MultiDrawElements(mode, count, type_, indices, drawcount);             debug_helper(loc, 0, mode, count, type_, indices, drawcount);             }
    PointParameterf   :: #force_inline proc "c" (pname: u32, param: f32, loc := #caller_location)                                                 { impl_PointParameterf(pname, param);                                         debug_helper(loc, 0, pname, param);                                       }
    PointParameterfv  :: #force_inline proc "c" (pname: u32, params: ^f32, loc := #caller_location)                                               { impl_PointParameterfv(pname, params);                                       debug_helper(loc, 0, pname, params);                                      }
    PointParameteri   :: #force_inline proc "c" (pname: u32, param: i32, loc := #caller_location)                                                 { impl_PointParameteri(pname, param);                                         debug_helper(loc, 0, pname, param);                                       }
    PointParameteriv  :: #force_inline proc "c" (pname: u32, params: ^i32, loc := #caller_location)                                               { impl_PointParameteriv(pname, params);                                       debug_helper(loc, 0, pname, params);                                      }
    BlendColor        :: #force_inline proc "c" (red: f32, green: f32, blue: f32, alpha: f32, loc := #caller_location)                            { impl_BlendColor(red, green, blue, alpha);                                   debug_helper(loc, 0, red, green, blue, alpha);                            }
    BlendEquation     :: #force_inline proc "c" (mode: u32, loc := #caller_location)                                                              { impl_BlendEquation(mode);                                                   debug_helper(loc, 0, mode);                                               }

    // VERSION_1_5
	GenQueries           :: #force_inline proc "c" (n: i32, ids: ^u32, loc := #caller_location)                                 {        impl_GenQueries(n, ids);                           debug_helper(loc, 0, n, ids);                                 }
	DeleteQueries        :: #force_inline proc "c" (n: i32, ids: ^u32, loc := #caller_location)                                 {        impl_DeleteQueries(n, ids);                        debug_helper(loc, 0, n, ids);                                 }
	IsQuery              :: #force_inline proc "c" (id: u32, loc := #caller_location) -> u8                                     { ret := impl_IsQuery(id);                                  debug_helper(loc, 1, ret, id);                    return ret; }
	BeginQuery           :: #force_inline proc "c" (target: u32, id: u32, loc := #caller_location)                              {        impl_BeginQuery(target, id);                       debug_helper(loc, 0, target, id);                             }
	EndQuery             :: #force_inline proc "c" (target: u32, loc := #caller_location)                                       {        impl_EndQuery(target);                             debug_helper(loc, 0, target);                                 }
	GetQueryiv           :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32, loc := #caller_location)             {        impl_GetQueryiv(target, pname, params);            debug_helper(loc, 0, target, pname, params);                  }
	GetQueryObjectiv     :: #force_inline proc "c" (id: u32, pname: u32, params: ^i32, loc := #caller_location)                 {        impl_GetQueryObjectiv(id, pname, params);          debug_helper(loc, 0, id, pname, params);                      }
	GetQueryObjectuiv    :: #force_inline proc "c" (id: u32, pname: u32, params: ^u32, loc := #caller_location)                 {        impl_GetQueryObjectuiv(id, pname, params);         debug_helper(loc, 0, id, pname, params);                      }
	BindBuffer           :: #force_inline proc "c" (target: u32, buffer: u32, loc := #caller_location)                          {        impl_BindBuffer(target, buffer);                   debug_helper(loc, 0, target, buffer);                         }
	DeleteBuffers        :: #force_inline proc "c" (n: i32, buffers: ^u32, loc := #caller_location)                             {        impl_DeleteBuffers(n, buffers);                    debug_helper(loc, 0, n, buffers);                             }
	GenBuffers           :: #force_inline proc "c" (n: i32, buffers: ^u32, loc := #caller_location)                             {        impl_GenBuffers(n, buffers);                       debug_helper(loc, 0, n, buffers);                             }
	IsBuffer             :: #force_inline proc "c" (buffer: u32, loc := #caller_location) -> u8                                 { ret := impl_IsBuffer(buffer);                             debug_helper(loc, 1, ret, buffer);                return ret; }
	BufferData           :: #force_inline proc "c" (target: u32, size: int, data: rawptr, usage: u32, loc := #caller_location)  {        impl_BufferData(target, size, data, usage);        debug_helper(loc, 0, target, size, data, usage);              }
	BufferSubData        :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr, loc := #caller_location) {        impl_BufferSubData(target, offset, size, data);    debug_helper(loc, 0, target, offset, size, data);             }
	GetBufferSubData     :: #force_inline proc "c" (target: u32, offset: int, size: int, data: rawptr, loc := #caller_location) {        impl_GetBufferSubData(target, offset, size, data); debug_helper(loc, 0, target, offset, size, data);             }
	MapBuffer            :: #force_inline proc "c" (target: u32, access: u32, loc := #caller_location) -> rawptr                { ret := impl_MapBuffer(target, access);                    debug_helper(loc, 1, ret, target, access);        return ret; }
	UnmapBuffer          :: #force_inline proc "c" (target: u32, loc := #caller_location) -> u8                                 { ret := impl_UnmapBuffer(target);                          debug_helper(loc, 1, ret, target);                return ret; }
	GetBufferParameteriv :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32, loc := #caller_location)             {        impl_GetBufferParameteriv(target, pname, params);  debug_helper(loc, 0, target, pname, params);                  }
	GetBufferPointerv    :: #force_inline proc "c" (target: u32, pname: u32, params: ^rawptr, loc := #caller_location)          {        impl_GetBufferPointerv(target, pname, params);     debug_helper(loc, 0, target, pname, params);                  }

	// VERSION_2_0
	BlendEquationSeparate    :: #force_inline proc "c" (modeRGB: u32, modeAlpha: u32, loc := #caller_location)                                                             {        impl_BlendEquationSeparate(modeRGB, modeAlpha);                            debug_helper(loc, 0, modeRGB, modeAlpha);                                             }
	DrawBuffers              :: #force_inline proc "c" (n: i32, bufs: ^u32, loc := #caller_location)                                                                       {        impl_DrawBuffers(n, bufs);                                                 debug_helper(loc, 0, n, bufs);                                                        }
	StencilOpSeparate        :: #force_inline proc "c" (face: u32, sfail: u32, dpfail: u32, dppass: u32, loc := #caller_location)                                          {        impl_StencilOpSeparate(face, sfail, dpfail, dppass);                       debug_helper(loc, 0, face, sfail, dpfail, dppass);                                    }
	StencilFuncSeparate      :: #force_inline proc "c" (face: u32, func: u32, ref: i32, mask: u32, loc := #caller_location)                                                {        impl_StencilFuncSeparate(face, func, ref, mask);                           debug_helper(loc, 0, face, func, ref, mask);                                          }
	StencilMaskSeparate      :: #force_inline proc "c" (face: u32, mask: u32, loc := #caller_location)                                                                     {        impl_StencilMaskSeparate(face, mask);                                      debug_helper(loc, 0, face, mask);                                                     }
	AttachShader             :: #force_inline proc "c" (program: u32, shader: u32, loc := #caller_location)                                                                {        impl_AttachShader(program, shader);                                        debug_helper(loc, 0, program, shader);                                                }
	BindAttribLocation       :: #force_inline proc "c" (program: u32, index: u32, name: ^u8, loc := #caller_location)                                                      {        impl_BindAttribLocation(program, index, name);                             debug_helper(loc, 0, program, index, name);                                           }
	CompileShader            :: #force_inline proc "c" (shader: u32, loc := #caller_location)                                                                              {        impl_CompileShader(shader);                                                debug_helper(loc, 0, shader);                                                         }
	CreateProgram            :: #force_inline proc "c" (loc := #caller_location) -> u32                                                                                    { ret := impl_CreateProgram();                                                      debug_helper(loc, 1, ret);                                                return ret; }
	CreateShader             :: #force_inline proc "c" (type_: u32, loc := #caller_location) -> u32                                                                        { ret := impl_CreateShader(type_);                                                  debug_helper(loc, 1, ret, type_);                                         return ret; }
	DeleteProgram            :: #force_inline proc "c" (program: u32, loc := #caller_location)                                                                             {        impl_DeleteProgram(program);                                               debug_helper(loc, 0, program);                                                        }
	DeleteShader             :: #force_inline proc "c" (shader: u32, loc := #caller_location)                                                                              {        impl_DeleteShader(shader);                                                 debug_helper(loc, 0, shader);                                                         }
	DetachShader             :: #force_inline proc "c" (program: u32, shader: u32, loc := #caller_location)                                                                {        impl_DetachShader(program, shader);                                        debug_helper(loc, 0, program, shader);                                                }
	DisableVertexAttribArray :: #force_inline proc "c" (index: u32, loc := #caller_location)                                                                               {        impl_DisableVertexAttribArray(index);                                      debug_helper(loc, 0, index);                                                          }
	EnableVertexAttribArray  :: #force_inline proc "c" (index: u32, loc := #caller_location)                                                                               {        impl_EnableVertexAttribArray(index);                                       debug_helper(loc, 0, index);                                                          }
	GetActiveAttrib          :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type_: ^u32, name: ^u8, loc := #caller_location) {        impl_GetActiveAttrib(program, index, bufSize, length, size, type_, name);  debug_helper(loc, 0, program, index, bufSize, length, size, type_, name);             }
	GetActiveUniform         :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type_: ^u32, name: ^u8, loc := #caller_location) {        impl_GetActiveUniform(program, index, bufSize, length, size, type_, name); debug_helper(loc, 0, program, index, bufSize, length, size, type_, name);             }
	GetAttachedShaders       :: #force_inline proc "c" (program: u32, maxCount: i32, count: ^i32, shaders: ^u32, loc := #caller_location)                                  {        impl_GetAttachedShaders(program, maxCount, count, shaders);                debug_helper(loc, 0, program, maxCount, count, shaders);                              }
	GetAttribLocation        :: #force_inline proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                       { ret := impl_GetAttribLocation(program, name);                                     debug_helper(loc, 1, ret, program, name);                                 return ret; }
	GetProgramiv             :: #force_inline proc "c" (program: u32, pname: u32, params: ^i32, loc := #caller_location)                                                   {        impl_GetProgramiv(program, pname, params);                                 debug_helper(loc, 0, program, pname, params);                                         }
	GetProgramInfoLog        :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, infoLog: ^u8, loc := #caller_location)                                   {        impl_GetProgramInfoLog(program, bufSize, length, infoLog);                 debug_helper(loc, 0, program, bufSize, length, infoLog);                              }
	GetShaderiv              :: #force_inline proc "c" (shader: u32, pname: u32, params: ^i32, loc := #caller_location)                                                    {        impl_GetShaderiv(shader, pname, params);                                   debug_helper(loc, 0, shader, pname, params);                                          }
	GetShaderInfoLog         :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, infoLog: ^u8, loc := #caller_location)                                    {        impl_GetShaderInfoLog(shader, bufSize, length, infoLog);                   debug_helper(loc, 0, shader, bufSize, length, infoLog);                               }
	GetShaderSource          :: #force_inline proc "c" (shader: u32, bufSize: i32, length: ^i32, source: ^u8, loc := #caller_location)                                     {        impl_GetShaderSource(shader, bufSize, length, source);                     debug_helper(loc, 0, shader, bufSize, length, source);                                }
	GetUniformLocation       :: #force_inline proc "c" (program: u32, name: cstring, loc := #caller_location) -> i32                                                       { ret := impl_GetUniformLocation(program, name);                                    debug_helper(loc, 1, ret, program, name);                                 return ret; }
	GetUniformfv             :: #force_inline proc "c" (program: u32, location: i32, params: ^f32, loc := #caller_location)                                                {        impl_GetUniformfv(program, location, params);                              debug_helper(loc, 0, program, location, params);                                      }
	GetUniformiv             :: #force_inline proc "c" (program: u32, location: i32, params: ^i32, loc := #caller_location)                                                {        impl_GetUniformiv(program, location, params);                              debug_helper(loc, 0, program, location, params);                                      }
	GetVertexAttribdv        :: #force_inline proc "c" (index: u32, pname: u32, params: ^f64, loc := #caller_location)                                                     {        impl_GetVertexAttribdv(index, pname, params);                              debug_helper(loc, 0, index, pname, params);                                           }
	GetVertexAttribfv        :: #force_inline proc "c" (index: u32, pname: u32, params: ^f32, loc := #caller_location)                                                     {        impl_GetVertexAttribfv(index, pname, params);                              debug_helper(loc, 0, index, pname, params);                                           }
	GetVertexAttribiv        :: #force_inline proc "c" (index: u32, pname: u32, params: ^i32, loc := #caller_location)                                                     {        impl_GetVertexAttribiv(index, pname, params);                              debug_helper(loc, 0, index, pname, params);                                           }
	GetVertexAttribPointerv  :: #force_inline proc "c" (index: u32, pname: u32, pointer: ^rawptr, loc := #caller_location)                                                 {        impl_GetVertexAttribPointerv(index, pname, pointer);                       debug_helper(loc, 0, index, pname, pointer);                                          }
	IsProgram                :: #force_inline proc "c" (program: u32, loc := #caller_location) -> u8                                                                       { ret := impl_IsProgram(program);                                                   debug_helper(loc, 1, ret, program);                                       return ret; }
	IsShader                 :: #force_inline proc "c" (shader: u32, loc := #caller_location) -> u8                                                                        { ret := impl_IsShader(shader);                                                     debug_helper(loc, 1, ret, shader);                                        return ret; }
	LinkProgram              :: #force_inline proc "c" (program: u32, loc := #caller_location)                                                                             {        impl_LinkProgram(program);                                                 debug_helper(loc, 0, program);                                                        }
	ShaderSource             :: #force_inline proc "c" (shader: u32, count: i32, string: ^^u8, length: ^i32, loc := #caller_location)                                      {        impl_ShaderSource(shader, count, string, length);                          debug_helper(loc, 0, shader, count, string, length);                                  }
	UseProgram               :: #force_inline proc "c" (program: u32, loc := #caller_location)                                                                             {        impl_UseProgram(program);                                                  debug_helper(loc, 0, program);                                                        }
	Uniform1f                :: #force_inline proc "c" (location: i32, v0: f32, loc := #caller_location)                                                                   {        impl_Uniform1f(location, v0);                                              debug_helper(loc, 0, location, v0);                                                   }
	Uniform2f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, loc := #caller_location)                                                          {        impl_Uniform2f(location, v0, v1);                                          debug_helper(loc, 0, location, v0, v1);                                               }
	Uniform3f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location)                                                 {        impl_Uniform3f(location, v0, v1, v2);                                      debug_helper(loc, 0, location, v0, v1, v2);                                           }
	Uniform4f                :: #force_inline proc "c" (location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location)                                        {        impl_Uniform4f(location, v0, v1, v2, v3);                                  debug_helper(loc, 0, location, v0, v1, v2, v3);                                       }
	Uniform1i                :: #force_inline proc "c" (location: i32, v0: i32, loc := #caller_location)                                                                   {        impl_Uniform1i(location, v0);                                              debug_helper(loc, 0, location, v0);                                                   }
	Uniform2i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, loc := #caller_location)                                                          {        impl_Uniform2i(location, v0, v1);                                          debug_helper(loc, 0, location, v0, v1);                                               }
	Uniform3i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                                                 {        impl_Uniform3i(location, v0, v1, v2);                                      debug_helper(loc, 0, location, v0, v1, v2);                                           }
	Uniform4i                :: #force_inline proc "c" (location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)                                        {        impl_Uniform4i(location, v0, v1, v2, v3);                                  debug_helper(loc, 0, location, v0, v1, v2, v3);                                       }
	Uniform1fv               :: #force_inline proc "c" (location: i32, count: i32, value: ^f32, loc := #caller_location)                                                   {        impl_Uniform1fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
	Uniform2fv               :: #force_inline proc "c" (location: i32, count: i32, value: ^f32, loc := #caller_location)                                                   {        impl_Uniform2fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
	Uniform3fv               :: #force_inline proc "c" (location: i32, count: i32, value: ^f32, loc := #caller_location)                                                   {        impl_Uniform3fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
	Uniform4fv               :: #force_inline proc "c" (location: i32, count: i32, value: ^f32, loc := #caller_location)                                                   {        impl_Uniform4fv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
	Uniform1iv               :: #force_inline proc "c" (location: i32, count: i32, value: ^i32, loc := #caller_location)                                                   {        impl_Uniform1iv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
	Uniform2iv               :: #force_inline proc "c" (location: i32, count: i32, value: ^i32, loc := #caller_location)                                                   {        impl_Uniform2iv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
	Uniform3iv               :: #force_inline proc "c" (location: i32, count: i32, value: ^i32, loc := #caller_location)                                                   {        impl_Uniform3iv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
	Uniform4iv               :: #force_inline proc "c" (location: i32, count: i32, value: ^i32, loc := #caller_location)                                                   {        impl_Uniform4iv(location, count, value);                                   debug_helper(loc, 0, location, count, value);                                         }
	UniformMatrix2fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)                                    {        impl_UniformMatrix2fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value);                              }
	UniformMatrix3fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)                                    {        impl_UniformMatrix3fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value);                              }
	UniformMatrix4fv         :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)                                    {        impl_UniformMatrix4fv(location, count, transpose, value);                  debug_helper(loc, 0, location, count, transpose, value);                              }
	ValidateProgram          :: #force_inline proc "c" (program: u32, loc := #caller_location)                                                                             {        impl_ValidateProgram(program);                                             debug_helper(loc, 0, program);                                                        }
	VertexAttrib1d           :: #force_inline proc "c" (index: u32, x: f64, loc := #caller_location)                                                                       {        impl_VertexAttrib1d(index, x);                                             debug_helper(loc, 0, index, x);                                                       }
	VertexAttrib1dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                                      {        impl_VertexAttrib1dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib1f           :: #force_inline proc "c" (index: u32, x: f32, loc := #caller_location)                                                                       {        impl_VertexAttrib1f(index, x);                                             debug_helper(loc, 0, index, x);                                                       }
	VertexAttrib1fv          :: #force_inline proc "c" (index: u32, v: ^f32, loc := #caller_location)                                                                      {        impl_VertexAttrib1fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib1s           :: #force_inline proc "c" (index: u32, x: i16, loc := #caller_location)                                                                       {        impl_VertexAttrib1s(index, x);                                             debug_helper(loc, 0, index, x);                                                       }
	VertexAttrib1sv          :: #force_inline proc "c" (index: u32, v: ^i16, loc := #caller_location)                                                                      {        impl_VertexAttrib1sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, loc := #caller_location)                                                               {        impl_VertexAttrib2d(index, x, y);                                          debug_helper(loc, 0, index, x, y);                                                    }
	VertexAttrib2dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                                      {        impl_VertexAttrib2dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib2f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, loc := #caller_location)                                                               {        impl_VertexAttrib2f(index, x, y);                                          debug_helper(loc, 0, index, x, y);                                                    }
	VertexAttrib2fv          :: #force_inline proc "c" (index: u32, v: ^f32, loc := #caller_location)                                                                      {        impl_VertexAttrib2fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib2s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, loc := #caller_location)                                                               {        impl_VertexAttrib2s(index, x, y);                                          debug_helper(loc, 0, index, x, y);                                                    }
	VertexAttrib2sv          :: #force_inline proc "c" (index: u32, v: ^i16, loc := #caller_location)                                                                      {        impl_VertexAttrib2sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, loc := #caller_location)                                                       {        impl_VertexAttrib3d(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z);                                                 }
	VertexAttrib3dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                                      {        impl_VertexAttrib3dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib3f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32, loc := #caller_location)                                                       {        impl_VertexAttrib3f(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z);                                                 }
	VertexAttrib3fv          :: #force_inline proc "c" (index: u32, v: ^f32, loc := #caller_location)                                                                      {        impl_VertexAttrib3fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib3s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16, loc := #caller_location)                                                       {        impl_VertexAttrib3s(index, x, y, z);                                       debug_helper(loc, 0, index, x, y, z);                                                 }
	VertexAttrib3sv          :: #force_inline proc "c" (index: u32, v: ^i16, loc := #caller_location)                                                                      {        impl_VertexAttrib3sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4Nbv         :: #force_inline proc "c" (index: u32, v: ^i8, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nbv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4Niv         :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location)                                                                      {        impl_VertexAttrib4Niv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4Nsv         :: #force_inline proc "c" (index: u32, v: ^i16, loc := #caller_location)                                                                      {        impl_VertexAttrib4Nsv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4Nub         :: #force_inline proc "c" (index: u32, x: u8, y: u8, z: u8, w: u8, loc := #caller_location)                                                   {        impl_VertexAttrib4Nub(index, x, y, z, w);                                  debug_helper(loc, 0, index, x, y, z, w);                                              }
	VertexAttrib4Nubv        :: #force_inline proc "c" (index: u32, v: ^u8, loc := #caller_location)                                                                       {        impl_VertexAttrib4Nubv(index, v);                                          debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4Nuiv        :: #force_inline proc "c" (index: u32, v: ^u32, loc := #caller_location)                                                                      {        impl_VertexAttrib4Nuiv(index, v);                                          debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4Nusv        :: #force_inline proc "c" (index: u32, v: ^u16, loc := #caller_location)                                                                      {        impl_VertexAttrib4Nusv(index, v);                                          debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4bv          :: #force_inline proc "c" (index: u32, v: ^i8, loc := #caller_location)                                                                       {        impl_VertexAttrib4bv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                               {        impl_VertexAttrib4d(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w);                                              }
	VertexAttrib4dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                                      {        impl_VertexAttrib4dv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4f           :: #force_inline proc "c" (index: u32, x: f32, y: f32, z: f32, w: f32, loc := #caller_location)                                               {        impl_VertexAttrib4f(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w);                                              }
	VertexAttrib4fv          :: #force_inline proc "c" (index: u32, v: ^f32, loc := #caller_location)                                                                      {        impl_VertexAttrib4fv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4iv          :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location)                                                                      {        impl_VertexAttrib4iv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4s           :: #force_inline proc "c" (index: u32, x: i16, y: i16, z: i16, w: i16, loc := #caller_location)                                               {        impl_VertexAttrib4s(index, x, y, z, w);                                    debug_helper(loc, 0, index, x, y, z, w);                                              }
	VertexAttrib4sv          :: #force_inline proc "c" (index: u32, v: ^i16, loc := #caller_location)                                                                      {        impl_VertexAttrib4sv(index, v);                                            debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4ubv         :: #force_inline proc "c" (index: u32, v: ^u8, loc := #caller_location)                                                                       {        impl_VertexAttrib4ubv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4uiv         :: #force_inline proc "c" (index: u32, v: ^u32, loc := #caller_location)                                                                      {        impl_VertexAttrib4uiv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
	VertexAttrib4usv         :: #force_inline proc "c" (index: u32, v: ^u16, loc := #caller_location)                                                                      {        impl_VertexAttrib4usv(index, v);                                           debug_helper(loc, 0, index, v);                                                       }
	VertexAttribPointer      :: #force_inline proc "c" (index: u32, size: i32, type_: u32, normalized: u8, stride: i32, pointer: rawptr, loc := #caller_location)          {        impl_VertexAttribPointer(index, size, type_, normalized, stride, pointer); debug_helper(loc, 0, index, size, type_, normalized, stride, pointer);                }

	// VERSION_2_1
	UniformMatrix2x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location) { impl_UniformMatrix2x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
	UniformMatrix3x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location) { impl_UniformMatrix3x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
	UniformMatrix2x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location) { impl_UniformMatrix2x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
	UniformMatrix4x2fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location) { impl_UniformMatrix4x2fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
	UniformMatrix3x4fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location) { impl_UniformMatrix3x4fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }
	UniformMatrix4x3fv :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location) { impl_UniformMatrix4x3fv(location, count, transpose, value); debug_helper(loc, 0, location, count, transpose, value); }

		// VERSION_3_0
	ColorMaski                          :: #force_inline proc "c" (index: u32, r: u8, g: u8, b: u8, a: u8, loc := #caller_location)                                                                                 {        impl_ColorMaski(index, r, g, b, a);                                                         debug_helper(loc, 0, index, r, g, b, a);                                                                }
	GetBooleani_v                       :: #force_inline proc "c" (target: u32, index: u32, data: ^u8, loc := #caller_location)                                                                                     {        impl_GetBooleani_v(target, index, data);                                                    debug_helper(loc, 0, target, index, data);                                                              }
	GetIntegeri_v                       :: #force_inline proc "c" (target: u32, index: u32, data: ^i32, loc := #caller_location)                                                                                    {        impl_GetIntegeri_v(target, index, data);                                                    debug_helper(loc, 0, target, index, data);                                                              }
	Enablei                             :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location)                                                                                                {        impl_Enablei(target, index);                                                                debug_helper(loc, 0, target, index);                                                                    }
	Disablei                            :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location)                                                                                                {        impl_Disablei(target, index);                                                               debug_helper(loc, 0, target, index);                                                                    }
	IsEnabledi                          :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location) -> u8                                                                                          { ret := impl_IsEnabledi(target, index);                                                             debug_helper(loc, 1, ret, target, index);                                                   return ret; }
	BeginTransformFeedback              :: #force_inline proc "c" (primitiveMode: u32, loc := #caller_location)                                                                                                     {        impl_BeginTransformFeedback(primitiveMode);                                                 debug_helper(loc, 0, primitiveMode);                                                                    }
	EndTransformFeedback                :: #force_inline proc "c" (loc := #caller_location)                                                                                                                         {        impl_EndTransformFeedback();                                                                debug_helper(loc, 0);                                                                                   }
	BindBufferRange                     :: #force_inline proc "c" (target: u32, index: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                           {        impl_BindBufferRange(target, index, buffer, offset, size);                                  debug_helper(loc, 0, target, index, buffer, offset, size);                                              }
	BindBufferBase                      :: #force_inline proc "c" (target: u32, index: u32, buffer: u32, loc := #caller_location)                                                                                   {        impl_BindBufferBase(target, index, buffer);                                                 debug_helper(loc, 0, target, index, buffer);                                                            }
	TransformFeedbackVaryings           :: #force_inline proc "c" (program: u32, count: i32, varyings: ^u8, bufferMode: u32, loc := #caller_location)                                                               {        impl_TransformFeedbackVaryings(program, count, varyings, bufferMode);                       debug_helper(loc, 0, program, count, varyings, bufferMode);                                             }
	GetTransformFeedbackVarying         :: #force_inline proc "c" (program: u32, index: u32, bufSize: i32, length: ^i32, size: ^i32, type_: ^u32, name: ^u8, loc := #caller_location)                               {        impl_GetTransformFeedbackVarying(program, index, bufSize, length, size, type_, name);       debug_helper(loc, 0, program, index, bufSize, length, size, type_, name);                               }
	ClampColor                          :: #force_inline proc "c" (target: u32, clamp: u32, loc := #caller_location)                                                                                                {        impl_ClampColor(target, clamp);                                                             debug_helper(loc, 0, target, clamp);                                                                    }
	BeginConditionalRender              :: #force_inline proc "c" (id: u32, mode: u32, loc := #caller_location)                                                                                                     {        impl_BeginConditionalRender(id, mode);                                                      debug_helper(loc, 0, id, mode);                                                                         }
	EndConditionalRender                :: #force_inline proc "c" (loc := #caller_location)                                                                                                                         {        impl_EndConditionalRender();                                                                debug_helper(loc, 0);                                                                                   }
	VertexAttribIPointer                :: #force_inline proc "c" (index: u32, size: i32, type_: u32, stride: i32, pointer: rawptr, loc := #caller_location)                                                        {        impl_VertexAttribIPointer(index, size, type_, stride, pointer);                             debug_helper(loc, 0, index, size, type_, stride, pointer);                                              }
	GetVertexAttribIiv                  :: #force_inline proc "c" (index: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                   {        impl_GetVertexAttribIiv(index, pname, params);                                              debug_helper(loc, 0, index, pname, params);                                                             }
	GetVertexAttribIuiv                 :: #force_inline proc "c" (index: u32, pname: u32, params: ^u32, loc := #caller_location)                                                                                   {        impl_GetVertexAttribIuiv(index, pname, params);                                             debug_helper(loc, 0, index, pname, params);                                                             }
	VertexAttribI1i                     :: #force_inline proc "c" (index: u32, x: i32, loc := #caller_location)                                                                                                     {        impl_VertexAttribI1i(index, x);                                                             debug_helper(loc, 0, index, x);                                                                         }
	VertexAttribI2i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32, loc := #caller_location)                                                                                             {        impl_VertexAttribI2i(index, x, y);                                                          debug_helper(loc, 0, index, x, y);                                                                      }
	VertexAttribI3i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32, loc := #caller_location)                                                                                     {        impl_VertexAttribI3i(index, x, y, z);                                                       debug_helper(loc, 0, index, x, y, z);                                                                   }
	VertexAttribI4i                     :: #force_inline proc "c" (index: u32, x: i32, y: i32, z: i32, w: i32, loc := #caller_location)                                                                             {        impl_VertexAttribI4i(index, x, y, z, w);                                                    debug_helper(loc, 0, index, x, y, z, w);                                                                }
	VertexAttribI1ui                    :: #force_inline proc "c" (index: u32, x: u32, loc := #caller_location)                                                                                                     {        impl_VertexAttribI1ui(index, x);                                                            debug_helper(loc, 0, index, x);                                                                         }
	VertexAttribI2ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32, loc := #caller_location)                                                                                             {        impl_VertexAttribI2ui(index, x, y);                                                         debug_helper(loc, 0, index, x, y);                                                                      }
	VertexAttribI3ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32, loc := #caller_location)                                                                                     {        impl_VertexAttribI3ui(index, x, y, z);                                                      debug_helper(loc, 0, index, x, y, z);                                                                   }
	VertexAttribI4ui                    :: #force_inline proc "c" (index: u32, x: u32, y: u32, z: u32, w: u32, loc := #caller_location)                                                                             {        impl_VertexAttribI4ui(index, x, y, z, w);                                                   debug_helper(loc, 0, index, x, y, z, w);                                                                }
	VertexAttribI1iv                    :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI1iv(index, v);                                                            debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI2iv                    :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI2iv(index, v);                                                            debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI3iv                    :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI3iv(index, v);                                                            debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI4iv                    :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4iv(index, v);                                                            debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI1uiv                   :: #force_inline proc "c" (index: u32, v: ^u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI1uiv(index, v);                                                           debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI2uiv                   :: #force_inline proc "c" (index: u32, v: ^u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI2uiv(index, v);                                                           debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI3uiv                   :: #force_inline proc "c" (index: u32, v: ^u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI3uiv(index, v);                                                           debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI4uiv                   :: #force_inline proc "c" (index: u32, v: ^u32, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4uiv(index, v);                                                           debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI4bv                    :: #force_inline proc "c" (index: u32, v: ^i8, loc := #caller_location)                                                                                                     {        impl_VertexAttribI4bv(index, v);                                                            debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI4sv                    :: #force_inline proc "c" (index: u32, v: ^i16, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4sv(index, v);                                                            debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI4ubv                   :: #force_inline proc "c" (index: u32, v: ^u8, loc := #caller_location)                                                                                                     {        impl_VertexAttribI4ubv(index, v);                                                           debug_helper(loc, 0, index, v);                                                                         }
	VertexAttribI4usv                   :: #force_inline proc "c" (index: u32, v: ^u16, loc := #caller_location)                                                                                                    {        impl_VertexAttribI4usv(index, v);                                                           debug_helper(loc, 0, index, v);                                                                         }
	GetUniformuiv                       :: #force_inline proc "c" (program: u32, location: i32, params: ^u32, loc := #caller_location)                                                                              {        impl_GetUniformuiv(program, location, params);                                              debug_helper(loc, 0, program, location, params);                                                        }
	BindFragDataLocation                :: #force_inline proc "c" (program: u32, color: u32, name: ^u8, loc := #caller_location)                                                                                    {        impl_BindFragDataLocation(program, color, name);                                            debug_helper(loc, 0, program, color, name);                                                             }
	GetFragDataLocation                 :: #force_inline proc "c" (program: u32, name: ^u8, loc := #caller_location) -> i32                                                                                         { ret := impl_GetFragDataLocation(program, name);                                                    debug_helper(loc, 1, ret, program, name);                                                   return ret; }
	Uniform1ui                          :: #force_inline proc "c" (location: i32, v0: u32, loc := #caller_location)                                                                                                 {        impl_Uniform1ui(location, v0);                                                              debug_helper(loc, 0, location, v0);                                                                     }
	Uniform2ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, loc := #caller_location)                                                                                        {        impl_Uniform2ui(location, v0, v1);                                                          debug_helper(loc, 0, location, v0, v1);                                                                 }
	Uniform3ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                                                                               {        impl_Uniform3ui(location, v0, v1, v2);                                                      debug_helper(loc, 0, location, v0, v1, v2);                                                             }
	Uniform4ui                          :: #force_inline proc "c" (location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)                                                                      {        impl_Uniform4ui(location, v0, v1, v2, v3);                                                  debug_helper(loc, 0, location, v0, v1, v2, v3);                                                         }
	Uniform1uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: ^u32, loc := #caller_location)                                                                                 {        impl_Uniform1uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
	Uniform2uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: ^u32, loc := #caller_location)                                                                                 {        impl_Uniform2uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
	Uniform3uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: ^u32, loc := #caller_location)                                                                                 {        impl_Uniform3uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
	Uniform4uiv                         :: #force_inline proc "c" (location: i32, count: i32, value: ^u32, loc := #caller_location)                                                                                 {        impl_Uniform4uiv(location, count, value);                                                   debug_helper(loc, 0, location, count, value);                                                           }
	TexParameterIiv                     :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                  {        impl_TexParameterIiv(target, pname, params);                                                debug_helper(loc, 0, target, pname, params);                                                            }
	TexParameterIuiv                    :: #force_inline proc "c" (target: u32, pname: u32, params: ^u32, loc := #caller_location)                                                                                  {        impl_TexParameterIuiv(target, pname, params);                                               debug_helper(loc, 0, target, pname, params);                                                            }
	GetTexParameterIiv                  :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                  {        impl_GetTexParameterIiv(target, pname, params);                                             debug_helper(loc, 0, target, pname, params);                                                            }
	GetTexParameterIuiv                 :: #force_inline proc "c" (target: u32, pname: u32, params: ^u32, loc := #caller_location)                                                                                  {        impl_GetTexParameterIuiv(target, pname, params);                                            debug_helper(loc, 0, target, pname, params);                                                            }
	ClearBufferiv                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^i32, loc := #caller_location)                                                                              {        impl_ClearBufferiv(buffer, drawbuffer, value);                                              debug_helper(loc, 0, buffer, drawbuffer, value);                                                        }
	ClearBufferuiv                      :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^u32, loc := #caller_location)                                                                              {        impl_ClearBufferuiv(buffer, drawbuffer, value);                                             debug_helper(loc, 0, buffer, drawbuffer, value);                                                        }
	ClearBufferfv                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, value: ^f32, loc := #caller_location)                                                                              {        impl_ClearBufferfv(buffer, drawbuffer, value);                                              debug_helper(loc, 0, buffer, drawbuffer, value);                                                        }
	ClearBufferfi                       :: #force_inline proc "c" (buffer: u32, drawbuffer: i32, depth: f32, stencil: i32, loc := #caller_location) -> rawptr                                                       { ret := impl_ClearBufferfi(buffer, drawbuffer, depth, stencil);                                     debug_helper(loc, 1, ret, buffer, drawbuffer, depth, stencil);                              return ret; }
	GetStringi                          :: #force_inline proc "c" (name: u32, index: u32, loc := #caller_location) -> cstring                                                                                            { ret := impl_GetStringi(name, index);                                                               debug_helper(loc, 1, ret, name, index);                                                     return ret; }
	IsRenderbuffer                      :: #force_inline proc "c" (renderbuffer: u32, loc := #caller_location) -> u8                                                                                                { ret := impl_IsRenderbuffer(renderbuffer);                                                          debug_helper(loc, 1, ret, renderbuffer);                                                    return ret; }
	BindRenderbuffer                    :: #force_inline proc "c" (target: u32, renderbuffer: u32, loc := #caller_location)                                                                                         {        impl_BindRenderbuffer(target, renderbuffer);                                                debug_helper(loc, 0, target, renderbuffer);                                                             }
	DeleteRenderbuffers                 :: #force_inline proc "c" (n: i32, renderbuffers: ^u32, loc := #caller_location)                                                                                            {        impl_DeleteRenderbuffers(n, renderbuffers);                                                 debug_helper(loc, 0, n, renderbuffers);                                                                 }
	GenRenderbuffers                    :: #force_inline proc "c" (n: i32, renderbuffers: ^u32, loc := #caller_location)                                                                                            {        impl_GenRenderbuffers(n, renderbuffers);                                                    debug_helper(loc, 0, n, renderbuffers);                                                                 }
	RenderbufferStorage                 :: #force_inline proc "c" (target: u32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                              {        impl_RenderbufferStorage(target, internalformat, width, height);                            debug_helper(loc, 0, target, internalformat, width, height);                                            }
	GetRenderbufferParameteriv          :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                  {        impl_GetRenderbufferParameteriv(target, pname, params);                                     debug_helper(loc, 0, target, pname, params);                                                            }
	IsFramebuffer                       :: #force_inline proc "c" (framebuffer: u32, loc := #caller_location) -> u8                                                                                                 { ret := impl_IsFramebuffer(framebuffer);                                                            debug_helper(loc, 1, ret, framebuffer);                                                     return ret; }
	BindFramebuffer                     :: #force_inline proc "c" (target: u32, framebuffer: u32, loc := #caller_location)                                                                                          {        impl_BindFramebuffer(target, framebuffer);                                                  debug_helper(loc, 0, target, framebuffer);                                                              }
	DeleteFramebuffers                  :: #force_inline proc "c" (n: i32, framebuffers: ^u32, loc := #caller_location)                                                                                             {        impl_DeleteFramebuffers(n, framebuffers);                                                   debug_helper(loc, 0, n, framebuffers);                                                                  }
	GenFramebuffers                     :: #force_inline proc "c" (n: i32, framebuffers: ^u32, loc := #caller_location)                                                                                             {        impl_GenFramebuffers(n, framebuffers);                                                      debug_helper(loc, 0, n, framebuffers);                                                                  }
	CheckFramebufferStatus              :: #force_inline proc "c" (target: u32, loc := #caller_location) -> u32                                                                                                     { ret := impl_CheckFramebufferStatus(target);                                                        debug_helper(loc, 1, ret, target);                                                          return ret; }
	FramebufferTexture1D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, loc := #caller_location)                                                 {        impl_FramebufferTexture1D(target, attachment, textarget, texture, level);                   debug_helper(loc, 0, target, attachment, textarget, texture, level);                                    }
	FramebufferTexture2D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, loc := #caller_location)                                                 {        impl_FramebufferTexture2D(target, attachment, textarget, texture, level);                   debug_helper(loc, 0, target, attachment, textarget, texture, level);                                    }
	FramebufferTexture3D                :: #force_inline proc "c" (target: u32, attachment: u32, textarget: u32, texture: u32, level: i32, zoffset: i32, loc := #caller_location)                                   {        impl_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);          debug_helper(loc, 0, target, attachment, textarget, texture, level, zoffset);                           }
	FramebufferRenderbuffer             :: #force_inline proc "c" (target: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32, loc := #caller_location)                                               {        impl_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);         debug_helper(loc, 0, target, attachment, renderbuffertarget, renderbuffer);                             }
	GetFramebufferAttachmentParameteriv :: #force_inline proc "c" (target: u32, attachment: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                 {        impl_GetFramebufferAttachmentParameteriv(target, attachment, pname, params);                debug_helper(loc, 0, target, attachment, pname, params);                                                }
	GenerateMipmap                      :: #force_inline proc "c" (target: u32, loc := #caller_location)                                                                                                            {        impl_GenerateMipmap(target);                                                                debug_helper(loc, 0, target);                                                                           }
	BlitFramebuffer                     :: #force_inline proc "c" (srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32, loc := #caller_location) {        impl_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); debug_helper(loc, 0, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);             }
	RenderbufferStorageMultisample      :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                {        impl_RenderbufferStorageMultisample(target, samples, internalformat, width, height);        debug_helper(loc, 0, target, samples, internalformat, width, height);                                   }
	FramebufferTextureLayer             :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32, layer: i32, loc := #caller_location)                                                     {        impl_FramebufferTextureLayer(target, attachment, texture, level, layer);                    debug_helper(loc, 0, target, attachment, texture, level, layer);                                        }
	MapBufferRange                      :: #force_inline proc "c" (target: u32, offset: int, length: int, access: u32, loc := #caller_location) -> rawptr                                                           { ret := impl_MapBufferRange(target, offset, length, access);                                        debug_helper(loc, 1, ret, target, offset, length, access);                                  return ret; }
	FlushMappedBufferRange              :: #force_inline proc "c" (target: u32, offset: int, length: int, loc := #caller_location)                                                                                  {        impl_FlushMappedBufferRange(target, offset, length);                                        debug_helper(loc, 0, target, offset, length);                                                           }
	BindVertexArray                     :: #force_inline proc "c" (array: u32, loc := #caller_location)                                                                                                             {        impl_BindVertexArray(array);                                                                debug_helper(loc, 0, array);                                                                            }
	DeleteVertexArrays                  :: #force_inline proc "c" (n: i32, arrays: ^u32, loc := #caller_location)                                                                                                   {        impl_DeleteVertexArrays(n, arrays);                                                         debug_helper(loc, 0, n, arrays);                                                                        }
	GenVertexArrays                     :: #force_inline proc "c" (n: i32, arrays: ^u32, loc := #caller_location)                                                                                                   {        impl_GenVertexArrays(n, arrays);                                                            debug_helper(loc, 0, n, arrays);                                                                        }
	IsVertexArray                       :: #force_inline proc "c" (array: u32, loc := #caller_location) -> u8                                                                                                       { ret := impl_IsVertexArray(array);                                                                  debug_helper(loc, 1, ret, array);                                                           return ret; }

	// VERSION_3_1
	DrawArraysInstanced       :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, loc := #caller_location)                                   {        impl_DrawArraysInstanced(mode, first, count, instancecount);                                   debug_helper(loc, 0, mode, first, count, instancecount);            }
	DrawElementsInstanced     :: #force_inline proc "c" (mode: u32, count: i32, type_: u32, indices: rawptr, instancecount: i32, loc := #caller_location)                  {        impl_DrawElementsInstanced(mode, count, type_, indices, instancecount);                        debug_helper(loc, 0, mode, count, type_, indices, instancecount);            }
	TexBuffer                 :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32, loc := #caller_location)                                           {        impl_TexBuffer(target, internalformat, buffer);                                                debug_helper(loc, 0, target, internalformat, buffer);            }
	PrimitiveRestartIndex     :: #force_inline proc "c" (index: u32, loc := #caller_location)                                                                              {        impl_PrimitiveRestartIndex(index);                                                             debug_helper(loc, 0, index);            }
	CopyBufferSubData         :: #force_inline proc "c" (readTarget: u32, writeTarget: u32, readOffset: int, writeOffset: int, size: int, loc := #caller_location)         {        impl_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);                debug_helper(loc, 0, readTarget, writeTarget, readOffset, writeOffset, size);            }
	GetUniformIndices         :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformNames: ^u8, uniformIndices: ^u32, loc := #caller_location)                {        impl_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);                   debug_helper(loc, 0, program, uniformCount, uniformNames, uniformIndices);            }
	GetActiveUniformsiv       :: #force_inline proc "c" (program: u32, uniformCount: i32, uniformIndices: ^u32, pname: u32, params: ^i32, loc := #caller_location)         {        impl_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);                debug_helper(loc, 0, program, uniformCount, uniformIndices, pname, params);            }
	GetActiveUniformName      :: #force_inline proc "c" (program: u32, uniformIndex: u32, bufSize: i32, length: ^i32, uniformName: ^u8, loc := #caller_location)           {        impl_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);                debug_helper(loc, 0, program, uniformIndex, bufSize, length, uniformName);            }
	GetUniformBlockIndex      :: #force_inline proc "c" (program: u32, uniformBlockName: ^u8, loc := #caller_location) -> u32                                              { ret := impl_GetUniformBlockIndex(program, uniformBlockName);                                          debug_helper(loc, 1, ret, program, uniformBlockName); return ret; }
	GetActiveUniformBlockiv   :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, pname: u32, params: ^i32, loc := #caller_location)                          {        impl_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);                       debug_helper(loc, 0, program, uniformBlockIndex, pname, params);            }
	GetActiveUniformBlockName :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, bufSize: i32, length: ^i32, uniformBlockName: ^u8, loc := #caller_location) {        impl_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); debug_helper(loc, 0, program, uniformBlockIndex, bufSize, length, uniformBlockName);            }
	UniformBlockBinding       :: #force_inline proc "c" (program: u32, uniformBlockIndex: u32, uniformBlockBinding: u32, loc := #caller_location)                          {        impl_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);                     debug_helper(loc, 0, program, uniformBlockIndex, uniformBlockBinding);            }

	// VERSION_3_2
	DrawElementsBaseVertex          :: #force_inline proc "c" (mode: u32, count: i32, type_: u32, indices: rawptr, basevertex: i32, loc := #caller_location)                                           {        impl_DrawElementsBaseVertex(mode, count, type_, indices, basevertex);                                    debug_helper(loc, 0, mode, count, type_, indices, basevertex);                                                 }
	DrawRangeElementsBaseVertex     :: #force_inline proc "c" (mode: u32, start: u32, end: u32, count: i32, type_: u32, indices: rawptr, basevertex: i32, loc := #caller_location)                     {        impl_DrawRangeElementsBaseVertex(mode, start, end, count, type_, indices, basevertex);                   debug_helper(loc, 0, mode, start, end, count, type_, indices, basevertex);                                     }
	DrawElementsInstancedBaseVertex :: #force_inline proc "c" (mode: u32, count: i32, type_: u32, indices: rawptr, instancecount: i32, basevertex: i32, loc := #caller_location)                       {        impl_DrawElementsInstancedBaseVertex(mode, count, type_, indices, instancecount, basevertex);            debug_helper(loc, 0, mode, count, type_, indices, instancecount, basevertex);                                  }
	MultiDrawElementsBaseVertex     :: #force_inline proc "c" (mode: u32, count: ^i32, type_: u32, indices: ^rawptr, drawcount: i32, basevertex: ^i32, loc := #caller_location)                        {        impl_MultiDrawElementsBaseVertex(mode, count, type_, indices, drawcount, basevertex);                    debug_helper(loc, 0, mode, count, type_, indices, drawcount, basevertex);                                      }
	ProvokingVertex                 :: #force_inline proc "c" (mode: u32, loc := #caller_location)                                                                                                     {        impl_ProvokingVertex(mode);                                                                              debug_helper(loc, 0, mode);                                                                                    }
	FenceSync                       :: #force_inline proc "c" (condition: u32, flags: u32, loc := #caller_location) -> sync_t                                                                          { ret := impl_FenceSync(condition, flags);                                                                        debug_helper(loc, 1, ret, condition, flags);                                                       return ret; }
	IsSync                          :: #force_inline proc "c" (sync: sync_t, loc := #caller_location) -> u8                                                                                            { ret := impl_IsSync(sync);                                                                                       debug_helper(loc, 1, ret, sync);                                                                   return ret; }
	DeleteSync                      :: #force_inline proc "c" (sync: sync_t, loc := #caller_location)                                                                                                  {        impl_DeleteSync(sync);                                                                                   debug_helper(loc, 0, sync);                                                                                    }
	ClientWaitSync                  :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64, loc := #caller_location) -> u32                                                                 { ret := impl_ClientWaitSync(sync, flags, timeout);                                                               debug_helper(loc, 1, ret, sync, flags, timeout);                                                   return ret; }
	WaitSync                        :: #force_inline proc "c" (sync: sync_t, flags: u32, timeout: u64, loc := #caller_location)                                                                        {        impl_WaitSync(sync, flags, timeout);                                                                     debug_helper(loc, 0, sync, flags, timeout);                                                                    }
	GetInteger64v                   :: #force_inline proc "c" (pname: u32, data: ^i64, loc := #caller_location)                                                                                        {        impl_GetInteger64v(pname, data);                                                                         debug_helper(loc, 0, pname, data);                                                                             }
	GetSynciv                       :: #force_inline proc "c" (sync: sync_t, pname: u32, bufSize: i32, length: ^i32, values: ^i32, loc := #caller_location)                                            {        impl_GetSynciv(sync, pname, bufSize, length, values);                                                    debug_helper(loc, 0, sync, pname, bufSize, length, values);                                                    }
	GetInteger64i_v                 :: #force_inline proc "c" (target: u32, index: u32, data: ^i64, loc := #caller_location)                                                                           {        impl_GetInteger64i_v(target, index, data);                                                               debug_helper(loc, 0, target, index, data);                                                                     }
	GetBufferParameteri64v          :: #force_inline proc "c" (target: u32, pname: u32, params: ^i64, loc := #caller_location)                                                                         {        impl_GetBufferParameteri64v(target, pname, params);                                                      debug_helper(loc, 0, target, pname, params);                                                                   }
	FramebufferTexture              :: #force_inline proc "c" (target: u32, attachment: u32, texture: u32, level: i32, loc := #caller_location)                                                        {        impl_FramebufferTexture(target, attachment, texture, level);                                             debug_helper(loc, 0, target, attachment, texture, level);                                                      }
	TexImage2DMultisample           :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8, loc := #caller_location)             {        impl_TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);        debug_helper(loc, 0, target, samples, internalformat, width, height, fixedsamplelocations);                    }
	TexImage3DMultisample           :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8, loc := #caller_location) {        impl_TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); debug_helper(loc, 0, target, samples, internalformat, width, height, depth, fixedsamplelocations);             }
	GetMultisamplefv                :: #force_inline proc "c" (pname: u32, index: u32, val: ^f32, loc := #caller_location)                                                                             {        impl_GetMultisamplefv(pname, index, val);                                                                debug_helper(loc, 0, pname, index, val);                                                                       }
	SampleMaski                     :: #force_inline proc "c" (maskNumber: u32, mask: u32, loc := #caller_location)                                                                                    {        impl_SampleMaski(maskNumber, mask);                                                                      debug_helper(loc, 0, maskNumber, mask);                                                                        }

	// VERSION_3_3
	BindFragDataLocationIndexed :: #force_inline proc "c" (program: u32, colorNumber: u32, index: u32, name: ^u8, loc := #caller_location) {        impl_BindFragDataLocationIndexed(program, colorNumber, index, name); debug_helper(loc, 0, program, colorNumber, index, name);             }
	GetFragDataIndex            :: #force_inline proc "c" (program: u32, name: ^u8, loc := #caller_location) -> i32                        { ret := impl_GetFragDataIndex(program, name);                                debug_helper(loc, 1, ret, program, name);                return ret; }
	GenSamplers                 :: #force_inline proc "c" (count: i32, samplers: ^u32, loc := #caller_location)                            {        impl_GenSamplers(count, samplers);                                   debug_helper(loc, 0, count, samplers);                               }
	DeleteSamplers              :: #force_inline proc "c" (count: i32, samplers: ^u32, loc := #caller_location)                            {        impl_DeleteSamplers(count, samplers);                                debug_helper(loc, 0, count, samplers);                               }
	IsSampler                   :: #force_inline proc "c" (sampler: u32, loc := #caller_location) -> u8                                    { ret := impl_IsSampler(sampler);                                             debug_helper(loc, 1, ret, sampler);                      return ret; }
	BindSampler                 :: #force_inline proc "c" (unit: u32, sampler: u32, loc := #caller_location)                               {        impl_BindSampler(unit, sampler);                                     debug_helper(loc, 0, unit, sampler);                                 }
	SamplerParameteri           :: #force_inline proc "c" (sampler: u32, pname: u32, param: i32, loc := #caller_location)                  {        impl_SamplerParameteri(sampler, pname, param);                       debug_helper(loc, 0, sampler, pname, param);                         }
	SamplerParameteriv          :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32, loc := #caller_location)                 {        impl_SamplerParameteriv(sampler, pname, param);                      debug_helper(loc, 0, sampler, pname, param);                         }
	SamplerParameterf           :: #force_inline proc "c" (sampler: u32, pname: u32, param: f32, loc := #caller_location)                  {        impl_SamplerParameterf(sampler, pname, param);                       debug_helper(loc, 0, sampler, pname, param);                         }
	SamplerParameterfv          :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^f32, loc := #caller_location)                 {        impl_SamplerParameterfv(sampler, pname, param);                      debug_helper(loc, 0, sampler, pname, param);                         }
	SamplerParameterIiv         :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^i32, loc := #caller_location)                 {        impl_SamplerParameterIiv(sampler, pname, param);                     debug_helper(loc, 0, sampler, pname, param);                         }
	SamplerParameterIuiv        :: #force_inline proc "c" (sampler: u32, pname: u32, param: ^u32, loc := #caller_location)                 {        impl_SamplerParameterIuiv(sampler, pname, param);                    debug_helper(loc, 0, sampler, pname, param);                         }
	GetSamplerParameteriv       :: #force_inline proc "c" (sampler: u32, pname: u32, params: ^i32, loc := #caller_location)                {        impl_GetSamplerParameteriv(sampler, pname, params);                  debug_helper(loc, 0, sampler, pname, params);                        }
	GetSamplerParameterIiv      :: #force_inline proc "c" (sampler: u32, pname: u32, params: ^i32, loc := #caller_location)                {        impl_GetSamplerParameterIiv(sampler, pname, params);                 debug_helper(loc, 0, sampler, pname, params);                        }
	GetSamplerParameterfv       :: #force_inline proc "c" (sampler: u32, pname: u32, params: ^f32, loc := #caller_location)                {        impl_GetSamplerParameterfv(sampler, pname, params);                  debug_helper(loc, 0, sampler, pname, params);                        }
	GetSamplerParameterIuiv     :: #force_inline proc "c" (sampler: u32, pname: u32, params: ^u32, loc := #caller_location)                {        impl_GetSamplerParameterIuiv(sampler, pname, params);                debug_helper(loc, 0, sampler, pname, params);                        }
	QueryCounter                :: #force_inline proc "c" (id: u32, target: u32, loc := #caller_location)                                  {        impl_QueryCounter(id, target);                                       debug_helper(loc, 0, id, target);                                    }
	GetQueryObjecti64v          :: #force_inline proc "c" (id: u32, pname: u32, params: ^i64, loc := #caller_location)                     {        impl_GetQueryObjecti64v(id, pname, params);                          debug_helper(loc, 0, id, pname, params);                             }
	GetQueryObjectui64v         :: #force_inline proc "c" (id: u32, pname: u32, params: ^u64, loc := #caller_location)                     {        impl_GetQueryObjectui64v(id, pname, params);                         debug_helper(loc, 0, id, pname, params);                             }
	VertexAttribDivisor         :: #force_inline proc "c" (index: u32, divisor: u32, loc := #caller_location)                              {        impl_VertexAttribDivisor(index, divisor);                            debug_helper(loc, 0, index, divisor);                                }
	VertexAttribP1ui            :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: u32, loc := #caller_location)    {        impl_VertexAttribP1ui(index, type_, normalized, value);              debug_helper(loc, 0, index, type_, normalized, value);               }
	VertexAttribP1uiv           :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: ^u32, loc := #caller_location)   {        impl_VertexAttribP1uiv(index, type_, normalized, value);             debug_helper(loc, 0, index, type_, normalized, value);               }
	VertexAttribP2ui            :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: u32, loc := #caller_location)    {        impl_VertexAttribP2ui(index, type_, normalized, value);              debug_helper(loc, 0, index, type_, normalized, value);               }
	VertexAttribP2uiv           :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: ^u32, loc := #caller_location)   {        impl_VertexAttribP2uiv(index, type_, normalized, value);             debug_helper(loc, 0, index, type_, normalized, value);               }
	VertexAttribP3ui            :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: u32, loc := #caller_location)    {        impl_VertexAttribP3ui(index, type_, normalized, value);              debug_helper(loc, 0, index, type_, normalized, value);               }
	VertexAttribP3uiv           :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: ^u32, loc := #caller_location)   {        impl_VertexAttribP3uiv(index, type_, normalized, value);             debug_helper(loc, 0, index, type_, normalized, value);               }
	VertexAttribP4ui            :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: u32, loc := #caller_location)    {        impl_VertexAttribP4ui(index, type_, normalized, value);              debug_helper(loc, 0, index, type_, normalized, value);               }
	VertexAttribP4uiv           :: #force_inline proc "c" (index: u32, type_: u32, normalized: u8, value: ^u32, loc := #caller_location)   {        impl_VertexAttribP4uiv(index, type_, normalized, value);             debug_helper(loc, 0, index, type_, normalized, value);               }
	VertexP2ui                  :: #force_inline proc "c" (type_: u32, value: u32, loc := #caller_location)                                {        impl_VertexP2ui(type_, value);                                       debug_helper(loc, 0, type_, value);                                  }
	VertexP2uiv                 :: #force_inline proc "c" (type_: u32, value: ^u32, loc := #caller_location)                               {        impl_VertexP2uiv(type_, value);                                      debug_helper(loc, 0, type_, value);                                  }
	VertexP3ui                  :: #force_inline proc "c" (type_: u32, value: u32, loc := #caller_location)                                {        impl_VertexP3ui(type_, value);                                       debug_helper(loc, 0, type_, value);                                  }
	VertexP3uiv                 :: #force_inline proc "c" (type_: u32, value: ^u32, loc := #caller_location)                               {        impl_VertexP3uiv(type_, value);                                      debug_helper(loc, 0, type_, value);                                  }
	VertexP4ui                  :: #force_inline proc "c" (type_: u32, value: u32, loc := #caller_location)                                {        impl_VertexP4ui(type_, value);                                       debug_helper(loc, 0, type_, value);                                  }
	VertexP4uiv                 :: #force_inline proc "c" (type_: u32, value: ^u32, loc := #caller_location)                               {        impl_VertexP4uiv(type_, value);                                      debug_helper(loc, 0, type_, value);                                  }
	TexCoordP1ui                :: #force_inline proc "c" (type_: u32, coords: u32, loc := #caller_location)                               {        impl_TexCoordP1ui(type_, coords);                                    debug_helper(loc, 0, type_, coords);                                 }
	TexCoordP1uiv               :: #force_inline proc "c" (type_: u32, coords: ^u32, loc := #caller_location)                              {        impl_TexCoordP1uiv(type_, coords);                                   debug_helper(loc, 0, type_, coords);                                 }
	TexCoordP2ui                :: #force_inline proc "c" (type_: u32, coords: u32, loc := #caller_location)                               {        impl_TexCoordP2ui(type_, coords);                                    debug_helper(loc, 0, type_, coords);                                 }
	TexCoordP2uiv               :: #force_inline proc "c" (type_: u32, coords: ^u32, loc := #caller_location)                              {        impl_TexCoordP2uiv(type_, coords);                                   debug_helper(loc, 0, type_, coords);                                 }
	TexCoordP3ui                :: #force_inline proc "c" (type_: u32, coords: u32, loc := #caller_location)                               {        impl_TexCoordP3ui(type_, coords);                                    debug_helper(loc, 0, type_, coords);                                 }
	TexCoordP3uiv               :: #force_inline proc "c" (type_: u32, coords: ^u32, loc := #caller_location)                              {        impl_TexCoordP3uiv(type_, coords);                                   debug_helper(loc, 0, type_, coords);                                 }
	TexCoordP4ui                :: #force_inline proc "c" (type_: u32, coords: u32, loc := #caller_location)                               {        impl_TexCoordP4ui(type_, coords);                                    debug_helper(loc, 0, type_, coords);                                 }
	TexCoordP4uiv               :: #force_inline proc "c" (type_: u32, coords: ^u32, loc := #caller_location)                              {        impl_TexCoordP4uiv(type_, coords);                                   debug_helper(loc, 0, type_, coords);                                 }
	MultiTexCoordP1ui           :: #force_inline proc "c" (texture: u32, type_: u32, coords: u32, loc := #caller_location)                 {        impl_MultiTexCoordP1ui(texture, type_, coords);                      debug_helper(loc, 0, texture, type_, coords);                        }
	MultiTexCoordP1uiv          :: #force_inline proc "c" (texture: u32, type_: u32, coords: ^u32, loc := #caller_location)                {        impl_MultiTexCoordP1uiv(texture, type_, coords);                     debug_helper(loc, 0, texture, type_, coords);                        }
	MultiTexCoordP2ui           :: #force_inline proc "c" (texture: u32, type_: u32, coords: u32, loc := #caller_location)                 {        impl_MultiTexCoordP2ui(texture, type_, coords);                      debug_helper(loc, 0, texture, type_, coords);                        }
	MultiTexCoordP2uiv          :: #force_inline proc "c" (texture: u32, type_: u32, coords: ^u32, loc := #caller_location)                {        impl_MultiTexCoordP2uiv(texture, type_, coords);                     debug_helper(loc, 0, texture, type_, coords);                        }
	MultiTexCoordP3ui           :: #force_inline proc "c" (texture: u32, type_: u32, coords: u32, loc := #caller_location)                 {        impl_MultiTexCoordP3ui(texture, type_, coords);                      debug_helper(loc, 0, texture, type_, coords);                        }
	MultiTexCoordP3uiv          :: #force_inline proc "c" (texture: u32, type_: u32, coords: ^u32, loc := #caller_location)                {        impl_MultiTexCoordP3uiv(texture, type_, coords);                     debug_helper(loc, 0, texture, type_, coords);                        }
	MultiTexCoordP4ui           :: #force_inline proc "c" (texture: u32, type_: u32, coords: u32, loc := #caller_location)                 {        impl_MultiTexCoordP4ui(texture, type_, coords);                      debug_helper(loc, 0, texture, type_, coords);                        }
	MultiTexCoordP4uiv          :: #force_inline proc "c" (texture: u32, type_: u32, coords: ^u32, loc := #caller_location)                {        impl_MultiTexCoordP4uiv(texture, type_, coords);                     debug_helper(loc, 0, texture, type_, coords);                        }
	NormalP3ui                  :: #force_inline proc "c" (type_: u32, coords: u32, loc := #caller_location)                               {        impl_NormalP3ui(type_, coords);                                      debug_helper(loc, 0, type_, coords);                                 }
	NormalP3uiv                 :: #force_inline proc "c" (type_: u32, coords: ^u32, loc := #caller_location)                              {        impl_NormalP3uiv(type_, coords);                                     debug_helper(loc, 0, type_, coords);                                 }
	ColorP3ui                   :: #force_inline proc "c" (type_: u32, color: u32, loc := #caller_location)                                {        impl_ColorP3ui(type_, color);                                        debug_helper(loc, 0, type_, color);                                  }
	ColorP3uiv                  :: #force_inline proc "c" (type_: u32, color: ^u32, loc := #caller_location)                               {        impl_ColorP3uiv(type_, color);                                       debug_helper(loc, 0, type_, color);                                  }
	ColorP4ui                   :: #force_inline proc "c" (type_: u32, color: u32, loc := #caller_location)                                {        impl_ColorP4ui(type_, color);                                        debug_helper(loc, 0, type_, color);                                  }
	ColorP4uiv                  :: #force_inline proc "c" (type_: u32, color: ^u32, loc := #caller_location)                               {        impl_ColorP4uiv(type_, color);                                       debug_helper(loc, 0, type_, color);                                  }
	SecondaryColorP3ui          :: #force_inline proc "c" (type_: u32, color: u32, loc := #caller_location)                                {        impl_SecondaryColorP3ui(type_, color);                               debug_helper(loc, 0, type_, color);                                  }
	SecondaryColorP3uiv         :: #force_inline proc "c" (type_: u32, color: ^u32, loc := #caller_location)                               {        impl_SecondaryColorP3uiv(type_, color);                              debug_helper(loc, 0, type_, color);                                  }

	// VERSION_4_0
	MinSampleShading               :: #force_inline proc "c" (value: f32, loc := #caller_location)                                                                        {        impl_MinSampleShading(value);                                                            debug_helper(loc, 0, value);                                                          }
	BlendEquationi                 :: #force_inline proc "c" (buf: u32, mode: u32, loc := #caller_location)                                                               {        impl_BlendEquationi(buf, mode);                                                          debug_helper(loc, 0, buf, mode);                                                      }
	BlendEquationSeparatei         :: #force_inline proc "c" (buf: u32, modeRGB: u32, modeAlpha: u32, loc := #caller_location)                                            {        impl_BlendEquationSeparatei(buf, modeRGB, modeAlpha);                                    debug_helper(loc, 0, buf, modeRGB, modeAlpha);                                        }
	BlendFunci                     :: #force_inline proc "c" (buf: u32, src: u32, dst: u32, loc := #caller_location)                                                      {        impl_BlendFunci(buf, src, dst);                                                          debug_helper(loc, 0, buf, src, dst);                                                  }
	BlendFuncSeparatei             :: #force_inline proc "c" (buf: u32, srcRGB: u32, dstRGB: u32, srcAlpha: u32, dstAlpha: u32, loc := #caller_location)                  {        impl_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);                        debug_helper(loc, 0, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);                        }
	DrawArraysIndirect             :: #force_inline proc "c" (mode: u32, indirect: rawptr, loc := #caller_location)                                                       {        impl_DrawArraysIndirect(mode, indirect);                                                 debug_helper(loc, 0, mode, indirect);                                                 }
	DrawElementsIndirect           :: #force_inline proc "c" (mode: u32, type_: u32, indirect: rawptr, loc := #caller_location)                                           {        impl_DrawElementsIndirect(mode, type_, indirect);                                        debug_helper(loc, 0, mode, type_, indirect);                                          }
	Uniform1d                      :: #force_inline proc "c" (location: i32, x: f64, loc := #caller_location)                                                             {        impl_Uniform1d(location, x);                                                             debug_helper(loc, 0, location, x);                                                    }
	Uniform2d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, loc := #caller_location)                                                     {        impl_Uniform2d(location, x, y);                                                          debug_helper(loc, 0, location, x, y);                                                 }
	Uniform3d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, loc := #caller_location)                                             {        impl_Uniform3d(location, x, y, z);                                                       debug_helper(loc, 0, location, x, y, z);                                              }
	Uniform4d                      :: #force_inline proc "c" (location: i32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                     {        impl_Uniform4d(location, x, y, z, w);                                                    debug_helper(loc, 0, location, x, y, z, w);                                           }
	Uniform1dv                     :: #force_inline proc "c" (location: i32, count: i32, value: ^f64, loc := #caller_location)                                            {        impl_Uniform1dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
	Uniform2dv                     :: #force_inline proc "c" (location: i32, count: i32, value: ^f64, loc := #caller_location)                                            {        impl_Uniform2dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
	Uniform3dv                     :: #force_inline proc "c" (location: i32, count: i32, value: ^f64, loc := #caller_location)                                            {        impl_Uniform3dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
	Uniform4dv                     :: #force_inline proc "c" (location: i32, count: i32, value: ^f64, loc := #caller_location)                                            {        impl_Uniform4dv(location, count, value);                                                 debug_helper(loc, 0, location, count, value);                                         }
	UniformMatrix2dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)                             {        impl_UniformMatrix2dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value);                              }
	UniformMatrix3dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)                             {        impl_UniformMatrix3dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value);                              }
	UniformMatrix4dv               :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)                             {        impl_UniformMatrix4dv(location, count, transpose, value);                                debug_helper(loc, 0, location, count, transpose, value);                              }
	UniformMatrix2x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)                             {        impl_UniformMatrix2x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
	UniformMatrix2x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)                             {        impl_UniformMatrix2x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
	UniformMatrix3x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)                             {        impl_UniformMatrix3x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
	UniformMatrix3x4dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)                             {        impl_UniformMatrix3x4dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
	UniformMatrix4x2dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)                             {        impl_UniformMatrix4x2dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
	UniformMatrix4x3dv             :: #force_inline proc "c" (location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)                             {        impl_UniformMatrix4x3dv(location, count, transpose, value);                              debug_helper(loc, 0, location, count, transpose, value);                              }
	GetUniformdv                   :: #force_inline proc "c" (program: u32, location: i32, params: ^f64, loc := #caller_location)                                         {        impl_GetUniformdv(program, location, params);                                            debug_helper(loc, 0, program, location, params);                                      }
	GetSubroutineUniformLocation   :: #force_inline proc "c" (program: u32, shadertype_: u32, name: ^u8, loc := #caller_location) -> i32                                  { ret := impl_GetSubroutineUniformLocation(program, shadertype_, name);                           debug_helper(loc, 1, ret, program, shadertype_, name);                    return ret; }
	GetSubroutineIndex             :: #force_inline proc "c" (program: u32, shadertype_: u32, name: ^u8, loc := #caller_location) -> u32                                  { ret := impl_GetSubroutineIndex(program, shadertype_, name);                                     debug_helper(loc, 1, ret, program, shadertype_, name);                    return ret; }
	GetActiveSubroutineUniformiv   :: #force_inline proc "c" (program: u32, shadertype_: u32, index: u32, pname: u32, values: ^i32, loc := #caller_location)              {        impl_GetActiveSubroutineUniformiv(program, shadertype_, index, pname, values);           debug_helper(loc, 0, program, shadertype_, index, pname, values);                     }
	GetActiveSubroutineUniformName :: #force_inline proc "c" (program: u32, shadertype_: u32, index: u32, bufsize: i32, length: ^i32, name: ^u8, loc := #caller_location) {        impl_GetActiveSubroutineUniformName(program, shadertype_, index, bufsize, length, name); debug_helper(loc, 0, program, shadertype_, index, bufsize, length, name);             }
	GetActiveSubroutineName        :: #force_inline proc "c" (program: u32, shadertype_: u32, index: u32, bufsize: i32, length: ^i32, name: ^u8, loc := #caller_location) {        impl_GetActiveSubroutineName(program, shadertype_, index, bufsize, length, name);        debug_helper(loc, 0, program, shadertype_, index, bufsize, length, name);             }
	UniformSubroutinesuiv          :: #force_inline proc "c" (shadertype_: u32, count: i32, indices: ^u32, loc := #caller_location)                                       {        impl_UniformSubroutinesuiv(shadertype_, count, indices);                                 debug_helper(loc, 0, shadertype_, count, indices);                                    }
	GetUniformSubroutineuiv        :: #force_inline proc "c" (shadertype_: u32, location: i32, params: ^u32, loc := #caller_location)                                     {        impl_GetUniformSubroutineuiv(shadertype_, location, params);                             debug_helper(loc, 0, shadertype_, location, params);                                  }
	GetProgramStageiv              :: #force_inline proc "c" (program: u32, shadertype_: u32, pname: u32, values: ^i32, loc := #caller_location)                          {        impl_GetProgramStageiv(program, shadertype_, pname, values);                             debug_helper(loc, 0, program, shadertype_, pname, values);                            }
	PatchParameteri                :: #force_inline proc "c" (pname: u32, value: i32, loc := #caller_location)                                                            {        impl_PatchParameteri(pname, value);                                                      debug_helper(loc, 0, pname, value);                                                   }
	PatchParameterfv               :: #force_inline proc "c" (pname: u32, values: ^f32, loc := #caller_location)                                                          {        impl_PatchParameterfv(pname, values);                                                    debug_helper(loc, 0, pname, values);                                                  }
	BindTransformFeedback          :: #force_inline proc "c" (target: u32, id: u32, loc := #caller_location)                                                              {        impl_BindTransformFeedback(target, id);                                                  debug_helper(loc, 0, target, id);                                                     }
	DeleteTransformFeedbacks       :: #force_inline proc "c" (n: i32, ids: ^u32, loc := #caller_location)                                                                 {        impl_DeleteTransformFeedbacks(n, ids);                                                   debug_helper(loc, 0, n, ids);                                                         }
	GenTransformFeedbacks          :: #force_inline proc "c" (n: i32, ids: ^u32, loc := #caller_location)                                                                 {        impl_GenTransformFeedbacks(n, ids);                                                      debug_helper(loc, 0, n, ids);                                                         }
	IsTransformFeedback            :: #force_inline proc "c" (id: u32, loc := #caller_location) -> u8                                                                     { ret := impl_IsTransformFeedback(id);                                                            debug_helper(loc, 1, ret, id);                                            return ret; }
	PauseTransformFeedback         :: #force_inline proc "c" (loc := #caller_location)                                                                                    {        impl_PauseTransformFeedback();                                                           debug_helper(loc, 0);                                                                 }
	ResumeTransformFeedback        :: #force_inline proc "c" (loc := #caller_location)                                                                                    {        impl_ResumeTransformFeedback();                                                          debug_helper(loc, 0);                                                                 }
	DrawTransformFeedback          :: #force_inline proc "c" (mode: u32, id: u32, loc := #caller_location)                                                                {        impl_DrawTransformFeedback(mode, id);                                                    debug_helper(loc, 0, mode, id);                                                       }
	DrawTransformFeedbackStream    :: #force_inline proc "c" (mode: u32, id: u32, stream: u32, loc := #caller_location)                                                   {        impl_DrawTransformFeedbackStream(mode, id, stream);                                      debug_helper(loc, 0, mode, id, stream);                                               }
	BeginQueryIndexed              :: #force_inline proc "c" (target: u32, index: u32, id: u32, loc := #caller_location)                                                  {        impl_BeginQueryIndexed(target, index, id);                                               debug_helper(loc, 0, target, index, id);                                              }
	EndQueryIndexed                :: #force_inline proc "c" (target: u32, index: u32, loc := #caller_location)                                                           {        impl_EndQueryIndexed(target, index);                                                     debug_helper(loc, 0, target, index);                                                  }
	GetQueryIndexediv              :: #force_inline proc "c" (target: u32, index: u32, pname: u32, params: ^i32, loc := #caller_location)                                 {        impl_GetQueryIndexediv(target, index, pname, params);                                    debug_helper(loc, 0, target, index, pname, params);                                   }

	// VERSION_4_1
	ReleaseShaderCompiler     :: #force_inline proc "c" (loc := #caller_location)                                                                               {        impl_ReleaseShaderCompiler();                                                 debug_helper(loc, 0);                                                             }
	ShaderBinary              :: #force_inline proc "c" (count: i32, shaders: ^u32, binaryformat: u32, binary: rawptr, length: i32, loc := #caller_location)    {        impl_ShaderBinary(count, shaders, binaryformat, binary, length);              debug_helper(loc, 0, count, shaders, binaryformat, binary, length);               }
	GetShaderPrecisionFormat  :: #force_inline proc "c" (shadertype_: u32, precisiontype_: u32, range: ^i32, precision: ^i32, loc := #caller_location)          {        impl_GetShaderPrecisionFormat(shadertype_, precisiontype_, range, precision); debug_helper(loc, 0, shadertype_, precisiontype_, range, precision);              }
	DepthRangef               :: #force_inline proc "c" (n: f32, f: f32, loc := #caller_location)                                                               {        impl_DepthRangef(n, f);                                                       debug_helper(loc, 0, n, f);                                                       }
	ClearDepthf               :: #force_inline proc "c" (d: f32, loc := #caller_location)                                                                       {        impl_ClearDepthf(d);                                                          debug_helper(loc, 0, d);                                                          }
	GetProgramBinary          :: #force_inline proc "c" (program: u32, bufSize: i32, length: ^i32, binaryFormat: ^u32, binary: rawptr, loc := #caller_location) {        impl_GetProgramBinary(program, bufSize, length, binaryFormat, binary);        debug_helper(loc, 0, program, bufSize, length, binaryFormat, binary);             }
	ProgramBinary             :: #force_inline proc "c" (program: u32, binaryFormat: u32, binary: rawptr, length: i32, loc := #caller_location)                 {        impl_ProgramBinary(program, binaryFormat, binary, length);                    debug_helper(loc, 0, program, binaryFormat, binary, length);                      }
	ProgramParameteri         :: #force_inline proc "c" (program: u32, pname: u32, value: i32, loc := #caller_location)                                         {        impl_ProgramParameteri(program, pname, value);                                debug_helper(loc, 0, program, pname, value);                                      }
	UseProgramStages          :: #force_inline proc "c" (pipeline: u32, stages: u32, program: u32, loc := #caller_location)                                     {        impl_UseProgramStages(pipeline, stages, program);                             debug_helper(loc, 0, pipeline, stages, program);                                  }
	ActiveShaderProgram       :: #force_inline proc "c" (pipeline: u32, program: u32, loc := #caller_location)                                                  {        impl_ActiveShaderProgram(pipeline, program);                                  debug_helper(loc, 0, pipeline, program);                                          }
	CreateShaderProgramv      :: #force_inline proc "c" (type_: u32, count: i32, strings: ^u8, loc := #caller_location) -> u32                                  { ret := impl_CreateShaderProgramv(type_, count, strings);                             debug_helper(loc, 1, ret, type_, count, strings);                    return ret;; }
	BindProgramPipeline       :: #force_inline proc "c" (pipeline: u32, loc := #caller_location)                                                                {        impl_BindProgramPipeline(pipeline);                                           debug_helper(loc, 0, pipeline);                                                   }
	DeleteProgramPipelines    :: #force_inline proc "c" (n: i32, pipelines: ^u32, loc := #caller_location)                                                      {        impl_DeleteProgramPipelines(n, pipelines);                                    debug_helper(loc, 0, n, pipelines);                                               }
	GenProgramPipelines       :: #force_inline proc "c" (n: i32, pipelines: ^u32, loc := #caller_location)                                                      {        impl_GenProgramPipelines(n, pipelines);                                       debug_helper(loc, 0, n, pipelines);                                               }
	IsProgramPipeline         :: #force_inline proc "c" (pipeline: u32, loc := #caller_location) -> u8                                                          { ret := impl_IsProgramPipeline(pipeline);                                             debug_helper(loc, 1, ret, pipeline);                                 return ret;; }
	GetProgramPipelineiv      :: #force_inline proc "c" (pipeline: u32, pname: u32, params: ^i32, loc := #caller_location)                                      {        impl_GetProgramPipelineiv(pipeline, pname, params);                           debug_helper(loc, 0, pipeline, pname, params);                                    }
	ProgramUniform1i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, loc := #caller_location)                                         {        impl_ProgramUniform1i(program, location, v0);                                 debug_helper(loc, 0, program, location, v0);                                      }
	ProgramUniform1iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^i32, loc := #caller_location)                         {        impl_ProgramUniform1iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform1f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, loc := #caller_location)                                         {        impl_ProgramUniform1f(program, location, v0);                                 debug_helper(loc, 0, program, location, v0);                                      }
	ProgramUniform1fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f32, loc := #caller_location)                         {        impl_ProgramUniform1fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform1d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, loc := #caller_location)                                         {        impl_ProgramUniform1d(program, location, v0);                                 debug_helper(loc, 0, program, location, v0);                                      }
	ProgramUniform1dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f64, loc := #caller_location)                         {        impl_ProgramUniform1dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform1ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, loc := #caller_location)                                         {        impl_ProgramUniform1ui(program, location, v0);                                debug_helper(loc, 0, program, location, v0);                                      }
	ProgramUniform1uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^u32, loc := #caller_location)                         {        impl_ProgramUniform1uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform2i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, loc := #caller_location)                                {        impl_ProgramUniform2i(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1);                                  }
	ProgramUniform2iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^i32, loc := #caller_location)                         {        impl_ProgramUniform2iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform2f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, loc := #caller_location)                                {        impl_ProgramUniform2f(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1);                                  }
	ProgramUniform2fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f32, loc := #caller_location)                         {        impl_ProgramUniform2fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform2d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, loc := #caller_location)                                {        impl_ProgramUniform2d(program, location, v0, v1);                             debug_helper(loc, 0, program, location, v0, v1);                                  }
	ProgramUniform2dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f64, loc := #caller_location)                         {        impl_ProgramUniform2dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform2ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, loc := #caller_location)                                {        impl_ProgramUniform2ui(program, location, v0, v1);                            debug_helper(loc, 0, program, location, v0, v1);                                  }
	ProgramUniform2uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^u32, loc := #caller_location)                         {        impl_ProgramUniform2uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform3i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, loc := #caller_location)                       {        impl_ProgramUniform3i(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2);                              }
	ProgramUniform3iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^i32, loc := #caller_location)                         {        impl_ProgramUniform3iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform3f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, loc := #caller_location)                       {        impl_ProgramUniform3f(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2);                              }
	ProgramUniform3fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f32, loc := #caller_location)                         {        impl_ProgramUniform3fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform3d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, loc := #caller_location)                       {        impl_ProgramUniform3d(program, location, v0, v1, v2);                         debug_helper(loc, 0, program, location, v0, v1, v2);                              }
	ProgramUniform3dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f64, loc := #caller_location)                         {        impl_ProgramUniform3dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform3ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, loc := #caller_location)                       {        impl_ProgramUniform3ui(program, location, v0, v1, v2);                        debug_helper(loc, 0, program, location, v0, v1, v2);                              }
	ProgramUniform3uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^u32, loc := #caller_location)                         {        impl_ProgramUniform3uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform4i          :: #force_inline proc "c" (program: u32, location: i32, v0: i32, v1: i32, v2: i32, v3: i32, loc := #caller_location)              {        impl_ProgramUniform4i(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
	ProgramUniform4iv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^i32, loc := #caller_location)                         {        impl_ProgramUniform4iv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform4f          :: #force_inline proc "c" (program: u32, location: i32, v0: f32, v1: f32, v2: f32, v3: f32, loc := #caller_location)              {        impl_ProgramUniform4f(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
	ProgramUniform4fv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f32, loc := #caller_location)                         {        impl_ProgramUniform4fv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform4d          :: #force_inline proc "c" (program: u32, location: i32, v0: f64, v1: f64, v2: f64, v3: f64, loc := #caller_location)              {        impl_ProgramUniform4d(program, location, v0, v1, v2, v3);                     debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
	ProgramUniform4dv         :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^f64, loc := #caller_location)                         {        impl_ProgramUniform4dv(program, location, count, value);                      debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniform4ui         :: #force_inline proc "c" (program: u32, location: i32, v0: u32, v1: u32, v2: u32, v3: u32, loc := #caller_location)              {        impl_ProgramUniform4ui(program, location, v0, v1, v2, v3);                    debug_helper(loc, 0, program, location, v0, v1, v2, v3);                          }
	ProgramUniform4uiv        :: #force_inline proc "c" (program: u32, location: i32, count: i32, value: ^u32, loc := #caller_location)                         {        impl_ProgramUniform4uiv(program, location, count, value);                     debug_helper(loc, 0, program, location, count, value);                            }
	ProgramUniformMatrix2fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)          {        impl_ProgramUniformMatrix2fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix3fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)          {        impl_ProgramUniformMatrix3fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix4fv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)          {        impl_ProgramUniformMatrix4fv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix2dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)          {        impl_ProgramUniformMatrix2dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix3dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)          {        impl_ProgramUniformMatrix3dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix4dv   :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)          {        impl_ProgramUniformMatrix4dv(program, location, count, transpose, value);     debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix2x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)          {        impl_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix3x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)          {        impl_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix2x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)          {        impl_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix4x2fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)          {        impl_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix3x4fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)          {        impl_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix4x3fv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f32, loc := #caller_location)          {        impl_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix2x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)          {        impl_ProgramUniformMatrix2x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix3x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)          {        impl_ProgramUniformMatrix3x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix2x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)          {        impl_ProgramUniformMatrix2x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix4x2dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)          {        impl_ProgramUniformMatrix4x2dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix3x4dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)          {        impl_ProgramUniformMatrix3x4dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ProgramUniformMatrix4x3dv :: #force_inline proc "c" (program: u32, location: i32, count: i32, transpose: u8, value: ^f64, loc := #caller_location)          {        impl_ProgramUniformMatrix4x3dv(program, location, count, transpose, value);   debug_helper(loc, 0, program, location, count, transpose, value);                 }
	ValidateProgramPipeline   :: #force_inline proc "c" (pipeline: u32, loc := #caller_location)                                                                {        impl_ValidateProgramPipeline(pipeline);                                       debug_helper(loc, 0, pipeline);                                                   }
	GetProgramPipelineInfoLog :: #force_inline proc "c" (pipeline: u32, bufSize: i32, length: ^i32, infoLog: ^u8, loc := #caller_location)                      {        impl_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);           debug_helper(loc, 0, pipeline, bufSize, length, infoLog);                         }
	VertexAttribL1d           :: #force_inline proc "c" (index: u32, x: f64, loc := #caller_location)                                                           {        impl_VertexAttribL1d(index, x);                                               debug_helper(loc, 0, index, x);                                                   }
	VertexAttribL2d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, loc := #caller_location)                                                   {        impl_VertexAttribL2d(index, x, y);                                            debug_helper(loc, 0, index, x, y);                                                }
	VertexAttribL3d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, loc := #caller_location)                                           {        impl_VertexAttribL3d(index, x, y, z);                                         debug_helper(loc, 0, index, x, y, z);                                             }
	VertexAttribL4d           :: #force_inline proc "c" (index: u32, x: f64, y: f64, z: f64, w: f64, loc := #caller_location)                                   {        impl_VertexAttribL4d(index, x, y, z, w);                                      debug_helper(loc, 0, index, x, y, z, w);                                          }
	VertexAttribL1dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                          {        impl_VertexAttribL1dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
	VertexAttribL2dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                          {        impl_VertexAttribL2dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
	VertexAttribL3dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                          {        impl_VertexAttribL3dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
	VertexAttribL4dv          :: #force_inline proc "c" (index: u32, v: ^f64, loc := #caller_location)                                                          {        impl_VertexAttribL4dv(index, v);                                              debug_helper(loc, 0, index, v);                                                   }
	VertexAttribLPointer      :: #force_inline proc "c" (index: u32, size: i32, type_: u32, stride: i32, pointer: rawptr, loc := #caller_location)              {        impl_VertexAttribLPointer(index, size, type_, stride, pointer);               debug_helper(loc, 0, index, size, type_, stride, pointer);                        }
	GetVertexAttribLdv        :: #force_inline proc "c" (index: u32, pname: u32, params: ^f64, loc := #caller_location)                                         {        impl_GetVertexAttribLdv(index, pname, params);                                debug_helper(loc, 0, index, pname, params);                                       }
	ViewportArrayv            :: #force_inline proc "c" (first: u32, count: i32, v: ^f32, loc := #caller_location)                                              {        impl_ViewportArrayv(first, count, v);                                         debug_helper(loc, 0, first, count, v);                                            }
	ViewportIndexedf          :: #force_inline proc "c" (index: u32, x: f32, y: f32, w: f32, h: f32, loc := #caller_location)                                   {        impl_ViewportIndexedf(index, x, y, w, h);                                     debug_helper(loc, 0, index, x, y, w, h);                                          }
	ViewportIndexedfv         :: #force_inline proc "c" (index: u32, v: ^f32, loc := #caller_location)                                                          {        impl_ViewportIndexedfv(index, v);                                             debug_helper(loc, 0, index, v);                                                   }
	ScissorArrayv             :: #force_inline proc "c" (first: u32, count: i32, v: ^i32, loc := #caller_location)                                              {        impl_ScissorArrayv(first, count, v);                                          debug_helper(loc, 0, first, count, v);                                            }
	ScissorIndexed            :: #force_inline proc "c" (index: u32, left: i32, bottom: i32, width: i32, height: i32, loc := #caller_location)                  {        impl_ScissorIndexed(index, left, bottom, width, height);                      debug_helper(loc, 0, index, left, bottom, width, height);                         }
	ScissorIndexedv           :: #force_inline proc "c" (index: u32, v: ^i32, loc := #caller_location)                                                          {        impl_ScissorIndexedv(index, v);                                               debug_helper(loc, 0, index, v);                                                   }
	DepthRangeArrayv          :: #force_inline proc "c" (first: u32, count: i32, v: ^f64, loc := #caller_location)                                              {        impl_DepthRangeArrayv(first, count, v);                                       debug_helper(loc, 0, first, count, v);                                            }
	DepthRangeIndexed         :: #force_inline proc "c" (index: u32, n: f64, f: f64, loc := #caller_location)                                                   {        impl_DepthRangeIndexed(index, n, f);                                          debug_helper(loc, 0, index, n, f);                                                }
	GetFloati_v               :: #force_inline proc "c" (target: u32, index: u32, data: ^f32, loc := #caller_location)                                          {        impl_GetFloati_v(target, index, data);                                        debug_helper(loc, 0, target, index, data);                                        }
	GetDoublei_v              :: #force_inline proc "c" (target: u32, index: u32, data: ^f64, loc := #caller_location)                                          {        impl_GetDoublei_v(target, index, data);                                       debug_helper(loc, 0, target, index, data);                                        }

	// VERSION_4_2
	DrawArraysInstancedBaseInstance             :: #force_inline proc "c" (mode: u32, first: i32, count: i32, instancecount: i32, baseinstance: u32, loc := #caller_location)                                   { impl_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);                                  debug_helper(loc, 0, mode, first, count, instancecount, baseinstance);                      }
	DrawElementsInstancedBaseInstance           :: #force_inline proc "c" (mode: u32, count: i32, type_: u32, indices: rawptr, instancecount: i32, baseinstance: u32, loc := #caller_location)                  { impl_DrawElementsInstancedBaseInstance(mode, count, type_, indices, instancecount, baseinstance);                       debug_helper(loc, 0, mode, count, type_, indices, instancecount, baseinstance);             }
	DrawElementsInstancedBaseVertexBaseInstance :: #force_inline proc "c" (mode: u32, count: i32, type_: u32, indices: rawptr, instancecount: i32, basevertex: i32, baseinstance: u32, loc := #caller_location) { impl_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type_, indices, instancecount, basevertex, baseinstance); debug_helper(loc, 0, mode, count, type_, indices, instancecount, basevertex, baseinstance); }
	GetInternalformativ                         :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: ^i32, loc := #caller_location)                                   { impl_GetInternalformativ(target, internalformat, pname, bufSize, params);                                               debug_helper(loc, 0, target, internalformat, pname, bufSize, params);                       }
	GetActiveAtomicCounterBufferiv              :: #force_inline proc "c" (program: u32, bufferIndex: u32, pname: u32, params: ^i32, loc := #caller_location)                                                   { impl_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);                                               debug_helper(loc, 0, program, bufferIndex, pname, params);                                  }
	BindImageTexture                            :: #force_inline proc "c" (unit: u32, texture: u32, level: i32, layered: u8, layer: i32, access: u32, format: u32, loc := #caller_location)                     { impl_BindImageTexture(unit, texture, level, layered, layer, access, format);                                            debug_helper(loc, 0, unit, texture, level, layered, layer, access, format);                 }
	MemoryBarrier                               :: #force_inline proc "c" (barriers: u32, loc := #caller_location)                                                                                              { impl_MemoryBarrier(barriers);                                                                                           debug_helper(loc, 0, barriers);                                                             }
	TexStorage1D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, loc := #caller_location)                                                  { impl_TexStorage1D(target, levels, internalformat, width);                                                               debug_helper(loc, 0, target, levels, internalformat, width);                                }
	TexStorage2D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                     { impl_TexStorage2D(target, levels, internalformat, width, height);                                                       debug_helper(loc, 0, target, levels, internalformat, width, height);                        }
	TexStorage3D                                :: #force_inline proc "c" (target: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32, loc := #caller_location)                         { impl_TexStorage3D(target, levels, internalformat, width, height, depth);                                                debug_helper(loc, 0, target, levels, internalformat, width, height, depth);                 }
	DrawTransformFeedbackInstanced              :: #force_inline proc "c" (mode: u32, id: u32, instancecount: i32, loc := #caller_location)                                                                     { impl_DrawTransformFeedbackInstanced(mode, id, instancecount);                                                           debug_helper(loc, 0, mode, id, instancecount);                                              }
	DrawTransformFeedbackStreamInstanced        :: #force_inline proc "c" (mode: u32, id: u32, stream: u32, instancecount: i32, loc := #caller_location)                                                        { impl_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);                                             debug_helper(loc, 0, mode, id, stream, instancecount);                                      }

	// VERSION_4_3
	ClearBufferData                 :: #force_inline proc "c" (target: u32, internalformat: u32, format: u32, type_: u32, data: rawptr, loc := #caller_location)                                                                                                                                  {        impl_ClearBufferData(target, internalformat, format, type_, data);                                                                                    debug_helper(loc, 0, target, internalformat, format, type_, data);                                                                                               }
	ClearBufferSubData              :: #force_inline proc "c" (target: u32, internalformat: u32, offset: int, size: int, format: u32, type_: u32, data: rawptr, loc := #caller_location)                                                                                                          {        impl_ClearBufferSubData(target, internalformat, offset, size, format, type_, data);                                                                   debug_helper(loc, 0, target, internalformat, offset, size, format, type_, data);                                                                                 }
	DispatchCompute                 :: #force_inline proc "c" (num_groups_x: u32, num_groups_y: u32, num_groups_z: u32, loc := #caller_location)                                                                                                                                                  {        impl_DispatchCompute(num_groups_x, num_groups_y, num_groups_z);                                                                                       debug_helper(loc, 0, num_groups_x, num_groups_y, num_groups_z);                                                                                                  }
	DispatchComputeIndirect         :: #force_inline proc "c" (indirect: int, loc := #caller_location)                                                                                                                                                                                            {        impl_DispatchComputeIndirect(indirect);                                                                                                               debug_helper(loc, 0, indirect);                                                                                                                                  }
	CopyImageSubData                :: #force_inline proc "c" (srcName: u32, srcTarget: u32, srcLevel: i32, srcX: i32, srcY: i32, srcZ: i32, dstName: u32, dstTarget: u32, dstLevel: i32, dstX: i32, dstY: i32, dstZ: i32, srcWidth: i32, srcHeight: i32, srcDepth: i32, loc := #caller_location) {        impl_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); debug_helper(loc, 0, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);             }
	FramebufferParameteri           :: #force_inline proc "c" (target: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                                                                      {        impl_FramebufferParameteri(target, pname, param);                                                                                                     debug_helper(loc, 0, target, pname, param);                                                                                                                      }
	GetFramebufferParameteriv       :: #force_inline proc "c" (target: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                                                                                                    {        impl_GetFramebufferParameteriv(target, pname, params);                                                                                                debug_helper(loc, 0, target, pname, params);                                                                                                                     }
	GetInternalformati64v           :: #force_inline proc "c" (target: u32, internalformat: u32, pname: u32, bufSize: i32, params: ^i64, loc := #caller_location)                                                                                                                                 {        impl_GetInternalformati64v(target, internalformat, pname, bufSize, params);                                                                           debug_helper(loc, 0, target, internalformat, pname, bufSize, params);                                                                                            }
	InvalidateTexSubImage           :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, loc := #caller_location)                                                                                                  {        impl_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);                                                          debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth);                                                                           }
	InvalidateTexImage              :: #force_inline proc "c" (texture: u32, level: i32, loc := #caller_location)                                                                                                                                                                                 {        impl_InvalidateTexImage(texture, level);                                                                                                              debug_helper(loc, 0, texture, level);                                                                                                                            }
	InvalidateBufferSubData         :: #force_inline proc "c" (buffer: u32, offset: int, length: int, loc := #caller_location)                                                                                                                                                                    {        impl_InvalidateBufferSubData(buffer, offset, length);                                                                                                 debug_helper(loc, 0, buffer, offset, length);                                                                                                                    }
	InvalidateBufferData            :: #force_inline proc "c" (buffer: u32, loc := #caller_location)                                                                                                                                                                                              {        impl_InvalidateBufferData(buffer);                                                                                                                    debug_helper(loc, 0, buffer);                                                                                                                                    }
	InvalidateFramebuffer           :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: ^u32, loc := #caller_location)                                                                                                                                                      {        impl_InvalidateFramebuffer(target, numAttachments, attachments);                                                                                      debug_helper(loc, 0, target, numAttachments, attachments);                                                                                                       }
	InvalidateSubFramebuffer        :: #force_inline proc "c" (target: u32, numAttachments: i32, attachments: ^u32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                                                             {        impl_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);                                                              debug_helper(loc, 0, target, numAttachments, attachments, x, y, width, height);                                                                                  }
	MultiDrawArraysIndirect         :: #force_inline proc "c" (mode: u32, indirect: rawptr, drawcount: i32, stride: i32, loc := #caller_location)                                                                                                                                                 {        impl_MultiDrawArraysIndirect(mode, indirect, drawcount, stride);                                                                                      debug_helper(loc, 0, mode, indirect, drawcount, stride);                                                                                                         }
	MultiDrawElementsIndirect       :: #force_inline proc "c" (mode: u32, type_: u32, indirect: rawptr, drawcount: i32, stride: i32, loc := #caller_location)                                                                                                                                     {        impl_MultiDrawElementsIndirect(mode, type_, indirect, drawcount, stride);                                                                             debug_helper(loc, 0, mode, type_, indirect, drawcount, stride);                                                                                                  }
	GetProgramInterfaceiv           :: #force_inline proc "c" (program: u32, programInterface: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                                                                            {        impl_GetProgramInterfaceiv(program, programInterface, pname, params);                                                                                 debug_helper(loc, 0, program, programInterface, pname, params);                                                                                                  }
	GetProgramResourceIndex         :: #force_inline proc "c" (program: u32, programInterface: u32, name: ^u8, loc := #caller_location) -> u32                                                                                                                                                    { ret := impl_GetProgramResourceIndex(program, programInterface, name);                                                                                        debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret; }
	GetProgramResourceName          :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, bufSize: i32, length: ^i32, name: ^u8, loc := #caller_location)                                                                                                                   {        impl_GetProgramResourceName(program, programInterface, index, bufSize, length, name);                                                                 debug_helper(loc, 0, program, programInterface, index, bufSize, length, name);                                                                                   }
	GetProgramResourceiv            :: #force_inline proc "c" (program: u32, programInterface: u32, index: u32, propCount: i32, props: ^u32, bufSize: i32, length: ^i32, params: ^i32, loc := #caller_location)                                                                                   {        impl_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);                                               debug_helper(loc, 0, program, programInterface, index, propCount, props, bufSize, length, params);                                                               }
	GetProgramResourceLocation      :: #force_inline proc "c" (program: u32, programInterface: u32, name: ^u8, loc := #caller_location) -> i32                                                                                                                                                    { ret := impl_GetProgramResourceLocation(program, programInterface, name);                                                                                     debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret; }
	GetProgramResourceLocationIndex :: #force_inline proc "c" (program: u32, programInterface: u32, name: ^u8, loc := #caller_location) -> i32                                                                                                                                                    { ret := impl_GetProgramResourceLocationIndex(program, programInterface, name);                                                                                debug_helper(loc, 1, ret, program, programInterface, name);                                                                                          return ret; }
	ShaderStorageBlockBinding       :: #force_inline proc "c" (program: u32, storageBlockIndex: u32, storageBlockBinding: u32, loc := #caller_location)                                                                                                                                           {        impl_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);                                                                      debug_helper(loc, 0, program, storageBlockIndex, storageBlockBinding);                                                                                           }
	TexBufferRange                  :: #force_inline proc "c" (target: u32, internalformat: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                                                                    {        impl_TexBufferRange(target, internalformat, buffer, offset, size);                                                                                    debug_helper(loc, 0, target, internalformat, buffer, offset, size);                                                                                              }
	TexStorage2DMultisample         :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8, loc := #caller_location)                                                                                                        {        impl_TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);                                                   debug_helper(loc, 0, target, samples, internalformat, width, height, fixedsamplelocations);                                                                      }
	TexStorage3DMultisample         :: #force_inline proc "c" (target: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8, loc := #caller_location)                                                                                            {        impl_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);                                            debug_helper(loc, 0, target, samples, internalformat, width, height, depth, fixedsamplelocations);                                                               }
	TextureView                     :: #force_inline proc "c" (texture: u32, target: u32, origtexture: u32, internalformat: u32, minlevel: u32, numlevels: u32, minlayer: u32, numlayers: u32, loc := #caller_location)                                                                           {        impl_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);                                             debug_helper(loc, 0, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);                                                    }
	BindVertexBuffer                :: #force_inline proc "c" (bindingindex: u32, buffer: u32, offset: int, stride: i32, loc := #caller_location)                                                                                                                                                 {        impl_BindVertexBuffer(bindingindex, buffer, offset, stride);                                                                                          debug_helper(loc, 0, bindingindex, buffer, offset, stride);                                                                                                      }
	VertexAttribFormat              :: #force_inline proc "c" (attribindex: u32, size: i32, type_: u32, normalized: u8, relativeoffset: u32, loc := #caller_location)                                                                                                                             {        impl_VertexAttribFormat(attribindex, size, type_, normalized, relativeoffset);                                                                        debug_helper(loc, 0, attribindex, size, type_, normalized, relativeoffset);                                                                                      }
	VertexAttribIFormat             :: #force_inline proc "c" (attribindex: u32, size: i32, type_: u32, relativeoffset: u32, loc := #caller_location)                                                                                                                                             {        impl_VertexAttribIFormat(attribindex, size, type_, relativeoffset);                                                                                   debug_helper(loc, 0, attribindex, size, type_, relativeoffset);                                                                                                  }
	VertexAttribLFormat             :: #force_inline proc "c" (attribindex: u32, size: i32, type_: u32, relativeoffset: u32, loc := #caller_location)                                                                                                                                             {        impl_VertexAttribLFormat(attribindex, size, type_, relativeoffset);                                                                                   debug_helper(loc, 0, attribindex, size, type_, relativeoffset);                                                                                                  }
	VertexAttribBinding             :: #force_inline proc "c" (attribindex: u32, bindingindex: u32, loc := #caller_location)                                                                                                                                                                      {        impl_VertexAttribBinding(attribindex, bindingindex);                                                                                                  debug_helper(loc, 0, attribindex, bindingindex);                                                                                                                 }
	VertexBindingDivisor            :: #force_inline proc "c" (bindingindex: u32, divisor: u32, loc := #caller_location)                                                                                                                                                                          {        impl_VertexBindingDivisor(bindingindex, divisor);                                                                                                     debug_helper(loc, 0, bindingindex, divisor);                                                                                                                     }
	DebugMessageControl             :: #force_inline proc "c" (source: u32, type_: u32, severity: u32, count: i32, ids: ^u32, enabled: u8, loc := #caller_location)                                                                                                                               {        impl_DebugMessageControl(source, type_, severity, count, ids, enabled);                                                                               debug_helper(loc, 0, source, type_, severity, count, ids, enabled);                                                                                              }
	DebugMessageInsert              :: #force_inline proc "c" (source: u32, type_: u32, id: u32, severity: u32, length: i32, buf: ^u8, loc := #caller_location)                                                                                                                                   {        impl_DebugMessageInsert(source, type_, id, severity, length, buf);                                                                                    debug_helper(loc, 0, source, type_, id, severity, length, buf);                                                                                                  }
	DebugMessageCallback            :: #force_inline proc "c" (callback: debug_proc_t, userParam: rawptr, loc := #caller_location)                                                                                                                                                                {        impl_DebugMessageCallback(callback, userParam);                                                                                                       debug_helper(loc, 0, callback, userParam);                                                                                                                       }
	GetDebugMessageLog              :: #force_inline proc "c" (count: u32, bufSize: i32, sources: ^u32, types: ^u32, ids: ^u32, severities: ^u32, lengths: ^i32, messageLog: ^u8, loc := #caller_location) -> u32                                                                                 { ret := impl_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                        debug_helper(loc, 1, ret, count, bufSize, sources, types, ids, severities, lengths, messageLog);                                                     return ret; }
	PushDebugGroup                  :: #force_inline proc "c" (source: u32, id: u32, length: i32, message: cstring, loc := #caller_location)                                                                                                                                                          {        impl_PushDebugGroup(source, id, length, message);                                                                                                     debug_helper(loc, 0, source, id, length, message);                                                                                                               }
	PopDebugGroup                   :: #force_inline proc "c" (loc := #caller_location)                                                                                                                                                                                                           {        impl_PopDebugGroup();                                                                                                                                 debug_helper(loc, 0);                                                                                                                                            }
	ObjectLabel                     :: #force_inline proc "c" (identifier: u32, name: u32, length: i32, label: ^u8, loc := #caller_location)                                                                                                                                                      {        impl_ObjectLabel(identifier, name, length, label);                                                                                                    debug_helper(loc, 0, identifier, name, length, label);                                                                                                           }
	GetObjectLabel                  :: #force_inline proc "c" (identifier: u32, name: u32, bufSize: i32, length: ^i32, label: ^u8, loc := #caller_location)                                                                                                                                       {        impl_GetObjectLabel(identifier, name, bufSize, length, label);                                                                                        debug_helper(loc, 0, identifier, name, bufSize, length, label);                                                                                                  }
	ObjectPtrLabel                  :: #force_inline proc "c" (ptr: rawptr, length: i32, label: ^u8, loc := #caller_location)                                                                                                                                                                     {        impl_ObjectPtrLabel(ptr, length, label);                                                                                                              debug_helper(loc, 0, ptr, length, label);                                                                                                                        }
	GetObjectPtrLabel               :: #force_inline proc "c" (ptr: rawptr, bufSize: i32, length: ^i32, label: ^u8, loc := #caller_location)                                                                                                                                                      {        impl_GetObjectPtrLabel(ptr, bufSize, length, label);                                                                                                  debug_helper(loc, 0, ptr, bufSize, length, label);                                                                                                               }

	// VERSION_4_4
	BufferStorage     :: #force_inline proc "c" (target: u32, size: int, data: rawptr, flags: u32, loc := #caller_location)                                                                                               { impl_BufferStorage(target, size, data, flags);                                                               debug_helper(loc, 0, target, size, data, flags);                                                            }
	ClearTexImage     :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type_: u32, data: rawptr, loc := #caller_location)                                                                                { impl_ClearTexImage(texture, level, format, type_, data);                                                     debug_helper(loc, 0, texture, level, format, type_, data);                                                  }
	ClearTexSubImage  :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type_: u32, data: rawptr, loc := #caller_location) { impl_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, data); debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, data); }
	BindBuffersBase   :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: ^u32, loc := #caller_location)                                                                                             { impl_BindBuffersBase(target, first, count, buffers);                                                         debug_helper(loc, 0, target, first, count, buffers);                                                        }
	BindBuffersRange  :: #force_inline proc "c" (target: u32, first: u32, count: i32, buffers: ^u32, offsets: ^int, sizes: ^int, loc := #caller_location)                                                                 { impl_BindBuffersRange(target, first, count, buffers, offsets, sizes);                                        debug_helper(loc, 0, target, first, count, buffers, offsets, sizes);                                        }
	BindTextures      :: #force_inline proc "c" (first: u32, count: i32, textures: ^u32, loc := #caller_location)                                                                                                         { impl_BindTextures(first, count, textures);                                                                   debug_helper(loc, 0, first, count, textures);                                                               }
	BindSamplers      :: #force_inline proc "c" (first: u32, count: i32, samplers: ^u32, loc := #caller_location)                                                                                                         { impl_BindSamplers(first, count, samplers);                                                                   debug_helper(loc, 0, first, count, samplers);                                                               }
	BindImageTextures :: #force_inline proc "c" (first: u32, count: i32, textures: ^u32, loc := #caller_location)                                                                                                         { impl_BindImageTextures(first, count, textures);                                                              debug_helper(loc, 0, first, count, textures);                                                               }
	BindVertexBuffers :: #force_inline proc "c" (first: u32, count: i32, buffers: ^u32, offsets: ^int, strides: ^i32, loc := #caller_location)                                                                            { impl_BindVertexBuffers(first, count, buffers, offsets, strides);                                             debug_helper(loc, 0, first, count, buffers, offsets, strides);                                              }

	// VERSION_4_5
	ClipControl                              :: #force_inline proc "c" (origin: u32, depth: u32, loc := #caller_location)                                                                                                                                            {        impl_ClipControl(origin, depth);                                                                                                   debug_helper(loc, 0, origin, depth);                                                                                                      }
	CreateTransformFeedbacks                 :: #force_inline proc "c" (n: i32, ids: ^u32, loc := #caller_location)                                                                                                                                                  {        impl_CreateTransformFeedbacks(n, ids);                                                                                             debug_helper(loc, 0, n, ids);                                                                                                             }
	TransformFeedbackBufferBase              :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32, loc := #caller_location)                                                                                                                                  {        impl_TransformFeedbackBufferBase(xfb, index, buffer);                                                                              debug_helper(loc, 0, xfb, index, buffer);                                                                                                 }
	TransformFeedbackBufferRange             :: #force_inline proc "c" (xfb: u32, index: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                                          {        impl_TransformFeedbackBufferRange(xfb, index, buffer, offset, size);                                                               debug_helper(loc, 0, xfb, index, buffer, offset, size);                                                                                   }
	GetTransformFeedbackiv                   :: #force_inline proc "c" (xfb: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                                  {        impl_GetTransformFeedbackiv(xfb, pname, param);                                                                                    debug_helper(loc, 0, xfb, pname, param);                                                                                                  }
	GetTransformFeedbacki_v                  :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i32, loc := #caller_location)                                                                                                                      {        impl_GetTransformFeedbacki_v(xfb, pname, index, param);                                                                            debug_helper(loc, 0, xfb, pname, index, param);                                                                                           }
	GetTransformFeedbacki64_v                :: #force_inline proc "c" (xfb: u32, pname: u32, index: u32, param: ^i64, loc := #caller_location)                                                                                                                      {        impl_GetTransformFeedbacki64_v(xfb, pname, index, param);                                                                          debug_helper(loc, 0, xfb, pname, index, param);                                                                                           }
	CreateBuffers                            :: #force_inline proc "c" (n: i32, buffers: ^u32, loc := #caller_location)                                                                                                                                              {        impl_CreateBuffers(n, buffers);                                                                                                    debug_helper(loc, 0, n, buffers);                                                                                                         }
	NamedBufferStorage                       :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, flags: u32, loc := #caller_location)                                                                                                                   {        impl_NamedBufferStorage(buffer, size, data, flags);                                                                                debug_helper(loc, 0, buffer, size, data, flags);                                                                                          }
	NamedBufferData                          :: #force_inline proc "c" (buffer: u32, size: int, data: rawptr, usage: u32, loc := #caller_location)                                                                                                                   {        impl_NamedBufferData(buffer, size, data, usage);                                                                                   debug_helper(loc, 0, buffer, size, data, usage);                                                                                          }
	NamedBufferSubData                       :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr, loc := #caller_location)                                                                                                                  {        impl_NamedBufferSubData(buffer, offset, size, data);                                                                               debug_helper(loc, 0, buffer, offset, size, data);                                                                                         }
	CopyNamedBufferSubData                   :: #force_inline proc "c" (readBuffer: u32, writeBuffer: u32, readOffset: int, writeOffset: int, size: int, loc := #caller_location)                                                                                    {        impl_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);                                               debug_helper(loc, 0, readBuffer, writeBuffer, readOffset, writeOffset, size);                                                             }
	ClearNamedBufferData                     :: #force_inline proc "c" (buffer: u32, internalformat: u32, format: u32, type_: u32, data: rawptr, loc := #caller_location)                                                                                            {        impl_ClearNamedBufferData(buffer, internalformat, format, type_, data);                                                            debug_helper(loc, 0, buffer, internalformat, format, type_, data);                                                                        }
	ClearNamedBufferSubData                  :: #force_inline proc "c" (buffer: u32, internalformat: u32, offset: int, size: int, format: u32, type_: u32, data: rawptr, loc := #caller_location)                                                                    {        impl_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type_, data);                                           debug_helper(loc, 0, buffer, internalformat, offset, size, format, type_, data);                                                          }
	MapNamedBuffer                           :: #force_inline proc "c" (buffer: u32, access: u32, loc := #caller_location) -> rawptr                                                                                                                                 { ret := impl_MapNamedBuffer(buffer, access);                                                                                               debug_helper(loc, 1, ret, buffer, access);                                                                                    return ret; }
	MapNamedBufferRange                      :: #force_inline proc "c" (buffer: u32, offset: int, length: int, access: u32, loc := #caller_location) -> rawptr                                                                                                       { ret := impl_MapNamedBufferRange(buffer, offset, length, access);                                                                          debug_helper(loc, 1, ret, buffer, offset, length, access);                                                                    return ret; }
	UnmapNamedBuffer                         :: #force_inline proc "c" (buffer: u32, loc := #caller_location) -> u8                                                                                                                                                  { ret := impl_UnmapNamedBuffer(buffer);                                                                                                     debug_helper(loc, 1, ret, buffer);                                                                                            return ret; }
	FlushMappedNamedBufferRange              :: #force_inline proc "c" (buffer: u32, offset: int, length: int, loc := #caller_location)                                                                                                                              {        impl_FlushMappedNamedBufferRange(buffer, offset, length);                                                                          debug_helper(loc, 0, buffer, offset, length);                                                                                             }
	GetNamedBufferParameteriv                :: #force_inline proc "c" (buffer: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                                                              {        impl_GetNamedBufferParameteriv(buffer, pname, params);                                                                             debug_helper(loc, 0, buffer, pname, params);                                                                                              }
	GetNamedBufferParameteri64v              :: #force_inline proc "c" (buffer: u32, pname: u32, params: ^i64, loc := #caller_location)                                                                                                                              {        impl_GetNamedBufferParameteri64v(buffer, pname, params);                                                                           debug_helper(loc, 0, buffer, pname, params);                                                                                              }
	GetNamedBufferPointerv                   :: #force_inline proc "c" (buffer: u32, pname: u32, params: ^rawptr, loc := #caller_location)                                                                                                                           {        impl_GetNamedBufferPointerv(buffer, pname, params);                                                                                debug_helper(loc, 0, buffer, pname, params);                                                                                              }
	GetNamedBufferSubData                    :: #force_inline proc "c" (buffer: u32, offset: int, size: int, data: rawptr, loc := #caller_location)                                                                                                                  {        impl_GetNamedBufferSubData(buffer, offset, size, data);                                                                            debug_helper(loc, 0, buffer, offset, size, data);                                                                                         }
	CreateFramebuffers                       :: #force_inline proc "c" (n: i32, framebuffers: ^u32, loc := #caller_location)                                                                                                                                         {        impl_CreateFramebuffers(n, framebuffers);                                                                                          debug_helper(loc, 0, n, framebuffers);                                                                                                    }
	NamedFramebufferRenderbuffer             :: #force_inline proc "c" (framebuffer: u32, attachment: u32, renderbuffertarget: u32, renderbuffer: u32, loc := #caller_location)                                                                                      {        impl_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);                                      debug_helper(loc, 0, framebuffer, attachment, renderbuffertarget, renderbuffer);                                                          }
	NamedFramebufferParameteri               :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                           {        impl_NamedFramebufferParameteri(framebuffer, pname, param);                                                                        debug_helper(loc, 0, framebuffer, pname, param);                                                                                          }
	NamedFramebufferTexture                  :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, loc := #caller_location)                                                                                                        {        impl_NamedFramebufferTexture(framebuffer, attachment, texture, level);                                                             debug_helper(loc, 0, framebuffer, attachment, texture, level);                                                                            }
	NamedFramebufferTextureLayer             :: #force_inline proc "c" (framebuffer: u32, attachment: u32, texture: u32, level: i32, layer: i32, loc := #caller_location)                                                                                            {        impl_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);                                                 debug_helper(loc, 0, framebuffer, attachment, texture, level, layer);                                                                     }
	NamedFramebufferDrawBuffer               :: #force_inline proc "c" (framebuffer: u32, buf: u32, loc := #caller_location)                                                                                                                                         {        impl_NamedFramebufferDrawBuffer(framebuffer, buf);                                                                                 debug_helper(loc, 0, framebuffer, buf);                                                                                                   }
	NamedFramebufferDrawBuffers              :: #force_inline proc "c" (framebuffer: u32, n: i32, bufs: ^u32, loc := #caller_location)                                                                                                                               {        impl_NamedFramebufferDrawBuffers(framebuffer, n, bufs);                                                                            debug_helper(loc, 0, framebuffer, n, bufs);                                                                                               }
	NamedFramebufferReadBuffer               :: #force_inline proc "c" (framebuffer: u32, src: u32, loc := #caller_location)                                                                                                                                         {        impl_NamedFramebufferReadBuffer(framebuffer, src);                                                                                 debug_helper(loc, 0, framebuffer, src);                                                                                                   }
	InvalidateNamedFramebufferData           :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: ^u32, loc := #caller_location)                                                                                                           {        impl_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);                                                     debug_helper(loc, 0, framebuffer, numAttachments, attachments);                                                                           }
	InvalidateNamedFramebufferSubData        :: #force_inline proc "c" (framebuffer: u32, numAttachments: i32, attachments: ^u32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                  {        impl_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);                             debug_helper(loc, 0, framebuffer, numAttachments, attachments, x, y, width, height);                                                      }
	ClearNamedFramebufferiv                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^i32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);                                                              debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value);                                                                             }
	ClearNamedFramebufferuiv                 :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^u32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);                                                             debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value);                                                                             }
	ClearNamedFramebufferfv                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, value: ^f32, loc := #caller_location)                                                                                                        {        impl_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);                                                              debug_helper(loc, 0, framebuffer, buffer, drawbuffer, value);                                                                             }
	ClearNamedFramebufferfi                  :: #force_inline proc "c" (framebuffer: u32, buffer: u32, drawbuffer: i32, depth: f32, stencil: i32, loc := #caller_location)                                                                                           {        impl_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);                                                     debug_helper(loc, 0, framebuffer, buffer, drawbuffer, depth, stencil);                                                                    }
	BlitNamedFramebuffer                     :: #force_inline proc "c" (readFramebuffer: u32, drawFramebuffer: u32, srcX0: i32, srcY0: i32, srcX1: i32, srcY1: i32, dstX0: i32, dstY0: i32, dstX1: i32, dstY1: i32, mask: u32, filter: u32, loc := #caller_location) {        impl_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); debug_helper(loc, 0, readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);             }
	CheckNamedFramebufferStatus              :: #force_inline proc "c" (framebuffer: u32, target: u32, loc := #caller_location) -> u32                                                                                                                               { ret := impl_CheckNamedFramebufferStatus(framebuffer, target);                                                                             debug_helper(loc, 1, ret, framebuffer, target); return ret;                                                                               }
	GetNamedFramebufferParameteriv           :: #force_inline proc "c" (framebuffer: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                          {        impl_GetNamedFramebufferParameteriv(framebuffer, pname, param);                                                                    debug_helper(loc, 0, framebuffer, pname, param);                                                                                          }
	GetNamedFramebufferAttachmentParameteriv :: #force_inline proc "c" (framebuffer: u32, attachment: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                                        {        impl_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);                                             debug_helper(loc, 0, framebuffer, attachment, pname, params);                                                                             }
	CreateRenderbuffers                      :: #force_inline proc "c" (n: i32, renderbuffers: ^u32, loc := #caller_location)                                                                                                                                        {        impl_CreateRenderbuffers(n, renderbuffers);                                                                                        debug_helper(loc, 0, n, renderbuffers);                                                                                                   }
	NamedRenderbufferStorage                 :: #force_inline proc "c" (renderbuffer: u32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                                    {        impl_NamedRenderbufferStorage(renderbuffer, internalformat, width, height);                                                        debug_helper(loc, 0, renderbuffer, internalformat, width, height);                                                                        }
	NamedRenderbufferStorageMultisample      :: #force_inline proc "c" (renderbuffer: u32, samples: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                      {        impl_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);                                    debug_helper(loc, 0, renderbuffer, samples, internalformat, width, height);                                                               }
	GetNamedRenderbufferParameteriv          :: #force_inline proc "c" (renderbuffer: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                                                        {        impl_GetNamedRenderbufferParameteriv(renderbuffer, pname, params);                                                                 debug_helper(loc, 0, renderbuffer, pname, params);                                                                                        }
	CreateTextures                           :: #force_inline proc "c" (target: u32, n: i32, textures: ^u32, loc := #caller_location)                                                                                                                                {        impl_CreateTextures(target, n, textures);                                                                                          debug_helper(loc, 0, target, n, textures);                                                                                                }
	TextureBuffer                            :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32, loc := #caller_location)                                                                                                                     {        impl_TextureBuffer(texture, internalformat, buffer);                                                                               debug_helper(loc, 0, texture, internalformat, buffer);                                                                                    }
	TextureBufferRange                       :: #force_inline proc "c" (texture: u32, internalformat: u32, buffer: u32, offset: int, size: int, loc := #caller_location)                                                                                             {        impl_TextureBufferRange(texture, internalformat, buffer, offset, size);                                                            debug_helper(loc, 0, texture, internalformat, buffer, offset, size);                                                                      }
	TextureStorage1D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, loc := #caller_location)                                                                                                         {        impl_TextureStorage1D(texture, levels, internalformat, width);                                                                     debug_helper(loc, 0, texture, levels, internalformat, width);                                                                             }
	TextureStorage2D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, loc := #caller_location)                                                                                            {        impl_TextureStorage2D(texture, levels, internalformat, width, height);                                                             debug_helper(loc, 0, texture, levels, internalformat, width, height);                                                                     }
	TextureStorage3D                         :: #force_inline proc "c" (texture: u32, levels: i32, internalformat: u32, width: i32, height: i32, depth: i32, loc := #caller_location)                                                                                {        impl_TextureStorage3D(texture, levels, internalformat, width, height, depth);                                                      debug_helper(loc, 0, texture, levels, internalformat, width, height, depth);                                                              }
	TextureStorage2DMultisample              :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, fixedsamplelocations: u8, loc := #caller_location)                                                                 {        impl_TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);                           debug_helper(loc, 0, texture, samples, internalformat, width, height, fixedsamplelocations);                                              }
	TextureStorage3DMultisample              :: #force_inline proc "c" (texture: u32, samples: i32, internalformat: u32, width: i32, height: i32, depth: i32, fixedsamplelocations: u8, loc := #caller_location)                                                     {        impl_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);                    debug_helper(loc, 0, texture, samples, internalformat, width, height, depth, fixedsamplelocations);                                       }
	TextureSubImage1D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, type_: u32, pixels: rawptr, loc := #caller_location)                                                                        {        impl_TextureSubImage1D(texture, level, xoffset, width, format, type_, pixels);                                                     debug_helper(loc, 0, texture, level, xoffset, width, format, type_, pixels);                                                              }
	TextureSubImage2D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, type_: u32, pixels: rawptr, loc := #caller_location)                                             {        impl_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type_, pixels);                                    debug_helper(loc, 0, texture, level, xoffset, yoffset, width, height, format, type_, pixels);                                             }
	TextureSubImage3D                        :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type_: u32, pixels: rawptr, loc := #caller_location)                   {        impl_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, pixels);                    debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, pixels);                             }
	CompressedTextureSubImage1D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, width: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                                                      {        impl_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);                                         debug_helper(loc, 0, texture, level, xoffset, width, format, imageSize, data);                                                            }
	CompressedTextureSubImage2D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, width: i32, height: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                                           {        impl_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);                        debug_helper(loc, 0, texture, level, xoffset, yoffset, width, height, format, imageSize, data);                                           }
	CompressedTextureSubImage3D              :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, imageSize: i32, data: rawptr, loc := #caller_location)                 {        impl_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);        debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);                           }
	CopyTextureSubImage1D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, x: i32, y: i32, width: i32, loc := #caller_location)                                                                                                 {        impl_CopyTextureSubImage1D(texture, level, xoffset, x, y, width);                                                                  debug_helper(loc, 0, texture, level, xoffset, x, y, width);                                                                               }
	CopyTextureSubImage2D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                                      {        impl_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);                                                 debug_helper(loc, 0, texture, level, xoffset, yoffset, x, y, width, height);                                                              }
	CopyTextureSubImage3D                    :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, x: i32, y: i32, width: i32, height: i32, loc := #caller_location)                                                        {        impl_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);                                        debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, x, y, width, height);                                                     }
	TextureParameterf                        :: #force_inline proc "c" (texture: u32, pname: u32, param: f32, loc := #caller_location)                                                                                                                               {        impl_TextureParameterf(texture, pname, param);                                                                                     debug_helper(loc, 0, texture, pname, param);                                                                                              }
	TextureParameterfv                       :: #force_inline proc "c" (texture: u32, pname: u32, param: ^f32, loc := #caller_location)                                                                                                                              {        impl_TextureParameterfv(texture, pname, param);                                                                                    debug_helper(loc, 0, texture, pname, param);                                                                                              }
	TextureParameteri                        :: #force_inline proc "c" (texture: u32, pname: u32, param: i32, loc := #caller_location)                                                                                                                               {        impl_TextureParameteri(texture, pname, param);                                                                                     debug_helper(loc, 0, texture, pname, param);                                                                                              }
	TextureParameterIiv                      :: #force_inline proc "c" (texture: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                                                             {        impl_TextureParameterIiv(texture, pname, params);                                                                                  debug_helper(loc, 0, texture, pname, params);                                                                                             }
	TextureParameterIuiv                     :: #force_inline proc "c" (texture: u32, pname: u32, params: ^u32, loc := #caller_location)                                                                                                                             {        impl_TextureParameterIuiv(texture, pname, params);                                                                                 debug_helper(loc, 0, texture, pname, params);                                                                                             }
	TextureParameteriv                       :: #force_inline proc "c" (texture: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                              {        impl_TextureParameteriv(texture, pname, param);                                                                                    debug_helper(loc, 0, texture, pname, param);                                                                                              }
	GenerateTextureMipmap                    :: #force_inline proc "c" (texture: u32, loc := #caller_location)                                                                                                                                                       {        impl_GenerateTextureMipmap(texture);                                                                                               debug_helper(loc, 0, texture);                                                                                                            }
	BindTextureUnit                          :: #force_inline proc "c" (unit: u32, texture: u32, loc := #caller_location)                                                                                                                                            {        impl_BindTextureUnit(unit, texture);                                                                                               debug_helper(loc, 0, unit, texture);                                                                                                      }
	GetTextureImage                          :: #force_inline proc "c" (texture: u32, level: i32, format: u32, type_: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                    {        impl_GetTextureImage(texture, level, format, type_, bufSize, pixels);                                                              debug_helper(loc, 0, texture, level, format, type_, bufSize, pixels);                                                                     }
	GetCompressedTextureImage                :: #force_inline proc "c" (texture: u32, level: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                                             {        impl_GetCompressedTextureImage(texture, level, bufSize, pixels);                                                                   debug_helper(loc, 0, texture, level, bufSize, pixels);                                                                                    }
	GetTextureLevelParameterfv               :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: ^f32, loc := #caller_location)                                                                                                                 {        impl_GetTextureLevelParameterfv(texture, level, pname, params);                                                                    debug_helper(loc, 0, texture, level, pname, params);                                                                                      }
	GetTextureLevelParameteriv               :: #force_inline proc "c" (texture: u32, level: i32, pname: u32, params: ^i32, loc := #caller_location)                                                                                                                 {        impl_GetTextureLevelParameteriv(texture, level, pname, params);                                                                    debug_helper(loc, 0, texture, level, pname, params);                                                                                      }
	GetTextureParameterfv                    :: #force_inline proc "c" (texture: u32, pname: u32, params: ^f32, loc := #caller_location)                                                                                                                             {        impl_GetTextureParameterfv(texture, pname, params);                                                                                debug_helper(loc, 0, texture, pname, params);                                                                                             }
	GetTextureParameterIiv                   :: #force_inline proc "c" (texture: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                                                             {        impl_GetTextureParameterIiv(texture, pname, params);                                                                               debug_helper(loc, 0, texture, pname, params);                                                                                             }
	GetTextureParameterIuiv                  :: #force_inline proc "c" (texture: u32, pname: u32, params: ^u32, loc := #caller_location)                                                                                                                             {        impl_GetTextureParameterIuiv(texture, pname, params);                                                                              debug_helper(loc, 0, texture, pname, params);                                                                                             }
	GetTextureParameteriv                    :: #force_inline proc "c" (texture: u32, pname: u32, params: ^i32, loc := #caller_location)                                                                                                                             {        impl_GetTextureParameteriv(texture, pname, params);                                                                                debug_helper(loc, 0, texture, pname, params);                                                                                             }
	CreateVertexArrays                       :: #force_inline proc "c" (n: i32, arrays: ^u32, loc := #caller_location)                                                                                                                                               {        impl_CreateVertexArrays(n, arrays);                                                                                                debug_helper(loc, 0, n, arrays);                                                                                                          }
	DisableVertexArrayAttrib                 :: #force_inline proc "c" (vaobj: u32, index: u32, loc := #caller_location)                                                                                                                                             {        impl_DisableVertexArrayAttrib(vaobj, index);                                                                                       debug_helper(loc, 0, vaobj, index);                                                                                                       }
	EnableVertexArrayAttrib                  :: #force_inline proc "c" (vaobj: u32, index: u32, loc := #caller_location)                                                                                                                                             {        impl_EnableVertexArrayAttrib(vaobj, index);                                                                                        debug_helper(loc, 0, vaobj, index);                                                                                                       }
	VertexArrayElementBuffer                 :: #force_inline proc "c" (vaobj: u32, buffer: u32, loc := #caller_location)                                                                                                                                            {        impl_VertexArrayElementBuffer(vaobj, buffer);                                                                                      debug_helper(loc, 0, vaobj, buffer);                                                                                                      }
	VertexArrayVertexBuffer                  :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, buffer: u32, offset: int, stride: i32, loc := #caller_location)                                                                                               {        impl_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);                                                         debug_helper(loc, 0, vaobj, bindingindex, buffer, offset, stride);                                                                        }
	VertexArrayVertexBuffers                 :: #force_inline proc "c" (vaobj: u32, first: u32, count: i32, buffers: ^u32, offsets: ^int, strides: ^i32, loc := #caller_location)                                                                                    {        impl_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);                                                     debug_helper(loc, 0, vaobj, first, count, buffers, offsets, strides);                                                                     }
	VertexArrayAttribBinding                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, bindingindex: u32, loc := #caller_location)                                                                                                                    {        impl_VertexArrayAttribBinding(vaobj, attribindex, bindingindex);                                                                   debug_helper(loc, 0, vaobj, attribindex, bindingindex);                                                                                   }
	VertexArrayAttribFormat                  :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type_: u32, normalized: u8, relativeoffset: u32, loc := #caller_location)                                                                           {        impl_VertexArrayAttribFormat(vaobj, attribindex, size, type_, normalized, relativeoffset);                                         debug_helper(loc, 0, vaobj, attribindex, size, type_, normalized, relativeoffset);                                                        }
	VertexArrayAttribIFormat                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type_: u32, relativeoffset: u32, loc := #caller_location)                                                                                           {        impl_VertexArrayAttribIFormat(vaobj, attribindex, size, type_, relativeoffset);                                                    debug_helper(loc, 0, vaobj, attribindex, size, type_, relativeoffset);                                                                    }
	VertexArrayAttribLFormat                 :: #force_inline proc "c" (vaobj: u32, attribindex: u32, size: i32, type_: u32, relativeoffset: u32, loc := #caller_location)                                                                                           {        impl_VertexArrayAttribLFormat(vaobj, attribindex, size, type_, relativeoffset);                                                    debug_helper(loc, 0, vaobj, attribindex, size, type_, relativeoffset);                                                                    }
	VertexArrayBindingDivisor                :: #force_inline proc "c" (vaobj: u32, bindingindex: u32, divisor: u32, loc := #caller_location)                                                                                                                        {        impl_VertexArrayBindingDivisor(vaobj, bindingindex, divisor);                                                                      debug_helper(loc, 0, vaobj, bindingindex, divisor);                                                                                       }
	GetVertexArrayiv                         :: #force_inline proc "c" (vaobj: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                                {        impl_GetVertexArrayiv(vaobj, pname, param);                                                                                        debug_helper(loc, 0, vaobj, pname, param);                                                                                                }
	GetVertexArrayIndexediv                  :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i32, loc := #caller_location)                                                                                                                    {        impl_GetVertexArrayIndexediv(vaobj, index, pname, param);                                                                          debug_helper(loc, 0, vaobj, index, pname, param);                                                                                         }
	GetVertexArrayIndexed64iv                :: #force_inline proc "c" (vaobj: u32, index: u32, pname: u32, param: ^i64, loc := #caller_location)                                                                                                                    {        impl_GetVertexArrayIndexed64iv(vaobj, index, pname, param);                                                                        debug_helper(loc, 0, vaobj, index, pname, param);                                                                                         }
	CreateSamplers                           :: #force_inline proc "c" (n: i32, samplers: ^u32, loc := #caller_location)                                                                                                                                             {        impl_CreateSamplers(n, samplers);                                                                                                  debug_helper(loc, 0, n, samplers);                                                                                                        }
	CreateProgramPipelines                   :: #force_inline proc "c" (n: i32, pipelines: ^u32, loc := #caller_location)                                                                                                                                            {        impl_CreateProgramPipelines(n, pipelines);                                                                                         debug_helper(loc, 0, n, pipelines);                                                                                                       }
	CreateQueries                            :: #force_inline proc "c" (target: u32, n: i32, ids: ^u32, loc := #caller_location)                                                                                                                                     {        impl_CreateQueries(target, n, ids);                                                                                                debug_helper(loc, 0, target, n, ids);                                                                                                     }
	GetQueryBufferObjecti64v                 :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjecti64v(id, buffer, pname, offset);                                                                          debug_helper(loc, 0, id, buffer, pname, offset);                                                                                          }
	GetQueryBufferObjectiv                   :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectiv(id, buffer, pname, offset);                                                                            debug_helper(loc, 0, id, buffer, pname, offset);                                                                                          }
	GetQueryBufferObjectui64v                :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectui64v(id, buffer, pname, offset);                                                                         debug_helper(loc, 0, id, buffer, pname, offset);                                                                                          }
	GetQueryBufferObjectuiv                  :: #force_inline proc "c" (id: u32, buffer: u32, pname: u32, offset: int, loc := #caller_location)                                                                                                                      {        impl_GetQueryBufferObjectuiv(id, buffer, pname, offset);                                                                           debug_helper(loc, 0, id, buffer, pname, offset);                                                                                          }
	MemoryBarrierByRegion                    :: #force_inline proc "c" (barriers: u32, loc := #caller_location)                                                                                                                                                      {        impl_MemoryBarrierByRegion(barriers);                                                                                              debug_helper(loc, 0, barriers);                                                                                                           }
	GetTextureSubImage                       :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, format: u32, type_: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)     {        impl_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, bufSize, pixels);          debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type_, bufSize, pixels);                    }
	GetCompressedTextureSubImage             :: #force_inline proc "c" (texture: u32, level: i32, xoffset: i32, yoffset: i32, zoffset: i32, width: i32, height: i32, depth: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                              {        impl_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);               debug_helper(loc, 0, texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);                                   }
	GetGraphicsResetStatus                   :: #force_inline proc "c" (loc := #caller_location) -> u32                                                                                                                                                              { ret := impl_GetGraphicsResetStatus();                                                                                                     debug_helper(loc, 1, ret);                                                                                                    return ret; }
	GetnCompressedTexImage                   :: #force_inline proc "c" (target: u32, lod: i32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                                                {        impl_GetnCompressedTexImage(target, lod, bufSize, pixels);                                                                         debug_helper(loc, 0, target, lod, bufSize, pixels);                                                                                       }
	GetnTexImage                             :: #force_inline proc "c" (target: u32, level: i32, format: u32, type_: u32, bufSize: i32, pixels: rawptr, loc := #caller_location)                                                                                     {        impl_GetnTexImage(target, level, format, type_, bufSize, pixels);                                                                  debug_helper(loc, 0, target, level, format, type_, bufSize, pixels);                                                                      }
	GetnUniformdv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: ^f64, loc := #caller_location)                                                                                                            {        impl_GetnUniformdv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params);                                                                                 }
	GetnUniformfv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: ^f32, loc := #caller_location)                                                                                                            {        impl_GetnUniformfv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params);                                                                                 }
	GetnUniformiv                            :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: ^i32, loc := #caller_location)                                                                                                            {        impl_GetnUniformiv(program, location, bufSize, params);                                                                            debug_helper(loc, 0, program, location, bufSize, params);                                                                                 }
	GetnUniformuiv                           :: #force_inline proc "c" (program: u32, location: i32, bufSize: i32, params: ^u32, loc := #caller_location)                                                                                                            {        impl_GetnUniformuiv(program, location, bufSize, params);                                                                           debug_helper(loc, 0, program, location, bufSize, params);                                                                                 }
	ReadnPixels                              :: #force_inline proc "c" (x: i32, y: i32, width: i32, height: i32, format: u32, type_: u32, bufSize: i32, data: rawptr, loc := #caller_location)                                                                       {        impl_ReadnPixels(x, y, width, height, format, type_, bufSize, data);                                                               debug_helper(loc, 0, x, y, width, height, format, type_, bufSize, data);                                                                  }
	GetnMapdv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^f64, loc := #caller_location)                                                                                                                     {        impl_GetnMapdv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v);                                                                                          }
	GetnMapfv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^f32, loc := #caller_location)                                                                                                                     {        impl_GetnMapfv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v);                                                                                          }
	GetnMapiv                                :: #force_inline proc "c" (target: u32, query: u32, bufSize: i32, v: ^i32, loc := #caller_location)                                                                                                                     {        impl_GetnMapiv(target, query, bufSize, v);                                                                                         debug_helper(loc, 0, target, query, bufSize, v);                                                                                          }
	GetnPixelMapusv                          :: #force_inline proc "c" (map_: u32, bufSize: i32, values: ^u16, loc := #caller_location)                                                                                                                              {        impl_GetnPixelMapusv(map_, bufSize, values);                                                                                       debug_helper(loc, 0, map_, bufSize, values);                                                                                              }
	GetnPixelMapfv                           :: #force_inline proc "c" (map_: u32, bufSize: i32, values: ^f32, loc := #caller_location)                                                                                                                              {        impl_GetnPixelMapfv(map_, bufSize, values);                                                                                        debug_helper(loc, 0, map_, bufSize, values);                                                                                              }
	GetnPixelMapuiv                          :: #force_inline proc "c" (map_: u32, bufSize: i32, values: ^u32, loc := #caller_location)                                                                                                                              {        impl_GetnPixelMapuiv(map_, bufSize, values);                                                                                       debug_helper(loc, 0, map_, bufSize, values);                                                                                              }
	GetnPolygonStipple                       :: #force_inline proc "c" (bufSize: i32, pattern: ^u8, loc := #caller_location)                                                                                                                                         {        impl_GetnPolygonStipple(bufSize, pattern);                                                                                         debug_helper(loc, 0, bufSize, pattern);                                                                                                   }
	GetnColorTable                           :: #force_inline proc "c" (target: u32, format: u32, type_: u32, bufSize: i32, table: rawptr, loc := #caller_location)                                                                                                  {        impl_GetnColorTable(target, format, type_, bufSize, table);                                                                        debug_helper(loc, 0, target, format, type_, bufSize, table);                                                                              }
	GetnConvolutionFilter                    :: #force_inline proc "c" (target: u32, format: u32, type_: u32, bufSize: i32, image: rawptr, loc := #caller_location)                                                                                                  {        impl_GetnConvolutionFilter(target, format, type_, bufSize, image);                                                                 debug_helper(loc, 0, target, format, type_, bufSize, image);                                                                              }
	GetnSeparableFilter                      :: #force_inline proc "c" (target: u32, format: u32, type_: u32, rowBufSize: i32, row: rawptr, columnBufSize: i32, column: rawptr, span: rawptr, loc := #caller_location)                                               {        impl_GetnSeparableFilter(target, format, type_, rowBufSize, row, columnBufSize, column, span);                                     debug_helper(loc, 0, target, format, type_, rowBufSize, row, columnBufSize, column, span);                                                }
	GetnHistogram                            :: #force_inline proc "c" (target: u32, reset: u8, format: u32, type_: u32, bufSize: i32, values: rawptr, loc := #caller_location)                                                                                      {        impl_GetnHistogram(target, reset, format, type_, bufSize, values);                                                                 debug_helper(loc, 0, target, reset, format, type_, bufSize, values);                                                                      }
	GetnMinmax                               :: #force_inline proc "c" (target: u32, reset: u8, format: u32, type_: u32, bufSize: i32, values: rawptr, loc := #caller_location)                                                                                      {        impl_GetnMinmax(target, reset, format, type_, bufSize, values);                                                                    debug_helper(loc, 0, target, reset, format, type_, bufSize, values);                                                                      }
	TextureBarrier                           :: #force_inline proc "c" (loc := #caller_location)                                                                                                                                                                     {        impl_TextureBarrier();                                                                                                             debug_helper(loc, 0);                                                                                                                     }
	GetUnsignedBytevEXT                      :: #force_inline proc "c" (pname: u32, data: ^byte, loc := #caller_location)                                                                                                                                            {        impl_glGetUnsignedBytevEXT(pname, data);                                                                                           debug_helper(loc, 0, pname, data);                                                                                                                     }
	TexPageCommitmentARB                     :: #force_inline proc "c"(target: u32,
                                                        level: i32,
                                                        xoffset: i32,
                                                        yoffset: i32,
                                                        zoffset: i32,
                                                        width: i32,
                                                        height: i32,
                                                        depth: i32,
                                                        commit: b8, loc := #caller_location) {
			impl_TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit); 
			debug_helper(loc, 0, target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
		}
	// VERSION_4_6
	SpecializeShader               :: #force_inline proc "c" (shader: u32, pEntryPoint: ^u8, numSpecializationConstants: u32, pConstantIndex: ^u32, pConstantValue: ^u32, loc := #caller_location) { impl_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); debug_helper(loc, 0, shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); }
	MultiDrawArraysIndirectCount   :: #force_inline proc "c" (mode: i32, indirect: rawptr, drawcount: int, maxdrawcount, stride: i32, loc := #caller_location)                                     { impl_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride);                     debug_helper(loc, 0, mode, indirect, drawcount, maxdrawcount, stride);                                 }
	MultiDrawElementsIndirectCount :: #force_inline proc "c" (mode: i32, type_: i32, indirect: rawptr, drawcount: int, maxdrawcount, stride: i32, loc := #caller_location)                         { impl_MultiDrawElementsIndirectCount(mode, type_, indirect, drawcount, maxdrawcount, stride);            debug_helper(loc, 0, mode, type_, indirect, drawcount, maxdrawcount, stride);                          }
	PolygonOffsetClamp             :: #force_inline proc "c" (factor, units, clamp: f32, loc := #caller_location)                                                                                  { impl_PolygonOffsetClamp(factor, units, clamp);                                                          debug_helper(loc, 0, factor, units, clamp);                                                            }
}