opengl-definitions 1.0.0 → 2.0.0

data/lib/opengl-definitions/versions/GLX_VERSION_1_4.rb

@@ -6,12 +6,8 @@ module GLX_VERSION_1_4
     SAMPLES        = 100001
   end
 
-  module Functions
-    def glXGetProcAddress(procName) end
-
-    Parameters = {
-      #void ( * glXGetProcAddress (const GLubyte *procName)) (void)
-      glXGetProcAddress: [ :pointer, :string ].freeze
-    }.freeze
-  end
+  Functions = {
+    # void ( * glXGetProcAddress (const GLubyte *procName)) (void)
+    def glXGetProcAddress(procName) end => [ :pointer, :string ].freeze
+  }.freeze
 end

data/lib/opengl-definitions/versions/GL_VERSION_1_0.rb

@@ -538,105 +538,54 @@ module GL_VERSION_1_0
     ZOOM_Y                        = 0x0D17
   end
 
-  module Functions
-    def glBlendFunc(sfactor, dfactor) end
-    def glClear(mask) end
-    def glClearColor(red, green, blue, alpha) end
-    def glClearDepth(depth) end
-    def glClearStencil(s) end
-    def glColorMask(red, green, blue, alpha) end
-    def glCullFace(mode) end
-    def glDepthFunc(func) end
-    def glDepthMask(flag) end
-    def glDepthRange(n, f) end
-    def glDisable(cap) end
-    def glDrawBuffer(buf) end
-    def glEnable(cap) end
-    def glFinish() end
-    def glFlush() end
-    def glFrontFace(mode) end
-    def glGetBooleanv(pname, data) end
-    def glGetDoublev(pname, data) end
-    def glGetError() end
-    def glGetFloatv(pname, data) end
-    def glGetIntegerv(pname, data) end
-    def glGetString(name) end
-    def glGetTexImage(target, level, format, type, pixels) end
-    def glGetTexLevelParameterfv(target, level, pname, params) end
-    def glGetTexLevelParameteriv(target, level, pname, params) end
-    def glGetTexParameterfv(target, pname, params) end
-    def glGetTexParameteriv(target, pname, params) end
-    def glHint(target, mode) end
-    def glIsEnabled(cap) end
-    def glLineWidth(width) end
-    def glLogicOp(opcode) end
-    def glPixelStoref(pname, param) end
-    def glPixelStorei(pname, param) end
-    def glPointSize(size) end
-    def glPolygonMode(face, mode) end
-    def glReadBuffer(src) end
-    def glReadPixels(x, y, width, height, format, type, pixels) end
-    def glScissor(x, y, width, height) end
-    def glStencilFunc(func, ref, mask) end
-    def glStencilMask(mask) end
-    def glStencilOp(fail, zfail, zpass) end
-    def glTexImage1D(target, level, internalformat, width, border, format, type, pixels) end
-    def glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels) end
-    def glTexParameterf(target, pname, param) end
-    def glTexParameterfv(target, pname, params) end
-    def glTexParameteri(target, pname, param) end
-    def glTexParameteriv(target, pname, params) end
-    def glViewport(x, y, width, height) end
-
-    Parameters = {
-      glBlendFunc:              [ :void, :GLenum, :GLenum ].freeze,
-      glClear:                  [ :void, :GLbitfield ].freeze,
-      glClearColor:             [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-      glClearDepth:             [ :void, :GLdouble ].freeze,
-      glClearStencil:           [ :void, :GLint ].freeze,
-      glColorMask:              [ :void, :GLboolean, :GLboolean, :GLboolean, :GLboolean ].freeze,
-      glCullFace:               [ :void, :GLenum ].freeze,
-      glDepthFunc:              [ :void, :GLenum ].freeze,
-      glDepthMask:              [ :void, :GLboolean ].freeze,
-      glDepthRange:             [ :void, :GLdouble, :GLdouble ].freeze,
-      glDisable:                [ :void, :GLenum ].freeze,
-      glDrawBuffer:             [ :void, :GLenum ].freeze,
-      glEnable:                 [ :void, :GLenum ].freeze,
-      glFinish:                 [ :void ].freeze,
-      glFlush:                  [ :void ].freeze,
-      glFrontFace:              [ :void, :GLenum ].freeze,
-      glGetBooleanv:            [ :void, :GLenum, :pointer ].freeze,
-      glGetDoublev:             [ :void, :GLenum, :pointer ].freeze,
-      glGetError:               [ :GLenum ].freeze,
-      glGetFloatv:              [ :void, :GLenum, :pointer ].freeze,
-      glGetIntegerv:            [ :void, :GLenum, :pointer ].freeze,
-      glGetString:              [ :string, :GLenum ].freeze,
-      glGetTexImage:            [ :void, :GLenum, :GLint, :GLenum, :GLenum, :pointer ].freeze,
-      glGetTexLevelParameterfv: [ :void, :GLenum, :GLint, :GLenum, :pointer ].freeze,
-      glGetTexLevelParameteriv: [ :void, :GLenum, :GLint, :GLenum, :pointer ].freeze,
-      glGetTexParameterfv:      [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glGetTexParameteriv:      [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glHint:                   [ :void, :GLenum, :GLenum ].freeze,
-      glIsEnabled:              [ :GLboolean, :GLenum ].freeze,
-      glLineWidth:              [ :void, :GLfloat ].freeze,
-      glLogicOp:                [ :void, :GLenum ].freeze,
-      glPixelStoref:            [ :void, :GLenum, :GLfloat ].freeze,
-      glPixelStorei:            [ :void, :GLenum, :GLint ].freeze,
-      glPointSize:              [ :void, :GLfloat ].freeze,
-      glPolygonMode:            [ :void, :GLenum, :GLenum ].freeze,
-      glReadBuffer:             [ :void, :GLenum ].freeze,
-      glReadPixels:             [ :void, :GLint, :GLint, :GLsizei, :GLsizei, :GLenum, :GLenum, :pointer ].freeze,
-      glScissor:                [ :void, :GLint, :GLint, :GLsizei, :GLsizei ].freeze,
-      glStencilFunc:            [ :void, :GLenum, :GLint, :GLuint ].freeze,
-      glStencilMask:            [ :void, :GLuint ].freeze,
-      glStencilOp:              [ :void, :GLenum, :GLenum, :GLenum ].freeze,
-      glTexImage1D:             [ :void, :GLenum, :GLint, :GLint, :GLsizei, :GLint, :GLenum, :GLenum, :pointer ].freeze,
-      glTexImage2D:             [ :void, :GLenum, :GLint, :GLint, :GLsizei, :GLsizei, :GLint, :GLenum, :GLenum, :pointer ].freeze,
-      glTexParameterf:          [ :void, :GLenum, :GLenum, :GLfloat ].freeze,
-      glTexParameterfv:         [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glTexParameteri:          [ :void, :GLenum, :GLenum, :GLint ].freeze,
-      glTexParameteriv:         [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glViewport:               [ :void, :GLint, :GLint, :GLsizei, :GLsizei ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glBlendFunc(sfactor, dfactor) end => [ :void, :GLenum, :GLenum ].freeze,
+    def glClear(mask) end => [ :void, :GLbitfield ].freeze,
+    def glClearColor(red, green, blue, alpha) end => [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+    def glClearDepth(depth) end => [ :void, :GLdouble ].freeze,
+    def glClearStencil(s) end => [ :void, :GLint ].freeze,
+    def glColorMask(red, green, blue, alpha) end => [ :void, :GLboolean, :GLboolean, :GLboolean, :GLboolean ].freeze,
+    def glCullFace(mode) end => [ :void, :GLenum ].freeze,
+    def glDepthFunc(func) end => [ :void, :GLenum ].freeze,
+    def glDepthMask(flag) end => [ :void, :GLboolean ].freeze,
+    def glDepthRange(n, f) end => [ :void, :GLdouble, :GLdouble ].freeze,
+    def glDisable(cap) end => [ :void, :GLenum ].freeze,
+    def glDrawBuffer(buf) end => [ :void, :GLenum ].freeze,
+    def glEnable(cap) end => [ :void, :GLenum ].freeze,
+    def glFinish() end => [ :void ].freeze,
+    def glFlush() end => [ :void ].freeze,
+    def glFrontFace(mode) end => [ :void, :GLenum ].freeze,
+    def glGetBooleanv(pname, data) end => [ :void, :GLenum, :pointer ].freeze,
+    def glGetDoublev(pname, data) end => [ :void, :GLenum, :pointer ].freeze,
+    def glGetError() end => [ :GLenum ].freeze,
+    def glGetFloatv(pname, data) end => [ :void, :GLenum, :pointer ].freeze,
+    def glGetIntegerv(pname, data) end => [ :void, :GLenum, :pointer ].freeze,
+    def glGetString(name) end => [ :string, :GLenum ].freeze,
+    def glGetTexImage(target, level, format, type, pixels) end => [ :void, :GLenum, :GLint, :GLenum, :GLenum, :pointer ].freeze,
+    def glGetTexLevelParameterfv(target, level, pname, params) end => [ :void, :GLenum, :GLint, :GLenum, :pointer ].freeze,
+    def glGetTexLevelParameteriv(target, level, pname, params) end => [ :void, :GLenum, :GLint, :GLenum, :pointer ].freeze,
+    def glGetTexParameterfv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glGetTexParameteriv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glHint(target, mode) end => [ :void, :GLenum, :GLenum ].freeze,
+    def glIsEnabled(cap) end => [ :GLboolean, :GLenum ].freeze,
+    def glLineWidth(width) end => [ :void, :GLfloat ].freeze,
+    def glLogicOp(opcode) end => [ :void, :GLenum ].freeze,
+    def glPixelStoref(pname, param) end => [ :void, :GLenum, :GLfloat ].freeze,
+    def glPixelStorei(pname, param) end => [ :void, :GLenum, :GLint ].freeze,
+    def glPointSize(size) end => [ :void, :GLfloat ].freeze,
+    def glPolygonMode(face, mode) end => [ :void, :GLenum, :GLenum ].freeze,
+    def glReadBuffer(src) end => [ :void, :GLenum ].freeze,
+    def glReadPixels(x, y, width, height, format, type, pixels) end => [ :void, :GLint, :GLint, :GLsizei, :GLsizei, :GLenum, :GLenum, :pointer ].freeze,
+    def glScissor(x, y, width, height) end => [ :void, :GLint, :GLint, :GLsizei, :GLsizei ].freeze,
+    def glStencilFunc(func, ref, mask) end => [ :void, :GLenum, :GLint, :GLuint ].freeze,
+    def glStencilMask(mask) end => [ :void, :GLuint ].freeze,
+    def glStencilOp(fail, zfail, zpass) end => [ :void, :GLenum, :GLenum, :GLenum ].freeze,
+    def glTexImage1D(target, level, internalformat, width, border, format, type, pixels) end => [ :void, :GLenum, :GLint, :GLint, :GLsizei, :GLint, :GLenum, :GLenum, :pointer ].freeze,
+    def glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels) end => [ :void, :GLenum, :GLint, :GLint, :GLsizei, :GLsizei, :GLint, :GLenum, :GLenum, :pointer ].freeze,
+    def glTexParameterf(target, pname, param) end => [ :void, :GLenum, :GLenum, :GLfloat ].freeze,
+    def glTexParameterfv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glTexParameteri(target, pname, param) end => [ :void, :GLenum, :GLenum, :GLint ].freeze,
+    def glTexParameteriv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glViewport(x, y, width, height) end => [ :void, :GLint, :GLint, :GLsizei, :GLsizei ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/versions/GL_VERSION_1_1.rb

@@ -1,35 +1,19 @@
 # Unlike other extensions, functions from this module are not pointers.
 
 module GL_VERSION_1_1
-  module Functions
-    def glBindTexture(target, texture) end
-    def glCopyTexImage1D(target, level, internalformat, x, y, width, border) end
-    def glCopyTexImage2D(target, level, internalformat, x, y, width, height, border) end
-    def glCopyTexSubImage1D(target, level, xoffset, x, y, width) end
-    def glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) end
-    def glDeleteTextures(n, textures) end
-    def glDrawArrays(mode, first, count) end
-    def glDrawElements(mode, count, type, indices) end
-    def glGenTextures(n, textures) end
-    def glIsTexture(texture) end
-    def glPolygonOffset(factor, units) end
-    def glTexSubImage1D(target, level, xoffset, width, format, type, pixels) end
-    def glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) end
-
-    Parameters = {
-      glBindTexture:       [ :void, :GLenum, :GLuint ].freeze,
-      glCopyTexImage1D:    [ :void, :GLenum, :GLint, :GLenum, :GLint, :GLint, :GLsizei, :GLint ].freeze,
-      glCopyTexImage2D:    [ :void, :GLenum, :GLint, :GLenum, :GLint, :GLint, :GLsizei, :GLsizei, :GLint ].freeze,
-      glCopyTexSubImage1D: [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLsizei ].freeze,
-      glCopyTexSubImage2D: [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei ].freeze,
-      glDeleteTextures:    [ :void, :GLsizei, :pointer ].freeze,
-      glDrawArrays:        [ :void, :GLenum, :GLint, :GLsizei ].freeze,
-      glDrawElements:      [ :void, :GLenum, :GLsizei, :GLenum, :pointer ].freeze,
-      glGenTextures:       [ :void, :GLsizei, :pointer ].freeze,
-      glIsTexture:         [ :GLboolean, :GLuint ].freeze,
-      glPolygonOffset:     [ :void, :GLfloat, :GLfloat ].freeze,
-      glTexSubImage1D:     [ :void, :GLenum, :GLint, :GLint, :GLsizei, :GLenum, :GLenum, :pointer ].freeze,
-      glTexSubImage2D:     [ :void, :GLenum, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLenum, :GLenum, :pointer ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glBindTexture(target, texture) end => [ :void, :GLenum, :GLuint ].freeze,
+    def glCopyTexImage1D(target, level, internalformat, x, y, width, border) end => [ :void, :GLenum, :GLint, :GLenum, :GLint, :GLint, :GLsizei, :GLint ].freeze,
+    def glCopyTexImage2D(target, level, internalformat, x, y, width, height, border) end => [ :void, :GLenum, :GLint, :GLenum, :GLint, :GLint, :GLsizei, :GLsizei, :GLint ].freeze,
+    def glCopyTexSubImage1D(target, level, xoffset, x, y, width) end => [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLsizei ].freeze,
+    def glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height) end => [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei ].freeze,
+    def glDeleteTextures(n, textures) end => [ :void, :GLsizei, :pointer ].freeze,
+    def glDrawArrays(mode, first, count) end => [ :void, :GLenum, :GLint, :GLsizei ].freeze,
+    def glDrawElements(mode, count, type, indices) end => [ :void, :GLenum, :GLsizei, :GLenum, :pointer ].freeze,
+    def glGenTextures(n, textures) end => [ :void, :GLsizei, :pointer ].freeze,
+    def glIsTexture(texture) end => [ :GLboolean, :GLuint ].freeze,
+    def glPolygonOffset(factor, units) end => [ :void, :GLfloat, :GLfloat ].freeze,
+    def glTexSubImage1D(target, level, xoffset, width, format, type, pixels) end => [ :void, :GLenum, :GLint, :GLint, :GLsizei, :GLenum, :GLenum, :pointer ].freeze,
+    def glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) end => [ :void, :GLenum, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLenum, :GLenum, :pointer ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/versions/GL_VERSION_1_2.rb

@@ -47,17 +47,10 @@ module GL_VERSION_1_2
     :GL_ARB_imaging
   ].freeze
 
-  module Functions
-    def glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height) end
-    def glDrawRangeElements(mode, start, end_, count, type, indices) end
-    def glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels) end
-    def glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) end
-
-    Parameters = {
-      glCopyTexSubImage3D: [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei ].freeze,
-      glDrawRangeElements: [ :void, :GLenum, :GLuint, :GLuint, :GLsizei, :GLenum, :pointer ].freeze,
-      glTexImage3D:        [ :void, :GLenum, :GLint, :GLint, :GLsizei, :GLsizei, :GLsizei, :GLint, :GLenum, :GLenum, :pointer ].freeze,
-      glTexSubImage3D:     [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLsizei, :GLenum, :GLenum, :pointer ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height) end => [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei ].freeze,
+    def glDrawRangeElements(mode, start, end_, count, type, indices) end => [ :void, :GLenum, :GLuint, :GLuint, :GLsizei, :GLenum, :pointer ].freeze,
+    def glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels) end => [ :void, :GLenum, :GLint, :GLint, :GLsizei, :GLsizei, :GLsizei, :GLint, :GLenum, :GLenum, :pointer ].freeze,
+    def glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) end => [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLsizei, :GLenum, :GLenum, :pointer ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/versions/GL_VERSION_1_3.rb

@@ -98,27 +98,15 @@ module GL_VERSION_1_3
     TRANSPOSE_TEXTURE_MATRIX       = 0x84E5
   end
 
-  module Functions
-    def glActiveTexture(texture) end
-    def glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data) end
-    def glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data) end
-    def glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data) end
-    def glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data) end
-    def glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) end
-    def glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) end
-    def glGetCompressedTexImage(target, level, img) end
-    def glSampleCoverage(value, invert) end
-
-    Parameters = {
-      glActiveTexture:           [ :void, :GLenum ].freeze,
-      glCompressedTexImage1D:    [ :void, :GLenum, :GLint, :GLenum, :GLsizei, :GLint, :GLsizei, :pointer ].freeze,
-      glCompressedTexImage2D:    [ :void, :GLenum, :GLint, :GLenum, :GLsizei, :GLsizei, :GLint, :GLsizei, :pointer ].freeze,
-      glCompressedTexImage3D:    [ :void, :GLenum, :GLint, :GLenum, :GLsizei, :GLsizei, :GLsizei, :GLint, :GLsizei, :pointer ].freeze,
-      glCompressedTexSubImage1D: [ :void, :GLenum, :GLint, :GLint, :GLsizei, :GLenum, :GLsizei, :pointer ].freeze,
-      glCompressedTexSubImage2D: [ :void, :GLenum, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLenum, :GLsizei, :pointer ].freeze,
-      glCompressedTexSubImage3D: [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLsizei, :GLenum, :GLsizei, :pointer ].freeze,
-      glGetCompressedTexImage:   [ :void, :GLenum, :GLint, :pointer ].freeze,
-      glSampleCoverage:          [ :void, :GLfloat, :GLboolean ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glActiveTexture(texture) end => [ :void, :GLenum ].freeze,
+    def glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data) end => [ :void, :GLenum, :GLint, :GLenum, :GLsizei, :GLint, :GLsizei, :pointer ].freeze,
+    def glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data) end => [ :void, :GLenum, :GLint, :GLenum, :GLsizei, :GLsizei, :GLint, :GLsizei, :pointer ].freeze,
+    def glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data) end => [ :void, :GLenum, :GLint, :GLenum, :GLsizei, :GLsizei, :GLsizei, :GLint, :GLsizei, :pointer ].freeze,
+    def glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data) end => [ :void, :GLenum, :GLint, :GLint, :GLsizei, :GLenum, :GLsizei, :pointer ].freeze,
+    def glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) end => [ :void, :GLenum, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLenum, :GLsizei, :pointer ].freeze,
+    def glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) end => [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLsizei, :GLenum, :GLsizei, :pointer ].freeze,
+    def glGetCompressedTexImage(target, level, img) end => [ :void, :GLenum, :GLint, :pointer ].freeze,
+    def glSampleCoverage(value, invert) end => [ :void, :GLfloat, :GLboolean ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/versions/GL_VERSION_1_4.rb

@@ -41,23 +41,13 @@ module GL_VERSION_1_4
     TEXTURE_LOD_BIAS              = 0x8501
   end
 
-  module Functions
-    def glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha) end
-    def glMultiDrawArrays(mode, first, count, drawcount) end
-    def glMultiDrawElements(mode, count, type, indices, drawcount) end
-    def glPointParameterf(pname, param) end
-    def glPointParameterfv(pname, params) end
-    def glPointParameteri(pname, param) end
-    def glPointParameteriv(pname, params) end
-
-    Parameters = {
-      glBlendFuncSeparate: [ :void, :GLenum, :GLenum, :GLenum, :GLenum ].freeze,
-      glMultiDrawArrays:   [ :void, :GLenum, :pointer, :pointer, :GLsizei ].freeze,
-      glMultiDrawElements: [ :void, :GLenum, :pointer, :GLenum, :pointer, :GLsizei ].freeze,
-      glPointParameterf:   [ :void, :GLenum, :GLfloat ].freeze,
-      glPointParameterfv:  [ :void, :GLenum, :pointer ].freeze,
-      glPointParameteri:   [ :void, :GLenum, :GLint ].freeze,
-      glPointParameteriv:  [ :void, :GLenum, :pointer ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha) end => [ :void, :GLenum, :GLenum, :GLenum, :GLenum ].freeze,
+    def glMultiDrawArrays(mode, first, count, drawcount) end => [ :void, :GLenum, :pointer, :pointer, :GLsizei ].freeze,
+    def glMultiDrawElements(mode, count, type, indices, drawcount) end => [ :void, :GLenum, :pointer, :GLenum, :pointer, :GLsizei ].freeze,
+    def glPointParameterf(pname, param) end => [ :void, :GLenum, :GLfloat ].freeze,
+    def glPointParameterfv(pname, params) end => [ :void, :GLenum, :pointer ].freeze,
+    def glPointParameteri(pname, param) end => [ :void, :GLenum, :GLint ].freeze,
+    def glPointParameteriv(pname, params) end => [ :void, :GLenum, :pointer ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/versions/GL_VERSION_1_5.rb

@@ -51,47 +51,25 @@ module GL_VERSION_1_5
     WRITE_ONLY                           = 0x88B9
   end
 
-  module Functions
-    def glBeginQuery(target, id) end
-    def glBindBuffer(target, buffer) end
-    def glBufferData(target, size, data, usage) end
-    def glBufferSubData(target, offset, size, data) end
-    def glDeleteBuffers(n, buffers) end
-    def glDeleteQueries(n, ids) end
-    def glEndQuery(target) end
-    def glGenBuffers(n, buffers) end
-    def glGenQueries(n, ids) end
-    def glGetBufferParameteriv(target, pname, params) end
-    def glGetBufferPointerv(target, pname, params) end
-    def glGetBufferSubData(target, offset, size, data) end
-    def glGetQueryiv(target, pname, params) end
-    def glGetQueryObjectiv(id, pname, params) end
-    def glGetQueryObjectuiv(id, pname, params) end
-    def glIsBuffer(buffer) end
-    def glIsQuery(id) end
-    def glMapBuffer(target, access) end
-    def glUnmapBuffer(target) end
-
-    Parameters = {
-      glBeginQuery:           [ :void, :GLenum, :GLuint ].freeze,
-      glBindBuffer:           [ :void, :GLenum, :GLuint ].freeze,
-      glBufferData:           [ :void, :GLenum, :GLsizeiptr, :pointer, :GLenum ].freeze,
-      glBufferSubData:        [ :void, :GLenum, :GLintptr, :GLsizeiptr, :pointer ].freeze,
-      glDeleteBuffers:        [ :void, :GLsizei, :pointer ].freeze,
-      glDeleteQueries:        [ :void, :GLsizei, :pointer ].freeze,
-      glEndQuery:             [ :void, :GLenum ].freeze,
-      glGenBuffers:           [ :void, :GLsizei, :pointer ].freeze,
-      glGenQueries:           [ :void, :GLsizei, :pointer ].freeze,
-      glGetBufferParameteriv: [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glGetBufferPointerv:    [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glGetBufferSubData:     [ :void, :GLenum, :GLintptr, :GLsizeiptr, :pointer ].freeze,
-      glGetQueryiv:           [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glGetQueryObjectiv:     [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetQueryObjectuiv:    [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glIsBuffer:             [ :GLboolean, :GLuint ].freeze,
-      glIsQuery:              [ :GLboolean, :GLuint ].freeze,
-      glMapBuffer:            [ :pointer, :GLenum, :GLenum ].freeze,
-      glUnmapBuffer:          [ :GLboolean, :GLenum ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glBeginQuery(target, id) end => [ :void, :GLenum, :GLuint ].freeze,
+    def glBindBuffer(target, buffer) end => [ :void, :GLenum, :GLuint ].freeze,
+    def glBufferData(target, size, data, usage) end => [ :void, :GLenum, :GLsizeiptr, :pointer, :GLenum ].freeze,
+    def glBufferSubData(target, offset, size, data) end => [ :void, :GLenum, :GLintptr, :GLsizeiptr, :pointer ].freeze,
+    def glDeleteBuffers(n, buffers) end => [ :void, :GLsizei, :pointer ].freeze,
+    def glDeleteQueries(n, ids) end => [ :void, :GLsizei, :pointer ].freeze,
+    def glEndQuery(target) end => [ :void, :GLenum ].freeze,
+    def glGenBuffers(n, buffers) end => [ :void, :GLsizei, :pointer ].freeze,
+    def glGenQueries(n, ids) end => [ :void, :GLsizei, :pointer ].freeze,
+    def glGetBufferParameteriv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glGetBufferPointerv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glGetBufferSubData(target, offset, size, data) end => [ :void, :GLenum, :GLintptr, :GLsizeiptr, :pointer ].freeze,
+    def glGetQueryObjectiv(id, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetQueryObjectuiv(id, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetQueryiv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glIsBuffer(buffer) end => [ :GLboolean, :GLuint ].freeze,
+    def glIsQuery(id) end => [ :GLboolean, :GLuint ].freeze,
+    def glMapBuffer(target, access) end => [ :pointer, :GLenum, :GLenum ].freeze,
+    def glUnmapBuffer(target) end => [ :GLboolean, :GLenum ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/versions/GL_VERSION_2_0.rb

@@ -87,195 +87,99 @@ module GL_VERSION_2_0
     VERTEX_SHADER                    = 0x8B31
   end
 
-  module Functions
-    def glAttachShader(program, shader) end
-    def glBindAttribLocation(program, index, name) end
-    def glBlendEquationSeparate(modeRGB, modeAlpha) end
-    def glCompileShader(shader) end
-    def glCreateProgram() end
-    def glCreateShader(type) end
-    def glDeleteProgram(program) end
-    def glDeleteShader(shader) end
-    def glDetachShader(program, shader) end
-    def glDisableVertexAttribArray(index) end
-    def glDrawBuffers(n, bufs) end
-    def glEnableVertexAttribArray(index) end
-    def glGetActiveAttrib(program, index, bufSize, length, size, type, name) end
-    def glGetActiveUniform(program, index, bufSize, length, size, type, name) end
-    def glGetAttachedShaders(program, maxCount, count, shaders) end
-    def glGetAttribLocation(program, name) end
-    def glGetProgramInfoLog(program, bufSize, length, infoLog) end
-    def glGetProgramiv(program, pname, params) end
-    def glGetShaderInfoLog(shader, bufSize, length, infoLog) end
-    def glGetShaderiv(shader, pname, params) end
-    def glGetShaderSource(shader, bufSize, length, source) end
-    def glGetUniformfv(program, location, params) end
-    def glGetUniformiv(program, location, params) end
-    def glGetUniformLocation(program, name) end
-    def glGetVertexAttribdv(index, pname, params) end
-    def glGetVertexAttribfv(index, pname, params) end
-    def glGetVertexAttribiv(index, pname, params) end
-    def glGetVertexAttribPointerv(index, pname, pointer) end
-    def glIsProgram(program) end
-    def glIsShader(shader) end
-    def glLinkProgram(program) end
-    def glShaderSource(shader, count, string, length) end
-    def glStencilFuncSeparate(face, func, ref, mask) end
-    def glStencilMaskSeparate(face, mask) end
-    def glStencilOpSeparate(face, sfail, dpfail, dppass) end
-    def glUniform1f(location, v0) end
-    def glUniform1fv(location, count, value) end
-    def glUniform1i(location, v0) end
-    def glUniform1iv(location, count, value) end
-    def glUniform2f(location, v0, v1) end
-    def glUniform2fv(location, count, value) end
-    def glUniform2i(location, v0, v1) end
-    def glUniform2iv(location, count, value) end
-    def glUniform3f(location, v0, v1, v2) end
-    def glUniform3fv(location, count, value) end
-    def glUniform3i(location, v0, v1, v2) end
-    def glUniform3iv(location, count, value) end
-    def glUniform4f(location, v0, v1, v2, v3) end
-    def glUniform4fv(location, count, value) end
-    def glUniform4i(location, v0, v1, v2, v3) end
-    def glUniform4iv(location, count, value) end
-    def glUniformMatrix2fv(location, count, transpose, value) end
-    def glUniformMatrix3fv(location, count, transpose, value) end
-    def glUniformMatrix4fv(location, count, transpose, value) end
-    def glUseProgram(program) end
-    def glValidateProgram(program) end
-    def glVertexAttrib1d(index, x) end
-    def glVertexAttrib1dv(index, v) end
-    def glVertexAttrib1f(index, x) end
-    def glVertexAttrib1fv(index, v) end
-    def glVertexAttrib1s(index, x) end
-    def glVertexAttrib1sv(index, v) end
-    def glVertexAttrib2d(index, x, y) end
-    def glVertexAttrib2dv(index, v) end
-    def glVertexAttrib2f(index, x, y) end
-    def glVertexAttrib2fv(index, v) end
-    def glVertexAttrib2s(index, x, y) end
-    def glVertexAttrib2sv(index, v) end
-    def glVertexAttrib3d(index, x, y, z) end
-    def glVertexAttrib3dv(index, v) end
-    def glVertexAttrib3f(index, x, y, z) end
-    def glVertexAttrib3fv(index, v) end
-    def glVertexAttrib3s(index, x, y, z) end
-    def glVertexAttrib3sv(index, v) end
-    def glVertexAttrib4bv(index, v) end
-    def glVertexAttrib4d(index, x, y, z, w) end
-    def glVertexAttrib4dv(index, v) end
-    def glVertexAttrib4f(index, x, y, z, w) end
-    def glVertexAttrib4fv(index, v) end
-    def glVertexAttrib4iv(index, v) end
-    def glVertexAttrib4Nbv(index, v) end
-    def glVertexAttrib4Niv(index, v) end
-    def glVertexAttrib4Nsv(index, v) end
-    def glVertexAttrib4Nub(index, x, y, z, w) end
-    def glVertexAttrib4Nubv(index, v) end
-    def glVertexAttrib4Nuiv(index, v) end
-    def glVertexAttrib4Nusv(index, v) end
-    def glVertexAttrib4s(index, x, y, z, w) end
-    def glVertexAttrib4sv(index, v) end
-    def glVertexAttrib4ubv(index, v) end
-    def glVertexAttrib4uiv(index, v) end
-    def glVertexAttrib4usv(index, v) end
-    def glVertexAttribPointer(index, size, type, normalized, stride, pointer) end
-
-    Parameters = {
-      glAttachShader:             [ :void, :GLuint, :GLuint ].freeze,
-      glBindAttribLocation:       [ :void, :GLuint, :GLuint, :string ].freeze,
-      glBlendEquationSeparate:    [ :void, :GLenum, :GLenum ].freeze,
-      glCompileShader:            [ :void, :GLuint ].freeze,
-      glCreateProgram:            [ :GLuint ].freeze,
-      glCreateShader:             [ :GLuint, :GLenum ].freeze,
-      glDeleteProgram:            [ :void, :GLuint ].freeze,
-      glDeleteShader:             [ :void, :GLuint ].freeze,
-      glDetachShader:             [ :void, :GLuint, :GLuint ].freeze,
-      glDisableVertexAttribArray: [ :void, :GLuint ].freeze,
-      glDrawBuffers:              [ :void, :GLsizei, :pointer ].freeze,
-      glEnableVertexAttribArray:  [ :void, :GLuint ].freeze,
-      glGetActiveAttrib:          [ :void, :GLuint, :GLuint, :GLsizei, :pointer, :pointer, :pointer, :string ].freeze,
-      glGetActiveUniform:         [ :void, :GLuint, :GLuint, :GLsizei, :pointer, :pointer, :pointer, :string ].freeze,
-      glGetAttachedShaders:       [ :void, :GLuint, :GLsizei, :pointer, :pointer ].freeze,
-      glGetAttribLocation:        [ :GLint, :GLuint, :string ].freeze,
-      glGetProgramInfoLog:        [ :void, :GLuint, :GLsizei, :pointer, :string ].freeze,
-      glGetProgramiv:             [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetShaderInfoLog:         [ :void, :GLuint, :GLsizei, :pointer, :string ].freeze,
-      glGetShaderiv:              [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetShaderSource:          [ :void, :GLuint, :GLsizei, :pointer, :string ].freeze,
-      glGetUniformfv:             [ :void, :GLuint, :GLint, :pointer ].freeze,
-      glGetUniformiv:             [ :void, :GLuint, :GLint, :pointer ].freeze,
-      glGetUniformLocation:       [ :GLint, :GLuint, :string ].freeze,
-      glGetVertexAttribdv:        [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVertexAttribfv:        [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVertexAttribiv:        [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVertexAttribPointerv:  [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glIsProgram:                [ :GLboolean, :GLuint ].freeze,
-      glIsShader:                 [ :GLboolean, :GLuint ].freeze,
-      glLinkProgram:              [ :void, :GLuint ].freeze,
-      glShaderSource:             [ :void, :GLuint, :GLsizei, :string, :pointer ].freeze,
-      glStencilFuncSeparate:      [ :void, :GLenum, :GLenum, :GLint, :GLuint ].freeze,
-      glStencilMaskSeparate:      [ :void, :GLenum, :GLuint ].freeze,
-      glStencilOpSeparate:        [ :void, :GLenum, :GLenum, :GLenum, :GLenum ].freeze,
-      glUniform1f:                [ :void, :GLint, :GLfloat ].freeze,
-      glUniform1fv:               [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniform1i:                [ :void, :GLint, :GLint ].freeze,
-      glUniform1iv:               [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniform2f:                [ :void, :GLint, :GLfloat, :GLfloat ].freeze,
-      glUniform2fv:               [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniform2i:                [ :void, :GLint, :GLint, :GLint ].freeze,
-      glUniform2iv:               [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniform3f:                [ :void, :GLint, :GLfloat, :GLfloat, :GLfloat ].freeze,
-      glUniform3fv:               [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniform3i:                [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
-      glUniform3iv:               [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniform4f:                [ :void, :GLint, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-      glUniform4fv:               [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniform4i:                [ :void, :GLint, :GLint, :GLint, :GLint, :GLint ].freeze,
-      glUniform4iv:               [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniformMatrix2fv:         [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
-      glUniformMatrix3fv:         [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
-      glUniformMatrix4fv:         [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
-      glUseProgram:               [ :void, :GLuint ].freeze,
-      glValidateProgram:          [ :void, :GLuint ].freeze,
-      glVertexAttrib1d:           [ :void, :GLuint, :GLdouble ].freeze,
-      glVertexAttrib1dv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib1f:           [ :void, :GLuint, :GLfloat ].freeze,
-      glVertexAttrib1fv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib1s:           [ :void, :GLuint, :GLshort ].freeze,
-      glVertexAttrib1sv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib2d:           [ :void, :GLuint, :GLdouble, :GLdouble ].freeze,
-      glVertexAttrib2dv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib2f:           [ :void, :GLuint, :GLfloat, :GLfloat ].freeze,
-      glVertexAttrib2fv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib2s:           [ :void, :GLuint, :GLshort, :GLshort ].freeze,
-      glVertexAttrib2sv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib3d:           [ :void, :GLuint, :GLdouble, :GLdouble, :GLdouble ].freeze,
-      glVertexAttrib3dv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib3f:           [ :void, :GLuint, :GLfloat, :GLfloat, :GLfloat ].freeze,
-      glVertexAttrib3fv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib3s:           [ :void, :GLuint, :GLshort, :GLshort, :GLshort ].freeze,
-      glVertexAttrib3sv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4bv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4d:           [ :void, :GLuint, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-      glVertexAttrib4dv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4f:           [ :void, :GLuint, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-      glVertexAttrib4fv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4iv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4Nbv:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4Niv:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4Nsv:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4Nub:         [ :void, :GLuint, :GLubyte, :GLubyte, :GLubyte, :GLubyte ].freeze,
-      glVertexAttrib4Nubv:        [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4Nuiv:        [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4Nusv:        [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4s:           [ :void, :GLuint, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
-      glVertexAttrib4sv:          [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4ubv:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4uiv:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4usv:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribPointer:      [ :void, :GLuint, :GLint, :GLenum, :GLboolean, :GLsizei, :pointer ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glAttachShader(program, shader) end => [ :void, :GLuint, :GLuint ].freeze,
+    def glBindAttribLocation(program, index, name) end => [ :void, :GLuint, :GLuint, :string ].freeze,
+    def glBlendEquationSeparate(modeRGB, modeAlpha) end => [ :void, :GLenum, :GLenum ].freeze,
+    def glCompileShader(shader) end => [ :void, :GLuint ].freeze,
+    def glCreateProgram() end => [ :GLuint ].freeze,
+    def glCreateShader(type) end => [ :GLuint, :GLenum ].freeze,
+    def glDeleteProgram(program) end => [ :void, :GLuint ].freeze,
+    def glDeleteShader(shader) end => [ :void, :GLuint ].freeze,
+    def glDetachShader(program, shader) end => [ :void, :GLuint, :GLuint ].freeze,
+    def glDisableVertexAttribArray(index) end => [ :void, :GLuint ].freeze,
+    def glDrawBuffers(n, bufs) end => [ :void, :GLsizei, :pointer ].freeze,
+    def glEnableVertexAttribArray(index) end => [ :void, :GLuint ].freeze,
+    def glGetActiveAttrib(program, index, bufSize, length, size, type, name) end => [ :void, :GLuint, :GLuint, :GLsizei, :pointer, :pointer, :pointer, :string ].freeze,
+    def glGetActiveUniform(program, index, bufSize, length, size, type, name) end => [ :void, :GLuint, :GLuint, :GLsizei, :pointer, :pointer, :pointer, :string ].freeze,
+    def glGetAttachedShaders(program, maxCount, count, shaders) end => [ :void, :GLuint, :GLsizei, :pointer, :pointer ].freeze,
+    def glGetAttribLocation(program, name) end => [ :GLint, :GLuint, :string ].freeze,
+    def glGetProgramInfoLog(program, bufSize, length, infoLog) end => [ :void, :GLuint, :GLsizei, :pointer, :string ].freeze,
+    def glGetProgramiv(program, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetShaderInfoLog(shader, bufSize, length, infoLog) end => [ :void, :GLuint, :GLsizei, :pointer, :string ].freeze,
+    def glGetShaderSource(shader, bufSize, length, source) end => [ :void, :GLuint, :GLsizei, :pointer, :string ].freeze,
+    def glGetShaderiv(shader, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetUniformLocation(program, name) end => [ :GLint, :GLuint, :string ].freeze,
+    def glGetUniformfv(program, location, params) end => [ :void, :GLuint, :GLint, :pointer ].freeze,
+    def glGetUniformiv(program, location, params) end => [ :void, :GLuint, :GLint, :pointer ].freeze,
+    def glGetVertexAttribPointerv(index, pname, pointer) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVertexAttribdv(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVertexAttribfv(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVertexAttribiv(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glIsProgram(program) end => [ :GLboolean, :GLuint ].freeze,
+    def glIsShader(shader) end => [ :GLboolean, :GLuint ].freeze,
+    def glLinkProgram(program) end => [ :void, :GLuint ].freeze,
+    def glShaderSource(shader, count, string, length) end => [ :void, :GLuint, :GLsizei, :string, :pointer ].freeze,
+    def glStencilFuncSeparate(face, func, ref, mask) end => [ :void, :GLenum, :GLenum, :GLint, :GLuint ].freeze,
+    def glStencilMaskSeparate(face, mask) end => [ :void, :GLenum, :GLuint ].freeze,
+    def glStencilOpSeparate(face, sfail, dpfail, dppass) end => [ :void, :GLenum, :GLenum, :GLenum, :GLenum ].freeze,
+    def glUniform1f(location, v0) end => [ :void, :GLint, :GLfloat ].freeze,
+    def glUniform1fv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniform1i(location, v0) end => [ :void, :GLint, :GLint ].freeze,
+    def glUniform1iv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniform2f(location, v0, v1) end => [ :void, :GLint, :GLfloat, :GLfloat ].freeze,
+    def glUniform2fv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniform2i(location, v0, v1) end => [ :void, :GLint, :GLint, :GLint ].freeze,
+    def glUniform2iv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniform3f(location, v0, v1, v2) end => [ :void, :GLint, :GLfloat, :GLfloat, :GLfloat ].freeze,
+    def glUniform3fv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniform3i(location, v0, v1, v2) end => [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
+    def glUniform3iv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniform4f(location, v0, v1, v2, v3) end => [ :void, :GLint, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+    def glUniform4fv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniform4i(location, v0, v1, v2, v3) end => [ :void, :GLint, :GLint, :GLint, :GLint, :GLint ].freeze,
+    def glUniform4iv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniformMatrix2fv(location, count, transpose, value) end => [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
+    def glUniformMatrix3fv(location, count, transpose, value) end => [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
+    def glUniformMatrix4fv(location, count, transpose, value) end => [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
+    def glUseProgram(program) end => [ :void, :GLuint ].freeze,
+    def glValidateProgram(program) end => [ :void, :GLuint ].freeze,
+    def glVertexAttrib1d(index, x) end => [ :void, :GLuint, :GLdouble ].freeze,
+    def glVertexAttrib1dv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib1f(index, x) end => [ :void, :GLuint, :GLfloat ].freeze,
+    def glVertexAttrib1fv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib1s(index, x) end => [ :void, :GLuint, :GLshort ].freeze,
+    def glVertexAttrib1sv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib2d(index, x, y) end => [ :void, :GLuint, :GLdouble, :GLdouble ].freeze,
+    def glVertexAttrib2dv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib2f(index, x, y) end => [ :void, :GLuint, :GLfloat, :GLfloat ].freeze,
+    def glVertexAttrib2fv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib2s(index, x, y) end => [ :void, :GLuint, :GLshort, :GLshort ].freeze,
+    def glVertexAttrib2sv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib3d(index, x, y, z) end => [ :void, :GLuint, :GLdouble, :GLdouble, :GLdouble ].freeze,
+    def glVertexAttrib3dv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib3f(index, x, y, z) end => [ :void, :GLuint, :GLfloat, :GLfloat, :GLfloat ].freeze,
+    def glVertexAttrib3fv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib3s(index, x, y, z) end => [ :void, :GLuint, :GLshort, :GLshort, :GLshort ].freeze,
+    def glVertexAttrib3sv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4Nbv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4Niv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4Nsv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4Nub(index, x, y, z, w) end => [ :void, :GLuint, :GLubyte, :GLubyte, :GLubyte, :GLubyte ].freeze,
+    def glVertexAttrib4Nubv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4Nuiv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4Nusv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4bv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4d(index, x, y, z, w) end => [ :void, :GLuint, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+    def glVertexAttrib4dv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4f(index, x, y, z, w) end => [ :void, :GLuint, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+    def glVertexAttrib4fv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4iv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4s(index, x, y, z, w) end => [ :void, :GLuint, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
+    def glVertexAttrib4sv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4ubv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4uiv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4usv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribPointer(index, size, type, normalized, stride, pointer) end => [ :void, :GLuint, :GLint, :GLenum, :GLboolean, :GLsizei, :pointer ].freeze,
+  }.freeze
 end