opengl-definitions 1.0.0 → 2.0.0

data/lib/opengl-definitions/extensions/GL_NV_vertex_array_range.rb

@@ -7,13 +7,8 @@ module GL_NV_vertex_array_range
     NVERTEX_ARRAY_RANGE_POINTER_NV     = 0x8521
   end
   
-  module Functions
-    def glFlushVertexArrayRangeNV() end
-    def glVertexArrayRangeNV(length, pointer) end
-  
-    Parameters = {
-      glFlushVertexArrayRangeNV: [ :void ].freeze,
-      glVertexArrayRangeNV:      [ :void, :GLsizei, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def glFlushVertexArrayRangeNV() end => [ :void ].freeze,
+    def glVertexArrayRangeNV(length, pointer) end => [ :void, :GLsizei, :pointer ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/extensions/GL_NV_vertex_attrib_integer_64bit.rb

@@ -4,47 +4,25 @@ module GL_NV_vertex_attrib_integer_64bit
     NUNSIGNED_INT64_NV = 0x140F
   end
   
-  module Functions
-    def glVertexAttribL1i64NV(index, x) end
-    def glVertexAttribL2i64NV(index, x, y) end
-    def glVertexAttribL3i64NV(index, x, y, z) end
-    def glVertexAttribL4i64NV(index, x, y, z, w) end
-    def glVertexAttribL1i64vNV(index, v) end
-    def glVertexAttribL2i64vNV(index, v) end
-    def glVertexAttribL3i64vNV(index, v) end
-    def glVertexAttribL4i64vNV(index, v) end
-    def glVertexAttribL1ui64NV(index, x) end
-    def glVertexAttribL2ui64NV(index, x, y) end
-    def glVertexAttribL3ui64NV(index, x, y, z) end
-    def glVertexAttribL4ui64NV(index, x, y, z, w) end
-    def glVertexAttribL1ui64vNV(index, v) end
-    def glVertexAttribL2ui64vNV(index, v) end
-    def glVertexAttribL3ui64vNV(index, v) end
-    def glVertexAttribL4ui64vNV(index, v) end
-    def glGetVertexAttribLi64vNV(index, pname, params) end
-    def glGetVertexAttribLui64vNV(index, pname, params) end
-    def glVertexAttribLFormatNV(index, size, type, stride) end
-  
-    Parameters = {
-      glVertexAttribL1i64NV:     [ :void, :GLuint, :GLint64EXT ].freeze,
-      glVertexAttribL2i64NV:     [ :void, :GLuint, :GLint64EXT, :GLint64EXT ].freeze,
-      glVertexAttribL3i64NV:     [ :void, :GLuint, :GLint64EXT, :GLint64EXT, :GLint64EXT ].freeze,
-      glVertexAttribL4i64NV:     [ :void, :GLuint, :GLint64EXT, :GLint64EXT, :GLint64EXT, :GLint64EXT ].freeze,
-      glVertexAttribL1i64vNV:    [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribL2i64vNV:    [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribL3i64vNV:    [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribL4i64vNV:    [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribL1ui64NV:    [ :void, :GLuint, :GLuint64EXT ].freeze,
-      glVertexAttribL2ui64NV:    [ :void, :GLuint, :GLuint64EXT, :GLuint64EXT ].freeze,
-      glVertexAttribL3ui64NV:    [ :void, :GLuint, :GLuint64EXT, :GLuint64EXT, :GLuint64EXT ].freeze,
-      glVertexAttribL4ui64NV:    [ :void, :GLuint, :GLuint64EXT, :GLuint64EXT, :GLuint64EXT, :GLuint64EXT ].freeze,
-      glVertexAttribL1ui64vNV:   [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribL2ui64vNV:   [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribL3ui64vNV:   [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribL4ui64vNV:   [ :void, :GLuint, :pointer ].freeze,
-      glGetVertexAttribLi64vNV:  [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVertexAttribLui64vNV: [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glVertexAttribLFormatNV:   [ :void, :GLuint, :GLint, :GLenum, :GLsizei ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def glVertexAttribL1i64NV(index, x) end => [ :void, :GLuint, :GLint64EXT ].freeze,
+    def glVertexAttribL2i64NV(index, x, y) end => [ :void, :GLuint, :GLint64EXT, :GLint64EXT ].freeze,
+    def glVertexAttribL3i64NV(index, x, y, z) end => [ :void, :GLuint, :GLint64EXT, :GLint64EXT, :GLint64EXT ].freeze,
+    def glVertexAttribL4i64NV(index, x, y, z, w) end => [ :void, :GLuint, :GLint64EXT, :GLint64EXT, :GLint64EXT, :GLint64EXT ].freeze,
+    def glVertexAttribL1i64vNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribL2i64vNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribL3i64vNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribL4i64vNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribL1ui64NV(index, x) end => [ :void, :GLuint, :GLuint64EXT ].freeze,
+    def glVertexAttribL2ui64NV(index, x, y) end => [ :void, :GLuint, :GLuint64EXT, :GLuint64EXT ].freeze,
+    def glVertexAttribL3ui64NV(index, x, y, z) end => [ :void, :GLuint, :GLuint64EXT, :GLuint64EXT, :GLuint64EXT ].freeze,
+    def glVertexAttribL4ui64NV(index, x, y, z, w) end => [ :void, :GLuint, :GLuint64EXT, :GLuint64EXT, :GLuint64EXT, :GLuint64EXT ].freeze,
+    def glVertexAttribL1ui64vNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribL2ui64vNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribL3ui64vNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribL4ui64vNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glGetVertexAttribLi64vNV(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVertexAttribLui64vNV(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glVertexAttribLFormatNV(index, size, type, stride) end => [ :void, :GLuint, :GLint, :GLenum, :GLsizei ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/extensions/GL_NV_vertex_buffer_unified_memory.rb

@@ -27,33 +27,18 @@ module GL_NV_vertex_buffer_unified_memory
     NDRAW_INDIRECT_LENGTH_NV          = 0x8F42
   end
   
-  module Functions
-    def glBufferAddressRangeNV(pname, index, address, length) end
-    def glVertexFormatNV(size, type, stride) end
-    def glNormalFormatNV(type, stride) end
-    def glColorFormatNV(size, type, stride) end
-    def glIndexFormatNV(type, stride) end
-    def glTexCoordFormatNV(size, type, stride) end
-    def glEdgeFlagFormatNV(stride) end
-    def glSecondaryColorFormatNV(size, type, stride) end
-    def glFogCoordFormatNV(type, stride) end
-    def glVertexAttribFormatNV(index, size, type, normalized, stride) end
-    def glVertexAttribIFormatNV(index, size, type, stride) end
-    def glGetIntegerui64i_vNV(value, index, result) end
-  
-    Parameters = {
-      glBufferAddressRangeNV:   [ :void, :GLenum, :GLuint, :GLuint64EXT, :GLsizeiptr ].freeze,
-      glVertexFormatNV:         [ :void, :GLint, :GLenum, :GLsizei ].freeze,
-      glNormalFormatNV:         [ :void, :GLenum, :GLsizei ].freeze,
-      glColorFormatNV:          [ :void, :GLint, :GLenum, :GLsizei ].freeze,
-      glIndexFormatNV:          [ :void, :GLenum, :GLsizei ].freeze,
-      glTexCoordFormatNV:       [ :void, :GLint, :GLenum, :GLsizei ].freeze,
-      glEdgeFlagFormatNV:       [ :void, :GLsizei ].freeze,
-      glSecondaryColorFormatNV: [ :void, :GLint, :GLenum, :GLsizei ].freeze,
-      glFogCoordFormatNV:       [ :void, :GLenum, :GLsizei ].freeze,
-      glVertexAttribFormatNV:   [ :void, :GLuint, :GLint, :GLenum, :GLboolean, :GLsizei ].freeze,
-      glVertexAttribIFormatNV:  [ :void, :GLuint, :GLint, :GLenum, :GLsizei ].freeze,
-      glGetIntegerui64i_vNV:    [ :void, :GLenum, :GLuint, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def glBufferAddressRangeNV(pname, index, address, length) end => [ :void, :GLenum, :GLuint, :GLuint64EXT, :GLsizeiptr ].freeze,
+    def glVertexFormatNV(size, type, stride) end => [ :void, :GLint, :GLenum, :GLsizei ].freeze,
+    def glNormalFormatNV(type, stride) end => [ :void, :GLenum, :GLsizei ].freeze,
+    def glColorFormatNV(size, type, stride) end => [ :void, :GLint, :GLenum, :GLsizei ].freeze,
+    def glIndexFormatNV(type, stride) end => [ :void, :GLenum, :GLsizei ].freeze,
+    def glTexCoordFormatNV(size, type, stride) end => [ :void, :GLint, :GLenum, :GLsizei ].freeze,
+    def glEdgeFlagFormatNV(stride) end => [ :void, :GLsizei ].freeze,
+    def glSecondaryColorFormatNV(size, type, stride) end => [ :void, :GLint, :GLenum, :GLsizei ].freeze,
+    def glFogCoordFormatNV(type, stride) end => [ :void, :GLenum, :GLsizei ].freeze,
+    def glVertexAttribFormatNV(index, size, type, normalized, stride) end => [ :void, :GLuint, :GLint, :GLenum, :GLboolean, :GLsizei ].freeze,
+    def glVertexAttribIFormatNV(index, size, type, stride) end => [ :void, :GLuint, :GLint, :GLenum, :GLsizei ].freeze,
+    def glGetIntegerui64i_vNV(value, index, result) end => [ :void, :GLenum, :GLuint, :pointer ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/extensions/GL_NV_vertex_program.rb

@@ -85,137 +85,70 @@ module GL_NV_vertex_program
     NMAP2_VERTEX_ATTRIB15_4_NV       = 0x867F
   end
   
-  module Functions
-    def glAreProgramsResidentNV(n, programs, residences) end
-    def glBindProgramNV(target, id) end
-    def glDeleteProgramsNV(n, programs) end
-    def glExecuteProgramNV(target, id, params) end
-    def glGenProgramsNV(n, programs) end
-    def glGetProgramParameterdvNV(target, index, pname, params) end
-    def glGetProgramParameterfvNV(target, index, pname, params) end
-    def glGetProgramivNV(id, pname, params) end
-    def glGetProgramStringNV(id, pname, program) end
-    def glGetTrackMatrixivNV(target, address, pname, params) end
-    def glGetVertexAttribdvNV(index, pname, params) end
-    def glGetVertexAttribfvNV(index, pname, params) end
-    def glGetVertexAttribivNV(index, pname, params) end
-    def glGetVertexAttribPointervNV(index, pname, pointer) end
-    def glIsProgramNV(id) end
-    def glLoadProgramNV(target, id, len, program) end
-    def glProgramParameter4dNV(target, index, x, y, z, w) end
-    def glProgramParameter4dvNV(target, index, v) end
-    def glProgramParameter4fNV(target, index, x, y, z, w) end
-    def glProgramParameter4fvNV(target, index, v) end
-    def glProgramParameters4dvNV(target, index, count, v) end
-    def glProgramParameters4fvNV(target, index, count, v) end
-    def glRequestResidentProgramsNV(n, programs) end
-    def glTrackMatrixNV(target, address, matrix, transform) end
-    def glVertexAttribPointerNV(index, fsize, type, stride, pointer) end
-    def glVertexAttrib1dNV(index, x) end
-    def glVertexAttrib1dvNV(index, v) end
-    def glVertexAttrib1fNV(index, x) end
-    def glVertexAttrib1fvNV(index, v) end
-    def glVertexAttrib1sNV(index, x) end
-    def glVertexAttrib1svNV(index, v) end
-    def glVertexAttrib2dNV(index, x, y) end
-    def glVertexAttrib2dvNV(index, v) end
-    def glVertexAttrib2fNV(index, x, y) end
-    def glVertexAttrib2fvNV(index, v) end
-    def glVertexAttrib2sNV(index, x, y) end
-    def glVertexAttrib2svNV(index, v) end
-    def glVertexAttrib3dNV(index, x, y, z) end
-    def glVertexAttrib3dvNV(index, v) end
-    def glVertexAttrib3fNV(index, x, y, z) end
-    def glVertexAttrib3fvNV(index, v) end
-    def glVertexAttrib3sNV(index, x, y, z) end
-    def glVertexAttrib3svNV(index, v) end
-    def glVertexAttrib4dNV(index, x, y, z, w) end
-    def glVertexAttrib4dvNV(index, v) end
-    def glVertexAttrib4fNV(index, x, y, z, w) end
-    def glVertexAttrib4fvNV(index, v) end
-    def glVertexAttrib4sNV(index, x, y, z, w) end
-    def glVertexAttrib4svNV(index, v) end
-    def glVertexAttrib4ubNV(index, x, y, z, w) end
-    def glVertexAttrib4ubvNV(index, v) end
-    def glVertexAttribs1dvNV(index, count, v) end
-    def glVertexAttribs1fvNV(index, count, v) end
-    def glVertexAttribs1svNV(index, count, v) end
-    def glVertexAttribs2dvNV(index, count, v) end
-    def glVertexAttribs2fvNV(index, count, v) end
-    def glVertexAttribs2svNV(index, count, v) end
-    def glVertexAttribs3dvNV(index, count, v) end
-    def glVertexAttribs3fvNV(index, count, v) end
-    def glVertexAttribs3svNV(index, count, v) end
-    def glVertexAttribs4dvNV(index, count, v) end
-    def glVertexAttribs4fvNV(index, count, v) end
-    def glVertexAttribs4svNV(index, count, v) end
-    def glVertexAttribs4ubvNV(index, count, v) end
-  
-    Parameters = {
-      glAreProgramsResidentNV:     [ :GLboolean, :GLsizei, :pointer, :pointer ].freeze,
-      glBindProgramNV:             [ :void, :GLenum, :GLuint ].freeze,
-      glDeleteProgramsNV:          [ :void, :GLsizei, :pointer ].freeze,
-      glExecuteProgramNV:          [ :void, :GLenum, :GLuint, :pointer ].freeze,
-      glGenProgramsNV:             [ :void, :GLsizei, :pointer ].freeze,
-      glGetProgramParameterdvNV:   [ :void, :GLenum, :GLuint, :GLenum, :pointer ].freeze,
-      glGetProgramParameterfvNV:   [ :void, :GLenum, :GLuint, :GLenum, :pointer ].freeze,
-      glGetProgramivNV:            [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetProgramStringNV:        [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetTrackMatrixivNV:        [ :void, :GLenum, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVertexAttribdvNV:       [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVertexAttribfvNV:       [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVertexAttribivNV:       [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVertexAttribPointervNV: [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glIsProgramNV:               [ :GLboolean, :GLuint ].freeze,
-      glLoadProgramNV:             [ :void, :GLenum, :GLuint, :GLsizei, :pointer ].freeze,
-      glProgramParameter4dNV:      [ :void, :GLenum, :GLuint, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-      glProgramParameter4dvNV:     [ :void, :GLenum, :GLuint, :pointer ].freeze,
-      glProgramParameter4fNV:      [ :void, :GLenum, :GLuint, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-      glProgramParameter4fvNV:     [ :void, :GLenum, :GLuint, :pointer ].freeze,
-      glProgramParameters4dvNV:    [ :void, :GLenum, :GLuint, :GLsizei, :pointer ].freeze,
-      glProgramParameters4fvNV:    [ :void, :GLenum, :GLuint, :GLsizei, :pointer ].freeze,
-      glRequestResidentProgramsNV: [ :void, :GLsizei, :pointer ].freeze,
-      glTrackMatrixNV:             [ :void, :GLenum, :GLuint, :GLenum, :GLenum ].freeze,
-      glVertexAttribPointerNV:     [ :void, :GLuint, :GLint, :GLenum, :GLsizei, :pointer ].freeze,
-      glVertexAttrib1dNV:          [ :void, :GLuint, :GLdouble ].freeze,
-      glVertexAttrib1dvNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib1fNV:          [ :void, :GLuint, :GLfloat ].freeze,
-      glVertexAttrib1fvNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib1sNV:          [ :void, :GLuint, :GLshort ].freeze,
-      glVertexAttrib1svNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib2dNV:          [ :void, :GLuint, :GLdouble, :GLdouble ].freeze,
-      glVertexAttrib2dvNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib2fNV:          [ :void, :GLuint, :GLfloat, :GLfloat ].freeze,
-      glVertexAttrib2fvNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib2sNV:          [ :void, :GLuint, :GLshort, :GLshort ].freeze,
-      glVertexAttrib2svNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib3dNV:          [ :void, :GLuint, :GLdouble, :GLdouble, :GLdouble ].freeze,
-      glVertexAttrib3dvNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib3fNV:          [ :void, :GLuint, :GLfloat, :GLfloat, :GLfloat ].freeze,
-      glVertexAttrib3fvNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib3sNV:          [ :void, :GLuint, :GLshort, :GLshort, :GLshort ].freeze,
-      glVertexAttrib3svNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4dNV:          [ :void, :GLuint, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
-      glVertexAttrib4dvNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4fNV:          [ :void, :GLuint, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
-      glVertexAttrib4fvNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4sNV:          [ :void, :GLuint, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
-      glVertexAttrib4svNV:         [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttrib4ubNV:         [ :void, :GLuint, :GLubyte, :GLubyte, :GLubyte, :GLubyte ].freeze,
-      glVertexAttrib4ubvNV:        [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribs1dvNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs1fvNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs1svNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs2dvNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs2fvNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs2svNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs3dvNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs3fvNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs3svNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs4dvNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs4fvNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs4svNV:        [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-      glVertexAttribs4ubvNV:       [ :void, :GLuint, :GLsizei, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def glAreProgramsResidentNV(n, programs, residences) end => [ :GLboolean, :GLsizei, :pointer, :pointer ].freeze,
+    def glBindProgramNV(target, id) end => [ :void, :GLenum, :GLuint ].freeze,
+    def glDeleteProgramsNV(n, programs) end => [ :void, :GLsizei, :pointer ].freeze,
+    def glExecuteProgramNV(target, id, params) end => [ :void, :GLenum, :GLuint, :pointer ].freeze,
+    def glGenProgramsNV(n, programs) end => [ :void, :GLsizei, :pointer ].freeze,
+    def glGetProgramParameterdvNV(target, index, pname, params) end => [ :void, :GLenum, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetProgramParameterfvNV(target, index, pname, params) end => [ :void, :GLenum, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetProgramivNV(id, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetProgramStringNV(id, pname, program) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetTrackMatrixivNV(target, address, pname, params) end => [ :void, :GLenum, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVertexAttribdvNV(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVertexAttribfvNV(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVertexAttribivNV(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVertexAttribPointervNV(index, pname, pointer) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glIsProgramNV(id) end => [ :GLboolean, :GLuint ].freeze,
+    def glLoadProgramNV(target, id, len, program) end => [ :void, :GLenum, :GLuint, :GLsizei, :pointer ].freeze,
+    def glProgramParameter4dNV(target, index, x, y, z, w) end => [ :void, :GLenum, :GLuint, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+    def glProgramParameter4dvNV(target, index, v) end => [ :void, :GLenum, :GLuint, :pointer ].freeze,
+    def glProgramParameter4fNV(target, index, x, y, z, w) end => [ :void, :GLenum, :GLuint, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+    def glProgramParameter4fvNV(target, index, v) end => [ :void, :GLenum, :GLuint, :pointer ].freeze,
+    def glProgramParameters4dvNV(target, index, count, v) end => [ :void, :GLenum, :GLuint, :GLsizei, :pointer ].freeze,
+    def glProgramParameters4fvNV(target, index, count, v) end => [ :void, :GLenum, :GLuint, :GLsizei, :pointer ].freeze,
+    def glRequestResidentProgramsNV(n, programs) end => [ :void, :GLsizei, :pointer ].freeze,
+    def glTrackMatrixNV(target, address, matrix, transform) end => [ :void, :GLenum, :GLuint, :GLenum, :GLenum ].freeze,
+    def glVertexAttribPointerNV(index, fsize, type, stride, pointer) end => [ :void, :GLuint, :GLint, :GLenum, :GLsizei, :pointer ].freeze,
+    def glVertexAttrib1dNV(index, x) end => [ :void, :GLuint, :GLdouble ].freeze,
+    def glVertexAttrib1dvNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib1fNV(index, x) end => [ :void, :GLuint, :GLfloat ].freeze,
+    def glVertexAttrib1fvNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib1sNV(index, x) end => [ :void, :GLuint, :GLshort ].freeze,
+    def glVertexAttrib1svNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib2dNV(index, x, y) end => [ :void, :GLuint, :GLdouble, :GLdouble ].freeze,
+    def glVertexAttrib2dvNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib2fNV(index, x, y) end => [ :void, :GLuint, :GLfloat, :GLfloat ].freeze,
+    def glVertexAttrib2fvNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib2sNV(index, x, y) end => [ :void, :GLuint, :GLshort, :GLshort ].freeze,
+    def glVertexAttrib2svNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib3dNV(index, x, y, z) end => [ :void, :GLuint, :GLdouble, :GLdouble, :GLdouble ].freeze,
+    def glVertexAttrib3dvNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib3fNV(index, x, y, z) end => [ :void, :GLuint, :GLfloat, :GLfloat, :GLfloat ].freeze,
+    def glVertexAttrib3fvNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib3sNV(index, x, y, z) end => [ :void, :GLuint, :GLshort, :GLshort, :GLshort ].freeze,
+    def glVertexAttrib3svNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4dNV(index, x, y, z, w) end => [ :void, :GLuint, :GLdouble, :GLdouble, :GLdouble, :GLdouble ].freeze,
+    def glVertexAttrib4dvNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4fNV(index, x, y, z, w) end => [ :void, :GLuint, :GLfloat, :GLfloat, :GLfloat, :GLfloat ].freeze,
+    def glVertexAttrib4fvNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4sNV(index, x, y, z, w) end => [ :void, :GLuint, :GLshort, :GLshort, :GLshort, :GLshort ].freeze,
+    def glVertexAttrib4svNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttrib4ubNV(index, x, y, z, w) end => [ :void, :GLuint, :GLubyte, :GLubyte, :GLubyte, :GLubyte ].freeze,
+    def glVertexAttrib4ubvNV(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribs1dvNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs1fvNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs1svNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs2dvNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs2fvNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs2svNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs3dvNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs3fvNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs3svNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs4dvNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs4fvNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs4svNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+    def glVertexAttribs4ubvNV(index, count, v) end => [ :void, :GLuint, :GLsizei, :pointer ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/extensions/GL_NV_vertex_program4.rb

@@ -3,55 +3,29 @@ module GL_NV_vertex_program4
     NVERTEX_ATTRIB_ARRAY_INTEGER_NV = 0x88FD
   end
   
-  module Functions
-    def glVertexAttribI1iEXT(index, x) end
-    def glVertexAttribI2iEXT(index, x, y) end
-    def glVertexAttribI3iEXT(index, x, y, z) end
-    def glVertexAttribI4iEXT(index, x, y, z, w) end
-    def glVertexAttribI1uiEXT(index, x) end
-    def glVertexAttribI2uiEXT(index, x, y) end
-    def glVertexAttribI3uiEXT(index, x, y, z) end
-    def glVertexAttribI4uiEXT(index, x, y, z, w) end
-    def glVertexAttribI1ivEXT(index, v) end
-    def glVertexAttribI2ivEXT(index, v) end
-    def glVertexAttribI3ivEXT(index, v) end
-    def glVertexAttribI4ivEXT(index, v) end
-    def glVertexAttribI1uivEXT(index, v) end
-    def glVertexAttribI2uivEXT(index, v) end
-    def glVertexAttribI3uivEXT(index, v) end
-    def glVertexAttribI4uivEXT(index, v) end
-    def glVertexAttribI4bvEXT(index, v) end
-    def glVertexAttribI4svEXT(index, v) end
-    def glVertexAttribI4ubvEXT(index, v) end
-    def glVertexAttribI4usvEXT(index, v) end
-    def glVertexAttribIPointerEXT(index, size, type, stride, pointer) end
-    def glGetVertexAttribIivEXT(index, pname, params) end
-    def glGetVertexAttribIuivEXT(index, pname, params) end
-  
-    Parameters = {
-      glVertexAttribI1iEXT:      [ :void, :GLuint, :GLint ].freeze,
-      glVertexAttribI2iEXT:      [ :void, :GLuint, :GLint, :GLint ].freeze,
-      glVertexAttribI3iEXT:      [ :void, :GLuint, :GLint, :GLint, :GLint ].freeze,
-      glVertexAttribI4iEXT:      [ :void, :GLuint, :GLint, :GLint, :GLint, :GLint ].freeze,
-      glVertexAttribI1uiEXT:     [ :void, :GLuint, :GLuint ].freeze,
-      glVertexAttribI2uiEXT:     [ :void, :GLuint, :GLuint, :GLuint ].freeze,
-      glVertexAttribI3uiEXT:     [ :void, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
-      glVertexAttribI4uiEXT:     [ :void, :GLuint, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
-      glVertexAttribI1ivEXT:     [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI2ivEXT:     [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI3ivEXT:     [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4ivEXT:     [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI1uivEXT:    [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI2uivEXT:    [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI3uivEXT:    [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4uivEXT:    [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4bvEXT:     [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4svEXT:     [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4ubvEXT:    [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribI4usvEXT:    [ :void, :GLuint, :pointer ].freeze,
-      glVertexAttribIPointerEXT: [ :void, :GLuint, :GLint, :GLenum, :GLsizei, :pointer ].freeze,
-      glGetVertexAttribIivEXT:   [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVertexAttribIuivEXT:  [ :void, :GLuint, :GLenum, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def glVertexAttribI1iEXT(index, x) end => [ :void, :GLuint, :GLint ].freeze,
+    def glVertexAttribI2iEXT(index, x, y) end => [ :void, :GLuint, :GLint, :GLint ].freeze,
+    def glVertexAttribI3iEXT(index, x, y, z) end => [ :void, :GLuint, :GLint, :GLint, :GLint ].freeze,
+    def glVertexAttribI4iEXT(index, x, y, z, w) end => [ :void, :GLuint, :GLint, :GLint, :GLint, :GLint ].freeze,
+    def glVertexAttribI1uiEXT(index, x) end => [ :void, :GLuint, :GLuint ].freeze,
+    def glVertexAttribI2uiEXT(index, x, y) end => [ :void, :GLuint, :GLuint, :GLuint ].freeze,
+    def glVertexAttribI3uiEXT(index, x, y, z) end => [ :void, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
+    def glVertexAttribI4uiEXT(index, x, y, z, w) end => [ :void, :GLuint, :GLuint, :GLuint, :GLuint, :GLuint ].freeze,
+    def glVertexAttribI1ivEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI2ivEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI3ivEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4ivEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI1uivEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI2uivEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI3uivEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4uivEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4bvEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4svEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4ubvEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribI4usvEXT(index, v) end => [ :void, :GLuint, :pointer ].freeze,
+    def glVertexAttribIPointerEXT(index, size, type, stride, pointer) end => [ :void, :GLuint, :GLint, :GLenum, :GLsizei, :pointer ].freeze,
+    def glGetVertexAttribIivEXT(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVertexAttribIuivEXT(index, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/extensions/GL_NV_video_capture.rb

@@ -31,33 +31,18 @@ module GL_NV_video_capture
     NVIDEO_CAPTURE_SURFACE_ORIGIN_NV          = 0x903C
   end
   
-  module Functions
-    def glBeginVideoCaptureNV(video_capture_slot) end
-    def glBindVideoCaptureStreamBufferNV(video_capture_slot, stream, frame_region, offset) end
-    def glBindVideoCaptureStreamTextureNV(video_capture_slot, stream, frame_region, target, texture) end
-    def glEndVideoCaptureNV(video_capture_slot) end
-    def glGetVideoCaptureivNV(video_capture_slot, pname, params) end
-    def glGetVideoCaptureStreamivNV(video_capture_slot, stream, pname, params) end
-    def glGetVideoCaptureStreamfvNV(video_capture_slot, stream, pname, params) end
-    def glGetVideoCaptureStreamdvNV(video_capture_slot, stream, pname, params) end
-    def glVideoCaptureNV(video_capture_slot, sequence_num, capture_time) end
-    def glVideoCaptureStreamParameterivNV(video_capture_slot, stream, pname, params) end
-    def glVideoCaptureStreamParameterfvNV(video_capture_slot, stream, pname, params) end
-    def glVideoCaptureStreamParameterdvNV(video_capture_slot, stream, pname, params) end
-  
-    Parameters = {
-      glBeginVideoCaptureNV:             [ :void, :GLuint ].freeze,
-      glBindVideoCaptureStreamBufferNV:  [ :void, :GLuint, :GLuint, :GLenum, :GLintptrARB ].freeze,
-      glBindVideoCaptureStreamTextureNV: [ :void, :GLuint, :GLuint, :GLenum, :GLenum, :GLuint ].freeze,
-      glEndVideoCaptureNV:               [ :void, :GLuint ].freeze,
-      glGetVideoCaptureivNV:             [ :void, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVideoCaptureStreamivNV:       [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVideoCaptureStreamfvNV:       [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
-      glGetVideoCaptureStreamdvNV:       [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
-      glVideoCaptureNV:                  [ :GLenum, :GLuint, :pointer, :pointer ].freeze,
-      glVideoCaptureStreamParameterivNV: [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
-      glVideoCaptureStreamParameterfvNV: [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
-      glVideoCaptureStreamParameterdvNV: [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def glBeginVideoCaptureNV(video_capture_slot) end => [ :void, :GLuint ].freeze,
+    def glBindVideoCaptureStreamBufferNV(video_capture_slot, stream, frame_region, offset) end => [ :void, :GLuint, :GLuint, :GLenum, :GLintptrARB ].freeze,
+    def glBindVideoCaptureStreamTextureNV(video_capture_slot, stream, frame_region, target, texture) end => [ :void, :GLuint, :GLuint, :GLenum, :GLenum, :GLuint ].freeze,
+    def glEndVideoCaptureNV(video_capture_slot) end => [ :void, :GLuint ].freeze,
+    def glGetVideoCaptureivNV(video_capture_slot, pname, params) end => [ :void, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVideoCaptureStreamivNV(video_capture_slot, stream, pname, params) end => [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVideoCaptureStreamfvNV(video_capture_slot, stream, pname, params) end => [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
+    def glGetVideoCaptureStreamdvNV(video_capture_slot, stream, pname, params) end => [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
+    def glVideoCaptureNV(video_capture_slot, sequence_num, capture_time) end => [ :GLenum, :GLuint, :pointer, :pointer ].freeze,
+    def glVideoCaptureStreamParameterivNV(video_capture_slot, stream, pname, params) end => [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
+    def glVideoCaptureStreamParameterfvNV(video_capture_slot, stream, pname, params) end => [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
+    def glVideoCaptureStreamParameterdvNV(video_capture_slot, stream, pname, params) end => [ :void, :GLuint, :GLuint, :GLenum, :pointer ].freeze,
+  }.freeze
 end