opengl-definitions 1.0.0 → 2.0.0

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

@@ -25,21 +25,12 @@ module GL_VERSION_2_1
     SRGB8_ALPHA8                   = 0x8C43
   end
 
-  module Functions
-    def glUniformMatrix2x3fv(location, count, transpose, value) end
-    def glUniformMatrix2x4fv(location, count, transpose, value) end
-    def glUniformMatrix3x2fv(location, count, transpose, value) end
-    def glUniformMatrix3x4fv(location, count, transpose, value) end
-    def glUniformMatrix4x2fv(location, count, transpose, value) end
-    def glUniformMatrix4x3fv(location, count, transpose, value) end
-
-    Parameters = {
-      glUniformMatrix2x3fv: [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
-      glUniformMatrix2x4fv: [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
-      glUniformMatrix3x2fv: [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
-      glUniformMatrix3x4fv: [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
-      glUniformMatrix4x2fv: [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
-      glUniformMatrix4x3fv: [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glUniformMatrix2x3fv(location, count, transpose, value) end => [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
+    def glUniformMatrix2x4fv(location, count, transpose, value) end => [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
+    def glUniformMatrix3x2fv(location, count, transpose, value) end => [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
+    def glUniformMatrix3x4fv(location, count, transpose, value) end => [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
+    def glUniformMatrix4x2fv(location, count, transpose, value) end => [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
+    def glUniformMatrix4x3fv(location, count, transpose, value) end => [ :void, :GLint, :GLsizei, :GLboolean, :pointer ].freeze,
+  }.freeze
 end

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

@@ -118,119 +118,61 @@ module GL_VERSION_3_0
     :GL_ARB_vertex_array_object
   ].freeze
 
-  module Functions
-    def glBeginConditionalRender(id, mode) end
-    def glBeginTransformFeedback(primitiveMode) end
-    def glBindFragDataLocation(program, color, name) end
-    def glClampColor(target, clamp) end
-    def glClearBufferfi(buffer, drawbuffer, depth, stencil) end
-    def glClearBufferfv(buffer, drawbuffer, value) end
-    def glClearBufferiv(buffer, drawbuffer, value) end
-    def glClearBufferuiv(buffer, drawbuffer, value) end
-    def glColorMaski(index, r, g, b, a) end
-    def glDisablei(target, index) end
-    def glEnablei(target, index) end
-    def glEndConditionalRender() end
-    def glEndTransformFeedback() end
-    def glGetBooleani_v(target, index, data) end
-    def glGetFragDataLocation(program, name) end
-    def glGetStringi(name, index) end
-    def glGetTexParameterIiv(target, pname, params) end
-    def glGetTexParameterIuiv(target, pname, params) end
-    def glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name) end
-    def glGetUniformuiv(program, location, params) end
-    def glGetVertexAttribIiv(index, pname, params) end
-    def glGetVertexAttribIuiv(index, pname, params) end
-    def glIsEnabledi(target, index) end
-    def glTexParameterIiv(target, pname, params) end
-    def glTexParameterIuiv(target, pname, params) end
-    def glTransformFeedbackVaryings(program, count, varyings, bufferMode) end
-    def glUniform1ui(location, v0) end
-    def glUniform1uiv(location, count, value) end
-    def glUniform2ui(location, v0, v1) end
-    def glUniform2uiv(location, count, value) end
-    def glUniform3ui(location, v0, v1, v2) end
-    def glUniform3uiv(location, count, value) end
-    def glUniform4ui(location, v0, v1, v2, v3) end
-    def glUniform4uiv(location, count, value) end
-    def glVertexAttribI1i(index, x) end
-    def glVertexAttribI1iv(index, v) end
-    def glVertexAttribI1ui(index, x) end
-    def glVertexAttribI1uiv(index, v) end
-    def glVertexAttribI2i(index, x, y) end
-    def glVertexAttribI2iv(index, v) end
-    def glVertexAttribI2ui(index, x, y) end
-    def glVertexAttribI2uiv(index, v) end
-    def glVertexAttribI3i(index, x, y, z) end
-    def glVertexAttribI3iv(index, v) end
-    def glVertexAttribI3ui(index, x, y, z) end
-    def glVertexAttribI3uiv(index, v) end
-    def glVertexAttribI4bv(index, v) end
-    def glVertexAttribI4i(index, x, y, z, w) end
-    def glVertexAttribI4iv(index, v) end
-    def glVertexAttribI4sv(index, v) end
-    def glVertexAttribI4ubv(index, v) end
-    def glVertexAttribI4ui(index, x, y, z, w) end
-    def glVertexAttribI4uiv(index, v) end
-    def glVertexAttribI4usv(index, v) end
-    def glVertexAttribIPointer(index, size, type, stride, pointer) end
-
-    Parameters = {
-      glBeginConditionalRender:      [ :void, :GLuint, :GLenum ].freeze,
-      glBeginTransformFeedback:      [ :void, :GLenum ].freeze,
-      glBindFragDataLocation:        [ :void, :GLuint, :GLuint, :string ].freeze,
-      glClampColor:                  [ :void, :GLenum, :GLenum ].freeze,
-      glClearBufferfi:               [ :void, :GLenum, :GLint, :GLfloat, :GLint ].freeze,
-      glClearBufferfv:               [ :void, :GLenum, :GLint, :pointer ].freeze,
-      glClearBufferiv:               [ :void, :GLenum, :GLint, :pointer ].freeze,
-      glClearBufferuiv:              [ :void, :GLenum, :GLint, :pointer ].freeze,
-      glColorMaski:                  [ :void, :GLuint, :GLboolean, :GLboolean, :GLboolean, :GLboolean ].freeze,
-      glDisablei:                    [ :void, :GLenum, :GLuint ].freeze,
-      glEnablei:                     [ :void, :GLenum, :GLuint ].freeze,
-      glEndConditionalRender:        [ :void ].freeze,
-      glEndTransformFeedback:        [ :void ].freeze,
-      glGetBooleani_v:               [ :void, :GLenum, :GLuint, :pointer ].freeze,
-      glGetFragDataLocation:         [ :GLint, :GLuint, :string ].freeze,
-      glGetStringi:                  [ :string, :GLenum, :GLuint ].freeze,
-      glGetTexParameterIiv:          [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glGetTexParameterIuiv:         [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glGetTransformFeedbackVarying: [ :void, :GLuint, :GLuint, :GLsizei, :pointer, :pointer, :pointer, :string ].freeze,
-      glGetUniformuiv:               [ :void, :GLuint, :GLint, :pointer ].freeze,
-      glGetVertexAttribIiv:          [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVertexAttribIuiv:         [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glIsEnabledi:                  [ :GLboolean, :GLenum, :GLuint ].freeze,
-      glTexParameterIiv:             [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glTexParameterIuiv:            [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glTransformFeedbackVaryings:   [ :void, :GLuint, :GLsizei, :pointer, :GLenum ].freeze,
-      glUniform1ui:                  [ :void, :GLint, :GLuint ].freeze,
-      glUniform1uiv:                 [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniform2ui:                  [ :void, :GLint, :GLuint, :GLuint ].freeze,
-      glUniform2uiv:                 [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniform3ui:                  [ :void, :GLint, :GLuint, :GLuint, :GLuint ].freeze,
-      glUniform3uiv:                 [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glUniform4ui:                  [ :void, :GLint, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
-      glUniform4uiv:                 [ :void, :GLint, :GLsizei, :pointer ].freeze,
-      glVertexAttribI1i:             [ :void, :GLuint, :GLint ].freeze,
-      glVertexAttribI1iv:            [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI1ui:            [ :void, :GLuint, :GLuint ].freeze,
-      glVertexAttribI1uiv:           [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI2i:             [ :void, :GLuint, :GLint, :GLint ].freeze,
-      glVertexAttribI2iv:            [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI2ui:            [ :void, :GLuint, :GLuint, :GLuint ].freeze,
-      glVertexAttribI2uiv:           [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI3i:             [ :void, :GLuint, :GLint, :GLint, :GLint ].freeze,
-      glVertexAttribI3iv:            [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI3ui:            [ :void, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
-      glVertexAttribI3uiv:           [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4bv:            [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4i:             [ :void, :GLuint, :GLint, :GLint, :GLint, :GLint ].freeze,
-      glVertexAttribI4iv:            [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4sv:            [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4ubv:           [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4ui:            [ :void, :GLuint, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
-      glVertexAttribI4uiv:           [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4usv:           [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribIPointer:        [ :void, :GLuint, :GLint, :GLenum, :GLsizei, :pointer ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glBeginConditionalRender(id, mode) end => [ :void, :GLuint, :GLenum ].freeze,
+    def glBeginTransformFeedback(primitiveMode) end => [ :void, :GLenum ].freeze,
+    def glBindFragDataLocation(program, color, name) end => [ :void, :GLuint, :GLuint, :string ].freeze,
+    def glClampColor(target, clamp) end => [ :void, :GLenum, :GLenum ].freeze,
+    def glClearBufferfi(buffer, drawbuffer, depth, stencil) end => [ :void, :GLenum, :GLint, :GLfloat, :GLint ].freeze,
+    def glClearBufferfv(buffer, drawbuffer, value) end => [ :void, :GLenum, :GLint, :pointer ].freeze,
+    def glClearBufferiv(buffer, drawbuffer, value) end => [ :void, :GLenum, :GLint, :pointer ].freeze,
+    def glClearBufferuiv(buffer, drawbuffer, value) end => [ :void, :GLenum, :GLint, :pointer ].freeze,
+    def glColorMaski(index, r, g, b, a) end => [ :void, :GLuint, :GLboolean, :GLboolean, :GLboolean, :GLboolean ].freeze,
+    def glDisablei(target, index) end => [ :void, :GLenum, :GLuint ].freeze,
+    def glEnablei(target, index) end => [ :void, :GLenum, :GLuint ].freeze,
+    def glEndConditionalRender() end => [ :void ].freeze,
+    def glEndTransformFeedback() end => [ :void ].freeze,
+    def glGetBooleani_v(target, index, data) end => [ :void, :GLenum, :GLuint, :pointer ].freeze,
+    def glGetFragDataLocation(program, name) end => [ :GLint, :GLuint, :string ].freeze,
+    def glGetStringi(name, index) end => [ :string, :GLenum, :GLuint ].freeze,
+    def glGetTexParameterIiv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glGetTexParameterIuiv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name) end => [ :void, :GLuint, :GLuint, :GLsizei, :pointer, :pointer, :pointer, :string ].freeze,
+    def glGetUniformuiv(program, location, params) end => [ :void, :GLuint, :GLint, :pointer ].freeze,
+    def glGetVertexAttribIiv(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVertexAttribIuiv(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glIsEnabledi(target, index) end => [ :GLboolean, :GLenum, :GLuint ].freeze,
+    def glTexParameterIiv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glTexParameterIuiv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glTransformFeedbackVaryings(program, count, varyings, bufferMode) end => [ :void, :GLuint, :GLsizei, :pointer, :GLenum ].freeze,
+    def glUniform1ui(location, v0) end => [ :void, :GLint, :GLuint ].freeze,
+    def glUniform1uiv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniform2ui(location, v0, v1) end => [ :void, :GLint, :GLuint, :GLuint ].freeze,
+    def glUniform2uiv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniform3ui(location, v0, v1, v2) end => [ :void, :GLint, :GLuint, :GLuint, :GLuint ].freeze,
+    def glUniform3uiv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glUniform4ui(location, v0, v1, v2, v3) end => [ :void, :GLint, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
+    def glUniform4uiv(location, count, value) end => [ :void, :GLint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribI1i(index, x) end => [ :void, :GLuint, :GLint ].freeze,
+    def glVertexAttribI1iv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI1ui(index, x) end => [ :void, :GLuint, :GLuint ].freeze,
+    def glVertexAttribI1uiv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI2i(index, x, y) end => [ :void, :GLuint, :GLint, :GLint ].freeze,
+    def glVertexAttribI2iv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI2ui(index, x, y) end => [ :void, :GLuint, :GLuint, :GLuint ].freeze,
+    def glVertexAttribI2uiv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI3i(index, x, y, z) end => [ :void, :GLuint, :GLint, :GLint, :GLint ].freeze,
+    def glVertexAttribI3iv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI3ui(index, x, y, z) end => [ :void, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
+    def glVertexAttribI3uiv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4bv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4i(index, x, y, z, w) end => [ :void, :GLuint, :GLint, :GLint, :GLint, :GLint ].freeze,
+    def glVertexAttribI4iv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4sv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4ubv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4ui(index, x, y, z, w) end => [ :void, :GLuint, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
+    def glVertexAttribI4uiv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4usv(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribIPointer(index, size, type, stride, pointer) end => [ :void, :GLuint, :GLint, :GLenum, :GLsizei, :pointer ].freeze,
+  }.freeze
 end

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

@@ -41,17 +41,10 @@ module GL_VERSION_3_1
     :GL_ARB_uniform_buffer_object
   ].freeze
 
-  module Functions
-    def glDrawArraysInstanced(mode, first, count, instancecount) end
-    def glDrawElementsInstanced(mode, count, type, indices, instancecount) end
-    def glPrimitiveRestartIndex(index) end
-    def glTexBuffer(target, internalformat, buffer) end
-
-    Parameters = {
-      glDrawArraysInstanced:   [ :void, :GLenum, :GLint, :GLsizei, :GLsizei ].freeze,
-      glDrawElementsInstanced: [ :void, :GLenum, :GLsizei, :GLenum, :pointer, :GLsizei ].freeze,
-      glPrimitiveRestartIndex: [ :void, :GLuint ].freeze,
-      glTexBuffer:             [ :void, :GLenum, :GLenum, :GLuint ].freeze
-    }.freeze
-  end
-end
+  Functions = {
+    def glDrawArraysInstanced(mode, first, count, instancecount) end => [ :void, :GLenum, :GLint, :GLsizei, :GLsizei ].freeze,
+    def glDrawElementsInstanced(mode, count, type, indices, instancecount) end => [ :void, :GLenum, :GLsizei, :GLenum, :pointer, :GLsizei ].freeze,
+    def glPrimitiveRestartIndex(index) end => [ :void, :GLuint ].freeze,
+    def glTexBuffer(target, internalformat, buffer) end => [ :void, :GLenum, :GLenum, :GLuint ].freeze,
+  }.freeze
+end

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

@@ -31,15 +31,9 @@ module GL_VERSION_3_2
     :GL_ARB_texture_multisample
   ].freeze
 
-  module Functions
-    def glFramebufferTexture(target, attachment, texture, level) end
-    def glGetBufferParameteri64v(target, pname, params) end
-    def glGetInteger64i_v(target, index, data) end
-
-    Parameters = {
-      glFramebufferTexture:     [ :void, :GLenum, :GLenum, :GLuint, :GLint ].freeze,
-      glGetBufferParameteri64v: [ :void, :GLenum, :GLenum, :pointer ].freeze,
-      glGetInteger64i_v:        [ :void, :GLenum, :GLuint, :pointer ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glFramebufferTexture(target, attachment, texture, level) end => [ :void, :GLenum, :GLenum, :GLuint, :GLint ].freeze,
+    def glGetBufferParameteri64v(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+    def glGetInteger64i_v(target, index, data) end => [ :void, :GLenum, :GLuint, :pointer ].freeze,
+  }.freeze
 end

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

@@ -15,11 +15,7 @@ module GL_VERSION_3_3
     :GL_ARB_vertex_type_2_10_10_10_rev
   ].freeze
 
-  module Functions
-    def glVertexAttribDivisor(index, divisor) end
-
-    Parameters = {
-      glVertexAttribDivisor: [ :void, :GLuint, :GLuint ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glVertexAttribDivisor(index, divisor) end => [ :void, :GLuint, :GLuint ].freeze,
+  }.freeze
 end

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

@@ -28,19 +28,11 @@ module GL_VERSION_4_0
     :GL_ARB_transform_feedback3
   ].freeze
 
-  module Functions
-    def glBlendEquationi(buf, mode) end
-    def glBlendEquationSeparatei(buf, modeRGB, modeAlpha) end
-    def glBlendFunci(buf, src, dst) end
-    def glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha) end
-    def glMinSampleShading(value) end
-
-    Parameters = {
-      glBlendEquationi:         [ :void, :GLuint, :GLenum ].freeze,
-      glBlendEquationSeparatei: [ :void, :GLuint, :GLenum, :GLenum ].freeze,
-      glBlendFunci:             [ :void, :GLuint, :GLenum, :GLenum ].freeze,
-      glBlendFuncSeparatei:     [ :void, :GLuint, :GLenum, :GLenum, :GLenum, :GLenum ].freeze,
-      glMinSampleShading:       [ :void, :GLfloat ].freeze
-    }.freeze
-  end
+  Functions = {
+    def glBlendEquationSeparatei(buf, modeRGB, modeAlpha) end => [ :void, :GLuint, :GLenum, :GLenum ].freeze,
+    def glBlendEquationi(buf, mode) end => [ :void, :GLuint, :GLenum ].freeze,
+    def glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha) end => [ :void, :GLuint, :GLenum, :GLenum, :GLenum, :GLenum ].freeze,
+    def glBlendFunci(buf, src, dst) end => [ :void, :GLuint, :GLenum, :GLenum ].freeze,
+    def glMinSampleShading(value) end => [ :void, :GLfloat ].freeze,
+  }.freeze
 end

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

@@ -1,4 +1,4 @@
-module GL_VERSIONS_4_2
+module GL_VERSION_4_2
   Extensions = [
     :GL_ARB_base_instance,
     :GL_ARB_internalformat_query,

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

@@ -2,516 +2,260 @@
 
 module GL_VERSION_1_0
   module Compatibility
-    module Functions
-      def glAccum(op, value) end
-      def glAlphaFunc(func, ref) end
-      def glBegin(mode) end
-      def glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap) end
-      def glCallList(list) end
-      def glCallLists(n, type, lists) end
-      def glClearAccum(red, green, blue, alpha) end
-      def glClearIndex(c) end
-      def glClipPlane(plane, equation) end
-      def glColor3b(red, green, blue) end
-      def glColor3bv(v) end
-      def glColor3d(red, green, blue) end
-      def glColor3dv(v) end
-      def glColor3f(red, green, blue) end
-      def glColor3fv(v) end
-      def glColor3i(red, green, blue) end
-      def glColor3iv(v) end
-      def glColor3s(red, green, blue) end
-      def glColor3sv(v) end
-      def glColor3ub(red, green, blue) end
-      def glColor3ubv(v) end
-      def glColor3ui(red, green, blue) end
-      def glColor3uiv(v) end
-      def glColor3us(red, green, blue) end
-      def glColor3usv(v) end
-      def glColor4b(red, green, blue, alpha) end
-      def glColor4bv(v) end
-      def glColor4d(red, green, blue, alpha) end
-      def glColor4dv(v) end
-      def glColor4f(red, green, blue, alpha) end
-      def glColor4fv(v) end
-      def glColor4i(red, green, blue, alpha) end
-      def glColor4iv(v) end
-      def glColor4s(red, green, blue, alpha) end
-      def glColor4sv(v) end
-      def glColor4ub(red, green, blue, alpha) end
-      def glColor4ubv(v) end
-      def glColor4ui(red, green, blue, alpha) end
-      def glColor4uiv(v) end
-      def glColor4us(red, green, blue, alpha) end
-      def glColor4usv(v) end
-      def glColorMaterial(face, mode) end
-      def glCopyPixels(x, y, width, height, type) end
-      def glDeleteLists(list, range) end
-      def glDrawPixels(width, height, format, type, pixels) end
-      def glEdgeFlag(flag) end
-      def glEdgeFlagv(flag) end
-      def glEnd() end
-      def glEndList() end
-      def glEvalCoord1d(u) end
-      def glEvalCoord1dv(u) end
-      def glEvalCoord1f(u) end
-      def glEvalCoord1fv(u) end
-      def glEvalCoord2d(u, v) end
-      def glEvalCoord2dv(u) end
-      def glEvalCoord2f(u, v) end
-      def glEvalCoord2fv(u) end
-      def glEvalMesh1(mode, i1, i2) end
-      def glEvalMesh2(mode, i1, i2, j1, j2) end
-      def glEvalPoint1(i) end
-      def glEvalPoint2(i, j) end
-      def glFeedbackBuffer(size, type, buffer) end
-      def glFogf(pname, param) end
-      def glFogfv(pname, params) end
-      def glFogi(pname, param) end
-      def glFogiv(pname, params) end
-      def glFrustum(left, right, bottom, top, zNear, zFar) end
-      def glGenLists(range) end
-      def glGetClipPlane(plane, equation) end
-      def glGetLightfv(light, pname, params) end
-      def glGetLightiv(light, pname, params) end
-      def glGetMapdv(target, query, v) end
-      def glGetMapfv(target, query, v) end
-      def glGetMapiv(target, query, v) end
-      def glGetMaterialfv(face, pname, params) end
-      def glGetMaterialiv(face, pname, params) end
-      def glGetPixelMapfv(map, values) end
-      def glGetPixelMapuiv(map, values) end
-      def glGetPixelMapusv(map, values) end
-      def glGetPolygonStipple(mask) end
-      def glGetTexEnvfv(target, pname, params) end
-      def glGetTexEnviv(target, pname, params) end
-      def glGetTexGenfv(coord, pname, params) end
-      def glGetTexGeniv(coord, pname, params) end
-      def glIndexd(c) end
-      def glIndexdv(c) end
-      def glIndexf(c) end
-      def glIndexfv(c) end
-      def glIndexi(c) end
-      def glIndexiv(c) end
-      def glIndexMask(mask) end
-      def glIndexs(c) end
-      def glIndexsv(c) end
-      def glInitNames() end
-      def glIsList(list) end
-      def glLightf(light, pname, param) end
-      def glLightfv(light, pname, params) end
-      def glLighti(light, pname, param) end
-      def glLightiv(light, pname, params) end
-      def glLightModelf(pname, param) end
-      def glLightModelfv(pname, params) end
-      def glLightModeli(pname, param) end
-      def glLightModeliv(pname, params) end
-      def glLineStipple(factor, pattern) end
-      def glListBase(base) end
-      def glLoadIdentity() end
-      def glLoadMatrixd(m) end
-      def glLoadMatrixf(m) end
-      def glLoadName(name) end
-      def glMap1d(target, u1, u2, stride, order, points) end
-      def glMap1f(target, u1, u2, stride, order, points) end
-      def glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) end
-      def glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) end
-      def glMaterialf(face, pname, param) end
-      def glMaterialfv(face, pname, params) end
-      def glMateriali(face, pname, param) end
-      def glMaterialiv(face, pname, params) end
-      def glMatrixMode(mode) end
-      def glMultMatrixd(m) end
-      def glMultMatrixf(m) end
-      def glNewList(list, mode) end
-      def glNormal3b(nx, ny, nz) end
-      def glNormal3bv(v) end
-      def glNormal3d(nx, ny, nz) end
-      def glNormal3dv(v) end
-      def glNormal3f(nx, ny, nz) end
-      def glNormal3fv(v) end
-      def glNormal3i(nx, ny, nz) end
-      def glNormal3iv(v) end
-      def glNormal3s(nx, ny, nz) end
-      def glNormal3sv(v) end
-      def glOrtho(left, right, bottom, top, zNear, zFar) end
-      def glPassThrough(token) end
-      def glPixelMapfv(map, mapsize, values) end
-      def glPixelMapuiv(map, mapsize, values) end
-      def glPixelMapusv(map, mapsize, values) end
-      def glPixelTransferf(pname, param) end
-      def glPixelTransferi(pname, param) end
-      def glPixelZoom(xfactor, yfactor) end
-      def glPolygonStipple(mask) end
-      def glPopAttrib() end
-      def glPopMatrix() end
-      def glPopName() end
-      def glPushAttrib(mask) end
-      def glPushMatrix() end
-      def glPushName(name) end
-      def glRasterPos2d(x, y) end
-      def glRasterPos2dv(v) end
-      def glRasterPos2f(x, y) end
-      def glRasterPos2fv(v) end
-      def glRasterPos2i(x, y) end
-      def glRasterPos2iv(v) end
-      def glRasterPos2s(x, y) end
-      def glRasterPos2sv(v) end
-      def glRasterPos3d(x, y, z) end
-      def glRasterPos3dv(v) end
-      def glRasterPos3f(x, y, z) end
-      def glRasterPos3fv(v) end
-      def glRasterPos3i(x, y, z) end
-      def glRasterPos3iv(v) end
-      def glRasterPos3s(x, y, z) end
-      def glRasterPos3sv(v) end
-      def glRasterPos4d(x, y, z, w) end
-      def glRasterPos4dv(v) end
-      def glRasterPos4f(x, y, z, w) end
-      def glRasterPos4fv(v) end
-      def glRasterPos4i(x, y, z, w) end
-      def glRasterPos4iv(v) end
-      def glRasterPos4s(x, y, z, w) end
-      def glRasterPos4sv(v) end
-      def glRectd(x1, y1, x2, y2) end
-      def glRectdv(v1, v2) end
-      def glRectf(x1, y1, x2, y2) end
-      def glRectfv(v1, v2) end
-      def glRecti(x1, y1, x2, y2) end
-      def glRectiv(v1, v2) end
-      def glRects(x1, y1, x2, y2) end
-      def glRectsv(v1, v2) end
-      def glRenderMode(mode) end
-      def glRotated(angle, x, y, z) end
-      def glRotatef(angle, x, y, z) end
-      def glScaled(x, y, z) end
-      def glScalef(x, y, z) end
-      def glSelectBuffer(size, buffer) end
-      def glShadeModel(mode) end
-      def glTexCoord1d(s) end
-      def glTexCoord1dv(v) end
-      def glTexCoord1f(s) end
-      def glTexCoord1fv(v) end
-      def glTexCoord1i(s) end
-      def glTexCoord1iv(v) end
-      def glTexCoord1s(s) end
-      def glTexCoord1sv(v) end
-      def glTexCoord2d(s, t) end
-      def glTexCoord2dv(v) end
-      def glTexCoord2f(s, t) end
-      def glTexCoord2fv(v) end
-      def glTexCoord2i(s, t) end
-      def glTexCoord2iv(v) end
-      def glTexCoord2s(s, t) end
-      def glTexCoord2sv(v) end
-      def glTexCoord3d(s, t, r) end
-      def glTexCoord3dv(v) end
-      def glTexCoord3f(s, t, r) end
-      def glTexCoord3fv(v) end
-      def glTexCoord3i(s, t, r) end
-      def glTexCoord3iv(v) end
-      def glTexCoord3s(s, t, r) end
-      def glTexCoord3sv(v) end
-      def glTexCoord4d(s, t, r, q) end
-      def glTexCoord4dv(v) end
-      def glTexCoord4f(s, t, r, q) end
-      def glTexCoord4fv(v) end
-      def glTexCoord4i(s, t, r, q) end
-      def glTexCoord4iv(v) end
-      def glTexCoord4s(s, t, r, q) end
-      def glTexCoord4sv(v) end
-      def glTexEnvf(target, pname, param) end
-      def glTexEnvfv(target, pname, params) end
-      def glTexEnvi(target, pname, param) end
-      def glTexEnviv(target, pname, params) end
-      def glTexGend(coord, pname, param) end
-      def glTexGendv(coord, pname, params) end
-      def glTexGenf(coord, pname, param) end
-      def glTexGenfv(coord, pname, params) end
-      def glTexGeni(coord, pname, param) end
-      def glTexGeniv(coord, pname, params) end
-      def glTranslated(x, y, z) end
-      def glTranslatef(x, y, z) end
-      def glVertex2d(x, y) end
-      def glVertex2dv(v) end
-      def glVertex2f(x, y) end
-      def glVertex2fv(v) end
-      def glVertex2i(x, y) end
-      def glVertex2iv(v) end
-      def glVertex2s(x, y) end
-      def glVertex2sv(v) end
-      def glVertex3d(x, y, z) end
-      def glVertex3dv(v) end
-      def glVertex3f(x, y, z) end
-      def glVertex3fv(v) end
-      def glVertex3i(x, y, z) end
-      def glVertex3iv(v) end
-      def glVertex3s(x, y, z) end
-      def glVertex3sv(v) end
-      def glVertex4d(x, y, z, w) end
-      def glVertex4dv(v) end
-      def glVertex4f(x, y, z, w) end
-      def glVertex4fv(v) end
-      def glVertex4i(x, y, z, w) end
-      def glVertex4iv(v) end
-      def glVertex4s(x, y, z, w) end
-      def glVertex4sv(v) end
-
-      Parameters = {
-        glAccum:             [ :void, :GLenum, :GLfloat ].freeze,
-        glAlphaFunc:         [ :void, :GLenum, :GLfloat ].freeze,
-        glBegin:             [ :void, :GLenum ].freeze,
-        glBitmap:            [ :void, :GLsizei, :GLsizei, :GLfloat, :GLfloat, :GLfloat, :GLfloat, :pointer ].freeze,
-        glCallList:          [ :void, :GLuint ].freeze,
-        glCallLists:         [ :void, :GLsizei, :GLenum, :pointer ].freeze,
-        glClearAccum:        [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glClearIndex:        [ :void, :GLfloat ].freeze,
-        glClipPlane:         [ :void, :GLenum, :pointer ].freeze,
-        glColor3b:           [ :void, :GLbyte, :GLbyte, :GLbyte ].freeze,
-        glColor3bv:          [ :void, :pointer ].freeze,
-        glColor3d:           [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glColor3dv:          [ :void, :pointer ].freeze,
-        glColor3f:           [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glColor3fv:          [ :void, :pointer ].freeze,
-        glColor3i:           [ :void, :GLint, :GLint, :GLint ].freeze,
-        glColor3iv:          [ :void, :pointer ].freeze,
-        glColor3s:           [ :void, :GLshort, :GLshort, :GLshort ].freeze,
-        glColor3sv:          [ :void, :pointer ].freeze,
-        glColor3ub:          [ :void, :GLubyte, :GLubyte, :GLubyte ].freeze,
-        glColor3ubv:         [ :void, :pointer ].freeze,
-        glColor3ui:          [ :void, :GLuint, :GLuint, :GLuint ].freeze,
-        glColor3uiv:         [ :void, :pointer ].freeze,
-        glColor3us:          [ :void, :GLushort, :GLushort, :GLushort ].freeze,
-        glColor3usv:         [ :void, :pointer ].freeze,
-        glColor4b:           [ :void, :GLbyte, :GLbyte, :GLbyte, :GLbyte ].freeze,
-        glColor4bv:          [ :void, :pointer ].freeze,
-        glColor4d:           [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glColor4dv:          [ :void, :pointer ].freeze,
-        glColor4f:           [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glColor4fv:          [ :void, :pointer ].freeze,
-        glColor4i:           [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
-        glColor4iv:          [ :void, :pointer ].freeze,
-        glColor4s:           [ :void, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
-        glColor4sv:          [ :void, :pointer ].freeze,
-        glColor4ub:          [ :void, :GLubyte, :GLubyte, :GLubyte, :GLubyte ].freeze,
-        glColor4ubv:         [ :void, :pointer ].freeze,
-        glColor4ui:          [ :void, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
-        glColor4uiv:         [ :void, :pointer ].freeze,
-        glColor4us:          [ :void, :GLushort, :GLushort, :GLushort, :GLushort ].freeze,
-        glColor4usv:         [ :void, :pointer ].freeze,
-        glColorMaterial:     [ :void, :GLenum, :GLenum ].freeze,
-        glCopyPixels:        [ :void, :GLint, :GLint, :GLsizei, :GLsizei, :GLenum ].freeze,
-        glDeleteLists:       [ :void, :GLuint, :GLsizei ].freeze,
-        glDrawPixels:        [ :void, :GLsizei, :GLsizei, :GLenum, :GLenum, :pointer ].freeze,
-        glEdgeFlag:          [ :void, :GLboolean ].freeze,
-        glEdgeFlagv:         [ :void, :pointer ].freeze,
-        glEnd:               [ :void ].freeze,
-        glEndList:           [ :void ].freeze,
-        glEvalCoord1d:       [ :void, :GLdouble ].freeze,
-        glEvalCoord1dv:      [ :void, :pointer ].freeze,
-        glEvalCoord1f:       [ :void, :GLfloat ].freeze,
-        glEvalCoord1fv:      [ :void, :pointer ].freeze,
-        glEvalCoord2d:       [ :void, :GLdouble, :GLdouble ].freeze,
-        glEvalCoord2dv:      [ :void, :pointer ].freeze,
-        glEvalCoord2f:       [ :void, :GLfloat, :GLfloat ].freeze,
-        glEvalCoord2fv:      [ :void, :pointer ].freeze,
-        glEvalMesh1:         [ :void, :GLenum, :GLint, :GLint ].freeze,
-        glEvalMesh2:         [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint ].freeze,
-        glEvalPoint1:        [ :void, :GLint ].freeze,
-        glEvalPoint2:        [ :void, :GLint, :GLint ].freeze,
-        glFeedbackBuffer:    [ :void, :GLsizei, :GLenum, :pointer ].freeze,
-        glFogf:              [ :void, :GLenum, :GLfloat ].freeze,
-        glFogfv:             [ :void, :GLenum, :pointer ].freeze,
-        glFogi:              [ :void, :GLenum, :GLint ].freeze,
-        glFogiv:             [ :void, :GLenum, :pointer ].freeze,
-        glFrustum:           [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glGenLists:          [ :GLuint, :GLsizei ].freeze,
-        glGetClipPlane:      [ :void, :GLenum, :pointer ].freeze,
-        glGetLightfv:        [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glGetLightiv:        [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glGetMapdv:          [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glGetMapfv:          [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glGetMapiv:          [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glGetMaterialfv:     [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glGetMaterialiv:     [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glGetPixelMapfv:     [ :void, :GLenum, :pointer ].freeze,
-        glGetPixelMapuiv:    [ :void, :GLenum, :pointer ].freeze,
-        glGetPixelMapusv:    [ :void, :GLenum, :pointer ].freeze,
-        glGetPolygonStipple: [ :void, :pointer ].freeze,
-        glGetTexEnvfv:       [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glGetTexEnviv:       [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glGetTexGenfv:       [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glGetTexGeniv:       [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glIndexd:            [ :void, :GLdouble ].freeze,
-        glIndexdv:           [ :void, :pointer ].freeze,
-        glIndexf:            [ :void, :GLfloat ].freeze,
-        glIndexfv:           [ :void, :pointer ].freeze,
-        glIndexi:            [ :void, :GLint ].freeze,
-        glIndexiv:           [ :void, :pointer ].freeze,
-        glIndexs:            [ :void, :GLshort ].freeze,
-        glIndexsv:           [ :void, :pointer ].freeze,
-        glIndexMask:         [ :void, :GLuint ].freeze,
-        glInitNames:         [ :void ].freeze,
-        glIsList:            [ :GLboolean, :GLuint ].freeze,
-        glLightf:            [ :void, :GLenum, :GLenum, :GLfloat ].freeze,
-        glLightfv:           [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glLighti:            [ :void, :GLenum, :GLenum, :GLint ].freeze,
-        glLightiv:           [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glLightModelf:       [ :void, :GLenum, :GLfloat ].freeze,
-        glLightModelfv:      [ :void, :GLenum, :pointer ].freeze,
-        glLightModeli:       [ :void, :GLenum, :GLint ].freeze,
-        glLightModeliv:      [ :void, :GLenum, :pointer ].freeze,
-        glLineStipple:       [ :void, :GLint, :GLushort ].freeze,
-        glListBase:          [ :void, :GLuint ].freeze,
-        glLoadIdentity:      [ :void ].freeze,
-        glLoadMatrixd:       [ :void, :pointer ].freeze,
-        glLoadMatrixf:       [ :void, :pointer ].freeze,
-        glLoadName:          [ :void, :GLuint ].freeze,
-        glMap1d:             [ :void, :GLenum, :GLdouble, :GLdouble, :GLint, :GLint, :pointer ].freeze,
-        glMap1f:             [ :void, :GLenum, :GLfloat, :GLfloat, :GLint, :GLint, :pointer ].freeze,
-        glMap2d:             [ :void, :GLenum, :GLdouble, :GLdouble, :GLint, :GLint, :GLdouble, :GLdouble, :GLint, :GLint, :pointer ].freeze,
-        glMap2f:             [ :void, :GLenum, :GLfloat, :GLfloat, :GLint, :GLint, :GLfloat, :GLfloat, :GLint, :GLint, :pointer ].freeze,
-        glMaterialf:         [ :void, :GLenum, :GLenum, :GLfloat ].freeze,
-        glMaterialfv:        [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glMateriali:         [ :void, :GLenum, :GLenum, :GLint ].freeze,
-        glMaterialiv:        [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glMatrixMode:        [ :void, :GLenum ].freeze,
-        glMultMatrixd:       [ :void, :pointer ].freeze,
-        glMultMatrixf:       [ :void, :pointer ].freeze,
-        glNewList:           [ :void, :GLuint, :GLenum ].freeze,
-        glNormal3b:          [ :void, :GLbyte, :GLbyte, :GLbyte ].freeze,
-        glNormal3bv:         [ :void, :pointer ].freeze,
-        glNormal3d:          [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glNormal3dv:         [ :void, :pointer ].freeze,
-        glNormal3f:          [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glNormal3fv:         [ :void, :pointer ].freeze,
-        glNormal3i:          [ :void, :GLint, :GLint, :GLint ].freeze,
-        glNormal3iv:         [ :void, :pointer ].freeze,
-        glNormal3s:          [ :void, :GLshort, :GLshort, :GLshort ].freeze,
-        glNormal3sv:         [ :void, :pointer ].freeze,
-        glOrtho:             [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glPassThrough:       [ :void, :GLfloat ].freeze,
-        glPixelMapfv:        [ :void, :GLenum, :GLsizei, :pointer ].freeze,
-        glPixelMapuiv:       [ :void, :GLenum, :GLsizei, :pointer ].freeze,
-        glPixelMapusv:       [ :void, :GLenum, :GLsizei, :pointer ].freeze,
-        glPixelTransferf:    [ :void, :GLenum, :GLfloat ].freeze,
-        glPixelTransferi:    [ :void, :GLenum, :GLint ].freeze,
-        glPixelZoom:         [ :void, :GLfloat, :GLfloat ].freeze,
-        glPolygonStipple:    [ :void, :pointer ].freeze,
-        glPopAttrib:         [ :void ].freeze,
-        glPopMatrix:         [ :void ].freeze,
-        glPopName:           [ :void ].freeze,
-        glPushAttrib:        [ :void, :GLbitfield ].freeze,
-        glPushMatrix:        [ :void ].freeze,
-        glPushName:          [ :void, :GLuint ].freeze,
-        glRasterPos2d:       [ :void, :GLdouble, :GLdouble ].freeze,
-        glRasterPos2dv:      [ :void, :pointer ].freeze,
-        glRasterPos2f:       [ :void, :GLfloat, :GLfloat ].freeze,
-        glRasterPos2fv:      [ :void, :pointer ].freeze,
-        glRasterPos2i:       [ :void, :GLint, :GLint ].freeze,
-        glRasterPos2iv:      [ :void, :pointer ].freeze,
-        glRasterPos2s:       [ :void, :GLshort, :GLshort ].freeze,
-        glRasterPos2sv:      [ :void, :pointer ].freeze,
-        glRasterPos3d:       [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glRasterPos3dv:      [ :void, :pointer ].freeze,
-        glRasterPos3f:       [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glRasterPos3fv:      [ :void, :pointer ].freeze,
-        glRasterPos3i:       [ :void, :GLint, :GLint, :GLint ].freeze,
-        glRasterPos3iv:      [ :void, :pointer ].freeze,
-        glRasterPos3s:       [ :void, :GLshort, :GLshort, :GLshort ].freeze,
-        glRasterPos3sv:      [ :void, :pointer ].freeze,
-        glRasterPos4d:       [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glRasterPos4dv:      [ :void, :pointer ].freeze,
-        glRasterPos4f:       [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glRasterPos4fv:      [ :void, :pointer ].freeze,
-        glRasterPos4i:       [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
-        glRasterPos4iv:      [ :void, :pointer ].freeze,
-        glRasterPos4s:       [ :void, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
-        glRasterPos4sv:      [ :void, :pointer ].freeze,
-        glRectd:             [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glRectdv:            [ :void, :pointer, :pointer ].freeze,
-        glRectf:             [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glRectfv:            [ :void, :pointer, :pointer ].freeze,
-        glRecti:             [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
-        glRectiv:            [ :void, :pointer, :pointer ].freeze,
-        glRects:             [ :void, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
-        glRectsv:            [ :void, :pointer, :pointer ].freeze,
-        glRenderMode:        [ :GLint, :GLenum ].freeze,
-        glRotated:           [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glRotatef:           [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glScaled:            [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glScalef:            [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glSelectBuffer:      [ :void, :GLsizei, :pointer ].freeze,
-        glShadeModel:        [ :void, :GLenum ].freeze,
-        glTexCoord1d:        [ :void, :GLdouble ].freeze,
-        glTexCoord1dv:       [ :void, :pointer ].freeze,
-        glTexCoord1f:        [ :void, :GLfloat ].freeze,
-        glTexCoord1fv:       [ :void, :pointer ].freeze,
-        glTexCoord1i:        [ :void, :GLint ].freeze,
-        glTexCoord1iv:       [ :void, :pointer ].freeze,
-        glTexCoord1s:        [ :void, :GLshort ].freeze,
-        glTexCoord1sv:       [ :void, :pointer ].freeze,
-        glTexCoord2d:        [ :void, :GLdouble, :GLdouble ].freeze,
-        glTexCoord2dv:       [ :void, :pointer ].freeze,
-        glTexCoord2f:        [ :void, :GLfloat, :GLfloat ].freeze,
-        glTexCoord2fv:       [ :void, :pointer ].freeze,
-        glTexCoord2i:        [ :void, :GLint, :GLint ].freeze,
-        glTexCoord2iv:       [ :void, :pointer ].freeze,
-        glTexCoord2s:        [ :void, :GLshort, :GLshort ].freeze,
-        glTexCoord2sv:       [ :void, :pointer ].freeze,
-        glTexCoord3d:        [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glTexCoord3dv:       [ :void, :pointer ].freeze,
-        glTexCoord3f:        [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glTexCoord3fv:       [ :void, :pointer ].freeze,
-        glTexCoord3i:        [ :void, :GLint, :GLint, :GLint ].freeze,
-        glTexCoord3iv:       [ :void, :pointer ].freeze,
-        glTexCoord3s:        [ :void, :GLshort, :GLshort, :GLshort ].freeze,
-        glTexCoord3sv:       [ :void, :pointer ].freeze,
-        glTexCoord4d:        [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glTexCoord4dv:       [ :void, :pointer ].freeze,
-        glTexCoord4f:        [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glTexCoord4fv:       [ :void, :pointer ].freeze,
-        glTexCoord4i:        [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
-        glTexCoord4iv:       [ :void, :pointer ].freeze,
-        glTexCoord4s:        [ :void, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
-        glTexCoord4sv:       [ :void, :pointer ].freeze,
-        glTexEnvf:           [ :void, :GLenum, :GLenum, :GLfloat ].freeze,
-        glTexEnvfv:          [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glTexEnvi:           [ :void, :GLenum, :GLenum, :GLint ].freeze,
-        glTexEnviv:          [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glTexGend:           [ :void, :GLenum, :GLenum, :GLdouble ].freeze,
-        glTexGendv:          [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glTexGenf:           [ :void, :GLenum, :GLenum, :GLfloat ].freeze,
-        glTexGenfv:          [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glTexGeni:           [ :void, :GLenum, :GLenum, :GLint ].freeze,
-        glTexGeniv:          [ :void, :GLenum, :GLenum, :pointer ].freeze,
-        glTranslated:        [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glTranslatef:        [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glVertex2d:          [ :void, :GLdouble, :GLdouble ].freeze,
-        glVertex2dv:         [ :void, :pointer ].freeze,
-        glVertex2f:          [ :void, :GLfloat, :GLfloat ].freeze,
-        glVertex2fv:         [ :void, :pointer ].freeze,
-        glVertex2i:          [ :void, :GLint, :GLint ].freeze,
-        glVertex2iv:         [ :void, :pointer ].freeze,
-        glVertex2s:          [ :void, :GLshort, :GLshort ].freeze,
-        glVertex2sv:         [ :void, :pointer ].freeze,
-        glVertex3d:          [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glVertex3dv:         [ :void, :pointer ].freeze,
-        glVertex3f:          [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glVertex3fv:         [ :void, :pointer ].freeze,
-        glVertex3i:          [ :void, :GLint, :GLint, :GLint ].freeze,
-        glVertex3iv:         [ :void, :pointer ].freeze,
-        glVertex3s:          [ :void, :GLshort, :GLshort, :GLshort ].freeze,
-        glVertex3sv:         [ :void, :pointer ].freeze,
-        glVertex4d:          [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-        glVertex4dv:         [ :void, :pointer ].freeze,
-        glVertex4f:          [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-        glVertex4fv:         [ :void, :pointer ].freeze,
-        glVertex4i:          [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
-        glVertex4iv:         [ :void, :pointer ].freeze,
-        glVertex4s:          [ :void, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
-        glVertex4sv:         [ :void, :pointer ].freeze
-      }.freeze
-    end
+    Functions = {
+      def glAccum(op, value) end => [ :void, :GLenum, :GLfloat ].freeze,
+      def glAlphaFunc(func, ref) end => [ :void, :GLenum, :GLfloat ].freeze,
+      def glBegin(mode) end => [ :void, :GLenum ].freeze,
+      def glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap) end => [ :void, :GLsizei, :GLsizei, :GLfloat, :GLfloat, :GLfloat, :GLfloat, :pointer ].freeze,
+      def glCallList(list) end => [ :void, :GLuint ].freeze,
+      def glCallLists(n, type, lists) end => [ :void, :GLsizei, :GLenum, :pointer ].freeze,
+      def glClearAccum(red, green, blue, alpha) end => [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glClearIndex(c) end => [ :void, :GLfloat ].freeze,
+      def glClipPlane(plane, equation) end => [ :void, :GLenum, :pointer ].freeze,
+      def glColor3b(red, green, blue) end => [ :void, :GLbyte, :GLbyte, :GLbyte ].freeze,
+      def glColor3bv(v) end => [ :void, :pointer ].freeze,
+      def glColor3d(red, green, blue) end => [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glColor3dv(v) end => [ :void, :pointer ].freeze,
+      def glColor3f(red, green, blue) end => [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glColor3fv(v) end => [ :void, :pointer ].freeze,
+      def glColor3i(red, green, blue) end => [ :void, :GLint, :GLint, :GLint ].freeze,
+      def glColor3iv(v) end => [ :void, :pointer ].freeze,
+      def glColor3s(red, green, blue) end => [ :void, :GLshort, :GLshort, :GLshort ].freeze,
+      def glColor3sv(v) end => [ :void, :pointer ].freeze,
+      def glColor3ub(red, green, blue) end => [ :void, :GLubyte, :GLubyte, :GLubyte ].freeze,
+      def glColor3ubv(v) end => [ :void, :pointer ].freeze,
+      def glColor3ui(red, green, blue) end => [ :void, :GLuint, :GLuint, :GLuint ].freeze,
+      def glColor3uiv(v) end => [ :void, :pointer ].freeze,
+      def glColor3us(red, green, blue) end => [ :void, :GLushort, :GLushort, :GLushort ].freeze,
+      def glColor3usv(v) end => [ :void, :pointer ].freeze,
+      def glColor4b(red, green, blue, alpha) end => [ :void, :GLbyte, :GLbyte, :GLbyte, :GLbyte ].freeze,
+      def glColor4bv(v) end => [ :void, :pointer ].freeze,
+      def glColor4d(red, green, blue, alpha) end => [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glColor4dv(v) end => [ :void, :pointer ].freeze,
+      def glColor4f(red, green, blue, alpha) end => [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glColor4fv(v) end => [ :void, :pointer ].freeze,
+      def glColor4i(red, green, blue, alpha) end => [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
+      def glColor4iv(v) end => [ :void, :pointer ].freeze,
+      def glColor4s(red, green, blue, alpha) end => [ :void, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
+      def glColor4sv(v) end => [ :void, :pointer ].freeze,
+      def glColor4ub(red, green, blue, alpha) end => [ :void, :GLubyte, :GLubyte, :GLubyte, :GLubyte ].freeze,
+      def glColor4ubv(v) end => [ :void, :pointer ].freeze,
+      def glColor4ui(red, green, blue, alpha) end => [ :void, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
+      def glColor4uiv(v) end => [ :void, :pointer ].freeze,
+      def glColor4us(red, green, blue, alpha) end => [ :void, :GLushort, :GLushort, :GLushort, :GLushort ].freeze,
+      def glColor4usv(v) end => [ :void, :pointer ].freeze,
+      def glColorMaterial(face, mode) end => [ :void, :GLenum, :GLenum ].freeze,
+      def glCopyPixels(x, y, width, height, type) end => [ :void, :GLint, :GLint, :GLsizei, :GLsizei, :GLenum ].freeze,
+      def glDeleteLists(list, range) end => [ :void, :GLuint, :GLsizei ].freeze,
+      def glDrawPixels(width, height, format, type, pixels) end => [ :void, :GLsizei, :GLsizei, :GLenum, :GLenum, :pointer ].freeze,
+      def glEdgeFlag(flag) end => [ :void, :GLboolean ].freeze,
+      def glEdgeFlagv(flag) end => [ :void, :pointer ].freeze,
+      def glEnd() end => [ :void ].freeze,
+      def glEndList() end => [ :void ].freeze,
+      def glEvalCoord1d(u) end => [ :void, :GLdouble ].freeze,
+      def glEvalCoord1dv(u) end => [ :void, :pointer ].freeze,
+      def glEvalCoord1f(u) end => [ :void, :GLfloat ].freeze,
+      def glEvalCoord1fv(u) end => [ :void, :pointer ].freeze,
+      def glEvalCoord2d(u, v) end => [ :void, :GLdouble, :GLdouble ].freeze,
+      def glEvalCoord2dv(u) end => [ :void, :pointer ].freeze,
+      def glEvalCoord2f(u, v) end => [ :void, :GLfloat, :GLfloat ].freeze,
+      def glEvalCoord2fv(u) end => [ :void, :pointer ].freeze,
+      def glEvalMesh1(mode, i1, i2) end => [ :void, :GLenum, :GLint, :GLint ].freeze,
+      def glEvalMesh2(mode, i1, i2, j1, j2) end => [ :void, :GLenum, :GLint, :GLint, :GLint, :GLint ].freeze,
+      def glEvalPoint1(i) end => [ :void, :GLint ].freeze,
+      def glEvalPoint2(i, j) end => [ :void, :GLint, :GLint ].freeze,
+      def glFeedbackBuffer(size, type, buffer) end => [ :void, :GLsizei, :GLenum, :pointer ].freeze,
+      def glFogf(pname, param) end => [ :void, :GLenum, :GLfloat ].freeze,
+      def glFogfv(pname, params) end => [ :void, :GLenum, :pointer ].freeze,
+      def glFogi(pname, param) end => [ :void, :GLenum, :GLint ].freeze,
+      def glFogiv(pname, params) end => [ :void, :GLenum, :pointer ].freeze,
+      def glFrustum(left, right, bottom, top, zNear, zFar) end => [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glGenLists(range) end => [ :GLuint, :GLsizei ].freeze,
+      def glGetClipPlane(plane, equation) end => [ :void, :GLenum, :pointer ].freeze,
+      def glGetLightfv(light, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glGetLightiv(light, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glGetMapdv(target, query, v) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glGetMapfv(target, query, v) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glGetMapiv(target, query, v) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glGetMaterialfv(face, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glGetMaterialiv(face, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glGetPixelMapfv(map, values) end => [ :void, :GLenum, :pointer ].freeze,
+      def glGetPixelMapuiv(map, values) end => [ :void, :GLenum, :pointer ].freeze,
+      def glGetPixelMapusv(map, values) end => [ :void, :GLenum, :pointer ].freeze,
+      def glGetPolygonStipple(mask) end => [ :void, :pointer ].freeze,
+      def glGetTexEnvfv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glGetTexEnviv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glGetTexGenfv(coord, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glGetTexGeniv(coord, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glIndexMask(mask) end => [ :void, :GLuint ].freeze,
+      def glIndexd(c) end => [ :void, :GLdouble ].freeze,
+      def glIndexdv(c) end => [ :void, :pointer ].freeze,
+      def glIndexf(c) end => [ :void, :GLfloat ].freeze,
+      def glIndexfv(c) end => [ :void, :pointer ].freeze,
+      def glIndexi(c) end => [ :void, :GLint ].freeze,
+      def glIndexiv(c) end => [ :void, :pointer ].freeze,
+      def glIndexs(c) end => [ :void, :GLshort ].freeze,
+      def glIndexsv(c) end => [ :void, :pointer ].freeze,
+      def glInitNames() end => [ :void ].freeze,
+      def glIsList(list) end => [ :GLboolean, :GLuint ].freeze,
+      def glLightModelf(pname, param) end => [ :void, :GLenum, :GLfloat ].freeze,
+      def glLightModelfv(pname, params) end => [ :void, :GLenum, :pointer ].freeze,
+      def glLightModeli(pname, param) end => [ :void, :GLenum, :GLint ].freeze,
+      def glLightModeliv(pname, params) end => [ :void, :GLenum, :pointer ].freeze,
+      def glLightf(light, pname, param) end => [ :void, :GLenum, :GLenum, :GLfloat ].freeze,
+      def glLightfv(light, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glLighti(light, pname, param) end => [ :void, :GLenum, :GLenum, :GLint ].freeze,
+      def glLightiv(light, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glLineStipple(factor, pattern) end => [ :void, :GLint, :GLushort ].freeze,
+      def glListBase(base) end => [ :void, :GLuint ].freeze,
+      def glLoadIdentity() end => [ :void ].freeze,
+      def glLoadMatrixd(m) end => [ :void, :pointer ].freeze,
+      def glLoadMatrixf(m) end => [ :void, :pointer ].freeze,
+      def glLoadName(name) end => [ :void, :GLuint ].freeze,
+      def glMap1d(target, u1, u2, stride, order, points) end => [ :void, :GLenum, :GLdouble, :GLdouble, :GLint, :GLint, :pointer ].freeze,
+      def glMap1f(target, u1, u2, stride, order, points) end => [ :void, :GLenum, :GLfloat, :GLfloat, :GLint, :GLint, :pointer ].freeze,
+      def glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) end => [ :void, :GLenum, :GLdouble, :GLdouble, :GLint, :GLint, :GLdouble, :GLdouble, :GLint, :GLint, :pointer ].freeze,
+      def glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) end => [ :void, :GLenum, :GLfloat, :GLfloat, :GLint, :GLint, :GLfloat, :GLfloat, :GLint, :GLint, :pointer ].freeze,
+      def glMaterialf(face, pname, param) end => [ :void, :GLenum, :GLenum, :GLfloat ].freeze,
+      def glMaterialfv(face, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glMateriali(face, pname, param) end => [ :void, :GLenum, :GLenum, :GLint ].freeze,
+      def glMaterialiv(face, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glMatrixMode(mode) end => [ :void, :GLenum ].freeze,
+      def glMultMatrixd(m) end => [ :void, :pointer ].freeze,
+      def glMultMatrixf(m) end => [ :void, :pointer ].freeze,
+      def glNewList(list, mode) end => [ :void, :GLuint, :GLenum ].freeze,
+      def glNormal3b(nx, ny, nz) end => [ :void, :GLbyte, :GLbyte, :GLbyte ].freeze,
+      def glNormal3bv(v) end => [ :void, :pointer ].freeze,
+      def glNormal3d(nx, ny, nz) end => [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glNormal3dv(v) end => [ :void, :pointer ].freeze,
+      def glNormal3f(nx, ny, nz) end => [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glNormal3fv(v) end => [ :void, :pointer ].freeze,
+      def glNormal3i(nx, ny, nz) end => [ :void, :GLint, :GLint, :GLint ].freeze,
+      def glNormal3iv(v) end => [ :void, :pointer ].freeze,
+      def glNormal3s(nx, ny, nz) end => [ :void, :GLshort, :GLshort, :GLshort ].freeze,
+      def glNormal3sv(v) end => [ :void, :pointer ].freeze,
+      def glOrtho(left, right, bottom, top, zNear, zFar) end => [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glPassThrough(token) end => [ :void, :GLfloat ].freeze,
+      def glPixelMapfv(map, mapsize, values) end => [ :void, :GLenum, :GLsizei, :pointer ].freeze,
+      def glPixelMapuiv(map, mapsize, values) end => [ :void, :GLenum, :GLsizei, :pointer ].freeze,
+      def glPixelMapusv(map, mapsize, values) end => [ :void, :GLenum, :GLsizei, :pointer ].freeze,
+      def glPixelTransferf(pname, param) end => [ :void, :GLenum, :GLfloat ].freeze,
+      def glPixelTransferi(pname, param) end => [ :void, :GLenum, :GLint ].freeze,
+      def glPixelZoom(xfactor, yfactor) end => [ :void, :GLfloat, :GLfloat ].freeze,
+      def glPolygonStipple(mask) end => [ :void, :pointer ].freeze,
+      def glPopAttrib() end => [ :void ].freeze,
+      def glPopMatrix() end => [ :void ].freeze,
+      def glPopName() end => [ :void ].freeze,
+      def glPushAttrib(mask) end => [ :void, :GLbitfield ].freeze,
+      def glPushMatrix() end => [ :void ].freeze,
+      def glPushName(name) end => [ :void, :GLuint ].freeze,
+      def glRasterPos2d(x, y) end => [ :void, :GLdouble, :GLdouble ].freeze,
+      def glRasterPos2dv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos2f(x, y) end => [ :void, :GLfloat, :GLfloat ].freeze,
+      def glRasterPos2fv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos2i(x, y) end => [ :void, :GLint, :GLint ].freeze,
+      def glRasterPos2iv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos2s(x, y) end => [ :void, :GLshort, :GLshort ].freeze,
+      def glRasterPos2sv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos3d(x, y, z) end => [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glRasterPos3dv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos3f(x, y, z) end => [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glRasterPos3fv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos3i(x, y, z) end => [ :void, :GLint, :GLint, :GLint ].freeze,
+      def glRasterPos3iv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos3s(x, y, z) end => [ :void, :GLshort, :GLshort, :GLshort ].freeze,
+      def glRasterPos3sv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos4d(x, y, z, w) end => [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glRasterPos4dv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos4f(x, y, z, w) end => [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glRasterPos4fv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos4i(x, y, z, w) end => [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
+      def glRasterPos4iv(v) end => [ :void, :pointer ].freeze,
+      def glRasterPos4s(x, y, z, w) end => [ :void, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
+      def glRasterPos4sv(v) end => [ :void, :pointer ].freeze,
+      def glRectd(x1, y1, x2, y2) end => [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glRectdv(v1, v2) end => [ :void, :pointer, :pointer ].freeze,
+      def glRectf(x1, y1, x2, y2) end => [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glRectfv(v1, v2) end => [ :void, :pointer, :pointer ].freeze,
+      def glRecti(x1, y1, x2, y2) end => [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
+      def glRectiv(v1, v2) end => [ :void, :pointer, :pointer ].freeze,
+      def glRects(x1, y1, x2, y2) end => [ :void, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
+      def glRectsv(v1, v2) end => [ :void, :pointer, :pointer ].freeze,
+      def glRenderMode(mode) end => [ :GLint, :GLenum ].freeze,
+      def glRotated(angle, x, y, z) end => [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glRotatef(angle, x, y, z) end => [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glScaled(x, y, z) end => [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glScalef(x, y, z) end => [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glSelectBuffer(size, buffer) end => [ :void, :GLsizei, :pointer ].freeze,
+      def glShadeModel(mode) end => [ :void, :GLenum ].freeze,
+      def glTexCoord1d(s) end => [ :void, :GLdouble ].freeze,
+      def glTexCoord1dv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord1f(s) end => [ :void, :GLfloat ].freeze,
+      def glTexCoord1fv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord1i(s) end => [ :void, :GLint ].freeze,
+      def glTexCoord1iv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord1s(s) end => [ :void, :GLshort ].freeze,
+      def glTexCoord1sv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord2d(s, t) end => [ :void, :GLdouble, :GLdouble ].freeze,
+      def glTexCoord2dv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord2f(s, t) end => [ :void, :GLfloat, :GLfloat ].freeze,
+      def glTexCoord2fv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord2i(s, t) end => [ :void, :GLint, :GLint ].freeze,
+      def glTexCoord2iv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord2s(s, t) end => [ :void, :GLshort, :GLshort ].freeze,
+      def glTexCoord2sv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord3d(s, t, r) end => [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glTexCoord3dv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord3f(s, t, r) end => [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glTexCoord3fv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord3i(s, t, r) end => [ :void, :GLint, :GLint, :GLint ].freeze,
+      def glTexCoord3iv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord3s(s, t, r) end => [ :void, :GLshort, :GLshort, :GLshort ].freeze,
+      def glTexCoord3sv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord4d(s, t, r, q) end => [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glTexCoord4dv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord4f(s, t, r, q) end => [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glTexCoord4fv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord4i(s, t, r, q) end => [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
+      def glTexCoord4iv(v) end => [ :void, :pointer ].freeze,
+      def glTexCoord4s(s, t, r, q) end => [ :void, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
+      def glTexCoord4sv(v) end => [ :void, :pointer ].freeze,
+      def glTexEnvf(target, pname, param) end => [ :void, :GLenum, :GLenum, :GLfloat ].freeze,
+      def glTexEnvfv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glTexEnvi(target, pname, param) end => [ :void, :GLenum, :GLenum, :GLint ].freeze,
+      def glTexEnviv(target, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glTexGend(coord, pname, param) end => [ :void, :GLenum, :GLenum, :GLdouble ].freeze,
+      def glTexGendv(coord, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glTexGenf(coord, pname, param) end => [ :void, :GLenum, :GLenum, :GLfloat ].freeze,
+      def glTexGenfv(coord, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glTexGeni(coord, pname, param) end => [ :void, :GLenum, :GLenum, :GLint ].freeze,
+      def glTexGeniv(coord, pname, params) end => [ :void, :GLenum, :GLenum, :pointer ].freeze,
+      def glTranslated(x, y, z) end => [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glTranslatef(x, y, z) end => [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glVertex2d(x, y) end => [ :void, :GLdouble, :GLdouble ].freeze,
+      def glVertex2dv(v) end => [ :void, :pointer ].freeze,
+      def glVertex2f(x, y) end => [ :void, :GLfloat, :GLfloat ].freeze,
+      def glVertex2fv(v) end => [ :void, :pointer ].freeze,
+      def glVertex2i(x, y) end => [ :void, :GLint, :GLint ].freeze,
+      def glVertex2iv(v) end => [ :void, :pointer ].freeze,
+      def glVertex2s(x, y) end => [ :void, :GLshort, :GLshort ].freeze,
+      def glVertex2sv(v) end => [ :void, :pointer ].freeze,
+      def glVertex3d(x, y, z) end => [ :void, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glVertex3dv(v) end => [ :void, :pointer ].freeze,
+      def glVertex3f(x, y, z) end => [ :void, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glVertex3fv(v) end => [ :void, :pointer ].freeze,
+      def glVertex3i(x, y, z) end => [ :void, :GLint, :GLint, :GLint ].freeze,
+      def glVertex3iv(v) end => [ :void, :pointer ].freeze,
+      def glVertex3s(x, y, z) end => [ :void, :GLshort, :GLshort, :GLshort ].freeze,
+      def glVertex3sv(v) end => [ :void, :pointer ].freeze,
+      def glVertex4d(x, y, z, w) end => [ :void, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+      def glVertex4dv(v) end => [ :void, :pointer ].freeze,
+      def glVertex4f(x, y, z, w) end => [ :void, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+      def glVertex4fv(v) end => [ :void, :pointer ].freeze,
+      def glVertex4i(x, y, z, w) end => [ :void, :GLint, :GLint, :GLint, :GLint ].freeze,
+      def glVertex4iv(v) end => [ :void, :pointer ].freeze,
+      def glVertex4s(x, y, z, w) end => [ :void, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
+      def glVertex4sv(v) end => [ :void, :pointer ].freeze,
+    }.freeze
   end
 end