opengl-definitions 1.0.0 → 2.0.0

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

@@ -1,15 +1,8 @@
 module WGL_I3D_swap_frame_usage
-  module Functions
-    def wglGetFrameUsageI3D(pUsage) end
-    def wglBeginFrameTrackingI3D() end
-    def wglEndFrameTrackingI3D() end
-    def wglQueryFrameTrackingI3D(pFrameCount, pMissedFrames, pLastMissedUsage) end
-  
-    Parameters = {
-      wglGetFrameUsageI3D:      [ :BOOL, :pointer ].freeze,
-      wglBeginFrameTrackingI3D: [ :BOOL ].freeze,
-      wglEndFrameTrackingI3D:   [ :BOOL ].freeze,
-      wglQueryFrameTrackingI3D: [ :BOOL, :pointer, :pointer, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglGetFrameUsageI3D(pUsage) end => [ :BOOL, :pointer ].freeze,
+    def wglBeginFrameTrackingI3D() end => [ :BOOL ].freeze,
+    def wglEndFrameTrackingI3D() end => [ :BOOL ].freeze,
+    def wglQueryFrameTrackingI3D(pFrameCount, pMissedFrames, pLastMissedUsage) end => [ :BOOL, :pointer, :pointer, :pointer ].freeze,
+  }.freeze
 end

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

@@ -5,25 +5,14 @@ module WGL_NV_DX_interop
     NACCESS_WRITE_DISCARD_NV = 0x00000002
   end
   
-  module Functions
-    def wglDXSetResourceShareHandleNV(dxObject, shareHandle) end
-    def wglDXOpenDeviceNV(dxDevice) end
-    def wglDXCloseDeviceNV(hDevice) end
-    def wglDXRegisterObjectNV(hDevice, dxObject, name, type, access) end
-    def wglDXUnregisterObjectNV(hDevice, hObject) end
-    def wglDXObjectAccessNV(hObject, access) end
-    def wglDXLockObjectsNV(hDevice, count, hObjects) end
-    def wglDXUnlockObjectsNV(hDevice, count, hObjects) end
-  
-    Parameters = {
-      wglDXSetResourceShareHandleNV: [ :BOOL, :pointer, :HANDLE ].freeze,
-      wglDXOpenDeviceNV:             [ :HANDLE, :pointer ].freeze,
-      wglDXCloseDeviceNV:            [ :BOOL, :HANDLE ].freeze,
-      wglDXRegisterObjectNV:         [ :HANDLE, :HANDLE, :pointer, :GLuint, :GLenum, :GLenum ].freeze,
-      wglDXUnregisterObjectNV:       [ :BOOL, :HANDLE, :HANDLE ].freeze,
-      wglDXObjectAccessNV:           [ :BOOL, :HANDLE, :GLenum ].freeze,
-      wglDXLockObjectsNV:            [ :BOOL, :HANDLE, :GLint, :pointer ].freeze,
-      wglDXUnlockObjectsNV:          [ :BOOL, :HANDLE, :GLint, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglDXSetResourceShareHandleNV(dxObject, shareHandle) end => [ :BOOL, :pointer, :HANDLE ].freeze,
+    def wglDXOpenDeviceNV(dxDevice) end => [ :HANDLE, :pointer ].freeze,
+    def wglDXCloseDeviceNV(hDevice) end => [ :BOOL, :HANDLE ].freeze,
+    def wglDXRegisterObjectNV(hDevice, dxObject, name, type, access) end => [ :HANDLE, :HANDLE, :pointer, :GLuint, :GLenum, :GLenum ].freeze,
+    def wglDXUnregisterObjectNV(hDevice, hObject) end => [ :BOOL, :HANDLE, :HANDLE ].freeze,
+    def wglDXObjectAccessNV(hObject, access) end => [ :BOOL, :HANDLE, :GLenum ].freeze,
+    def wglDXLockObjectsNV(hDevice, count, hObjects) end => [ :BOOL, :HANDLE, :GLint, :pointer ].freeze,
+    def wglDXUnlockObjectsNV(hDevice, count, hObjects) end => [ :BOOL, :HANDLE, :GLint, :pointer ].freeze,
+  }.freeze
 end

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

@@ -1,9 +1,5 @@
 module WGL_NV_copy_image
-  module Functions
-    def wglCopyImageSubDataNV(hSrcRC, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, hDstRC, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth) end
-  
-    Parameters = {
-      wglCopyImageSubDataNV: [ :BOOL, :HGLRC, :GLuint, :GLenum, :GLint, :GLint, :GLint, :GLint, :HGLRC, :GLuint, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLsizei ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglCopyImageSubDataNV(hSrcRC, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, hDstRC, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth) end => [ :BOOL, :HGLRC, :GLuint, :GLenum, :GLint, :GLint, :GLint, :GLint, :HGLRC, :GLuint, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLsizei ].freeze,
+  }.freeze
 end

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

@@ -1,9 +1,5 @@
 module WGL_NV_delay_before_swap
-  module Functions
-    def wglDelayBeforeSwapNV(hDC, seconds) end
-  
-    Parameters = {
-      wglDelayBeforeSwapNV: [ :BOOL, :HDC, :GLfloat ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglDelayBeforeSwapNV(hDC, seconds) end => [ :BOOL, :HDC, :GLfloat ].freeze,
+  }.freeze
 end

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

@@ -4,19 +4,11 @@ module WGL_NV_gpu_affinity
     NERROR_MISSING_AFFINITY_MASK_NV       = 0x20D1
   end
   
-  module Functions
-    def wglEnumGpusNV(iGpuIndex, phGpu) end
-    def wglEnumGpuDevicesNV(hGpu, iDeviceIndex, lpGpuDevice) end
-    def wglCreateAffinityDCNV(phGpuList) end
-    def wglEnumGpusFromAffinityDCNV(hAffinityDC, iGpuIndex, hGpu) end
-    def wglDeleteDCNV(hdc) end
-  
-    Parameters = {
-      wglEnumGpusNV:               [ :BOOL, :UINT, :pointer ].freeze,
-      wglEnumGpuDevicesNV:         [ :BOOL, :HGPUNV, :UINT, :PGPU_DEVICE ].freeze,
-      wglCreateAffinityDCNV:       [ :HDC, :pointer ].freeze,
-      wglEnumGpusFromAffinityDCNV: [ :BOOL, :HDC, :UINT, :pointer ].freeze,
-      wglDeleteDCNV:               [ :BOOL, :HDC ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglEnumGpusNV(iGpuIndex, phGpu) end => [ :BOOL, :UINT, :pointer ].freeze,
+    def wglEnumGpuDevicesNV(hGpu, iDeviceIndex, lpGpuDevice) end => [ :BOOL, :HGPUNV, :UINT, :PGPU_DEVICE ].freeze,
+    def wglCreateAffinityDCNV(phGpuList) end => [ :HDC, :pointer ].freeze,
+    def wglEnumGpusFromAffinityDCNV(hAffinityDC, iGpuIndex, hGpu) end => [ :BOOL, :HDC, :UINT, :pointer ].freeze,
+    def wglDeleteDCNV(hdc) end => [ :BOOL, :HDC ].freeze,
+  }.freeze
 end

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

@@ -3,15 +3,9 @@ module WGL_NV_present_video
     NNUM_VIDEO_SLOTS_NV = 0x20F0
   end
   
-  module Functions
-    def wglEnumerateVideoDevicesNV(hDC, phDeviceList) end
-    def wglBindVideoDeviceNV(hDC, uVideoSlot, hVideoDevice, piAttribList) end
-    def wglQueryCurrentContextNV(iAttribute, piValue) end
-  
-    Parameters = {
-      wglEnumerateVideoDevicesNV: [ :int, :HDC, :pointer ].freeze,
-      wglBindVideoDeviceNV:       [ :BOOL, :HDC, :uint, :HVIDEOOUTPUTDEVICENV, :pointer ].freeze,
-      wglQueryCurrentContextNV:   [ :BOOL, :int, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglEnumerateVideoDevicesNV(hDC, phDeviceList) end => [ :int, :HDC, :pointer ].freeze,
+    def wglBindVideoDeviceNV(hDC, uVideoSlot, hVideoDevice, piAttribList) end => [ :BOOL, :HDC, :uint, :HVIDEOOUTPUTDEVICENV, :pointer ].freeze,
+    def wglQueryCurrentContextNV(iAttribute, piValue) end => [ :BOOL, :int, :pointer ].freeze,
+  }.freeze
 end

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

@@ -1,19 +1,10 @@
 module WGL_NV_swap_group
-  module Functions
-    def wglJoinSwapGroupNV(hDC, group) end
-    def wglBindSwapBarrierNV(group, barrier) end
-    def wglQuerySwapGroupNV(hDC, group, barrier) end
-    def wglQueryMaxSwapGroupsNV(hDC, maxGroups, maxBarriers) end
-    def wglQueryFrameCountNV(hDC, count) end
-    def wglResetFrameCountNV(hDC) end
-  
-    Parameters = {
-      wglJoinSwapGroupNV:      [ :BOOL, :HDC, :GLuint ].freeze,
-      wglBindSwapBarrierNV:    [ :BOOL, :GLuint, :GLuint ].freeze,
-      wglQuerySwapGroupNV:     [ :BOOL, :HDC, :pointer, :pointer ].freeze,
-      wglQueryMaxSwapGroupsNV: [ :BOOL, :HDC, :pointer, :pointer ].freeze,
-      wglQueryFrameCountNV:    [ :BOOL, :HDC, :pointer ].freeze,
-      wglResetFrameCountNV:    [ :BOOL, :HDC ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglJoinSwapGroupNV(hDC, group) end => [ :BOOL, :HDC, :GLuint ].freeze,
+    def wglBindSwapBarrierNV(group, barrier) end => [ :BOOL, :GLuint, :GLuint ].freeze,
+    def wglQuerySwapGroupNV(hDC, group, barrier) end => [ :BOOL, :HDC, :pointer, :pointer ].freeze,
+    def wglQueryMaxSwapGroupsNV(hDC, maxGroups, maxBarriers) end => [ :BOOL, :HDC, :pointer, :pointer ].freeze,
+    def wglQueryFrameCountNV(hDC, count) end => [ :BOOL, :HDC, :pointer ].freeze,
+    def wglResetFrameCountNV(hDC) end => [ :BOOL, :HDC ].freeze,
+  }.freeze
 end

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

@@ -1,11 +1,6 @@
 module WGL_NV_vertex_array_range
-  module Functions
-    def wglAllocateMemoryNV(size, readfreq, writefreq, priority) end
-    def wglFreeMemoryNV(pointer) end
-  
-    Parameters = {
-      wglAllocateMemoryNV: [ :pointer, :GLsizei, :GLfloat, :GLfloat, :GLfloat ].freeze,
-      wglFreeMemoryNV:     [ :void, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglAllocateMemoryNV(size, readfreq, writefreq, priority) end => [ :pointer, :GLsizei, :GLfloat, :GLfloat, :GLfloat ].freeze,
+    def wglFreeMemoryNV(pointer) end => [ :void, :pointer ].freeze,
+  }.freeze
 end

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

@@ -4,19 +4,11 @@ module WGL_NV_video_capture
     NNUM_VIDEO_CAPTURE_SLOTS_NV = 0x20CF
   end
   
-  module Functions
-    def wglBindVideoCaptureDeviceNV(uVideoSlot, hDevice) end
-    def wglEnumerateVideoCaptureDevicesNV(hDc, phDeviceList) end
-    def wglLockVideoCaptureDeviceNV(hDc, hDevice) end
-    def wglQueryVideoCaptureDeviceNV(hDc, hDevice, iAttribute, piValue) end
-    def wglReleaseVideoCaptureDeviceNV(hDc, hDevice) end
-  
-    Parameters = {
-      wglBindVideoCaptureDeviceNV:       [ :BOOL, :UINT, :HVIDEOINPUTDEVICENV ].freeze,
-      wglEnumerateVideoCaptureDevicesNV: [ :UINT, :HDC, :pointer ].freeze,
-      wglLockVideoCaptureDeviceNV:       [ :BOOL, :HDC, :HVIDEOINPUTDEVICENV ].freeze,
-      wglQueryVideoCaptureDeviceNV:      [ :BOOL, :HDC, :HVIDEOINPUTDEVICENV, :int, :pointer ].freeze,
-      wglReleaseVideoCaptureDeviceNV:    [ :BOOL, :HDC, :HVIDEOINPUTDEVICENV ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglBindVideoCaptureDeviceNV(uVideoSlot, hDevice) end => [ :BOOL, :UINT, :HVIDEOINPUTDEVICENV ].freeze,
+    def wglEnumerateVideoCaptureDevicesNV(hDc, phDeviceList) end => [ :UINT, :HDC, :pointer ].freeze,
+    def wglLockVideoCaptureDeviceNV(hDc, hDevice) end => [ :BOOL, :HDC, :HVIDEOINPUTDEVICENV ].freeze,
+    def wglQueryVideoCaptureDeviceNV(hDc, hDevice, iAttribute, piValue) end => [ :BOOL, :HDC, :HVIDEOINPUTDEVICENV, :int, :pointer ].freeze,
+    def wglReleaseVideoCaptureDeviceNV(hDc, hDevice) end => [ :BOOL, :HDC, :HVIDEOINPUTDEVICENV ].freeze,
+  }.freeze
 end

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

@@ -15,21 +15,12 @@ module WGL_NV_video_output
     NVIDEO_OUT_STACKED_FIELDS_2_1   = 0x20CC
   end
   
-  module Functions
-    def wglGetVideoDeviceNV(hDC, numDevices, hVideoDevice) end
-    def wglReleaseVideoDeviceNV(hVideoDevice) end
-    def wglBindVideoImageNV(hVideoDevice, hPbuffer, iVideoBuffer) end
-    def wglReleaseVideoImageNV(hPbuffer, iVideoBuffer) end
-    def wglSendPbufferToVideoNV(hPbuffer, iBufferType, pulCounterPbuffer, bBlock) end
-    def wglGetVideoInfoNV(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo) end
-  
-    Parameters = {
-      wglGetVideoDeviceNV:     [ :BOOL, :HDC, :int, :pointer ].freeze,
-      wglReleaseVideoDeviceNV: [ :BOOL, :HPVIDEODEV ].freeze,
-      wglBindVideoImageNV:     [ :BOOL, :HPVIDEODEV, :HPBUFFERARB, :int ].freeze,
-      wglReleaseVideoImageNV:  [ :BOOL, :HPBUFFERARB, :int ].freeze,
-      wglSendPbufferToVideoNV: [ :BOOL, :HPBUFFERARB, :int, :pointer, :BOOL ].freeze,
-      wglGetVideoInfoNV:       [ :BOOL, :HPVIDEODEV, :pointer, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglGetVideoDeviceNV(hDC, numDevices, hVideoDevice) end => [ :BOOL, :HDC, :int, :pointer ].freeze,
+    def wglReleaseVideoDeviceNV(hVideoDevice) end => [ :BOOL, :HPVIDEODEV ].freeze,
+    def wglBindVideoImageNV(hVideoDevice, hPbuffer, iVideoBuffer) end => [ :BOOL, :HPVIDEODEV, :HPBUFFERARB, :int ].freeze,
+    def wglReleaseVideoImageNV(hPbuffer, iVideoBuffer) end => [ :BOOL, :HPBUFFERARB, :int ].freeze,
+    def wglSendPbufferToVideoNV(hPbuffer, iBufferType, pulCounterPbuffer, bBlock) end => [ :BOOL, :HPBUFFERARB, :int, :pointer, :BOOL ].freeze,
+    def wglGetVideoInfoNV(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo) end => [ :BOOL, :HPVIDEODEV, :pointer, :pointer ].freeze,
+  }.freeze
 end

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

@@ -1,19 +1,10 @@
 module WGL_OML_sync_control
-  module Functions
-    def wglGetSyncValuesOML(hdc, ust, msc, sbc) end
-    def wglGetMscRateOML(hdc, numerator, denominator) end
-    def wglSwapBuffersMscOML(hdc, target_msc, divisor, remainder) end
-    def wglSwapLayerBuffersMscOML(hdc, fuPlanes, target_msc, divisor, remainder) end
-    def wglWaitForMscOML(hdc, target_msc, divisor, remainder, ust, msc, sbc) end
-    def wglWaitForSbcOML(hdc, target_sbc, ust, msc, sbc) end
-  
-    Parameters = {
-      wglGetSyncValuesOML:       [ :BOOL, :HDC, :pointer, :pointer, :pointer ].freeze,
-      wglGetMscRateOML:          [ :BOOL, :HDC, :pointer, :pointer ].freeze,
-      wglSwapBuffersMscOML:      [ :INT64, :HDC, :INT64, :INT64, :INT64 ].freeze,
-      wglSwapLayerBuffersMscOML: [ :INT64, :HDC, :int, :INT64, :INT64, :INT64 ].freeze,
-      wglWaitForMscOML:          [ :BOOL, :HDC, :INT64, :INT64, :INT64, :pointer, :pointer, :pointer ].freeze,
-      wglWaitForSbcOML:          [ :BOOL, :HDC, :INT64, :pointer, :pointer, :pointer ].freeze,
-    }.freeze
-  end
+  Functions = {
+    def wglGetSyncValuesOML(hdc, ust, msc, sbc) end => [ :BOOL, :HDC, :pointer, :pointer, :pointer ].freeze,
+    def wglGetMscRateOML(hdc, numerator, denominator) end => [ :BOOL, :HDC, :pointer, :pointer ].freeze,
+    def wglSwapBuffersMscOML(hdc, target_msc, divisor, remainder) end => [ :INT64, :HDC, :INT64, :INT64, :INT64 ].freeze,
+    def wglSwapLayerBuffersMscOML(hdc, fuPlanes, target_msc, divisor, remainder) end => [ :INT64, :HDC, :int, :INT64, :INT64, :INT64 ].freeze,
+    def wglWaitForMscOML(hdc, target_msc, divisor, remainder, ust, msc, sbc) end => [ :BOOL, :HDC, :INT64, :INT64, :INT64, :pointer, :pointer, :pointer ].freeze,
+    def wglWaitForSbcOML(hdc, target_sbc, ust, msc, sbc) end => [ :BOOL, :HDC, :INT64, :pointer, :pointer, :pointer ].freeze,
+  }.freeze
 end

data/lib/opengl-definitions/version.rb

@@ -1,5 +1,5 @@
 module GL
   module Definitions
-    VERSION = '1.0.0'
+    VERSION = '2.0.0'
   end
 end

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

@@ -0,0 +1,87 @@
+# Unlike other extensions, functions from this module are not pointers.
+#
+module GLX_VERSION_1_0
+  module Constants
+    GLX_EXTENSION_NAME     = 'GLX'
+    GLX_PbufferClobber     = 0
+    GLX_BufferSwapComplete = 1
+    GLX_NUMBER_EVENTS      = 17
+    GLX_BAD_SCREEN         = 1
+    GLX_BAD_ATTRIBUTE      = 2
+    GLX_NO_EXTENSION       = 3
+    GLX_BAD_VISUAL         = 4
+    GLX_BAD_CONTEXT        = 5
+    GLX_BAD_VALUE          = 6
+    GLX_BAD_ENUM           = 7
+    GLX_USE_GL             = 1
+    GLX_BUFFER_SIZE        = 2
+    GLX_LEVEL              = 3
+    GLX_RGBA               = 4
+    GLX_DOUBLEBUFFER       = 5
+    GLX_STEREO             = 6
+    GLX_AUX_BUFFERS        = 7
+    GLX_RED_SIZE           = 8
+    GLX_GREEN_SIZE         = 9
+    GLX_BLUE_SIZE          = 10
+    GLX_ALPHA_SIZE         = 11
+    GLX_DEPTH_SIZE         = 12
+    GLX_STENCIL_SIZE       = 13
+    GLX_ACCUM_RED_SIZE     = 14
+    GLX_ACCUM_GREEN_SIZE   = 15
+    GLX_ACCUM_BLUE_SIZE    = 16
+    GLX_ACCUM_ALPHA_SIZE   = 17
+  end
+
+  Functions = {
+    # XVisualInfo* glXChooseVisual (Display *dpy, int screen, int *attribList)
+    def glXChooseVisual(dpy, screen, attribList) end => [ :pointer, :pointer, :int, :pointer ].freeze,
+
+    # void glXCopyContext (Display *dpy, GLXContext src, GLXContext dst, GLulong mask)
+    def glXCopyContext(dpy, src, dst, mask) end => [ :void, :pointer, :pointer, :pointer, :ulong ].freeze,
+
+    # GLXContext glXCreateContext (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct)
+    def glXCreateContext(dpy, vis, shareList, direct) end => [ :pointer, :pointer, :pointer, :pointer, :int ].freeze,
+
+    # GLXPixmap glXCreateGLXPixmap (Display *dpy, XVisualInfo *vis, Pixmap pixmap)
+    def glXCreateGLXPixmap(dpy, visual, pixmap) end => [ :ulong, :pointer, :pointer, :ulong ].freeze,
+
+    # void glXDestroyContext (Display *dpy, GLXContext ctx)
+    def glXDestroyContext(dpy, ctx) end => [ :void, :pointer, :pointer ].freeze,
+
+    # void glXDestroyGLXPixmap (Display *dpy, GLXPixmap pix)
+    def glXDestroyGLXPixmap(dpy, pixmap) end => [ :void, :pointer, :ulong ].freeze,
+
+    # int glXGetConfig (Display *dpy, XVisualInfo *vis, int attrib, int *value)
+    def glXGetConfig(dpy, visual, attrib, value) end => [ :int, :pointer, :pointer, :int, :pointer ].freeze,
+
+    # GLXContext glXGetCurrentContext (void)
+    def glXGetCurrentContext() end => [ :pointer ].freeze,
+
+    # GLXDrawable glXGetCurrentDrawable (void)
+    def glXGetCurrentDrawable() end => [ :ulong ].freeze,
+
+    # Bool glXIsDirect (Display *dpy, GLXContext ctx)
+    def glXIsDirect(dpy, ctx) end => [ :int, :pointer, :pointer ].freeze,
+
+    # Bool glXMakeCurrent (Display *dpy, GLXDrawable drawable, GLXContext ctx)
+    def glXMakeCurrent(dpy, drawable, ctx) end => [ :int, :pointer, :ulong, :pointer ].freeze,
+
+    # Bool glXQueryExtension (Display *dpy, int *errorBase, int *eventBase)
+    def glXQueryExtension(dpy, errorb, event) end => [ :int, :pointer, :pointer, :pointer ].freeze,
+
+    # Bool glXQueryVersion (Display *dpy, int *major, int *minor)
+    def glXQueryVersion(dpy, major, minor) end => [ :int, :pointer, :pointer, :pointer ].freeze,
+
+    # void glXSwapBuffers (Display *dpy, GLXDrawable drawable)
+    def glXSwapBuffers(dpy, drawable) end => [ :void, :pointer, :ulong ].freeze,
+
+    # void glXUseXFont (Font font, int first, int count, int listBase)
+    def glXUseXFont(font, first, count, list) end => [ :void, :ulong, :int, :int, :int ].freeze,
+
+    # void glXWaitGL (void)
+    def glXWaitGL() end => [ :void ].freeze,
+
+    # void glXWaitX (void)
+    def glXWaitX() end => [ :void ].freeze,
+  }.freeze
+end

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

@@ -7,20 +7,14 @@ module GLX_VERSION_1_1
     EXTENSIONS = 0x3
   end
 
-  module Functions
-    def glXGetClientString(dpy, name) end
-    def glXQueryExtensionsString(dpy, screen) end
-    def glXQueryServerString(dpy, screen, name) end
+  Functions = {
+    # const char* glXGetClientString (Display *dpy, int name)
+    def glXGetClientString(dpy, name) end => [ :string, :pointer, :int ].freeze,
 
-    Parameters = {
-      #const char* glXGetClientString (Display *dpy, int name)
-      glXGetClientString: [ :string, :pointer, :int ].freeze,
+    # const char* glXQueryExtensionsString (Display *dpy, int screen)
+    def glXQueryExtensionsString(dpy, screen) end => [ :string, :pointer, :int ].freeze,
 
-      #const char* glXQueryExtensionsString (Display *dpy, int screen)
-      glXQueryExtensionsString: [ :string, :pointer, :int ].freeze,
-
-      #const char* glXQueryServerString (Display *dpy, int screen, int name)
-      glXQueryServerString: [ :string, :pointer, :int, :int ].freeze
-    }.freeze
-  end
+    # const char* glXQueryServerString (Display *dpy, int screen, int name)
+    def glXQueryServerString(dpy, screen, name) end => [ :string, :pointer, :int, :int ].freeze
+  }.freeze
 end

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

@@ -1,10 +1,6 @@
 module GLX_VERSION_1_2
-  module Functions
-    def glXGetCurrentDisplay() end
-
-    Parameters = {
-      #Display* glXGetCurrentDisplay (void)
-      glXGetCurrentDisplay: [ :pointer ].freeze
-    }.freeze
-  end
+  Functions = {
+    # Display* glXGetCurrentDisplay (void)
+    def glXGetCurrentDisplay() end => [ :pointer ].freeze
+  }.freeze
 end

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

@@ -58,76 +58,56 @@ module GLX_VERSION_1_3
     X_VISUAL_TYPE           = 0x22
   end
 
-  module Functions
-    def glXChooseFBConfig(dpy, screen, attrib_list, nelements) end
-    def glXCreateNewContext(dpy, config, render_type, share_list, direct) end
-    def glXCreatePbuffer(dpy, config, attrib_list) end
-    def glXCreatePixmap(dpy, config, pixmap, attrib_list) end
-    def glXCreateWindow(dpy, config, win, attrib_list) end
-    def glXDestroyPbuffer(dpy, pbuf) end
-    def glXDestroyPixmap(dpy, pixmap) end
-    def glXDestroyWindow(dpy, win) end
-    def glXGetCurrentReadDrawable() end
-    def glXGetFBConfigAttrib(dpy, config, attribute, value) end
-    def glXGetFBConfigs(dpy, screen, nelements) end
-    def glXGetSelectedEvent(dpy, draw, event_mask) end
-    def glXGetVisualFromFBConfig(dpy, config) end
-    def glXMakeContextCurrent(dpy, draw, read, ctx) end
-    def glXQueryContext(dpy, ctx, attribute, value) end
-    def glXQueryDrawable(dpy, draw, attribute, value) end
-    def glXSelectEvent(dpy, draw, event_mask) end
+  Functions = {
+    # GLXFBConfig* glXChooseFBConfig (Display *dpy, int screen, const int *attrib_list, int *nelements)
+    def glXChooseFBConfig(dpy, screen, attrib_list, nelements) end => [ :pointer, :pointer, :int, :pointer, :pointe ].freeze,
 
-    Parameters = {
-      #GLXFBConfig* glXChooseFBConfig (Display *dpy, int screen, const int *attrib_list, int *nelements)
-      glXChooseFBConfig: [ :pointer, :pointer, :int, :pointer, :pointe ].freeze,
+    # GLXContext glXCreateNewContext (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct)
+    def glXCreateNewContext(dpy, config, render_type, share_list, direct) end => [ :pointer, :pointer, :pointer, :int, :pointer, :boo ].freeze,
 
-      #GLXContext glXCreateNewContext (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct)
-      glXCreateNewContext: [ :pointer, :pointer, :pointer, :int, :pointer, :boo ].freeze,
+    # GLXPbuffer glXCreatePbuffer (Display *dpy, GLXFBConfig config, const int *attrib_list)
+    def glXCreatePbuffer(dpy, config, attrib_list) end => [ :int, :pointer, :pointer, :pointe ].freeze,
 
-      #GLXPbuffer glXCreatePbuffer (Display *dpy, GLXFBConfig config, const int *attrib_list)
-      glXCreatePbuffer: [ :int, :pointer, :pointer, :pointe ].freeze,
+    # GLXPixmap glXCreatePixmap (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list)
+    def glXCreatePixmap(dpy, config, pixmap, attrib_list) end => [ :int, :pointer, :pointer, :int, :pointe ].freeze,
 
-      #GLXPixmap glXCreatePixmap (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list)
-      glXCreatePixmap: [ :int, :pointer, :pointer, :int, :pointe ].freeze,
+    # GLXWindow glXCreateWindow (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list)
+    def glXCreateWindow(dpy, config, win, attrib_list) end => [ :int, :pointer, :pointer, :int, :pointe ].freeze,
 
-      #GLXWindow glXCreateWindow (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list)
-      glXCreateWindow: [ :int, :pointer, :pointer, :int, :pointe ].freeze,
+    # void glXDestroyPbuffer (Display *dpy, GLXPbuffer pbuf)
+    def glXDestroyPbuffer(dpy, pbuf) end => [ :void, :pointer, :in ].freeze,
 
-      #void glXDestroyPbuffer (Display *dpy, GLXPbuffer pbuf)
-      glXDestroyPbuffer: [ :void, :pointer, :in ].freeze,
+    # void glXDestroyPixmap (Display *dpy, GLXPixmap pixmap)
+    def glXDestroyPixmap(dpy, pixmap) end => [ :void, :pointer, :in ].freeze,
 
-      #void glXDestroyPixmap (Display *dpy, GLXPixmap pixmap)
-      glXDestroyPixmap: [ :void, :pointer, :in ].freeze,
+    # void glXDestroyWindow (Display *dpy, GLXWindow win)
+    def glXDestroyWindow(dpy, win) end => [ :void, :pointer, :in ].freeze,
 
-      #void glXDestroyWindow (Display *dpy, GLXWindow win)
-      glXDestroyWindow: [ :void, :pointer, :in ].freeze,
+    # GLXDrawable glXGetCurrentReadDrawable (void)
+    def glXGetCurrentReadDrawable() end => [ :int ].freeze,
 
-      #GLXDrawable glXGetCurrentReadDrawable (void)
-      glXGetCurrentReadDrawable: [ :int ].freeze,
+    # int glXGetFBConfigAttrib (Display *dpy, GLXFBConfig config, int attribute, int *value)
+    def glXGetFBConfigAttrib(dpy, config, attribute, value) end => [ :int, :pointer, :pointer, :int, :pointe ].freeze,
 
-      #int glXGetFBConfigAttrib (Display *dpy, GLXFBConfig config, int attribute, int *value)
-      glXGetFBConfigAttrib: [ :int, :pointer, :pointer, :int, :pointe ].freeze,
+    # GLXFBConfig* glXGetFBConfigs (Display *dpy, int screen, int *nelements)
+    def glXGetFBConfigs(dpy, screen, nelements) end => [ :pointer, :pointer, :int, :pointe ].freeze,
 
-      #GLXFBConfig* glXGetFBConfigs (Display *dpy, int screen, int *nelements)
-      glXGetFBConfigs: [ :pointer, :pointer, :int, :pointe ].freeze,
+    # void glXGetSelectedEvent (Display *dpy, GLXDrawable draw, unsigned long *event_mask)
+    def glXGetSelectedEvent(dpy, draw, event_mask) end => [ :void, :pointer, :int, :pointe ].freeze,
 
-      #void glXGetSelectedEvent (Display *dpy, GLXDrawable draw, unsigned long *event_mask)
-      glXGetSelectedEvent: [ :void, :pointer, :int, :pointe ].freeze,
+    # XVisualInfo* glXGetVisualFromFBConfig (Display *dpy, GLXFBConfig config)
+    def glXGetVisualFromFBConfig(dpy, config) end => [ :pointer, :pointer, :pointer ].freeze,
 
-      #XVisualInfo* glXGetVisualFromFBConfig (Display *dpy, GLXFBConfig config)
-      glXGetVisualFromFBConfig: [ :pointer, :pointer, :pointer ].freeze,
+    # Bool glXMakeContextCurrent (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
+    def glXMakeContextCurrent(dpy, draw, read, ctx) end => [ :bool, :pointer, :int, :int, :pointe ].freeze,
 
-      #Bool glXMakeContextCurrent (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
-      glXMakeContextCurrent: [ :bool, :pointer, :int, :int, :pointe ].freeze,
+    # int glXQueryContext (Display *dpy, GLXContext ctx, int attribute, int *value)
+    def glXQueryContext(dpy, ctx, attribute, value) end => [ :int, :pointer, :pointer, :int, :pointe ].freeze,
 
-      #int glXQueryContext (Display *dpy, GLXContext ctx, int attribute, int *value)
-      glXQueryContext: [ :int, :pointer, :pointer, :int, :pointe ].freeze,
+    # void glXQueryDrawable (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value)
+    def glXQueryDrawable(dpy, draw, attribute, value) end => [ :void, :pointer, :int, :int, :pointe ].freeze,
 
-      #void glXQueryDrawable (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value)
-      glXQueryDrawable: [ :void, :pointer, :int, :int, :pointe ].freeze,
-
-      #void glXSelectEvent (Display *dpy, GLXDrawable draw, unsigned long event_mask)
-      glXSelectEvent: [ :void, :pointer, :int, :uin ].freeze
-    }.freeze
-  end
+    # void glXSelectEvent (Display *dpy, GLXDrawable draw, unsigned long event_mask)
+    def glXSelectEvent(dpy, draw, event_mask) end => [ :void, :pointer, :int, :uin ].freeze,
+  }.freeze
 end