opengl-definitions 0.0.6 → 1.0.0

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

@@ -1,3 +1,5 @@
 module WGL_EXT_pixel_format_packed_float
-  WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = 0x20A8
+  module Constants
+    NTYPE_RGBA_UNSIGNED_FLOAT_EXT = 0x20A8
+  end
 end

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

@@ -1,6 +1,11 @@
 module WGL_EXT_swap_control
-  @functions = {
-    wglSwapIntervalEXT:    [ :BOOL, :int ].freeze,
-    wglGetSwapIntervalEXT: [ :int ].freeze,
-  }.freeze
+  module Functions
+    def wglSwapIntervalEXT(interval) end
+    def wglGetSwapIntervalEXT() end
+  
+    Parameters = {
+      wglSwapIntervalEXT:    [ :BOOL, :int ].freeze,
+      wglGetSwapIntervalEXT: [ :int ].freeze,
+    }.freeze
+  end
 end

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

@@ -1,11 +1,18 @@
 module WGL_I3D_digital_video_control
-  WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = 0x2050
-  WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D       = 0x2051
-  WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D          = 0x2052
-  WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D          = 0x2053
+  module Constants
+    NDIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = 0x2050
+    NDIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D       = 0x2051
+    NDIGITAL_VIDEO_CURSOR_INCLUDED_I3D          = 0x2052
+    NDIGITAL_VIDEO_GAMMA_CORRECTED_I3D          = 0x2053
+  end
   
-  @functions = {
-    wglGetDigitalVideoParametersI3D: [ :BOOL, :HDC, :int, :pointer ].freeze,
-    wglSetDigitalVideoParametersI3D: [ :BOOL, :HDC, :int, :pointer ].freeze,
-  }.freeze
+  module Functions
+    def wglGetDigitalVideoParametersI3D(hDC, iAttribute, piValue) end
+    def wglSetDigitalVideoParametersI3D(hDC, iAttribute, piValue) end
+  
+    Parameters = {
+      wglGetDigitalVideoParametersI3D: [ :BOOL, :HDC, :int, :pointer ].freeze,
+      wglSetDigitalVideoParametersI3D: [ :BOOL, :HDC, :int, :pointer ].freeze,
+    }.freeze
+  end
 end

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

@@ -1,11 +1,20 @@
 module WGL_I3D_gamma
-  WGL_GAMMA_TABLE_SIZE_I3D      = 0x204E
-  WGL_GAMMA_EXCLUDE_DESKTOP_I3D = 0x204F
+  module Constants
+    NGAMMA_TABLE_SIZE_I3D      = 0x204E
+    NGAMMA_EXCLUDE_DESKTOP_I3D = 0x204F
+  end
   
-  @functions = {
-    wglGetGammaTableParametersI3D: [ :BOOL, :HDC, :int, :pointer ].freeze,
-    wglSetGammaTableParametersI3D: [ :BOOL, :HDC, :int, :pointer ].freeze,
-    wglGetGammaTableI3D:           [ :BOOL, :HDC, :int, :pointer, :pointer, :pointer ].freeze,
-    wglSetGammaTableI3D:           [ :BOOL, :HDC, :int, :pointer, :pointer, :pointer ].freeze,
-  }.freeze
+  module Functions
+    def wglGetGammaTableParametersI3D(hDC, iAttribute, piValue) end
+    def wglSetGammaTableParametersI3D(hDC, iAttribute, piValue) end
+    def wglGetGammaTableI3D(hDC, iEntries, puRed, puGreen, puBlue) end
+    def wglSetGammaTableI3D(hDC, iEntries, puRed, puGreen, puBlue) end
+  
+    Parameters = {
+      wglGetGammaTableParametersI3D: [ :BOOL, :HDC, :int, :pointer ].freeze,
+      wglSetGammaTableParametersI3D: [ :BOOL, :HDC, :int, :pointer ].freeze,
+      wglGetGammaTableI3D:           [ :BOOL, :HDC, :int, :pointer, :pointer, :pointer ].freeze,
+      wglSetGammaTableI3D:           [ :BOOL, :HDC, :int, :pointer, :pointer, :pointer ].freeze,
+    }.freeze
+  end
 end

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

@@ -1,26 +1,43 @@
 module WGL_I3D_genlock
-  WGL_GENLOCK_SOURCE_MULTIVIEW_I3D      = 0x2044
-  WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D  = 0x2045
-  WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D = 0x2046
-  WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D   = 0x2047
-  WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D   = 0x2048
-  WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D  = 0x2049
-  WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D   = 0x204A
-  WGL_GENLOCK_SOURCE_EDGE_RISING_I3D    = 0x204B
-  WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D      = 0x204C
+  module Constants
+    NGENLOCK_SOURCE_MULTIVIEW_I3D      = 0x2044
+    NGENLOCK_SOURCE_EXTERNAL_SYNC_I3D  = 0x2045
+    NGENLOCK_SOURCE_EXTERNAL_FIELD_I3D = 0x2046
+    NGENLOCK_SOURCE_EXTERNAL_TTL_I3D   = 0x2047
+    NGENLOCK_SOURCE_DIGITAL_SYNC_I3D   = 0x2048
+    NGENLOCK_SOURCE_DIGITAL_FIELD_I3D  = 0x2049
+    NGENLOCK_SOURCE_EDGE_FALLING_I3D   = 0x204A
+    NGENLOCK_SOURCE_EDGE_RISING_I3D    = 0x204B
+    NGENLOCK_SOURCE_EDGE_BOTH_I3D      = 0x204C
+  end
   
-  @functions = {
-    wglEnableGenlockI3D:              [ :BOOL, :HDC ].freeze,
-    wglDisableGenlockI3D:             [ :BOOL, :HDC ].freeze,
-    wglIsEnabledGenlockI3D:           [ :BOOL, :HDC, :pointer ].freeze,
-    wglGenlockSourceI3D:              [ :BOOL, :HDC, :UINT ].freeze,
-    wglGetGenlockSourceI3D:           [ :BOOL, :HDC, :pointer ].freeze,
-    wglGenlockSourceEdgeI3D:          [ :BOOL, :HDC, :UINT ].freeze,
-    wglGetGenlockSourceEdgeI3D:       [ :BOOL, :HDC, :pointer ].freeze,
-    wglGenlockSampleRateI3D:          [ :BOOL, :HDC, :UINT ].freeze,
-    wglGetGenlockSampleRateI3D:       [ :BOOL, :HDC, :pointer ].freeze,
-    wglGenlockSourceDelayI3D:         [ :BOOL, :HDC, :UINT ].freeze,
-    wglGetGenlockSourceDelayI3D:      [ :BOOL, :HDC, :pointer ].freeze,
-    wglQueryGenlockMaxSourceDelayI3D: [ :BOOL, :HDC, :pointer, :pointer ].freeze,
-  }.freeze
+  module Functions
+    def wglEnableGenlockI3D(hDC) end
+    def wglDisableGenlockI3D(hDC) end
+    def wglIsEnabledGenlockI3D(hDC, pFlag) end
+    def wglGenlockSourceI3D(hDC, uSource) end
+    def wglGetGenlockSourceI3D(hDC, uSource) end
+    def wglGenlockSourceEdgeI3D(hDC, uEdge) end
+    def wglGetGenlockSourceEdgeI3D(hDC, uEdge) end
+    def wglGenlockSampleRateI3D(hDC, uRate) end
+    def wglGetGenlockSampleRateI3D(hDC, uRate) end
+    def wglGenlockSourceDelayI3D(hDC, uDelay) end
+    def wglGetGenlockSourceDelayI3D(hDC, uDelay) end
+    def wglQueryGenlockMaxSourceDelayI3D(hDC, uMaxLineDelay, uMaxPixelDelay) end
+  
+    Parameters = {
+      wglEnableGenlockI3D:              [ :BOOL, :HDC ].freeze,
+      wglDisableGenlockI3D:             [ :BOOL, :HDC ].freeze,
+      wglIsEnabledGenlockI3D:           [ :BOOL, :HDC, :pointer ].freeze,
+      wglGenlockSourceI3D:              [ :BOOL, :HDC, :UINT ].freeze,
+      wglGetGenlockSourceI3D:           [ :BOOL, :HDC, :pointer ].freeze,
+      wglGenlockSourceEdgeI3D:          [ :BOOL, :HDC, :UINT ].freeze,
+      wglGetGenlockSourceEdgeI3D:       [ :BOOL, :HDC, :pointer ].freeze,
+      wglGenlockSampleRateI3D:          [ :BOOL, :HDC, :UINT ].freeze,
+      wglGetGenlockSampleRateI3D:       [ :BOOL, :HDC, :pointer ].freeze,
+      wglGenlockSourceDelayI3D:         [ :BOOL, :HDC, :UINT ].freeze,
+      wglGetGenlockSourceDelayI3D:      [ :BOOL, :HDC, :pointer ].freeze,
+      wglQueryGenlockMaxSourceDelayI3D: [ :BOOL, :HDC, :pointer, :pointer ].freeze,
+    }.freeze
+  end
 end

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

@@ -1,11 +1,20 @@
 module WGL_I3D_image_buffer
-  WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = 0x00000001
-  WGL_IMAGE_BUFFER_LOCK_I3D       = 0x00000002
+  module Constants
+    NIMAGE_BUFFER_MIN_ACCESS_I3D = 0x00000001
+    NIMAGE_BUFFER_LOCK_I3D       = 0x00000002
+  end
   
-  @functions = {
-    wglCreateImageBufferI3D:          [ :LPVOID, :HDC, :DWORD, :UINT ].freeze,
-    wglDestroyImageBufferI3D:         [ :BOOL, :HDC, :LPVOID ].freeze,
-    wglAssociateImageBufferEventsI3D: [ :BOOL, :HDC, :pointer, :pointer, :pointer, :UINT ].freeze,
-    wglReleaseImageBufferEventsI3D:   [ :BOOL, :HDC, :pointer, :UINT ].freeze,
-  }.freeze
+  module Functions
+    def wglCreateImageBufferI3D(hDC, dwSize, uFlags) end
+    def wglDestroyImageBufferI3D(hDC, pAddress) end
+    def wglAssociateImageBufferEventsI3D(hDC, pEvent, pAddress, pSize, count) end
+    def wglReleaseImageBufferEventsI3D(hDC, pAddress, count) end
+  
+    Parameters = {
+      wglCreateImageBufferI3D:          [ :LPVOID, :HDC, :DWORD, :UINT ].freeze,
+      wglDestroyImageBufferI3D:         [ :BOOL, :HDC, :LPVOID ].freeze,
+      wglAssociateImageBufferEventsI3D: [ :BOOL, :HDC, :pointer, :pointer, :pointer, :UINT ].freeze,
+      wglReleaseImageBufferEventsI3D:   [ :BOOL, :HDC, :pointer, :UINT ].freeze,
+    }.freeze
+  end
 end

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

@@ -1,8 +1,15 @@
 module WGL_I3D_swap_frame_lock
-  @functions = {
-    wglEnableFrameLockI3D:      [ :BOOL ].freeze,
-    wglDisableFrameLockI3D:     [ :BOOL ].freeze,
-    wglIsEnabledFrameLockI3D:   [ :BOOL, :pointer ].freeze,
-    wglQueryFrameLockMasterI3D: [ :BOOL, :pointer ].freeze,
-  }.freeze
+  module Functions
+    def wglEnableFrameLockI3D() end
+    def wglDisableFrameLockI3D() end
+    def wglIsEnabledFrameLockI3D(pFlag) end
+    def wglQueryFrameLockMasterI3D(pFlag) end
+  
+    Parameters = {
+      wglEnableFrameLockI3D:      [ :BOOL ].freeze,
+      wglDisableFrameLockI3D:     [ :BOOL ].freeze,
+      wglIsEnabledFrameLockI3D:   [ :BOOL, :pointer ].freeze,
+      wglQueryFrameLockMasterI3D: [ :BOOL, :pointer ].freeze,
+    }.freeze
+  end
 end

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

@@ -1,8 +1,15 @@
 module WGL_I3D_swap_frame_usage
-  @functions = {
-    wglGetFrameUsageI3D:      [ :BOOL, :pointer ].freeze,
-    wglBeginFrameTrackingI3D: [ :BOOL ].freeze,
-    wglEndFrameTrackingI3D:   [ :BOOL ].freeze,
-    wglQueryFrameTrackingI3D: [ :BOOL, :pointer, :pointer, :pointer ].freeze,
-  }.freeze
+  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
 end

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

@@ -1,16 +1,29 @@
 module WGL_NV_DX_interop
-  WGL_ACCESS_READ_ONLY_NV     = 0x00000000
-  WGL_ACCESS_READ_WRITE_NV    = 0x00000001
-  WGL_ACCESS_WRITE_DISCARD_NV = 0x00000002
+  module Constants
+    NACCESS_READ_ONLY_NV     = 0x00000000
+    NACCESS_READ_WRITE_NV    = 0x00000001
+    NACCESS_WRITE_DISCARD_NV = 0x00000002
+  end
   
-  @functions = {
-    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
+  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
 end

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

@@ -1,5 +1,9 @@
 module WGL_NV_copy_image
-  @functions = {
-    wglCopyImageSubDataNV: [ :BOOL, :HGLRC, :GLuint, :GLenum, :GLint, :GLint, :GLint, :GLint, :HGLRC, :GLuint, :GLenum, :GLint, :GLint, :GLint, :GLint, :GLsizei, :GLsizei, :GLsizei ].freeze,
-  }.freeze
+  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
 end

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

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

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

@@ -1,11 +1,13 @@
 module WGL_NV_float_buffer
-  WGL_FLOAT_COMPONENTS_NV                     = 0x20B0
-  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV    = 0x20B1
-  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV   = 0x20B2
-  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV  = 0x20B3
-  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = 0x20B4
-  WGL_TEXTURE_FLOAT_R_NV                      = 0x20B5
-  WGL_TEXTURE_FLOAT_RG_NV                     = 0x20B6
-  WGL_TEXTURE_FLOAT_RGB_NV                    = 0x20B7
-  WGL_TEXTURE_FLOAT_RGBA_NV                   = 0x20B8
+  module Constants
+    NFLOAT_COMPONENTS_NV                     = 0x20B0
+    NBIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV    = 0x20B1
+    NBIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV   = 0x20B2
+    NBIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV  = 0x20B3
+    NBIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = 0x20B4
+    NTEXTURE_FLOAT_R_NV                      = 0x20B5
+    NTEXTURE_FLOAT_RG_NV                     = 0x20B6
+    NTEXTURE_FLOAT_RGB_NV                    = 0x20B7
+    NTEXTURE_FLOAT_RGBA_NV                   = 0x20B8
+  end
 end

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

@@ -1,12 +1,22 @@
 module WGL_NV_gpu_affinity
-  ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = 0x20D0
-  ERROR_MISSING_AFFINITY_MASK_NV       = 0x20D1
+  module Constants
+    NERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = 0x20D0
+    NERROR_MISSING_AFFINITY_MASK_NV       = 0x20D1
+  end
   
-  @functions = {
-    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
+  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
 end

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

@@ -1,4 +1,6 @@
 module WGL_NV_multisample_coverage
-  WGL_COVERAGE_SAMPLES_NV = 0x2042
-  WGL_COLOR_SAMPLES_NV    = 0x20B9
+  module Constants
+    NCOVERAGE_SAMPLES_NV = 0x2042
+    NCOLOR_SAMPLES_NV    = 0x20B9
+  end
 end

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

@@ -1,9 +1,17 @@
 module WGL_NV_present_video
-  WGL_NUM_VIDEO_SLOTS_NV = 0x20F0
+  module Constants
+    NNUM_VIDEO_SLOTS_NV = 0x20F0
+  end
   
-  @functions = {
-    wglEnumerateVideoDevicesNV: [ :int, :HDC, :pointer ].freeze,
-    wglBindVideoDeviceNV:       [ :BOOL, :HDC, :uint, :HVIDEOOUTPUTDEVICENV, :pointer ].freeze,
-    wglQueryCurrentContextNV:   [ :BOOL, :int, :pointer ].freeze,
-  }.freeze
+  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
 end

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

@@ -1,7 +1,9 @@
 module WGL_NV_render_depth_texture
-  WGL_BIND_TO_TEXTURE_DEPTH_NV           = 0x20A3
-  WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = 0x20A4
-  WGL_DEPTH_TEXTURE_FORMAT_NV            = 0x20A5
-  WGL_TEXTURE_DEPTH_COMPONENT_NV         = 0x20A6
-  WGL_DEPTH_COMPONENT_NV                 = 0x20A7
+  module Constants
+    NBIND_TO_TEXTURE_DEPTH_NV           = 0x20A3
+    NBIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = 0x20A4
+    NDEPTH_TEXTURE_FORMAT_NV            = 0x20A5
+    NTEXTURE_DEPTH_COMPONENT_NV         = 0x20A6
+    NDEPTH_COMPONENT_NV                 = 0x20A7
+  end
 end

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

@@ -1,5 +1,7 @@
 module WGL_NV_render_texture_rectangle
-  WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV  = 0x20A0
-  WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = 0x20A1
-  WGL_TEXTURE_RECTANGLE_NV              = 0x20A2
+  module Constants
+    NBIND_TO_TEXTURE_RECTANGLE_RGB_NV  = 0x20A0
+    NBIND_TO_TEXTURE_RECTANGLE_RGBA_NV = 0x20A1
+    NTEXTURE_RECTANGLE_NV              = 0x20A2
+  end
 end

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

@@ -1,10 +1,19 @@
 module WGL_NV_swap_group
-  @functions = {
-    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
+  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
 end

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

@@ -1,6 +1,11 @@
 module WGL_NV_vertex_array_range
-  @functions = {
-    wglAllocateMemoryNV: [ :pointer, :GLsizei, :GLfloat, :GLfloat, :GLfloat ].freeze,
-    wglFreeMemoryNV:     [ :void, :pointer ].freeze,
-  }.freeze
+  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
 end

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

@@ -1,12 +1,22 @@
 module WGL_NV_video_capture
-  WGL_UNIQUE_ID_NV               = 0x20CE
-  WGL_NUM_VIDEO_CAPTURE_SLOTS_NV = 0x20CF
+  module Constants
+    NUNIQUE_ID_NV               = 0x20CE
+    NNUM_VIDEO_CAPTURE_SLOTS_NV = 0x20CF
+  end
   
-  @functions = {
-    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
+  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
 end

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

@@ -1,24 +1,35 @@
 module WGL_NV_video_output
-  WGL_BIND_TO_VIDEO_RGB_NV           = 0x20C0
-  WGL_BIND_TO_VIDEO_RGBA_NV          = 0x20C1
-  WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV = 0x20C2
-  WGL_VIDEO_OUT_COLOR_NV             = 0x20C3
-  WGL_VIDEO_OUT_ALPHA_NV             = 0x20C4
-  WGL_VIDEO_OUT_DEPTH_NV             = 0x20C5
-  WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV   = 0x20C6
-  WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV   = 0x20C7
-  WGL_VIDEO_OUT_FRAME                = 0x20C8
-  WGL_VIDEO_OUT_FIELD_1              = 0x20C9
-  WGL_VIDEO_OUT_FIELD_2              = 0x20CA
-  WGL_VIDEO_OUT_STACKED_FIELDS_1_2   = 0x20CB
-  WGL_VIDEO_OUT_STACKED_FIELDS_2_1   = 0x20CC
+  module Constants
+    NBIND_TO_VIDEO_RGB_NV           = 0x20C0
+    NBIND_TO_VIDEO_RGBA_NV          = 0x20C1
+    NBIND_TO_VIDEO_RGB_AND_DEPTH_NV = 0x20C2
+    NVIDEO_OUT_COLOR_NV             = 0x20C3
+    NVIDEO_OUT_ALPHA_NV             = 0x20C4
+    NVIDEO_OUT_DEPTH_NV             = 0x20C5
+    NVIDEO_OUT_COLOR_AND_ALPHA_NV   = 0x20C6
+    NVIDEO_OUT_COLOR_AND_DEPTH_NV   = 0x20C7
+    NVIDEO_OUT_FRAME                = 0x20C8
+    NVIDEO_OUT_FIELD_1              = 0x20C9
+    NVIDEO_OUT_FIELD_2              = 0x20CA
+    NVIDEO_OUT_STACKED_FIELDS_1_2   = 0x20CB
+    NVIDEO_OUT_STACKED_FIELDS_2_1   = 0x20CC
+  end
   
-  @functions = {
-    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
+  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
 end

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

@@ -1,10 +1,19 @@
 module WGL_OML_sync_control
-  @functions = {
-    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
+  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
 end