FramebufferTarget = enum
  ftRead, ftDraw

BufferTarget = enum
  btArray, btElementArray, btPixelPack, btPixelUnpack

TextureTarget = enum
  ttTexture1D, ttTexture1DArray, ttTexture2D, ttTexture2DMultisample,
  ttTexture2DArray, ttTexture2DMultisampleArray, ttTexture3D, ttTextureCubeMapPosX,
  ttTextureCubeMapNegX, ttTextureCubeMapPosY, ttTextureCubeMapNegY,
  ttTextureCubeMapPosZ, ttTextureCubeMapNegZ

OpenGlFeature = enum
  glfBlend, glfColorLogicOp, glfCullFace, glfDepthTest, glfDither, glfLineSmooth,
  glfMultisample, glfPolygonSmooth, glfPrimitiveRestart, glfScissorTest,
  glfStencilTest, glfTextureCubeMapSeamless, glfProgramPointSize

VertexArray = object
  buffers: array[BufferTarget, GlUint]
  id*: GlUint

Framebuffer = ref object
  id*: GlUint
  drawBuffers: seq[GlEnum]

OpenGl = ref object
  version*: string
  sBlendColor: tuple[r, g, b, a: GlClampf]
  sBlendEquation: tuple[rgb, alpha: GlEnum]
  sBlendFunc: tuple[srcRgb, destRgb, srcAlpha, destAlpha: GlEnum]
  sBuffers: array[BufferTarget, GlUint]
  sClearColor: tuple[r, g, b, a: GlClampf]
  sClearDepth: GlClampd
  sClearStencil: GlInt
  sColorMask: tuple[r, g, b, a: GlBool]
  sCullFace: GlEnum
  sDepthFunc: GlEnum
  sDepthMask: bool
  sEnabledFeatures: array[OpenGlFeature, bool]
  sFramebuffers: tuple[read, draw: Framebuffer]
  sFrontFace: GlEnum
  sHints: array[Hint, GlEnum]
  sLogicOp: GlEnum
  sLineWidth: GlFloat
  sPointSize: GlFloat
  sPolygonModes: array[Facing, GlEnum]
  sPrimitiveRestartIndex: GlUint
  sProgram: GlUint
  sRenderbuffer: GlUint
  sSamplerBindings: seq[GlUint]
  sScissor: tuple[x, y: GlInt, width, height: GlSizei]
  sStencilFuncs: array[Facing, tuple[fn: GlEnum, refr: GlInt, mask: GlUint]]
  sStencilMasks: array[Facing, GlUint]
  sStencilOps: array[Facing, tuple[sfail, dpfail, dppass: GlEnum]]
  sTextureUnit: int
  sTextureUnitBindings: seq[array[TextureTarget, GlUint]]
  sVertexArray: VertexArray
  sViewport: tuple[x, y: GlInt, w, h: GlSizei]
  uniformTextureUnit: int
  currentDrawParamsHash*: Hash
  defaultFramebufferSamples*: int
  defaultFramebuffer*: Framebuffer
  glActiveTexture: proc (texture: GlEnum) {...}{.cdecl.}
  glBindBuffer: proc (target: GlEnum; buffer: GlUint) {...}{.cdecl.}
  glBindFramebuffer: proc (target: GlEnum; framebuffer: GlUint) {...}{.cdecl.}
  glBindRenderbuffer: proc (target: GlEnum; renderbuffer: GlUint) {...}{.cdecl.}
  glBindSampler: proc (unit, sampler: GlUint) {...}{.cdecl.}
  glBindTexture: proc (target: GlEnum; texture: GlUint) {...}{.cdecl.}
  glBindVertexArray: proc (array: GlUint) {...}{.cdecl.}
  glBlendColor: proc (r, g, b, a: GlClampf) {...}{.cdecl.}
  glBlendEquationSeparate: proc (modeRGB, modeAlpha: GlEnum) {...}{.cdecl.}
  glBlendFuncSeparate: proc (srcRGB, destRGB: GlEnum; srcAlpha, destAlpha: GlEnum) {...}{.
      cdecl.}
  glClear: proc (targets: GlBitfield) {...}{.cdecl.}
  glClearColor: proc (r, g, b, a: GlClampf) {...}{.cdecl.}
  glClearDepth: proc (depth: GlClampd) {...}{.cdecl.}
  glClearStencil: proc (stencil: GlInt) {...}{.cdecl.}
  glColorMask: proc (r, g, b, a: GlBool) {...}{.cdecl.}
  glCullFace: proc (mode: GlEnum) {...}{.cdecl.}
  glDepthFunc: proc (fn: GlEnum) {...}{.cdecl.}
  glDepthMask: proc (mask: GlBool) {...}{.cdecl.}
  glDrawBuffers: proc (n: GlSizei; bufs: ptr GlEnum) {...}{.cdecl.}
  glDisable: proc (cap: GlEnum) {...}{.cdecl.}
  glEnable: proc (cap: GlEnum) {...}{.cdecl.}
  glFrontFace: proc (mode: GlEnum) {...}{.cdecl.}
  glHint: proc (target, mode: GlEnum) {...}{.cdecl.}
  glLineWidth: proc (width: GlFloat) {...}{.cdecl.}
  glLogicOp: proc (opcode: GlEnum) {...}{.cdecl.}
  glPixelStorei: proc (pname: GlEnum; param: GlInt) {...}{.cdecl.}
  glPointSize: proc (size: GlFloat) {...}{.cdecl.}
  glPolygonMode: proc (face, mode: GlEnum) {...}{.cdecl.}
  glPrimitiveRestartIndex: proc (index: GlUint) {...}{.cdecl.}
  glScissor: proc (x, y: GlInt; width, height: GlSizei) {...}{.cdecl.}
  glStencilFuncSeparate: proc (face, fn: GlEnum; reference: GlInt; mask: GlUint) {...}{.cdecl.}
  glStencilMaskSeparate: proc (face: GlEnum; mask: GlUint) {...}{.cdecl.}
  glStencilOpSeparate: proc (face, sfail, dpfail, dppass: GlEnum) {...}{.cdecl.}
  glUseProgram: proc (program: GlUint) {...}{.cdecl.}
  glViewport: proc (x, y: GlInt; width, height: GlSizei) {...}{.cdecl.}
  glAttachShader: proc (program, shader: GlUint) {...}{.cdecl.}
  glBindAttribLocation: proc (program, index: GlUint; name: cstring) {...}{.cdecl.}
  glBlitFramebuffer: proc (srcX0, srcY0, srcX1, srcY1: GlInt;
                         destX0, destY0, destX1, destY1: GlInt; mask: GlBitfield;
                         filter: GlEnum) {...}{.cdecl.}
  glBufferData: proc (target: GlEnum; size: GlSizeiptr; data: pointer; usage: GlEnum) {...}{.
      cdecl.}
  glBufferSubData: proc (target: GlEnum; offset: GlIntptr; size: GlSizeiptr;
                       data: pointer) {...}{.cdecl.}
  glCheckFramebufferStatus: proc (target: GlEnum): GlEnum {...}{.cdecl.}
  glClientWaitSync: proc (sync: GlSync; flags: GlBitfield; timeout: GlUint64): GlEnum {...}{.
      cdecl.}
  glCompileShader: proc (shader: GlUint) {...}{.cdecl.}
  glCreateProgram: proc (): GlUint {...}{.cdecl.}
  glCreateShader: proc (shaderType: GlEnum): GlUint {...}{.cdecl.}
  glDeleteBuffers: proc (n: GlSizei; buffers: pointer) {...}{.cdecl.}
  glDeleteFramebuffers: proc (n: GlSizei; framebuffers: pointer) {...}{.cdecl.}
  glDeleteRenderbuffers: proc (n: GlSizei; renderbuffers: pointer) {...}{.cdecl.}
  glDeleteProgram: proc (program: GlUint) {...}{.cdecl.}
  glDeleteSamplers: proc (n: GlSizei; samplers: pointer) {...}{.cdecl.}
  glDeleteShader: proc (shader: GlUint) {...}{.cdecl.}
  glDeleteSync: proc (sync: GlSync) {...}{.cdecl.}
  glDeleteTextures: proc (n: GlSizei; textures: pointer) {...}{.cdecl.}
  glDeleteVertexArrays: proc (n: GlSizei; arrays: pointer) {...}{.cdecl.}
  glDisableVertexAttribArray: proc (index: GlUint) {...}{.cdecl.}
  glDrawArrays: proc (mode: GlEnum; first: GlInt; count: GlSizei) {...}{.cdecl.}
  glDrawArraysInstanced: proc (mode: GlEnum; first: GlInt; count, primCount: GlSizei) {...}{.
      cdecl.}
  glDrawElements: proc (mode: GlEnum; count: GlSizei; kind: GlEnum; indices: pointer) {...}{.
      cdecl.}
  glDrawElementsInstanced: proc (mode: GlEnum; count: GlSizei; kind: GlEnum;
                               indices: pointer; primCount: GlSizei) {...}{.cdecl.}
  glEnableVertexAttribArray: proc (index: GlUint) {...}{.cdecl.}
  glFenceSync: proc (condition: GlEnum; flags: GlBitfield): GlSync {...}{.cdecl.}
  glFramebufferRenderbuffer: proc (target, attachment: GlEnum;
                                 renderbufferTarget: GlEnum; renderbuffer: GlUint) {...}{.
      cdecl.}
  glFramebufferTexture1D: proc (target, attachment, texTarget: GlEnum;
                              texture: GlUint; level: GlInt) {...}{.cdecl.}
  glFramebufferTexture2D: proc (target, attachment, texTarget: GlEnum;
                              texture: GlUint; level: GlInt) {...}{.cdecl.}
  glFramebufferTextureLayer: proc (target, attachment: GlEnum; texture: GlUint;
                                 level, layer: GlInt) {...}{.cdecl.}
  glGenBuffers: proc (n: GlSizei; buffers: pointer) {...}{.cdecl.}
  glGenFramebuffers: proc (n: GlSizei; framebuffers: pointer) {...}{.cdecl.}
  glGenRenderbuffers: proc (n: GlSizei; renderbuffers: pointer) {...}{.cdecl.}
  glGenSamplers: proc (n: GlSizei; samplers: pointer) {...}{.cdecl.}
  glGenTextures: proc (n: GlSizei; textures: pointer) {...}{.cdecl.}
  glGenVertexArrays: proc (n: GlSizei; arrays: pointer) {...}{.cdecl.}
  glGenerateMipmap: proc (target: GlEnum) {...}{.cdecl.}
  glGetError: proc (): GlEnum {...}{.cdecl.}
  glGetProgramInfoLog: proc (program: GlUint; maxLen: GlSizei; length: ptr GlSizei;
                           infoLog: cstring) {...}{.cdecl.}
  glGetProgramiv: proc (program: GlUint; pname: GlEnum; params: pointer) {...}{.cdecl.}
  glGetShaderInfoLog: proc (shader: GlUint; maxLen: GlSizei; length: ptr GlSizei;
                          infoLog: cstring) {...}{.cdecl.}
  glGetShaderiv: proc (shader: GlUint; pname: GlEnum; params: pointer) {...}{.cdecl.}
  glGetString: proc (name: GlEnum): cstring {...}{.cdecl.}
  glGetIntegerv: proc (pname: GlEnum; params: pointer) {...}{.cdecl.}
  glGetTexImage: proc (target: GlEnum; level: GlInt; format, typ: GlEnum; image: pointer) {...}{.
      cdecl.}
  glGetUniformLocation: proc (program: GlUint; name: cstring): GlInt {...}{.cdecl.}
  glLinkProgram: proc (program: GlUint) {...}{.cdecl.}
  glMapBuffer: proc (target, access: GlEnum): pointer {...}{.cdecl.}
  glReadPixels: proc (x, y: GlInt; width, height: GlSizei; format, typ: GlEnum;
                    data: pointer) {...}{.cdecl.}
  glRenderbufferStorageMultisample: proc (target: GlEnum; samples: GlSizei;
                                        internalFormat: GlEnum;
                                        width, height: GlSizei) {...}{.cdecl.}
  glSamplerParameteri: proc (sampler: GlUint; pname: GlEnum; param: GlInt) {...}{.cdecl.}
  glSamplerParameterfv: proc (sampler: GlUint; pname: GlEnum; params: pointer) {...}{.cdecl.}
  glShaderSource: proc (shader: GlUint; count: GlSizei; str: cstringArray;
                      length: pointer) {...}{.cdecl.}
  glTexImage1D: proc (target: GlEnum; level, internalFormat: GlInt; width: GlSizei;
                    border: GlInt; format, kind: GlEnum; data: pointer) {...}{.cdecl.}
  glTexImage2D: proc (target: GlEnum; level, internalFormat: GlInt;
                    width, height: GlSizei; border: GlInt; format, kind: GlEnum;
                    data: pointer) {...}{.cdecl.}
  glTexImage2DMultisample: proc (target: GlEnum; samples: GlSizei;
                               internalFormat: GlInt; width, height: GlSizei;
                               fixedSampleLocations: GlBool) {...}{.cdecl.}
  glTexImage3D: proc (target: GlEnum; level, internalFormat: GlInt;
                    width, height, depth: GlSizei; border: GlInt;
                    format, kind: GlEnum; data: pointer) {...}{.cdecl.}
  glTexImage3DMultisample: proc (target: GlEnum; samples: GlSizei;
                               internalFormat: GlInt;
                               width, height, depth: GlSizei;
                               fixedSampleLocations: GlBool) {...}{.cdecl.}
  glTexParameteriv: proc (target, pname: GlEnum; params: ptr GlInt) {...}{.cdecl.}
  glTexSubImage1D: proc (target: GlEnum; level, xoffset: GlInt; width: GlSizei;
                       format, typ: GlEnum; data: pointer) {...}{.cdecl.}
  glTexSubImage2D: proc (target: GlEnum; level, xoffset, yoffset: GlInt;
                       width, height: GlSizei; format, typ: GlEnum; data: pointer) {...}{.
      cdecl.}
  glTexSubImage3D: proc (target: GlEnum; level: GlInt;
                       xoffset, yoffset, zoffset: GlInt;
                       width, height, depth: GlSizei; format, typ: GlEnum;
                       data: pointer) {...}{.cdecl.}
  glUniform1fv, glUniform2fv, glUniform3fv, glUniform4fv, glUniform1iv, glUniform2iv,
  glUniform3iv, glUniform4iv, glUniform1uiv, glUniform2uiv, glUniform3uiv,
  glUniform4uiv: UniformVecProc
  glUniformMatrix2fv, glUniformMatrix3fv, glUniformMatrix4fv, glUniformMatrix2x3fv,
  glUniformMatrix3x2fv, glUniformMatrix2x4fv, glUniformMatrix4x2fv,
  glUniformMatrix3x4fv, glUniformMatrix4x3fv: UniformMatrixProc
  glUnmapBuffer: proc (target: GlEnum): GlBool {...}{.cdecl.}
  glVertexAttribPointer: proc (index: GlUint; size: GlInt; typ: GlEnum;
                             normalized: bool; stride: GlSizei; point: pointer) {...}{.
      cdecl.}
  glVertexAttribIPointer: proc (index: GlUint; size: GlInt; typ: GlEnum;
                              stride: GlSizei; point: pointer) {...}{.cdecl.}

proc load(gl: OpenGl; getProcAddr: proc (name: string): pointer) {...}{.
    raises: [Exception, OSError], tags: [RootEffect].}

proc toGlEnum(hint: Hint): GlEnum {...}{.inline, raises: [], tags: [].}

proc toGlEnum(facing: Facing): GlEnum {...}{.inline, raises: [], tags: [].}

proc toGlEnum(mode: AccessMode): GlEnum {...}{.inline, raises: [], tags: [].}

proc newGl(): OpenGl {...}{.raises: [], tags: [].}

proc viewport(gl: OpenGl; x, y: GlInt; width, height: GlSizei) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc feature(gl: OpenGl; feature: OpenGlFeature; enabled: bool) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc clearColor(gl: OpenGl; r, g, b, a: GlClampf) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc clearDepth(gl: OpenGl; depth: GlClampd) {...}{.raises: [Exception], tags: [RootEffect].}

proc clearStencil(gl: OpenGl; stencil: GlInt) {...}{.raises: [Exception], tags: [RootEffect].}

proc bindBuffer(gl: OpenGl; target: BufferTarget; buffer: GlUint) {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}

proc bindFramebuffer(gl: OpenGl; targets: set[FramebufferTarget]; buffer: Framebuffer) {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}

proc bindRenderbuffer(gl: OpenGl; renderbuffer: GlUint) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc bindSampler(gl: OpenGl; unit: int; sampler: GlUint) {...}{.
    raises: [ValueError, Exception], tags: [RootEffect].}

proc textureUnit=(gl: OpenGl; unit: int) {...}{.raises: [ValueError, Exception],
                                      tags: [RootEffect].}

proc bindTexture(gl: OpenGl; target: TextureTarget; texture: GlUint) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc bindVertexArray(gl: OpenGl; vao: VertexArray) {...}{.raises: [Exception, ValueError],
    tags: [RootEffect].}

proc blendColor(gl: OpenGl; r, g, b, a: GlClampf) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc blendEquation(gl: OpenGl; colorMode, alphaMode: GlEnum) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc blendFunc(gl: OpenGl; srcRgb, destRgb, srcAlpha, destAlpha: GlEnum) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc colorMask(gl: OpenGl; red, green, blue, alpha: GlBool) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc cullFace(gl: OpenGl; mode: GlEnum) {...}{.raises: [Exception], tags: [RootEffect].}

proc depthFunc(gl: OpenGl; function: GlEnum) {...}{.raises: [Exception], tags: [RootEffect].}

proc depthMask(gl: OpenGl; enabled: bool) {...}{.raises: [Exception], tags: [RootEffect].}

proc drawBuffers(gl: OpenGl; buffers: seq[GlEnum]) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc frontFace(gl: OpenGl; mode: GlEnum) {...}{.raises: [Exception], tags: [RootEffect].}

proc hint(gl: OpenGl; hint: Hint; mode: GlEnum) {...}{.raises: [Exception], tags: [RootEffect].}

proc logicOp(gl: OpenGl; opcode: GlEnum) {...}{.raises: [Exception], tags: [RootEffect].}

proc lineWidth(gl: OpenGl; width: GlFloat) {...}{.raises: [Exception], tags: [RootEffect].}

proc pointSize(gl: OpenGl; size: GlFloat) {...}{.raises: [Exception], tags: [RootEffect].}

proc polygonMode(gl: OpenGl; facing: Facing; mode: GlEnum) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc primitiveRestartIndex(gl: OpenGl; index: GlUint) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc scissor(gl: OpenGl; x, y: GlInt; width, height: GlSizei) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc stencilFunc(gl: OpenGl; facing: Facing; fn: GlEnum; reference: GlInt; mask: GlUint) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc stencilMask(gl: OpenGl; facing: Facing; mask: GlUint) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc stencilOp(gl: OpenGl; facing: Facing; sfail, dpfail, dppass: GlEnum) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc useProgram(gl: OpenGl; program: GlUint) {...}{.raises: [Exception, ValueError],
    tags: [RootEffect].}

proc createShader(gl: OpenGl; shaderType: GlEnum; source: string; outError: var string): Option[
    GlUint] {...}{.raises: [Exception], tags: [RootEffect].}

proc createProgram(gl: OpenGl): GlUint {...}{.raises: [Exception], tags: [RootEffect].}

proc attachShader(gl: OpenGl; program, shader: GlUint) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc bindAttribLocation(gl: OpenGl; program: GlUint; index: Natural; name: string) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc linkProgram(gl: OpenGl; program: GlUint): Option[string] {...}{.raises: [Exception],
    tags: [RootEffect].}

proc getUniformLocation(gl: OpenGl; program: GlUint; name: string): GlInt {...}{.
    raises: [Exception], tags: [RootEffect].}

proc resetTextureUnitCounter(gl: OpenGl) {...}{.raises: [], tags: [].}

proc uniform(gl: OpenGl; loc: GlInt; u: Uniform) {...}{.raises: [Exception, ValueError],
    tags: [RootEffect].}

proc deleteShader(gl: OpenGl; shader: GlUint) {...}{.raises: [Exception], tags: [RootEffect].}

proc deleteProgram(gl: OpenGl; program: GlUint) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc createBuffer(gl: OpenGl): GlUint {...}{.raises: [Exception], tags: [RootEffect].}

proc bufferData(gl: OpenGl; target: BufferTarget; size: int; data: pointer; usage: GlEnum) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc bufferSubData(gl: OpenGl; target: BufferTarget; where: Slice[int]; data: pointer) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc mapBuffer(gl: OpenGl; target: BufferTarget; access: GlEnum): pointer {...}{.
    raises: [Exception], tags: [RootEffect].}

proc unmapBuffer(gl: OpenGl; target: BufferTarget) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc deleteBuffer(gl: OpenGl; buffer: GlUint) {...}{.raises: [Exception], tags: [RootEffect].}

proc createVertexArray(gl: OpenGl): VertexArray {...}{.raises: [Exception],
    tags: [RootEffect].}

proc vertexAttrib[T](gl: OpenGl; index, stride, offset: int)

proc enableVertexAttrib(gl: OpenGl; index: int) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc disableVertexAttrib(gl: OpenGl; index: int) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc deleteVertexArray(gl: OpenGl; array: VertexArray) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc createTexture(gl: OpenGl): GlUint {...}{.raises: [Exception], tags: [RootEffect].}

proc data1D(gl: OpenGl; width: Positive; internalFormat, format, typ: GlEnum) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc data2D(gl: OpenGl; target: TextureTarget; width, height: Positive;
           internalFormat, format, typ: GlEnum) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc data2DMS(gl: OpenGl; width, height: Positive; internalFormat: GlEnum;
             samples: Natural; fixedSampleLocations: bool) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc data3D(gl: OpenGl; target: TextureTarget; width, height, depth: Positive;
           internalFormat, format, typ: GlEnum) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc data3DMS(gl: OpenGl; width, height, depth: Positive; internalFormat: GlEnum;
             samples: Natural; fixedSampleLocations: bool) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc subImage1D(gl: OpenGl; x: Natural; width: Positive; format, typ: GlEnum;
               data: pointer) {...}{.raises: [Exception], tags: [RootEffect].}

proc subImage2D(gl: OpenGl; target: TextureTarget; x, y: Natural;
               width, height: Positive; format, typ: GlEnum; data: pointer) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc subImage3D(gl: OpenGl; target: TextureTarget; x, y, z: Natural;
               width, height, depth: Positive; format, typ: GlEnum; data: pointer) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc getImage(gl: OpenGl; target: TextureTarget; level: GlInt; format, typ: GlEnum;
             dest: pointer) {...}{.raises: [Exception], tags: [RootEffect].}

proc genMipmaps(gl: OpenGl; target: TextureTarget) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc textureParam(gl: OpenGl; target: TextureTarget; param: GlEnum; values: ptr GlInt) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc deleteTexture(gl: OpenGl; texture: GlUint) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc createSampler(gl: OpenGl): GlUint {...}{.raises: [Exception], tags: [RootEffect].}

proc samplerParam(gl: OpenGl; sampler: GlUint; param: GlEnum; value: GlInt) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc samplerParam(gl: OpenGl; sampler: GlUint; param: GlEnum; value: ptr GlFloat) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc deleteSampler(gl: OpenGl; sampler: GlUint) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc createFramebuffer(gl: OpenGl): Framebuffer {...}{.raises: [Exception],
    tags: [RootEffect].}

proc attachRenderbuffer(gl: OpenGl; attachment: GlEnum; renderbuffer: GlUint) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc attachTexture1D(gl: OpenGl; attachment: GlEnum; texTarget: TextureTarget;
                    texture: GlUint; mipLevel: GlInt) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc attachTexture2D(gl: OpenGl; attachment: GlEnum; texTarget: TextureTarget;
                    texture: GlUint; mipLevel: GlInt) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc attachTextureLayer(gl: OpenGl; attachment: GlEnum; texture: GlUint;
                       mipLevel, layer: GlInt) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc framebufferStatus(gl: OpenGl): GlEnum {...}{.raises: [Exception], tags: [RootEffect].}

proc blitFramebuffer(gl: OpenGl; srcX0, srcY0, srcX1, srcY1: GlInt;
                    destX0, destY0, destX1, destY1: GlInt; mask: GlBitfield;
                    filter: GlEnum) {...}{.raises: [Exception], tags: [RootEffect].}

proc deleteFramebuffer(gl: OpenGl; framebuffer: Framebuffer) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc createRenderbuffer(gl: OpenGl): GlUint {...}{.raises: [Exception], tags: [RootEffect].}

proc renderbufferStorage(gl: OpenGl; width, height, samples: GlSizei;
                        internalFormat: GlEnum) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc deleteRenderbuffer(gl: OpenGl; renderbuffer: GlUint) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc createFenceSync(gl: OpenGl; condition: GlEnum): GlSync {...}{.raises: [Exception],
    tags: [RootEffect].}

proc pollSyncStatus(gl: OpenGl; sync: GlSync; timeout: GlUint64): GlEnum {...}{.
    raises: [Exception], tags: [RootEffect].}

proc deleteSync(gl: OpenGl; sync: GlSync) {...}{.raises: [Exception], tags: [RootEffect].}

proc drawArrays(gl: OpenGl; primitive: GlEnum; start, count: int) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc drawArraysInstanced(gl: OpenGl; primitive: GlEnum;
                        start, count, instanceCount: int) {...}{.raises: [Exception],
    tags: [RootEffect].}

proc drawElements(gl: OpenGl; primitive: GlEnum; start, count: int; indexType: GlEnum) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc drawElementsInstanced(gl: OpenGl; primitive: GlEnum;
                          start, count, instanceCount: int; indexType: GlEnum) {...}{.
    raises: [Exception], tags: [RootEffect].}

proc readPixels(gl: OpenGl; x, y: GlInt; width, height: GlSizei; format, typ: GlEnum;
               data: pointer) {...}{.raises: [Exception], tags: [RootEffect].}