From 2d65a0dcd3b2d317dddd5f8b17ecf2f8ca768df9 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Tue, 15 Apr 2014 15:31:10 +0200 Subject: [PATCH 01/18] Update wrapper; add automatic error-checking. --- src/opengl.nim | 17821 +++++++++++++++++++++-------------------------- 1 file changed, 8089 insertions(+), 9732 deletions(-) diff --git a/src/opengl.nim b/src/opengl.nim index d512fc1..2c18c90 100644 --- a/src/opengl.nim +++ b/src/opengl.nim @@ -1,9732 +1,8089 @@ -# -# -# Nimrod's Runtime Library -# (c) Copyright 2012 Andreas Rumpf -# -# See the file "copying.txt", included in this -# distribution, for details about the copyright. -# - -## This module is a wrapper around `opengl`:idx:. If you define the symbol -## ``useGlew`` this wrapper does not use Nimrod's ``dynlib`` mechanism, -## but `glew`:idx: instead. However, this shouldn't be necessary anymore; even -## extension loading for the different operating systems is handled here. -## -## You need to call ``loadExtensions`` after a rendering context has been -## created to load any extension proc that your code uses. - -when defined(linux): - import X, XLib, XUtil -elif defined(windows): - import winlean, os - -when defined(windows): - const - ogldll* = "OpenGL32.dll" - gludll* = "GLU32.dll" -elif defined(macosx): - #macosx has this notion of a framework, thus the path to the openGL dylib files - #is absolute - const - ogldll* = "/System/Library/Frameworks/OpenGL.framework/Versions/Current/Libraries/libGL.dylib" - gludll* = "/System/Library/Frameworks/OpenGL.framework/Versions/Current/Libraries/libGLU.dylib" -else: - const - ogldll* = "libGL.so.1" - gludll* = "libGLU.so.1" - -when defined(useGlew): - {.pragma: ogl, header: "".} - {.pragma: oglx, header: "".} - {.pragma: wgl, header: "".} - {.pragma: glu, dynlib: gludll.} -else: - # quite complex ... thanks to extension support for various platforms: - import dynlib - - let oglHandle = LoadLib(ogldll) - if isNil(oglHandle): quit("could not load: " & ogldll) - - when defined(windows): - var wglGetProcAddress = cast[proc (s: cstring): pointer {.stdcall.}]( - symAddr(oglHandle, "wglGetProcAddress")) - elif defined(linux): - var glXGetProcAddress = cast[proc (s: cstring): pointer {.cdecl.}]( - symAddr(oglHandle, "glXGetProcAddress")) - var glXGetProcAddressARB = cast[proc (s: cstring): pointer {.cdecl.}]( - symAddr(oglHandle, "glXGetProcAddressARB")) - - proc glGetProc(h: TLibHandle; procName: cstring): pointer = - when defined(windows): - result = symAddr(h, procname) - if result != nil: return - if not isNil(wglGetProcAddress): result = wglGetProcAddress(ProcName) - elif defined(linux): - if not isNil(glXGetProcAddress): result = glXGetProcAddress(ProcName) - if result != nil: return - if not isNil(glXGetProcAddressARB): - result = glXGetProcAddressARB(ProcName) - if result != nil: return - result = symAddr(h, procname) - else: - result = symAddr(h, procName) - if result == nil: raiseInvalidLibrary(procName) - - var gluHandle: TLibHandle - - proc gluGetProc(procname: cstring): pointer = - if gluHandle == nil: - gluHandle = LoadLib(gludll) - if gluHandle == nil: quit("could not load: " & gludll) - result = glGetProc(gluHandle, procname) - - # undocumented 'dynlib' feature: the string literal is replaced by - # the imported proc name: - {.pragma: ogl, dynlib: glGetProc(oglHandle, "0").} - {.pragma: oglx, dynlib: glGetProc(oglHandle, "0").} - {.pragma: wgl, dynlib: glGetProc(oglHandle, "0").} - {.pragma: glu, dynlib: gluGetProc("").} - - proc nimLoadProcs0() {.importc.} - - template loadExtensions*() = - ## call this after your rendering context has been setup if you use - ## extensions. - bind nimLoadProcs0 - nimLoadProcs0() - -#============================================================================== -# -# OpenGL 4.2 - Headertranslation -# Version 4.2a -# Date : 26.11.2011 -# -# Works with : -# - Delphi 3 and up -# - FreePascal (1.9.3 and up) -# -#============================================================================== -# -# Containts the translations of glext.h, gl_1_1.h, glu.h and weglext.h. -# It also contains some helperfunctions that were inspired by those -# found in Mike Lischke's OpenGL12.pas. -# -# Copyright (C) DGL-OpenGL2-Portteam -# All Rights Reserved -# -# Obtained through: -# Delphi OpenGL Community(DGL) - www.delphigl.com -# -# Converted and maintained by DGL's GL2.0-Team : -# - Sascha Willems - http://www.saschawillems.de -# - Steffen Xonna (Lossy eX) - http://www.dev-center.de -# Additional input : -# - Andrey Gruzdev (Mac OS X patch for XE2 / FPC) -# - Lars Middendorf -# - Martin Waldegger (Mars) -# - Benjamin Rosseaux (BeRo) - http://www.0ok.de -# Additional thanks: -# sigsegv (libdl.so) -# -# -#============================================================================== -# You may retrieve the latest version of this file at the Delphi OpenGL -# Community home page, located at http://www.delphigl.com/ -# -# The contents of this file are used with permission, subject to -# the Mozilla Public License Version 1.1 (the "License"); you may -# not use this file except in compliance with the License. You may -# obtain a copy of the License at -# http://www.mozilla.org/MPL/MPL-1.1.html -# -# Software distributed under the License is distributed on an -# "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or -# implied. See the License for the specific language governing -# rights and limitations under the License. -# -#============================================================================== -# History : -# Version 1.0 Initial Release -# Version 1.1 Added PPointer in Tpyessection for compatiblity with Delphi -# versions lower than 7 (SW) -# Added a function named RaiseLastOSError including a comment -# on how to make it run under Delphi versions lower than 7 (SW) -# Added some data types according to the GL-Syntax (SW) -# Version 1.2 Fixed some problems with getting the addresses of some -# Extensions (e.g. glTexImage3D) where the EXT/ARB did work -# but not the core-functions (SW) -# Version 1.3 A second call to ReadimplementationProperties won't -# revert to the default libs anymore (MW) -# Libraries now will be released if necessary (MW) -# Version 1.3a Small fixes for glSlang-functions (SW) -# Version 1.3b Fixed a small bug with GL_ARB_shader_objects, that lead -# lead to that extension not loaded correctly (SW) -# Version 1.3c more GL 1.5 compliance by FOG_COORD_xx and -# ARB less VBO and occlusion query routines (MW) -# Version 1.3d Fixed linebreaks (should now be corrected under D5) (SW) -# Version 1.4 Changed header to correspond to the OpenGL-Shading -# Language specification 1.10 : -# - Added new GL_SAMPLER*-Constants -# - Added Constant GL_SHADING_LANGUAGE_VERSION_ARB -# - Added Constant GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB -# - Added Constant GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB (SW) -# Version 1.4a Fixed a missing stdcall for glBindAttribLocationARB (SW) -# Version 1.4b Fixed declaration for glUniform*(f/i)vARB (added count) (MW) -# glCompileShaderARB changed from function to procedure (MW) -# Version 1.5 Added support for FreePascal (BR) -# Added type TGLVectorf3/TGLVector3f (SW) -# Version 1.6 Added Extension GL_EXT_framebuffer_object (SX) -# Version 1.7 Added Extension GL_ARB_fragment_program_shadow (SX) -# Added Extension GL_ARB_draw_buffers (SX) -# Added Extension GL_ARB_texture_rectangle (SX) -# Added Extension GL_ARB_color_buffer_float (SX) -# Added Extension GL_ARB_half_float_pixel (SX) -# Added Extension GL_ARB_texture_float (SX) -# Added Extension GL_ARB_pixel_buffer_object (SX) -# Added Extension GL_EXT_depth_bounds_test (SX) -# Added Extension GL_EXT_texture_mirror_clamp (SX) -# Added Extension GL_EXT_blend_equation_separate (SX) -# Added Extension GL_EXT_pixel_buffer_object (SX) -# Added Extension GL_EXT_texture_compression_dxt1 (SX) -# Added Extension GL_NV_fragment_program_option (SX) -# Added Extension GL_NV_fragment_program2 (SX) -# Added Extension GL_NV_vertex_program2_option (SX) -# Added Extension GL_NV_vertex_program3 (SX) -# Version 1.8 Added explicit delegate type definitions (LM) -# Added .Net 1.1 Support (LM) -# Added .Net overloaded functions (LM) -# Added delayed extension loading and stubs (LM) -# Added automatic InitOpenGL call in CreateRenderingContext(LM) -# Added extra Read* function (LM) -# Version 2.0 fixed some Problem with version string and damn drivers. -# String 1.15 identified as OpenGL 1.5 not as OpenGL 1.1 (SX) -# Removed unexisting extension GL_ARB_texture_mirror_repeat(SX) -# Added Extension WGL_ARB_pixel_format_float (SX) -# Added Extension GL_EXT_stencil_clear_tag (SX) -# Added Extension GL_EXT_texture_rectangle (SX) -# Added Extension GL_EXT_texture_edge_clamp (SX) -# Some 1.5 Core Consts added (now completed) (SX) -# gluProject need pointer for not .net (SX) -# gluUnProject need pointer for not .net (SX) -# wglUseFontOutlines* need pointer for not .net (SX) -# wglSwapMultipleBuffers need pointer for not .net (SX) -# Bug with wglGetExtensionsStringEXT removed -# different type for .net (SX) -# Added OpenGL 2.0 Core (SX) -# Version 2.0.1 fixed some problems with glGetActiveAttrib in 2.0 Core (SX) -# fixes some problems with gluProject (SX) -# fixes some problems with gluUnProject (SX) -# fixes some problems with gluTessVertex (SX) -# fixes some problems with gluLoadSamplingMatrices (SX) -# Version 2.1 Removed .NET Support (SX) -# Better support for Linux (SX) -# Better Codeformation (SX) -# Added some more Vector/Matrix types (SX) -# Added OpenGL 2.1 Core (SX) -# Added Extension GL_EXT_packed_depth_stencil (SX) -# Added Extension GL_EXT_texture_sRGB (SX) -# Added Extension GL_EXT_framebuffer_blit (SX) -# Added Extension GL_EXT_framebuffer_multisample (SX) -# Added Extension GL_EXT_timer_query (SX) -# Added Extension GL_EXT_gpu_program_parameters (SX) -# Added Extension GL_EXT_bindable_uniform (SX) -# Added Extension GL_EXT_draw_buffers2 (SX) -# Added Extension GL_EXT_draw_instanced (SX) -# Added Extension GL_EXT_framebuffer_sRGB (SX) -# Added Extension GL_EXT_geometry_shader4 (SX) -# Added Extension GL_EXT_gpu_shader4 (SX) -# Added Extension GL_EXT_packed_float (SX) -# Added Extension GL_EXT_texture_array (SX) -# Added Extension GL_EXT_texture_buffer_object (SX) -# Added Extension GL_EXT_texture_compression_latc (SX) -# Added Extension GL_EXT_texture_compression_rgtc (SX) -# Added Extension GL_EXT_texture_integer (SX) -# Added Extension GL_EXT_texture_shared_exponent (SX) -# Added Extension GL_NV_depth_buffer_float (SX) -# Added Extension GL_NV_fragment_program4 (SX) -# Added Extension GL_NV_framebuffer_multisample_coverage (SX) -# Added Extension GL_NV_geometry_program4 (SX) -# Added Extension GL_NV_gpu_program4 (SX) -# Added Extension GL_NV_parameter_buffer_object (SX) -# Added Extension GL_NV_transform_feedback (SX) -# Added Extension GL_NV_vertex_program4 (SX) -# Version 3.0 fixed some const of GL_EXT_texture_shared_exponent (SX) -# possible better support for mac (SX) -# Added OpenGL 3.0 Core (SX) -# Added Extension GL_ARB_depth_buffer_float (SX) -# Added Extension GL_ARB_draw_instanced (SX) -# Added Extension GL_ARB_framebuffer_object (SX) -# Added Extension GL_ARB_framebuffer_sRGB (SX) -# Added Extension GL_ARB_geometry_shader4 (SX) -# Added Extension GL_ARB_half_float_vertex (SX) -# Added Extension GL_ARB_instanced_arrays (SX) -# Added Extension GL_ARB_map_buffer_range (SX) -# Added Extension GL_ARB_texture_buffer_object (SX) -# Added Extension GL_ARB_texture_compression_rgtc (SX) -# Added Extension GL_ARB_texture_rg (SX) -# Added Extension GL_ARB_vertex_array_object (SX) -# Added Extension GL_NV_conditional_render (SX) -# Added Extension GL_NV_present_video (SX) -# Added Extension GL_EXT_transform_feedback (SX) -# Added Extension GL_EXT_direct_state_access (SX) -# Added Extension GL_EXT_vertex_array_bgra (SX) -# Added Extension GL_EXT_texture_swizzle (SX) -# Added Extension GL_NV_explicit_multisample (SX) -# Added Extension GL_NV_transform_feedback2 (SX) -# Added Extension WGL_ARB_create_context (SX) -# Added Extension WGL_NV_present_video (SX) -# Added Extension WGL_NV_video_out (SX) -# Added Extension WGL_NV_swap_group (SX) -# Added Extension WGL_NV_gpu_affinity (SX) -# Added define DGL_TINY_HEADER to suppress automatic -# function loading (SX) -# glProcedure renamed to dglGetProcAddress and now it's -# visible from outside the unit to custom load functions (SX) -# dglCheckExtension added to check if an extension exists (SX) -# Read_GL_ARB_buffer_object renamed to -# Read_GL_ARB_vertex_buffer_object (SX) -# Version 3.0.1 fixed an problem with fpc (SX) -# Version 3.0.2 fixed an problem with WGL_ARB_create_context (SX) -# Version 3.2 Functions from GL_VERSION_3_0 where updated (SX) -# Functions from GL_ARB_map_buffer_range where updated (SX) -# Functions from GL_NV_present_video where added (SX) -# Added consts of GL_ARB_instanced_arrays (SX) -# Defines to identify Delphi was changed (prevent for -# feature maintenance) (SX) -# Added Extension GL_ATI_meminfo (SX) -# Added Extension GL_AMD_performance_monitor (SX) -# Added Extension GL_AMD_texture_texture4 (SX) -# Added Extension GL_AMD_vertex_shader_tesselator (SX) -# Added Extension GL_EXT_provoking_vertex (SX) -# Added Extension WGL_AMD_gpu_association (SX) -# Added OpenGL 3.1 Core (SX) -# All deprecated stuff can be disabled if you undef the -# define DGL_DEPRECATED (SX) -# Added Extension GL_ARB_uniform_buffer_object (SX) -# Added Extension GL_ARB_compatibility (SX) -# Added Extension GL_ARB_copy_buffer (SX) -# Added Extension GL_ARB_shader_texture_lod (SX) -# Remove function from GL_NV_present_video (SX) -# Added Extension WGL_3DL_stereo_control (SX) -# Added Extension GL_EXT_texture_snorm (SX) -# Added Extension GL_AMD_draw_buffers_blend (SX) -# Added Extension GL_APPLE_texture_range (SX) -# Added Extension GL_APPLE_float_pixels (SX) -# Added Extension GL_APPLE_vertex_program_evaluators (SX) -# Added Extension GL_APPLE_aux_depth_stencil (SX) -# Added Extension GL_APPLE_object_purgeable (SX) -# Added Extension GL_APPLE_row_bytes (SX) -# Added OpenGL 3.2 Core (SX) -# Added Extension GL_ARB_depth_clamp (SX) -# Added Extension GL_ARB_draw_elements_base_vertex (SX) -# Added Extension GL_ARB_fragment_coord_conventions (SX) -# Added Extension GL_ARB_provoking_vertex (SX) -# Added Extension GL_ARB_seamless_cube_map (SX) -# Added Extension GL_ARB_sync (SX) -# Added Extension GL_ARB_texture_multisample (SX) -# Added Extension GL_ARB_vertex_array_bgra (SX) -# Added Extension GL_ARB_draw_buffers_blend (SX) -# Added Extension GL_ARB_sample_shading (SX) -# Added Extension GL_ARB_texture_cube_map_array (SX) -# Added Extension GL_ARB_texture_gather (SX) -# Added Extension GL_ARB_texture_query_lod (SX) -# Added Extension WGL_ARB_create_context_profile (SX) -# Added GLX Core up to Version 1.4 (SX) -# Added Extension GLX_ARB_multisample (SX) -# Added Extension GLX_ARB_fbconfig_float (SX) -# Added Extension GLX_ARB_get_proc_address (SX) -# Added Extension GLX_ARB_create_context (SX) -# Added Extension GLX_ARB_create_context_profile (SX) -# Added Extension GLX_EXT_visual_info (SX) -# Added Extension GLX_EXT_visual_rating (SX) -# Added Extension GLX_EXT_import_context (SX) -# Added Extension GLX_EXT_fbconfig_packed_float (SX) -# Added Extension GLX_EXT_framebuffer_sRGB (SX) -# Added Extension GLX_EXT_texture_from_pixmap (SX) -# Version 3.2.1 Fixed some problems with Delphi < 6 (SX) -# Version 3.2.2 Added Extension GL_APPLE_rgb_422 (SX) -# Added Extension GL_EXT_separate_shader_objects (SX) -# Added Extension GL_NV_video_capture (SX) -# Added Extension GL_NV_copy_image (SX) -# Added Extension GL_NV_parameter_buffer_object2 (SX) -# Added Extension GL_NV_shader_buffer_load (SX) -# Added Extension GL_NV_vertex_buffer_unified_memory (SX) -# Added Extension GL_NV_texture_barrier (SX) -# Variable GL_EXT_texture_snorm will be filled (SX) -# Variable GL_APPLE_row_bytes will be filled (SX) -# Added Extension WGL_NV_video_capture (SX) -# Added Extension WGL_NV_copy_image (SX) -# WGL_NV_video_out now named WGL_NV_video_output (SX) -# Added Extension GLX_EXT_swap_control (SX) -# Version 3.2.3 Fixed an Problem with glGetAttribLocation (SX) -# Added const GL_UNIFORM_BUFFER_EXT (SX) -# Functions of GL_NV_texture_barrier now will be loaded (SX) -# Version 4.0 Changes on Extension GL_ARB_texture_gather (SX) -# Changes on Extension GL_NV_shader_buffer_load (SX) -# Added OpenGL 3.3 Core (SX) -# Added OpenGL 4.0 Core (SX) -# Added Extension GL_AMD_shader_stencil_export (SX) -# Added Extension GL_AMD_seamless_cubemap_per_texture (SX) -# Added Extension GL_ARB_shading_language_include (SX) -# Added Extension GL_ARB_texture_compression_bptc (SX) -# Added Extension GL_ARB_blend_func_extended (SX) -# Added Extension GL_ARB_explicit_attrib_location (SX) -# Added Extension GL_ARB_occlusion_query2 (SX) -# Added Extension GL_ARB_sampler_objects (SX) -# Added Extension GL_ARB_shader_bit_encoding (SX) -# Added Extension GL_ARB_texture_rgb10_a2ui (SX) -# Added Extension GL_ARB_texture_swizzle (SX) -# Added Extension GL_ARB_timer_query (SX) -# Added Extension GL_ARB_vertextyp_2_10_10_10_rev (SX) -# Added Extension GL_ARB_draw_indirect (SX) -# Added Extension GL_ARB_gpu_shader5 (SX) -# Added Extension GL_ARB_gpu_shader_fp64 (SX) -# Added Extension GL_ARB_shader_subroutine (SX) -# Added Extension GL_ARB_tessellation_shader (SX) -# Added Extension GL_ARB_texture_buffer_object_rgb32 (SX) -# Added Extension GL_ARB_transform_feedback2 (SX) -# Added Extension GL_ARB_transform_feedback3 (SX) -# Version 4.1 Possible fix some strange linux behavior (SX) -# All function uses GL instead of TGL types (SX) -# GL_AMD_vertex_shader_tesselator will be read now (SX) -# GL_AMD_draw_buffers_blend will be read now (SX) -# Changes on glStencilFuncSeparate (GL_2_0) (SX) -# Changes on GL_VERSION_3_2 (SX) -# Changes on GL_VERSION_3_3 (SX) -# Changes on GL_VERSION_4_0 (SX) -# Changes on GL_ARB_sample_shading (SX) -# Changes on GL_ARB_texture_cube_map_array (SX) -# Changes on GL_ARB_gpu_shader5 (SX) -# Changes on GL_ARB_transform_feedback3 (SX) -# Changes on GL_ARB_sampler_objects (SX) -# Changes on GL_ARB_gpu_shader_fp64 (SX) -# Changes on GL_APPLE_element_array (SX) -# Changes on GL_APPLE_vertex_array_range (SX) -# Changes on GL_NV_transform_feedback (SX) -# Changes on GL_NV_vertex_buffer_unified_memory (SX) -# Changes on GL_EXT_multi_draw_arrays (SX) -# Changes on GL_EXT_direct_state_access (SX) -# Changes on GL_AMD_performance_monitor (SX) -# Changes on GL_AMD_seamless_cubemap_per_texture (SX) -# Changes on GL_EXT_geometry_shader4 (SX) -# Added OpenGL 4.1 Core (SX) -# Added Extension GL_ARB_ES2_compatibility (SX) -# Added Extension GL_ARB_get_program_binary (SX) -# Added Extension GL_ARB_separate_shader_objects (SX) -# Added Extension GL_ARB_shader_precision (SX) -# Added Extension GL_ARB_vertex_attrib_64bit (SX) -# Added Extension GL_ARB_viewport_array (SX) -# Added Extension GL_ARB_cl_event (SX) -# Added Extension GL_ARB_debug_output (SX) -# Added Extension GL_ARB_robustness (SX) -# Added Extension GL_ARB_shader_stencil_export (SX) -# Added Extension GL_AMD_conservative_depth (SX) -# Added Extension GL_EXT_shader_image_load_store (SX) -# Added Extension GL_EXT_vertex_attrib_64bit (SX) -# Added Extension GL_NV_gpu_program5 (SX) -# Added Extension GL_NV_gpu_shader5 (SX) -# Added Extension GL_NV_shader_buffer_store (SX) -# Added Extension GL_NV_tessellation_program5 (SX) -# Added Extension GL_NV_vertex_attrib_integer_64bit (SX) -# Added Extension GL_NV_multisample_coverage (SX) -# Added Extension GL_AMD_name_gen_delete (SX) -# Added Extension GL_AMD_debug_output (SX) -# Added Extension GL_NV_vdpau_interop (SX) -# Added Extension GL_AMD_transform_feedback3_lines_triangles (SX) -# Added Extension GL_AMD_depth_clamp_separate (SX) -# Added Extension GL_EXT_texture_sRGB_decode (SX) -# Added Extension WGL_ARB_framebuffer_sRGB (SX) -# Added Extension WGL_ARB_create_context_robustness (SX) -# Added Extension WGL_EXT_create_context_es2_profile (SX) -# Added Extension WGL_NV_multisample_coverage (SX) -# Added Extension GLX_ARB_vertex_buffer_object (SX) -# Added Extension GLX_ARB_framebuffer_sRGB (SX) -# Added Extension GLX_ARB_create_context_robustness (SX) -# Added Extension GLX_EXT_create_context_es2_profile (SX) -# Version 4.1a Fix for dglGetProcAddress with FPC and linux (def param) (SW) -# Version 4.2 Added OpenGL 4.2 Core (SW) -# Added Extension GL_ARB_base_instance (SW) -# Added Extension GL_ARB_shading_language_420pack (SW) -# Added Extension GL_ARB_transform_feedback_instanced (SW) -# Added Extension GL_ARB_compressed_texture_pixel_storage (SW) -# Added Extension GL_ARB_conservative_depth (SW) -# Added Extension GL_ARB_internalformat_query (SW) -# Added Extension GL_ARB_map_buffer_alignment (SW) -# Added Extension GL_ARB_shader_atomic_counters (SW) -# Added Extension GL_ARB_shader_image_load_store (SW) -# Added Extension GL_ARB_shading_language_packing (SW) -# Added Extension GL_ARB_texture_storage (SW) -# Added Extension WGL_NV_DX_interop (SW) -# Added Define for WGL_EXT_create_context_es2_profile (SW) -# Version 4.2a Added Mac OS X patch by Andrey Gruzdev (SW) -#============================================================================== -# Header based on glext.h rev 72 (2011/08/08) -# Header based on wglext.h rev 23 (2011/04/13) -# Header based on glxext.h rev 32 (2010/08/06) (only Core/ARB/EXT) -# -# This is an important notice for maintaining. Dont remove it. And make sure -# to keep it up to date -#============================================================================== - -{.deadCodeElim: on.} - -type - PPointer* = ptr Pointer - GLenum* = uint32 - GLboolean* = bool - GLbitfield* = uint32 - GLbyte* = int8 - GLshort* = int16 - GLint* = int32 - GLsizei* = int32 - GLubyte* = uint8 - GLushort* = uint16 - GLuint* = uint32 - GLfloat* = float32 - GLclampf* = float32 - GLdouble* = float64 - GLclampd* = float64 - GLvoid* = Pointer - GLint64* = Int64 - GLuint64* = uint64 - TGLenum* = GLenum - TGLboolean* = GLboolean - TGLbitfield* = GLbitfield - TGLbyte* = GLbyte - TGLshort* = GLshort - TGLint* = GLint - TGLsizei* = GLsizei - TGLubyte* = GLubyte - TGLushort* = GLushort - TGLuint* = GLuint - TGLfloat* = GLfloat - TGLclampf* = GLclampf - TGLdouble* = GLdouble - TGLclampd* = GLclampd - TGLvoid* = GLvoid - TGLint64* = GLint64 - TGLuint64* = GLuint64 - PGLboolean* = ptr GLboolean - PGLbyte* = ptr GLbyte - PGLshort* = ptr GLshort - PGLint* = ptr GLint - PGLsizei* = ptr GLsizei - PGLubyte* = ptr GLubyte - PGLushort* = ptr GLushort - PGLuint* = ptr GLuint - PGLclampf* = ptr GLclampf - PGLfloat* = ptr GLfloat - PGLdouble* = ptr GLdouble - PGLclampd* = ptr GLclampd - PGLenum* = ptr GLenum - PGLvoid* = Pointer - PPGLvoid* = ptr PGLvoid - PGLint64* = ptr GLint64 - PGLuint64* = ptr GLuint64 # GL_NV_half_float - GLhalfNV* = int16 - TGLhalfNV* = GLhalfNV - PGLhalfNV* = ptr GLhalfNV # GL_ARB_shader_objects - PGLHandleARB* = ptr GLHandleARB - GLHandleARB* = int - GLcharARB* = Char - PGLcharARB* = cstring - PPGLcharARB* = ptr PGLcharARB # GL_VERSION_1_5 - GLintptr* = GLint - GLsizeiptr* = GLsizei # GL_ARB_vertex_buffer_object - GLintptrARB* = GLint - GLsizeiptrARB* = GLsizei # GL_VERSION_2_0 - GLHandle* = GLuint - PGLchar* = cstring - PPGLchar* = ptr PGLChar # GL_EXT_timer_query - GLint64EXT* = Int64 - TGLint64EXT* = GLint64EXT - PGLint64EXT* = ptr GLint64EXT - GLuint64EXT* = GLuint64 - TGLuint64EXT* = GLuint64EXT - PGLuint64EXT* = ptr GLuint64EXT # WGL_ARB_pbuffer - - GLsync* = Pointer # GL_ARB_cl_event - # These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event - Tcl_context*{.final.} = object - Tcl_event*{.final.} = object - p_cl_context* = ptr Tcl_context - p_cl_event* = ptr Tcl_event # GL_ARB_debug_output - TglDebugProcARB* = proc (source: GLenum, typ: GLenum, id: GLuint, - severity: GLenum, len: GLsizei, message: PGLchar, - userParam: PGLvoid){.stdcall.} # GL_AMD_debug_output - TglDebugProcAMD* = proc (id: GLuint, category: GLenum, severity: GLenum, - len: GLsizei, message: PGLchar, userParam: PGLvoid){. - stdcall.} # GL_NV_vdpau_interop - GLvdpauSurfaceNV* = GLintptr - PGLvdpauSurfaceNV* = ptr GLvdpauSurfaceNV # GLX - -when defined(windows): - type - HPBUFFERARB* = THandle # WGL_EXT_pbuffer - HPBUFFEREXT* = THandle # WGL_NV_present_video - PHVIDEOOUTPUTDEVICENV* = ptr HVIDEOOUTPUTDEVICENV - HVIDEOOUTPUTDEVICENV* = THandle # WGL_NV_video_output - PHPVIDEODEV* = ptr HPVIDEODEV - HPVIDEODEV* = THandle # WGL_NV_gpu_affinity - PHPGPUNV* = ptr HPGPUNV - PHGPUNV* = ptr HGPUNV # WGL_NV_video_capture - HVIDEOINPUTDEVICENV* = THandle - PHVIDEOINPUTDEVICENV* = ptr HVIDEOINPUTDEVICENV - HPGPUNV* = THandle - HGPUNV* = THandle # GL_ARB_sync - -when defined(LINUX): - type - GLXContext* = Pointer - GLXContextID* = TXID - GLXDrawable* = TXID - GLXFBConfig* = Pointer - GLXPbuffer* = TXID - GLXPixmap* = TXID - GLXWindow* = TXID - Window* = TXID - Colormap* = TXID - Pixmap* = TXID - Font* = TXID -type # Datatypes corresponding to GL's types TGL(name)(type)(count) - TGLVectorub2* = array[0..1, GLubyte] - TGLVectori2* = array[0..1, GLint] - TGLVectorf2* = array[0..1, GLfloat] - TGLVectord2* = array[0..1, GLdouble] - TGLVectorp2* = array[0..1, Pointer] - TGLVectorb3* = array[0..2, GLbyte] - TGLVectorub3* = array[0..2, GLubyte] - TGLVectori3* = array[0..2, GLint] - TGLVectorui3* = array[0..2, GLuint] - TGLVectorf3* = array[0..2, GLfloat] - TGLVectord3* = array[0..2, GLdouble] - TGLVectorp3* = array[0..2, Pointer] - TGLVectors3* = array[0..2, GLshort] - TGLVectorus3* = array[0..2, GLushort] - TGLVectorb4* = array[0..3, GLbyte] - TGLVectorub4* = array[0..3, GLubyte] - TGLVectori4* = array[0..3, GLint] - TGLVectorui4* = array[0..3, GLuint] - TGLVectorf4* = array[0..3, GLfloat] - TGLVectord4* = array[0..3, GLdouble] - TGLVectorp4* = array[0..3, Pointer] - TGLVectors4* = array[0..3, GLshort] - TGLVectorus4* = array[0..3, GLshort] - TGLArrayf4* = TGLVectorf4 - TGLArrayf3* = TGLVectorf3 - TGLArrayd3* = TGLVectord3 - TGLArrayi4* = TGLVectori4 - TGLArrayp4* = TGLVectorp4 - TGlMatrixub3* = array[0..2, array[0..2, GLubyte]] - TGlMatrixi3* = array[0..2, array[0..2, GLint]] - TGLMatrixf3* = array[0..2, array[0..2, GLfloat]] - TGLMatrixd3* = array[0..2, array[0..2, GLdouble]] - TGlMatrixub4* = array[0..3, array[0..3, GLubyte]] - TGlMatrixi4* = array[0..3, array[0..3, GLint]] - TGLMatrixf4* = array[0..3, array[0..3, GLfloat]] - TGLMatrixd4* = array[0..3, array[0..3, GLdouble]] - TGLVector3f* = TGLVectorf3 # Datatypes corresponding to OpenGL12.pas for easy porting - TVector3d* = TGLVectord3 - TVector4i* = TGLVectori4 - TVector4f* = TGLVectorf4 - TVector4p* = TGLVectorp4 - TMatrix4f* = TGLMatrixf4 - TMatrix4d* = TGLMatrixd4 - PGLMatrixd4* = ptr TGLMatrixd4 - PVector4i* = ptr TVector4i - TRect*{.final.} = object - Left*, Top*, Right*, Bottom*: int32 - - PGPU_DEVICE* = ptr GPU_DEVICE - GPU_DEVICE*{.final.} = object - cb*: int32 - DeviceName*: array[0..31, Char] - DeviceString*: array[0..127, Char] - Flags*: int32 - rcVirtualScreen*: TRect - - -when defined(windows): - type - PWGLSwap* = ptr TWGLSwap - TWGLSWAP*{.final.} = object - hdc*: HDC - uiFlags*: int32 - -type - TGLUNurbs*{.final.} = object - TGLUQuadric*{.final.} = object - TGLUTesselator*{.final.} = object - PGLUNurbs* = ptr TGLUNurbs - PGLUQuadric* = ptr TGLUQuadric - PGLUTesselator* = ptr TGLUTesselator # backwards compatibility - TGLUNurbsObj* = TGLUNurbs - TGLUQuadricObj* = TGLUQuadric - TGLUTesselatorObj* = TGLUTesselator - TGLUTriangulatorObj* = TGLUTesselator - PGLUNurbsObj* = PGLUNurbs - PGLUQuadricObj* = PGLUQuadric - PGLUTesselatorObj* = PGLUTesselator - PGLUTriangulatorObj* = PGLUTesselator # GLUQuadricCallback - - TGLUQuadricErrorProc* = proc(errorCode: GLenum){.stdcall.} - TGLUTessBeginProc* = proc(AType: GLenum){.stdcall.} - TGLUTessEdgeFlagProc* = proc(Flag: GLboolean){.stdcall.} - TGLUTessVertexProc* = proc(VertexData: Pointer){.stdcall.} - TGLUTessEndProc* = proc(){.stdcall.} - TGLUTessErrorProc* = proc(ErrNo: GLenum){.stdcall.} - TGLUTessCombineProc* = proc(Coords: TGLArrayd3, VertexData: TGLArrayp4, - Weight: TGLArrayf4, OutData: PPointer){.stdcall.} - TGLUTessBeginDataProc* = proc(AType: GLenum, UserData: Pointer){.stdcall.} - TGLUTessEdgeFlagDataProc* = proc(Flag: GLboolean, UserData: Pointer){.stdcall.} - TGLUTessVertexDataProc* = proc(VertexData: Pointer, UserData: Pointer){.stdcall.} - TGLUTessEndDataProc* = proc(UserData: Pointer){.stdcall.} - TGLUTessErrorDataProc* = proc(ErrNo: GLenum, UserData: Pointer){.stdcall.} - TGLUTessCombineDataProc* = proc(Coords: TGLArrayd3, VertexData: TGLArrayp4, - Weight: TGLArrayf4, OutData: PPointer, - UserData: Pointer){.stdcall.} - # GLUNurbsCallback - TGLUNurbsErrorProc* = proc(ErrorCode: GLEnum){.stdcall.} - -const # GL_VERSION_1_1 - # AttribMask - GL_DEPTH_BUFFER_BIT* = 0x00000100 - GL_STENCIL_BUFFER_BIT* = 0x00000400 - GL_COLOR_BUFFER_BIT* = 0x00004000 # Boolean - GL_TRUE* = 1 - GL_FALSE* = 0 # BeginMode - GL_POINTS* = 0x00000000 - GL_LINES* = 0x00000001 - GL_LINE_LOOP* = 0x00000002 - GL_LINE_STRIP* = 0x00000003 - GL_TRIANGLES* = 0x00000004 - GL_TRIANGLE_STRIP* = 0x00000005 - GL_TRIANGLE_FAN* = 0x00000006 # AlphaFunction - GL_NEVER* = 0x00000200 - GL_LESS* = 0x00000201 - GL_EQUAL* = 0x00000202 - GL_LEQUAL* = 0x00000203 - GL_GREATER* = 0x00000204 - GL_NOTEQUAL* = 0x00000205 - GL_GEQUAL* = 0x00000206 - GL_ALWAYS* = 0x00000207 # BlendingFactorDest - GL_ZERO* = 0 - GL_ONE* = 1 - GL_SRC_COLOR* = 0x00000300 - GL_ONE_MINUS_SRC_COLOR* = 0x00000301 - GL_SRC_ALPHA* = 0x00000302 - GL_ONE_MINUS_SRC_ALPHA* = 0x00000303 - GL_DST_ALPHA* = 0x00000304 - GL_ONE_MINUS_DST_ALPHA* = 0x00000305 # BlendingFactorSrc - GL_DST_COLOR* = 0x00000306 - GL_ONE_MINUS_DST_COLOR* = 0x00000307 - GL_SRC_ALPHA_SATURATE* = 0x00000308 # DrawBufferMode - GL_NONE* = 0 - GL_FRONT_LEFT* = 0x00000400 - GL_FRONT_RIGHT* = 0x00000401 - GL_BACK_LEFT* = 0x00000402 - GL_BACK_RIGHT* = 0x00000403 - GL_FRONT* = 0x00000404 - GL_BACK* = 0x00000405 - GL_LEFT* = 0x00000406 - GL_RIGHT* = 0x00000407 - GL_FRONT_AND_BACK* = 0x00000408 # ErrorCode - GL_NO_ERROR* = 0 - GL_INVALID_ENUM* = 0x00000500 - GL_INVALID_VALUE* = 0x00000501 - GL_INVALID_OPERATION* = 0x00000502 - GL_OUT_OF_MEMORY* = 0x00000505 # FrontFaceDirection - GL_CW* = 0x00000900 - GL_CCW* = 0x00000901 # GetPName - cGL_POINT_SIZE* = 0x00000B11 - GL_POINT_SIZE_RANGE* = 0x00000B12 - GL_POINT_SIZE_GRANULARITY* = 0x00000B13 - GL_LINE_SMOOTH* = 0x00000B20 - cGL_LINE_WIDTH* = 0x00000B21 - GL_LINE_WIDTH_RANGE* = 0x00000B22 - GL_LINE_WIDTH_GRANULARITY* = 0x00000B23 - GL_POLYGON_SMOOTH* = 0x00000B41 - cGL_CULL_FACE* = 0x00000B44 - GL_CULL_FACE_MODE* = 0x00000B45 - cGL_FRONT_FACE* = 0x00000B46 - cGL_DEPTH_RANGE* = 0x00000B70 - GL_DEPTH_TEST* = 0x00000B71 - GL_DEPTH_WRITEMASK* = 0x00000B72 - GL_DEPTH_CLEAR_VALUE* = 0x00000B73 - cGL_DEPTH_FUNC* = 0x00000B74 - GL_STENCIL_TEST* = 0x00000B90 - GL_STENCIL_CLEAR_VALUE* = 0x00000B91 - cGL_STENCIL_FUNC* = 0x00000B92 - GL_STENCIL_VALUE_MASK* = 0x00000B93 - GL_STENCIL_FAIL* = 0x00000B94 - GL_STENCIL_PASS_DEPTH_FAIL* = 0x00000B95 - GL_STENCIL_PASS_DEPTH_PASS* = 0x00000B96 - GL_STENCIL_REF* = 0x00000B97 - GL_STENCIL_WRITEMASK* = 0x00000B98 - cGL_VIEWPORT* = 0x00000BA2 - GL_DITHER* = 0x00000BD0 - GL_BLEND_DST* = 0x00000BE0 - GL_BLEND_SRC* = 0x00000BE1 - GL_BLEND* = 0x00000BE2 - GL_LOGIC_OP_MODE* = 0x00000BF0 - GL_COLOR_LOGIC_OP* = 0x00000BF2 - cGL_DRAW_BUFFER* = 0x00000C01 - cGL_READ_BUFFER* = 0x00000C02 - GL_SCISSOR_BOX* = 0x00000C10 - GL_SCISSOR_TEST* = 0x00000C11 - GL_COLOR_CLEAR_VALUE* = 0x00000C22 - GL_COLOR_WRITEMASK* = 0x00000C23 - GL_DOUBLEBUFFER* = 0x00000C32 - GL_STEREO* = 0x00000C33 - GL_LINE_SMOOTH_HINT* = 0x00000C52 - GL_POLYGON_SMOOTH_HINT* = 0x00000C53 - GL_UNPACK_SWAP_BYTES* = 0x00000CF0 - GL_UNPACK_LSB_FIRST* = 0x00000CF1 - GL_UNPACK_ROW_LENGTH* = 0x00000CF2 - GL_UNPACK_SKIP_ROWS* = 0x00000CF3 - GL_UNPACK_SKIP_PIXELS* = 0x00000CF4 - GL_UNPACK_ALIGNMENT* = 0x00000CF5 - GL_PACK_SWAP_BYTES* = 0x00000D00 - GL_PACK_LSB_FIRST* = 0x00000D01 - GL_PACK_ROW_LENGTH* = 0x00000D02 - GL_PACK_SKIP_ROWS* = 0x00000D03 - GL_PACK_SKIP_PIXELS* = 0x00000D04 - GL_PACK_ALIGNMENT* = 0x00000D05 - GL_MAX_TEXTURE_SIZE* = 0x00000D33 - GL_MAX_VIEWPORT_DIMS* = 0x00000D3A - GL_SUBPIXEL_BITS* = 0x00000D50 - GL_TEXTURE_1D* = 0x00000DE0 - GL_TEXTURE_2D* = 0x00000DE1 - GL_POLYGON_OFFSET_UNITS* = 0x00002A00 - GL_POLYGON_OFFSET_POINT* = 0x00002A01 - GL_POLYGON_OFFSET_LINE* = 0x00002A02 - GL_POLYGON_OFFSET_FILL* = 0x00008037 - GL_POLYGON_OFFSET_FACTOR* = 0x00008038 - GL_TEXTURE_BINDING_1D* = 0x00008068 - GL_TEXTURE_BINDING_2D* = 0x00008069 # GetTextureParameter - GL_TEXTURE_WIDTH* = 0x00001000 - GL_TEXTURE_HEIGHT* = 0x00001001 - GL_TEXTURE_INTERNAL_FORMAT* = 0x00001003 - GL_TEXTURE_BORDER_COLOR* = 0x00001004 - GL_TEXTURE_BORDER* = 0x00001005 - GL_TEXTURE_RED_SIZE* = 0x0000805C - GL_TEXTURE_GREEN_SIZE* = 0x0000805D - GL_TEXTURE_BLUE_SIZE* = 0x0000805E - GL_TEXTURE_ALPHA_SIZE* = 0x0000805F # HintMode - GL_DONT_CARE* = 0x00001100 - GL_FASTEST* = 0x00001101 - GL_NICEST* = 0x00001102 # DataType - cGL_BYTE* = 0x00001400 - cGL_UNSIGNED_BYTE* = 0x00001401 - cGL_SHORT* = 0x00001402 - cGL_UNSIGNED_SHORT* = 0x00001403 - cGL_INT* = 0x00001404 - cGL_UNSIGNED_INT* = 0x00001405 - cGL_FLOAT* = 0x00001406 - cGL_DOUBLE* = 0x0000140A # LogicOp - cGL_CLEAR* = 0x00001500 - GL_AND* = 0x00001501 - GL_AND_REVERSE* = 0x00001502 - GL_COPY* = 0x00001503 - GL_AND_INVERTED* = 0x00001504 - GL_NOOP* = 0x00001505 - GL_XOR* = 0x00001506 - GL_OR* = 0x00001507 - GL_NOR* = 0x00001508 - GL_EQUIV* = 0x00001509 - GL_INVERT* = 0x0000150A - GL_OR_REVERSE* = 0x0000150B - GL_COPY_INVERTED* = 0x0000150C - GL_OR_INVERTED* = 0x0000150D - GL_NAND* = 0x0000150E - GL_SET* = 0x0000150F # MatrixMode (for gl3.h, FBO attachment type) - GL_TEXTURE* = 0x00001702 # PixelCopyType - GL_COLOR* = 0x00001800 - GL_DEPTH* = 0x00001801 - GL_STENCIL* = 0x00001802 # PixelFormat - GL_STENCIL_INDEX* = 0x00001901 - GL_DEPTH_COMPONENT* = 0x00001902 - GL_RED* = 0x00001903 - GL_GREEN* = 0x00001904 - GL_BLUE* = 0x00001905 - GL_ALPHA* = 0x00001906 - GL_RGB* = 0x00001907 - GL_RGBA* = 0x00001908 # PolygonMode - GL_POINT* = 0x00001B00 - GL_LINE* = 0x00001B01 - GL_FILL* = 0x00001B02 # StencilOp - GL_KEEP* = 0x00001E00 - GL_REPLACE* = 0x00001E01 - GL_INCR* = 0x00001E02 - GL_DECR* = 0x00001E03 # StringName - GL_VENDOR* = 0x00001F00 - GL_RENDERER* = 0x00001F01 - GL_VERSION* = 0x00001F02 - GL_EXTENSIONS* = 0x00001F03 # TextureMagFilter - GL_NEAREST* = 0x00002600 - GL_LINEAR* = 0x00002601 # TextureMinFilter - GL_NEAREST_MIPMAP_NEAREST* = 0x00002700 - GL_LINEAR_MIPMAP_NEAREST* = 0x00002701 - GL_NEAREST_MIPMAP_LINEAR* = 0x00002702 - GL_LINEAR_MIPMAP_LINEAR* = 0x00002703 # TextureParameterName - GL_TEXTURE_MAG_FILTER* = 0x00002800 - GL_TEXTURE_MIN_FILTER* = 0x00002801 - GL_TEXTURE_WRAP_S* = 0x00002802 - GL_TEXTURE_WRAP_T* = 0x00002803 # TextureTarget - GL_PROXY_TEXTURE_1D* = 0x00008063 - GL_PROXY_TEXTURE_2D* = 0x00008064 # TextureWrapMode - GL_REPEAT* = 0x00002901 # PixelInternalFormat - GL_R3_G3_B2* = 0x00002A10 - GL_RGB4* = 0x0000804F - GL_RGB5* = 0x00008050 - GL_RGB8* = 0x00008051 - GL_RGB10* = 0x00008052 - GL_RGB12* = 0x00008053 - GL_RGB16* = 0x00008054 - GL_RGBA2* = 0x00008055 - GL_RGBA4* = 0x00008056 - GL_RGB5_A1* = 0x00008057 - GL_RGBA8* = 0x00008058 - GL_RGB10_A2* = 0x00008059 - GL_RGBA12* = 0x0000805A - GL_RGBA16* = 0x0000805B - cGL_ACCUM* = 0x00000100 - GL_LOAD* = 0x00000101 - GL_RETURN* = 0x00000102 - GL_MULT* = 0x00000103 - GL_ADD* = 0x00000104 - GL_CURRENT_BIT* = 0x00000001 - GL_POINT_BIT* = 0x00000002 - GL_LINE_BIT* = 0x00000004 - GL_POLYGON_BIT* = 0x00000008 - GL_POLYGON_STIPPLE_BIT* = 0x00000010 - GL_PIXEL_MODE_BIT* = 0x00000020 - GL_LIGHTING_BIT* = 0x00000040 - GL_FOG_BIT* = 0x00000080 - GL_ACCUM_BUFFER_BIT* = 0x00000200 - GL_VIEWPORT_BIT* = 0x00000800 - GL_TRANSFORM_BIT* = 0x00001000 - GL_ENABLE_BIT* = 0x00002000 - GL_HINT_BIT* = 0x00008000 - GL_EVAL_BIT* = 0x00010000 - GL_LIST_BIT* = 0x00020000 - GL_TEXTURE_BIT* = 0x00040000 - GL_SCISSOR_BIT* = 0x00080000 - GL_ALL_ATTRIB_BITS* = 0x000FFFFF - GL_QUADS* = 0x00000007 - GL_QUAD_STRIP* = 0x00000008 - GL_POLYGON* = 0x00000009 - GL_CLIP_PLANE0* = 0x00003000 - GL_CLIP_PLANE1* = 0x00003001 - GL_CLIP_PLANE2* = 0x00003002 - GL_CLIP_PLANE3* = 0x00003003 - GL_CLIP_PLANE4* = 0x00003004 - GL_CLIP_PLANE5* = 0x00003005 - GL_2_BYTES* = 0x00001407 - GL_3_BYTES* = 0x00001408 - GL_4_BYTES* = 0x00001409 - GL_AUX0* = 0x00000409 - GL_AUX1* = 0x0000040A - GL_AUX2* = 0x0000040B - GL_AUX3* = 0x0000040C - GL_STACK_OVERFLOW* = 0x00000503 - GL_STACK_UNDERFLOW* = 0x00000504 - GL_2D* = 0x00000600 - GL_3D* = 0x00000601 - GL_3D_COLOR* = 0x00000602 - GL_3D_COLOR_TEXTURE* = 0x00000603 - GL_4D_COLOR_TEXTURE* = 0x00000604 - GL_PASS_THROUGH_TOKEN* = 0x00000700 - GL_POINT_TOKEN* = 0x00000701 - GL_LINE_TOKEN* = 0x00000702 - GL_POLYGON_TOKEN* = 0x00000703 - GL_BITMAP_TOKEN* = 0x00000704 - GL_DRAW_PIXEL_TOKEN* = 0x00000705 - GL_COPY_PIXEL_TOKEN* = 0x00000706 - GL_LINE_RESET_TOKEN* = 0x00000707 - GL_EXP* = 0x00000800 - GL_EXP2* = 0x00000801 - GL_COEFF* = 0x00000A00 - GL_ORDER* = 0x00000A01 - GL_DOMAIN* = 0x00000A02 - GL_CURRENT_COLOR* = 0x00000B00 - GL_CURRENT_INDEX* = 0x00000B01 - GL_CURRENT_NORMAL* = 0x00000B02 - GL_CURRENT_TEXTURE_COORDS* = 0x00000B03 - GL_CURRENT_RASTER_COLOR* = 0x00000B04 - GL_CURRENT_RASTER_INDEX* = 0x00000B05 - GL_CURRENT_RASTER_TEXTURE_COORDS* = 0x00000B06 - GL_CURRENT_RASTER_POSITION* = 0x00000B07 - GL_CURRENT_RASTER_POSITION_VALID* = 0x00000B08 - GL_CURRENT_RASTER_DISTANCE* = 0x00000B09 - GL_POINT_SMOOTH* = 0x00000B10 - cGL_LINE_STIPPLE* = 0x00000B24 - GL_LINE_STIPPLE_PATTERN* = 0x00000B25 - GL_LINE_STIPPLE_REPEAT* = 0x00000B26 - GL_LIST_MODE* = 0x00000B30 - GL_MAX_LIST_NESTING* = 0x00000B31 - cGL_LIST_BASE* = 0x00000B32 - GL_LIST_INDEX* = 0x00000B33 - cGL_POLYGON_MODE* = 0x00000B40 - cGL_POLYGON_STIPPLE* = 0x00000B42 - cGL_EDGE_FLAG* = 0x00000B43 - GL_LIGHTING* = 0x00000B50 - GL_LIGHT_MODEL_LOCAL_VIEWER* = 0x00000B51 - GL_LIGHT_MODEL_TWO_SIDE* = 0x00000B52 - GL_LIGHT_MODEL_AMBIENT* = 0x00000B53 - cGL_SHADE_MODEL* = 0x00000B54 - GL_COLOR_MATERIAL_FACE* = 0x00000B55 - GL_COLOR_MATERIAL_PARAMETER* = 0x00000B56 - cGL_COLOR_MATERIAL* = 0x00000B57 - GL_FOG* = 0x00000B60 - GL_FOG_INDEX* = 0x00000B61 - GL_FOG_DENSITY* = 0x00000B62 - GL_FOG_START* = 0x00000B63 - GL_FOG_END* = 0x00000B64 - GL_FOG_MODE* = 0x00000B65 - GL_FOG_COLOR* = 0x00000B66 - GL_ACCUM_CLEAR_VALUE* = 0x00000B80 - cGL_MATRIX_MODE* = 0x00000BA0 - GL_NORMALIZE* = 0x00000BA1 - GL_MODELVIEW_STACK_DEPTH* = 0x00000BA3 - GL_PROJECTION_STACK_DEPTH* = 0x00000BA4 - GL_TEXTURE_STACK_DEPTH* = 0x00000BA5 - GL_MODELVIEW_MATRIX* = 0x00000BA6 - GL_PROJECTION_MATRIX* = 0x00000BA7 - GL_TEXTURE_MATRIX* = 0x00000BA8 - GL_ATTRIB_STACK_DEPTH* = 0x00000BB0 - GL_CLIENT_ATTRIB_STACK_DEPTH* = 0x00000BB1 - GL_ALPHA_TEST* = 0x00000BC0 - GL_ALPHA_TEST_FUNC* = 0x00000BC1 - GL_ALPHA_TEST_REF* = 0x00000BC2 - GL_INDEX_LOGIC_OP* = 0x00000BF1 - GL_AUX_BUFFERS* = 0x00000C00 - GL_INDEX_CLEAR_VALUE* = 0x00000C20 - GL_INDEX_WRITEMASK* = 0x00000C21 - GL_INDEX_MODE* = 0x00000C30 - GL_RGBA_MODE* = 0x00000C31 - cGL_RENDER_MODE* = 0x00000C40 - GL_PERSPECTIVE_CORRECTION_HINT* = 0x00000C50 - GL_POINT_SMOOTH_HINT* = 0x00000C51 - GL_FOG_HINT* = 0x00000C54 - GL_TEXTURE_GEN_S* = 0x00000C60 - GL_TEXTURE_GEN_T* = 0x00000C61 - GL_TEXTURE_GEN_R* = 0x00000C62 - GL_TEXTURE_GEN_Q* = 0x00000C63 - GL_PIXEL_MAP_I_TO_I* = 0x00000C70 - GL_PIXEL_MAP_S_TO_S* = 0x00000C71 - GL_PIXEL_MAP_I_TO_R* = 0x00000C72 - GL_PIXEL_MAP_I_TO_G* = 0x00000C73 - GL_PIXEL_MAP_I_TO_B* = 0x00000C74 - GL_PIXEL_MAP_I_TO_A* = 0x00000C75 - GL_PIXEL_MAP_R_TO_R* = 0x00000C76 - GL_PIXEL_MAP_G_TO_G* = 0x00000C77 - GL_PIXEL_MAP_B_TO_B* = 0x00000C78 - GL_PIXEL_MAP_A_TO_A* = 0x00000C79 - GL_PIXEL_MAP_I_TO_I_SIZE* = 0x00000CB0 - GL_PIXEL_MAP_S_TO_S_SIZE* = 0x00000CB1 - GL_PIXEL_MAP_I_TO_R_SIZE* = 0x00000CB2 - GL_PIXEL_MAP_I_TO_G_SIZE* = 0x00000CB3 - GL_PIXEL_MAP_I_TO_B_SIZE* = 0x00000CB4 - GL_PIXEL_MAP_I_TO_A_SIZE* = 0x00000CB5 - GL_PIXEL_MAP_R_TO_R_SIZE* = 0x00000CB6 - GL_PIXEL_MAP_G_TO_G_SIZE* = 0x00000CB7 - GL_PIXEL_MAP_B_TO_B_SIZE* = 0x00000CB8 - GL_PIXEL_MAP_A_TO_A_SIZE* = 0x00000CB9 - GL_MAP_COLOR* = 0x00000D10 - GL_MAP_STENCIL* = 0x00000D11 - GL_INDEX_SHIFT* = 0x00000D12 - GL_INDEX_OFFSET* = 0x00000D13 - GL_RED_SCALE* = 0x00000D14 - GL_RED_BIAS* = 0x00000D15 - GL_ZOOM_X* = 0x00000D16 - GL_ZOOM_Y* = 0x00000D17 - GL_GREEN_SCALE* = 0x00000D18 - GL_GREEN_BIAS* = 0x00000D19 - GL_BLUE_SCALE* = 0x00000D1A - GL_BLUE_BIAS* = 0x00000D1B - GL_ALPHA_SCALE* = 0x00000D1C - GL_ALPHA_BIAS* = 0x00000D1D - GL_DEPTH_SCALE* = 0x00000D1E - GL_DEPTH_BIAS* = 0x00000D1F - GL_MAX_EVAL_ORDER* = 0x00000D30 - GL_MAX_LIGHTS* = 0x00000D31 - GL_MAX_CLIP_PLANES* = 0x00000D32 - GL_MAX_PIXEL_MAP_TABLE* = 0x00000D34 - GL_MAX_ATTRIB_STACK_DEPTH* = 0x00000D35 - GL_MAX_MODELVIEW_STACK_DEPTH* = 0x00000D36 - GL_MAX_NAME_STACK_DEPTH* = 0x00000D37 - GL_MAX_PROJECTION_STACK_DEPTH* = 0x00000D38 - GL_MAX_TEXTURE_STACK_DEPTH* = 0x00000D39 - GL_MAX_CLIENT_ATTRIB_STACK_DEPTH* = 0x00000D3B - GL_INDEX_BITS* = 0x00000D51 - GL_RED_BITS* = 0x00000D52 - GL_GREEN_BITS* = 0x00000D53 - GL_BLUE_BITS* = 0x00000D54 - GL_ALPHA_BITS* = 0x00000D55 - GL_DEPTH_BITS* = 0x00000D56 - GL_STENCIL_BITS* = 0x00000D57 - GL_ACCUM_RED_BITS* = 0x00000D58 - GL_ACCUM_GREEN_BITS* = 0x00000D59 - GL_ACCUM_BLUE_BITS* = 0x00000D5A - GL_ACCUM_ALPHA_BITS* = 0x00000D5B - GL_NAME_STACK_DEPTH* = 0x00000D70 - GL_AUTO_NORMAL* = 0x00000D80 - GL_MAP1_COLOR_4* = 0x00000D90 - GL_MAP1_INDEX* = 0x00000D91 - GL_MAP1_NORMAL* = 0x00000D92 - GL_MAP1_TEXTURE_COORD_1* = 0x00000D93 - GL_MAP1_TEXTURE_COORD_2* = 0x00000D94 - GL_MAP1_TEXTURE_COORD_3* = 0x00000D95 - GL_MAP1_TEXTURE_COORD_4* = 0x00000D96 - GL_MAP1_VERTEX_3* = 0x00000D97 - GL_MAP1_VERTEX_4* = 0x00000D98 - GL_MAP2_COLOR_4* = 0x00000DB0 - GL_MAP2_INDEX* = 0x00000DB1 - GL_MAP2_NORMAL* = 0x00000DB2 - GL_MAP2_TEXTURE_COORD_1* = 0x00000DB3 - GL_MAP2_TEXTURE_COORD_2* = 0x00000DB4 - GL_MAP2_TEXTURE_COORD_3* = 0x00000DB5 - GL_MAP2_TEXTURE_COORD_4* = 0x00000DB6 - GL_MAP2_VERTEX_3* = 0x00000DB7 - GL_MAP2_VERTEX_4* = 0x00000DB8 - GL_MAP1_GRID_DOMAIN* = 0x00000DD0 - GL_MAP1_GRID_SEGMENTS* = 0x00000DD1 - GL_MAP2_GRID_DOMAIN* = 0x00000DD2 - GL_MAP2_GRID_SEGMENTS* = 0x00000DD3 - GL_FEEDBACK_BUFFER_POINTER* = 0x00000DF0 - GL_FEEDBACK_BUFFER_SIZE* = 0x00000DF1 - GL_FEEDBACK_BUFFERtyp* = 0x00000DF2 - GL_SELECTION_BUFFER_POINTER* = 0x00000DF3 - GL_SELECTION_BUFFER_SIZE* = 0x00000DF4 - GL_LIGHT0* = 0x00004000 - GL_LIGHT1* = 0x00004001 - GL_LIGHT2* = 0x00004002 - GL_LIGHT3* = 0x00004003 - GL_LIGHT4* = 0x00004004 - GL_LIGHT5* = 0x00004005 - GL_LIGHT6* = 0x00004006 - GL_LIGHT7* = 0x00004007 - GL_AMBIENT* = 0x00001200 - GL_DIFFUSE* = 0x00001201 - GL_SPECULAR* = 0x00001202 - GL_POSITION* = 0x00001203 - GL_SPOT_DIRECTION* = 0x00001204 - GL_SPOT_EXPONENT* = 0x00001205 - GL_SPOT_CUTOFF* = 0x00001206 - GL_CONSTANT_ATTENUATION* = 0x00001207 - GL_LINEAR_ATTENUATION* = 0x00001208 - GL_QUADRATIC_ATTENUATION* = 0x00001209 - GL_COMPILE* = 0x00001300 - GL_COMPILE_AND_EXECUTE* = 0x00001301 - GL_EMISSION* = 0x00001600 - GL_SHININESS* = 0x00001601 - GL_AMBIENT_AND_DIFFUSE* = 0x00001602 - GL_COLOR_INDEXES* = 0x00001603 - GL_MODELVIEW* = 0x00001700 - GL_PROJECTION* = 0x00001701 - GL_COLOR_INDEX* = 0x00001900 - GL_LUMINANCE* = 0x00001909 - GL_LUMINANCE_ALPHA* = 0x0000190A - cGL_BITMAP* = 0x00001A00 - GL_RENDER* = 0x00001C00 - GL_FEEDBACK* = 0x00001C01 - GL_SELECT* = 0x00001C02 - GL_FLAT* = 0x00001D00 - GL_SMOOTH* = 0x00001D01 - GL_S* = 0x00002000 - GL_T* = 0x00002001 - GL_R* = 0x00002002 - GL_Q* = 0x00002003 - GL_MODULATE* = 0x00002100 - GL_DECAL* = 0x00002101 - GL_TEXTURE_ENV_MODE* = 0x00002200 - GL_TEXTURE_ENV_COLOR* = 0x00002201 - GL_TEXTURE_ENV* = 0x00002300 - GL_EYE_LINEAR* = 0x00002400 - GL_OBJECT_LINEAR* = 0x00002401 - GL_SPHERE_MAP* = 0x00002402 - GL_TEXTURE_GEN_MODE* = 0x00002500 - GL_OBJECT_PLANE* = 0x00002501 - GL_EYE_PLANE* = 0x00002502 - GL_CLAMP* = 0x00002900 - GL_CLIENT_PIXEL_STORE_BIT* = 0x00000001 - GL_CLIENT_VERTEX_ARRAY_BIT* = 0x00000002 - GL_CLIENT_ALL_ATTRIB_BITS* = 0xFFFFFFFF - GL_ALPHA4* = 0x0000803B - GL_ALPHA8* = 0x0000803C - GL_ALPHA12* = 0x0000803D - GL_ALPHA16* = 0x0000803E - GL_LUMINANCE4* = 0x0000803F - GL_LUMINANCE8* = 0x00008040 - GL_LUMINANCE12* = 0x00008041 - GL_LUMINANCE16* = 0x00008042 - GL_LUMINANCE4_ALPHA4* = 0x00008043 - GL_LUMINANCE6_ALPHA2* = 0x00008044 - GL_LUMINANCE8_ALPHA8* = 0x00008045 - GL_LUMINANCE12_ALPHA4* = 0x00008046 - GL_LUMINANCE12_ALPHA12* = 0x00008047 - GL_LUMINANCE16_ALPHA16* = 0x00008048 - GL_INTENSITY* = 0x00008049 - GL_INTENSITY4* = 0x0000804A - GL_INTENSITY8* = 0x0000804B - GL_INTENSITY12* = 0x0000804C - GL_INTENSITY16* = 0x0000804D - GL_TEXTURE_LUMINANCE_SIZE* = 0x00008060 - GL_TEXTURE_INTENSITY_SIZE* = 0x00008061 - GL_TEXTURE_PRIORITY* = 0x00008066 - GL_TEXTURE_RESIDENT* = 0x00008067 - GL_VERTEX_ARRAY* = 0x00008074 - GL_NORMAL_ARRAY* = 0x00008075 - GL_COLOR_ARRAY* = 0x00008076 - GL_INDEX_ARRAY* = 0x00008077 - GL_TEXTURE_COORD_ARRAY* = 0x00008078 - GL_EDGE_FLAG_ARRAY* = 0x00008079 - GL_VERTEX_ARRAY_SIZE* = 0x0000807A - GL_VERTEX_ARRAYtyp* = 0x0000807B - GL_VERTEX_ARRAY_STRIDE* = 0x0000807C - GL_NORMAL_ARRAYtyp* = 0x0000807E - GL_NORMAL_ARRAY_STRIDE* = 0x0000807F - GL_COLOR_ARRAY_SIZE* = 0x00008081 - GL_COLOR_ARRAYtyp* = 0x00008082 - GL_COLOR_ARRAY_STRIDE* = 0x00008083 - GL_INDEX_ARRAYtyp* = 0x00008085 - GL_INDEX_ARRAY_STRIDE* = 0x00008086 - GL_TEXTURE_COORD_ARRAY_SIZE* = 0x00008088 - GL_TEXTURE_COORD_ARRAYtyp* = 0x00008089 - GL_TEXTURE_COORD_ARRAY_STRIDE* = 0x0000808A - GL_EDGE_FLAG_ARRAY_STRIDE* = 0x0000808C - GL_VERTEX_ARRAY_POINTER* = 0x0000808E - GL_NORMAL_ARRAY_POINTER* = 0x0000808F - GL_COLOR_ARRAY_POINTER* = 0x00008090 - GL_INDEX_ARRAY_POINTER* = 0x00008091 - GL_TEXTURE_COORD_ARRAY_POINTER* = 0x00008092 - GL_EDGE_FLAG_ARRAY_POINTER* = 0x00008093 - GL_V2F* = 0x00002A20 - GL_V3F* = 0x00002A21 - GL_C4UB_V2F* = 0x00002A22 - GL_C4UB_V3F* = 0x00002A23 - GL_C3F_V3F* = 0x00002A24 - GL_N3F_V3F* = 0x00002A25 - GL_C4F_N3F_V3F* = 0x00002A26 - GL_T2F_V3F* = 0x00002A27 - GL_T4F_V4F* = 0x00002A28 - GL_T2F_C4UB_V3F* = 0x00002A29 - GL_T2F_C3F_V3F* = 0x00002A2A - GL_T2F_N3F_V3F* = 0x00002A2B - GL_T2F_C4F_N3F_V3F* = 0x00002A2C - GL_T4F_C4F_N3F_V4F* = 0x00002A2D - GL_COLOR_TABLE_FORMAT_EXT* = 0x000080D8 - GL_COLOR_TABLE_WIDTH_EXT* = 0x000080D9 - GL_COLOR_TABLE_RED_SIZE_EXT* = 0x000080DA - GL_COLOR_TABLE_GREEN_SIZE_EXT* = 0x000080DB - GL_COLOR_TABLE_BLUE_SIZE_EXT* = 0x000080DC - GL_COLOR_TABLE_ALPHA_SIZE_EXT* = 0x000080DD - GL_COLOR_TABLE_LUMINANCE_SIZE_EXT* = 0x000080DE - GL_COLOR_TABLE_INTENSITY_SIZE_EXT* = 0x000080DF - cGL_LOGIC_OP* = GL_INDEX_LOGIC_OP - GL_TEXTURE_COMPONENTS* = GL_TEXTURE_INTERNAL_FORMAT # GL_VERSION_1_2 - GL_UNSIGNED_BYTE_3_3_2* = 0x00008032 - GL_UNSIGNED_SHORT_4_4_4_4* = 0x00008033 - GL_UNSIGNED_SHORT_5_5_5_1* = 0x00008034 - GL_UNSIGNED_INT_8_8_8_8* = 0x00008035 - GL_UNSIGNED_INT_10_10_10_2* = 0x00008036 - GL_TEXTURE_BINDING_3D* = 0x0000806A - GL_PACK_SKIP_IMAGES* = 0x0000806B - GL_PACK_IMAGE_HEIGHT* = 0x0000806C - GL_UNPACK_SKIP_IMAGES* = 0x0000806D - GL_UNPACK_IMAGE_HEIGHT* = 0x0000806E - GL_TEXTURE_3D* = 0x0000806F - GL_PROXY_TEXTURE_3D* = 0x00008070 - GL_TEXTURE_DEPTH* = 0x00008071 - GL_TEXTURE_WRAP_R* = 0x00008072 - GL_MAX_3D_TEXTURE_SIZE* = 0x00008073 - GL_UNSIGNED_BYTE_2_3_3_REV* = 0x00008362 - GL_UNSIGNED_SHORT_5_6_5* = 0x00008363 - GL_UNSIGNED_SHORT_5_6_5_REV* = 0x00008364 - GL_UNSIGNED_SHORT_4_4_4_4_REV* = 0x00008365 - GL_UNSIGNED_SHORT_1_5_5_5_REV* = 0x00008366 - GL_UNSIGNED_INT_8_8_8_8_REV* = 0x00008367 - GL_UNSIGNED_INT_2_10_10_10_REV* = 0x00008368 - GL_BGR* = 0x000080E0 - GL_BGRA* = 0x000080E1 - GL_MAX_ELEMENTS_VERTICES* = 0x000080E8 - GL_MAX_ELEMENTS_INDICES* = 0x000080E9 - GL_CLAMP_TO_EDGE* = 0x0000812F - GL_TEXTURE_MIN_LOD* = 0x0000813A - GL_TEXTURE_MAX_LOD* = 0x0000813B - GL_TEXTURE_BASE_LEVEL* = 0x0000813C - GL_TEXTURE_MAX_LEVEL* = 0x0000813D - GL_SMOOTH_POINT_SIZE_RANGE* = 0x00000B12 - GL_SMOOTH_POINT_SIZE_GRANULARITY* = 0x00000B13 - GL_SMOOTH_LINE_WIDTH_RANGE* = 0x00000B22 - GL_SMOOTH_LINE_WIDTH_GRANULARITY* = 0x00000B23 - GL_ALIASED_LINE_WIDTH_RANGE* = 0x0000846E - GL_RESCALE_NORMAL* = 0x0000803A - GL_LIGHT_MODEL_COLOR_CONTROL* = 0x000081F8 - GL_SINGLE_COLOR* = 0x000081F9 - GL_SEPARATE_SPECULAR_COLOR* = 0x000081FA - GL_ALIASED_POINT_SIZE_RANGE* = 0x0000846D # GL_VERSION_1_3 - GL_TEXTURE0* = 0x000084C0 - GL_TEXTURE1* = 0x000084C1 - GL_TEXTURE2* = 0x000084C2 - GL_TEXTURE3* = 0x000084C3 - GL_TEXTURE4* = 0x000084C4 - GL_TEXTURE5* = 0x000084C5 - GL_TEXTURE6* = 0x000084C6 - GL_TEXTURE7* = 0x000084C7 - GL_TEXTURE8* = 0x000084C8 - GL_TEXTURE9* = 0x000084C9 - GL_TEXTURE10* = 0x000084CA - GL_TEXTURE11* = 0x000084CB - GL_TEXTURE12* = 0x000084CC - GL_TEXTURE13* = 0x000084CD - GL_TEXTURE14* = 0x000084CE - GL_TEXTURE15* = 0x000084CF - GL_TEXTURE16* = 0x000084D0 - GL_TEXTURE17* = 0x000084D1 - GL_TEXTURE18* = 0x000084D2 - GL_TEXTURE19* = 0x000084D3 - GL_TEXTURE20* = 0x000084D4 - GL_TEXTURE21* = 0x000084D5 - GL_TEXTURE22* = 0x000084D6 - GL_TEXTURE23* = 0x000084D7 - GL_TEXTURE24* = 0x000084D8 - GL_TEXTURE25* = 0x000084D9 - GL_TEXTURE26* = 0x000084DA - GL_TEXTURE27* = 0x000084DB - GL_TEXTURE28* = 0x000084DC - GL_TEXTURE29* = 0x000084DD - GL_TEXTURE30* = 0x000084DE - GL_TEXTURE31* = 0x000084DF - cGL_ACTIVE_TEXTURE* = 0x000084E0 - GL_MULTISAMPLE* = 0x0000809D - GL_SAMPLE_ALPHA_TO_COVERAGE* = 0x0000809E - GL_SAMPLE_ALPHA_TO_ONE* = 0x0000809F - cGL_SAMPLE_COVERAGE* = 0x000080A0 - GL_SAMPLE_BUFFERS* = 0x000080A8 - GL_SAMPLES* = 0x000080A9 - GL_SAMPLE_COVERAGE_VALUE* = 0x000080AA - GL_SAMPLE_COVERAGE_INVERT* = 0x000080AB - GL_TEXTURE_CUBE_MAP* = 0x00008513 - GL_TEXTURE_BINDING_CUBE_MAP* = 0x00008514 - GL_TEXTURE_CUBE_MAP_POSITIVE_X* = 0x00008515 - GL_TEXTURE_CUBE_MAP_NEGATIVE_X* = 0x00008516 - GL_TEXTURE_CUBE_MAP_POSITIVE_Y* = 0x00008517 - GL_TEXTURE_CUBE_MAP_NEGATIVE_Y* = 0x00008518 - GL_TEXTURE_CUBE_MAP_POSITIVE_Z* = 0x00008519 - GL_TEXTURE_CUBE_MAP_NEGATIVE_Z* = 0x0000851A - GL_PROXY_TEXTURE_CUBE_MAP* = 0x0000851B - GL_MAX_CUBE_MAP_TEXTURE_SIZE* = 0x0000851C - GL_COMPRESSED_RGB* = 0x000084ED - GL_COMPRESSED_RGBA* = 0x000084EE - GL_TEXTURE_COMPRESSION_HINT* = 0x000084EF - GL_TEXTURE_COMPRESSED_IMAGE_SIZE* = 0x000086A0 - GL_TEXTURE_COMPRESSED* = 0x000086A1 - GL_NUM_COMPRESSED_TEXTURE_FORMATS* = 0x000086A2 - GL_COMPRESSED_TEXTURE_FORMATS* = 0x000086A3 - GL_CLAMP_TO_BORDER* = 0x0000812D - cGL_CLIENT_ACTIVE_TEXTURE* = 0x000084E1 - GL_MAX_TEXTURE_UNITS* = 0x000084E2 - GL_TRANSPOSE_MODELVIEW_MATRIX* = 0x000084E3 - GL_TRANSPOSE_PROJECTION_MATRIX* = 0x000084E4 - GL_TRANSPOSE_TEXTURE_MATRIX* = 0x000084E5 - GL_TRANSPOSE_COLOR_MATRIX* = 0x000084E6 - GL_MULTISAMPLE_BIT* = 0x20000000 - GL_NORMAL_MAP* = 0x00008511 - GL_REFLECTION_MAP* = 0x00008512 - GL_COMPRESSED_ALPHA* = 0x000084E9 - GL_COMPRESSED_LUMINANCE* = 0x000084EA - GL_COMPRESSED_LUMINANCE_ALPHA* = 0x000084EB - GL_COMPRESSED_INTENSITY* = 0x000084EC - GL_COMBINE* = 0x00008570 - GL_COMBINE_RGB* = 0x00008571 - GL_COMBINE_ALPHA* = 0x00008572 - GL_SOURCE0_RGB* = 0x00008580 - GL_SOURCE1_RGB* = 0x00008581 - GL_SOURCE2_RGB* = 0x00008582 - GL_SOURCE0_ALPHA* = 0x00008588 - GL_SOURCE1_ALPHA* = 0x00008589 - GL_SOURCE2_ALPHA* = 0x0000858A - GL_OPERAND0_RGB* = 0x00008590 - GL_OPERAND1_RGB* = 0x00008591 - GL_OPERAND2_RGB* = 0x00008592 - GL_OPERAND0_ALPHA* = 0x00008598 - GL_OPERAND1_ALPHA* = 0x00008599 - GL_OPERAND2_ALPHA* = 0x0000859A - GL_RGB_SCALE* = 0x00008573 - GL_ADD_SIGNED* = 0x00008574 - GL_INTERPOLATE* = 0x00008575 - GL_SUBTRACT* = 0x000084E7 - GL_CONSTANT* = 0x00008576 - GL_PRIMARY_COLOR* = 0x00008577 - GL_PREVIOUS* = 0x00008578 - GL_DOT3_RGB* = 0x000086AE - GL_DOT3_RGBA* = 0x000086AF # GL_VERSION_1_4 - GL_BLEND_DST_RGB* = 0x000080C8 - GL_BLEND_SRC_RGB* = 0x000080C9 - GL_BLEND_DST_ALPHA* = 0x000080CA - GL_BLEND_SRC_ALPHA* = 0x000080CB - GL_POINT_FADE_THRESHOLD_SIZE* = 0x00008128 - GL_DEPTH_COMPONENT16* = 0x000081A5 - GL_DEPTH_COMPONENT24* = 0x000081A6 - GL_DEPTH_COMPONENT32* = 0x000081A7 - GL_MIRRORED_REPEAT* = 0x00008370 - GL_MAX_TEXTURE_LOD_BIAS* = 0x000084FD - GL_TEXTURE_LOD_BIAS* = 0x00008501 - GL_INCR_WRAP* = 0x00008507 - GL_DECR_WRAP* = 0x00008508 - GL_TEXTURE_DEPTH_SIZE* = 0x0000884A - GL_TEXTURE_COMPARE_MODE* = 0x0000884C - GL_TEXTURE_COMPARE_FUNC* = 0x0000884D - GL_POINT_SIZE_MIN* = 0x00008126 - GL_POINT_SIZE_MAX* = 0x00008127 - GL_POINT_DISTANCE_ATTENUATION* = 0x00008129 - cGL_GENERATE_MIPMAP* = 0x00008191 - GL_GENERATE_MIPMAP_HINT* = 0x00008192 - GL_FOG_COORDINATE_SOURCE* = 0x00008450 - GL_FOG_COORDINATE* = 0x00008451 - GL_FRAGMENT_DEPTH* = 0x00008452 - GL_CURRENT_FOG_COORDINATE* = 0x00008453 - GL_FOG_COORDINATE_ARRAYtyp* = 0x00008454 - GL_FOG_COORDINATE_ARRAY_STRIDE* = 0x00008455 - GL_FOG_COORDINATE_ARRAY_POINTER* = 0x00008456 - GL_FOG_COORDINATE_ARRAY* = 0x00008457 - GL_COLOR_SUM* = 0x00008458 - GL_CURRENT_SECONDARY_COLOR* = 0x00008459 - GL_SECONDARY_COLOR_ARRAY_SIZE* = 0x0000845A - GL_SECONDARY_COLOR_ARRAYtyp* = 0x0000845B - GL_SECONDARY_COLOR_ARRAY_STRIDE* = 0x0000845C - GL_SECONDARY_COLOR_ARRAY_POINTER* = 0x0000845D - GL_SECONDARY_COLOR_ARRAY* = 0x0000845E - GL_TEXTURE_FILTER_CONTROL* = 0x00008500 - GL_DEPTH_TEXTURE_MODE* = 0x0000884B - GL_COMPARE_R_TO_TEXTURE* = 0x0000884E # GL_VERSION_1_5 - GL_BUFFER_SIZE* = 0x00008764 - GL_BUFFER_USAGE* = 0x00008765 - GL_QUERY_COUNTER_BITS* = 0x00008864 - GL_CURRENT_QUERY* = 0x00008865 - GL_QUERY_RESULT* = 0x00008866 - GL_QUERY_RESULT_AVAILABLE* = 0x00008867 - GL_ARRAY_BUFFER* = 0x00008892 - GL_ELEMENT_ARRAY_BUFFER* = 0x00008893 - GL_ARRAY_BUFFER_BINDING* = 0x00008894 - GL_ELEMENT_ARRAY_BUFFER_BINDING* = 0x00008895 - GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING* = 0x0000889F - GL_READ_ONLY* = 0x000088B8 - GL_WRITE_ONLY* = 0x000088B9 - GL_READ_WRITE* = 0x000088BA - GL_BUFFER_ACCESS* = 0x000088BB - GL_BUFFER_MAPPED* = 0x000088BC - GL_BUFFER_MAP_POINTER* = 0x000088BD - GL_STREAM_DRAW* = 0x000088E0 - GL_STREAM_READ* = 0x000088E1 - GL_STREAM_COPY* = 0x000088E2 - GL_STATIC_DRAW* = 0x000088E4 - GL_STATIC_READ* = 0x000088E5 - GL_STATIC_COPY* = 0x000088E6 - GL_DYNAMIC_DRAW* = 0x000088E8 - GL_DYNAMIC_READ* = 0x000088E9 - GL_DYNAMIC_COPY* = 0x000088EA - GL_SAMPLES_PASSED* = 0x00008914 - GL_VERTEX_ARRAY_BUFFER_BINDING* = 0x00008896 - GL_NORMAL_ARRAY_BUFFER_BINDING* = 0x00008897 - GL_COLOR_ARRAY_BUFFER_BINDING* = 0x00008898 - GL_INDEX_ARRAY_BUFFER_BINDING* = 0x00008899 - GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING* = 0x0000889A - GL_EDGE_FLAG_ARRAY_BUFFER_BINDING* = 0x0000889B - GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING* = 0x0000889C - GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING* = 0x0000889D - GL_WEIGHT_ARRAY_BUFFER_BINDING* = 0x0000889E - GL_FOG_COORD_SRC* = 0x00008450 - GL_FOG_COORD* = 0x00008451 - GL_CURRENT_FOG_COORD* = 0x00008453 - GL_FOG_COORD_ARRAYtyp* = 0x00008454 - GL_FOG_COORD_ARRAY_STRIDE* = 0x00008455 - GL_FOG_COORD_ARRAY_POINTER* = 0x00008456 - GL_FOG_COORD_ARRAY* = 0x00008457 - GL_FOG_COORD_ARRAY_BUFFER_BINDING* = 0x0000889D - GL_SRC0_RGB* = 0x00008580 - GL_SRC1_RGB* = 0x00008581 - GL_SRC2_RGB* = 0x00008582 - GL_SRC0_ALPHA* = 0x00008588 - GL_SRC1_ALPHA* = 0x00008589 - GL_SRC2_ALPHA* = 0x0000858A # GL_VERSION_2_0 - GL_BLEND_EQUATION_RGB* = 0x00008009 - GL_VERTEX_ATTRIB_ARRAY_ENABLED* = 0x00008622 - GL_VERTEX_ATTRIB_ARRAY_SIZE* = 0x00008623 - GL_VERTEX_ATTRIB_ARRAY_STRIDE* = 0x00008624 - GL_VERTEX_ATTRIB_ARRAYtyp* = 0x00008625 - GL_CURRENT_VERTEX_ATTRIB* = 0x00008626 - GL_VERTEX_PROGRAM_POINT_SIZE* = 0x00008642 - GL_VERTEX_ATTRIB_ARRAY_POINTER* = 0x00008645 - GL_STENCIL_BACK_FUNC* = 0x00008800 - GL_STENCIL_BACK_FAIL* = 0x00008801 - GL_STENCIL_BACK_PASS_DEPTH_FAIL* = 0x00008802 - GL_STENCIL_BACK_PASS_DEPTH_PASS* = 0x00008803 - GL_MAX_DRAW_BUFFERS* = 0x00008824 - GL_DRAW_BUFFER0* = 0x00008825 - GL_DRAW_BUFFER1* = 0x00008826 - GL_DRAW_BUFFER2* = 0x00008827 - GL_DRAW_BUFFER3* = 0x00008828 - GL_DRAW_BUFFER4* = 0x00008829 - GL_DRAW_BUFFER5* = 0x0000882A - GL_DRAW_BUFFER6* = 0x0000882B - GL_DRAW_BUFFER7* = 0x0000882C - GL_DRAW_BUFFER8* = 0x0000882D - GL_DRAW_BUFFER9* = 0x0000882E - GL_DRAW_BUFFER10* = 0x0000882F - GL_DRAW_BUFFER11* = 0x00008830 - GL_DRAW_BUFFER12* = 0x00008831 - GL_DRAW_BUFFER13* = 0x00008832 - GL_DRAW_BUFFER14* = 0x00008833 - GL_DRAW_BUFFER15* = 0x00008834 - GL_BLEND_EQUATION_ALPHA* = 0x0000883D - GL_MAX_VERTEX_ATTRIBS* = 0x00008869 - GL_VERTEX_ATTRIB_ARRAY_NORMALIZED* = 0x0000886A - GL_MAX_TEXTURE_IMAGE_UNITS* = 0x00008872 - GL_FRAGMENT_SHADER* = 0x00008B30 - GL_VERTEX_SHADER* = 0x00008B31 - GL_MAX_FRAGMENT_UNIFORM_COMPONENTS* = 0x00008B49 - GL_MAX_VERTEX_UNIFORM_COMPONENTS* = 0x00008B4A - GL_MAX_VARYING_FLOATS* = 0x00008B4B - GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS* = 0x00008B4C - GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS* = 0x00008B4D - GL_SHADERtyp* = 0x00008B4F - GL_FLOAT_VEC2* = 0x00008B50 - GL_FLOAT_VEC3* = 0x00008B51 - GL_FLOAT_VEC4* = 0x00008B52 - GL_INT_VEC2* = 0x00008B53 - GL_INT_VEC3* = 0x00008B54 - GL_INT_VEC4* = 0x00008B55 - GL_BOOL* = 0x00008B56 - GL_BOOL_VEC2* = 0x00008B57 - GL_BOOL_VEC3* = 0x00008B58 - GL_BOOL_VEC4* = 0x00008B59 - GL_FLOAT_MAT2* = 0x00008B5A - GL_FLOAT_MAT3* = 0x00008B5B - GL_FLOAT_MAT4* = 0x00008B5C - GL_SAMPLER_1D* = 0x00008B5D - GL_SAMPLER_2D* = 0x00008B5E - GL_SAMPLER_3D* = 0x00008B5F - GL_SAMPLER_CUBE* = 0x00008B60 - GL_SAMPLER_1D_SHADOW* = 0x00008B61 - GL_SAMPLER_2D_SHADOW* = 0x00008B62 - GL_DELETE_STATUS* = 0x00008B80 - GL_COMPILE_STATUS* = 0x00008B81 - GL_LINK_STATUS* = 0x00008B82 - GL_VALIDATE_STATUS* = 0x00008B83 - GL_INFO_LOG_LENGTH* = 0x00008B84 - GL_ATTACHED_SHADERS* = 0x00008B85 - GL_ACTIVE_UNIFORMS* = 0x00008B86 - GL_ACTIVE_UNIFORM_MAX_LENGTH* = 0x00008B87 - GL_SHADER_SOURCE_LENGTH* = 0x00008B88 - GL_ACTIVE_ATTRIBUTES* = 0x00008B89 - GL_ACTIVE_ATTRIBUTE_MAX_LENGTH* = 0x00008B8A - GL_FRAGMENT_SHADER_DERIVATIVE_HINT* = 0x00008B8B - GL_SHADING_LANGUAGE_VERSION* = 0x00008B8C - GL_CURRENT_PROGRAM* = 0x00008B8D - GL_POINT_SPRITE_COORD_ORIGIN* = 0x00008CA0 - GL_LOWER_LEFT* = 0x00008CA1 - GL_UPPER_LEFT* = 0x00008CA2 - GL_STENCIL_BACK_REF* = 0x00008CA3 - GL_STENCIL_BACK_VALUE_MASK* = 0x00008CA4 - GL_STENCIL_BACK_WRITEMASK* = 0x00008CA5 - GL_VERTEX_PROGRAM_TWO_SIDE* = 0x00008643 - GL_POINT_SPRITE* = 0x00008861 - GL_COORD_REPLACE* = 0x00008862 - GL_MAX_TEXTURE_COORDS* = 0x00008871 # GL_VERSION_2_1 - GL_PIXEL_PACK_BUFFER* = 0x000088EB - GL_PIXEL_UNPACK_BUFFER* = 0x000088EC - GL_PIXEL_PACK_BUFFER_BINDING* = 0x000088ED - GL_PIXEL_UNPACK_BUFFER_BINDING* = 0x000088EF - GL_FLOAT_MAT2x3* = 0x00008B65 - GL_FLOAT_MAT2x4* = 0x00008B66 - GL_FLOAT_MAT3x2* = 0x00008B67 - GL_FLOAT_MAT3x4* = 0x00008B68 - GL_FLOAT_MAT4x2* = 0x00008B69 - GL_FLOAT_MAT4x3* = 0x00008B6A - GL_SRGB* = 0x00008C40 - GL_SRGB8* = 0x00008C41 - GL_SRGB_ALPHA* = 0x00008C42 - GL_SRGB8_ALPHA8* = 0x00008C43 - GL_COMPRESSED_SRGB* = 0x00008C48 - GL_COMPRESSED_SRGB_ALPHA* = 0x00008C49 - GL_CURRENT_RASTER_SECONDARY_COLOR* = 0x0000845F - GL_SLUMINANCE_ALPHA* = 0x00008C44 - GL_SLUMINANCE8_ALPHA8* = 0x00008C45 - GL_SLUMINANCE* = 0x00008C46 - GL_SLUMINANCE8* = 0x00008C47 - GL_COMPRESSED_SLUMINANCE* = 0x00008C4A - GL_COMPRESSED_SLUMINANCE_ALPHA* = 0x00008C4B # GL_VERSION_3_0 - GL_COMPARE_REF_TO_TEXTURE* = 0x0000884E - GL_CLIP_DISTANCE0* = 0x00003000 - GL_CLIP_DISTANCE1* = 0x00003001 - GL_CLIP_DISTANCE2* = 0x00003002 - GL_CLIP_DISTANCE3* = 0x00003003 - GL_CLIP_DISTANCE4* = 0x00003004 - GL_CLIP_DISTANCE5* = 0x00003005 - GL_CLIP_DISTANCE6* = 0x00003006 - GL_CLIP_DISTANCE7* = 0x00003007 - GL_MAX_CLIP_DISTANCES* = 0x00000D32 - GL_MAJOR_VERSION* = 0x0000821B - GL_MINOR_VERSION* = 0x0000821C - GL_NUM_EXTENSIONS* = 0x0000821D - GL_CONTEXT_FLAGS* = 0x0000821E - GL_DEPTH_BUFFER* = 0x00008223 - GL_STENCIL_BUFFER* = 0x00008224 - GL_COMPRESSED_RED* = 0x00008225 - GL_COMPRESSED_RG* = 0x00008226 - GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT* = 0x00000001 - GL_RGBA32F* = 0x00008814 - GL_RGB32F* = 0x00008815 - GL_RGBA16F* = 0x0000881A - GL_RGB16F* = 0x0000881B - GL_VERTEX_ATTRIB_ARRAY_INTEGER* = 0x000088FD - GL_MAX_ARRAY_TEXTURE_LAYERS* = 0x000088FF - GL_MIN_PROGRAM_TEXEL_OFFSET* = 0x00008904 - GL_MAX_PROGRAM_TEXEL_OFFSET* = 0x00008905 - GL_CLAMP_READ_COLOR* = 0x0000891C - GL_FIXED_ONLY* = 0x0000891D - GL_MAX_VARYING_COMPONENTS* = 0x00008B4B - GL_TEXTURE_1D_ARRAY* = 0x00008C18 - GL_PROXY_TEXTURE_1D_ARRAY* = 0x00008C19 - GL_TEXTURE_2D_ARRAY* = 0x00008C1A - GL_PROXY_TEXTURE_2D_ARRAY* = 0x00008C1B - GL_TEXTURE_BINDING_1D_ARRAY* = 0x00008C1C - GL_TEXTURE_BINDING_2D_ARRAY* = 0x00008C1D - GL_R11F_G11F_B10F* = 0x00008C3A - GL_UNSIGNED_INT_10F_11F_11F_REV* = 0x00008C3B - GL_RGB9_E5* = 0x00008C3D - GL_UNSIGNED_INT_5_9_9_9_REV* = 0x00008C3E - GL_TEXTURE_SHARED_SIZE* = 0x00008C3F - GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH* = 0x00008C76 - GL_TRANSFORM_FEEDBACK_BUFFER_MODE* = 0x00008C7F - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS* = 0x00008C80 - cGL_TRANSFORM_FEEDBACK_VARYINGS* = 0x00008C83 - GL_TRANSFORM_FEEDBACK_BUFFER_START* = 0x00008C84 - GL_TRANSFORM_FEEDBACK_BUFFER_SIZE* = 0x00008C85 - GL_PRIMITIVES_GENERATED* = 0x00008C87 - GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN* = 0x00008C88 - GL_RASTERIZER_DISCARD* = 0x00008C89 - GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS* = 0x00008C8A - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS* = 0x00008C8B - GL_INTERLEAVED_ATTRIBS* = 0x00008C8C - GL_SEPARATE_ATTRIBS* = 0x00008C8D - GL_TRANSFORM_FEEDBACK_BUFFER* = 0x00008C8E - GL_TRANSFORM_FEEDBACK_BUFFER_BINDING* = 0x00008C8F - GL_RGBA32UI* = 0x00008D70 - GL_RGB32UI* = 0x00008D71 - GL_RGBA16UI* = 0x00008D76 - GL_RGB16UI* = 0x00008D77 - GL_RGBA8UI* = 0x00008D7C - GL_RGB8UI* = 0x00008D7D - GL_RGBA32I* = 0x00008D82 - GL_RGB32I* = 0x00008D83 - GL_RGBA16I* = 0x00008D88 - GL_RGB16I* = 0x00008D89 - GL_RGBA8I* = 0x00008D8E - GL_RGB8I* = 0x00008D8F - GL_RED_INTEGER* = 0x00008D94 - GL_GREEN_INTEGER* = 0x00008D95 - GL_BLUE_INTEGER* = 0x00008D96 - GL_RGB_INTEGER* = 0x00008D98 - GL_RGBA_INTEGER* = 0x00008D99 - GL_BGR_INTEGER* = 0x00008D9A - GL_BGRA_INTEGER* = 0x00008D9B - GL_SAMPLER_1D_ARRAY* = 0x00008DC0 - GL_SAMPLER_2D_ARRAY* = 0x00008DC1 - GL_SAMPLER_1D_ARRAY_SHADOW* = 0x00008DC3 - GL_SAMPLER_2D_ARRAY_SHADOW* = 0x00008DC4 - GL_SAMPLER_CUBE_SHADOW* = 0x00008DC5 - GL_UNSIGNED_INT_VEC2* = 0x00008DC6 - GL_UNSIGNED_INT_VEC3* = 0x00008DC7 - GL_UNSIGNED_INT_VEC4* = 0x00008DC8 - GL_INT_SAMPLER_1D* = 0x00008DC9 - GL_INT_SAMPLER_2D* = 0x00008DCA - GL_INT_SAMPLER_3D* = 0x00008DCB - GL_INT_SAMPLER_CUBE* = 0x00008DCC - GL_INT_SAMPLER_1D_ARRAY* = 0x00008DCE - GL_INT_SAMPLER_2D_ARRAY* = 0x00008DCF - GL_UNSIGNED_INT_SAMPLER_1D* = 0x00008DD1 - GL_UNSIGNED_INT_SAMPLER_2D* = 0x00008DD2 - GL_UNSIGNED_INT_SAMPLER_3D* = 0x00008DD3 - GL_UNSIGNED_INT_SAMPLER_CUBE* = 0x00008DD4 - GL_UNSIGNED_INT_SAMPLER_1D_ARRAY* = 0x00008DD6 - GL_UNSIGNED_INT_SAMPLER_2D_ARRAY* = 0x00008DD7 - GL_QUERY_WAIT* = 0x00008E13 - GL_QUERY_NO_WAIT* = 0x00008E14 - GL_QUERY_BY_REGION_WAIT* = 0x00008E15 - GL_QUERY_BY_REGION_NO_WAIT* = 0x00008E16 - GL_BUFFER_ACCESS_FLAGS* = 0x0000911F - GL_BUFFER_MAP_LENGTH* = 0x00009120 - GL_BUFFER_MAP_OFFSET* = 0x00009121 - GL_CLAMP_VERTEX_COLOR* = 0x0000891A - GL_CLAMP_FRAGMENT_COLOR* = 0x0000891B - GL_ALPHA_INTEGER* = 0x00008D97 # GL_VERSION_3_1 - GL_SAMPLER_2D_RECT* = 0x00008B63 - GL_SAMPLER_2D_RECT_SHADOW* = 0x00008B64 - GL_SAMPLER_BUFFER* = 0x00008DC2 - GL_INT_SAMPLER_2D_RECT* = 0x00008DCD - GL_INT_SAMPLER_BUFFER* = 0x00008DD0 - GL_UNSIGNED_INT_SAMPLER_2D_RECT* = 0x00008DD5 - GL_UNSIGNED_INT_SAMPLER_BUFFER* = 0x00008DD8 - GL_TEXTURE_BUFFER* = 0x00008C2A - GL_MAX_TEXTURE_BUFFER_SIZE* = 0x00008C2B - GL_TEXTURE_BINDING_BUFFER* = 0x00008C2C - GL_TEXTURE_BUFFER_DATA_STORE_BINDING* = 0x00008C2D - GL_TEXTURE_BUFFER_FORMAT* = 0x00008C2E - GL_TEXTURE_RECTANGLE* = 0x000084F5 - GL_TEXTURE_BINDING_RECTANGLE* = 0x000084F6 - GL_PROXY_TEXTURE_RECTANGLE* = 0x000084F7 - GL_MAX_RECTANGLE_TEXTURE_SIZE* = 0x000084F8 - GL_RED_SNORM* = 0x00008F90 - GL_RG_SNORM* = 0x00008F91 - GL_RGB_SNORM* = 0x00008F92 - GL_RGBA_SNORM* = 0x00008F93 - GL_R8_SNORM* = 0x00008F94 - GL_RG8_SNORM* = 0x00008F95 - GL_RGB8_SNORM* = 0x00008F96 - GL_RGBA8_SNORM* = 0x00008F97 - GL_R16_SNORM* = 0x00008F98 - GL_RG16_SNORM* = 0x00008F99 - GL_RGB16_SNORM* = 0x00008F9A - GL_RGBA16_SNORM* = 0x00008F9B - GL_SIGNED_NORMALIZED* = 0x00008F9C - GL_PRIMITIVE_RESTART* = 0x00008F9D - cGL_PRIMITIVE_RESTART_INDEX* = 0x00008F9E - GL_CONTEXT_CORE_PROFILE_BIT* = 0x00000001 - GL_CONTEXT_COMPATIBILITY_PROFILE_BIT* = 0x00000002 - GL_LINES_ADJACENCY* = 0x0000000A - GL_LINE_STRIP_ADJACENCY* = 0x0000000B - GL_TRIANGLES_ADJACENCY* = 0x0000000C - GL_TRIANGLE_STRIP_ADJACENCY* = 0x0000000D - GL_PROGRAM_POINT_SIZE* = 0x00008642 - GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS* = 0x00008C29 - GL_FRAMEBUFFER_ATTACHMENT_LAYERED* = 0x00008DA7 - GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS* = 0x00008DA8 - GL_GEOMETRY_SHADER* = 0x00008DD9 - GL_GEOMETRY_VERTICES_OUT* = 0x00008916 - GL_GEOMETRY_INPUTtyp* = 0x00008917 - GL_GEOMETRY_OUTPUTtyp* = 0x00008918 - GL_MAX_GEOMETRY_UNIFORM_COMPONENTS* = 0x00008DDF - GL_MAX_GEOMETRY_OUTPUT_VERTICES* = 0x00008DE0 - GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS* = 0x00008DE1 - GL_MAX_VERTEX_OUTPUT_COMPONENTS* = 0x00009122 - GL_MAX_GEOMETRY_INPUT_COMPONENTS* = 0x00009123 - GL_MAX_GEOMETRY_OUTPUT_COMPONENTS* = 0x00009124 - GL_MAX_FRAGMENT_INPUT_COMPONENTS* = 0x00009125 - GL_CONTEXT_PROFILE_MASK* = 0x00009126 # GL_VERSION_3_3 - GL_VERTEX_ATTRIB_ARRAY_DIVISOR* = 0x000088FE # GL_VERSION_4_0 - GL_SAMPLE_SHADING* = 0x00008C36 - GL_MIN_SAMPLE_SHADING_VALUE* = 0x00008C37 - GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET* = 0x00008E5E - GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET* = 0x00008E5F - GL_TEXTURE_CUBE_MAP_ARRAY* = 0x00009009 - GL_TEXTURE_BINDING_CUBE_MAP_ARRAY* = 0x0000900A - GL_PROXY_TEXTURE_CUBE_MAP_ARRAY* = 0x0000900B - GL_SAMPLER_CUBE_MAP_ARRAY* = 0x0000900C - GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW* = 0x0000900D - GL_INT_SAMPLER_CUBE_MAP_ARRAY* = 0x0000900E - GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY* = 0x0000900F # GL_3DFX_multisample - GL_MULTISAMPLE_3DFX* = 0x000086B2 - GL_SAMPLE_BUFFERS_3DFX* = 0x000086B3 - GL_SAMPLES_3DFX* = 0x000086B4 - GL_MULTISAMPLE_BIT_3DFX* = 0x20000000 # GL_3DFX_texture_compression_FXT1 - GL_COMPRESSED_RGB_FXT1_3DFX* = 0x000086B0 - GL_COMPRESSED_RGBA_FXT1_3DFX* = 0x000086B1 # GL_APPLE_client_storage - GL_UNPACK_CLIENT_STORAGE_APPLE* = 0x000085B2 # GL_APPLE_element_array - GL_ELEMENT_ARRAY_APPLE* = 0x00008A0C - GL_ELEMENT_ARRAYtyp_APPLE* = 0x00008A0D - GL_ELEMENT_ARRAY_POINTER_APPLE* = 0x00008A0E # GL_APPLE_fence - GL_DRAW_PIXELS_APPLE* = 0x00008A0A - GL_FENCE_APPLE* = 0x00008A0B # GL_APPLE_specular_vector - GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE* = 0x000085B0 # GL_APPLE_transform_hint - GL_TRANSFORM_HINT_APPLE* = 0x000085B1 # GL_APPLE_vertex_array_object - GL_VERTEX_ARRAY_BINDING_APPLE* = 0x000085B5 # GL_APPLE_vertex_array_range - cGL_VERTEX_ARRAY_RANGE_APPLE* = 0x0000851D - GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE* = 0x0000851E - GL_VERTEX_ARRAY_STORAGE_HINT_APPLE* = 0x0000851F - GL_VERTEX_ARRAY_RANGE_POINTER_APPLE* = 0x00008521 - GL_STORAGE_CLIENT_APPLE* = 0x000085B4 - GL_STORAGE_CACHED_APPLE* = 0x000085BE - GL_STORAGE_SHARED_APPLE* = 0x000085BF # GL_APPLE_ycbcr_422 - GL_YCBCR_422_APPLE* = 0x000085B9 - GL_UNSIGNED_SHORT_8_8_APPLE* = 0x000085BA - GL_UNSIGNED_SHORT_8_8_REV_APPLE* = 0x000085BB # GL_APPLE_texture_range - GL_TEXTURE_RANGE_LENGTH_APPLE* = 0x000085B7 - GL_TEXTURE_RANGE_POINTER_APPLE* = 0x000085B8 - GL_TEXTURE_STORAGE_HINT_APPLE* = 0x000085BC - GL_STORAGE_PRIVATE_APPLE* = 0x000085BD # reuse GL_STORAGE_CACHED_APPLE - # reuse GL_STORAGE_SHARED_APPLE - # GL_APPLE_float_pixels - GL_HALF_APPLE* = 0x0000140B - GL_RGBA_FLOAT32_APPLE* = 0x00008814 - GL_RGB_FLOAT32_APPLE* = 0x00008815 - GL_ALPHA_FLOAT32_APPLE* = 0x00008816 - GL_INTENSITY_FLOAT32_APPLE* = 0x00008817 - GL_LUMINANCE_FLOAT32_APPLE* = 0x00008818 - GL_LUMINANCE_ALPHA_FLOAT32_APPLE* = 0x00008819 - GL_RGBA_FLOAT16_APPLE* = 0x0000881A - GL_RGB_FLOAT16_APPLE* = 0x0000881B - GL_ALPHA_FLOAT16_APPLE* = 0x0000881C - GL_INTENSITY_FLOAT16_APPLE* = 0x0000881D - GL_LUMINANCE_FLOAT16_APPLE* = 0x0000881E - GL_LUMINANCE_ALPHA_FLOAT16_APPLE* = 0x0000881F - GL_COLOR_FLOAT_APPLE* = 0x00008A0F # GL_APPLE_vertex_program_evaluators - GL_VERTEX_ATTRIB_MAP1_APPLE* = 0x00008A00 - GL_VERTEX_ATTRIB_MAP2_APPLE* = 0x00008A01 - GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE* = 0x00008A02 - GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE* = 0x00008A03 - GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE* = 0x00008A04 - GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE* = 0x00008A05 - GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE* = 0x00008A06 - GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE* = 0x00008A07 - GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE* = 0x00008A08 - GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE* = 0x00008A09 # GL_APPLE_aux_depth_stencil - GL_AUX_DEPTH_STENCIL_APPLE* = 0x00008A14 # GL_APPLE_object_purgeable - GL_BUFFER_OBJECT_APPLE* = 0x000085B3 - GL_RELEASED_APPLE* = 0x00008A19 - GL_VOLATILE_APPLE* = 0x00008A1A - GL_RETAINED_APPLE* = 0x00008A1B - GL_UNDEFINED_APPLE* = 0x00008A1C - GL_PURGEABLE_APPLE* = 0x00008A1D # GL_APPLE_row_bytes - GL_PACK_ROW_BYTES_APPLE* = 0x00008A15 - GL_UNPACK_ROW_BYTES_APPLE* = 0x00008A16 # GL_APPLE_rgb_422 - # reuse GL_UNSIGNED_SHORT_8_8_APPLE - # reuse GL_UNSIGNED_SHORT_8_8_REV_APPLE - # GL_ARB_depth_texture - GL_DEPTH_COMPONENT16_ARB* = 0x000081A5 - GL_DEPTH_COMPONENT24_ARB* = 0x000081A6 - GL_DEPTH_COMPONENT32_ARB* = 0x000081A7 - GL_TEXTURE_DEPTH_SIZE_ARB* = 0x0000884A - GL_DEPTH_TEXTURE_MODE_ARB* = 0x0000884B # GL_ARB_fragment_program - GL_FRAGMENT_PROGRAM_ARB* = 0x00008804 - GL_PROGRAM_ALU_INSTRUCTIONS_ARB* = 0x00008805 - GL_PROGRAM_TEX_INSTRUCTIONS_ARB* = 0x00008806 - GL_PROGRAM_TEX_INDIRECTIONS_ARB* = 0x00008807 - GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB* = 0x00008808 - GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB* = 0x00008809 - GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB* = 0x0000880A - GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB* = 0x0000880B - GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB* = 0x0000880C - GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB* = 0x0000880D - GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB* = 0x0000880E - GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB* = 0x0000880F - GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB* = 0x00008810 - GL_MAX_TEXTURE_COORDS_ARB* = 0x00008871 - GL_MAX_TEXTURE_IMAGE_UNITS_ARB* = 0x00008872 # GL_ARB_imaging - GL_CONSTANT_COLOR_ARB* = 0x00008001 - GL_ONE_MINUS_CONSTANT_COLOR* = 0x00008002 - GL_CONSTANT_ALPHA* = 0x00008003 - GL_ONE_MINUS_CONSTANT_ALPHA* = 0x00008004 - cGL_BLEND_COLOR* = 0x00008005 - GL_FUNC_ADD* = 0x00008006 - GL_MIN* = 0x00008007 - GL_MAX* = 0x00008008 - cGL_BLEND_EQUATION* = 0x00008009 - GL_FUNC_SUBTRACT* = 0x0000800A - GL_FUNC_REVERSE_SUBTRACT* = 0x0000800B - GL_CONVOLUTION_1D* = 0x00008010 - GL_CONVOLUTION_2D* = 0x00008011 - GL_SEPARABLE_2D* = 0x00008012 - GL_CONVOLUTION_BORDER_MODE* = 0x00008013 - GL_CONVOLUTION_FILTER_SCALE* = 0x00008014 - GL_CONVOLUTION_FILTER_BIAS* = 0x00008015 - GL_REDUCE* = 0x00008016 - GL_CONVOLUTION_FORMAT* = 0x00008017 - GL_CONVOLUTION_WIDTH* = 0x00008018 - GL_CONVOLUTION_HEIGHT* = 0x00008019 - GL_MAX_CONVOLUTION_WIDTH* = 0x0000801A - GL_MAX_CONVOLUTION_HEIGHT* = 0x0000801B - GL_POST_CONVOLUTION_RED_SCALE* = 0x0000801C - GL_POST_CONVOLUTION_GREEN_SCALE* = 0x0000801D - GL_POST_CONVOLUTION_BLUE_SCALE* = 0x0000801E - GL_POST_CONVOLUTION_ALPHA_SCALE* = 0x0000801F - GL_POST_CONVOLUTION_RED_BIAS* = 0x00008020 - GL_POST_CONVOLUTION_GREEN_BIAS* = 0x00008021 - GL_POST_CONVOLUTION_BLUE_BIAS* = 0x00008022 - GL_POST_CONVOLUTION_ALPHA_BIAS* = 0x00008023 - cGL_HISTOGRAM* = 0x00008024 - GL_PROXY_HISTOGRAM* = 0x00008025 - GL_HISTOGRAM_WIDTH* = 0x00008026 - GL_HISTOGRAM_FORMAT* = 0x00008027 - GL_HISTOGRAM_RED_SIZE* = 0x00008028 - GL_HISTOGRAM_GREEN_SIZE* = 0x00008029 - GL_HISTOGRAM_BLUE_SIZE* = 0x0000802A - GL_HISTOGRAM_ALPHA_SIZE* = 0x0000802B - GL_HISTOGRAM_LUMINANCE_SIZE* = 0x0000802C - GL_HISTOGRAM_SINK* = 0x0000802D - cGL_MINMAX* = 0x0000802E - GL_MINMAX_FORMAT* = 0x0000802F - GL_MINMAX_SINK* = 0x00008030 - GL_TABLE_TOO_LARGE* = 0x00008031 - GL_COLOR_MATRIX* = 0x000080B1 - GL_COLOR_MATRIX_STACK_DEPTH* = 0x000080B2 - GL_MAX_COLOR_MATRIX_STACK_DEPTH* = 0x000080B3 - GL_POST_COLOR_MATRIX_RED_SCALE* = 0x000080B4 - GL_POST_COLOR_MATRIX_GREEN_SCALE* = 0x000080B5 - GL_POST_COLOR_MATRIX_BLUE_SCALE* = 0x000080B6 - GL_POST_COLOR_MATRIX_ALPHA_SCALE* = 0x000080B7 - GL_POST_COLOR_MATRIX_RED_BIAS* = 0x000080B8 - GL_POST_COLOR_MATRIX_GREEN_BIAS* = 0x000080B9 - GL_POST_COLOR_MATRIX_BLUE_BIAS* = 0x000080BA - GL_POST_COLOR_MATRIX_ALPHA_BIAS* = 0x000080BB - cGL_COLOR_TABLE* = 0x000080D0 - GL_POST_CONVOLUTION_COLOR_TABLE* = 0x000080D1 - GL_POST_COLOR_MATRIX_COLOR_TABLE* = 0x000080D2 - GL_PROXY_COLOR_TABLE* = 0x000080D3 - GL_PROXY_POST_CONVOLUTION_COLOR_TABLE* = 0x000080D4 - GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE* = 0x000080D5 - GL_COLOR_TABLE_SCALE* = 0x000080D6 - GL_COLOR_TABLE_BIAS* = 0x000080D7 - GL_COLOR_TABLE_FORMAT* = 0x000080D8 - GL_COLOR_TABLE_WIDTH* = 0x000080D9 - GL_COLOR_TABLE_RED_SIZE* = 0x000080DA - GL_COLOR_TABLE_GREEN_SIZE* = 0x000080DB - GL_COLOR_TABLE_BLUE_SIZE* = 0x000080DC - GL_COLOR_TABLE_ALPHA_SIZE* = 0x000080DD - GL_COLOR_TABLE_LUMINANCE_SIZE* = 0x000080DE - GL_COLOR_TABLE_INTENSITY_SIZE* = 0x000080DF - GL_CONSTANT_BORDER* = 0x00008151 - GL_REPLICATE_BORDER* = 0x00008153 - GL_CONVOLUTION_BORDER_COLOR* = 0x00008154 # GL_ARB_matrix_palette - GL_MATRIX_PALETTE_ARB* = 0x00008840 - GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB* = 0x00008841 - GL_MAX_PALETTE_MATRICES_ARB* = 0x00008842 - cGL_CURRENT_PALETTE_MATRIX_ARB* = 0x00008843 - GL_MATRIX_INDEX_ARRAY_ARB* = 0x00008844 - GL_CURRENT_MATRIX_INDEX_ARB* = 0x00008845 - GL_MATRIX_INDEX_ARRAY_SIZE_ARB* = 0x00008846 - GL_MATRIX_INDEX_ARRAYtyp_ARB* = 0x00008847 - GL_MATRIX_INDEX_ARRAY_STRIDE_ARB* = 0x00008848 - GL_MATRIX_INDEX_ARRAY_POINTER_ARB* = 0x00008849 # GL_ARB_multisample - GL_MULTISAMPLE_ARB* = 0x0000809D - GL_SAMPLE_ALPHA_TO_COVERAGE_ARB* = 0x0000809E - GL_SAMPLE_ALPHA_TO_ONE_ARB* = 0x0000809F - cGL_SAMPLE_COVERAGE_ARB* = 0x000080A0 - GL_SAMPLE_BUFFERS_ARB* = 0x000080A8 - GL_SAMPLES_ARB* = 0x000080A9 - GL_SAMPLE_COVERAGE_VALUE_ARB* = 0x000080AA - GL_SAMPLE_COVERAGE_INVERT_ARB* = 0x000080AB - GL_MULTISAMPLE_BIT_ARB* = 0x20000000 # GL_ARB_multitexture - GL_TEXTURE0_ARB* = 0x000084C0 - GL_TEXTURE1_ARB* = 0x000084C1 - GL_TEXTURE2_ARB* = 0x000084C2 - GL_TEXTURE3_ARB* = 0x000084C3 - GL_TEXTURE4_ARB* = 0x000084C4 - GL_TEXTURE5_ARB* = 0x000084C5 - GL_TEXTURE6_ARB* = 0x000084C6 - GL_TEXTURE7_ARB* = 0x000084C7 - GL_TEXTURE8_ARB* = 0x000084C8 - GL_TEXTURE9_ARB* = 0x000084C9 - GL_TEXTURE10_ARB* = 0x000084CA - GL_TEXTURE11_ARB* = 0x000084CB - GL_TEXTURE12_ARB* = 0x000084CC - GL_TEXTURE13_ARB* = 0x000084CD - GL_TEXTURE14_ARB* = 0x000084CE - GL_TEXTURE15_ARB* = 0x000084CF - GL_TEXTURE16_ARB* = 0x000084D0 - GL_TEXTURE17_ARB* = 0x000084D1 - GL_TEXTURE18_ARB* = 0x000084D2 - GL_TEXTURE19_ARB* = 0x000084D3 - GL_TEXTURE20_ARB* = 0x000084D4 - GL_TEXTURE21_ARB* = 0x000084D5 - GL_TEXTURE22_ARB* = 0x000084D6 - GL_TEXTURE23_ARB* = 0x000084D7 - GL_TEXTURE24_ARB* = 0x000084D8 - GL_TEXTURE25_ARB* = 0x000084D9 - GL_TEXTURE26_ARB* = 0x000084DA - GL_TEXTURE27_ARB* = 0x000084DB - GL_TEXTURE28_ARB* = 0x000084DC - GL_TEXTURE29_ARB* = 0x000084DD - GL_TEXTURE30_ARB* = 0x000084DE - GL_TEXTURE31_ARB* = 0x000084DF - cGL_ACTIVE_TEXTURE_ARB* = 0x000084E0 - cGL_CLIENT_ACTIVE_TEXTURE_ARB* = 0x000084E1 - GL_MAX_TEXTURE_UNITS_ARB* = 0x000084E2 # GL_ARB_point_parameters - GL_POINT_SIZE_MIN_ARB* = 0x00008126 - GL_POINT_SIZE_MAX_ARB* = 0x00008127 - GL_POINT_FADE_THRESHOLD_SIZE_ARB* = 0x00008128 - GL_POINT_DISTANCE_ATTENUATION_ARB* = 0x00008129 # GL_ARB_shadow - GL_TEXTURE_COMPARE_MODE_ARB* = 0x0000884C - GL_TEXTURE_COMPARE_FUNC_ARB* = 0x0000884D - GL_COMPARE_R_TO_TEXTURE_ARB* = 0x0000884E # GL_ARB_shadow_ambient - GL_TEXTURE_COMPARE_FAIL_VALUE_ARB* = 0x000080BF # GL_ARB_texture_border_clamp - GL_CLAMP_TO_BORDER_ARB* = 0x0000812D # GL_ARB_texture_compression - GL_COMPRESSED_ALPHA_ARB* = 0x000084E9 - GL_COMPRESSED_LUMINANCE_ARB* = 0x000084EA - GL_COMPRESSED_LUMINANCE_ALPHA_ARB* = 0x000084EB - GL_COMPRESSED_INTENSITY_ARB* = 0x000084EC - GL_COMPRESSED_RGB_ARB* = 0x000084ED - GL_COMPRESSED_RGBA_ARB* = 0x000084EE - GL_TEXTURE_COMPRESSION_HINT_ARB* = 0x000084EF - GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB* = 0x000086A0 - GL_TEXTURE_COMPRESSED_ARB* = 0x000086A1 - GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB* = 0x000086A2 - GL_COMPRESSED_TEXTURE_FORMATS_ARB* = 0x000086A3 # GL_ARB_texture_cube_map - GL_NORMAL_MAP_ARB* = 0x00008511 - GL_REFLECTION_MAP_ARB* = 0x00008512 - GL_TEXTURE_CUBE_MAP_ARB* = 0x00008513 - GL_TEXTURE_BINDING_CUBE_MAP_ARB* = 0x00008514 - GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB* = 0x00008515 - GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB* = 0x00008516 - GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB* = 0x00008517 - GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB* = 0x00008518 - GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB* = 0x00008519 - GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB* = 0x0000851A - GL_PROXY_TEXTURE_CUBE_MAP_ARB* = 0x0000851B - GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB* = 0x0000851C # GL_ARB_texture_env_combine - GL_COMBINE_ARB* = 0x00008570 - GL_COMBINE_RGB_ARB* = 0x00008571 - GL_COMBINE_ALPHA_ARB* = 0x00008572 - GL_SOURCE0_RGB_ARB* = 0x00008580 - GL_SOURCE1_RGB_ARB* = 0x00008581 - GL_SOURCE2_RGB_ARB* = 0x00008582 - GL_SOURCE0_ALPHA_ARB* = 0x00008588 - GL_SOURCE1_ALPHA_ARB* = 0x00008589 - GL_SOURCE2_ALPHA_ARB* = 0x0000858A - GL_OPERAND0_RGB_ARB* = 0x00008590 - GL_OPERAND1_RGB_ARB* = 0x00008591 - GL_OPERAND2_RGB_ARB* = 0x00008592 - GL_OPERAND0_ALPHA_ARB* = 0x00008598 - GL_OPERAND1_ALPHA_ARB* = 0x00008599 - GL_OPERAND2_ALPHA_ARB* = 0x0000859A - GL_RGB_SCALE_ARB* = 0x00008573 - GL_ADD_SIGNED_ARB* = 0x00008574 - GL_INTERPOLATE_ARB* = 0x00008575 - GL_SUBTRACT_ARB* = 0x000084E7 - GL_CONSTANT_ARB* = 0x00008576 - GL_PRIMARY_COLOR_ARB* = 0x00008577 - GL_PREVIOUS_ARB* = 0x00008578 # GL_ARB_texture_env_dot3 - GL_DOT3_RGB_ARB* = 0x000086AE - GL_DOT3_RGBA_ARB* = 0x000086AF # GL_ARB_texture_mirrored_repeat - GL_MIRRORED_REPEAT_ARB* = 0x00008370 # GL_ARB_transpose_matrix - GL_TRANSPOSE_MODELVIEW_MATRIX_ARB* = 0x000084E3 - GL_TRANSPOSE_PROJECTION_MATRIX_ARB* = 0x000084E4 - GL_TRANSPOSE_TEXTURE_MATRIX_ARB* = 0x000084E5 - GL_TRANSPOSE_COLOR_MATRIX_ARB* = 0x000084E6 # GL_ARB_vertex_blend - GL_MAX_VERTEX_UNITS_ARB* = 0x000086A4 - GL_ACTIVE_VERTEX_UNITS_ARB* = 0x000086A5 - GL_WEIGHT_SUM_UNITY_ARB* = 0x000086A6 - cGL_VERTEX_BLEND_ARB* = 0x000086A7 - GL_CURRENT_WEIGHT_ARB* = 0x000086A8 - GL_WEIGHT_ARRAYtyp_ARB* = 0x000086A9 - GL_WEIGHT_ARRAY_STRIDE_ARB* = 0x000086AA - GL_WEIGHT_ARRAY_SIZE_ARB* = 0x000086AB - GL_WEIGHT_ARRAY_POINTER_ARB* = 0x000086AC - GL_WEIGHT_ARRAY_ARB* = 0x000086AD - GL_MODELVIEW0_ARB* = 0x00001700 - GL_MODELVIEW1_ARB* = 0x0000850A - GL_MODELVIEW2_ARB* = 0x00008722 - GL_MODELVIEW3_ARB* = 0x00008723 - GL_MODELVIEW4_ARB* = 0x00008724 - GL_MODELVIEW5_ARB* = 0x00008725 - GL_MODELVIEW6_ARB* = 0x00008726 - GL_MODELVIEW7_ARB* = 0x00008727 - GL_MODELVIEW8_ARB* = 0x00008728 - GL_MODELVIEW9_ARB* = 0x00008729 - GL_MODELVIEW10_ARB* = 0x0000872A - GL_MODELVIEW11_ARB* = 0x0000872B - GL_MODELVIEW12_ARB* = 0x0000872C - GL_MODELVIEW13_ARB* = 0x0000872D - GL_MODELVIEW14_ARB* = 0x0000872E - GL_MODELVIEW15_ARB* = 0x0000872F - GL_MODELVIEW16_ARB* = 0x00008730 - GL_MODELVIEW17_ARB* = 0x00008731 - GL_MODELVIEW18_ARB* = 0x00008732 - GL_MODELVIEW19_ARB* = 0x00008733 - GL_MODELVIEW20_ARB* = 0x00008734 - GL_MODELVIEW21_ARB* = 0x00008735 - GL_MODELVIEW22_ARB* = 0x00008736 - GL_MODELVIEW23_ARB* = 0x00008737 - GL_MODELVIEW24_ARB* = 0x00008738 - GL_MODELVIEW25_ARB* = 0x00008739 - GL_MODELVIEW26_ARB* = 0x0000873A - GL_MODELVIEW27_ARB* = 0x0000873B - GL_MODELVIEW28_ARB* = 0x0000873C - GL_MODELVIEW29_ARB* = 0x0000873D - GL_MODELVIEW30_ARB* = 0x0000873E - GL_MODELVIEW31_ARB* = 0x0000873F # GL_ARB_vertex_buffer_object - GL_BUFFER_SIZE_ARB* = 0x00008764 - GL_BUFFER_USAGE_ARB* = 0x00008765 - GL_ARRAY_BUFFER_ARB* = 0x00008892 - GL_ELEMENT_ARRAY_BUFFER_ARB* = 0x00008893 - GL_ARRAY_BUFFER_BINDING_ARB* = 0x00008894 - GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB* = 0x00008895 - GL_VERTEX_ARRAY_BUFFER_BINDING_ARB* = 0x00008896 - GL_NORMAL_ARRAY_BUFFER_BINDING_ARB* = 0x00008897 - GL_COLOR_ARRAY_BUFFER_BINDING_ARB* = 0x00008898 - GL_INDEX_ARRAY_BUFFER_BINDING_ARB* = 0x00008899 - GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB* = 0x0000889A - GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB* = 0x0000889B - GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB* = 0x0000889C - GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB* = 0x0000889D - GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB* = 0x0000889E - GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB* = 0x0000889F - GL_READ_ONLY_ARB* = 0x000088B8 - GL_WRITE_ONLY_ARB* = 0x000088B9 - GL_READ_WRITE_ARB* = 0x000088BA - GL_BUFFER_ACCESS_ARB* = 0x000088BB - GL_BUFFER_MAPPED_ARB* = 0x000088BC - GL_BUFFER_MAP_POINTER_ARB* = 0x000088BD - GL_STREAM_DRAW_ARB* = 0x000088E0 - GL_STREAM_READ_ARB* = 0x000088E1 - GL_STREAM_COPY_ARB* = 0x000088E2 - GL_STATIC_DRAW_ARB* = 0x000088E4 - GL_STATIC_READ_ARB* = 0x000088E5 - GL_STATIC_COPY_ARB* = 0x000088E6 - GL_DYNAMIC_DRAW_ARB* = 0x000088E8 - GL_DYNAMIC_READ_ARB* = 0x000088E9 - GL_DYNAMIC_COPY_ARB* = 0x000088EA # GL_ARB_vertex_program - GL_COLOR_SUM_ARB* = 0x00008458 - GL_VERTEX_PROGRAM_ARB* = 0x00008620 - GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB* = 0x00008622 - GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB* = 0x00008623 - GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB* = 0x00008624 - GL_VERTEX_ATTRIB_ARRAYtyp_ARB* = 0x00008625 - GL_CURRENT_VERTEX_ATTRIB_ARB* = 0x00008626 - GL_PROGRAM_LENGTH_ARB* = 0x00008627 - cGL_PROGRAM_STRING_ARB* = 0x00008628 - GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB* = 0x0000862E - GL_MAX_PROGRAM_MATRICES_ARB* = 0x0000862F - GL_CURRENT_MATRIX_STACK_DEPTH_ARB* = 0x00008640 - GL_CURRENT_MATRIX_ARB* = 0x00008641 - GL_VERTEX_PROGRAM_POINT_SIZE_ARB* = 0x00008642 - GL_VERTEX_PROGRAM_TWO_SIDE_ARB* = 0x00008643 - GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB* = 0x00008645 - GL_PROGRAM_ERROR_POSITION_ARB* = 0x0000864B - GL_PROGRAM_BINDING_ARB* = 0x00008677 - GL_MAX_VERTEX_ATTRIBS_ARB* = 0x00008869 - GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB* = 0x0000886A - GL_PROGRAM_ERROR_STRING_ARB* = 0x00008874 - GL_PROGRAM_FORMAT_ASCII_ARB* = 0x00008875 - GL_PROGRAM_FORMAT_ARB* = 0x00008876 - GL_PROGRAM_INSTRUCTIONS_ARB* = 0x000088A0 - GL_MAX_PROGRAM_INSTRUCTIONS_ARB* = 0x000088A1 - GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB* = 0x000088A2 - GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB* = 0x000088A3 - GL_PROGRAM_TEMPORARIES_ARB* = 0x000088A4 - GL_MAX_PROGRAM_TEMPORARIES_ARB* = 0x000088A5 - GL_PROGRAM_NATIVE_TEMPORARIES_ARB* = 0x000088A6 - GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB* = 0x000088A7 - GL_PROGRAM_PARAMETERS_ARB* = 0x000088A8 - GL_MAX_PROGRAM_PARAMETERS_ARB* = 0x000088A9 - GL_PROGRAM_NATIVE_PARAMETERS_ARB* = 0x000088AA - GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB* = 0x000088AB - GL_PROGRAM_ATTRIBS_ARB* = 0x000088AC - GL_MAX_PROGRAM_ATTRIBS_ARB* = 0x000088AD - GL_PROGRAM_NATIVE_ATTRIBS_ARB* = 0x000088AE - GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB* = 0x000088AF - GL_PROGRAM_ADDRESS_REGISTERS_ARB* = 0x000088B0 - GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB* = 0x000088B1 - GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB* = 0x000088B2 - GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB* = 0x000088B3 - GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB* = 0x000088B4 - GL_MAX_PROGRAM_ENV_PARAMETERS_ARB* = 0x000088B5 - GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB* = 0x000088B6 - GL_TRANSPOSE_CURRENT_MATRIX_ARB* = 0x000088B7 - GL_MATRIX0_ARB* = 0x000088C0 - GL_MATRIX1_ARB* = 0x000088C1 - GL_MATRIX2_ARB* = 0x000088C2 - GL_MATRIX3_ARB* = 0x000088C3 - GL_MATRIX4_ARB* = 0x000088C4 - GL_MATRIX5_ARB* = 0x000088C5 - GL_MATRIX6_ARB* = 0x000088C6 - GL_MATRIX7_ARB* = 0x000088C7 - GL_MATRIX8_ARB* = 0x000088C8 - GL_MATRIX9_ARB* = 0x000088C9 - GL_MATRIX10_ARB* = 0x000088CA - GL_MATRIX11_ARB* = 0x000088CB - GL_MATRIX12_ARB* = 0x000088CC - GL_MATRIX13_ARB* = 0x000088CD - GL_MATRIX14_ARB* = 0x000088CE - GL_MATRIX15_ARB* = 0x000088CF - GL_MATRIX16_ARB* = 0x000088D0 - GL_MATRIX17_ARB* = 0x000088D1 - GL_MATRIX18_ARB* = 0x000088D2 - GL_MATRIX19_ARB* = 0x000088D3 - GL_MATRIX20_ARB* = 0x000088D4 - GL_MATRIX21_ARB* = 0x000088D5 - GL_MATRIX22_ARB* = 0x000088D6 - GL_MATRIX23_ARB* = 0x000088D7 - GL_MATRIX24_ARB* = 0x000088D8 - GL_MATRIX25_ARB* = 0x000088D9 - GL_MATRIX26_ARB* = 0x000088DA - GL_MATRIX27_ARB* = 0x000088DB - GL_MATRIX28_ARB* = 0x000088DC - GL_MATRIX29_ARB* = 0x000088DD - GL_MATRIX30_ARB* = 0x000088DE - GL_MATRIX31_ARB* = 0x000088DF # GL_ARB_draw_buffers - GL_MAX_DRAW_BUFFERS_ARB* = 0x00008824 - GL_DRAW_BUFFER0_ARB* = 0x00008825 - GL_DRAW_BUFFER1_ARB* = 0x00008826 - GL_DRAW_BUFFER2_ARB* = 0x00008827 - GL_DRAW_BUFFER3_ARB* = 0x00008828 - GL_DRAW_BUFFER4_ARB* = 0x00008829 - GL_DRAW_BUFFER5_ARB* = 0x0000882A - GL_DRAW_BUFFER6_ARB* = 0x0000882B - GL_DRAW_BUFFER7_ARB* = 0x0000882C - GL_DRAW_BUFFER8_ARB* = 0x0000882D - GL_DRAW_BUFFER9_ARB* = 0x0000882E - GL_DRAW_BUFFER10_ARB* = 0x0000882F - GL_DRAW_BUFFER11_ARB* = 0x00008830 - GL_DRAW_BUFFER12_ARB* = 0x00008831 - GL_DRAW_BUFFER13_ARB* = 0x00008832 - GL_DRAW_BUFFER14_ARB* = 0x00008833 - GL_DRAW_BUFFER15_ARB* = 0x00008834 # GL_ARB_texture_rectangle - GL_TEXTURE_RECTANGLE_ARB* = 0x000084F5 - GL_TEXTURE_BINDING_RECTANGLE_ARB* = 0x000084F6 - GL_PROXY_TEXTURE_RECTANGLE_ARB* = 0x000084F7 - GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB* = 0x000084F8 # GL_ARB_color_buffer_float - GL_RGBA_FLOAT_MODE_ARB* = 0x00008820 - GL_CLAMP_VERTEX_COLOR_ARB* = 0x0000891A - GL_CLAMP_FRAGMENT_COLOR_ARB* = 0x0000891B - GL_CLAMP_READ_COLOR_ARB* = 0x0000891C - GL_FIXED_ONLY_ARB* = 0x0000891D - WGLtyp_RGBA_FLOAT_ARB* = 0x000021A0 - GLX_RGBA_FLOATtyp* = 0x000020B9 - GLX_RGBA_FLOAT_BIT* = 0x00000004 # GL_ARB_half_float_pixel - GL_HALF_FLOAT_ARB* = 0x0000140B # GL_ARB_texture_float - GL_TEXTURE_REDtyp_ARB* = 0x00008C10 - GL_TEXTURE_GREENtyp_ARB* = 0x00008C11 - GL_TEXTURE_BLUEtyp_ARB* = 0x00008C12 - GL_TEXTURE_ALPHAtyp_ARB* = 0x00008C13 - GL_TEXTURE_LUMINANCEtyp_ARB* = 0x00008C14 - GL_TEXTURE_INTENSITYtyp_ARB* = 0x00008C15 - GL_TEXTURE_DEPTHtyp_ARB* = 0x00008C16 - GL_UNSIGNED_NORMALIZED_ARB* = 0x00008C17 - GL_RGBA32F_ARB* = 0x00008814 - GL_RGB32F_ARB* = 0x00008815 - GL_ALPHA32F_ARB* = 0x00008816 - GL_INTENSITY32F_ARB* = 0x00008817 - GL_LUMINANCE32F_ARB* = 0x00008818 - GL_LUMINANCE_ALPHA32F_ARB* = 0x00008819 - GL_RGBA16F_ARB* = 0x0000881A - GL_RGB16F_ARB* = 0x0000881B - GL_ALPHA16F_ARB* = 0x0000881C - GL_INTENSITY16F_ARB* = 0x0000881D - GL_LUMINANCE16F_ARB* = 0x0000881E - GL_LUMINANCE_ALPHA16F_ARB* = 0x0000881F # GL_ARB_pixel_buffer_object - GL_PIXEL_PACK_BUFFER_ARB* = 0x000088EB - GL_PIXEL_UNPACK_BUFFER_ARB* = 0x000088EC - GL_PIXEL_PACK_BUFFER_BINDING_ARB* = 0x000088ED - GL_PIXEL_UNPACK_BUFFER_BINDING_ARB* = 0x000088EF # GL_ARB_depth_buffer_float - GL_DEPTH_COMPONENT32F* = 0x00008CAC - GL_DEPTH32F_STENCIL8* = 0x00008CAD - GL_FLOAT_32_UNSIGNED_INT_24_8_REV* = 0x00008DAD # GL_ARB_framebuffer_object - GL_INVALID_FRAMEBUFFER_OPERATION* = 0x00000506 - GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING* = 0x00008210 - GL_FRAMEBUFFER_ATTACHMENT_COMPONENTtyp* = 0x00008211 - GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE* = 0x00008212 - GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE* = 0x00008213 - GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE* = 0x00008214 - GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE* = 0x00008215 - GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE* = 0x00008216 - GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE* = 0x00008217 - GL_FRAMEBUFFER_DEFAULT* = 0x00008218 - GL_FRAMEBUFFER_UNDEFINED* = 0x00008219 - GL_DEPTH_STENCIL_ATTACHMENT* = 0x0000821A - GL_MAX_RENDERBUFFER_SIZE* = 0x000084E8 - GL_DEPTH_STENCIL* = 0x000084F9 - GL_UNSIGNED_INT_24_8* = 0x000084FA - GL_DEPTH24_STENCIL8* = 0x000088F0 - GL_TEXTURE_STENCIL_SIZE* = 0x000088F1 - GL_TEXTURE_REDtyp* = 0x00008C10 - GL_TEXTURE_GREENtyp* = 0x00008C11 - GL_TEXTURE_BLUEtyp* = 0x00008C12 - GL_TEXTURE_ALPHAtyp* = 0x00008C13 - GL_TEXTURE_DEPTHtyp* = 0x00008C16 - GL_UNSIGNED_NORMALIZED* = 0x00008C17 - GL_FRAMEBUFFER_BINDING* = 0x00008CA6 - GL_DRAW_FRAMEBUFFER_BINDING* = GL_FRAMEBUFFER_BINDING - GL_RENDERBUFFER_BINDING* = 0x00008CA7 - GL_READ_FRAMEBUFFER* = 0x00008CA8 - GL_DRAW_FRAMEBUFFER* = 0x00008CA9 - GL_READ_FRAMEBUFFER_BINDING* = 0x00008CAA - GL_RENDERBUFFER_SAMPLES* = 0x00008CAB - GL_FRAMEBUFFER_ATTACHMENT_OBJECTtyp* = 0x00008CD0 - GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME* = 0x00008CD1 - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL* = 0x00008CD2 - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE* = 0x00008CD3 - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER* = 0x00008CD4 - GL_FRAMEBUFFER_COMPLETE* = 0x00008CD5 - GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT* = 0x00008CD6 - GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT* = 0x00008CD7 - GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER* = 0x00008CDB - GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER* = 0x00008CDC - GL_FRAMEBUFFER_UNSUPPORTED* = 0x00008CDD - GL_MAX_COLOR_ATTACHMENTS* = 0x00008CDF - GL_COLOR_ATTACHMENT0* = 0x00008CE0 - GL_COLOR_ATTACHMENT1* = 0x00008CE1 - GL_COLOR_ATTACHMENT2* = 0x00008CE2 - GL_COLOR_ATTACHMENT3* = 0x00008CE3 - GL_COLOR_ATTACHMENT4* = 0x00008CE4 - GL_COLOR_ATTACHMENT5* = 0x00008CE5 - GL_COLOR_ATTACHMENT6* = 0x00008CE6 - GL_COLOR_ATTACHMENT7* = 0x00008CE7 - GL_COLOR_ATTACHMENT8* = 0x00008CE8 - GL_COLOR_ATTACHMENT9* = 0x00008CE9 - GL_COLOR_ATTACHMENT10* = 0x00008CEA - GL_COLOR_ATTACHMENT11* = 0x00008CEB - GL_COLOR_ATTACHMENT12* = 0x00008CEC - GL_COLOR_ATTACHMENT13* = 0x00008CED - GL_COLOR_ATTACHMENT14* = 0x00008CEE - GL_COLOR_ATTACHMENT15* = 0x00008CEF - GL_DEPTH_ATTACHMENT* = 0x00008D00 - GL_STENCIL_ATTACHMENT* = 0x00008D20 - GL_FRAMEBUFFER* = 0x00008D40 - GL_RENDERBUFFER* = 0x00008D41 - GL_RENDERBUFFER_WIDTH* = 0x00008D42 - GL_RENDERBUFFER_HEIGHT* = 0x00008D43 - GL_RENDERBUFFER_INTERNAL_FORMAT* = 0x00008D44 - GL_STENCIL_INDEX1* = 0x00008D46 - GL_STENCIL_INDEX4* = 0x00008D47 - GL_STENCIL_INDEX8* = 0x00008D48 - GL_STENCIL_INDEX16* = 0x00008D49 - GL_RENDERBUFFER_RED_SIZE* = 0x00008D50 - GL_RENDERBUFFER_GREEN_SIZE* = 0x00008D51 - GL_RENDERBUFFER_BLUE_SIZE* = 0x00008D52 - GL_RENDERBUFFER_ALPHA_SIZE* = 0x00008D53 - GL_RENDERBUFFER_DEPTH_SIZE* = 0x00008D54 - GL_RENDERBUFFER_STENCIL_SIZE* = 0x00008D55 - GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE* = 0x00008D56 - GL_MAX_SAMPLES* = 0x00008D57 - GL_INDEX* = 0x00008222 - GL_TEXTURE_LUMINANCEtyp* = 0x00008C14 - GL_TEXTURE_INTENSITYtyp* = 0x00008C15 # GL_ARB_framebuffer_sRGB - GL_FRAMEBUFFER_SRGB* = 0x00008DB9 # GL_ARB_geometry_shader4 - GL_LINES_ADJACENCY_ARB* = 0x0000000A - GL_LINE_STRIP_ADJACENCY_ARB* = 0x0000000B - GL_TRIANGLES_ADJACENCY_ARB* = 0x0000000C - GL_TRIANGLE_STRIP_ADJACENCY_ARB* = 0x0000000D - GL_PROGRAM_POINT_SIZE_ARB* = 0x00008642 - GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB* = 0x00008C29 - GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB* = 0x00008DA7 - GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB* = 0x00008DA8 - GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB* = 0x00008DA9 - GL_GEOMETRY_SHADER_ARB* = 0x00008DD9 - GL_GEOMETRY_VERTICES_OUT_ARB* = 0x00008DDA - GL_GEOMETRY_INPUTtyp_ARB* = 0x00008DDB - GL_GEOMETRY_OUTPUTtyp_ARB* = 0x00008DDC - GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB* = 0x00008DDD - GL_MAX_VERTEX_VARYING_COMPONENTS_ARB* = 0x00008DDE - GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB* = 0x00008DDF - GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB* = 0x00008DE0 - GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB* = 0x00008DE1 # reuse - # GL_MAX_VARYING_COMPONENTS - # reuse - # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER - # - # GL_ARB_half_float_vertex - GL_HALF_FLOAT* = 0x0000140B # GL_ARB_instanced_arrays - GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB* = 0x000088FE # GL_ARB_map_buffer_range - GL_MAP_READ_BIT* = 0x00000001 - GL_MAP_WRITE_BIT* = 0x00000002 - GL_MAP_INVALIDATE_RANGE_BIT* = 0x00000004 - GL_MAP_INVALIDATE_BUFFER_BIT* = 0x00000008 - GL_MAP_FLUSH_EXPLICIT_BIT* = 0x00000010 - GL_MAP_UNSYNCHRONIZED_BIT* = 0x00000020 # GL_ARB_texture_buffer_object - GL_TEXTURE_BUFFER_ARB* = 0x00008C2A - GL_MAX_TEXTURE_BUFFER_SIZE_ARB* = 0x00008C2B - GL_TEXTURE_BINDING_BUFFER_ARB* = 0x00008C2C - GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB* = 0x00008C2D - GL_TEXTURE_BUFFER_FORMAT_ARB* = 0x00008C2E # GL_ARB_texture_compression_rgtc - GL_COMPRESSED_RED_RGTC1* = 0x00008DBB - GL_COMPRESSED_SIGNED_RED_RGTC1* = 0x00008DBC - GL_COMPRESSED_RG_RGTC2* = 0x00008DBD - GL_COMPRESSED_SIGNED_RG_RGTC2* = 0x00008DBE # GL_ARB_texture_rg - GL_RG* = 0x00008227 - GL_RG_INTEGER* = 0x00008228 - GL_R8* = 0x00008229 - GL_R16* = 0x0000822A - GL_RG8* = 0x0000822B - GL_RG16* = 0x0000822C - GL_R16F* = 0x0000822D - GL_R32F* = 0x0000822E - GL_RG16F* = 0x0000822F - GL_RG32F* = 0x00008230 - GL_R8I* = 0x00008231 - GL_R8UI* = 0x00008232 - GL_R16I* = 0x00008233 - GL_R16UI* = 0x00008234 - GL_R32I* = 0x00008235 - GL_R32UI* = 0x00008236 - GL_RG8I* = 0x00008237 - GL_RG8UI* = 0x00008238 - GL_RG16I* = 0x00008239 - GL_RG16UI* = 0x0000823A - GL_RG32I* = 0x0000823B - GL_RG32UI* = 0x0000823C # GL_ARB_vertex_array_object - GL_VERTEX_ARRAY_BINDING* = 0x000085B5 # GL_ARB_uniform_buffer_object - GL_UNIFORM_BUFFER* = 0x00008A11 - GL_UNIFORM_BUFFER_BINDING* = 0x00008A28 - GL_UNIFORM_BUFFER_START* = 0x00008A29 - GL_UNIFORM_BUFFER_SIZE* = 0x00008A2A - GL_MAX_VERTEX_UNIFORM_BLOCKS* = 0x00008A2B - GL_MAX_GEOMETRY_UNIFORM_BLOCKS* = 0x00008A2C - GL_MAX_FRAGMENT_UNIFORM_BLOCKS* = 0x00008A2D - GL_MAX_COMBINED_UNIFORM_BLOCKS* = 0x00008A2E - GL_MAX_UNIFORM_BUFFER_BINDINGS* = 0x00008A2F - GL_MAX_UNIFORM_BLOCK_SIZE* = 0x00008A30 - GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS* = 0x00008A31 - GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS* = 0x00008A32 - GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS* = 0x00008A33 - GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT* = 0x00008A34 - GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH* = 0x00008A35 - GL_ACTIVE_UNIFORM_BLOCKS* = 0x00008A36 - GL_UNIFORMtyp* = 0x00008A37 - GL_UNIFORM_SIZE* = 0x00008A38 - GL_UNIFORM_NAME_LENGTH* = 0x00008A39 - GL_UNIFORM_BLOCK_INDEX* = 0x00008A3A - GL_UNIFORM_OFFSET* = 0x00008A3B - GL_UNIFORM_ARRAY_STRIDE* = 0x00008A3C - GL_UNIFORM_MATRIX_STRIDE* = 0x00008A3D - GL_UNIFORM_IS_ROW_MAJOR* = 0x00008A3E - cGL_UNIFORM_BLOCK_BINDING* = 0x00008A3F - GL_UNIFORM_BLOCK_DATA_SIZE* = 0x00008A40 - GL_UNIFORM_BLOCK_NAME_LENGTH* = 0x00008A41 - GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS* = 0x00008A42 - GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES* = 0x00008A43 - GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER* = 0x00008A44 - GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER* = 0x00008A45 - GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER* = 0x00008A46 - GL_INVALID_INDEX* = 0xFFFFFFFF # GL_ARB_compatibility - # ARB_compatibility just defines tokens from core 3.0 - # GL_ARB_copy_buffer - GL_COPY_READ_BUFFER* = 0x00008F36 - GL_COPY_WRITE_BUFFER* = 0x00008F37 # GL_ARB_depth_clamp - GL_DEPTH_CLAMP* = 0x0000864F # GL_ARB_provoking_vertex - GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION* = 0x00008E4C - GL_FIRST_VERTEX_CONVENTION* = 0x00008E4D - GL_LAST_VERTEX_CONVENTION* = 0x00008E4E - cGL_PROVOKING_VERTEX* = 0x00008E4F # GL_ARB_seamless_cube_map - GL_TEXTURE_CUBE_MAP_SEAMLESS* = 0x0000884F # GL_ARB_sync - GL_MAX_SERVER_WAIT_TIMEOUT* = 0x00009111 - GL_OBJECTtyp* = 0x00009112 - GL_SYNC_CONDITION* = 0x00009113 - GL_SYNC_STATUS* = 0x00009114 - GL_SYNC_FLAGS* = 0x00009115 - GL_SYNC_FENCE* = 0x00009116 - GL_SYNC_GPU_COMMANDS_COMPLETE* = 0x00009117 - GL_UNSIGNALED* = 0x00009118 - GL_SIGNALED* = 0x00009119 - GL_ALREADY_SIGNALED* = 0x0000911A - GL_TIMEOUT_EXPIRED* = 0x0000911B - GL_CONDITION_SATISFIED* = 0x0000911C - GL_WAIT_FAILED* = 0x0000911D - GL_SYNC_FLUSH_COMMANDS_BIT* = 0x00000001 - GL_TIMEOUT_IGNORED* = int64(- 1) # GL_ARB_texture_multisample - GL_SAMPLE_POSITION* = 0x00008E50 - GL_SAMPLE_MASK* = 0x00008E51 - GL_SAMPLE_MASK_VALUE* = 0x00008E52 - GL_MAX_SAMPLE_MASK_WORDS* = 0x00008E59 - GL_TEXTURE_2D_MULTISAMPLE* = 0x00009100 - GL_PROXY_TEXTURE_2D_MULTISAMPLE* = 0x00009101 - GL_TEXTURE_2D_MULTISAMPLE_ARRAY* = 0x00009102 - GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY* = 0x00009103 - GL_TEXTURE_BINDING_2D_MULTISAMPLE* = 0x00009104 - GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY* = 0x00009105 - GL_TEXTURE_SAMPLES* = 0x00009106 - GL_TEXTURE_FIXED_SAMPLE_LOCATIONS* = 0x00009107 - GL_SAMPLER_2D_MULTISAMPLE* = 0x00009108 - GL_INT_SAMPLER_2D_MULTISAMPLE* = 0x00009109 - GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE* = 0x0000910A - GL_SAMPLER_2D_MULTISAMPLE_ARRAY* = 0x0000910B - GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY* = 0x0000910C - GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY* = 0x0000910D - GL_MAX_COLOR_TEXTURE_SAMPLES* = 0x0000910E - GL_MAX_DEPTH_TEXTURE_SAMPLES* = 0x0000910F - GL_MAX_INTEGER_SAMPLES* = 0x00009110 # GL_ARB_vertex_array_bgra - # reuse GL_BGRA - # GL_ARB_sample_shading - GL_SAMPLE_SHADING_ARB* = 0x00008C36 - GL_MIN_SAMPLE_SHADING_VALUE_ARB* = 0x00008C37 # GL_ARB_texture_cube_map_array - GL_TEXTURE_CUBE_MAP_ARRAY_ARB* = 0x00009009 - GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB* = 0x0000900A - GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB* = 0x0000900B - GL_SAMPLER_CUBE_MAP_ARRAY_ARB* = 0x0000900C - GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB* = 0x0000900D - GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB* = 0x0000900E - GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB* = 0x0000900F # GL_ARB_texture_gather - GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB* = 0x00008E5E - GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB* = 0x00008E5F # - # GL_ARB_shading_language_include - GL_SHADER_INCLUDE_ARB* = 0x00008DAE - GL_NAMED_STRING_LENGTH_ARB* = 0x00008DE9 - GL_NAMED_STRINGtyp_ARB* = 0x00008DEA # GL_ARB_texture_compression_bptc - GL_COMPRESSED_RGBA_BPTC_UNORM_ARB* = 0x00008E8C - GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB* = 0x00008E8D - GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB* = 0x00008E8E - GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB* = 0x00008E8F # - # GL_ARB_blend_func_extended - GL_SRC1_COLOR* = 0x000088F9 # reuse GL_SRC1_ALPHA - GL_ONE_MINUS_SRC1_COLOR* = 0x000088FA - GL_ONE_MINUS_SRC1_ALPHA* = 0x000088FB - GL_MAX_DUAL_SOURCE_DRAW_BUFFERS* = 0x000088FC # GL_ARB_occlusion_query2 - GL_ANY_SAMPLES_PASSED* = 0x00008C2F # GL_ARB_sampler_objects - GL_SAMPLER_BINDING* = 0x00008919 # GL_ARB_texture_rgb10_a2ui - GL_RGB10_A2UI* = 0x0000906F # GL_ARB_texture_swizzle - GL_TEXTURE_SWIZZLE_R* = 0x00008E42 - GL_TEXTURE_SWIZZLE_G* = 0x00008E43 - GL_TEXTURE_SWIZZLE_B* = 0x00008E44 - GL_TEXTURE_SWIZZLE_A* = 0x00008E45 - GL_TEXTURE_SWIZZLE_RGBA* = 0x00008E46 # GL_ARB_timer_query - GL_TIME_ELAPSED* = 0x000088BF - GL_TIMESTAMP* = 0x00008E28 # GL_ARB_vertextyp_2_10_10_10_rev - # reuse GL_UNSIGNED_INT_2_10_10_10_REV - GL_INT_2_10_10_10_REV* = 0x00008D9F # GL_ARB_draw_indirect - GL_DRAW_INDIRECT_BUFFER* = 0x00008F3F - GL_DRAW_INDIRECT_BUFFER_BINDING* = 0x00008F43 # GL_ARB_gpu_shader5 - GL_GEOMETRY_SHADER_INVOCATIONS* = 0x0000887F - GL_MAX_GEOMETRY_SHADER_INVOCATIONS* = 0x00008E5A - GL_MIN_FRAGMENT_INTERPOLATION_OFFSET* = 0x00008E5B - GL_MAX_FRAGMENT_INTERPOLATION_OFFSET* = 0x00008E5C - GL_FRAGMENT_INTERPOLATION_OFFSET_BITS* = 0x00008E5D # reuse GL_MAX_VERTEX_STREAMS - # GL_ARB_gpu_shader_fp64 - # reuse GL_DOUBLE - GL_DOUBLE_VEC2* = 0x00008FFC - GL_DOUBLE_VEC3* = 0x00008FFD - GL_DOUBLE_VEC4* = 0x00008FFE - GL_DOUBLE_MAT2* = 0x00008F46 - GL_DOUBLE_MAT3* = 0x00008F47 - GL_DOUBLE_MAT4* = 0x00008F48 - GL_DOUBLE_MAT2x3* = 0x00008F49 - GL_DOUBLE_MAT2x4* = 0x00008F4A - GL_DOUBLE_MAT3x2* = 0x00008F4B - GL_DOUBLE_MAT3x4* = 0x00008F4C - GL_DOUBLE_MAT4x2* = 0x00008F4D - GL_DOUBLE_MAT4x3* = 0x00008F4E # GL_ARB_shader_subroutine - GL_ACTIVE_SUBROUTINES* = 0x00008DE5 - GL_ACTIVE_SUBROUTINE_UNIFORMS* = 0x00008DE6 - GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS* = 0x00008E47 - GL_ACTIVE_SUBROUTINE_MAX_LENGTH* = 0x00008E48 - GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH* = 0x00008E49 - GL_MAX_SUBROUTINES* = 0x00008DE7 - GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS* = 0x00008DE8 - GL_NUM_COMPATIBLE_SUBROUTINES* = 0x00008E4A - GL_COMPATIBLE_SUBROUTINES* = 0x00008E4B # GL_ARB_tessellation_shader - GL_PATCHES* = 0x0000000E - GL_PATCH_VERTICES* = 0x00008E72 - GL_PATCH_DEFAULT_INNER_LEVEL* = 0x00008E73 - GL_PATCH_DEFAULT_OUTER_LEVEL* = 0x00008E74 - GL_TESS_CONTROL_OUTPUT_VERTICES* = 0x00008E75 - GL_TESS_GEN_MODE* = 0x00008E76 - GL_TESS_GEN_SPACING* = 0x00008E77 - GL_TESS_GEN_VERTEX_ORDER* = 0x00008E78 - GL_TESS_GEN_POINT_MODE* = 0x00008E79 - GL_ISOLINES* = 0x00008E7A # reuse GL_EQUAL - GL_FRACTIONAL_ODD* = 0x00008E7B - GL_FRACTIONAL_EVEN* = 0x00008E7C - GL_MAX_PATCH_VERTICES* = 0x00008E7D - GL_MAX_TESS_GEN_LEVEL* = 0x00008E7E - GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS* = 0x00008E7F - GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS* = 0x00008E80 - GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS* = 0x00008E81 - GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS* = 0x00008E82 - GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS* = 0x00008E83 - GL_MAX_TESS_PATCH_COMPONENTS* = 0x00008E84 - GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS* = 0x00008E85 - GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS* = 0x00008E86 - GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS* = 0x00008E89 - GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS* = 0x00008E8A - GL_MAX_TESS_CONTROL_INPUT_COMPONENTS* = 0x0000886C - GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS* = 0x0000886D - GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS* = 0x00008E1E - GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS* = 0x00008E1F - GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER* = 0x000084F0 - GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER* = 0x000084F1 - GL_TESS_EVALUATION_SHADER* = 0x00008E87 - GL_TESS_CONTROL_SHADER* = 0x00008E88 # GL_ARB_texture_buffer_object_rgb32 - # GL_ARB_transform_feedback2 - GL_TRANSFORM_FEEDBACK* = 0x00008E22 - GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED* = 0x00008E23 - GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE* = 0x00008E24 - GL_TRANSFORM_FEEDBACK_BINDING* = 0x00008E25 # GL_ARB_transform_feedback3 - GL_MAX_TRANSFORM_FEEDBACK_BUFFERS* = 0x00008E70 - GL_MAX_VERTEX_STREAMS* = 0x00008E71 # GL_ARB_ES2_compatibility - GL_FIXED* = 0x0000140C - GL_IMPLEMENTATION_COLOR_READtyp* = 0x00008B9A - GL_IMPLEMENTATION_COLOR_READ_FORMAT* = 0x00008B9B - GL_LOW_FLOAT* = 0x00008DF0 - GL_MEDIUM_FLOAT* = 0x00008DF1 - GL_HIGH_FLOAT* = 0x00008DF2 - GL_LOW_INT* = 0x00008DF3 - GL_MEDIUM_INT* = 0x00008DF4 - GL_HIGH_INT* = 0x00008DF5 - GL_SHADER_COMPILER* = 0x00008DFA - GL_NUM_SHADER_BINARY_FORMATS* = 0x00008DF9 - GL_MAX_VERTEX_UNIFORM_VECTORS* = 0x00008DFB - GL_MAX_VARYING_VECTORS* = 0x00008DFC - GL_MAX_FRAGMENT_UNIFORM_VECTORS* = 0x00008DFD # GL_ARB_get_program_binary - GL_PROGRAM_BINARY_RETRIEVABLE_HINT* = 0x00008257 - GL_PROGRAM_BINARY_LENGTH* = 0x00008741 - GL_NUM_PROGRAM_BINARY_FORMATS* = 0x000087FE - GL_PROGRAM_BINARY_FORMATS* = 0x000087FF # GL_ARB_separate_shader_objects - GL_VERTEX_SHADER_BIT* = 0x00000001 - GL_FRAGMENT_SHADER_BIT* = 0x00000002 - GL_GEOMETRY_SHADER_BIT* = 0x00000004 - GL_TESS_CONTROL_SHADER_BIT* = 0x00000008 - GL_TESS_EVALUATION_SHADER_BIT* = 0x00000010 - GL_ALL_SHADER_BITS* = 0xFFFFFFFF - GL_PROGRAM_SEPARABLE* = 0x00008258 - GL_ACTIVE_PROGRAM* = 0x00008259 - GL_PROGRAM_PIPELINE_BINDING* = 0x0000825A # GL_ARB_vertex_attrib_64bit - GL_MAX_VIEWPORTS* = 0x0000825B - GL_VIEWPORT_SUBPIXEL_BITS* = 0x0000825C - GL_VIEWPORT_BOUNDS_RANGE* = 0x0000825D - GL_LAYER_PROVOKING_VERTEX* = 0x0000825E - GL_VIEWPORT_INDEX_PROVOKING_VERTEX* = 0x0000825F - GL_UNDEFINED_VERTEX* = 0x00008260 # GL_ARB_cl_event - GL_SYNC_CL_EVENT_ARB* = 0x00008240 - GL_SYNC_CL_EVENT_COMPLETE_ARB* = 0x00008241 # GL_ARB_debug_output - GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB* = 0x00008242 - GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB* = 0x00008243 - GL_DEBUG_CALLBACK_FUNCTION_ARB* = 0x00008244 - GL_DEBUG_CALLBACK_USER_PARAM_ARB* = 0x00008245 - GL_DEBUG_SOURCE_API_ARB* = 0x00008246 - GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB* = 0x00008247 - GL_DEBUG_SOURCE_SHADER_COMPILER_ARB* = 0x00008248 - GL_DEBUG_SOURCE_THIRD_PARTY_ARB* = 0x00008249 - GL_DEBUG_SOURCE_APPLICATION_ARB* = 0x0000824A - GL_DEBUG_SOURCE_OTHER_ARB* = 0x0000824B - GL_DEBUGtyp_ERROR_ARB* = 0x0000824C - GL_DEBUGtyp_DEPRECATED_BEHAVIOR_ARB* = 0x0000824D - GL_DEBUGtyp_UNDEFINED_BEHAVIOR_ARB* = 0x0000824E - GL_DEBUGtyp_PORTABILITY_ARB* = 0x0000824F - GL_DEBUGtyp_PERFORMANCE_ARB* = 0x00008250 - GL_DEBUGtyp_OTHER_ARB* = 0x00008251 - GL_MAX_DEBUG_MESSAGE_LENGTH_ARB* = 0x00009143 - GL_MAX_DEBUG_LOGGED_MESSAGES_ARB* = 0x00009144 - GL_DEBUG_LOGGED_MESSAGES_ARB* = 0x00009145 - GL_DEBUG_SEVERITY_HIGH_ARB* = 0x00009146 - GL_DEBUG_SEVERITY_MEDIUM_ARB* = 0x00009147 - GL_DEBUG_SEVERITY_LOW_ARB* = 0x00009148 # GL_ARB_robustness - # reuse GL_NO_ERROR - GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB* = 0x00000004 - GL_LOSE_CONTEXT_ON_RESET_ARB* = 0x00008252 - GL_GUILTY_CONTEXT_RESET_ARB* = 0x00008253 - GL_INNOCENT_CONTEXT_RESET_ARB* = 0x00008254 - GL_UNKNOWN_CONTEXT_RESET_ARB* = 0x00008255 - GL_RESET_NOTIFICATION_STRATEGY_ARB* = 0x00008256 - GL_NO_RESET_NOTIFICATION_ARB* = 0x00008261 # - # GL_ARB_compressed_texture_pixel_storage - GL_UNPACK_COMPRESSED_BLOCK_WIDTH* = 0x00009127 - GL_UNPACK_COMPRESSED_BLOCK_HEIGHT* = 0x00009128 - GL_UNPACK_COMPRESSED_BLOCK_DEPTH* = 0x00009129 - GL_UNPACK_COMPRESSED_BLOCK_SIZE* = 0x0000912A - GL_PACK_COMPRESSED_BLOCK_WIDTH* = 0x0000912B - GL_PACK_COMPRESSED_BLOCK_HEIGHT* = 0x0000912C - GL_PACK_COMPRESSED_BLOCK_DEPTH* = 0x0000912D - GL_PACK_COMPRESSED_BLOCK_SIZE* = 0x0000912E # GL_ARB_internalformat_query - GL_NUM_SAMPLE_COUNTS* = 0x00009380 # GL_ARB_map_buffer_alignment - GL_MIN_MAP_BUFFER_ALIGNMENT* = 0x000090BC # GL_ARB_shader_atomic_counters - GL_ATOMIC_COUNTER_BUFFER* = 0x000092C0 - GL_ATOMIC_COUNTER_BUFFER_BINDING* = 0x000092C1 - GL_ATOMIC_COUNTER_BUFFER_START* = 0x000092C2 - GL_ATOMIC_COUNTER_BUFFER_SIZE* = 0x000092C3 - GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE* = 0x000092C4 - GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS* = 0x000092C5 - GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES* = 0x000092C6 - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER* = 0x000092C7 - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER* = 0x000092C8 - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER* = 0x000092C9 - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER* = 0x000092CA - GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER* = 0x000092CB - GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS* = 0x000092CC - GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS* = 0x000092CD - GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS* = 0x000092CE - GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS* = 0x000092CF - GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS* = 0x000092D0 - GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS* = 0x000092D1 - GL_MAX_VERTEX_ATOMIC_COUNTERS* = 0x000092D2 - GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS* = 0x000092D3 - GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS* = 0x000092D4 - GL_MAX_GEOMETRY_ATOMIC_COUNTERS* = 0x000092D5 - GL_MAX_FRAGMENT_ATOMIC_COUNTERS* = 0x000092D6 - GL_MAX_COMBINED_ATOMIC_COUNTERS* = 0x000092D7 - GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE* = 0x000092D8 - GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS* = 0x000092DC - GL_ACTIVE_ATOMIC_COUNTER_BUFFERS* = 0x000092D9 - GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX* = 0x000092DA - GL_UNSIGNED_INT_ATOMIC_COUNTER* = 0x000092DB # GL_ARB_shader_image_load_store - GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT* = 0x00000001 - GL_ELEMENT_ARRAY_BARRIER_BIT* = 0x00000002 - GL_UNIFORM_BARRIER_BIT* = 0x00000004 - GL_TEXTURE_FETCH_BARRIER_BIT* = 0x00000008 - GL_SHADER_IMAGE_ACCESS_BARRIER_BIT* = 0x00000020 - GL_COMMAND_BARRIER_BIT* = 0x00000040 - GL_PIXEL_BUFFER_BARRIER_BIT* = 0x00000080 - GL_TEXTURE_UPDATE_BARRIER_BIT* = 0x00000100 - GL_BUFFER_UPDATE_BARRIER_BIT* = 0x00000200 - GL_FRAMEBUFFER_BARRIER_BIT* = 0x00000400 - GL_TRANSFORM_FEEDBACK_BARRIER_BIT* = 0x00000800 - GL_ATOMIC_COUNTER_BARRIER_BIT* = 0x00001000 - GL_ALL_BARRIER_BITS* = 0xFFFFFFFF - GL_MAX_IMAGE_UNITS* = 0x00008F38 - GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS* = 0x00008F39 - GL_IMAGE_BINDING_NAME* = 0x00008F3A - GL_IMAGE_BINDING_LEVEL* = 0x00008F3B - GL_IMAGE_BINDING_LAYERED* = 0x00008F3C - GL_IMAGE_BINDING_LAYER* = 0x00008F3D - GL_IMAGE_BINDING_ACCESS* = 0x00008F3E - GL_IMAGE_1D* = 0x0000904C - GL_IMAGE_2D* = 0x0000904D - GL_IMAGE_3D* = 0x0000904E - GL_IMAGE_2D_RECT* = 0x0000904F - GL_IMAGE_CUBE* = 0x00009050 - GL_IMAGE_BUFFER* = 0x00009051 - GL_IMAGE_1D_ARRAY* = 0x00009052 - GL_IMAGE_2D_ARRAY* = 0x00009053 - GL_IMAGE_CUBE_MAP_ARRAY* = 0x00009054 - GL_IMAGE_2D_MULTISAMPLE* = 0x00009055 - GL_IMAGE_2D_MULTISAMPLE_ARRAY* = 0x00009056 - GL_INT_IMAGE_1D* = 0x00009057 - GL_INT_IMAGE_2D* = 0x00009058 - GL_INT_IMAGE_3D* = 0x00009059 - GL_INT_IMAGE_2D_RECT* = 0x0000905A - GL_INT_IMAGE_CUBE* = 0x0000905B - GL_INT_IMAGE_BUFFER* = 0x0000905C - GL_INT_IMAGE_1D_ARRAY* = 0x0000905D - GL_INT_IMAGE_2D_ARRAY* = 0x0000905E - GL_INT_IMAGE_CUBE_MAP_ARRAY* = 0x0000905F - GL_INT_IMAGE_2D_MULTISAMPLE* = 0x00009060 - GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY* = 0x00009061 - GL_UNSIGNED_INT_IMAGE_1D* = 0x00009062 - GL_UNSIGNED_INT_IMAGE_2D* = 0x00009063 - GL_UNSIGNED_INT_IMAGE_3D* = 0x00009064 - GL_UNSIGNED_INT_IMAGE_2D_RECT* = 0x00009065 - GL_UNSIGNED_INT_IMAGE_CUBE* = 0x00009066 - GL_UNSIGNED_INT_IMAGE_BUFFER* = 0x00009067 - GL_UNSIGNED_INT_IMAGE_1D_ARRAY* = 0x00009068 - GL_UNSIGNED_INT_IMAGE_2D_ARRAY* = 0x00009069 - GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY* = 0x0000906A - GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE* = 0x0000906B - GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY* = 0x0000906C - GL_MAX_IMAGE_SAMPLES* = 0x0000906D - GL_IMAGE_BINDING_FORMAT* = 0x0000906E - GL_IMAGE_FORMAT_COMPATIBILITYtyp* = 0x000090C7 - GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE* = 0x000090C8 - GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS* = 0x000090C9 - GL_MAX_VERTEX_IMAGE_UNIFORMS* = 0x000090CA - GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS* = 0x000090CB - GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS* = 0x000090CC - GL_MAX_GEOMETRY_IMAGE_UNIFORMS* = 0x000090CD - GL_MAX_FRAGMENT_IMAGE_UNIFORMS* = 0x000090CE - GL_MAX_COMBINED_IMAGE_UNIFORMS* = 0x000090CF # GL_ARB_texture_storage - GL_TEXTURE_IMMUTABLE_FORMAT* = 0x0000912F # GL_ATI_draw_buffers - GL_MAX_DRAW_BUFFERS_ATI* = 0x00008824 - GL_DRAW_BUFFER0_ATI* = 0x00008825 - GL_DRAW_BUFFER1_ATI* = 0x00008826 - GL_DRAW_BUFFER2_ATI* = 0x00008827 - GL_DRAW_BUFFER3_ATI* = 0x00008828 - GL_DRAW_BUFFER4_ATI* = 0x00008829 - GL_DRAW_BUFFER5_ATI* = 0x0000882A - GL_DRAW_BUFFER6_ATI* = 0x0000882B - GL_DRAW_BUFFER7_ATI* = 0x0000882C - GL_DRAW_BUFFER8_ATI* = 0x0000882D - GL_DRAW_BUFFER9_ATI* = 0x0000882E - GL_DRAW_BUFFER10_ATI* = 0x0000882F - GL_DRAW_BUFFER11_ATI* = 0x00008830 - GL_DRAW_BUFFER12_ATI* = 0x00008831 - GL_DRAW_BUFFER13_ATI* = 0x00008832 - GL_DRAW_BUFFER14_ATI* = 0x00008833 - GL_DRAW_BUFFER15_ATI* = 0x00008834 # GL_ATI_element_array - GL_ELEMENT_ARRAY_ATI* = 0x00008768 - GL_ELEMENT_ARRAYtyp_ATI* = 0x00008769 - GL_ELEMENT_ARRAY_POINTER_ATI* = 0x0000876A # GL_ATI_envmap_bumpmap - GL_BUMP_ROT_MATRIX_ATI* = 0x00008775 - GL_BUMP_ROT_MATRIX_SIZE_ATI* = 0x00008776 - GL_BUMP_NUM_TEX_UNITS_ATI* = 0x00008777 - GL_BUMP_TEX_UNITS_ATI* = 0x00008778 - GL_DUDV_ATI* = 0x00008779 - GL_DU8DV8_ATI* = 0x0000877A - GL_BUMP_ENVMAP_ATI* = 0x0000877B - GL_BUMP_TARGET_ATI* = 0x0000877C # GL_ATI_fragment_shader - GL_FRAGMENT_SHADER_ATI* = 0x00008920 - GL_REG_0_ATI* = 0x00008921 - GL_REG_1_ATI* = 0x00008922 - GL_REG_2_ATI* = 0x00008923 - GL_REG_3_ATI* = 0x00008924 - GL_REG_4_ATI* = 0x00008925 - GL_REG_5_ATI* = 0x00008926 - GL_REG_6_ATI* = 0x00008927 - GL_REG_7_ATI* = 0x00008928 - GL_REG_8_ATI* = 0x00008929 - GL_REG_9_ATI* = 0x0000892A - GL_REG_10_ATI* = 0x0000892B - GL_REG_11_ATI* = 0x0000892C - GL_REG_12_ATI* = 0x0000892D - GL_REG_13_ATI* = 0x0000892E - GL_REG_14_ATI* = 0x0000892F - GL_REG_15_ATI* = 0x00008930 - GL_REG_16_ATI* = 0x00008931 - GL_REG_17_ATI* = 0x00008932 - GL_REG_18_ATI* = 0x00008933 - GL_REG_19_ATI* = 0x00008934 - GL_REG_20_ATI* = 0x00008935 - GL_REG_21_ATI* = 0x00008936 - GL_REG_22_ATI* = 0x00008937 - GL_REG_23_ATI* = 0x00008938 - GL_REG_24_ATI* = 0x00008939 - GL_REG_25_ATI* = 0x0000893A - GL_REG_26_ATI* = 0x0000893B - GL_REG_27_ATI* = 0x0000893C - GL_REG_28_ATI* = 0x0000893D - GL_REG_29_ATI* = 0x0000893E - GL_REG_30_ATI* = 0x0000893F - GL_REG_31_ATI* = 0x00008940 - GL_CON_0_ATI* = 0x00008941 - GL_CON_1_ATI* = 0x00008942 - GL_CON_2_ATI* = 0x00008943 - GL_CON_3_ATI* = 0x00008944 - GL_CON_4_ATI* = 0x00008945 - GL_CON_5_ATI* = 0x00008946 - GL_CON_6_ATI* = 0x00008947 - GL_CON_7_ATI* = 0x00008948 - GL_CON_8_ATI* = 0x00008949 - GL_CON_9_ATI* = 0x0000894A - GL_CON_10_ATI* = 0x0000894B - GL_CON_11_ATI* = 0x0000894C - GL_CON_12_ATI* = 0x0000894D - GL_CON_13_ATI* = 0x0000894E - GL_CON_14_ATI* = 0x0000894F - GL_CON_15_ATI* = 0x00008950 - GL_CON_16_ATI* = 0x00008951 - GL_CON_17_ATI* = 0x00008952 - GL_CON_18_ATI* = 0x00008953 - GL_CON_19_ATI* = 0x00008954 - GL_CON_20_ATI* = 0x00008955 - GL_CON_21_ATI* = 0x00008956 - GL_CON_22_ATI* = 0x00008957 - GL_CON_23_ATI* = 0x00008958 - GL_CON_24_ATI* = 0x00008959 - GL_CON_25_ATI* = 0x0000895A - GL_CON_26_ATI* = 0x0000895B - GL_CON_27_ATI* = 0x0000895C - GL_CON_28_ATI* = 0x0000895D - GL_CON_29_ATI* = 0x0000895E - GL_CON_30_ATI* = 0x0000895F - GL_CON_31_ATI* = 0x00008960 - GL_MOV_ATI* = 0x00008961 - GL_ADD_ATI* = 0x00008963 - GL_MUL_ATI* = 0x00008964 - GL_SUB_ATI* = 0x00008965 - GL_DOT3_ATI* = 0x00008966 - GL_DOT4_ATI* = 0x00008967 - GL_MAD_ATI* = 0x00008968 - GL_LERP_ATI* = 0x00008969 - GL_CND_ATI* = 0x0000896A - GL_CND0_ATI* = 0x0000896B - GL_DOT2_ADD_ATI* = 0x0000896C - GL_SECONDARY_INTERPOLATOR_ATI* = 0x0000896D - GL_NUM_FRAGMENT_REGISTERS_ATI* = 0x0000896E - GL_NUM_FRAGMENT_CONSTANTS_ATI* = 0x0000896F - GL_NUM_PASSES_ATI* = 0x00008970 - GL_NUM_INSTRUCTIONS_PER_PASS_ATI* = 0x00008971 - GL_NUM_INSTRUCTIONS_TOTAL_ATI* = 0x00008972 - GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI* = 0x00008973 - GL_NUM_LOOPBACK_COMPONENTS_ATI* = 0x00008974 - GL_COLOR_ALPHA_PAIRING_ATI* = 0x00008975 - GL_SWIZZLE_STR_ATI* = 0x00008976 - GL_SWIZZLE_STQ_ATI* = 0x00008977 - GL_SWIZZLE_STR_DR_ATI* = 0x00008978 - GL_SWIZZLE_STQ_DQ_ATI* = 0x00008979 - GL_SWIZZLE_STRQ_ATI* = 0x0000897A - GL_SWIZZLE_STRQ_DQ_ATI* = 0x0000897B - GL_RED_BIT_ATI* = 0x00000001 - GL_GREEN_BIT_ATI* = 0x00000002 - GL_BLUE_BIT_ATI* = 0x00000004 - GL_2X_BIT_ATI* = 0x00000001 - GL_4X_BIT_ATI* = 0x00000002 - GL_8X_BIT_ATI* = 0x00000004 - GL_HALF_BIT_ATI* = 0x00000008 - GL_QUARTER_BIT_ATI* = 0x00000010 - GL_EIGHTH_BIT_ATI* = 0x00000020 - GL_SATURATE_BIT_ATI* = 0x00000040 - GL_COMP_BIT_ATI* = 0x00000002 - GL_NEGATE_BIT_ATI* = 0x00000004 - GL_BIAS_BIT_ATI* = 0x00000008 # GL_ATI_pn_triangles - GL_PN_TRIANGLES_ATI* = 0x000087F0 - GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI* = 0x000087F1 - GL_PN_TRIANGLES_POINT_MODE_ATI* = 0x000087F2 - GL_PN_TRIANGLES_NORMAL_MODE_ATI* = 0x000087F3 - GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI* = 0x000087F4 - GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI* = 0x000087F5 - GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI* = 0x000087F6 - GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI* = 0x000087F7 - GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI* = 0x000087F8 # - # GL_ATI_separate_stencil - GL_STENCIL_BACK_FUNC_ATI* = 0x00008800 - GL_STENCIL_BACK_FAIL_ATI* = 0x00008801 - GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI* = 0x00008802 - GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI* = 0x00008803 # GL_ATI_text_fragment_shader - GL_TEXT_FRAGMENT_SHADER_ATI* = 0x00008200 # GL_ATI_texture_env_combine3 - GL_MODULATE_ADD_ATI* = 0x00008744 - GL_MODULATE_SIGNED_ADD_ATI* = 0x00008745 - GL_MODULATE_SUBTRACT_ATI* = 0x00008746 # GL_ATI_texture_float - GL_RGBA_FLOAT32_ATI* = 0x00008814 - GL_RGB_FLOAT32_ATI* = 0x00008815 - GL_ALPHA_FLOAT32_ATI* = 0x00008816 - GL_INTENSITY_FLOAT32_ATI* = 0x00008817 - GL_LUMINANCE_FLOAT32_ATI* = 0x00008818 - GL_LUMINANCE_ALPHA_FLOAT32_ATI* = 0x00008819 - GL_RGBA_FLOAT16_ATI* = 0x0000881A - GL_RGB_FLOAT16_ATI* = 0x0000881B - GL_ALPHA_FLOAT16_ATI* = 0x0000881C - GL_INTENSITY_FLOAT16_ATI* = 0x0000881D - GL_LUMINANCE_FLOAT16_ATI* = 0x0000881E - GL_LUMINANCE_ALPHA_FLOAT16_ATI* = 0x0000881F # GL_ATI_texture_mirror_once - GL_MIRROR_CLAMP_ATI* = 0x00008742 - GL_MIRROR_CLAMP_TO_EDGE_ATI* = 0x00008743 # GL_ATI_vertex_array_object - GL_STATIC_ATI* = 0x00008760 - GL_DYNAMIC_ATI* = 0x00008761 - GL_PRESERVE_ATI* = 0x00008762 - GL_DISCARD_ATI* = 0x00008763 - GL_OBJECT_BUFFER_SIZE_ATI* = 0x00008764 - GL_OBJECT_BUFFER_USAGE_ATI* = 0x00008765 - GL_ARRAY_OBJECT_BUFFER_ATI* = 0x00008766 - GL_ARRAY_OBJECT_OFFSET_ATI* = 0x00008767 # GL_ATI_vertex_streams - GL_MAX_VERTEX_STREAMS_ATI* = 0x0000876B - GL_VERTEX_STREAM0_ATI* = 0x0000876C - GL_VERTEX_STREAM1_ATI* = 0x0000876D - GL_VERTEX_STREAM2_ATI* = 0x0000876E - GL_VERTEX_STREAM3_ATI* = 0x0000876F - GL_VERTEX_STREAM4_ATI* = 0x00008770 - GL_VERTEX_STREAM5_ATI* = 0x00008771 - GL_VERTEX_STREAM6_ATI* = 0x00008772 - GL_VERTEX_STREAM7_ATI* = 0x00008773 - GL_VERTEX_SOURCE_ATI* = 0x00008774 # GL_ATI_meminfo - GL_VBO_FREE_MEMORY_ATI* = 0x000087FB - GL_TEXTURE_FREE_MEMORY_ATI* = 0x000087FC - GL_RENDERBUFFER_FREE_MEMORY_ATI* = 0x000087FD # GL_AMD_performance_monitor - GL_COUNTERtyp_AMD* = 0x00008BC0 - GL_COUNTER_RANGE_AMD* = 0x00008BC1 - GL_UNSIGNED_INT64_AMD* = 0x00008BC2 - GL_PERCENTAGE_AMD* = 0x00008BC3 - GL_PERFMON_RESULT_AVAILABLE_AMD* = 0x00008BC4 - GL_PERFMON_RESULT_SIZE_AMD* = 0x00008BC5 - GL_PERFMON_RESULT_AMD* = 0x00008BC6 # GL_AMD_vertex_shader_tesselator - GL_SAMPLER_BUFFER_AMD* = 0x00009001 - GL_INT_SAMPLER_BUFFER_AMD* = 0x00009002 - GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD* = 0x00009003 - cGL_TESSELLATION_MODE_AMD* = 0x00009004 - cGL_TESSELLATION_FACTOR_AMD* = 0x00009005 - GL_DISCRETE_AMD* = 0x00009006 - GL_CONTINUOUS_AMD* = 0x00009007 # GL_AMD_seamless_cubemap_per_texture - # reuse GL_TEXTURE_CUBE_MAP_SEAMLESS - # GL_AMD_name_gen_delete - GL_DATA_BUFFER_AMD* = 0x00009151 - GL_PERFORMANCE_MONITOR_AMD* = 0x00009152 - GL_QUERY_OBJECT_AMD* = 0x00009153 - GL_VERTEX_ARRAY_OBJECT_AMD* = 0x00009154 - GL_SAMPLER_OBJECT_AMD* = 0x00009155 # GL_AMD_debug_output - GL_MAX_DEBUG_LOGGED_MESSAGES_AMD* = 0x00009144 - GL_DEBUG_LOGGED_MESSAGES_AMD* = 0x00009145 - GL_DEBUG_SEVERITY_HIGH_AMD* = 0x00009146 - GL_DEBUG_SEVERITY_MEDIUM_AMD* = 0x00009147 - GL_DEBUG_SEVERITY_LOW_AMD* = 0x00009148 - GL_DEBUG_CATEGORY_API_ERROR_AMD* = 0x00009149 - GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD* = 0x0000914A - GL_DEBUG_CATEGORY_DEPRECATION_AMD* = 0x0000914B - GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD* = 0x0000914C - GL_DEBUG_CATEGORY_PERFORMANCE_AMD* = 0x0000914D - GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD* = 0x0000914E - GL_DEBUG_CATEGORY_APPLICATION_AMD* = 0x0000914F - GL_DEBUG_CATEGORY_OTHER_AMD* = 0x00009150 # GL_AMD_depth_clamp_separate - GL_DEPTH_CLAMP_NEAR_AMD* = 0x0000901E - GL_DEPTH_CLAMP_FAR_AMD* = 0x0000901F # GL_EXT_422_pixels - GL_422_EXT* = 0x000080CC - GL_422_REV_EXT* = 0x000080CD - GL_422_AVERAGE_EXT* = 0x000080CE - GL_422_REV_AVERAGE_EXT* = 0x000080CF # GL_EXT_abgr - GL_ABGR_EXT* = 0x00008000 # GL_EXT_bgra - GL_BGR_EXT* = 0x000080E0 - GL_BGRA_EXT* = 0x000080E1 # GL_EXT_blend_color - GL_CONSTANT_COLOR_EXT* = 0x00008001 - GL_ONE_MINUS_CONSTANT_COLOR_EXT* = 0x00008002 - GL_CONSTANT_ALPHA_EXT* = 0x00008003 - GL_ONE_MINUS_CONSTANT_ALPHA_EXT* = 0x00008004 - cGL_BLEND_COLOR_EXT* = 0x00008005 # GL_EXT_blend_func_separate - GL_BLEND_DST_RGB_EXT* = 0x000080C8 - GL_BLEND_SRC_RGB_EXT* = 0x000080C9 - GL_BLEND_DST_ALPHA_EXT* = 0x000080CA - GL_BLEND_SRC_ALPHA_EXT* = 0x000080CB # GL_EXT_blend_minmax - GL_FUNC_ADD_EXT* = 0x00008006 - GL_MIN_EXT* = 0x00008007 - GL_MAX_EXT* = 0x00008008 - cGL_BLEND_EQUATION_EXT* = 0x00008009 # GL_EXT_blend_subtract - GL_FUNC_SUBTRACT_EXT* = 0x0000800A - GL_FUNC_REVERSE_SUBTRACT_EXT* = 0x0000800B # GL_EXT_clip_volume_hint - GL_CLIP_VOLUME_CLIPPING_HINT_EXT* = 0x000080F0 # GL_EXT_cmyka - GL_CMYK_EXT* = 0x0000800C - GL_CMYKA_EXT* = 0x0000800D - GL_PACK_CMYK_HINT_EXT* = 0x0000800E - GL_UNPACK_CMYK_HINT_EXT* = 0x0000800F # GL_EXT_compiled_vertex_array - GL_ARRAY_ELEMENT_LOCK_FIRST_EXT* = 0x000081A8 - GL_ARRAY_ELEMENT_LOCK_COUNT_EXT* = 0x000081A9 # GL_EXT_convolution - GL_CONVOLUTION_1D_EXT* = 0x00008010 - GL_CONVOLUTION_2D_EXT* = 0x00008011 - GL_SEPARABLE_2D_EXT* = 0x00008012 - GL_CONVOLUTION_BORDER_MODE_EXT* = 0x00008013 - GL_CONVOLUTION_FILTER_SCALE_EXT* = 0x00008014 - GL_CONVOLUTION_FILTER_BIAS_EXT* = 0x00008015 - GL_REDUCE_EXT* = 0x00008016 - GL_CONVOLUTION_FORMAT_EXT* = 0x00008017 - GL_CONVOLUTION_WIDTH_EXT* = 0x00008018 - GL_CONVOLUTION_HEIGHT_EXT* = 0x00008019 - GL_MAX_CONVOLUTION_WIDTH_EXT* = 0x0000801A - GL_MAX_CONVOLUTION_HEIGHT_EXT* = 0x0000801B - GL_POST_CONVOLUTION_RED_SCALE_EXT* = 0x0000801C - GL_POST_CONVOLUTION_GREEN_SCALE_EXT* = 0x0000801D - GL_POST_CONVOLUTION_BLUE_SCALE_EXT* = 0x0000801E - GL_POST_CONVOLUTION_ALPHA_SCALE_EXT* = 0x0000801F - GL_POST_CONVOLUTION_RED_BIAS_EXT* = 0x00008020 - GL_POST_CONVOLUTION_GREEN_BIAS_EXT* = 0x00008021 - GL_POST_CONVOLUTION_BLUE_BIAS_EXT* = 0x00008022 - GL_POST_CONVOLUTION_ALPHA_BIAS_EXT* = 0x00008023 # GL_EXT_coordinate_frame - GL_TANGENT_ARRAY_EXT* = 0x00008439 - GL_BINORMAL_ARRAY_EXT* = 0x0000843A - GL_CURRENT_TANGENT_EXT* = 0x0000843B - GL_CURRENT_BINORMAL_EXT* = 0x0000843C - GL_TANGENT_ARRAYtyp_EXT* = 0x0000843E - GL_TANGENT_ARRAY_STRIDE_EXT* = 0x0000843F - GL_BINORMAL_ARRAYtyp_EXT* = 0x00008440 - GL_BINORMAL_ARRAY_STRIDE_EXT* = 0x00008441 - GL_TANGENT_ARRAY_POINTER_EXT* = 0x00008442 - GL_BINORMAL_ARRAY_POINTER_EXT* = 0x00008443 - GL_MAP1_TANGENT_EXT* = 0x00008444 - GL_MAP2_TANGENT_EXT* = 0x00008445 - GL_MAP1_BINORMAL_EXT* = 0x00008446 - GL_MAP2_BINORMAL_EXT* = 0x00008447 # GL_EXT_cull_vertex - GL_CULL_VERTEX_EXT* = 0x000081AA - GL_CULL_VERTEX_EYE_POSITION_EXT* = 0x000081AB - GL_CULL_VERTEX_OBJECT_POSITION_EXT* = 0x000081AC # GL_EXT_draw_range_elements - GL_MAX_ELEMENTS_VERTICES_EXT* = 0x000080E8 - GL_MAX_ELEMENTS_INDICES_EXT* = 0x000080E9 # GL_EXT_fog_coord - GL_FOG_COORDINATE_SOURCE_EXT* = 0x00008450 - GL_FOG_COORDINATE_EXT* = 0x00008451 - GL_FRAGMENT_DEPTH_EXT* = 0x00008452 - GL_CURRENT_FOG_COORDINATE_EXT* = 0x00008453 - GL_FOG_COORDINATE_ARRAYtyp_EXT* = 0x00008454 - GL_FOG_COORDINATE_ARRAY_STRIDE_EXT* = 0x00008455 - GL_FOG_COORDINATE_ARRAY_POINTER_EXT* = 0x00008456 - GL_FOG_COORDINATE_ARRAY_EXT* = 0x00008457 # GL_EXT_framebuffer_object - GL_FRAMEBUFFER_EXT* = 0x00008D40 - GL_RENDERBUFFER_EXT* = 0x00008D41 - GL_STENCIL_INDEX_EXT* = 0x00008D45 - GL_STENCIL_INDEX1_EXT* = 0x00008D46 - GL_STENCIL_INDEX4_EXT* = 0x00008D47 - GL_STENCIL_INDEX8_EXT* = 0x00008D48 - GL_STENCIL_INDEX16_EXT* = 0x00008D49 - GL_RENDERBUFFER_WIDTH_EXT* = 0x00008D42 - GL_RENDERBUFFER_HEIGHT_EXT* = 0x00008D43 - GL_RENDERBUFFER_INTERNAL_FORMAT_EXT* = 0x00008D44 - GL_FRAMEBUFFER_ATTACHMENT_OBJECTtyp_EXT* = 0x00008CD0 - GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT* = 0x00008CD1 - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT* = 0x00008CD2 - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT* = 0x00008CD3 - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT* = 0x00008CD4 - GL_COLOR_ATTACHMENT0_EXT* = 0x00008CE0 - GL_COLOR_ATTACHMENT1_EXT* = 0x00008CE1 - GL_COLOR_ATTACHMENT2_EXT* = 0x00008CE2 - GL_COLOR_ATTACHMENT3_EXT* = 0x00008CE3 - GL_COLOR_ATTACHMENT4_EXT* = 0x00008CE4 - GL_COLOR_ATTACHMENT5_EXT* = 0x00008CE5 - GL_COLOR_ATTACHMENT6_EXT* = 0x00008CE6 - GL_COLOR_ATTACHMENT7_EXT* = 0x00008CE7 - GL_COLOR_ATTACHMENT8_EXT* = 0x00008CE8 - GL_COLOR_ATTACHMENT9_EXT* = 0x00008CE9 - GL_COLOR_ATTACHMENT10_EXT* = 0x00008CEA - GL_COLOR_ATTACHMENT11_EXT* = 0x00008CEB - GL_COLOR_ATTACHMENT12_EXT* = 0x00008CEC - GL_COLOR_ATTACHMENT13_EXT* = 0x00008CED - GL_COLOR_ATTACHMENT14_EXT* = 0x00008CEE - GL_COLOR_ATTACHMENT15_EXT* = 0x00008CEF - GL_DEPTH_ATTACHMENT_EXT* = 0x00008D00 - GL_STENCIL_ATTACHMENT_EXT* = 0x00008D20 - GL_FRAMEBUFFER_COMPLETE_EXT* = 0x00008CD5 - GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT* = 0x00008CD6 - GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT* = 0x00008CD7 - GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT* = 0x00008CD8 - GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT* = 0x00008CD9 - GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT* = 0x00008CDA - GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT* = 0x00008CDB - GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT* = 0x00008CDC - GL_FRAMEBUFFER_UNSUPPORTED_EXT* = 0x00008CDD - GL_FRAMEBUFFER_STATUS_ERROR_EXT* = 0x00008CDE - GL_FRAMEBUFFER_BINDING_EXT* = 0x00008CA6 - GL_RENDERBUFFER_BINDING_EXT* = 0x00008CA7 - GL_MAX_COLOR_ATTACHMENTS_EXT* = 0x00008CDF - GL_MAX_RENDERBUFFER_SIZE_EXT* = 0x000084E8 - GL_INVALID_FRAMEBUFFER_OPERATION_EXT* = 0x00000506 # GL_EXT_histogram - cGL_HISTOGRAM_EXT* = 0x00008024 - GL_PROXY_HISTOGRAM_EXT* = 0x00008025 - GL_HISTOGRAM_WIDTH_EXT* = 0x00008026 - GL_HISTOGRAM_FORMAT_EXT* = 0x00008027 - GL_HISTOGRAM_RED_SIZE_EXT* = 0x00008028 - GL_HISTOGRAM_GREEN_SIZE_EXT* = 0x00008029 - GL_HISTOGRAM_BLUE_SIZE_EXT* = 0x0000802A - GL_HISTOGRAM_ALPHA_SIZE_EXT* = 0x0000802B - GL_HISTOGRAM_LUMINANCE_SIZE_EXT* = 0x0000802C - GL_HISTOGRAM_SINK_EXT* = 0x0000802D - cGL_MINMAX_EXT* = 0x0000802E - GL_MINMAX_FORMAT_EXT* = 0x0000802F - GL_MINMAX_SINK_EXT* = 0x00008030 - GL_TABLE_TOO_LARGE_EXT* = 0x00008031 # GL_EXT_index_array_formats - GL_IUI_V2F_EXT* = 0x000081AD - GL_IUI_V3F_EXT* = 0x000081AE - GL_IUI_N3F_V2F_EXT* = 0x000081AF - GL_IUI_N3F_V3F_EXT* = 0x000081B0 - GL_T2F_IUI_V2F_EXT* = 0x000081B1 - GL_T2F_IUI_V3F_EXT* = 0x000081B2 - GL_T2F_IUI_N3F_V2F_EXT* = 0x000081B3 - GL_T2F_IUI_N3F_V3F_EXT* = 0x000081B4 # GL_EXT_index_func - GL_INDEX_TEST_EXT* = 0x000081B5 - GL_INDEX_TEST_FUNC_EXT* = 0x000081B6 - GL_INDEX_TEST_REF_EXT* = 0x000081B7 # GL_EXT_index_material - cGL_INDEX_MATERIAL_EXT* = 0x000081B8 - GL_INDEX_MATERIAL_PARAMETER_EXT* = 0x000081B9 - GL_INDEX_MATERIAL_FACE_EXT* = 0x000081BA # GL_EXT_light_texture - GL_FRAGMENT_MATERIAL_EXT* = 0x00008349 - GL_FRAGMENT_NORMAL_EXT* = 0x0000834A - GL_FRAGMENT_COLOR_EXT* = 0x0000834C - GL_ATTENUATION_EXT* = 0x0000834D - GL_SHADOW_ATTENUATION_EXT* = 0x0000834E - GL_TEXTURE_APPLICATION_MODE_EXT* = 0x0000834F - cGL_TEXTURE_LIGHT_EXT* = 0x00008350 - GL_TEXTURE_MATERIAL_FACE_EXT* = 0x00008351 - GL_TEXTURE_MATERIAL_PARAMETER_EXT* = 0x00008352 # GL_EXT_multisample - GL_MULTISAMPLE_EXT* = 0x0000809D - GL_SAMPLE_ALPHA_TO_MASK_EXT* = 0x0000809E - GL_SAMPLE_ALPHA_TO_ONE_EXT* = 0x0000809F - cGL_SAMPLE_MASK_EXT* = 0x000080A0 - GL_1PASS_EXT* = 0x000080A1 - GL_2PASS_0_EXT* = 0x000080A2 - GL_2PASS_1_EXT* = 0x000080A3 - GL_4PASS_0_EXT* = 0x000080A4 - GL_4PASS_1_EXT* = 0x000080A5 - GL_4PASS_2_EXT* = 0x000080A6 - GL_4PASS_3_EXT* = 0x000080A7 - GL_SAMPLE_BUFFERS_EXT* = 0x000080A8 - GL_SAMPLES_EXT* = 0x000080A9 - GL_SAMPLE_MASK_VALUE_EXT* = 0x000080AA - GL_SAMPLE_MASK_INVERT_EXT* = 0x000080AB - cGL_SAMPLE_PATTERN_EXT* = 0x000080AC - GL_MULTISAMPLE_BIT_EXT* = 0x20000000 # GL_EXT_packed_pixels - GL_UNSIGNED_BYTE_3_3_2_EXT* = 0x00008032 - GL_UNSIGNED_SHORT_4_4_4_4_EXT* = 0x00008033 - GL_UNSIGNED_SHORT_5_5_5_1_EXT* = 0x00008034 - GL_UNSIGNED_INT_8_8_8_8_EXT* = 0x00008035 - GL_UNSIGNED_INT_10_10_10_2_EXT* = 0x00008036 # GL_EXT_paletted_texture - GL_COLOR_INDEX1_EXT* = 0x000080E2 - GL_COLOR_INDEX2_EXT* = 0x000080E3 - GL_COLOR_INDEX4_EXT* = 0x000080E4 - GL_COLOR_INDEX8_EXT* = 0x000080E5 - GL_COLOR_INDEX12_EXT* = 0x000080E6 - GL_COLOR_INDEX16_EXT* = 0x000080E7 - GL_TEXTURE_INDEX_SIZE_EXT* = 0x000080ED # GL_EXT_pixel_transform - GL_PIXEL_TRANSFORM_2D_EXT* = 0x00008330 - GL_PIXEL_MAG_FILTER_EXT* = 0x00008331 - GL_PIXEL_MIN_FILTER_EXT* = 0x00008332 - GL_PIXEL_CUBIC_WEIGHT_EXT* = 0x00008333 - GL_CUBIC_EXT* = 0x00008334 - GL_AVERAGE_EXT* = 0x00008335 - GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT* = 0x00008336 - GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT* = 0x00008337 - GL_PIXEL_TRANSFORM_2D_MATRIX_EXT* = 0x00008338 # GL_EXT_point_parameters - GL_POINT_SIZE_MIN_EXT* = 0x00008126 - GL_POINT_SIZE_MAX_EXT* = 0x00008127 - GL_POINT_FADE_THRESHOLD_SIZE_EXT* = 0x00008128 - GL_DISTANCE_ATTENUATION_EXT* = 0x00008129 # GL_EXT_polygon_offset - cGL_POLYGON_OFFSET_EXT* = 0x00008037 - GL_POLYGON_OFFSET_FACTOR_EXT* = 0x00008038 - GL_POLYGON_OFFSET_BIAS_EXT* = 0x00008039 # GL_EXT_rescale_normal - GL_RESCALE_NORMAL_EXT* = 0x0000803A # GL_EXT_secondary_color - GL_COLOR_SUM_EXT* = 0x00008458 - GL_CURRENT_SECONDARY_COLOR_EXT* = 0x00008459 - GL_SECONDARY_COLOR_ARRAY_SIZE_EXT* = 0x0000845A - GL_SECONDARY_COLOR_ARRAYtyp_EXT* = 0x0000845B - GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT* = 0x0000845C - GL_SECONDARY_COLOR_ARRAY_POINTER_EXT* = 0x0000845D - GL_SECONDARY_COLOR_ARRAY_EXT* = 0x0000845E # GL_EXT_separate_specular_color - GL_LIGHT_MODEL_COLOR_CONTROL_EXT* = 0x000081F8 - GL_SINGLE_COLOR_EXT* = 0x000081F9 - GL_SEPARATE_SPECULAR_COLOR_EXT* = 0x000081FA # GL_EXT_shared_texture_palette - GL_SHARED_TEXTURE_PALETTE_EXT* = 0x000081FB # GL_EXT_stencil_two_side - GL_STENCIL_TEST_TWO_SIDE_EXT* = 0x00008910 - cGL_ACTIVE_STENCIL_FACE_EXT* = 0x00008911 # GL_EXT_stencil_wrap - GL_INCR_WRAP_EXT* = 0x00008507 - GL_DECR_WRAP_EXT* = 0x00008508 # GL_EXT_texture - GL_ALPHA4_EXT* = 0x0000803B - GL_ALPHA8_EXT* = 0x0000803C - GL_ALPHA12_EXT* = 0x0000803D - GL_ALPHA16_EXT* = 0x0000803E - GL_LUMINANCE4_EXT* = 0x0000803F - GL_LUMINANCE8_EXT* = 0x00008040 - GL_LUMINANCE12_EXT* = 0x00008041 - GL_LUMINANCE16_EXT* = 0x00008042 - GL_LUMINANCE4_ALPHA4_EXT* = 0x00008043 - GL_LUMINANCE6_ALPHA2_EXT* = 0x00008044 - GL_LUMINANCE8_ALPHA8_EXT* = 0x00008045 - GL_LUMINANCE12_ALPHA4_EXT* = 0x00008046 - GL_LUMINANCE12_ALPHA12_EXT* = 0x00008047 - GL_LUMINANCE16_ALPHA16_EXT* = 0x00008048 - GL_INTENSITY_EXT* = 0x00008049 - GL_INTENSITY4_EXT* = 0x0000804A - GL_INTENSITY8_EXT* = 0x0000804B - GL_INTENSITY12_EXT* = 0x0000804C - GL_INTENSITY16_EXT* = 0x0000804D - GL_RGB2_EXT* = 0x0000804E - GL_RGB4_EXT* = 0x0000804F - GL_RGB5_EXT* = 0x00008050 - GL_RGB8_EXT* = 0x00008051 - GL_RGB10_EXT* = 0x00008052 - GL_RGB12_EXT* = 0x00008053 - GL_RGB16_EXT* = 0x00008054 - GL_RGBA2_EXT* = 0x00008055 - GL_RGBA4_EXT* = 0x00008056 - GL_RGB5_A1_EXT* = 0x00008057 - GL_RGBA8_EXT* = 0x00008058 - GL_RGB10_A2_EXT* = 0x00008059 - GL_RGBA12_EXT* = 0x0000805A - GL_RGBA16_EXT* = 0x0000805B - GL_TEXTURE_RED_SIZE_EXT* = 0x0000805C - GL_TEXTURE_GREEN_SIZE_EXT* = 0x0000805D - GL_TEXTURE_BLUE_SIZE_EXT* = 0x0000805E - GL_TEXTURE_ALPHA_SIZE_EXT* = 0x0000805F - GL_TEXTURE_LUMINANCE_SIZE_EXT* = 0x00008060 - GL_TEXTURE_INTENSITY_SIZE_EXT* = 0x00008061 - GL_REPLACE_EXT* = 0x00008062 - GL_PROXY_TEXTURE_1D_EXT* = 0x00008063 - GL_PROXY_TEXTURE_2D_EXT* = 0x00008064 - GL_TEXTURE_TOO_LARGE_EXT* = 0x00008065 # GL_EXT_texture3D - GL_PACK_SKIP_IMAGES_EXT* = 0x0000806B - GL_PACK_IMAGE_HEIGHT_EXT* = 0x0000806C - GL_UNPACK_SKIP_IMAGES_EXT* = 0x0000806D - GL_UNPACK_IMAGE_HEIGHT_EXT* = 0x0000806E - GL_TEXTURE_3D_EXT* = 0x0000806F - GL_PROXY_TEXTURE_3D_EXT* = 0x00008070 - GL_TEXTURE_DEPTH_EXT* = 0x00008071 - GL_TEXTURE_WRAP_R_EXT* = 0x00008072 - GL_MAX_3D_TEXTURE_SIZE_EXT* = 0x00008073 # GL_EXT_texture_compression_s3tc - GL_COMPRESSED_RGB_S3TC_DXT1_EXT* = 0x000083F0 - GL_COMPRESSED_RGBA_S3TC_DXT1_EXT* = 0x000083F1 - GL_COMPRESSED_RGBA_S3TC_DXT3_EXT* = 0x000083F2 - GL_COMPRESSED_RGBA_S3TC_DXT5_EXT* = 0x000083F3 # GL_EXT_texture_cube_map - GL_NORMAL_MAP_EXT* = 0x00008511 - GL_REFLECTION_MAP_EXT* = 0x00008512 - GL_TEXTURE_CUBE_MAP_EXT* = 0x00008513 - GL_TEXTURE_BINDING_CUBE_MAP_EXT* = 0x00008514 - GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT* = 0x00008515 - GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT* = 0x00008516 - GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT* = 0x00008517 - GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT* = 0x00008518 - GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT* = 0x00008519 - GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT* = 0x0000851A - GL_PROXY_TEXTURE_CUBE_MAP_EXT* = 0x0000851B - GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT* = 0x0000851C # GL_EXT_texture_edge_clamp - GL_CLAMP_TO_EDGE_EXT* = 0x0000812F # GL_EXT_texture_env_combine - GL_COMBINE_EXT* = 0x00008570 - GL_COMBINE_RGB_EXT* = 0x00008571 - GL_COMBINE_ALPHA_EXT* = 0x00008572 - GL_RGB_SCALE_EXT* = 0x00008573 - GL_ADD_SIGNED_EXT* = 0x00008574 - GL_INTERPOLATE_EXT* = 0x00008575 - GL_CONSTANT_EXT* = 0x00008576 - GL_PRIMARY_COLOR_EXT* = 0x00008577 - GL_PREVIOUS_EXT* = 0x00008578 - GL_SOURCE0_RGB_EXT* = 0x00008580 - GL_SOURCE1_RGB_EXT* = 0x00008581 - GL_SOURCE2_RGB_EXT* = 0x00008582 - GL_SOURCE0_ALPHA_EXT* = 0x00008588 - GL_SOURCE1_ALPHA_EXT* = 0x00008589 - GL_SOURCE2_ALPHA_EXT* = 0x0000858A - GL_OPERAND0_RGB_EXT* = 0x00008590 - GL_OPERAND1_RGB_EXT* = 0x00008591 - GL_OPERAND2_RGB_EXT* = 0x00008592 - GL_OPERAND0_ALPHA_EXT* = 0x00008598 - GL_OPERAND1_ALPHA_EXT* = 0x00008599 - GL_OPERAND2_ALPHA_EXT* = 0x0000859A # GL_EXT_texture_env_dot3 - GL_DOT3_RGB_EXT* = 0x00008740 - GL_DOT3_RGBA_EXT* = 0x00008741 # GL_EXT_texture_filter_anisotropic - GL_TEXTURE_MAX_ANISOTROPY_EXT* = 0x000084FE - GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT* = 0x000084FF # GL_EXT_texture_lod_bias - GL_MAX_TEXTURE_LOD_BIAS_EXT* = 0x000084FD - GL_TEXTURE_FILTER_CONTROL_EXT* = 0x00008500 - GL_TEXTURE_LOD_BIAS_EXT* = 0x00008501 # GL_EXT_texture_object - GL_TEXTURE_PRIORITY_EXT* = 0x00008066 - GL_TEXTURE_RESIDENT_EXT* = 0x00008067 - GL_TEXTURE_1D_BINDING_EXT* = 0x00008068 - GL_TEXTURE_2D_BINDING_EXT* = 0x00008069 - GL_TEXTURE_3D_BINDING_EXT* = 0x0000806A # GL_EXT_texture_perturb_normal - GL_PERTURB_EXT* = 0x000085AE - cGL_TEXTURE_NORMAL_EXT* = 0x000085AF # GL_EXT_texture_rectangle - GL_TEXTURE_RECTANGLE_EXT* = 0x000084F5 - GL_TEXTURE_BINDING_RECTANGLE_EXT* = 0x000084F6 - GL_PROXY_TEXTURE_RECTANGLE_EXT* = 0x000084F7 - GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT* = 0x000084F8 # GL_EXT_vertex_array - GL_VERTEX_ARRAY_EXT* = 0x00008074 - GL_NORMAL_ARRAY_EXT* = 0x00008075 - GL_COLOR_ARRAY_EXT* = 0x00008076 - GL_INDEX_ARRAY_EXT* = 0x00008077 - GL_TEXTURE_COORD_ARRAY_EXT* = 0x00008078 - GL_EDGE_FLAG_ARRAY_EXT* = 0x00008079 - GL_VERTEX_ARRAY_SIZE_EXT* = 0x0000807A - GL_VERTEX_ARRAYtyp_EXT* = 0x0000807B - GL_VERTEX_ARRAY_STRIDE_EXT* = 0x0000807C - GL_VERTEX_ARRAY_COUNT_EXT* = 0x0000807D - GL_NORMAL_ARRAYtyp_EXT* = 0x0000807E - GL_NORMAL_ARRAY_STRIDE_EXT* = 0x0000807F - GL_NORMAL_ARRAY_COUNT_EXT* = 0x00008080 - GL_COLOR_ARRAY_SIZE_EXT* = 0x00008081 - GL_COLOR_ARRAYtyp_EXT* = 0x00008082 - GL_COLOR_ARRAY_STRIDE_EXT* = 0x00008083 - GL_COLOR_ARRAY_COUNT_EXT* = 0x00008084 - GL_INDEX_ARRAYtyp_EXT* = 0x00008085 - GL_INDEX_ARRAY_STRIDE_EXT* = 0x00008086 - GL_INDEX_ARRAY_COUNT_EXT* = 0x00008087 - GL_TEXTURE_COORD_ARRAY_SIZE_EXT* = 0x00008088 - GL_TEXTURE_COORD_ARRAYtyp_EXT* = 0x00008089 - GL_TEXTURE_COORD_ARRAY_STRIDE_EXT* = 0x0000808A - GL_TEXTURE_COORD_ARRAY_COUNT_EXT* = 0x0000808B - GL_EDGE_FLAG_ARRAY_STRIDE_EXT* = 0x0000808C - GL_EDGE_FLAG_ARRAY_COUNT_EXT* = 0x0000808D - GL_VERTEX_ARRAY_POINTER_EXT* = 0x0000808E - GL_NORMAL_ARRAY_POINTER_EXT* = 0x0000808F - GL_COLOR_ARRAY_POINTER_EXT* = 0x00008090 - GL_INDEX_ARRAY_POINTER_EXT* = 0x00008091 - GL_TEXTURE_COORD_ARRAY_POINTER_EXT* = 0x00008092 - GL_EDGE_FLAG_ARRAY_POINTER_EXT* = 0x00008093 # GL_EXT_vertex_shader - GL_VERTEX_SHADER_EXT* = 0x00008780 - GL_VERTEX_SHADER_BINDING_EXT* = 0x00008781 - GL_OP_INDEX_EXT* = 0x00008782 - GL_OP_NEGATE_EXT* = 0x00008783 - GL_OP_DOT3_EXT* = 0x00008784 - GL_OP_DOT4_EXT* = 0x00008785 - GL_OP_MUL_EXT* = 0x00008786 - GL_OP_ADD_EXT* = 0x00008787 - GL_OP_MADD_EXT* = 0x00008788 - GL_OP_FRAC_EXT* = 0x00008789 - GL_OP_MAX_EXT* = 0x0000878A - GL_OP_MIN_EXT* = 0x0000878B - GL_OP_SET_GE_EXT* = 0x0000878C - GL_OP_SET_LT_EXT* = 0x0000878D - GL_OP_CLAMP_EXT* = 0x0000878E - GL_OP_FLOOR_EXT* = 0x0000878F - GL_OP_ROUND_EXT* = 0x00008790 - GL_OP_EXP_BASE_2_EXT* = 0x00008791 - GL_OP_LOG_BASE_2_EXT* = 0x00008792 - GL_OP_POWER_EXT* = 0x00008793 - GL_OP_RECIP_EXT* = 0x00008794 - GL_OP_RECIP_SQRT_EXT* = 0x00008795 - GL_OP_SUB_EXT* = 0x00008796 - GL_OP_CROSS_PRODUCT_EXT* = 0x00008797 - GL_OP_MULTIPLY_MATRIX_EXT* = 0x00008798 - GL_OP_MOV_EXT* = 0x00008799 - GL_OUTPUT_VERTEX_EXT* = 0x0000879A - GL_OUTPUT_COLOR0_EXT* = 0x0000879B - GL_OUTPUT_COLOR1_EXT* = 0x0000879C - GL_OUTPUT_TEXTURE_COORD0_EXT* = 0x0000879D - GL_OUTPUT_TEXTURE_COORD1_EXT* = 0x0000879E - GL_OUTPUT_TEXTURE_COORD2_EXT* = 0x0000879F - GL_OUTPUT_TEXTURE_COORD3_EXT* = 0x000087A0 - GL_OUTPUT_TEXTURE_COORD4_EXT* = 0x000087A1 - GL_OUTPUT_TEXTURE_COORD5_EXT* = 0x000087A2 - GL_OUTPUT_TEXTURE_COORD6_EXT* = 0x000087A3 - GL_OUTPUT_TEXTURE_COORD7_EXT* = 0x000087A4 - GL_OUTPUT_TEXTURE_COORD8_EXT* = 0x000087A5 - GL_OUTPUT_TEXTURE_COORD9_EXT* = 0x000087A6 - GL_OUTPUT_TEXTURE_COORD10_EXT* = 0x000087A7 - GL_OUTPUT_TEXTURE_COORD11_EXT* = 0x000087A8 - GL_OUTPUT_TEXTURE_COORD12_EXT* = 0x000087A9 - GL_OUTPUT_TEXTURE_COORD13_EXT* = 0x000087AA - GL_OUTPUT_TEXTURE_COORD14_EXT* = 0x000087AB - GL_OUTPUT_TEXTURE_COORD15_EXT* = 0x000087AC - GL_OUTPUT_TEXTURE_COORD16_EXT* = 0x000087AD - GL_OUTPUT_TEXTURE_COORD17_EXT* = 0x000087AE - GL_OUTPUT_TEXTURE_COORD18_EXT* = 0x000087AF - GL_OUTPUT_TEXTURE_COORD19_EXT* = 0x000087B0 - GL_OUTPUT_TEXTURE_COORD20_EXT* = 0x000087B1 - GL_OUTPUT_TEXTURE_COORD21_EXT* = 0x000087B2 - GL_OUTPUT_TEXTURE_COORD22_EXT* = 0x000087B3 - GL_OUTPUT_TEXTURE_COORD23_EXT* = 0x000087B4 - GL_OUTPUT_TEXTURE_COORD24_EXT* = 0x000087B5 - GL_OUTPUT_TEXTURE_COORD25_EXT* = 0x000087B6 - GL_OUTPUT_TEXTURE_COORD26_EXT* = 0x000087B7 - GL_OUTPUT_TEXTURE_COORD27_EXT* = 0x000087B8 - GL_OUTPUT_TEXTURE_COORD28_EXT* = 0x000087B9 - GL_OUTPUT_TEXTURE_COORD29_EXT* = 0x000087BA - GL_OUTPUT_TEXTURE_COORD30_EXT* = 0x000087BB - GL_OUTPUT_TEXTURE_COORD31_EXT* = 0x000087BC - GL_OUTPUT_FOG_EXT* = 0x000087BD - GL_SCALAR_EXT* = 0x000087BE - GL_VECTOR_EXT* = 0x000087BF - GL_MATRIX_EXT* = 0x000087C0 - GL_VARIANT_EXT* = 0x000087C1 - GL_INVARIANT_EXT* = 0x000087C2 - GL_LOCAL_CONSTANT_EXT* = 0x000087C3 - GL_LOCAL_EXT* = 0x000087C4 - GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT* = 0x000087C5 - GL_MAX_VERTEX_SHADER_VARIANTS_EXT* = 0x000087C6 - GL_MAX_VERTEX_SHADER_INVARIANTS_EXT* = 0x000087C7 - GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT* = 0x000087C8 - GL_MAX_VERTEX_SHADER_LOCALS_EXT* = 0x000087C9 - GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT* = 0x000087CA - GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT* = 0x000087CB - GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT* = 0x000087CC - GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT* = 0x000087CD - GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT* = 0x000087CE - GL_VERTEX_SHADER_INSTRUCTIONS_EXT* = 0x000087CF - GL_VERTEX_SHADER_VARIANTS_EXT* = 0x000087D0 - GL_VERTEX_SHADER_INVARIANTS_EXT* = 0x000087D1 - GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT* = 0x000087D2 - GL_VERTEX_SHADER_LOCALS_EXT* = 0x000087D3 - GL_VERTEX_SHADER_OPTIMIZED_EXT* = 0x000087D4 - GL_X_EXT* = 0x000087D5 - GL_Y_EXT* = 0x000087D6 - GL_Z_EXT* = 0x000087D7 - GL_W_EXT* = 0x000087D8 - GL_NEGATIVE_X_EXT* = 0x000087D9 - GL_NEGATIVE_Y_EXT* = 0x000087DA - GL_NEGATIVE_Z_EXT* = 0x000087DB - GL_NEGATIVE_W_EXT* = 0x000087DC - GL_ZERO_EXT* = 0x000087DD - GL_ONE_EXT* = 0x000087DE - GL_NEGATIVE_ONE_EXT* = 0x000087DF - GL_NORMALIZED_RANGE_EXT* = 0x000087E0 - GL_FULL_RANGE_EXT* = 0x000087E1 - GL_CURRENT_VERTEX_EXT* = 0x000087E2 - GL_MVP_MATRIX_EXT* = 0x000087E3 - GL_VARIANT_VALUE_EXT* = 0x000087E4 - GL_VARIANT_DATAtypEXT* = 0x000087E5 - GL_VARIANT_ARRAY_STRIDE_EXT* = 0x000087E6 - GL_VARIANT_ARRAYtyp_EXT* = 0x000087E7 - GL_VARIANT_ARRAY_EXT* = 0x000087E8 - GL_VARIANT_ARRAY_POINTER_EXT* = 0x000087E9 - GL_INVARIANT_VALUE_EXT* = 0x000087EA - GL_INVARIANT_DATAtypEXT* = 0x000087EB - GL_LOCAL_CONSTANT_VALUE_EXT* = 0x000087EC - GL_LOCAL_CONSTANT_DATAtypEXT* = 0x000087ED # GL_EXT_vertex_weighting - GL_MODELVIEW0_STACK_DEPTH_EXT* = 0x00000BA3 - GL_MODELVIEW1_STACK_DEPTH_EXT* = 0x00008502 - GL_MODELVIEW0_MATRIX_EXT* = 0x00000BA6 - GL_MODELVIEW1_MATRIX_EXT* = 0x00008506 - GL_VERTEX_WEIGHTING_EXT* = 0x00008509 - GL_MODELVIEW0_EXT* = 0x00001700 - GL_MODELVIEW1_EXT* = 0x0000850A - GL_CURRENT_VERTEX_WEIGHT_EXT* = 0x0000850B - GL_VERTEX_WEIGHT_ARRAY_EXT* = 0x0000850C - GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT* = 0x0000850D - GL_VERTEX_WEIGHT_ARRAYtyp_EXT* = 0x0000850E - GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT* = 0x0000850F - GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT* = 0x00008510 # GL_EXT_depth_bounds_test - GL_DEPTH_BOUNDS_TEST_EXT* = 0x00008890 - cGL_DEPTH_BOUNDS_EXT* = 0x00008891 # GL_EXT_texture_mirror_clamp - GL_MIRROR_CLAMP_EXT* = 0x00008742 - GL_MIRROR_CLAMP_TO_EDGE_EXT* = 0x00008743 - GL_MIRROR_CLAMP_TO_BORDER_EXT* = 0x00008912 # GL_EXT_blend_equation_separate - GL_BLEND_EQUATION_RGB_EXT* = 0x00008009 - GL_BLEND_EQUATION_ALPHA_EXT* = 0x0000883D # GL_EXT_pixel_buffer_object - GL_PIXEL_PACK_BUFFER_EXT* = 0x000088EB - GL_PIXEL_UNPACK_BUFFER_EXT* = 0x000088EC - GL_PIXEL_PACK_BUFFER_BINDING_EXT* = 0x000088ED - GL_PIXEL_UNPACK_BUFFER_BINDING_EXT* = 0x000088EF # GL_EXT_stencil_clear_tag - GL_STENCIL_TAG_BITS_EXT* = 0x000088F2 - GL_STENCIL_CLEAR_TAG_VALUE_EXT* = 0x000088F3 # GL_EXT_packed_depth_stencil - GL_DEPTH_STENCIL_EXT* = 0x000084F9 - GL_UNSIGNED_INT_24_8_EXT* = 0x000084FA - GL_DEPTH24_STENCIL8_EXT* = 0x000088F0 - GL_TEXTURE_STENCIL_SIZE_EXT* = 0x000088F1 # GL_EXT_texture_sRGB - GL_SRGB_EXT* = 0x00008C40 - GL_SRGB8_EXT* = 0x00008C41 - GL_SRGB_ALPHA_EXT* = 0x00008C42 - GL_SRGB8_ALPHA8_EXT* = 0x00008C43 - GL_SLUMINANCE_ALPHA_EXT* = 0x00008C44 - GL_SLUMINANCE8_ALPHA8_EXT* = 0x00008C45 - GL_SLUMINANCE_EXT* = 0x00008C46 - GL_SLUMINANCE8_EXT* = 0x00008C47 - GL_COMPRESSED_SRGB_EXT* = 0x00008C48 - GL_COMPRESSED_SRGB_ALPHA_EXT* = 0x00008C49 - GL_COMPRESSED_SLUMINANCE_EXT* = 0x00008C4A - GL_COMPRESSED_SLUMINANCE_ALPHA_EXT* = 0x00008C4B - GL_COMPRESSED_SRGB_S3TC_DXT1_EXT* = 0x00008C4C - GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT* = 0x00008C4D - GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT* = 0x00008C4E - GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT* = 0x00008C4F # GL_EXT_framebuffer_blit - GL_READ_FRAMEBUFFER_EXT* = 0x00008CA8 - GL_DRAW_FRAMEBUFFER_EXT* = 0x00008CA9 - GL_READ_FRAMEBUFFER_BINDING_EXT* = GL_FRAMEBUFFER_BINDING_EXT - GL_DRAW_FRAMEBUFFER_BINDING_EXT* = 0x00008CAA # GL_EXT_framebuffer_multisample - GL_RENDERBUFFER_SAMPLES_EXT* = 0x00008CAB - GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT* = 0x00008D56 - GL_MAX_SAMPLES_EXT* = 0x00008D57 # GL_EXT_timer_query - GL_TIME_ELAPSED_EXT* = 0x000088BF # GL_EXT_bindable_uniform - GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT* = 0x00008DE2 - GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT* = 0x00008DE3 - GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT* = 0x00008DE4 - GL_MAX_BINDABLE_UNIFORM_SIZE_EXT* = 0x00008DED - cGL_UNIFORM_BUFFER_EXT* = 0x00008DEE - GL_UNIFORM_BUFFER_BINDING_EXT* = 0x00008DEF # GL_EXT_framebuffer_sRGB - GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT* = 0x000020B2 - WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT* = 0x000020A9 - GL_FRAMEBUFFER_SRGB_EXT* = 0x00008DB9 - GL_FRAMEBUFFER_SRGB_CAPABLE_EXT* = 0x00008DBA # GL_EXT_geometry_shader4 - GL_GEOMETRY_SHADER_EXT* = 0x00008DD9 - GL_GEOMETRY_VERTICES_OUT_EXT* = 0x00008DDA - GL_GEOMETRY_INPUTtyp_EXT* = 0x00008DDB - GL_GEOMETRY_OUTPUTtyp_EXT* = 0x00008DDC - GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT* = 0x00008C29 - GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT* = 0x00008DDD - GL_MAX_VERTEX_VARYING_COMPONENTS_EXT* = 0x00008DDE - GL_MAX_VARYING_COMPONENTS_EXT* = 0x00008B4B - GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT* = 0x00008DDF - GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT* = 0x00008DE0 - GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT* = 0x00008DE1 - GL_LINES_ADJACENCY_EXT* = 0x0000000A - GL_LINE_STRIP_ADJACENCY_EXT* = 0x0000000B - GL_TRIANGLES_ADJACENCY_EXT* = 0x0000000C - GL_TRIANGLE_STRIP_ADJACENCY_EXT* = 0x0000000D - GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT* = 0x00008DA8 - GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT* = 0x00008DA9 - GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT* = 0x00008DA7 - GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT* = 0x00008CD4 - GL_PROGRAM_POINT_SIZE_EXT* = 0x00008642 # GL_EXT_gpu_shader4 - GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT* = 0x000088FD - GL_SAMPLER_1D_ARRAY_EXT* = 0x00008DC0 - GL_SAMPLER_2D_ARRAY_EXT* = 0x00008DC1 - GL_SAMPLER_BUFFER_EXT* = 0x00008DC2 - GL_SAMPLER_1D_ARRAY_SHADOW_EXT* = 0x00008DC3 - GL_SAMPLER_2D_ARRAY_SHADOW_EXT* = 0x00008DC4 - GL_SAMPLER_CUBE_SHADOW_EXT* = 0x00008DC5 - GL_UNSIGNED_INT_VEC2_EXT* = 0x00008DC6 - GL_UNSIGNED_INT_VEC3_EXT* = 0x00008DC7 - GL_UNSIGNED_INT_VEC4_EXT* = 0x00008DC8 - GL_INT_SAMPLER_1D_EXT* = 0x00008DC9 - GL_INT_SAMPLER_2D_EXT* = 0x00008DCA - GL_INT_SAMPLER_3D_EXT* = 0x00008DCB - GL_INT_SAMPLER_CUBE_EXT* = 0x00008DCC - GL_INT_SAMPLER_2D_RECT_EXT* = 0x00008DCD - GL_INT_SAMPLER_1D_ARRAY_EXT* = 0x00008DCE - GL_INT_SAMPLER_2D_ARRAY_EXT* = 0x00008DCF - GL_INT_SAMPLER_BUFFER_EXT* = 0x00008DD0 - GL_UNSIGNED_INT_SAMPLER_1D_EXT* = 0x00008DD1 - GL_UNSIGNED_INT_SAMPLER_2D_EXT* = 0x00008DD2 - GL_UNSIGNED_INT_SAMPLER_3D_EXT* = 0x00008DD3 - GL_UNSIGNED_INT_SAMPLER_CUBE_EXT* = 0x00008DD4 - GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT* = 0x00008DD5 - GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT* = 0x00008DD6 - GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT* = 0x00008DD7 - GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT* = 0x00008DD8 - GL_MIN_PROGRAM_TEXEL_OFFSET_EXT* = 0x00008904 - GL_MAX_PROGRAM_TEXEL_OFFSET_EXT* = 0x00008905 # GL_EXT_packed_float - GL_R11F_G11F_B10F_EXT* = 0x00008C3A - GL_UNSIGNED_INT_10F_11F_11F_REV_EXT* = 0x00008C3B - RGBA_SIGNED_COMPONENTS_EXT* = 0x00008C3C - WGLtyp_RGBA_UNSIGNED_FLOAT_EXT* = 0x000020A8 - GLX_RGBA_UNSIGNED_FLOATtyp_EXT* = 0x000020B1 - GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT* = 0x00000008 # GL_EXT_texture_array - GL_TEXTURE_1D_ARRAY_EXT* = 0x00008C18 - GL_TEXTURE_2D_ARRAY_EXT* = 0x00008C1A - GL_PROXY_TEXTURE_2D_ARRAY_EXT* = 0x00008C1B - GL_PROXY_TEXTURE_1D_ARRAY_EXT* = 0x00008C19 - GL_TEXTURE_BINDING_1D_ARRAY_EXT* = 0x00008C1C - GL_TEXTURE_BINDING_2D_ARRAY_EXT* = 0x00008C1D - GL_MAX_ARRAY_TEXTURE_LAYERS_EXT* = 0x000088FF - GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT* = 0x0000884E # GL_EXT_texture_buffer_object - cGL_TEXTURE_BUFFER_EXT* = 0x00008C2A - GL_MAX_TEXTURE_BUFFER_SIZE_EXT* = 0x00008C2B - GL_TEXTURE_BINDING_BUFFER_EXT* = 0x00008C2C - GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT* = 0x00008C2D - GL_TEXTURE_BUFFER_FORMAT_EXT* = 0x00008C2E # GL_EXT_texture_compression_latc - GL_COMPRESSED_LUMINANCE_LATC1_EXT* = 0x00008C70 - GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT* = 0x00008C71 - GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT* = 0x00008C72 - GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT* = 0x00008C73 # - # GL_EXT_texture_compression_rgtc - GL_COMPRESSED_RED_RGTC1_EXT* = 0x00008DBB - GL_COMPRESSED_SIGNED_RED_RGTC1_EXT* = 0x00008DBC - GL_COMPRESSED_RED_GREEN_RGTC2_EXT* = 0x00008DBD - GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT* = 0x00008DBE # GL_EXT_texture_integer - GL_RGBA_INTEGER_MODE_EXT* = 0x00008D9E - GL_RGBA32UI_EXT* = 0x00008D70 - GL_RGB32UI_EXT* = 0x00008D71 - GL_ALPHA32UI_EXT* = 0x00008D72 - GL_INTENSITY32UI_EXT* = 0x00008D73 - GL_LUMINANCE32UI_EXT* = 0x00008D74 - GL_LUMINANCE_ALPHA32UI_EXT* = 0x00008D75 - GL_RGBA16UI_EXT* = 0x00008D76 - GL_RGB16UI_EXT* = 0x00008D77 - GL_ALPHA16UI_EXT* = 0x00008D78 - GL_INTENSITY16UI_EXT* = 0x00008D79 - GL_LUMINANCE16UI_EXT* = 0x00008D7A - GL_LUMINANCE_ALPHA16UI_EXT* = 0x00008D7B - GL_RGBA8UI_EXT* = 0x00008D7C - GL_RGB8UI_EXT* = 0x00008D7D - GL_ALPHA8UI_EXT* = 0x00008D7E - GL_INTENSITY8UI_EXT* = 0x00008D7F - GL_LUMINANCE8UI_EXT* = 0x00008D80 - GL_LUMINANCE_ALPHA8UI_EXT* = 0x00008D81 - GL_RGBA32I_EXT* = 0x00008D82 - GL_RGB32I_EXT* = 0x00008D83 - GL_ALPHA32I_EXT* = 0x00008D84 - GL_INTENSITY32I_EXT* = 0x00008D85 - GL_LUMINANCE32I_EXT* = 0x00008D86 - GL_LUMINANCE_ALPHA32I_EXT* = 0x00008D87 - GL_RGBA16I_EXT* = 0x00008D88 - GL_RGB16I_EXT* = 0x00008D89 - GL_ALPHA16I_EXT* = 0x00008D8A - GL_INTENSITY16I_EXT* = 0x00008D8B - GL_LUMINANCE16I_EXT* = 0x00008D8C - GL_LUMINANCE_ALPHA16I_EXT* = 0x00008D8D - GL_RGBA8I_EXT* = 0x00008D8E - GL_RGB8I_EXT* = 0x00008D8F - GL_ALPHA8I_EXT* = 0x00008D90 - GL_INTENSITY8I_EXT* = 0x00008D91 - GL_LUMINANCE8I_EXT* = 0x00008D92 - GL_LUMINANCE_ALPHA8I_EXT* = 0x00008D93 - GL_RED_INTEGER_EXT* = 0x00008D94 - GL_GREEN_INTEGER_EXT* = 0x00008D95 - GL_BLUE_INTEGER_EXT* = 0x00008D96 - GL_ALPHA_INTEGER_EXT* = 0x00008D97 - GL_RGB_INTEGER_EXT* = 0x00008D98 - GL_RGBA_INTEGER_EXT* = 0x00008D99 - GL_BGR_INTEGER_EXT* = 0x00008D9A - GL_BGRA_INTEGER_EXT* = 0x00008D9B - GL_LUMINANCE_INTEGER_EXT* = 0x00008D9C - GL_LUMINANCE_ALPHA_INTEGER_EXT* = 0x00008D9D # GL_EXT_texture_shared_exponent - GL_RGB9_E5_EXT* = 0x00008C3D - GL_UNSIGNED_INT_5_9_9_9_REV_EXT* = 0x00008C3E - GL_TEXTURE_SHARED_SIZE_EXT* = 0x00008C3F # GL_EXT_transform_feedback - GL_TRANSFORM_FEEDBACK_BUFFER_EXT* = 0x00008C8E - GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT* = 0x00008C84 - GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT* = 0x00008C85 - GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT* = 0x00008C8F - GL_INTERLEAVED_ATTRIBS_EXT* = 0x00008C8C - GL_SEPARATE_ATTRIBS_EXT* = 0x00008C8D - GL_PRIMITIVES_GENERATED_EXT* = 0x00008C87 - GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT* = 0x00008C88 - GL_RASTERIZER_DISCARD_EXT* = 0x00008C89 - GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT* = 0x00008C8A - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT* = 0x00008C8B - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT* = 0x00008C80 - cGL_TRANSFORM_FEEDBACK_VARYINGS_EXT* = 0x00008C83 - GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT* = 0x00008C7F - GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT* = 0x00008C76 # - # GL_EXT_direct_state_access - GL_PROGRAM_MATRIX_EXT* = 0x00008E2D - GL_TRANSPOSE_PROGRAM_MATRIX_EXT* = 0x00008E2E - GL_PROGRAM_MATRIX_STACK_DEPTH_EXT* = 0x00008E2F # GL_EXT_texture_swizzle - GL_TEXTURE_SWIZZLE_R_EXT* = 0x00008E42 - GL_TEXTURE_SWIZZLE_G_EXT* = 0x00008E43 - GL_TEXTURE_SWIZZLE_B_EXT* = 0x00008E44 - GL_TEXTURE_SWIZZLE_A_EXT* = 0x00008E45 - GL_TEXTURE_SWIZZLE_RGBA_EXT* = 0x00008E46 # GL_EXT_provoking_vertex - GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT* = 0x00008E4C - GL_FIRST_VERTEX_CONVENTION_EXT* = 0x00008E4D - GL_LAST_VERTEX_CONVENTION_EXT* = 0x00008E4E - GL_PROVOKING_VERTEX_EXT* = 0x00008E4F # GL_EXT_texture_snorm - GL_ALPHA_SNORM* = 0x00009010 - GL_LUMINANCE_SNORM* = 0x00009011 - GL_LUMINANCE_ALPHA_SNORM* = 0x00009012 - GL_INTENSITY_SNORM* = 0x00009013 - GL_ALPHA8_SNORM* = 0x00009014 - GL_LUMINANCE8_SNORM* = 0x00009015 - GL_LUMINANCE8_ALPHA8_SNORM* = 0x00009016 - GL_INTENSITY8_SNORM* = 0x00009017 - GL_ALPHA16_SNORM* = 0x00009018 - GL_LUMINANCE16_SNORM* = 0x00009019 - GL_LUMINANCE16_ALPHA16_SNORM* = 0x0000901A - GL_INTENSITY16_SNORM* = 0x0000901B # GL_EXT_separate_shader_objects - cGL_ACTIVE_PROGRAM_EXT* = 0x00008B8D # GL_EXT_shader_image_load_store - GL_MAX_IMAGE_UNITS_EXT* = 0x00008F38 - GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT* = 0x00008F39 - GL_IMAGE_BINDING_NAME_EXT* = 0x00008F3A - GL_IMAGE_BINDING_LEVEL_EXT* = 0x00008F3B - GL_IMAGE_BINDING_LAYERED_EXT* = 0x00008F3C - GL_IMAGE_BINDING_LAYER_EXT* = 0x00008F3D - GL_IMAGE_BINDING_ACCESS_EXT* = 0x00008F3E - GL_IMAGE_1D_EXT* = 0x0000904C - GL_IMAGE_2D_EXT* = 0x0000904D - GL_IMAGE_3D_EXT* = 0x0000904E - GL_IMAGE_2D_RECT_EXT* = 0x0000904F - GL_IMAGE_CUBE_EXT* = 0x00009050 - GL_IMAGE_BUFFER_EXT* = 0x00009051 - GL_IMAGE_1D_ARRAY_EXT* = 0x00009052 - GL_IMAGE_2D_ARRAY_EXT* = 0x00009053 - GL_IMAGE_CUBE_MAP_ARRAY_EXT* = 0x00009054 - GL_IMAGE_2D_MULTISAMPLE_EXT* = 0x00009055 - GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT* = 0x00009056 - GL_INT_IMAGE_1D_EXT* = 0x00009057 - GL_INT_IMAGE_2D_EXT* = 0x00009058 - GL_INT_IMAGE_3D_EXT* = 0x00009059 - GL_INT_IMAGE_2D_RECT_EXT* = 0x0000905A - GL_INT_IMAGE_CUBE_EXT* = 0x0000905B - GL_INT_IMAGE_BUFFER_EXT* = 0x0000905C - GL_INT_IMAGE_1D_ARRAY_EXT* = 0x0000905D - GL_INT_IMAGE_2D_ARRAY_EXT* = 0x0000905E - GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT* = 0x0000905F - GL_INT_IMAGE_2D_MULTISAMPLE_EXT* = 0x00009060 - GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT* = 0x00009061 - GL_UNSIGNED_INT_IMAGE_1D_EXT* = 0x00009062 - GL_UNSIGNED_INT_IMAGE_2D_EXT* = 0x00009063 - GL_UNSIGNED_INT_IMAGE_3D_EXT* = 0x00009064 - GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT* = 0x00009065 - GL_UNSIGNED_INT_IMAGE_CUBE_EXT* = 0x00009066 - GL_UNSIGNED_INT_IMAGE_BUFFER_EXT* = 0x00009067 - GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT* = 0x00009068 - GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT* = 0x00009069 - GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT* = 0x0000906A - GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT* = 0x0000906B - GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT* = 0x0000906C - GL_MAX_IMAGE_SAMPLES_EXT* = 0x0000906D - GL_IMAGE_BINDING_FORMAT_EXT* = 0x0000906E - GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT* = 0x00000001 - GL_ELEMENT_ARRAY_BARRIER_BIT_EXT* = 0x00000002 - GL_UNIFORM_BARRIER_BIT_EXT* = 0x00000004 - GL_TEXTURE_FETCH_BARRIER_BIT_EXT* = 0x00000008 - GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT* = 0x00000020 - GL_COMMAND_BARRIER_BIT_EXT* = 0x00000040 - GL_PIXEL_BUFFER_BARRIER_BIT_EXT* = 0x00000080 - GL_TEXTURE_UPDATE_BARRIER_BIT_EXT* = 0x00000100 - GL_BUFFER_UPDATE_BARRIER_BIT_EXT* = 0x00000200 - GL_FRAMEBUFFER_BARRIER_BIT_EXT* = 0x00000400 - GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT* = 0x00000800 - GL_ATOMIC_COUNTER_BARRIER_BIT_EXT* = 0x00001000 - GL_ALL_BARRIER_BITS_EXT* = 0xFFFFFFFF # GL_EXT_vertex_attrib_64bit - # reuse GL_DOUBLE - GL_DOUBLE_VEC2_EXT* = 0x00008FFC - GL_DOUBLE_VEC3_EXT* = 0x00008FFD - GL_DOUBLE_VEC4_EXT* = 0x00008FFE - GL_DOUBLE_MAT2_EXT* = 0x00008F46 - GL_DOUBLE_MAT3_EXT* = 0x00008F47 - GL_DOUBLE_MAT4_EXT* = 0x00008F48 - GL_DOUBLE_MAT2x3_EXT* = 0x00008F49 - GL_DOUBLE_MAT2x4_EXT* = 0x00008F4A - GL_DOUBLE_MAT3x2_EXT* = 0x00008F4B - GL_DOUBLE_MAT3x4_EXT* = 0x00008F4C - GL_DOUBLE_MAT4x2_EXT* = 0x00008F4D - GL_DOUBLE_MAT4x3_EXT* = 0x00008F4E # GL_EXT_texture_sRGB_decode - GL_TEXTURE_SRGB_DECODE_EXT* = 0x00008A48 - GL_DECODE_EXT* = 0x00008A49 - GL_SKIP_DECODE_EXT* = 0x00008A4A # GL_NV_texture_multisample - GL_TEXTURE_COVERAGE_SAMPLES_NV* = 0x00009045 - GL_TEXTURE_COLOR_SAMPLES_NV* = 0x00009046 # GL_AMD_blend_minmax_factor - GL_FACTOR_MIN_AMD* = 0x0000901C - GL_FACTOR_MAX_AMD* = 0x0000901D # GL_AMD_sample_positions - GL_SUBSAMPLE_DISTANCE_AMD* = 0x0000883F # GL_EXT_x11_sync_object - GL_SYNC_X11_FENCE_EXT* = 0x000090E1 # GL_EXT_framebuffer_multisample_blit_scaled - GL_SCALED_RESOLVE_FASTEST_EXT* = 0x000090BA - GL_SCALED_RESOLVE_NICEST_EXT* = 0x000090BB # GL_FfdMaskSGIX - GL_TEXTURE_DEFORMATION_BIT_SGIX* = 0x00000001 - GL_GEOMETRY_DEFORMATION_BIT_SGIX* = 0x00000002 # GL_HP_convolution_border_modes - GL_IGNORE_BORDER_HP* = 0x00008150 - GL_CONSTANT_BORDER_HP* = 0x00008151 - GL_REPLICATE_BORDER_HP* = 0x00008153 - GL_CONVOLUTION_BORDER_COLOR_HP* = 0x00008154 # GL_HP_image_transform - GL_IMAGE_SCALE_X_HP* = 0x00008155 - GL_IMAGE_SCALE_Y_HP* = 0x00008156 - GL_IMAGE_TRANSLATE_X_HP* = 0x00008157 - GL_IMAGE_TRANSLATE_Y_HP* = 0x00008158 - GL_IMAGE_ROTATE_ANGLE_HP* = 0x00008159 - GL_IMAGE_ROTATE_ORIGIN_X_HP* = 0x0000815A - GL_IMAGE_ROTATE_ORIGIN_Y_HP* = 0x0000815B - GL_IMAGE_MAG_FILTER_HP* = 0x0000815C - GL_IMAGE_MIN_FILTER_HP* = 0x0000815D - GL_IMAGE_CUBIC_WEIGHT_HP* = 0x0000815E - GL_CUBIC_HP* = 0x0000815F - GL_AVERAGE_HP* = 0x00008160 - GL_IMAGE_TRANSFORM_2D_HP* = 0x00008161 - GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP* = 0x00008162 - GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP* = 0x00008163 # - # GL_HP_occlusion_test - GL_OCCLUSION_TEST_HP* = 0x00008165 - GL_OCCLUSION_TEST_RESULT_HP* = 0x00008166 # GL_HP_texture_lighting - GL_TEXTURE_LIGHTING_MODE_HP* = 0x00008167 - GL_TEXTURE_POST_SPECULAR_HP* = 0x00008168 - GL_TEXTURE_PRE_SPECULAR_HP* = 0x00008169 # GL_IBM_cull_vertex - GL_CULL_VERTEX_IBM* = 103050 # GL_IBM_rasterpos_clip - GL_RASTER_POSITION_UNCLIPPED_IBM* = 0x00019262 # GL_IBM_texture_mirrored_repeat - GL_MIRRORED_REPEAT_IBM* = 0x00008370 # GL_IBM_vertex_array_lists - GL_VERTEX_ARRAY_LIST_IBM* = 103070 - GL_NORMAL_ARRAY_LIST_IBM* = 103071 - GL_COLOR_ARRAY_LIST_IBM* = 103072 - GL_INDEX_ARRAY_LIST_IBM* = 103073 - GL_TEXTURE_COORD_ARRAY_LIST_IBM* = 103074 - GL_EDGE_FLAG_ARRAY_LIST_IBM* = 103075 - GL_FOG_COORDINATE_ARRAY_LIST_IBM* = 103076 - GL_SECONDARY_COLOR_ARRAY_LIST_IBM* = 103077 - GL_VERTEX_ARRAY_LIST_STRIDE_IBM* = 103080 - GL_NORMAL_ARRAY_LIST_STRIDE_IBM* = 103081 - GL_COLOR_ARRAY_LIST_STRIDE_IBM* = 103082 - GL_INDEX_ARRAY_LIST_STRIDE_IBM* = 103083 - GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM* = 103084 - GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM* = 103085 - GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM* = 103086 - GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM* = 103087 # GL_INGR_color_clamp - GL_RED_MIN_CLAMP_INGR* = 0x00008560 - GL_GREEN_MIN_CLAMP_INGR* = 0x00008561 - GL_BLUE_MIN_CLAMP_INGR* = 0x00008562 - GL_ALPHA_MIN_CLAMP_INGR* = 0x00008563 - GL_RED_MAX_CLAMP_INGR* = 0x00008564 - GL_GREEN_MAX_CLAMP_INGR* = 0x00008565 - GL_BLUE_MAX_CLAMP_INGR* = 0x00008566 - GL_ALPHA_MAX_CLAMP_INGR* = 0x00008567 # GL_INGR_interlace_read - GL_INTERLACE_READ_INGR* = 0x00008568 # GL_INTEL_parallel_arrays - GL_PARALLEL_ARRAYS_INTEL* = 0x000083F4 - GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL* = 0x000083F5 - GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL* = 0x000083F6 - GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL* = 0x000083F7 - GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL* = 0x000083F8 # - # GL_NV_copy_depth_to_color - GL_DEPTH_STENCIL_TO_RGBA_NV* = 0x0000886E - GL_DEPTH_STENCIL_TO_BGRA_NV* = 0x0000886F # GL_NV_depth_clamp - GL_DEPTH_CLAMP_NV* = 0x0000864F # GL_NV_evaluators - GL_EVAL_2D_NV* = 0x000086C0 - GL_EVAL_TRIANGULAR_2D_NV* = 0x000086C1 - GL_MAP_TESSELLATION_NV* = 0x000086C2 - GL_MAP_ATTRIB_U_ORDER_NV* = 0x000086C3 - GL_MAP_ATTRIB_V_ORDER_NV* = 0x000086C4 - GL_EVAL_FRACTIONAL_TESSELLATION_NV* = 0x000086C5 - GL_EVAL_VERTEX_ATTRIB0_NV* = 0x000086C6 - GL_EVAL_VERTEX_ATTRIB1_NV* = 0x000086C7 - GL_EVAL_VERTEX_ATTRIB2_NV* = 0x000086C8 - GL_EVAL_VERTEX_ATTRIB3_NV* = 0x000086C9 - GL_EVAL_VERTEX_ATTRIB4_NV* = 0x000086CA - GL_EVAL_VERTEX_ATTRIB5_NV* = 0x000086CB - GL_EVAL_VERTEX_ATTRIB6_NV* = 0x000086CC - GL_EVAL_VERTEX_ATTRIB7_NV* = 0x000086CD - GL_EVAL_VERTEX_ATTRIB8_NV* = 0x000086CE - GL_EVAL_VERTEX_ATTRIB9_NV* = 0x000086CF - GL_EVAL_VERTEX_ATTRIB10_NV* = 0x000086D0 - GL_EVAL_VERTEX_ATTRIB11_NV* = 0x000086D1 - GL_EVAL_VERTEX_ATTRIB12_NV* = 0x000086D2 - GL_EVAL_VERTEX_ATTRIB13_NV* = 0x000086D3 - GL_EVAL_VERTEX_ATTRIB14_NV* = 0x000086D4 - GL_EVAL_VERTEX_ATTRIB15_NV* = 0x000086D5 - GL_MAX_MAP_TESSELLATION_NV* = 0x000086D6 - GL_MAX_RATIONAL_EVAL_ORDER_NV* = 0x000086D7 # GL_NV_fence - GL_ALL_COMPLETED_NV* = 0x000084F2 - GL_FENCE_STATUS_NV* = 0x000084F3 - GL_FENCE_CONDITION_NV* = 0x000084F4 # GL_NV_float_buffer - GL_FLOAT_R_NV* = 0x00008880 - GL_FLOAT_RG_NV* = 0x00008881 - GL_FLOAT_RGB_NV* = 0x00008882 - GL_FLOAT_RGBA_NV* = 0x00008883 - GL_FLOAT_R16_NV* = 0x00008884 - GL_FLOAT_R32_NV* = 0x00008885 - GL_FLOAT_RG16_NV* = 0x00008886 - GL_FLOAT_RG32_NV* = 0x00008887 - GL_FLOAT_RGB16_NV* = 0x00008888 - GL_FLOAT_RGB32_NV* = 0x00008889 - GL_FLOAT_RGBA16_NV* = 0x0000888A - GL_FLOAT_RGBA32_NV* = 0x0000888B - GL_TEXTURE_FLOAT_COMPONENTS_NV* = 0x0000888C - GL_FLOAT_CLEAR_COLOR_VALUE_NV* = 0x0000888D - GL_FLOAT_RGBA_MODE_NV* = 0x0000888E # GL_NV_fog_distance - GL_FOG_DISTANCE_MODE_NV* = 0x0000855A - GL_EYE_RADIAL_NV* = 0x0000855B - GL_EYE_PLANE_ABSOLUTE_NV* = 0x0000855C # GL_NV_fragment_program - GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV* = 0x00008868 - GL_FRAGMENT_PROGRAM_NV* = 0x00008870 - GL_MAX_TEXTURE_COORDS_NV* = 0x00008871 - GL_MAX_TEXTURE_IMAGE_UNITS_NV* = 0x00008872 - GL_FRAGMENT_PROGRAM_BINDING_NV* = 0x00008873 - GL_PROGRAM_ERROR_STRING_NV* = 0x00008874 # GL_NV_half_float - GL_HALF_FLOAT_NV* = 0x0000140B # GL_NV_light_max_exponent - GL_MAX_SHININESS_NV* = 0x00008504 - GL_MAX_SPOT_EXPONENT_NV* = 0x00008505 # GL_NV_multisample_filter_hint - GL_MULTISAMPLE_FILTER_HINT_NV* = 0x00008534 # GL_NV_occlusion_query - GL_PIXEL_COUNTER_BITS_NV* = 0x00008864 - GL_CURRENT_OCCLUSION_QUERY_ID_NV* = 0x00008865 - GL_PIXEL_COUNT_NV* = 0x00008866 - GL_PIXEL_COUNT_AVAILABLE_NV* = 0x00008867 # GL_NV_packed_depth_stencil - GL_DEPTH_STENCIL_NV* = 0x000084F9 - GL_UNSIGNED_INT_24_8_NV* = 0x000084FA # GL_NV_pixel_data_range - GL_WRITE_PIXEL_DATA_RANGE_NV* = 0x00008878 - GL_READ_PIXEL_DATA_RANGE_NV* = 0x00008879 - GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV* = 0x0000887A - GL_READ_PIXEL_DATA_RANGE_LENGTH_NV* = 0x0000887B - GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV* = 0x0000887C - GL_READ_PIXEL_DATA_RANGE_POINTER_NV* = 0x0000887D # GL_NV_point_sprite - GL_POINT_SPRITE_NV* = 0x00008861 - GL_COORD_REPLACE_NV* = 0x00008862 - GL_POINT_SPRITE_R_MODE_NV* = 0x00008863 # GL_NV_primitive_restart - cGL_PRIMITIVE_RESTART_NV* = 0x00008558 - cGL_PRIMITIVE_RESTART_INDEX_NV* = 0x00008559 # GL_NV_register_combiners - GL_REGISTER_COMBINERS_NV* = 0x00008522 - GL_VARIABLE_A_NV* = 0x00008523 - GL_VARIABLE_B_NV* = 0x00008524 - GL_VARIABLE_C_NV* = 0x00008525 - GL_VARIABLE_D_NV* = 0x00008526 - GL_VARIABLE_E_NV* = 0x00008527 - GL_VARIABLE_F_NV* = 0x00008528 - GL_VARIABLE_G_NV* = 0x00008529 - GL_CONSTANT_COLOR0_NV* = 0x0000852A - GL_CONSTANT_COLOR1_NV* = 0x0000852B - GL_PRIMARY_COLOR_NV* = 0x0000852C - GL_SECONDARY_COLOR_NV* = 0x0000852D - GL_SPARE0_NV* = 0x0000852E - GL_SPARE1_NV* = 0x0000852F - GL_DISCARD_NV* = 0x00008530 - GL_E_TIMES_F_NV* = 0x00008531 - GL_SPARE0_PLUS_SECONDARY_COLOR_NV* = 0x00008532 - GL_UNSIGNED_IDENTITY_NV* = 0x00008536 - GL_UNSIGNED_INVERT_NV* = 0x00008537 - GL_EXPAND_NORMAL_NV* = 0x00008538 - GL_EXPAND_NEGATE_NV* = 0x00008539 - GL_HALF_BIAS_NORMAL_NV* = 0x0000853A - GL_HALF_BIAS_NEGATE_NV* = 0x0000853B - GL_SIGNED_IDENTITY_NV* = 0x0000853C - GL_SIGNED_NEGATE_NV* = 0x0000853D - GL_SCALE_BY_TWO_NV* = 0x0000853E - GL_SCALE_BY_FOUR_NV* = 0x0000853F - GL_SCALE_BY_ONE_HALF_NV* = 0x00008540 - GL_BIAS_BY_NEGATIVE_ONE_HALF_NV* = 0x00008541 - cGL_COMBINER_INPUT_NV* = 0x00008542 - GL_COMBINER_MAPPING_NV* = 0x00008543 - GL_COMBINER_COMPONENT_USAGE_NV* = 0x00008544 - GL_COMBINER_AB_DOT_PRODUCT_NV* = 0x00008545 - GL_COMBINER_CD_DOT_PRODUCT_NV* = 0x00008546 - GL_COMBINER_MUX_SUM_NV* = 0x00008547 - GL_COMBINER_SCALE_NV* = 0x00008548 - GL_COMBINER_BIAS_NV* = 0x00008549 - GL_COMBINER_AB_OUTPUT_NV* = 0x0000854A - GL_COMBINER_CD_OUTPUT_NV* = 0x0000854B - GL_COMBINER_SUM_OUTPUT_NV* = 0x0000854C - GL_MAX_GENERAL_COMBINERS_NV* = 0x0000854D - GL_NUM_GENERAL_COMBINERS_NV* = 0x0000854E - GL_COLOR_SUM_CLAMP_NV* = 0x0000854F - GL_COMBINER0_NV* = 0x00008550 - GL_COMBINER1_NV* = 0x00008551 - GL_COMBINER2_NV* = 0x00008552 - GL_COMBINER3_NV* = 0x00008553 - GL_COMBINER4_NV* = 0x00008554 - GL_COMBINER5_NV* = 0x00008555 - GL_COMBINER6_NV* = 0x00008556 - GL_COMBINER7_NV* = 0x00008557 # GL_NV_register_combiners2 - GL_PER_STAGE_CONSTANTS_NV* = 0x00008535 # GL_NV_texgen_emboss - GL_EMBOSS_LIGHT_NV* = 0x0000855D - GL_EMBOSS_CONSTANT_NV* = 0x0000855E - GL_EMBOSS_MAP_NV* = 0x0000855F # GL_NV_texgen_reflection - GL_NORMAL_MAP_NV* = 0x00008511 - GL_REFLECTION_MAP_NV* = 0x00008512 # GL_NV_texture_env_combine4 - GL_COMBINE4_NV* = 0x00008503 - GL_SOURCE3_RGB_NV* = 0x00008583 - GL_SOURCE3_ALPHA_NV* = 0x0000858B - GL_OPERAND3_RGB_NV* = 0x00008593 - GL_OPERAND3_ALPHA_NV* = 0x0000859B # GL_NV_texture_expand_normal - GL_TEXTURE_UNSIGNED_REMAP_MODE_NV* = 0x0000888F # GL_NV_texture_rectangle - GL_TEXTURE_RECTANGLE_NV* = 0x000084F5 - GL_TEXTURE_BINDING_RECTANGLE_NV* = 0x000084F6 - GL_PROXY_TEXTURE_RECTANGLE_NV* = 0x000084F7 - GL_MAX_RECTANGLE_TEXTURE_SIZE_NV* = 0x000084F8 # GL_NV_texture_shader - GL_OFFSET_TEXTURE_RECTANGLE_NV* = 0x0000864C - GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV* = 0x0000864D - GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV* = 0x0000864E - GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV* = 0x000086D9 - GL_UNSIGNED_INT_S8_S8_8_8_NV* = 0x000086DA - GL_UNSIGNED_INT_8_8_S8_S8_REV_NV* = 0x000086DB - GL_DSDT_MAG_INTENSITY_NV* = 0x000086DC - GL_SHADER_CONSISTENT_NV* = 0x000086DD - GL_TEXTURE_SHADER_NV* = 0x000086DE - GL_SHADER_OPERATION_NV* = 0x000086DF - GL_CULL_MODES_NV* = 0x000086E0 - GL_OFFSET_TEXTURE_MATRIX_NV* = 0x000086E1 - GL_OFFSET_TEXTURE_SCALE_NV* = 0x000086E2 - GL_OFFSET_TEXTURE_BIAS_NV* = 0x000086E3 - GL_OFFSET_TEXTURE_2D_MATRIX_NV* = GL_OFFSET_TEXTURE_MATRIX_NV - GL_OFFSET_TEXTURE_2D_SCALE_NV* = GL_OFFSET_TEXTURE_SCALE_NV - GL_OFFSET_TEXTURE_2D_BIAS_NV* = GL_OFFSET_TEXTURE_BIAS_NV - GL_PREVIOUS_TEXTURE_INPUT_NV* = 0x000086E4 - GL_CONST_EYE_NV* = 0x000086E5 - GL_PASS_THROUGH_NV* = 0x000086E6 - GL_CULL_FRAGMENT_NV* = 0x000086E7 - GL_OFFSET_TEXTURE_2D_NV* = 0x000086E8 - GL_DEPENDENT_AR_TEXTURE_2D_NV* = 0x000086E9 - GL_DEPENDENT_GB_TEXTURE_2D_NV* = 0x000086EA - GL_DOT_PRODUCT_NV* = 0x000086EC - GL_DOT_PRODUCT_DEPTH_REPLACE_NV* = 0x000086ED - GL_DOT_PRODUCT_TEXTURE_2D_NV* = 0x000086EE - GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV* = 0x000086F0 - GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV* = 0x000086F1 - GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV* = 0x000086F2 - GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV* = 0x000086F3 - GL_HILO_NV* = 0x000086F4 - GL_DSDT_NV* = 0x000086F5 - GL_DSDT_MAG_NV* = 0x000086F6 - GL_DSDT_MAG_VIB_NV* = 0x000086F7 - GL_HILO16_NV* = 0x000086F8 - GL_SIGNED_HILO_NV* = 0x000086F9 - GL_SIGNED_HILO16_NV* = 0x000086FA - GL_SIGNED_RGBA_NV* = 0x000086FB - GL_SIGNED_RGBA8_NV* = 0x000086FC - GL_SIGNED_RGB_NV* = 0x000086FE - GL_SIGNED_RGB8_NV* = 0x000086FF - GL_SIGNED_LUMINANCE_NV* = 0x00008701 - GL_SIGNED_LUMINANCE8_NV* = 0x00008702 - GL_SIGNED_LUMINANCE_ALPHA_NV* = 0x00008703 - GL_SIGNED_LUMINANCE8_ALPHA8_NV* = 0x00008704 - GL_SIGNED_ALPHA_NV* = 0x00008705 - GL_SIGNED_ALPHA8_NV* = 0x00008706 - GL_SIGNED_INTENSITY_NV* = 0x00008707 - GL_SIGNED_INTENSITY8_NV* = 0x00008708 - GL_DSDT8_NV* = 0x00008709 - GL_DSDT8_MAG8_NV* = 0x0000870A - GL_DSDT8_MAG8_INTENSITY8_NV* = 0x0000870B - GL_SIGNED_RGB_UNSIGNED_ALPHA_NV* = 0x0000870C - GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV* = 0x0000870D - GL_HI_SCALE_NV* = 0x0000870E - GL_LO_SCALE_NV* = 0x0000870F - GL_DS_SCALE_NV* = 0x00008710 - GL_DT_SCALE_NV* = 0x00008711 - GL_MAGNITUDE_SCALE_NV* = 0x00008712 - GL_VIBRANCE_SCALE_NV* = 0x00008713 - GL_HI_BIAS_NV* = 0x00008714 - GL_LO_BIAS_NV* = 0x00008715 - GL_DS_BIAS_NV* = 0x00008716 - GL_DT_BIAS_NV* = 0x00008717 - GL_MAGNITUDE_BIAS_NV* = 0x00008718 - GL_VIBRANCE_BIAS_NV* = 0x00008719 - GL_TEXTURE_BORDER_VALUES_NV* = 0x0000871A - GL_TEXTURE_HI_SIZE_NV* = 0x0000871B - GL_TEXTURE_LO_SIZE_NV* = 0x0000871C - GL_TEXTURE_DS_SIZE_NV* = 0x0000871D - GL_TEXTURE_DT_SIZE_NV* = 0x0000871E - GL_TEXTURE_MAG_SIZE_NV* = 0x0000871F # GL_NV_texture_shader2 - GL_DOT_PRODUCT_TEXTURE_3D_NV* = 0x000086EF # GL_NV_texture_shader3 - GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV* = 0x00008850 - GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV* = 0x00008851 - GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV* = 0x00008852 - GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV* = 0x00008853 - GL_OFFSET_HILO_TEXTURE_2D_NV* = 0x00008854 - GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV* = 0x00008855 - GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV* = 0x00008856 - GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV* = 0x00008857 - GL_DEPENDENT_HILO_TEXTURE_2D_NV* = 0x00008858 - GL_DEPENDENT_RGB_TEXTURE_3D_NV* = 0x00008859 - GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV* = 0x0000885A - GL_DOT_PRODUCT_PASS_THROUGH_NV* = 0x0000885B - GL_DOT_PRODUCT_TEXTURE_1D_NV* = 0x0000885C - GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV* = 0x0000885D - GL_HILO8_NV* = 0x0000885E - GL_SIGNED_HILO8_NV* = 0x0000885F - GL_FORCE_BLUE_TO_ONE_NV* = 0x00008860 # GL_NV_vertex_array_range - cGL_VERTEX_ARRAY_RANGE_NV* = 0x0000851D - GL_VERTEX_ARRAY_RANGE_LENGTH_NV* = 0x0000851E - GL_VERTEX_ARRAY_RANGE_VALID_NV* = 0x0000851F - GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV* = 0x00008520 - GL_VERTEX_ARRAY_RANGE_POINTER_NV* = 0x00008521 # GL_NV_vertex_array_range2 - GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV* = 0x00008533 # GL_NV_vertex_program - GL_VERTEX_PROGRAM_NV* = 0x00008620 - GL_VERTEX_STATE_PROGRAM_NV* = 0x00008621 - GL_ATTRIB_ARRAY_SIZE_NV* = 0x00008623 - GL_ATTRIB_ARRAY_STRIDE_NV* = 0x00008624 - GL_ATTRIB_ARRAYtyp_NV* = 0x00008625 - GL_CURRENT_ATTRIB_NV* = 0x00008626 - GL_PROGRAM_LENGTH_NV* = 0x00008627 - GL_PROGRAM_STRING_NV* = 0x00008628 - GL_MODELVIEW_PROJECTION_NV* = 0x00008629 - GL_IDENTITY_NV* = 0x0000862A - GL_INVERSE_NV* = 0x0000862B - GL_TRANSPOSE_NV* = 0x0000862C - GL_INVERSE_TRANSPOSE_NV* = 0x0000862D - GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV* = 0x0000862E - GL_MAX_TRACK_MATRICES_NV* = 0x0000862F - GL_MATRIX0_NV* = 0x00008630 - GL_MATRIX1_NV* = 0x00008631 - GL_MATRIX2_NV* = 0x00008632 - GL_MATRIX3_NV* = 0x00008633 - GL_MATRIX4_NV* = 0x00008634 - GL_MATRIX5_NV* = 0x00008635 - GL_MATRIX6_NV* = 0x00008636 - GL_MATRIX7_NV* = 0x00008637 - GL_CURRENT_MATRIX_STACK_DEPTH_NV* = 0x00008640 - GL_CURRENT_MATRIX_NV* = 0x00008641 - GL_VERTEX_PROGRAM_POINT_SIZE_NV* = 0x00008642 - GL_VERTEX_PROGRAM_TWO_SIDE_NV* = 0x00008643 - GL_PROGRAM_PARAMETER_NV* = 0x00008644 - GL_ATTRIB_ARRAY_POINTER_NV* = 0x00008645 - GL_PROGRAM_TARGET_NV* = 0x00008646 - GL_PROGRAM_RESIDENT_NV* = 0x00008647 - cGL_TRACK_MATRIX_NV* = 0x00008648 - GL_TRACK_MATRIX_TRANSFORM_NV* = 0x00008649 - GL_VERTEX_PROGRAM_BINDING_NV* = 0x0000864A - GL_PROGRAM_ERROR_POSITION_NV* = 0x0000864B - GL_VERTEX_ATTRIB_ARRAY0_NV* = 0x00008650 - GL_VERTEX_ATTRIB_ARRAY1_NV* = 0x00008651 - GL_VERTEX_ATTRIB_ARRAY2_NV* = 0x00008652 - GL_VERTEX_ATTRIB_ARRAY3_NV* = 0x00008653 - GL_VERTEX_ATTRIB_ARRAY4_NV* = 0x00008654 - GL_VERTEX_ATTRIB_ARRAY5_NV* = 0x00008655 - GL_VERTEX_ATTRIB_ARRAY6_NV* = 0x00008656 - GL_VERTEX_ATTRIB_ARRAY7_NV* = 0x00008657 - GL_VERTEX_ATTRIB_ARRAY8_NV* = 0x00008658 - GL_VERTEX_ATTRIB_ARRAY9_NV* = 0x00008659 - GL_VERTEX_ATTRIB_ARRAY10_NV* = 0x0000865A - GL_VERTEX_ATTRIB_ARRAY11_NV* = 0x0000865B - GL_VERTEX_ATTRIB_ARRAY12_NV* = 0x0000865C - GL_VERTEX_ATTRIB_ARRAY13_NV* = 0x0000865D - GL_VERTEX_ATTRIB_ARRAY14_NV* = 0x0000865E - GL_VERTEX_ATTRIB_ARRAY15_NV* = 0x0000865F - GL_MAP1_VERTEX_ATTRIB0_4_NV* = 0x00008660 - GL_MAP1_VERTEX_ATTRIB1_4_NV* = 0x00008661 - GL_MAP1_VERTEX_ATTRIB2_4_NV* = 0x00008662 - GL_MAP1_VERTEX_ATTRIB3_4_NV* = 0x00008663 - GL_MAP1_VERTEX_ATTRIB4_4_NV* = 0x00008664 - GL_MAP1_VERTEX_ATTRIB5_4_NV* = 0x00008665 - GL_MAP1_VERTEX_ATTRIB6_4_NV* = 0x00008666 - GL_MAP1_VERTEX_ATTRIB7_4_NV* = 0x00008667 - GL_MAP1_VERTEX_ATTRIB8_4_NV* = 0x00008668 - GL_MAP1_VERTEX_ATTRIB9_4_NV* = 0x00008669 - GL_MAP1_VERTEX_ATTRIB10_4_NV* = 0x0000866A - GL_MAP1_VERTEX_ATTRIB11_4_NV* = 0x0000866B - GL_MAP1_VERTEX_ATTRIB12_4_NV* = 0x0000866C - GL_MAP1_VERTEX_ATTRIB13_4_NV* = 0x0000866D - GL_MAP1_VERTEX_ATTRIB14_4_NV* = 0x0000866E - GL_MAP1_VERTEX_ATTRIB15_4_NV* = 0x0000866F - GL_MAP2_VERTEX_ATTRIB0_4_NV* = 0x00008670 - GL_MAP2_VERTEX_ATTRIB1_4_NV* = 0x00008671 - GL_MAP2_VERTEX_ATTRIB2_4_NV* = 0x00008672 - GL_MAP2_VERTEX_ATTRIB3_4_NV* = 0x00008673 - GL_MAP2_VERTEX_ATTRIB4_4_NV* = 0x00008674 - GL_MAP2_VERTEX_ATTRIB5_4_NV* = 0x00008675 - GL_MAP2_VERTEX_ATTRIB6_4_NV* = 0x00008676 - GL_MAP2_VERTEX_ATTRIB7_4_NV* = 0x00008677 - GL_MAP2_VERTEX_ATTRIB8_4_NV* = 0x00008678 - GL_MAP2_VERTEX_ATTRIB9_4_NV* = 0x00008679 - GL_MAP2_VERTEX_ATTRIB10_4_NV* = 0x0000867A - GL_MAP2_VERTEX_ATTRIB11_4_NV* = 0x0000867B - GL_MAP2_VERTEX_ATTRIB12_4_NV* = 0x0000867C - GL_MAP2_VERTEX_ATTRIB13_4_NV* = 0x0000867D - GL_MAP2_VERTEX_ATTRIB14_4_NV* = 0x0000867E - GL_MAP2_VERTEX_ATTRIB15_4_NV* = 0x0000867F # GL_NV_fragment_program2 and GL_NV_vertex_program2_option - GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV* = 0x000088F4 - GL_MAX_PROGRAM_CALL_DEPTH_NV* = 0x000088F5 # GL_NV_fragment_program2 - GL_MAX_PROGRAM_IF_DEPTH_NV* = 0x000088F6 - GL_MAX_PROGRAM_LOOP_DEPTH_NV* = 0x000088F7 - GL_MAX_PROGRAM_LOOP_COUNT_NV* = 0x000088F8 # GL_NV_vertex_program3 - MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB* = 0x00008B4C # GL_NV_depth_buffer_float - GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV* = 0x00008DAD - GL_DEPTH_BUFFER_FLOAT_MODE_NV* = 0x00008DAF # - # GL_NV_framebuffer_multisample_coverage - GL_RENDERBUFFER_COVERAGE_SAMPLES_NV* = 0x00008CAB - GL_RENDERBUFFER_COLOR_SAMPLES_NV* = 0x00008E10 # GL_NV_geometry_program4 - GL_GEOMETRY_PROGRAM_NV* = 0x00008C26 - GL_MAX_PROGRAM_OUTPUT_VERTICES_NV* = 0x00008C27 - GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV* = 0x00008C28 # GL_NV_gpu_program4 - GL_PROGRAM_ATTRIB_COMPONENTS_NV* = 0x00008906 - GL_PROGRAM_RESULT_COMPONENTS_NV* = 0x00008907 - GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV* = 0x00008908 - GL_MAX_PROGRAM_RESULT_COMPONENTS_NV* = 0x00008909 - GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV* = 0x00008DA5 - GL_MAX_PROGRAM_GENERIC_RESULTS_NV* = 0x00008DA6 # GL_NV_parameter_buffer_object - GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV* = 0x00008DA0 - GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV* = 0x00008DA1 - GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV* = 0x00008DA2 - GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV* = 0x00008DA3 - GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV* = 0x00008DA4 # GL_NV_transform_feedback - GL_TRANSFORM_FEEDBACK_BUFFER_NV* = 0x00008C8E - GL_TRANSFORM_FEEDBACK_BUFFER_START_NV* = 0x00008C84 - GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV* = 0x00008C85 - GL_TRANSFORM_FEEDBACK_RECORD_NV* = 0x00008C86 - GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV* = 0x00008C8F - GL_INTERLEAVED_ATTRIBS_NV* = 0x00008C8C - GL_SEPARATE_ATTRIBS_NV* = 0x00008C8D - GL_PRIMITIVES_GENERATED_NV* = 0x00008C87 - GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV* = 0x00008C88 - GL_RASTERIZER_DISCARD_NV* = 0x00008C89 - GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV* = 0x00008C8A - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV* = 0x00008C8B - GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV* = 0x00008C80 - cGL_TRANSFORM_FEEDBACK_ATTRIBS_NV* = 0x00008C7E - GL_ACTIVE_VARYINGS_NV* = 0x00008C81 - GL_ACTIVE_VARYING_MAX_LENGTH_NV* = 0x00008C82 - cGL_TRANSFORM_FEEDBACK_VARYINGS_NV* = 0x00008C83 - GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV* = 0x00008C7F - GL_BACK_PRIMARY_COLOR_NV* = 0x00008C77 - GL_BACK_SECONDARY_COLOR_NV* = 0x00008C78 - GL_TEXTURE_COORD_NV* = 0x00008C79 - GL_CLIP_DISTANCE_NV* = 0x00008C7A - GL_VERTEX_ID_NV* = 0x00008C7B - GL_PRIMITIVE_ID_NV* = 0x00008C7C - GL_GENERIC_ATTRIB_NV* = 0x00008C7D - GL_LAYER_NV* = 0x00008DAA - GL_NEXT_BUFFER_NV* = - 2 - GL_SKIP_COMPONENTS4_NV* = - 3 - GL_SKIP_COMPONENTS3_NV* = - 4 - GL_SKIP_COMPONENTS2_NV* = - 5 - GL_SKIP_COMPONENTS1_NV* = - 6 # GL_NV_conditional_render - GL_QUERY_WAIT_NV* = 0x00008E13 - GL_QUERY_NO_WAIT_NV* = 0x00008E14 - GL_QUERY_BY_REGION_WAIT_NV* = 0x00008E15 - GL_QUERY_BY_REGION_NO_WAIT_NV* = 0x00008E16 # GL_NV_present_video - GL_FRAME_NV* = 0x00008E26 - GL_FIELDS_NV* = 0x00008E27 - GL_CURRENT_TIME_NV* = 0x00008E28 - GL_NUM_FILL_STREAMS_NV* = 0x00008E29 - GL_PRESENT_TIME_NV* = 0x00008E2A - GL_PRESENT_DURATION_NV* = 0x00008E2B # GL_NV_explicit_multisample - GL_SAMPLE_POSITION_NV* = 0x00008E50 - GL_SAMPLE_MASK_NV* = 0x00008E51 - GL_SAMPLE_MASK_VALUE_NV* = 0x00008E52 - GL_TEXTURE_BINDING_RENDERBUFFER_NV* = 0x00008E53 - GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV* = 0x00008E54 - GL_TEXTURE_RENDERBUFFER_NV* = 0x00008E55 - GL_SAMPLER_RENDERBUFFER_NV* = 0x00008E56 - GL_INT_SAMPLER_RENDERBUFFER_NV* = 0x00008E57 - GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV* = 0x00008E58 - GL_MAX_SAMPLE_MASK_WORDS_NV* = 0x00008E59 # GL_NV_transform_feedback2 - GL_TRANSFORM_FEEDBACK_NV* = 0x00008E22 - GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV* = 0x00008E23 - GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV* = 0x00008E24 - GL_TRANSFORM_FEEDBACK_BINDING_NV* = 0x00008E25 # GL_NV_video_capture - GL_VIDEO_BUFFER_NV* = 0x00009020 - GL_VIDEO_BUFFER_BINDING_NV* = 0x00009021 - GL_FIELD_UPPER_NV* = 0x00009022 - GL_FIELD_LOWER_NV* = 0x00009023 - GL_NUM_VIDEO_CAPTURE_STREAMS_NV* = 0x00009024 - GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV* = 0x00009025 - GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV* = 0x00009026 - GL_LAST_VIDEO_CAPTURE_STATUS_NV* = 0x00009027 - GL_VIDEO_BUFFER_PITCH_NV* = 0x00009028 - GL_VIDEO_COLOR_CONVERSION_MATRIX_NV* = 0x00009029 - GL_VIDEO_COLOR_CONVERSION_MAX_NV* = 0x0000902A - GL_VIDEO_COLOR_CONVERSION_MIN_NV* = 0x0000902B - GL_VIDEO_COLOR_CONVERSION_OFFSET_NV* = 0x0000902C - GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV* = 0x0000902D - GL_PARTIAL_SUCCESS_NV* = 0x0000902E - GL_SUCCESS_NV* = 0x0000902F - GL_FAILURE_NV* = 0x00009030 - GL_YCBYCR8_422_NV* = 0x00009031 - GL_YCBAYCR8A_4224_NV* = 0x00009032 - GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV* = 0x00009033 - GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV* = 0x00009034 - GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV* = 0x00009035 - GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV* = 0x00009036 - GL_Z4Y12Z4CB12Z4CR12_444_NV* = 0x00009037 - GL_VIDEO_CAPTURE_FRAME_WIDTH_NV* = 0x00009038 - GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV* = 0x00009039 - GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV* = 0x0000903A - GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV* = 0x0000903B - GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV* = 0x0000903C # GL_NV_shader_buffer_load - GL_BUFFER_GPU_ADDRESS_NV* = 0x00008F1D - GL_GPU_ADDRESS_NV* = 0x00008F34 - GL_MAX_SHADER_BUFFER_ADDRESS_NV* = 0x00008F35 # - # GL_NV_vertex_buffer_unified_memory - GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV* = 0x00008F1E - GL_ELEMENT_ARRAY_UNIFIED_NV* = 0x00008F1F - GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV* = 0x00008F20 - GL_VERTEX_ARRAY_ADDRESS_NV* = 0x00008F21 - GL_NORMAL_ARRAY_ADDRESS_NV* = 0x00008F22 - GL_COLOR_ARRAY_ADDRESS_NV* = 0x00008F23 - GL_INDEX_ARRAY_ADDRESS_NV* = 0x00008F24 - GL_TEXTURE_COORD_ARRAY_ADDRESS_NV* = 0x00008F25 - GL_EDGE_FLAG_ARRAY_ADDRESS_NV* = 0x00008F26 - GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV* = 0x00008F27 - GL_FOG_COORD_ARRAY_ADDRESS_NV* = 0x00008F28 - GL_ELEMENT_ARRAY_ADDRESS_NV* = 0x00008F29 - GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV* = 0x00008F2A - GL_VERTEX_ARRAY_LENGTH_NV* = 0x00008F2B - GL_NORMAL_ARRAY_LENGTH_NV* = 0x00008F2C - GL_COLOR_ARRAY_LENGTH_NV* = 0x00008F2D - GL_INDEX_ARRAY_LENGTH_NV* = 0x00008F2E - GL_TEXTURE_COORD_ARRAY_LENGTH_NV* = 0x00008F2F - GL_EDGE_FLAG_ARRAY_LENGTH_NV* = 0x00008F30 - GL_SECONDARY_COLOR_ARRAY_LENGTH_NV* = 0x00008F31 - GL_FOG_COORD_ARRAY_LENGTH_NV* = 0x00008F32 - GL_ELEMENT_ARRAY_LENGTH_NV* = 0x00008F33 - GL_DRAW_INDIRECT_UNIFIED_NV* = 0x00008F40 - GL_DRAW_INDIRECT_ADDRESS_NV* = 0x00008F41 - GL_DRAW_INDIRECT_LENGTH_NV* = 0x00008F42 # GL_NV_gpu_program5 - GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV* = 0x00008E5A - GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV* = 0x00008E5B - GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV* = 0x00008E5C - GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV* = 0x00008E5D - GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV* = 0x00008E5E - GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV* = 0x00008E5F - GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV* = 0x00008F44 - GL_MAX_PROGRAM_SUBROUTINE_NUM_NV* = 0x00008F45 # GL_NV_gpu_shader5 - GL_INT64_NV* = 0x0000140E - GL_UNSIGNED_INT64_NV* = 0x0000140F - GL_INT8_NV* = 0x00008FE0 - GL_INT8_VEC2_NV* = 0x00008FE1 - GL_INT8_VEC3_NV* = 0x00008FE2 - GL_INT8_VEC4_NV* = 0x00008FE3 - GL_INT16_NV* = 0x00008FE4 - GL_INT16_VEC2_NV* = 0x00008FE5 - GL_INT16_VEC3_NV* = 0x00008FE6 - GL_INT16_VEC4_NV* = 0x00008FE7 - GL_INT64_VEC2_NV* = 0x00008FE9 - GL_INT64_VEC3_NV* = 0x00008FEA - GL_INT64_VEC4_NV* = 0x00008FEB - GL_UNSIGNED_INT8_NV* = 0x00008FEC - GL_UNSIGNED_INT8_VEC2_NV* = 0x00008FED - GL_UNSIGNED_INT8_VEC3_NV* = 0x00008FEE - GL_UNSIGNED_INT8_VEC4_NV* = 0x00008FEF - GL_UNSIGNED_INT16_NV* = 0x00008FF0 - GL_UNSIGNED_INT16_VEC2_NV* = 0x00008FF1 - GL_UNSIGNED_INT16_VEC3_NV* = 0x00008FF2 - GL_UNSIGNED_INT16_VEC4_NV* = 0x00008FF3 - GL_UNSIGNED_INT64_VEC2_NV* = 0x00008FF5 - GL_UNSIGNED_INT64_VEC3_NV* = 0x00008FF6 - GL_UNSIGNED_INT64_VEC4_NV* = 0x00008FF7 - GL_FLOAT16_NV* = 0x00008FF8 - GL_FLOAT16_VEC2_NV* = 0x00008FF9 - GL_FLOAT16_VEC3_NV* = 0x00008FFA - GL_FLOAT16_VEC4_NV* = 0x00008FFB # reuse GL_PATCHES - # GL_NV_shader_buffer_store - GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV* = 0x00000010 # reuse GL_READ_WRITE - # reuse GL_WRITE_ONLY - # - # GL_NV_tessellation_program5 - GL_MAX_PROGRAM_PATCH_ATTRIBS_NV* = 0x000086D8 - GL_TESS_CONTROL_PROGRAM_NV* = 0x0000891E - GL_TESS_EVALUATION_PROGRAM_NV* = 0x0000891F - GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV* = 0x00008C74 - GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV* = 0x00008C75 # - # GL_NV_vertex_attrib_integer_64bit - # reuse GL_INT64_NV - # reuse - # GL_UNSIGNED_INT64_NV - # - # GL_NV_multisample_coverage - GL_COVERAGE_SAMPLES_NV* = 0x000080A9 - GL_COLOR_SAMPLES_NV* = 0x00008E20 # GL_NV_vdpau_interop - GL_SURFACE_STATE_NV* = 0x000086EB - GL_SURFACE_REGISTERED_NV* = 0x000086FD - GL_SURFACE_MAPPED_NV* = 0x00008700 - GL_WRITE_DISCARD_NV* = 0x000088BE # GL_OML_interlace - GL_INTERLACE_OML* = 0x00008980 - GL_INTERLACE_READ_OML* = 0x00008981 # GL_OML_resample - GL_PACK_RESAMPLE_OML* = 0x00008984 - GL_UNPACK_RESAMPLE_OML* = 0x00008985 - GL_RESAMPLE_REPLICATE_OML* = 0x00008986 - GL_RESAMPLE_ZERO_FILL_OML* = 0x00008987 - GL_RESAMPLE_AVERAGE_OML* = 0x00008988 - GL_RESAMPLE_DECIMATE_OML* = 0x00008989 # GL_OML_subsample - GL_FORMAT_SUBSAMPLE_24_24_OML* = 0x00008982 - GL_FORMAT_SUBSAMPLE_244_244_OML* = 0x00008983 # GL_PGI_misc_hints - GL_PREFER_DOUBLEBUFFER_HINT_PGI* = 0x0001A1F8 - GL_CONSERVE_MEMORY_HINT_PGI* = 0x0001A1FD - GL_RECLAIM_MEMORY_HINT_PGI* = 0x0001A1FE - GL_NATIVE_GRAPHICS_HANDLE_PGI* = 0x0001A202 - GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI* = 0x0001A203 - GL_NATIVE_GRAPHICS_END_HINT_PGI* = 0x0001A204 - GL_ALWAYS_FAST_HINT_PGI* = 0x0001A20C - GL_ALWAYS_SOFT_HINT_PGI* = 0x0001A20D - GL_ALLOW_DRAW_OBJ_HINT_PGI* = 0x0001A20E - GL_ALLOW_DRAW_WIN_HINT_PGI* = 0x0001A20F - GL_ALLOW_DRAW_FRG_HINT_PGI* = 0x0001A210 - GL_ALLOW_DRAW_MEM_HINT_PGI* = 0x0001A211 - GL_STRICT_DEPTHFUNC_HINT_PGI* = 0x0001A216 - GL_STRICT_LIGHTING_HINT_PGI* = 0x0001A217 - GL_STRICT_SCISSOR_HINT_PGI* = 0x0001A218 - GL_FULL_STIPPLE_HINT_PGI* = 0x0001A219 - GL_CLIP_NEAR_HINT_PGI* = 0x0001A220 - GL_CLIP_FAR_HINT_PGI* = 0x0001A221 - GL_WIDE_LINE_HINT_PGI* = 0x0001A222 - GL_BACK_NORMALS_HINT_PGI* = 0x0001A223 # GL_PGI_vertex_hints - GL_VERTEX_DATA_HINT_PGI* = 0x0001A22A - GL_VERTEX_CONSISTENT_HINT_PGI* = 0x0001A22B - GL_MATERIAL_SIDE_HINT_PGI* = 0x0001A22C - GL_MAX_VERTEX_HINT_PGI* = 0x0001A22D - GL_COLOR3_BIT_PGI* = 0x00010000 - GL_COLOR4_BIT_PGI* = 0x00020000 - GL_EDGEFLAG_BIT_PGI* = 0x00040000 - GL_INDEX_BIT_PGI* = 0x00080000 - GL_MAT_AMBIENT_BIT_PGI* = 0x00100000 - GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI* = 0x00200000 - GL_MAT_DIFFUSE_BIT_PGI* = 0x00400000 - GL_MAT_EMISSION_BIT_PGI* = 0x00800000 - GL_MAT_COLOR_INDEXES_BIT_PGI* = 0x01000000 - GL_MAT_SHININESS_BIT_PGI* = 0x02000000 - GL_MAT_SPECULAR_BIT_PGI* = 0x04000000 - GL_NORMAL_BIT_PGI* = 0x08000000 - GL_TEXCOORD1_BIT_PGI* = 0x10000000 - GL_TEXCOORD2_BIT_PGI* = 0x20000000 - GL_TEXCOORD3_BIT_PGI* = 0x40000000 - GL_TEXCOORD4_BIT_PGI* = 0x80000000 - GL_VERTEX23_BIT_PGI* = 0x00000004 - GL_VERTEX4_BIT_PGI* = 0x00000008 # GL_REND_screen_coordinates - GL_SCREEN_COORDINATES_REND* = 0x00008490 - GL_INVERTED_SCREEN_W_REND* = 0x00008491 # GL_S3_s3tc - GL_RGB_S3TC* = 0x000083A0 - GL_RGB4_S3TC* = 0x000083A1 - GL_RGBA_S3TC* = 0x000083A2 - GL_RGBA4_S3TC* = 0x000083A3 # GL_SGIS_detail_texture - GL_DETAIL_TEXTURE_2D_SGIS* = 0x00008095 - GL_DETAIL_TEXTURE_2D_BINDING_SGIS* = 0x00008096 - GL_LINEAR_DETAIL_SGIS* = 0x00008097 - GL_LINEAR_DETAIL_ALPHA_SGIS* = 0x00008098 - GL_LINEAR_DETAIL_COLOR_SGIS* = 0x00008099 - GL_DETAIL_TEXTURE_LEVEL_SGIS* = 0x0000809A - GL_DETAIL_TEXTURE_MODE_SGIS* = 0x0000809B - GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS* = 0x0000809C # GL_SGIS_fog_function - cGL_FOG_FUNC_SGIS* = 0x0000812A - GL_FOG_FUNC_POINTS_SGIS* = 0x0000812B - GL_MAX_FOG_FUNC_POINTS_SGIS* = 0x0000812C # GL_SGIS_generate_mipmap - GL_GENERATE_MIPMAP_SGIS* = 0x00008191 - GL_GENERATE_MIPMAP_HINT_SGIS* = 0x00008192 # GL_SGIS_multisample - GL_MULTISAMPLE_SGIS* = 0x0000809D - GL_SAMPLE_ALPHA_TO_MASK_SGIS* = 0x0000809E - GL_SAMPLE_ALPHA_TO_ONE_SGIS* = 0x0000809F - cGL_SAMPLE_MASK_SGIS* = 0x000080A0 - GL_1PASS_SGIS* = 0x000080A1 - GL_2PASS_0_SGIS* = 0x000080A2 - GL_2PASS_1_SGIS* = 0x000080A3 - GL_4PASS_0_SGIS* = 0x000080A4 - GL_4PASS_1_SGIS* = 0x000080A5 - GL_4PASS_2_SGIS* = 0x000080A6 - GL_4PASS_3_SGIS* = 0x000080A7 - GL_SAMPLE_BUFFERS_SGIS* = 0x000080A8 - GL_SAMPLES_SGIS* = 0x000080A9 - GL_SAMPLE_MASK_VALUE_SGIS* = 0x000080AA - GL_SAMPLE_MASK_INVERT_SGIS* = 0x000080AB - cGL_SAMPLE_PATTERN_SGIS* = 0x000080AC # GL_SGIS_pixel_texture - GL_PIXEL_TEXTURE_SGIS* = 0x00008353 - GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS* = 0x00008354 - GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS* = 0x00008355 - GL_PIXEL_GROUP_COLOR_SGIS* = 0x00008356 # GL_SGIS_point_line_texgen - GL_EYE_DISTANCE_TO_POINT_SGIS* = 0x000081F0 - GL_OBJECT_DISTANCE_TO_POINT_SGIS* = 0x000081F1 - GL_EYE_DISTANCE_TO_LINE_SGIS* = 0x000081F2 - GL_OBJECT_DISTANCE_TO_LINE_SGIS* = 0x000081F3 - GL_EYE_POINT_SGIS* = 0x000081F4 - GL_OBJECT_POINT_SGIS* = 0x000081F5 - GL_EYE_LINE_SGIS* = 0x000081F6 - GL_OBJECT_LINE_SGIS* = 0x000081F7 # GL_SGIS_point_parameters - GL_POINT_SIZE_MIN_SGIS* = 0x00008126 - GL_POINT_SIZE_MAX_SGIS* = 0x00008127 - GL_POINT_FADE_THRESHOLD_SIZE_SGIS* = 0x00008128 - GL_DISTANCE_ATTENUATION_SGIS* = 0x00008129 # GL_SGIS_sharpen_texture - GL_LINEAR_SHARPEN_SGIS* = 0x000080AD - GL_LINEAR_SHARPEN_ALPHA_SGIS* = 0x000080AE - GL_LINEAR_SHARPEN_COLOR_SGIS* = 0x000080AF - GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS* = 0x000080B0 # GL_SGIS_texture4D - GL_PACK_SKIP_VOLUMES_SGIS* = 0x00008130 - GL_PACK_IMAGE_DEPTH_SGIS* = 0x00008131 - GL_UNPACK_SKIP_VOLUMES_SGIS* = 0x00008132 - GL_UNPACK_IMAGE_DEPTH_SGIS* = 0x00008133 - GL_TEXTURE_4D_SGIS* = 0x00008134 - GL_PROXY_TEXTURE_4D_SGIS* = 0x00008135 - GL_TEXTURE_4DSIZE_SGIS* = 0x00008136 - GL_TEXTURE_WRAP_Q_SGIS* = 0x00008137 - GL_MAX_4D_TEXTURE_SIZE_SGIS* = 0x00008138 - GL_TEXTURE_4D_BINDING_SGIS* = 0x0000814F # GL_SGIS_texture_color_mask - GL_TEXTURE_COLOR_WRITEMASK_SGIS* = 0x000081EF # GL_SGIS_texture_edge_clamp - GL_CLAMP_TO_EDGE_SGIS* = 0x0000812F # GL_SGIS_texture_filter4 - GL_FILTER4_SGIS* = 0x00008146 - GL_TEXTURE_FILTER4_SIZE_SGIS* = 0x00008147 # GL_SGIS_texture_lod - GL_TEXTURE_MIN_LOD_SGIS* = 0x0000813A - GL_TEXTURE_MAX_LOD_SGIS* = 0x0000813B - GL_TEXTURE_BASE_LEVEL_SGIS* = 0x0000813C - GL_TEXTURE_MAX_LEVEL_SGIS* = 0x0000813D # GL_SGIS_texture_select - GL_DUAL_ALPHA4_SGIS* = 0x00008110 - GL_DUAL_ALPHA8_SGIS* = 0x00008111 - GL_DUAL_ALPHA12_SGIS* = 0x00008112 - GL_DUAL_ALPHA16_SGIS* = 0x00008113 - GL_DUAL_LUMINANCE4_SGIS* = 0x00008114 - GL_DUAL_LUMINANCE8_SGIS* = 0x00008115 - GL_DUAL_LUMINANCE12_SGIS* = 0x00008116 - GL_DUAL_LUMINANCE16_SGIS* = 0x00008117 - GL_DUAL_INTENSITY4_SGIS* = 0x00008118 - GL_DUAL_INTENSITY8_SGIS* = 0x00008119 - GL_DUAL_INTENSITY12_SGIS* = 0x0000811A - GL_DUAL_INTENSITY16_SGIS* = 0x0000811B - GL_DUAL_LUMINANCE_ALPHA4_SGIS* = 0x0000811C - GL_DUAL_LUMINANCE_ALPHA8_SGIS* = 0x0000811D - GL_QUAD_ALPHA4_SGIS* = 0x0000811E - GL_QUAD_ALPHA8_SGIS* = 0x0000811F - GL_QUAD_LUMINANCE4_SGIS* = 0x00008120 - GL_QUAD_LUMINANCE8_SGIS* = 0x00008121 - GL_QUAD_INTENSITY4_SGIS* = 0x00008122 - GL_QUAD_INTENSITY8_SGIS* = 0x00008123 - GL_DUAL_TEXTURE_SELECT_SGIS* = 0x00008124 - GL_QUAD_TEXTURE_SELECT_SGIS* = 0x00008125 # GL_SGIX_async - cGL_ASYNC_MARKER_SGIX* = 0x00008329 # GL_SGIX_async_histogram - GL_ASYNC_HISTOGRAM_SGIX* = 0x0000832C - GL_MAX_ASYNC_HISTOGRAM_SGIX* = 0x0000832D # GL_SGIX_async_pixel - GL_ASYNC_TEX_IMAGE_SGIX* = 0x0000835C - GL_ASYNC_DRAW_PIXELS_SGIX* = 0x0000835D - GL_ASYNC_READ_PIXELS_SGIX* = 0x0000835E - GL_MAX_ASYNC_TEX_IMAGE_SGIX* = 0x0000835F - GL_MAX_ASYNC_DRAW_PIXELS_SGIX* = 0x00008360 - GL_MAX_ASYNC_READ_PIXELS_SGIX* = 0x00008361 # GL_SGIX_blend_alpha_minmax - GL_ALPHA_MIN_SGIX* = 0x00008320 - GL_ALPHA_MAX_SGIX* = 0x00008321 # GL_SGIX_calligraphic_fragment - GL_CALLIGRAPHIC_FRAGMENT_SGIX* = 0x00008183 # GL_SGIX_clipmap - GL_LINEAR_CLIPMAP_LINEAR_SGIX* = 0x00008170 - GL_TEXTURE_CLIPMAP_CENTER_SGIX* = 0x00008171 - GL_TEXTURE_CLIPMAP_FRAME_SGIX* = 0x00008172 - GL_TEXTURE_CLIPMAP_OFFSET_SGIX* = 0x00008173 - GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX* = 0x00008174 - GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX* = 0x00008175 - GL_TEXTURE_CLIPMAP_DEPTH_SGIX* = 0x00008176 - GL_MAX_CLIPMAP_DEPTH_SGIX* = 0x00008177 - GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX* = 0x00008178 - GL_NEAREST_CLIPMAP_NEAREST_SGIX* = 0x0000844D - GL_NEAREST_CLIPMAP_LINEAR_SGIX* = 0x0000844E - GL_LINEAR_CLIPMAP_NEAREST_SGIX* = 0x0000844F # GL_SGIX_convolution_accuracy - GL_CONVOLUTION_HINT_SGIX* = 0x00008316 # GL_SGIX_depth_texture - GL_DEPTH_COMPONENT16_SGIX* = 0x000081A5 - GL_DEPTH_COMPONENT24_SGIX* = 0x000081A6 - GL_DEPTH_COMPONENT32_SGIX* = 0x000081A7 # GL_SGIX_fog_offset - GL_FOG_OFFSET_SGIX* = 0x00008198 - GL_FOG_OFFSET_VALUE_SGIX* = 0x00008199 # GL_SGIX_fog_scale - GL_FOG_SCALE_SGIX* = 0x000081FC - GL_FOG_SCALE_VALUE_SGIX* = 0x000081FD # GL_SGIX_fragment_lighting - GL_FRAGMENT_LIGHTING_SGIX* = 0x00008400 - cGL_FRAGMENT_COLOR_MATERIAL_SGIX* = 0x00008401 - GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX* = 0x00008402 - GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX* = 0x00008403 - GL_MAX_FRAGMENT_LIGHTS_SGIX* = 0x00008404 - GL_MAX_ACTIVE_LIGHTS_SGIX* = 0x00008405 - GL_CURRENT_RASTER_NORMAL_SGIX* = 0x00008406 - GL_LIGHT_ENV_MODE_SGIX* = 0x00008407 - GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX* = 0x00008408 - GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX* = 0x00008409 - GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX* = 0x0000840A - GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX* = 0x0000840B - GL_FRAGMENT_LIGHT0_SGIX* = 0x0000840C - GL_FRAGMENT_LIGHT1_SGIX* = 0x0000840D - GL_FRAGMENT_LIGHT2_SGIX* = 0x0000840E - GL_FRAGMENT_LIGHT3_SGIX* = 0x0000840F - GL_FRAGMENT_LIGHT4_SGIX* = 0x00008410 - GL_FRAGMENT_LIGHT5_SGIX* = 0x00008411 - GL_FRAGMENT_LIGHT6_SGIX* = 0x00008412 - GL_FRAGMENT_LIGHT7_SGIX* = 0x00008413 # GL_SGIX_framezoom - cGL_FRAMEZOOM_SGIX* = 0x0000818B - GL_FRAMEZOOM_FACTOR_SGIX* = 0x0000818C - GL_MAX_FRAMEZOOM_FACTOR_SGIX* = 0x0000818D # GL_SGIX_impact_pixel_texture - GL_PIXEL_TEX_GEN_Q_CEILING_SGIX* = 0x00008184 - GL_PIXEL_TEX_GEN_Q_ROUND_SGIX* = 0x00008185 - GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX* = 0x00008186 - GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX* = 0x00008187 - GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX* = 0x00008188 - GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX* = 0x00008189 - GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX* = 0x0000818A # GL_SGIX_instruments - GL_INSTRUMENT_BUFFER_POINTER_SGIX* = 0x00008180 - GL_INSTRUMENT_MEASUREMENTS_SGIX* = 0x00008181 # GL_SGIX_interlace - GL_INTERLACE_SGIX* = 0x00008094 # GL_SGIX_ir_instrument1 - GL_IR_INSTRUMENT1_SGIX* = 0x0000817F # GL_SGIX_list_priority - GL_LIST_PRIORITY_SGIX* = 0x00008182 # GL_SGIX_pixel_texture - cGL_PIXEL_TEX_GEN_SGIX* = 0x00008139 - GL_PIXEL_TEX_GEN_MODE_SGIX* = 0x0000832B # GL_SGIX_pixel_tiles - GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX* = 0x0000813E - GL_PIXEL_TILE_CACHE_INCREMENT_SGIX* = 0x0000813F - GL_PIXEL_TILE_WIDTH_SGIX* = 0x00008140 - GL_PIXEL_TILE_HEIGHT_SGIX* = 0x00008141 - GL_PIXEL_TILE_GRID_WIDTH_SGIX* = 0x00008142 - GL_PIXEL_TILE_GRID_HEIGHT_SGIX* = 0x00008143 - GL_PIXEL_TILE_GRID_DEPTH_SGIX* = 0x00008144 - GL_PIXEL_TILE_CACHE_SIZE_SGIX* = 0x00008145 # GL_SGIX_polynomial_ffd - GL_GEOMETRY_DEFORMATION_SGIX* = 0x00008194 - GL_TEXTURE_DEFORMATION_SGIX* = 0x00008195 - GL_DEFORMATIONS_MASK_SGIX* = 0x00008196 - GL_MAX_DEFORMATION_ORDER_SGIX* = 0x00008197 # GL_SGIX_reference_plane - cGL_REFERENCE_PLANE_SGIX* = 0x0000817D - GL_REFERENCE_PLANE_EQUATION_SGIX* = 0x0000817E # GL_SGIX_resample - GL_PACK_RESAMPLE_SGIX* = 0x0000842C - GL_UNPACK_RESAMPLE_SGIX* = 0x0000842D - GL_RESAMPLE_REPLICATE_SGIX* = 0x0000842E - GL_RESAMPLE_ZERO_FILL_SGIX* = 0x0000842F - GL_RESAMPLE_DECIMATE_SGIX* = 0x00008430 # GL_SGIX_scalebias_hint - GL_SCALEBIAS_HINT_SGIX* = 0x00008322 # GL_SGIX_shadow - GL_TEXTURE_COMPARE_SGIX* = 0x0000819A - GL_TEXTURE_COMPARE_OPERATOR_SGIX* = 0x0000819B - GL_TEXTURE_LEQUAL_R_SGIX* = 0x0000819C - GL_TEXTURE_GEQUAL_R_SGIX* = 0x0000819D # GL_SGIX_shadow_ambient - GL_SHADOW_AMBIENT_SGIX* = 0x000080BF # GL_SGIX_sprite - GL_SPRITE_SGIX* = 0x00008148 - GL_SPRITE_MODE_SGIX* = 0x00008149 - GL_SPRITE_AXIS_SGIX* = 0x0000814A - GL_SPRITE_TRANSLATION_SGIX* = 0x0000814B - GL_SPRITE_AXIAL_SGIX* = 0x0000814C - GL_SPRITE_OBJECT_ALIGNED_SGIX* = 0x0000814D - GL_SPRITE_EYE_ALIGNED_SGIX* = 0x0000814E # GL_SGIX_subsample - GL_PACK_SUBSAMPLE_RATE_SGIX* = 0x000085A0 - GL_UNPACK_SUBSAMPLE_RATE_SGIX* = 0x000085A1 - GL_PIXEL_SUBSAMPLE_4444_SGIX* = 0x000085A2 - GL_PIXEL_SUBSAMPLE_2424_SGIX* = 0x000085A3 - GL_PIXEL_SUBSAMPLE_4242_SGIX* = 0x000085A4 # GL_SGIX_texture_add_env - GL_TEXTURE_ENV_BIAS_SGIX* = 0x000080BE # GL_SGIX_texture_coordinate_clamp - GL_TEXTURE_MAX_CLAMP_S_SGIX* = 0x00008369 - GL_TEXTURE_MAX_CLAMP_T_SGIX* = 0x0000836A - GL_TEXTURE_MAX_CLAMP_R_SGIX* = 0x0000836B # GL_SGIX_texture_lod_bias - GL_TEXTURE_LOD_BIAS_S_SGIX* = 0x0000818E - GL_TEXTURE_LOD_BIAS_T_SGIX* = 0x0000818F - GL_TEXTURE_LOD_BIAS_R_SGIX* = 0x00008190 # GL_SGIX_texture_multi_buffer - GL_TEXTURE_MULTI_BUFFER_HINT_SGIX* = 0x0000812E # GL_SGIX_texture_scale_bias - GL_POST_TEXTURE_FILTER_BIAS_SGIX* = 0x00008179 - GL_POST_TEXTURE_FILTER_SCALE_SGIX* = 0x0000817A - GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX* = 0x0000817B - GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX* = 0x0000817C # GL_SGIX_vertex_preclip - GL_VERTEX_PRECLIP_SGIX* = 0x000083EE - GL_VERTEX_PRECLIP_HINT_SGIX* = 0x000083EF # GL_SGIX_ycrcb - GL_YCRCB_422_SGIX* = 0x000081BB - GL_YCRCB_444_SGIX* = 0x000081BC # GL_SGIX_ycrcba - GL_YCRCB_SGIX* = 0x00008318 - GL_YCRCBA_SGIX* = 0x00008319 # GL_SGI_color_matrix - GL_COLOR_MATRIX_SGI* = 0x000080B1 - GL_COLOR_MATRIX_STACK_DEPTH_SGI* = 0x000080B2 - GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI* = 0x000080B3 - GL_POST_COLOR_MATRIX_RED_SCALE_SGI* = 0x000080B4 - GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI* = 0x000080B5 - GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI* = 0x000080B6 - GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI* = 0x000080B7 - GL_POST_COLOR_MATRIX_RED_BIAS_SGI* = 0x000080B8 - GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI* = 0x000080B9 - GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI* = 0x000080BA - GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI* = 0x000080BB # GL_SGI_color_table - cGL_COLOR_TABLE_SGI* = 0x000080D0 - GL_POST_CONVOLUTION_COLOR_TABLE_SGI* = 0x000080D1 - GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI* = 0x000080D2 - GL_PROXY_COLOR_TABLE_SGI* = 0x000080D3 - GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI* = 0x000080D4 - GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI* = 0x000080D5 - GL_COLOR_TABLE_SCALE_SGI* = 0x000080D6 - GL_COLOR_TABLE_BIAS_SGI* = 0x000080D7 - GL_COLOR_TABLE_FORMAT_SGI* = 0x000080D8 - GL_COLOR_TABLE_WIDTH_SGI* = 0x000080D9 - GL_COLOR_TABLE_RED_SIZE_SGI* = 0x000080DA - GL_COLOR_TABLE_GREEN_SIZE_SGI* = 0x000080DB - GL_COLOR_TABLE_BLUE_SIZE_SGI* = 0x000080DC - GL_COLOR_TABLE_ALPHA_SIZE_SGI* = 0x000080DD - GL_COLOR_TABLE_LUMINANCE_SIZE_SGI* = 0x000080DE - GL_COLOR_TABLE_INTENSITY_SIZE_SGI* = 0x000080DF # GL_SGI_depth_pass_instrument - GL_DEPTH_PASS_INSTRUMENT_SGIX* = 0x00008310 - GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX* = 0x00008311 - GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX* = 0x00008312 # GL_SGI_texture_color_table - GL_TEXTURE_COLOR_TABLE_SGI* = 0x000080BC - GL_PROXY_TEXTURE_COLOR_TABLE_SGI* = 0x000080BD # GL_SUNX_constant_data - GL_UNPACK_CONSTANT_DATA_SUNX* = 0x000081D5 - GL_TEXTURE_CONSTANT_DATA_SUNX* = 0x000081D6 # GL_SUN_convolution_border_modes - GL_WRAP_BORDER_SUN* = 0x000081D4 # GL_SUN_global_alpha - GL_GLOBAL_ALPHA_SUN* = 0x000081D9 - GL_GLOBAL_ALPHA_FACTOR_SUN* = 0x000081DA # GL_SUN_mesh_array - GL_QUAD_MESH_SUN* = 0x00008614 - GL_TRIANGLE_MESH_SUN* = 0x00008615 # GL_SUN_slice_accum - GL_SLICE_ACCUM_SUN* = 0x000085CC # GL_SUN_triangle_list - GL_RESTART_SUN* = 0x00000001 - GL_REPLACE_MIDDLE_SUN* = 0x00000002 - GL_REPLACE_OLDEST_SUN* = 0x00000003 - GL_TRIANGLE_LIST_SUN* = 0x000081D7 - GL_REPLACEMENT_CODE_SUN* = 0x000081D8 - GL_REPLACEMENT_CODE_ARRAY_SUN* = 0x000085C0 - GL_REPLACEMENT_CODE_ARRAYtyp_SUN* = 0x000085C1 - GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN* = 0x000085C2 - GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN* = 0x000085C3 - GL_R1UI_V3F_SUN* = 0x000085C4 - GL_R1UI_C4UB_V3F_SUN* = 0x000085C5 - GL_R1UI_C3F_V3F_SUN* = 0x000085C6 - GL_R1UI_N3F_V3F_SUN* = 0x000085C7 - GL_R1UI_C4F_N3F_V3F_SUN* = 0x000085C8 - GL_R1UI_T2F_V3F_SUN* = 0x000085C9 - GL_R1UI_T2F_N3F_V3F_SUN* = 0x000085CA - GL_R1UI_T2F_C4F_N3F_V3F_SUN* = 0x000085CB # GL_WIN_phong_shading - GL_PHONG_WIN* = 0x000080EA - GL_PHONG_HINT_WIN* = 0x000080EB # GL_WIN_specular_fog - GL_FOG_SPECULAR_TEXTURE_WIN* = 0x000080EC # GL_ARB_vertex_shader - GL_VERTEX_SHADER_ARB* = 0x00008B31 - GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB* = 0x00008B4A - GL_MAX_VARYING_FLOATS_ARB* = 0x00008B4B - GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB* = 0x00008B4C - GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB* = 0x00008B4D - GL_OBJECT_ACTIVE_ATTRIBUTES_ARB* = 0x00008B89 - GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB* = 0x00008B8A # GL_ARB_fragment_shader - GL_FRAGMENT_SHADER_ARB* = 0x00008B30 - GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB* = 0x00008B49 # 1.4 - GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB* = 0x00008B8B # 1.4 - # GL_ARB_occlusion_query - GL_SAMPLES_PASSED_ARB* = 0x00008914 - GL_QUERY_COUNTER_BITS_ARB* = 0x00008864 - GL_CURRENT_QUERY_ARB* = 0x00008865 - GL_QUERY_RESULT_ARB* = 0x00008866 - GL_QUERY_RESULT_AVAILABLE_ARB* = 0x00008867 # GL_ARB_point_sprite - GL_POINT_SPRITE_ARB* = 0x00008861 - GL_COORD_REPLACE_ARB* = 0x00008862 # GL_ARB_shading_language_100 - GL_SHADING_LANGUAGE_VERSION_ARB* = 0x00008B8C # 1.4 - # GL_ARB_shader_objects - GL_PROGRAM_OBJECT_ARB* = 0x00008B40 - GL_OBJECTtyp_ARB* = 0x00008B4E - GL_OBJECT_SUBtypARB* = 0x00008B4F - GL_OBJECT_DELETE_STATUS_ARB* = 0x00008B80 - GL_OBJECT_COMPILE_STATUS_ARB* = 0x00008B81 - GL_OBJECT_LINK_STATUS_ARB* = 0x00008B82 - GL_OBJECT_VALIDATE_STATUS_ARB* = 0x00008B83 - GL_OBJECT_INFO_LOG_LENGTH_ARB* = 0x00008B84 - GL_OBJECT_ATTACHED_OBJECTS_ARB* = 0x00008B85 - GL_OBJECT_ACTIVE_UNIFORMS_ARB* = 0x00008B86 - GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB* = 0x00008B87 - GL_OBJECT_SHADER_SOURCE_LENGTH_ARB* = 0x00008B88 - GL_SHADER_OBJECT_ARB* = 0x00008B48 - GL_FLOAT_VEC2_ARB* = 0x00008B50 - GL_FLOAT_VEC3_ARB* = 0x00008B51 - GL_FLOAT_VEC4_ARB* = 0x00008B52 - GL_INT_VEC2_ARB* = 0x00008B53 - GL_INT_VEC3_ARB* = 0x00008B54 - GL_INT_VEC4_ARB* = 0x00008B55 - GL_BOOL_ARB* = 0x00008B56 - GL_BOOL_VEC2_ARB* = 0x00008B57 - GL_BOOL_VEC3_ARB* = 0x00008B58 - GL_BOOL_VEC4_ARB* = 0x00008B59 - GL_FLOAT_MAT2_ARB* = 0x00008B5A - GL_FLOAT_MAT3_ARB* = 0x00008B5B - GL_FLOAT_MAT4_ARB* = 0x00008B5C - GL_SAMPLER_1D_ARB* = 0x00008B5D - GL_SAMPLER_2D_ARB* = 0x00008B5E - GL_SAMPLER_3D_ARB* = 0x00008B5F - GL_SAMPLER_CUBE_ARB* = 0x00008B60 - GL_SAMPLER_1D_SHADOW_ARB* = 0x00008B61 - GL_SAMPLER_2D_SHADOW_ARB* = 0x00008B62 - GL_SAMPLER_2D_RECT_ARB* = 0x00008B63 - GL_SAMPLER_2D_RECT_SHADOW_ARB* = 0x00008B64 # WGL_3DFX_multisample - WGL_SAMPLE_BUFFERS_3DFX* = 0x00002060 - WGL_SAMPLES_3DFX* = 0x00002061 # WGL_ARB_buffer_region - WGL_FRONT_COLOR_BUFFER_BIT_ARB* = 0x00000001 - WGL_BACK_COLOR_BUFFER_BIT_ARB* = 0x00000002 - WGL_DEPTH_BUFFER_BIT_ARB* = 0x00000004 - WGL_STENCIL_BUFFER_BIT_ARB* = 0x00000008 # WGL_ARB_make_current_read - ERROR_INVALID_PIXELtyp_ARB* = 0x00002043 - ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB* = 0x00002054 # WGL_ARB_multisample - WGL_SAMPLE_BUFFERS_ARB* = 0x00002041 - WGL_SAMPLES_ARB* = 0x00002042 # WGL_ARB_pbuffer - WGL_DRAW_TO_PBUFFER_ARB* = 0x0000202D - WGL_MAX_PBUFFER_PIXELS_ARB* = 0x0000202E - WGL_MAX_PBUFFER_WIDTH_ARB* = 0x0000202F - WGL_MAX_PBUFFER_HEIGHT_ARB* = 0x00002030 - WGL_PBUFFER_LARGEST_ARB* = 0x00002033 - WGL_PBUFFER_WIDTH_ARB* = 0x00002034 - WGL_PBUFFER_HEIGHT_ARB* = 0x00002035 - WGL_PBUFFER_LOST_ARB* = 0x00002036 # WGL_ARB_pixel_format - WGL_NUMBER_PIXEL_FORMATS_ARB* = 0x00002000 - WGL_DRAW_TO_WINDOW_ARB* = 0x00002001 - WGL_DRAW_TO_BITMAP_ARB* = 0x00002002 - WGL_ACCELERATION_ARB* = 0x00002003 - WGL_NEED_PALETTE_ARB* = 0x00002004 - WGL_NEED_SYSTEM_PALETTE_ARB* = 0x00002005 - WGL_SWAP_LAYER_BUFFERS_ARB* = 0x00002006 - WGL_SWAP_METHOD_ARB* = 0x00002007 - WGL_NUMBER_OVERLAYS_ARB* = 0x00002008 - WGL_NUMBER_UNDERLAYS_ARB* = 0x00002009 - WGL_TRANSPARENT_ARB* = 0x0000200A - WGL_TRANSPARENT_RED_VALUE_ARB* = 0x00002037 - WGL_TRANSPARENT_GREEN_VALUE_ARB* = 0x00002038 - WGL_TRANSPARENT_BLUE_VALUE_ARB* = 0x00002039 - WGL_TRANSPARENT_ALPHA_VALUE_ARB* = 0x0000203A - WGL_TRANSPARENT_INDEX_VALUE_ARB* = 0x0000203B - WGL_SHARE_DEPTH_ARB* = 0x0000200C - WGL_SHARE_STENCIL_ARB* = 0x0000200D - WGL_SHARE_ACCUM_ARB* = 0x0000200E - WGL_SUPPORT_GDI_ARB* = 0x0000200F - WGL_SUPPORT_OPENGL_ARB* = 0x00002010 - WGL_DOUBLE_BUFFER_ARB* = 0x00002011 - WGL_STEREO_ARB* = 0x00002012 - WGL_PIXELtyp_ARB* = 0x00002013 - WGL_COLOR_BITS_ARB* = 0x00002014 - WGL_RED_BITS_ARB* = 0x00002015 - WGL_RED_SHIFT_ARB* = 0x00002016 - WGL_GREEN_BITS_ARB* = 0x00002017 - WGL_GREEN_SHIFT_ARB* = 0x00002018 - WGL_BLUE_BITS_ARB* = 0x00002019 - WGL_BLUE_SHIFT_ARB* = 0x0000201A - WGL_ALPHA_BITS_ARB* = 0x0000201B - WGL_ALPHA_SHIFT_ARB* = 0x0000201C - WGL_ACCUM_BITS_ARB* = 0x0000201D - WGL_ACCUM_RED_BITS_ARB* = 0x0000201E - WGL_ACCUM_GREEN_BITS_ARB* = 0x0000201F - WGL_ACCUM_BLUE_BITS_ARB* = 0x00002020 - WGL_ACCUM_ALPHA_BITS_ARB* = 0x00002021 - WGL_DEPTH_BITS_ARB* = 0x00002022 - WGL_STENCIL_BITS_ARB* = 0x00002023 - WGL_AUX_BUFFERS_ARB* = 0x00002024 - WGL_NO_ACCELERATION_ARB* = 0x00002025 - WGL_GENERIC_ACCELERATION_ARB* = 0x00002026 - WGL_FULL_ACCELERATION_ARB* = 0x00002027 - WGL_SWAP_EXCHANGE_ARB* = 0x00002028 - WGL_SWAP_COPY_ARB* = 0x00002029 - WGL_SWAP_UNDEFINED_ARB* = 0x0000202A - WGLtyp_RGBA_ARB* = 0x0000202B - WGLtyp_COLORINDEX_ARB* = 0x0000202C # WGL_ARB_pixel_format_float - WGL_RGBA_FLOAT_MODE_ARB* = 0x00008820 - WGL_CLAMP_VERTEX_COLOR_ARB* = 0x0000891A - WGL_CLAMP_FRAGMENT_COLOR_ARB* = 0x0000891B - WGL_CLAMP_READ_COLOR_ARB* = 0x0000891C - WGL_FIXED_ONLY_ARB* = 0x0000891D # WGL_ARB_render_texture - WGL_BIND_TO_TEXTURE_RGB_ARB* = 0x00002070 - WGL_BIND_TO_TEXTURE_RGBA_ARB* = 0x00002071 - WGL_TEXTURE_FORMAT_ARB* = 0x00002072 - WGL_TEXTURE_TARGET_ARB* = 0x00002073 - WGL_MIPMAP_TEXTURE_ARB* = 0x00002074 - WGL_TEXTURE_RGB_ARB* = 0x00002075 - WGL_TEXTURE_RGBA_ARB* = 0x00002076 - WGL_NO_TEXTURE_ARB* = 0x00002077 - WGL_TEXTURE_CUBE_MAP_ARB* = 0x00002078 - WGL_TEXTURE_1D_ARB* = 0x00002079 - WGL_TEXTURE_2D_ARB* = 0x0000207A - WGL_MIPMAP_LEVEL_ARB* = 0x0000207B - WGL_CUBE_MAP_FACE_ARB* = 0x0000207C - WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB* = 0x0000207D - WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB* = 0x0000207E - WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB* = 0x0000207F - WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB* = 0x00002080 - WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB* = 0x00002081 - WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB* = 0x00002082 - WGL_FRONT_LEFT_ARB* = 0x00002083 - WGL_FRONT_RIGHT_ARB* = 0x00002084 - WGL_BACK_LEFT_ARB* = 0x00002085 - WGL_BACK_RIGHT_ARB* = 0x00002086 - WGL_AUX0_ARB* = 0x00002087 - WGL_AUX1_ARB* = 0x00002088 - WGL_AUX2_ARB* = 0x00002089 - WGL_AUX3_ARB* = 0x0000208A - WGL_AUX4_ARB* = 0x0000208B - WGL_AUX5_ARB* = 0x0000208C - WGL_AUX6_ARB* = 0x0000208D - WGL_AUX7_ARB* = 0x0000208E - WGL_AUX8_ARB* = 0x0000208F - WGL_AUX9_ARB* = 0x00002090 # WGL_ARB_create_context - WGL_CONTEXT_DEBUG_BIT_ARB* = 0x00000001 - WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB* = 0x00000002 - WGL_CONTEXT_MAJOR_VERSION_ARB* = 0x00002091 - WGL_CONTEXT_MINOR_VERSION_ARB* = 0x00002092 - WGL_CONTEXT_LAYER_PLANE_ARB* = 0x00002093 - WGL_CONTEXT_FLAGS_ARB* = 0x00002094 - ERROR_INVALID_VERSION_ARB* = 0x00002095 # WGL_ARB_create_context_profile - WGL_CONTEXT_PROFILE_MASK_ARB* = 0x00009126 - WGL_CONTEXT_CORE_PROFILE_BIT_ARB* = 0x00000001 - WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB* = 0x00000002 - ERROR_INVALID_PROFILE_ARB* = 0x00002096 # WGL_ARB_framebuffer_sRGB - WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB* = 0x000020A9 # - # WGL_ARB_create_context_robustness - WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB* = 0x00000004 - WGL_LOSE_CONTEXT_ON_RESET_ARB* = 0x00008252 - WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB* = 0x00008256 - WGL_NO_RESET_NOTIFICATION_ARB* = 0x00008261 # WGL_ATI_pixel_format_float - WGLtyp_RGBA_FLOAT_ATI* = 0x000021A0 - GLtyp_RGBA_FLOAT_ATI* = 0x00008820 - GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI* = 0x00008835 # WGL_AMD_gpu_association - WGL_GPU_VENDOR_AMD* = 0x00001F00 - WGL_GPU_RENDERER_STRING_AMD* = 0x00001F01 - WGL_GPU_OPENGL_VERSION_STRING_AMD* = 0x00001F02 - WGL_GPU_FASTEST_TARGET_GPUS_AMD* = 0x000021A2 - WGL_GPU_RAM_AMD* = 0x000021A3 - WGL_GPU_CLOCK_AMD* = 0x000021A4 - WGL_GPU_NUM_PIPES_AMD* = 0x000021A5 - WGL_GPU_NUM_SIMD_AMD* = 0x000021A6 - WGL_GPU_NUM_RB_AMD* = 0x000021A7 - WGL_GPU_NUM_SPI_AMD* = 0x000021A8 # WGL_EXT_depth_float - WGL_DEPTH_FLOAT_EXT* = 0x00002040 # WGL_EXT_make_current_read - ERROR_INVALID_PIXELtyp_EXT* = 0x00002043 # WGL_EXT_multisample - WGL_SAMPLE_BUFFERS_EXT* = 0x00002041 - WGL_SAMPLES_EXT* = 0x00002042 # WGL_EXT_pbuffer - WGL_DRAW_TO_PBUFFER_EXT* = 0x0000202D - WGL_MAX_PBUFFER_PIXELS_EXT* = 0x0000202E - WGL_MAX_PBUFFER_WIDTH_EXT* = 0x0000202F - WGL_MAX_PBUFFER_HEIGHT_EXT* = 0x00002030 - WGL_OPTIMAL_PBUFFER_WIDTH_EXT* = 0x00002031 - WGL_OPTIMAL_PBUFFER_HEIGHT_EXT* = 0x00002032 - WGL_PBUFFER_LARGEST_EXT* = 0x00002033 - WGL_PBUFFER_WIDTH_EXT* = 0x00002034 - WGL_PBUFFER_HEIGHT_EXT* = 0x00002035 # WGL_EXT_pixel_format - WGL_NUMBER_PIXEL_FORMATS_EXT* = 0x00002000 - WGL_DRAW_TO_WINDOW_EXT* = 0x00002001 - WGL_DRAW_TO_BITMAP_EXT* = 0x00002002 - WGL_ACCELERATION_EXT* = 0x00002003 - WGL_NEED_PALETTE_EXT* = 0x00002004 - WGL_NEED_SYSTEM_PALETTE_EXT* = 0x00002005 - WGL_SWAP_LAYER_BUFFERS_EXT* = 0x00002006 - WGL_SWAP_METHOD_EXT* = 0x00002007 - WGL_NUMBER_OVERLAYS_EXT* = 0x00002008 - WGL_NUMBER_UNDERLAYS_EXT* = 0x00002009 - WGL_TRANSPARENT_EXT* = 0x0000200A - WGL_TRANSPARENT_VALUE_EXT* = 0x0000200B - WGL_SHARE_DEPTH_EXT* = 0x0000200C - WGL_SHARE_STENCIL_EXT* = 0x0000200D - WGL_SHARE_ACCUM_EXT* = 0x0000200E - WGL_SUPPORT_GDI_EXT* = 0x0000200F - WGL_SUPPORT_OPENGL_EXT* = 0x00002010 - WGL_DOUBLE_BUFFER_EXT* = 0x00002011 - WGL_STEREO_EXT* = 0x00002012 - WGL_PIXELtyp_EXT* = 0x00002013 - WGL_COLOR_BITS_EXT* = 0x00002014 - WGL_RED_BITS_EXT* = 0x00002015 - WGL_RED_SHIFT_EXT* = 0x00002016 - WGL_GREEN_BITS_EXT* = 0x00002017 - WGL_GREEN_SHIFT_EXT* = 0x00002018 - WGL_BLUE_BITS_EXT* = 0x00002019 - WGL_BLUE_SHIFT_EXT* = 0x0000201A - WGL_ALPHA_BITS_EXT* = 0x0000201B - WGL_ALPHA_SHIFT_EXT* = 0x0000201C - WGL_ACCUM_BITS_EXT* = 0x0000201D - WGL_ACCUM_RED_BITS_EXT* = 0x0000201E - WGL_ACCUM_GREEN_BITS_EXT* = 0x0000201F - WGL_ACCUM_BLUE_BITS_EXT* = 0x00002020 - WGL_ACCUM_ALPHA_BITS_EXT* = 0x00002021 - WGL_DEPTH_BITS_EXT* = 0x00002022 - WGL_STENCIL_BITS_EXT* = 0x00002023 - WGL_AUX_BUFFERS_EXT* = 0x00002024 - WGL_NO_ACCELERATION_EXT* = 0x00002025 - WGL_GENERIC_ACCELERATION_EXT* = 0x00002026 - WGL_FULL_ACCELERATION_EXT* = 0x00002027 - WGL_SWAP_EXCHANGE_EXT* = 0x00002028 - WGL_SWAP_COPY_EXT* = 0x00002029 - WGL_SWAP_UNDEFINED_EXT* = 0x0000202A - WGLtyp_RGBA_EXT* = 0x0000202B - WGLtyp_COLORINDEX_EXT* = 0x0000202C # WGL_I3D_digital_video_control - WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D* = 0x00002050 - WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D* = 0x00002051 - WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D* = 0x00002052 - WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D* = 0x00002053 # WGL_I3D_gamma - WGL_GAMMA_TABLE_SIZE_I3D* = 0x0000204E - WGL_GAMMA_EXCLUDE_DESKTOP_I3D* = 0x0000204F # WGL_I3D_genlock - WGL_GENLOCK_SOURCE_MULTIVIEW_I3D* = 0x00002044 - WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D* = 0x00002045 - WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D* = 0x00002046 - WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D* = 0x00002047 - WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D* = 0x00002048 - WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D* = 0x00002049 - WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D* = 0x0000204A - WGL_GENLOCK_SOURCE_EDGE_RISING_I3D* = 0x0000204B - WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D* = 0x0000204C # WGL_I3D_image_buffer - WGL_IMAGE_BUFFER_MIN_ACCESS_I3D* = 0x00000001 - WGL_IMAGE_BUFFER_LOCK_I3D* = 0x00000002 # WGL_NV_float_buffer - WGL_FLOAT_COMPONENTS_NV* = 0x000020B0 - WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV* = 0x000020B1 - WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV* = 0x000020B2 - WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV* = 0x000020B3 - WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV* = 0x000020B4 - WGL_TEXTURE_FLOAT_R_NV* = 0x000020B5 - WGL_TEXTURE_FLOAT_RG_NV* = 0x000020B6 - WGL_TEXTURE_FLOAT_RGB_NV* = 0x000020B7 - WGL_TEXTURE_FLOAT_RGBA_NV* = 0x000020B8 # WGL_NV_render_depth_texture - WGL_BIND_TO_TEXTURE_DEPTH_NV* = 0x000020A3 - WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV* = 0x000020A4 - WGL_DEPTH_TEXTURE_FORMAT_NV* = 0x000020A5 - WGL_TEXTURE_DEPTH_COMPONENT_NV* = 0x000020A6 - WGL_DEPTH_COMPONENT_NV* = 0x000020A7 # WGL_NV_render_texture_rectangle - WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV* = 0x000020A0 - WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV* = 0x000020A1 - WGL_TEXTURE_RECTANGLE_NV* = 0x000020A2 # WGL_NV_present_video - WGL_NUM_VIDEO_SLOTS_NV* = 0x000020F0 # WGL_NV_video_output - WGL_BIND_TO_VIDEO_RGB_NV* = 0x000020C0 - WGL_BIND_TO_VIDEO_RGBA_NV* = 0x000020C1 - WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV* = 0x000020C2 - WGL_VIDEO_OUT_COLOR_NV* = 0x000020C3 - WGL_VIDEO_OUT_ALPHA_NV* = 0x000020C4 - WGL_VIDEO_OUT_DEPTH_NV* = 0x000020C5 - WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV* = 0x000020C6 - WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV* = 0x000020C7 - WGL_VIDEO_OUT_FRAME* = 0x000020C8 - WGL_VIDEO_OUT_FIELD_1* = 0x000020C9 - WGL_VIDEO_OUT_FIELD_2* = 0x000020CA - WGL_VIDEO_OUT_STACKED_FIELDS_1_2* = 0x000020CB - WGL_VIDEO_OUT_STACKED_FIELDS_2_1* = 0x000020CC # WGL_NV_gpu_affinity - WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV* = 0x000020D0 - WGL_ERROR_MISSING_AFFINITY_MASK_NV* = 0x000020D1 # WGL_NV_video_capture - WGL_UNIQUE_ID_NV* = 0x000020CE - WGL_NUM_VIDEO_CAPTURE_SLOTS_NV* = 0x000020CF # WGL_NV_multisample_coverage - WGL_COVERAGE_SAMPLES_NV* = 0x00002042 - WGL_COLOR_SAMPLES_NV* = 0x000020B9 # WGL_EXT_create_context_es2_profile - WGL_CONTEXT_ES2_PROFILE_BIT_EXT* = 0x00000004 # WGL_NV_DX_interop - WGL_ACCESS_READ_ONLY_NV* = 0x00000000 - WGL_ACCESS_READ_WRITE_NV* = 0x00000001 - WGL_ACCESS_WRITE_DISCARD_NV* = 0x00000002 # WIN_draw_range_elements - GL_MAX_ELEMENTS_VERTICES_WIN* = 0x000080E8 - GL_MAX_ELEMENTS_INDICES_WIN* = 0x000080E9 # GLX 1.1 and later: - GLX_VENDOR* = 1 - GLX_VERSION* = 2 - GLX_EXTENSIONS* = 3 - 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 # GLX_VERSION_1_3 - GLX_WINDOW_BIT* = 0x00000001 - GLX_PIXMAP_BIT* = 0x00000002 - GLX_PBUFFER_BIT* = 0x00000004 - GLX_RGBA_BIT* = 0x00000001 - GLX_COLOR_INDEX_BIT* = 0x00000002 - GLX_PBUFFER_CLOBBER_MASK* = 0x08000000 - GLX_FRONT_LEFT_BUFFER_BIT* = 0x00000001 - GLX_FRONT_RIGHT_BUFFER_BIT* = 0x00000002 - GLX_BACK_LEFT_BUFFER_BIT* = 0x00000004 - GLX_BACK_RIGHT_BUFFER_BIT* = 0x00000008 - GLX_AUX_BUFFERS_BIT* = 0x00000010 - GLX_DEPTH_BUFFER_BIT* = 0x00000020 - GLX_STENCIL_BUFFER_BIT* = 0x00000040 - GLX_ACCUM_BUFFER_BIT* = 0x00000080 - GLX_CONFIG_CAVEAT* = 0x00000020 - GLX_X_VISUALtyp* = 0x00000022 - GLX_TRANSPARENTtyp* = 0x00000023 - GLX_TRANSPARENT_INDEX_VALUE* = 0x00000024 - GLX_TRANSPARENT_RED_VALUE* = 0x00000025 - GLX_TRANSPARENT_GREEN_VALUE* = 0x00000026 - GLX_TRANSPARENT_BLUE_VALUE* = 0x00000027 - GLX_TRANSPARENT_ALPHA_VALUE* = 0x00000028 - GLX_DONT_CARE* = 0xFFFFFFFF - GLX_NONE* = 0x00008000 - GLX_SLOW_CONFIG* = 0x00008001 - GLX_TRUE_COLOR* = 0x00008002 - GLX_DIRECT_COLOR* = 0x00008003 - GLX_PSEUDO_COLOR* = 0x00008004 - GLX_STATIC_COLOR* = 0x00008005 - GLX_GRAY_SCALE* = 0x00008006 - GLX_STATIC_GRAY* = 0x00008007 - GLX_TRANSPARENT_RGB* = 0x00008008 - GLX_TRANSPARENT_INDEX* = 0x00008009 - GLX_VISUAL_ID* = 0x0000800B - GLX_SCREEN* = 0x0000800C - GLX_NON_CONFORMANT_CONFIG* = 0x0000800D - GLX_DRAWABLEtyp* = 0x00008010 - GLX_RENDERtyp* = 0x00008011 - GLX_X_RENDERABLE* = 0x00008012 - GLX_FBCONFIG_ID* = 0x00008013 - GLX_RGBAtyp* = 0x00008014 - GLX_COLOR_INDEXtyp* = 0x00008015 - GLX_MAX_PBUFFER_WIDTH* = 0x00008016 - GLX_MAX_PBUFFER_HEIGHT* = 0x00008017 - GLX_MAX_PBUFFER_PIXELS* = 0x00008018 - GLX_PRESERVED_CONTENTS* = 0x0000801B - GLX_LARGEST_PBUFFER* = 0x0000801C - GLX_WIDTH* = 0x0000801D - GLX_HEIGHT* = 0x0000801E - GLX_EVENT_MASK* = 0x0000801F - GLX_DAMAGED* = 0x00008020 - GLX_SAVED* = 0x00008021 - cGLX_WINDOW* = 0x00008022 - cGLX_PBUFFER* = 0x00008023 - GLX_PBUFFER_HEIGHT* = 0x00008040 - GLX_PBUFFER_WIDTH* = 0x00008041 # GLX_VERSION_1_4 - GLX_SAMPLE_BUFFERS* = 100000 - GLX_SAMPLES* = 100001 # GLX_ARB_multisample - GLX_SAMPLE_BUFFERS_ARB* = 100000 - GLX_SAMPLES_ARB* = 100001 # GLX_ARB_fbconfig_float - GLX_RGBA_FLOATtyp_ARB* = 0x000020B9 - GLX_RGBA_FLOAT_BIT_ARB* = 0x00000004 # GLX_ARB_create_context - GLX_CONTEXT_DEBUG_BIT_ARB* = 0x00000001 - GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB* = 0x00000002 - GLX_CONTEXT_MAJOR_VERSION_ARB* = 0x00002091 - GLX_CONTEXT_MINOR_VERSION_ARB* = 0x00002092 - GLX_CONTEXT_FLAGS_ARB* = 0x00002094 # GLX_ARB_create_context_profile - GLX_CONTEXT_CORE_PROFILE_BIT_ARB* = 0x00000001 - GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB* = 0x00000002 - GLX_CONTEXT_PROFILE_MASK_ARB* = 0x00009126 # GLX_ARB_vertex_buffer_object - GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB* = 0x00002095 # - # GLX_ARB_framebuffer_sRGB - GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB* = 0x000020B2 # - # GLX_ARB_create_context_robustness - GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB* = 0x00000004 - GLX_LOSE_CONTEXT_ON_RESET_ARB* = 0x00008252 - GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB* = 0x00008256 - GLX_NO_RESET_NOTIFICATION_ARB* = 0x00008261 # GLX_EXT_visual_info - GLX_X_VISUALtyp_EXT* = 0x00000022 - GLX_TRANSPARENTtyp_EXT* = 0x00000023 - GLX_TRANSPARENT_INDEX_VALUE_EXT* = 0x00000024 - GLX_TRANSPARENT_RED_VALUE_EXT* = 0x00000025 - GLX_TRANSPARENT_GREEN_VALUE_EXT* = 0x00000026 - GLX_TRANSPARENT_BLUE_VALUE_EXT* = 0x00000027 - GLX_TRANSPARENT_ALPHA_VALUE_EXT* = 0x00000028 - GLX_NONE_EXT* = 0x00008000 - GLX_TRUE_COLOR_EXT* = 0x00008002 - GLX_DIRECT_COLOR_EXT* = 0x00008003 - GLX_PSEUDO_COLOR_EXT* = 0x00008004 - GLX_STATIC_COLOR_EXT* = 0x00008005 - GLX_GRAY_SCALE_EXT* = 0x00008006 - GLX_STATIC_GRAY_EXT* = 0x00008007 - GLX_TRANSPARENT_RGB_EXT* = 0x00008008 - GLX_TRANSPARENT_INDEX_EXT* = 0x00008009 # GLX_EXT_visual_rating - GLX_VISUAL_CAVEAT_EXT* = 0x00000020 - GLX_SLOW_VISUAL_EXT* = 0x00008001 - GLX_NON_CONFORMANT_VISUAL_EXT* = 0x0000800D # reuse GLX_NONE_EXT - # GLX_EXT_import_context - GLX_SHARE_CONTEXT_EXT* = 0x0000800A - GLX_VISUAL_ID_EXT* = 0x0000800B - GLX_SCREEN_EXT* = 0x0000800C # GLX_EXT_fbconfig_packed_float - # GLX_RGBA_UNSIGNED_FLOATtyp_EXT = $20B1; - # GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008; - # GLX_EXT_framebuffer_sRGB - # GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2; - # GLX_EXT_texture_from_pixmap - GLX_TEXTURE_1D_BIT_EXT* = 0x00000001 - GLX_TEXTURE_2D_BIT_EXT* = 0x00000002 - GLX_TEXTURE_RECTANGLE_BIT_EXT* = 0x00000004 - GLX_BIND_TO_TEXTURE_RGB_EXT* = 0x000020D0 - GLX_BIND_TO_TEXTURE_RGBA_EXT* = 0x000020D1 - GLX_BIND_TO_MIPMAP_TEXTURE_EXT* = 0x000020D2 - GLX_BIND_TO_TEXTURE_TARGETS_EXT* = 0x000020D3 - GLX_Y_INVERTED_EXT* = 0x000020D4 - GLX_TEXTURE_FORMAT_EXT* = 0x000020D5 - GLX_TEXTURE_TARGET_EXT* = 0x000020D6 - GLX_MIPMAP_TEXTURE_EXT* = 0x000020D7 - GLX_TEXTURE_FORMAT_NONE_EXT* = 0x000020D8 - GLX_TEXTURE_FORMAT_RGB_EXT* = 0x000020D9 - GLX_TEXTURE_FORMAT_RGBA_EXT* = 0x000020DA - GLX_TEXTURE_1D_EXT* = 0x000020DB - GLX_TEXTURE_2D_EXT* = 0x000020DC - GLX_TEXTURE_RECTANGLE_EXT* = 0x000020DD - GLX_FRONT_LEFT_EXT* = 0x000020DE - GLX_FRONT_RIGHT_EXT* = 0x000020DF - GLX_BACK_LEFT_EXT* = 0x000020E0 - GLX_BACK_RIGHT_EXT* = 0x000020E1 - GLX_FRONT_EXT* = GLX_FRONT_LEFT_EXT - GLX_BACK_EXT* = GLX_BACK_LEFT_EXT - GLX_AUX0_EXT* = 0x000020E2 - GLX_AUX1_EXT* = 0x000020E3 - GLX_AUX2_EXT* = 0x000020E4 - GLX_AUX3_EXT* = 0x000020E5 - GLX_AUX4_EXT* = 0x000020E6 - GLX_AUX5_EXT* = 0x000020E7 - GLX_AUX6_EXT* = 0x000020E8 - GLX_AUX7_EXT* = 0x000020E9 - GLX_AUX8_EXT* = 0x000020EA - GLX_AUX9_EXT* = 0x000020EB # GLX_EXT_swap_control - GLX_SWAP_INTERVAL_EXT* = 0x000020F1 - GLX_MAX_SWAP_INTERVAL_EXT* = 0x000020F2 # GLX_EXT_create_context_es2_profile - GLX_CONTEXT_ES2_PROFILE_BIT_EXT* = 0x00000004 # GLU - GLU_INVALID_ENUM* = 100900 - GLU_INVALID_VALUE* = 100901 - GLU_OUT_OF_MEMORY* = 100902 - GLU_INCOMPATIBLE_GL_VERSION* = 100903 - GLU_VERSION* = 100800 - GLU_EXTENSIONS* = 100801 - GLU_TRUE* = GL_TRUE - GLU_FALSE* = GL_FALSE - GLU_SMOOTH* = 100000 - GLU_FLAT* = 100001 - GLU_NONE* = 100002 - GLU_POINT* = 100010 - GLU_LINE* = 100011 - GLU_FILL* = 100012 - GLU_SILHOUETTE* = 100013 - GLU_OUTSIDE* = 100020 - GLU_INSIDE* = 100021 - GLU_TESS_MAX_COORD* = 1.0000000000000005e+150 - GLU_TESS_WINDING_RULE* = 100140 - GLU_TESS_BOUNDARY_ONLY* = 100141 - GLU_TESS_TOLERANCE* = 100142 - GLU_TESS_WINDING_ODD* = 100130 - GLU_TESS_WINDING_NONZERO* = 100131 - GLU_TESS_WINDING_POSITIVE* = 100132 - GLU_TESS_WINDING_NEGATIVE* = 100133 - GLU_TESS_WINDING_ABS_GEQ_TWO* = 100134 - GLU_TESS_BEGIN* = 100100 # TGLUTessBeginProc - cGLU_TESS_VERTEX* = 100101 # TGLUTessVertexProc - GLU_TESS_END* = 100102 # TGLUTessEndProc - GLU_TESS_ERROR* = 100103 # TGLUTessErrorProc - GLU_TESS_EDGE_FLAG* = 100104 # TGLUTessEdgeFlagProc - GLU_TESS_COMBINE* = 100105 # TGLUTessCombineProc - GLU_TESS_BEGIN_DATA* = 100106 # TGLUTessBeginDataProc - GLU_TESS_VERTEX_DATA* = 100107 # TGLUTessVertexDataProc - GLU_TESS_END_DATA* = 100108 # TGLUTessEndDataProc - GLU_TESS_ERROR_DATA* = 100109 # TGLUTessErrorDataProc - GLU_TESS_EDGE_FLAG_DATA* = 100110 # TGLUTessEdgeFlagDataProc - GLU_TESS_COMBINE_DATA* = 100111 # TGLUTessCombineDataProc - GLU_TESS_ERROR1* = 100151 - GLU_TESS_ERROR2* = 100152 - GLU_TESS_ERROR3* = 100153 - GLU_TESS_ERROR4* = 100154 - GLU_TESS_ERROR5* = 100155 - GLU_TESS_ERROR6* = 100156 - GLU_TESS_ERROR7* = 100157 - GLU_TESS_ERROR8* = 100158 - GLU_TESS_MISSING_BEGIN_POLYGON* = GLU_TESS_ERROR1 - GLU_TESS_MISSING_BEGIN_CONTOUR* = GLU_TESS_ERROR2 - GLU_TESS_MISSING_END_POLYGON* = GLU_TESS_ERROR3 - GLU_TESS_MISSING_END_CONTOUR* = GLU_TESS_ERROR4 - GLU_TESS_COORD_TOO_LARGE* = GLU_TESS_ERROR5 - GLU_TESS_NEED_COMBINE_CALLBACK* = GLU_TESS_ERROR6 - GLU_AUTO_LOAD_MATRIX* = 100200 - GLU_CULLING* = 100201 - GLU_SAMPLING_TOLERANCE* = 100203 - GLU_DISPLAY_MODE* = 100204 - GLU_PARAMETRIC_TOLERANCE* = 100202 - GLU_SAMPLING_METHOD* = 100205 - GLU_U_STEP* = 100206 - GLU_V_STEP* = 100207 - GLU_PATH_LENGTH* = 100215 - GLU_PARAMETRIC_ERROR* = 100216 - GLU_DOMAIN_DISTANCE* = 100217 - GLU_MAP1_TRIM_2* = 100210 - GLU_MAP1_TRIM_3* = 100211 - GLU_OUTLINE_POLYGON* = 100240 - GLU_OUTLINE_PATCH* = 100241 - GLU_NURBS_ERROR1* = 100251 - GLU_NURBS_ERROR2* = 100252 - GLU_NURBS_ERROR3* = 100253 - GLU_NURBS_ERROR4* = 100254 - GLU_NURBS_ERROR5* = 100255 - GLU_NURBS_ERROR6* = 100256 - GLU_NURBS_ERROR7* = 100257 - GLU_NURBS_ERROR8* = 100258 - GLU_NURBS_ERROR9* = 100259 - GLU_NURBS_ERROR10* = 100260 - GLU_NURBS_ERROR11* = 100261 - GLU_NURBS_ERROR12* = 100262 - GLU_NURBS_ERROR13* = 100263 - GLU_NURBS_ERROR14* = 100264 - GLU_NURBS_ERROR15* = 100265 - GLU_NURBS_ERROR16* = 100266 - GLU_NURBS_ERROR17* = 100267 - GLU_NURBS_ERROR18* = 100268 - GLU_NURBS_ERROR19* = 100269 - GLU_NURBS_ERROR20* = 100270 - GLU_NURBS_ERROR21* = 100271 - GLU_NURBS_ERROR22* = 100272 - GLU_NURBS_ERROR23* = 100273 - GLU_NURBS_ERROR24* = 100274 - GLU_NURBS_ERROR25* = 100275 - GLU_NURBS_ERROR26* = 100276 - GLU_NURBS_ERROR27* = 100277 - GLU_NURBS_ERROR28* = 100278 - GLU_NURBS_ERROR29* = 100279 - GLU_NURBS_ERROR30* = 100280 - GLU_NURBS_ERROR31* = 100281 - GLU_NURBS_ERROR32* = 100282 - GLU_NURBS_ERROR33* = 100283 - GLU_NURBS_ERROR34* = 100284 - GLU_NURBS_ERROR35* = 100285 - GLU_NURBS_ERROR36* = 100286 - GLU_NURBS_ERROR37* = 100287 - GLU_CW* = 100120 - GLU_CCW* = 100121 - GLU_INTERIOR* = 100122 - GLU_EXTERIOR* = 100123 - GLU_UNKNOWN* = 100124 - GLU_BEGIN* = GLU_TESS_BEGIN - GLU_VERTEX* = cGLU_TESS_VERTEX - GLU_END* = GLU_TESS_END - GLU_ERROR* = GLU_TESS_ERROR - GLU_EDGE_FLAG* = GLU_TESS_EDGE_FLAG - -proc glCullFace*(mode: GLenum){.stdcall, importc, ogl.} -proc glFrontFace*(mode: GLenum){.stdcall, importc, ogl.} -proc glHint*(target: GLenum, mode: GLenum){.stdcall, importc, ogl.} -proc glLineWidth*(width: GLfloat){.stdcall, importc, ogl.} -proc glPointSize*(size: GLfloat){.stdcall, importc, ogl.} -proc glPolygonMode*(face: GLenum, mode: GLenum){.stdcall, importc, ogl.} -proc glScissor*(x: GLint, y: GLint, width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} -proc glTexParameterf*(target: GLenum, pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glTexParameterfv*(target: GLenum, pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glTexParameteri*(target: GLenum, pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glTexParameteriv*(target: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glTexImage1D*(target: GLenum, level: GLint, internalformat: GLint, - width: GLsizei, border: GLint, format: GLenum, typ: GLenum, - pixels: PGLvoid){.stdcall, importc, ogl.} -proc glTexImage2D*(target: GLenum, level: GLint, internalformat: GLint, - width: GLsizei, height: GLsizei, border: GLint, - format: GLenum, typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glDrawBuffer*(mode: GLenum){.stdcall, importc, ogl.} -proc glClear*(mask: GLbitfield){.stdcall, importc, ogl.} -proc glClearColor*(red: GLclampf, green: GLclampf, blue: GLclampf, - alpha: GLclampf){.stdcall, importc, ogl.} -proc glClearStencil*(s: GLint){.stdcall, importc, ogl.} -proc glClearDepth*(depth: GLclampd){.stdcall, importc, ogl.} -proc glStencilMask*(mask: GLuint){.stdcall, importc, ogl.} -proc glColorMask*(red: GLboolean, green: GLboolean, blue: GLboolean, - alpha: GLboolean){.stdcall, importc, ogl.} -proc glDepthMask*(flag: GLboolean){.stdcall, importc, ogl.} -proc glDisable*(cap: GLenum){.stdcall, importc, ogl.} -proc glEnable*(cap: GLenum){.stdcall, importc, ogl.} -proc glFinish*(){.stdcall, importc, ogl.} -proc glFlush*(){.stdcall, importc, ogl.} -proc glBlendFunc*(sfactor: GLenum, dfactor: GLenum){.stdcall, importc, ogl.} -proc glLogicOp*(opcode: GLenum){.stdcall, importc, ogl.} -proc glStencilFunc*(func: GLenum, theRef: GLint, mask: GLuint){.stdcall, importc, ogl.} -proc glStencilOp*(fail: GLenum, zfail: GLenum, zpass: GLenum){.stdcall, importc, ogl.} -proc glDepthFunc*(func: GLenum){.stdcall, importc, ogl.} -proc glPixelStoref*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glPixelStorei*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glReadBuffer*(mode: GLenum){.stdcall, importc, ogl.} -proc glReadPixels*(x: GLint, y: GLint, width: GLsizei, height: GLsizei, - format: GLenum, typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glGetBooleanv*(pname: GLenum, params: PGLboolean){.stdcall, importc, ogl.} -proc glGetDoublev*(pname: GLenum, params: PGLdouble){.stdcall, importc, ogl.} -proc glGetError*(): GLenum{.stdcall, importc, ogl.} -proc glGetFloatv*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetIntegerv*(pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetString*(name: GLenum): cstring{.stdcall, importc, ogl.} -proc glGetTexImage*(target: GLenum, level: GLint, format: GLenum, typ: GLenum, - pixels: PGLvoid){.stdcall, importc, ogl.} -proc glGetTexParameteriv*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetTexParameterfv*(target: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetTexLevelParameterfv*(target: GLenum, level: GLint, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetTexLevelParameteriv*(target: GLenum, level: GLint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glIsEnabled*(cap: GLenum): GLboolean{.stdcall, importc, ogl.} -proc glDepthRange*(zNear: GLclampd, zFar: GLclampd){.stdcall, importc, ogl.} -proc glViewport*(x: GLint, y: GLint, width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} - # GL_VERSION_1_1 -proc glDrawArrays*(mode: GLenum, first: GLint, count: GLsizei){.stdcall, importc, ogl.} -proc glDrawElements*(mode: GLenum, count: GLsizei, typ: GLenum, indices: PGLvoid){. - stdcall, importc, ogl.} -proc glGetPointerv*(pname: GLenum, params: PGLvoid){.stdcall, importc, ogl.} -proc glPolygonOffset*(factor: GLfloat, units: GLfloat){.stdcall, importc, ogl.} -proc glCopyTexImage1D*(target: GLenum, level: GLint, internalFormat: GLenum, - x: GLint, y: GLint, width: GLsizei, border: GLint){. - stdcall, importc, ogl.} -proc glCopyTexImage2D*(target: GLenum, level: GLint, internalFormat: GLenum, - x: GLint, y: GLint, width: GLsizei, height: GLsizei, - border: GLint){.stdcall, importc, ogl.} -proc glCopyTexSubImage1D*(target: GLenum, level: GLint, xoffset: GLint, - x: GLint, y: GLint, width: GLsizei){.stdcall, importc, ogl.} -proc glCopyTexSubImage2D*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, x: GLint, y: GLint, width: GLsizei, - height: GLsizei){.stdcall, importc, ogl.} -proc glTexSubImage1D*(target: GLenum, level: GLint, xoffset: GLint, - width: GLsizei, format: GLenum, typ: GLenum, - pixels: PGLvoid){.stdcall, importc, ogl.} -proc glTexSubImage2D*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, width: GLsizei, height: GLsizei, - format: GLenum, typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glBindTexture*(target: GLenum, texture: GLuint){.stdcall, importc, ogl.} -proc glDeleteTextures*(n: GLsizei, textures: PGLuint){.stdcall, importc, ogl.} -proc glGenTextures*(n: GLsizei, textures: PGLuint){.stdcall, importc, ogl.} -proc glAccum*(op: GLenum, value: GLfloat){.stdcall, importc, ogl.} -proc glAlphaFunc*(func: GLenum, theRef: GLclampf){.stdcall, importc, ogl.} -proc glAreTexturesResident*(n: GLsizei, textures: PGLuint, - residences: PGLboolean): GLboolean{.stdcall, importc, ogl.} -proc glArrayElement*(i: GLint){.stdcall, importc, ogl.} -proc glBegin*(mode: GLenum){.stdcall, importc, ogl.} -proc glBitmap*(width: GLsizei, height: GLsizei, xorig: GLfloat, yorig: GLfloat, - xmove: GLfloat, ymove: GLfloat, bitmap: PGLubyte){.stdcall, importc, ogl.} -proc glCallList*(list: GLuint){.stdcall, importc, ogl.} -proc glCallLists*(n: GLsizei, typ: GLenum, lists: PGLvoid){.stdcall, importc, ogl.} -proc glClearAccum*(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat){. - stdcall, importc, ogl.} -proc glClearIndex*(c: GLfloat){.stdcall, importc, ogl.} -proc glClipPlane*(plane: GLenum, equation: PGLdouble){.stdcall, importc, ogl.} -proc glColor3b*(red: GLbyte, green: GLbyte, blue: GLbyte){.stdcall, importc, ogl.} -proc glColor3bv*(v: PGLbyte){.stdcall, importc, ogl.} -proc glColor3bv*(v: TGLVectorb3){.stdcall, importc, ogl.} -proc glColor3d*(red: GLdouble, green: GLdouble, blue: GLdouble){.stdcall, importc, ogl.} -proc glColor3dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glColor3dv*(v: TGLVectord3){.stdcall, importc, ogl.} -proc glColor3f*(red: GLfloat, green: GLfloat, blue: GLfloat){.stdcall, importc, ogl.} -proc glColor3fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glColor3fv*(v: TGLVectorf3){.stdcall, importc, ogl.} -proc glColor3i*(red: GLint, green: GLint, blue: GLint){.stdcall, importc, ogl.} -proc glColor3iv*(v: PGLint){.stdcall, importc, ogl.} -proc glColor3iv*(v: TGLVectori3){.stdcall, importc, ogl.} -proc glColor3s*(red: GLshort, green: GLshort, blue: GLshort){.stdcall, importc, ogl.} -proc glColor3sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glColor3sv*(v: TGLVectors3){.stdcall, importc, ogl.} -proc glColor3ub*(red: GLubyte, green: GLubyte, blue: GLubyte){.stdcall, importc, ogl.} -proc glColor3ubv*(v: PGLubyte){.stdcall, importc, ogl.} -proc glColor3ubv*(v: TGLVectorub3){.stdcall, importc, ogl.} -proc glColor3ui*(red: GLuint, green: GLuint, blue: GLuint){.stdcall, importc, ogl.} -proc glColor3uiv*(v: PGLuint){.stdcall, importc, ogl.} -proc glColor3uiv*(v: TGLVectorui3){.stdcall, importc, ogl.} -proc glColor3us*(red: GLushort, green: GLushort, blue: GLushort){.stdcall, importc, ogl.} -proc glColor3usv*(v: PGLushort){.stdcall, importc, ogl.} -proc glColor3usv*(v: TGLVectorus3){.stdcall, importc, ogl.} -proc glColor4b*(red: GLbyte, green: GLbyte, blue: GLbyte, alpha: GLbyte){. - stdcall, importc, ogl.} -proc glColor4bv*(v: PGLbyte){.stdcall, importc, ogl.} -proc glColor4bv*(v: TGLVectorb4){.stdcall, importc, ogl.} -proc glColor4d*(red: GLdouble, green: GLdouble, blue: GLdouble, alpha: GLdouble){. - stdcall, importc, ogl.} -proc glColor4dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glColor4dv*(v: TGLVectord4){.stdcall, importc, ogl.} -proc glColor4f*(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat){. - stdcall, importc, ogl.} -proc glColor4fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glColor4fv*(v: TGLVectorf4){.stdcall, importc, ogl.} -proc glColor4i*(red: GLint, green: GLint, blue: GLint, alpha: GLint){.stdcall, importc, ogl.} -proc glColor4iv*(v: PGLint){.stdcall, importc, ogl.} -proc glColor4iv*(v: TGLVectori4){.stdcall, importc, ogl.} -proc glColor4s*(red: GLshort, green: GLshort, blue: GLshort, alpha: GLshort){. - stdcall, importc, ogl.} -proc glColor4sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glColor4sv*(v: TGLVectors4){.stdcall, importc, ogl.} -proc glColor4ub*(red: GLubyte, green: GLubyte, blue: GLubyte, alpha: GLubyte){. - stdcall, importc, ogl.} -proc glColor4ubv*(v: PGLubyte){.stdcall, importc, ogl.} -proc glColor4ubv*(v: TGLVectorub4){.stdcall, importc, ogl.} -proc glColor4ui*(red: GLuint, green: GLuint, blue: GLuint, alpha: GLuint){. - stdcall, importc, ogl.} -proc glColor4uiv*(v: PGLuint){.stdcall, importc, ogl.} -proc glColor4uiv*(v: TGLVectorui4){.stdcall, importc, ogl.} -proc glColor4us*(red: GLushort, green: GLushort, blue: GLushort, alpha: GLushort){. - stdcall, importc, ogl.} -proc glColor4usv*(v: PGLushort){.stdcall, importc, ogl.} -proc glColorMaterial*(face: GLenum, mode: GLenum){.stdcall, importc, ogl.} -proc glColorPointer*(size: GLint, typ: GLenum, stride: GLsizei, pointer: PGLvoid){. - stdcall, importc, ogl.} -proc glCopyPixels*(x: GLint, y: GLint, width: GLsizei, height: GLsizei, - typ: GLenum){.stdcall, importc, ogl.} -proc glDeleteLists*(list: GLuint, range: GLsizei){.stdcall, importc, ogl.} -proc glDisableClientState*(arr: GLenum){.stdcall, importc, ogl.} -proc glDrawPixels*(width: GLsizei, height: GLsizei, format: GLenum, typ: GLenum, - pixels: PGLvoid){.stdcall, importc, ogl.} -proc glEdgeFlag*(flag: GLboolean){.stdcall, importc, ogl.} -proc glEdgeFlagPointer*(stride: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glEdgeFlagv*(flag: PGLboolean){.stdcall, importc, ogl.} -proc glEnableClientState*(arr: GLenum){.stdcall, importc, ogl.} -proc glEnd*(){.stdcall, importc, ogl.} -proc glEndList*(){.stdcall, importc, ogl.} -proc glEvalCoord1d*(u: GLdouble){.stdcall, importc, ogl.} -proc glEvalCoord1dv*(u: PGLdouble){.stdcall, importc, ogl.} -proc glEvalCoord1f*(u: GLfloat){.stdcall, importc, ogl.} -proc glEvalCoord1fv*(u: PGLfloat){.stdcall, importc, ogl.} -proc glEvalCoord2d*(u: GLdouble, v: GLdouble){.stdcall, importc, ogl.} -proc glEvalCoord2dv*(u: PGLdouble){.stdcall, importc, ogl.} -proc glEvalCoord2f*(u: GLfloat, v: GLfloat){.stdcall, importc, ogl.} -proc glEvalCoord2fv*(u: PGLfloat){.stdcall, importc, ogl.} -proc glEvalMesh1*(mode: GLenum, i1: GLint, i2: GLint){.stdcall, importc, ogl.} -proc glEvalMesh2*(mode: GLenum, i1: GLint, i2: GLint, j1: GLint, j2: GLint){. - stdcall, importc, ogl.} -proc glEvalPoint1*(i: GLint){.stdcall, importc, ogl.} -proc glEvalPoint2*(i: GLint, j: GLint){.stdcall, importc, ogl.} -proc glFeedbackBuffer*(size: GLsizei, typ: GLenum, buffer: PGLfloat){.stdcall, importc, ogl.} -proc glFogf*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glFogfv*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glFogi*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glFogiv*(pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glFrustum*(left: GLdouble, right: GLdouble, bottom: GLdouble, - top: GLdouble, zNear: GLdouble, zFar: GLdouble){.stdcall, importc, ogl.} -proc glGenLists*(range: GLsizei): GLuint{.stdcall, importc, ogl.} -proc glGetClipPlane*(plane: GLenum, equation: PGLdouble){.stdcall, importc, ogl.} -proc glGetLightfv*(light: GLenum, pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetLightiv*(light: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetMapdv*(target: GLenum, query: GLenum, v: PGLdouble){.stdcall, importc, ogl.} -proc glGetMapfv*(target: GLenum, query: GLenum, v: PGLfloat){.stdcall, importc, ogl.} -proc glGetMapiv*(target: GLenum, query: GLenum, v: PGLint){.stdcall, importc, ogl.} -proc glGetMaterialfv*(face: GLenum, pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetMaterialiv*(face: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetPixelMapfv*(map: GLenum, values: PGLfloat){.stdcall, importc, ogl.} -proc glGetPixelMapuiv*(map: GLenum, values: PGLuint){.stdcall, importc, ogl.} -proc glGetPixelMapusv*(map: GLenum, values: PGLushort){.stdcall, importc, ogl.} -proc glGetPolygonStipple*(mask: PGLubyte){.stdcall, importc, ogl.} -proc glGetTexEnvfv*(target: GLenum, pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetTexEnviv*(target: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetTexGendv*(coord: GLenum, pname: GLenum, params: PGLdouble){.stdcall, importc, ogl.} -proc glGetTexGenfv*(coord: GLenum, pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetTexGeniv*(coord: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glIndexMask*(mask: GLuint){.stdcall, importc, ogl.} -proc glIndexPointer*(typ: GLenum, stride: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glIndexd*(c: GLdouble){.stdcall, importc, ogl.} -proc glIndexdv*(c: PGLdouble){.stdcall, importc, ogl.} -proc glIndexf*(c: GLfloat){.stdcall, importc, ogl.} -proc glIndexfv*(c: PGLfloat){.stdcall, importc, ogl.} -proc glIndexi*(c: GLint){.stdcall, importc, ogl.} -proc glIndexiv*(c: PGLint){.stdcall, importc, ogl.} -proc glIndexs*(c: GLshort){.stdcall, importc, ogl.} -proc glIndexsv*(c: PGLshort){.stdcall, importc, ogl.} -proc glIndexub*(c: GLubyte){.stdcall, importc, ogl.} -proc glIndexubv*(c: PGLubyte){.stdcall, importc, ogl.} -proc glInitNames*(){.stdcall, importc, ogl.} -proc glInterleavedArrays*(format: GLenum, stride: GLsizei, pointer: PGLvoid){. - stdcall, importc, ogl.} -proc glIsList*(list: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glIsTexture*(texture: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glLightModelf*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glLightModelfv*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glLightModeli*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glLightModeliv*(pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glLightf*(light: GLenum, pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glLightfv*(light: GLenum, pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glLighti*(light: GLenum, pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glLightiv*(light: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glLineStipple*(factor: GLint, pattern: GLushort){.stdcall, importc, ogl.} -proc glListBase*(base: GLuint){.stdcall, importc, ogl.} -proc glLoadIdentity*(){.stdcall, importc, ogl.} -proc glLoadMatrixd*(m: PGLdouble){.stdcall, importc, ogl.} -proc glLoadMatrixf*(m: PGLfloat){.stdcall, importc, ogl.} -proc glLoadName*(name: GLuint){.stdcall, importc, ogl.} -proc glMap1d*(target: GLenum, u1: GLdouble, u2: GLdouble, stride: GLint, - order: GLint, points: PGLdouble){.stdcall, importc, ogl.} -proc glMap1f*(target: GLenum, u1: GLfloat, u2: GLfloat, stride: GLint, - order: GLint, points: PGLfloat){.stdcall, importc, ogl.} -proc glMap2d*(target: GLenum, u1: GLdouble, u2: GLdouble, ustride: GLint, - uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, - vorder: GLint, points: PGLdouble){.stdcall, importc, ogl.} -proc glMap2f*(target: GLenum, u1: GLfloat, u2: GLfloat, ustride: GLint, - uorder: GLint, v1: GLfloat, v2: GLfloat, vstride: GLint, - vorder: GLint, points: PGLfloat){.stdcall, importc, ogl.} -proc glMapGrid1d*(un: GLint, u1: GLdouble, u2: GLdouble){.stdcall, importc, ogl.} -proc glMapGrid1f*(un: GLint, u1: GLfloat, u2: GLfloat){.stdcall, importc, ogl.} -proc glMapGrid2d*(un: GLint, u1: GLdouble, u2: GLdouble, vn: GLint, - v1: GLdouble, v2: GLdouble){.stdcall, importc, ogl.} -proc glMapGrid2f*(un: GLint, u1: GLfloat, u2: GLfloat, vn: GLint, v1: GLfloat, - v2: GLfloat){.stdcall, importc, ogl.} -proc glMaterialf*(face: GLenum, pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glMaterialfv*(face: GLenum, pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glMateriali*(face: GLenum, pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glMaterialiv*(face: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glMatrixMode*(mode: GLenum){.stdcall, importc, ogl.} -proc glMultMatrixd*(m: PGLdouble){.stdcall, importc, ogl.} -proc glMultMatrixf*(m: PGLfloat){.stdcall, importc, ogl.} -proc glNewList*(list: GLuint, mode: GLenum){.stdcall, importc, ogl.} -proc glNormal3b*(nx: GLbyte, ny: GLbyte, nz: GLbyte){.stdcall, importc, ogl.} -proc glNormal3bv*(v: PGLbyte){.stdcall, importc, ogl.} -proc glNormal3d*(nx: GLdouble, ny: GLdouble, nz: GLdouble){.stdcall, importc, ogl.} -proc glNormal3dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glNormal3f*(nx: GLfloat, ny: GLfloat, nz: GLfloat){.stdcall, importc, ogl.} -proc glNormal3fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glNormal3i*(nx: GLint, ny: GLint, nz: GLint){.stdcall, importc, ogl.} -proc glNormal3iv*(v: PGLint){.stdcall, importc, ogl.} -proc glNormal3s*(nx: GLshort, ny: GLshort, nz: GLshort){.stdcall, importc, ogl.} -proc glNormal3sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glNormalPointer*(typ: GLenum, stride: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glOrtho*(left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, - zNear: GLdouble, zFar: GLdouble){.stdcall, importc, ogl.} -proc glPassThrough*(token: GLfloat){.stdcall, importc, ogl.} -proc glPixelMapfv*(map: GLenum, mapsize: GLsizei, values: PGLfloat){.stdcall, importc, ogl.} -proc glPixelMapuiv*(map: GLenum, mapsize: GLsizei, values: PGLuint){.stdcall, importc, ogl.} -proc glPixelMapusv*(map: GLenum, mapsize: GLsizei, values: PGLushort){.stdcall, importc, ogl.} -proc glPixelTransferf*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glPixelTransferi*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glPixelZoom*(xfactor: GLfloat, yfactor: GLfloat){.stdcall, importc, ogl.} -proc glPolygonStipple*(mask: PGLubyte){.stdcall, importc, ogl.} -proc glPopAttrib*(){.stdcall, importc, ogl.} -proc glPopClientAttrib*(){.stdcall, importc, ogl.} -proc glPopMatrix*(){.stdcall, importc, ogl.} -proc glPopName*(){.stdcall, importc, ogl.} -proc glPrioritizeTextures*(n: GLsizei, textures: PGLuint, priorities: PGLclampf){. - stdcall, importc, ogl.} -proc glPushAttrib*(mask: GLbitfield){.stdcall, importc, ogl.} -proc glPushClientAttrib*(mask: GLbitfield){.stdcall, importc, ogl.} -proc glPushMatrix*(){.stdcall, importc, ogl.} -proc glPushName*(name: GLuint){.stdcall, importc, ogl.} -proc glRasterPos2d*(x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glRasterPos2dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glRasterPos2f*(x: GLfloat, y: GLfloat){.stdcall, importc, ogl.} -proc glRasterPos2fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glRasterPos2i*(x: GLint, y: GLint){.stdcall, importc, ogl.} -proc glRasterPos2iv*(v: PGLint){.stdcall, importc, ogl.} -proc glRasterPos2s*(x: GLshort, y: GLshort){.stdcall, importc, ogl.} -proc glRasterPos2sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glRasterPos3d*(x: GLdouble, y: GLdouble, z: GLdouble){.stdcall, importc, ogl.} -proc glRasterPos3dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glRasterPos3f*(x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glRasterPos3fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glRasterPos3i*(x: GLint, y: GLint, z: GLint){.stdcall, importc, ogl.} -proc glRasterPos3iv*(v: PGLint){.stdcall, importc, ogl.} -proc glRasterPos3s*(x: GLshort, y: GLshort, z: GLshort){.stdcall, importc, ogl.} -proc glRasterPos3sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glRasterPos4d*(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble){.stdcall, importc, ogl.} -proc glRasterPos4dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glRasterPos4f*(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat){.stdcall, importc, ogl.} -proc glRasterPos4fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glRasterPos4i*(x: GLint, y: GLint, z: GLint, w: GLint){.stdcall, importc, ogl.} -proc glRasterPos4iv*(v: PGLint){.stdcall, importc, ogl.} -proc glRasterPos4s*(x: GLshort, y: GLshort, z: GLshort, w: GLshort){.stdcall, importc, ogl.} -proc glRasterPos4sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glRectd*(x1: GLdouble, y1: GLdouble, x2: GLdouble, y2: GLdouble){.stdcall, importc, ogl.} -proc glRectdv*(v1: PGLdouble, v2: PGLdouble){.stdcall, importc, ogl.} -proc glRectf*(x1: GLfloat, y1: GLfloat, x2: GLfloat, y2: GLfloat){.stdcall, importc, ogl.} -proc glRectfv*(v1: PGLfloat, v2: PGLfloat){.stdcall, importc, ogl.} -proc glRecti*(x1: GLint, y1: GLint, x2: GLint, y2: GLint){.stdcall, importc, ogl.} -proc glRectiv*(v1: PGLint, v2: PGLint){.stdcall, importc, ogl.} -proc glRects*(x1: GLshort, y1: GLshort, x2: GLshort, y2: GLshort){.stdcall, importc, ogl.} -proc glRectsv*(v1: PGLshort, v2: PGLshort){.stdcall, importc, ogl.} -proc glRenderMode*(mode: GLenum): GLint{.stdcall, importc, ogl.} -proc glRotated*(angle: GLdouble, x: GLdouble, y: GLdouble, z: GLdouble){.stdcall, importc, ogl.} -proc glRotatef*(angle: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glScaled*(x: GLdouble, y: GLdouble, z: GLdouble){.stdcall, importc, ogl.} -proc glScalef*(x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glSelectBuffer*(size: GLsizei, buffer: PGLuint){.stdcall, importc, ogl.} -proc glShadeModel*(mode: GLenum){.stdcall, importc, ogl.} -proc glTexCoord1d*(s: GLdouble){.stdcall, importc, ogl.} -proc glTexCoord1dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glTexCoord1f*(s: GLfloat){.stdcall, importc, ogl.} -proc glTexCoord1fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glTexCoord1i*(s: GLint){.stdcall, importc, ogl.} -proc glTexCoord1iv*(v: PGLint){.stdcall, importc, ogl.} -proc glTexCoord1s*(s: GLshort){.stdcall, importc, ogl.} -proc glTexCoord1sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glTexCoord2d*(s: GLdouble, t: GLdouble){.stdcall, importc, ogl.} -proc glTexCoord2dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glTexCoord2f*(s: GLfloat, t: GLfloat){.stdcall, importc, ogl.} -proc glTexCoord2fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glTexCoord2i*(s: GLint, t: GLint){.stdcall, importc, ogl.} -proc glTexCoord2iv*(v: PGLint){.stdcall, importc, ogl.} -proc glTexCoord2s*(s: GLshort, t: GLshort){.stdcall, importc, ogl.} -proc glTexCoord2sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glTexCoord3d*(s: GLdouble, t: GLdouble, r: GLdouble){.stdcall, importc, ogl.} -proc glTexCoord3dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glTexCoord3f*(s: GLfloat, t: GLfloat, r: GLfloat){.stdcall, importc, ogl.} -proc glTexCoord3fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glTexCoord3i*(s: GLint, t: GLint, r: GLint){.stdcall, importc, ogl.} -proc glTexCoord3iv*(v: PGLint){.stdcall, importc, ogl.} -proc glTexCoord3s*(s: GLshort, t: GLshort, r: GLshort){.stdcall, importc, ogl.} -proc glTexCoord3sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glTexCoord4d*(s: GLdouble, t: GLdouble, r: GLdouble, q: GLdouble){.stdcall, importc, ogl.} -proc glTexCoord4dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glTexCoord4f*(s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat){.stdcall, importc, ogl.} -proc glTexCoord4fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glTexCoord4i*(s: GLint, t: GLint, r: GLint, q: GLint){.stdcall, importc, ogl.} -proc glTexCoord4iv*(v: PGLint){.stdcall, importc, ogl.} -proc glTexCoord4s*(s: GLshort, t: GLshort, r: GLshort, q: GLshort){.stdcall, importc, ogl.} -proc glTexCoord4sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glTexCoordPointer*(size: GLint, typ: GLenum, stride: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} -proc glTexEnvf*(target: GLenum, pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glTexEnvfv*(target: GLenum, pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glTexEnvi*(target: GLenum, pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glTexEnviv*(target: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glTexGend*(coord: GLenum, pname: GLenum, param: GLdouble){.stdcall, importc, ogl.} -proc glTexGendv*(coord: GLenum, pname: GLenum, params: PGLdouble){.stdcall, importc, ogl.} -proc glTexGenf*(coord: GLenum, pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glTexGenfv*(coord: GLenum, pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glTexGeni*(coord: GLenum, pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glTexGeniv*(coord: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glTranslated*(x: GLdouble, y: GLdouble, z: GLdouble){.stdcall, importc, ogl.} -proc glTranslatef*(x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glVertex2d*(x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glVertex2dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glVertex2f*(x: GLfloat, y: GLfloat){.stdcall, importc, ogl.} -proc glVertex2fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glVertex2i*(x: GLint, y: GLint){.stdcall, importc, ogl.} -proc glVertex2iv*(v: PGLint){.stdcall, importc, ogl.} -proc glVertex2s*(x: GLshort, y: GLshort){.stdcall, importc, ogl.} -proc glVertex2sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glVertex3d*(x: GLdouble, y: GLdouble, z: GLdouble){.stdcall, importc, ogl.} -proc glVertex3dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glVertex3f*(x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glVertex3fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glVertex3i*(x: GLint, y: GLint, z: GLint){.stdcall, importc, ogl.} -proc glVertex3iv*(v: PGLint){.stdcall, importc, ogl.} -proc glVertex3s*(x: GLshort, y: GLshort, z: GLshort){.stdcall, importc, ogl.} -proc glVertex3sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glVertex4d*(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble){.stdcall, importc, ogl.} -proc glVertex4dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glVertex4f*(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat){.stdcall, importc, ogl.} -proc glVertex4fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glVertex4i*(x: GLint, y: GLint, z: GLint, w: GLint){.stdcall, importc, ogl.} -proc glVertex4iv*(v: PGLint){.stdcall, importc, ogl.} -proc glVertex4s*(x: GLshort, y: GLshort, z: GLshort, w: GLshort){.stdcall, importc, ogl.} -proc glVertex4sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glVertexPointer*(size: GLint, typ: GLenum, stride: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} - # GL_VERSION_1_2 -proc glBlendColor*(red: GLclampf, green: GLclampf, blue: GLclampf, - alpha: GLclampf){.stdcall, importc, ogl.} -proc glBlendEquation*(mode: GLenum){.stdcall, importc, ogl.} -proc glDrawRangeElements*(mode: GLenum, start: GLuint, ending: GLuint, - count: GLsizei, typ: GLenum, indices: PGLvoid){. - stdcall, importc, ogl.} -proc glTexImage3D*(target: GLenum, level: GLint, internalformat: GLint, - width: GLsizei, height: GLsizei, depth: GLsizei, - border: GLint, format: GLenum, typ: GLenum, pixels: PGLvoid){. - stdcall, importc, ogl.} -proc glTexSubImage3D*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, zoffset: GLint, width: GLsizei, - height: GLsizei, depth: GLsizei, format: GLenum, - typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glCopyTexSubImage3D*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, - width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} -proc glColorTable*(target: GLenum, internalformat: GLenum, width: GLsizei, - format: GLenum, typ: GLenum, table: PGLvoid){.stdcall, importc, ogl.} -proc glColorTableParameterfv*(target: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glColorTableParameteriv*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glCopyColorTable*(target: GLenum, internalformat: GLenum, x: GLint, - y: GLint, width: GLsizei){.stdcall, importc, ogl.} -proc glGetColorTable*(target: GLenum, format: GLenum, typ: GLenum, - table: PGLvoid){.stdcall, importc, ogl.} -proc glGetColorTableParameterfv*(target: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetColorTableParameteriv*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glColorSubTable*(target: GLenum, start: GLsizei, count: GLsizei, - format: GLenum, typ: GLenum, data: PGLvoid){.stdcall, importc, ogl.} -proc glCopyColorSubTable*(target: GLenum, start: GLsizei, x: GLint, y: GLint, - width: GLsizei){.stdcall, importc, ogl.} -proc glConvolutionFilter1D*(target: GLenum, internalformat: GLenum, - width: GLsizei, format: GLenum, typ: GLenum, - image: PGLvoid){.stdcall, importc, ogl.} -proc glConvolutionFilter2D*(target: GLenum, internalformat: GLenum, - width: GLsizei, height: GLsizei, format: GLenum, - typ: GLenum, image: PGLvoid){.stdcall, importc, ogl.} -proc glConvolutionParameterf*(target: GLenum, pname: GLenum, params: GLfloat){. - stdcall, importc, ogl.} -proc glConvolutionParameterfv*(target: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glConvolutionParameteri*(target: GLenum, pname: GLenum, params: GLint){. - stdcall, importc, ogl.} -proc glConvolutionParameteriv*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glCopyConvolutionFilter1D*(target: GLenum, internalformat: GLenum, - x: GLint, y: GLint, width: GLsizei){.stdcall, importc, ogl.} -proc glCopyConvolutionFilter2D*(target: GLenum, internalformat: GLenum, - x: GLint, y: GLint, width: GLsizei, - height: GLsizei){.stdcall, importc, ogl.} -proc glGetConvolutionFilter*(target: GLenum, format: GLenum, typ: GLenum, - image: PGLvoid){.stdcall, importc, ogl.} -proc glGetConvolutionParameterfv*(target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetConvolutionParameteriv*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetSeparableFilter*(target: GLenum, format: GLenum, typ: GLenum, - row: PGLvoid, column: PGLvoid, span: PGLvoid){. - stdcall, importc, ogl.} -proc glSeparableFilter2D*(target: GLenum, internalformat: GLenum, - width: GLsizei, height: GLsizei, format: GLenum, - typ: GLenum, row: PGLvoid, column: PGLvoid){.stdcall, importc, ogl.} -proc glGetHistogram*(target: GLenum, reset: GLboolean, format: GLenum, - typ: GLenum, values: PGLvoid){.stdcall, importc, ogl.} -proc glGetHistogramParameterfv*(target: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetHistogramParameteriv*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetMinmax*(target: GLenum, reset: GLboolean, format: GLenum, typ: GLenum, - values: PGLvoid){.stdcall, importc, ogl.} -proc glGetMinmaxParameterfv*(target: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetMinmaxParameteriv*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glHistogram*(target: GLenum, width: GLsizei, internalformat: GLenum, - sink: GLboolean){.stdcall, importc, ogl.} -proc glMinmax*(target: GLenum, internalformat: GLenum, sink: GLboolean){.stdcall, importc, ogl.} -proc glResetHistogram*(target: GLenum){.stdcall, importc, ogl.} -proc glResetMinmax*(target: GLenum){.stdcall, importc, ogl.} - # GL_VERSION_1_3 -proc glActiveTexture*(texture: GLenum){.stdcall, importc, ogl.} -proc glSampleCoverage*(value: GLclampf, invert: GLboolean){.stdcall, importc, ogl.} -proc glCompressedTexImage3D*(target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - height: GLsizei, depth: GLsizei, border: GLint, - imageSize: GLsizei, data: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTexImage2D*(target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - height: GLsizei, border: GLint, imageSize: GLsizei, - data: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTexImage1D*(target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - border: GLint, imageSize: GLsizei, data: PGLvoid){. - stdcall, importc, ogl.} -proc glCompressedTexSubImage3D*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, zoffset: GLint, width: GLsizei, - height: GLsizei, depth: GLsizei, format: GLenum, - imageSize: GLsizei, data: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTexSubImage2D*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, width: GLsizei, height: GLsizei, - format: GLenum, imageSize: GLsizei, - data: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTexSubImage1D*(target: GLenum, level: GLint, xoffset: GLint, - width: GLsizei, format: GLenum, - imageSize: GLsizei, data: PGLvoid){.stdcall, importc, ogl.} -proc glGetCompressedTexImage*(target: GLenum, level: GLint, img: PGLvoid){. - stdcall, importc, ogl.} -proc glClientActiveTexture*(texture: GLenum){.stdcall, importc, ogl.} -proc glMultiTexCoord1d*(target: GLenum, s: GLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord1dv*(target: GLenum, v: PGLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord1f*(target: GLenum, s: GLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord1fv*(target: GLenum, v: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord1i*(target: GLenum, s: GLint){.stdcall, importc, ogl.} -proc glMultiTexCoord1iv*(target: GLenum, v: PGLint){.stdcall, importc, ogl.} -proc glMultiTexCoord1s*(target: GLenum, s: GLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord1sv*(target: GLenum, v: PGLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord2d*(target: GLenum, s: GLdouble, t: GLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord2dv*(target: GLenum, v: PGLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord2f*(target: GLenum, s: GLfloat, t: GLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord2fv*(target: GLenum, v: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord2i*(target: GLenum, s: GLint, t: GLint){.stdcall, importc, ogl.} -proc glMultiTexCoord2iv*(target: GLenum, v: PGLint){.stdcall, importc, ogl.} -proc glMultiTexCoord2s*(target: GLenum, s: GLshort, t: GLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord2sv*(target: GLenum, v: PGLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord3d*(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble){. - stdcall, importc, ogl.} -proc glMultiTexCoord3dv*(target: GLenum, v: PGLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord3f*(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat){. - stdcall, importc, ogl.} -proc glMultiTexCoord3fv*(target: GLenum, v: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord3i*(target: GLenum, s: GLint, t: GLint, r: GLint){.stdcall, importc, ogl.} -proc glMultiTexCoord3iv*(target: GLenum, v: PGLint){.stdcall, importc, ogl.} -proc glMultiTexCoord3s*(target: GLenum, s: GLshort, t: GLshort, r: GLshort){. - stdcall, importc, ogl.} -proc glMultiTexCoord3sv*(target: GLenum, v: PGLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord4d*(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble, - q: GLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord4dv*(target: GLenum, v: PGLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord4f*(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, - q: GLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord4fv*(target: GLenum, v: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord4i*(target: GLenum, s: GLint, t: GLint, r: GLint, q: GLint){. - stdcall, importc, ogl.} -proc glMultiTexCoord4iv*(target: GLenum, v: PGLint){.stdcall, importc, ogl.} -proc glMultiTexCoord4s*(target: GLenum, s: GLshort, t: GLshort, r: GLshort, - q: GLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord4sv*(target: GLenum, v: PGLshort){.stdcall, importc, ogl.} -proc glLoadTransposeMatrixf*(m: PGLfloat){.stdcall, importc, ogl.} -proc glLoadTransposeMatrixd*(m: PGLdouble){.stdcall, importc, ogl.} -proc glMultTransposeMatrixf*(m: PGLfloat){.stdcall, importc, ogl.} -proc glMultTransposeMatrixd*(m: PGLdouble){.stdcall, importc, ogl.} - # GL_VERSION_1_4 -proc glBlendFuncSeparate*(sfactorRGB: GLenum, dfactorRGB: GLenum, - sfactorAlpha: GLenum, dfactorAlpha: GLenum){.stdcall, importc, ogl.} -proc glMultiDrawArrays*(mode: GLenum, first: PGLint, count: PGLsizei, - primcount: GLsizei){.stdcall, importc, ogl.} -proc glMultiDrawElements*(mode: GLenum, count: PGLsizei, typ: GLenum, - indices: PGLvoid, primcount: GLsizei){.stdcall, importc, ogl.} -proc glPointParameterf*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glPointParameterfv*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glPointParameteri*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glPointParameteriv*(pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glFogCoordf*(coord: GLfloat){.stdcall, importc, ogl.} -proc glFogCoordfv*(coord: PGLfloat){.stdcall, importc, ogl.} -proc glFogCoordd*(coord: GLdouble){.stdcall, importc, ogl.} -proc glFogCoorddv*(coord: PGLdouble){.stdcall, importc, ogl.} -proc glFogCoordPointer*(typ: GLenum, stride: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glSecondaryColor3b*(red: GLbyte, green: GLbyte, blue: GLbyte){.stdcall, importc, ogl.} -proc glSecondaryColor3bv*(v: PGLbyte){.stdcall, importc, ogl.} -proc glSecondaryColor3d*(red: GLdouble, green: GLdouble, blue: GLdouble){. - stdcall, importc, ogl.} -proc glSecondaryColor3dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glSecondaryColor3f*(red: GLfloat, green: GLfloat, blue: GLfloat){.stdcall, importc, ogl.} -proc glSecondaryColor3fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glSecondaryColor3i*(red: GLint, green: GLint, blue: GLint){.stdcall, importc, ogl.} -proc glSecondaryColor3iv*(v: PGLint){.stdcall, importc, ogl.} -proc glSecondaryColor3s*(red: GLshort, green: GLshort, blue: GLshort){.stdcall, importc, ogl.} -proc glSecondaryColor3sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glSecondaryColor3ub*(red: GLubyte, green: GLubyte, blue: GLubyte){.stdcall, importc, ogl.} -proc glSecondaryColor3ubv*(v: PGLubyte){.stdcall, importc, ogl.} -proc glSecondaryColor3ui*(red: GLuint, green: GLuint, blue: GLuint){.stdcall, importc, ogl.} -proc glSecondaryColor3uiv*(v: PGLuint){.stdcall, importc, ogl.} -proc glSecondaryColor3us*(red: GLushort, green: GLushort, blue: GLushort){. - stdcall, importc, ogl.} -proc glSecondaryColor3usv*(v: PGLushort){.stdcall, importc, ogl.} -proc glSecondaryColorPointer*(size: GLint, typ: GLenum, stride: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} -proc glWindowPos2d*(x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glWindowPos2dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glWindowPos2f*(x: GLfloat, y: GLfloat){.stdcall, importc, ogl.} -proc glWindowPos2fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glWindowPos2i*(x: GLint, y: GLint){.stdcall, importc, ogl.} -proc glWindowPos2iv*(v: PGLint){.stdcall, importc, ogl.} -proc glWindowPos2s*(x: GLshort, y: GLshort){.stdcall, importc, ogl.} -proc glWindowPos2sv*(v: PGLshort){.stdcall, importc, ogl.} -proc glWindowPos3d*(x: GLdouble, y: GLdouble, z: GLdouble){.stdcall, importc, ogl.} -proc glWindowPos3dv*(v: PGLdouble){.stdcall, importc, ogl.} -proc glWindowPos3f*(x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glWindowPos3fv*(v: PGLfloat){.stdcall, importc, ogl.} -proc glWindowPos3i*(x: GLint, y: GLint, z: GLint){.stdcall, importc, ogl.} -proc glWindowPos3iv*(v: PGLint){.stdcall, importc, ogl.} -proc glWindowPos3s*(x: GLshort, y: GLshort, z: GLshort){.stdcall, importc, ogl.} -proc glWindowPos3sv*(v: PGLshort){.stdcall, importc, ogl.} - # GL_VERSION_1_5 -proc glGenQueries*(n: GLsizei, ids: PGLuint){.stdcall, importc, ogl.} -proc glDeleteQueries*(n: GLsizei, ids: PGLuint){.stdcall, importc, ogl.} -proc glIsQuery*(id: GLuint): bool{.stdcall, importc, ogl.} -proc glBeginQuery*(target: GLenum, id: GLuint){.stdcall, importc, ogl.} -proc glEndQuery*(target: GLenum){.stdcall, importc, ogl.} -proc glGetQueryiv*(target, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetQueryObjectiv*(id: GLuint, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetQueryObjectuiv*(id: GLuint, pname: GLenum, params: PGLuint){.stdcall, importc, ogl.} -proc glBindBuffer*(target: GLenum, buffer: GLuint){.stdcall, importc, ogl.} -proc glDeleteBuffers*(n: GLsizei, buffers: PGLuint){.stdcall, importc, ogl.} -proc glGenBuffers*(n: GLsizei, buffers: PGLuint){.stdcall, importc, ogl.} -proc glIsBuffer*(buffer: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glBufferData*(target: GLenum, size: GLsizeiptr, data: PGLvoid, - usage: GLenum){.stdcall, importc, ogl.} -proc glBufferSubData*(target: GLenum, offset: GLintptr, size: GLsizeiptr, - data: PGLvoid){.stdcall, importc, ogl.} -proc glGetBufferSubData*(target: GLenum, offset: GLintptr, size: GLsizeiptr, - data: PGLvoid){.stdcall, importc, ogl.} -proc glMapBuffer*(target: GLenum, access: GLenum): PGLvoid{.stdcall, importc, ogl.} -proc glUnmapBuffer*(target: GLenum): GLboolean{.stdcall, importc, ogl.} -proc glGetBufferParameteriv*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetBufferPointerv*(target: GLenum, pname: GLenum, params: PGLvoid){. - stdcall, importc, ogl.} - # GL_VERSION_2_0 -proc glBlendEquationSeparate*(modeRGB: GLenum, modeAlpha: GLenum){.stdcall, importc, ogl.} -proc glDrawBuffers*(n: GLsizei, bufs: PGLenum){.stdcall, importc, ogl.} -proc glStencilOpSeparate*(face: GLenum, sfail: GLenum, dpfail: GLenum, - dppass: GLenum){.stdcall, importc, ogl.} -proc glStencilFuncSeparate*(face: GLenum, func: GLenum, theRef: GLint, mask: GLuint){. - stdcall, importc, ogl.} -proc glStencilMaskSeparate*(face: GLenum, mask: GLuint){.stdcall, importc, ogl.} -proc glAttachShader*(programObj, shaderObj: GLhandle){.stdcall, importc, ogl.} -proc glBindAttribLocation*(programObj: GLhandle, index: GLuint, name: PGLChar){. - stdcall, importc, ogl.} -proc glCompileShader*(shaderObj: GLhandle){.stdcall, importc, ogl.} -proc glCreateProgram*(): GLhandle{.stdcall, importc, ogl.} -proc glCreateShader*(shaderType: GLenum): GLhandle{.stdcall, importc, ogl.} -proc glDeleteProgram*(programObj: GLhandle){.stdcall, importc, ogl.} -proc glDeleteShader*(shaderObj: GLhandle){.stdcall, importc, ogl.} -proc glDetachShader*(programObj, shaderObj: GLhandle){.stdcall, importc, ogl.} -proc glDisableVertexAttribArray*(index: GLuint){.stdcall, importc, ogl.} -proc glEnableVertexAttribArray*(index: GLuint){.stdcall, importc, ogl.} -proc glGetActiveAttrib*(programObj: GLhandle, index: GLuint, maxlength: GLsizei, - len: ptr GLint, size: ptr GLint, typ: ptr GLenum, - name: PGLChar){.stdcall, importc, ogl.} -proc glGetActiveAttrib*(programObj: GLhandle, index: GLuint, maxlength: GLsizei, - len: var GLint, size: var GLint, typ: var GLenum, - name: PGLChar) = - glGetActiveAttrib(programObj, index, maxlength, addr len, addr size, - addr typ, name) -proc glGetActiveUniform*(programObj: GLhandle, index: GLuint, - maxLength: GLsizei, len: ptr GLsizei, size: ptr GLint, - typ: ptr GLenum, name: PGLChar){.stdcall, importc, ogl.} -proc glGetActiveUniform*(programObj: GLhandle, index: GLuint, - maxLength: GLsizei, len: var GLsizei, size: var GLint, - typ: var GLenum, name: PGLChar) = - glGetActiveUniform(programObj, index, maxLength, addr len, addr size, - addr typ, name) -proc glGetAttachedShaders*(programObj: GLhandle, MaxCount: GLsizei, - Count: ptr GLint, shaders: PGLuint){.stdcall, importc, ogl.} -proc glGetAttachedShaders*(programObj: GLhandle, MaxCount: GLsizei, - Count: var GLint, shaders: PGLuint) = - glGetAttachedShaders(programObj, MaxCount, addr count, shaders) -proc glGetAttribLocation*(programObj: GLhandle, char: PGLChar): glint{.stdcall, importc, ogl.} -proc glGetProgramiv*(programObj: GLhandle, pname: GLenum, params: PGLInt){. - stdcall, importc, ogl.} -proc glGetProgramInfoLog*(programObj: GLHandle, maxLength: glsizei, - len: ptr GLint, infoLog: PGLChar){.stdcall, importc, ogl.} -proc glGetProgramInfoLog*(programObj: GLHandle, maxLength: glsizei, - len: var GLint, infoLog: PGLChar) = - glGetProgramInfoLog(programObj, maxLength, addr len, infoLog) -proc glGetShaderiv*(shaderObj: GLhandle, pname: GLenum, params: PGLInt){.stdcall, importc, ogl.} -proc glGetShaderInfoLog*(shaderObj: GLHandle, maxLength: glsizei, - len: ptr glint, infoLog: PGLChar){.stdcall, importc, ogl.} -proc glGetShaderInfoLog*(shaderObj: GLHandle, maxLength: glsizei, - len: var glint, infoLog: PGLChar) = - glGetShaderInfoLog(shaderObj, maxLength, addr len, infoLog) -proc glGetShaderSource*(shaderObj: GLhandle, maxlength: GLsizei, - len: ptr GLsizei, source: PGLChar){.stdcall, importc, ogl.} -proc glGetShaderSource*(shaderObj: GLhandle, maxlength: GLsizei, - len: var GLsizei, source: PGLChar) = - glGetShaderSource(shaderObj, maxlength, addr len, source) -proc glGetUniformLocation*(programObj: GLhandle, char: PGLChar): glint{.stdcall, importc, ogl.} -proc glGetUniformfv*(programObj: GLhandle, location: GLint, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetUniformiv*(programObj: GLhandle, location: GLint, params: PGLInt){. - stdcall, importc, ogl.} -proc glGetVertexAttribfv*(index: GLuint, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetVertexAttribiv*(index: GLuint, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetVertexAttribPointerv*(index: GLuint, pname: GLenum, pointer: PGLvoid){. - stdcall, importc, ogl.} -proc glIsProgram*(programObj: GLhandle): GLboolean{.stdcall, importc, ogl.} -proc glIsShader*(shaderObj: GLhandle): GLboolean{.stdcall, importc, ogl.} -proc glLinkProgram*(programObj: GLHandle){.stdcall, importc, ogl.} -proc glShaderSource*(shaderObj: GLHandle, count: glsizei, string: cstringArray, - lengths: pglint){.stdcall, importc, ogl.} -proc glUseProgram*(programObj: GLhandle){.stdcall, importc, ogl.} -proc glUniform1f*(location: GLint, v0: GLfloat){.stdcall, importc, ogl.} -proc glUniform2f*(location: GLint, v0, v1: GLfloat){.stdcall, importc, ogl.} -proc glUniform3f*(location: GLint, v0, v1, v2: GLfloat){.stdcall, importc, ogl.} -proc glUniform4f*(location: GLint, v0, v1, v2, v3: GLfloat){.stdcall, importc, ogl.} -proc glUniform1i*(location: GLint, v0: GLint){.stdcall, importc, ogl.} -proc glUniform2i*(location: GLint, v0, v1: GLint){.stdcall, importc, ogl.} -proc glUniform3i*(location: GLint, v0, v1, v2: GLint){.stdcall, importc, ogl.} -proc glUniform4i*(location: GLint, v0, v1, v2, v3: GLint){.stdcall, importc, ogl.} -proc glUniform1fv*(location: GLint, count: GLsizei, value: PGLfloat){.stdcall, importc, ogl.} -proc glUniform2fv*(location: GLint, count: GLsizei, value: PGLfloat){.stdcall, importc, ogl.} -proc glUniform3fv*(location: GLint, count: GLsizei, value: PGLfloat){.stdcall, importc, ogl.} -proc glUniform4fv*(location: GLint, count: GLsizei, value: PGLfloat){.stdcall, importc, ogl.} -proc glUniform1iv*(location: GLint, count: GLsizei, value: PGLint){.stdcall, importc, ogl.} -proc glUniform2iv*(location: GLint, count: GLsizei, value: PGLint){.stdcall, importc, ogl.} -proc glUniform3iv*(location: GLint, count: GLsizei, value: PGLint){.stdcall, importc, ogl.} -proc glUniform4iv*(location: GLint, count: GLsizei, value: PGLint){.stdcall, importc, ogl.} -proc glUniformMatrix2fv*(location: GLint, count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glUniformMatrix3fv*(location: GLint, count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glUniformMatrix4fv*(location: GLint, count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glValidateProgram*(programObj: GLhandle){.stdcall, importc, ogl.} -proc glVertexAttrib1d*(index: GLuint, x: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib1dv*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib1f*(index: GLuint, x: GLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib1fv*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib1s*(index: GLuint, x: GLshort){.stdcall, importc, ogl.} -proc glVertexAttrib1sv*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib2d*(index: GLuint, x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib2dv*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib2f*(index: GLuint, x: GLfloat, y: GLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib2fv*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib2s*(index: GLuint, x: GLshort, y: GLshort){.stdcall, importc, ogl.} -proc glVertexAttrib2sv*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib3d*(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble){. - stdcall, importc, ogl.} -proc glVertexAttrib3dv*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib3f*(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat){. - stdcall, importc, ogl.} -proc glVertexAttrib3fv*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib3s*(index: GLuint, x: GLshort, y: GLshort, z: GLshort){. - stdcall, importc, ogl.} -proc glVertexAttrib3sv*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4Nbv*(index: GLuint, v: PGLbyte){.stdcall, importc, ogl.} -proc glVertexAttrib4Niv*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttrib4Nsv*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4Nub*(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, - w: GLubyte){.stdcall, importc, ogl.} -proc glVertexAttrib4Nubv*(index: GLuint, v: PGLubyte){.stdcall, importc, ogl.} -proc glVertexAttrib4Nuiv*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttrib4Nusv*(index: GLuint, v: PGLushort){.stdcall, importc, ogl.} -proc glVertexAttrib4bv*(index: GLuint, v: PGLbyte){.stdcall, importc, ogl.} -proc glVertexAttrib4d*(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, - w: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib4dv*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib4f*(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, - w: GLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib4fv*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib4iv*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttrib4s*(index: GLuint, x: GLshort, y: GLshort, z: GLshort, - w: GLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4sv*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4ubv*(index: GLuint, v: PGLubyte){.stdcall, importc, ogl.} -proc glVertexAttrib4uiv*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttrib4usv*(index: GLuint, v: PGLushort){.stdcall, importc, ogl.} -proc glVertexAttribPointer*(index: GLuint, size: GLint, typ: GLenum, - normalized: GLboolean, stride: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} - # GL_VERSION_2_1 -proc glUniformMatrix2x3fv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){.stdcall, importc, ogl.} -proc glUniformMatrix3x2fv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){.stdcall, importc, ogl.} -proc glUniformMatrix2x4fv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){.stdcall, importc, ogl.} -proc glUniformMatrix4x2fv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){.stdcall, importc, ogl.} -proc glUniformMatrix3x4fv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){.stdcall, importc, ogl.} -proc glUniformMatrix4x3fv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){.stdcall, importc, ogl.} - # GL_VERSION_3_0 - # OpenGL 3.0 also reuses entry points from these extensions: - # ARB_framebuffer_object - # ARB_map_buffer_range - # ARB_vertex_array_object -proc glColorMaski*(index: GLuint, r: GLboolean, g: GLboolean, b: GLboolean, - a: GLboolean){.stdcall, importc, ogl.} -proc glGetBooleani_v*(target: GLenum, index: GLuint, data: PGLboolean){.stdcall, importc, ogl.} -proc glGetIntegeri_v*(target: GLenum, index: GLuint, data: PGLint){.stdcall, importc, ogl.} -proc glEnablei*(target: GLenum, index: GLuint){.stdcall, importc, ogl.} -proc glDisablei*(target: GLenum, index: GLuint){.stdcall, importc, ogl.} -proc glIsEnabledi*(target: GLenum, index: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glBeginTransformFeedback*(primitiveMode: GLenum){.stdcall, importc, ogl.} -proc glEndTransformFeedback*(){.stdcall, importc, ogl.} -proc glBindBufferRange*(target: GLenum, index: GLuint, buffer: GLuint, - offset: GLintptr, size: GLsizeiptr){.stdcall, importc, ogl.} -proc glBindBufferBase*(target: GLenum, index: GLuint, buffer: GLuint){.stdcall, importc, ogl.} -proc glTransformFeedbackVaryings*(prog: GLuint, count: GLsizei, - varyings: cstringArray, bufferMode: GLenum){. - stdcall, importc, ogl.} -proc glGetTransformFeedbackVarying*(prog: GLuint, index: GLuint, - bufSize: GLsizei, len: PGLsizei, - size: PGLsizei, typ: PGLsizei, name: PGLchar){. - stdcall, importc, ogl.} -proc glClampColor*(targe: GLenum, clamp: GLenum){.stdcall, importc, ogl.} -proc glBeginConditionalRender*(id: GLuint, mode: GLenum){.stdcall, importc, ogl.} -proc glEndConditionalRender*(){.stdcall, importc, ogl.} -proc glVertexAttribIPointer*(index: GLuint, size: GLint, typ: GLenum, - stride: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glGetVertexAttribIiv*(index: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetVertexAttribIuiv*(index: GLuint, pname: GLenum, params: PGLuint){. - stdcall, importc, ogl.} -proc glVertexAttribI1i*(index: GLuint, x: GLint){.stdcall, importc, ogl.} -proc glVertexAttribI2i*(index: GLuint, x: GLint, y: GLint){.stdcall, importc, ogl.} -proc glVertexAttribI3i*(index: GLuint, x: GLint, y: GLint, z: GLint){.stdcall, importc, ogl.} -proc glVertexAttribI4i*(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint){. - stdcall, importc, ogl.} -proc glVertexAttribI1ui*(index: GLuint, x: GLuint){.stdcall, importc, ogl.} -proc glVertexAttribI2ui*(index: GLuint, x: GLuint, y: GLuint){.stdcall, importc, ogl.} -proc glVertexAttribI3ui*(index: GLuint, x: GLuint, y: GLuint, z: GLuint){. - stdcall, importc, ogl.} -proc glVertexAttribI4ui*(index: GLuint, x: GLuint, y: GLuint, z: GLuint, - w: GLuint){.stdcall, importc, ogl.} -proc glVertexAttribI1iv*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttribI2iv*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttribI3iv*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttribI4iv*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttribI1uiv*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribI2uiv*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribI3uiv*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribI4uiv*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribI4bv*(index: GLuint, v: PGLbyte){.stdcall, importc, ogl.} -proc glVertexAttribI4sv*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttribI4ubv*(index: GLuint, v: PGLubyte){.stdcall, importc, ogl.} -proc glVertexAttribI4usv*(index: GLuint, v: PGLushort){.stdcall, importc, ogl.} -proc glGetUniformuiv*(prog: GLuint, location: GLint, params: PGLuint){.stdcall, importc, ogl.} -proc glBindFragDataLocation*(prog: GLuint, color: GLuint, name: PGLChar){. - stdcall, importc, ogl.} -proc glGetFragDataLocation*(prog: GLuint, name: PGLChar): GLint{.stdcall, importc, ogl.} -proc glUniform1ui*(location: GLint, v0: GLuint){.stdcall, importc, ogl.} -proc glUniform2ui*(location: GLint, v0: GLuint, v1: GLuint){.stdcall, importc, ogl.} -proc glUniform3ui*(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint){.stdcall, importc, ogl.} -proc glUniform4ui*(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, - v3: GLuint){.stdcall, importc, ogl.} -proc glUniform1uiv*(location: GLint, count: GLsizei, value: PGLuint){.stdcall, importc, ogl.} -proc glUniform2uiv*(location: GLint, count: GLsizei, value: PGLuint){.stdcall, importc, ogl.} -proc glUniform3uiv*(location: GLint, count: GLsizei, value: PGLuint){.stdcall, importc, ogl.} -proc glUniform4uiv*(location: GLint, count: GLsizei, value: PGLuint){.stdcall, importc, ogl.} -proc glTexParameterIiv*(target: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glTexParameterIuiv*(target: GLenum, pname: GLenum, params: PGLuint){. - stdcall, importc, ogl.} -proc glGetTexParameterIiv*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetTexParameterIuiv*(target: GLenum, pname: GLenum, params: PGLuint){. - stdcall, importc, ogl.} -proc glClearBufferiv*(buffer: GLenum, drawbuffer: GLint, value: PGLint){.stdcall, importc, ogl.} -proc glClearBufferuiv*(buffer: GLenum, drawbuffer: GLint, value: PGLuint){. - stdcall, importc, ogl.} -proc glClearBufferfv*(buffer: GLenum, drawbuffer: GLint, value: PGLfloat){. - stdcall, importc, ogl.} -proc glClearBufferfi*(buffer: GLenum, drawbuffer: GLint, depth: GLfloat, - stencil: GLint){.stdcall, importc, ogl.} -proc glGetStringi*(name: GLenum, index: GLuint): PGLubyte{.stdcall, importc, ogl.} - # GL_VERSION_3_1 - # OpenGL 3.1 also reuses entry points from these extensions: - # ARB_copy_buffer - # ARB_uniform_buffer_object -proc glDrawArraysInstanced*(mode: GLenum, first: GLint, count: GLsizei, - primcount: GLsizei){.stdcall, importc, ogl.} -proc glDrawElementsInstanced*(mode: GLenum, count: GLsizei, typ: GLenum, - indices: PGLvoid, primcount: GLsizei){.stdcall, importc, ogl.} -proc glTexBuffer*(target: GLenum, internalformat: GLenum, buffer: GLuint){. - stdcall, importc, ogl.} -proc glPrimitiveRestartIndex*(index: GLuint){.stdcall, importc, ogl.} - # GL_VERSION_3_2 - # OpenGL 3.2 also reuses entry points from these extensions: - # ARB_draw_elements_base_vertex - # ARB_provoking_vertex - # ARB_sync - # ARB_texture_multisample -proc glGetInteger64i_v*(target: GLenum, index: GLuint, data: PGLint64){.stdcall, importc, ogl.} -proc glGetBufferParameteri64v*(target: GLenum, pname: GLenum, params: PGLint64){. - stdcall, importc, ogl.} -proc glFramebufferTexture*(target: GLenum, attachment: GLenum, texture: GLuint, - level: GLint){.stdcall, importc, ogl.} - #procedure glFramebufferTextureFace(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); stdcall, importc, ogl; - # GL_VERSION_3_3 - # OpenGL 3.3 also reuses entry points from these extensions: - # ARB_blend_func_extended - # ARB_sampler_objects - # ARB_explicit_attrib_location, but it has none - # ARB_occlusion_query2 (no entry points) - # ARB_shader_bit_encoding (no entry points) - # ARB_texture_rgb10_a2ui (no entry points) - # ARB_texture_swizzle (no entry points) - # ARB_timer_query - # ARB_vertextyp_2_10_10_10_rev -proc glVertexAttribDivisor*(index: GLuint, divisor: GLuint){.stdcall, importc, ogl.} - # GL_VERSION_4_0 - # OpenGL 4.0 also reuses entry points from these extensions: - # ARB_texture_query_lod (no entry points) - # ARB_draw_indirect - # ARB_gpu_shader5 (no entry points) - # ARB_gpu_shader_fp64 - # ARB_shader_subroutine - # ARB_tessellation_shader - # ARB_texture_buffer_object_rgb32 (no entry points) - # ARB_texture_cube_map_array (no entry points) - # ARB_texture_gather (no entry points) - # ARB_transform_feedback2 - # ARB_transform_feedback3 -proc glMinSampleShading*(value: GLclampf){.stdcall, importc, ogl.} -proc glBlendEquationi*(buf: GLuint, mode: GLenum){.stdcall, importc, ogl.} -proc glBlendEquationSeparatei*(buf: GLuint, modeRGB: GLenum, modeAlpha: GLenum){. - stdcall, importc, ogl.} -proc glBlendFunci*(buf: GLuint, src: GLenum, dst: GLenum){.stdcall, importc, ogl.} -proc glBlendFuncSeparatei*(buf: GLuint, srcRGB: GLenum, dstRGB: GLenum, - srcAlpha: GLenum, dstAlpha: GLenum){.stdcall, importc, ogl.} - # GL_VERSION_4_1 - # OpenGL 4.1 also reuses entry points from these extensions: - # ARB_ES2_compatibility - # ARB_get_program_binary - # ARB_separate_shader_objects - # ARB_shader_precision (no entry points) - # ARB_vertex_attrib_64bit - # ARB_viewport_array - # GL_3DFX_tbuffer -proc glTbufferMask3DFX*(mask: GLuint){.stdcall, importc, ogl.} - # GL_APPLE_element_array -proc glElementPointerAPPLE*(typ: GLenum, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glDrawElementArrayAPPLE*(mode: GLenum, first: GLint, count: GLsizei){. - stdcall, importc, ogl.} -proc glDrawRangeElementArrayAPPLE*(mode: GLenum, start: GLuint, ending: GLuint, - first: GLint, count: GLsizei){.stdcall, importc, ogl.} -proc glMultiDrawElementArrayAPPLE*(mode: GLenum, first: PGLint, count: PGLsizei, - primcount: GLsizei){.stdcall, importc, ogl.} -proc glMultiDrawRangeElementArrayAPPLE*(mode: GLenum, start: GLuint, - ending: GLuint, first: PGLint, - count: PGLsizei, primcount: GLsizei){. - stdcall, importc, ogl.} - # GL_APPLE_fence -proc glGenFencesAPPLE*(n: GLsizei, fences: PGLuint){.stdcall, importc, ogl.} -proc glDeleteFencesAPPLE*(n: GLsizei, fences: PGLuint){.stdcall, importc, ogl.} -proc glSetFenceAPPLE*(fence: GLuint){.stdcall, importc, ogl.} -proc glIsFenceAPPLE*(fence: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glTestFenceAPPLE*(fence: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glFinishFenceAPPLE*(fence: GLuint){.stdcall, importc, ogl.} -proc glTestObjectAPPLE*(obj: GLenum, name: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glFinishObjectAPPLE*(obj: GLenum, name: GLint){.stdcall, importc, ogl.} - # GL_APPLE_vertex_array_object -proc glBindVertexArrayAPPLE*(arr: GLuint){.stdcall, importc, ogl.} -proc glDeleteVertexArraysAPPLE*(n: GLsizei, arrays: PGLuint){.stdcall, importc, ogl.} -proc glGenVertexArraysAPPLE*(n: GLsizei, arrays: PGLuint){.stdcall, importc, ogl.} -proc glIsVertexArrayAPPLE*(arr: GLuint): GLboolean{.stdcall, importc, ogl.} - # GL_APPLE_vertex_array_range -proc glVertexArrayRangeAPPLE*(len: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glFlushVertexArrayRangeAPPLE*(len: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glVertexArrayParameteriAPPLE*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} - # GL_APPLE_texture_range -proc glTextureRangeAPPLE*(target: GLenum, len: GLsizei, Pointer: PGLvoid){. - stdcall, importc, ogl.} -proc glGetTexParameterPointervAPPLE*(target: GLenum, pname: GLenum, - params: PPGLvoid){.stdcall, importc, ogl.} - # GL_APPLE_vertex_program_evaluators -proc glEnableVertexAttribAPPLE*(index: GLuint, pname: GLenum){.stdcall, importc, ogl.} -proc glDisableVertexAttribAPPLE*(index: GLuint, pname: GLenum){.stdcall, importc, ogl.} -proc glIsVertexAttribEnabledAPPLE*(index: GLuint, pname: GLenum): GLboolean{. - stdcall, importc, ogl.} -proc glMapVertexAttrib1dAPPLE*(index: GLuint, size: GLuint, u1: GLdouble, - u2: GLdouble, stride: GLint, order: GLint, - points: PGLdouble){.stdcall, importc, ogl.} -proc glMapVertexAttrib1fAPPLE*(index: GLuint, size: GLuint, u1: GLfloat, - u2: GLfloat, stride: GLint, order: GLint, - points: PGLfloat){.stdcall, importc, ogl.} -proc glMapVertexAttrib2dAPPLE*(index: GLuint, size: GLuint, u1: GLdouble, - u2: GLdouble, ustride: GLint, uorder: GLint, - v1: GLdouble, v2: GLdouble, vstride: GLint, - vorder: GLint, points: PGLdouble){.stdcall, importc, ogl.} -proc glMapVertexAttrib2fAPPLE*(index: GLuint, size: GLuint, u1: GLfloat, - u2: GLfloat, ustride: GLint, order: GLint, - v1: GLfloat, v2: GLfloat, vstride: GLint, - vorder: GLint, points: GLfloat){.stdcall, importc, ogl.} - # GL_APPLE_object_purgeable -proc glObjectPurgeableAPPLE*(objectType: GLenum, name: GLuint, option: GLenum): GLenum{. - stdcall, importc, ogl.} -proc glObjectUnpurgeableAPPLE*(objectType: GLenum, name: GLuint, option: GLenum): GLenum{. - stdcall, importc, ogl.} -proc glGetObjectParameterivAPPLE*(objectType: GLenum, name: GLuint, - pname: GLenum, params: PGLint){.stdcall, importc, ogl.} - # GL_ARB_matrix_palette -proc glCurrentPaletteMatrixARB*(index: GLint){.stdcall, importc, ogl.} -proc glMatrixIndexubvARB*(size: GLint, indices: PGLubyte){.stdcall, importc, ogl.} -proc glMatrixIndexusvARB*(size: GLint, indices: PGLushort){.stdcall, importc, ogl.} -proc glMatrixIndexuivARB*(size: GLint, indices: PGLuint){.stdcall, importc, ogl.} -proc glMatrixIndexPointerARB*(size: GLint, typ: GLenum, stride: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} - # GL_ARB_multisample -proc glSampleCoverageARB*(value: GLclampf, invert: GLboolean){.stdcall, importc, ogl.} - # GL_ARB_multitexture -proc glActiveTextureARB*(texture: GLenum){.stdcall, importc, ogl.} -proc glClientActiveTextureARB*(texture: GLenum){.stdcall, importc, ogl.} -proc glMultiTexCoord1dARB*(target: GLenum, s: GLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord1dvARB*(target: GLenum, v: PGLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord1fARB*(target: GLenum, s: GLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord1fvARB*(target: GLenum, v: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord1iARB*(target: GLenum, s: GLint){.stdcall, importc, ogl.} -proc glMultiTexCoord1ivARB*(target: GLenum, v: PGLint){.stdcall, importc, ogl.} -proc glMultiTexCoord1sARB*(target: GLenum, s: GLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord1svARB*(target: GLenum, v: PGLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord2dARB*(target: GLenum, s: GLdouble, t: GLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord2dvARB*(target: GLenum, v: PGLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord2fARB*(target: GLenum, s: GLfloat, t: GLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord2fvARB*(target: GLenum, v: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord2iARB*(target: GLenum, s: GLint, t: GLint){.stdcall, importc, ogl.} -proc glMultiTexCoord2ivARB*(target: GLenum, v: PGLint){.stdcall, importc, ogl.} -proc glMultiTexCoord2sARB*(target: GLenum, s: GLshort, t: GLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord2svARB*(target: GLenum, v: PGLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord3dARB*(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble){. - stdcall, importc, ogl.} -proc glMultiTexCoord3dvARB*(target: GLenum, v: PGLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord3fARB*(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat){. - stdcall, importc, ogl.} -proc glMultiTexCoord3fvARB*(target: GLenum, v: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord3iARB*(target: GLenum, s: GLint, t: GLint, r: GLint){. - stdcall, importc, ogl.} -proc glMultiTexCoord3ivARB*(target: GLenum, v: PGLint){.stdcall, importc, ogl.} -proc glMultiTexCoord3sARB*(target: GLenum, s: GLshort, t: GLshort, r: GLshort){. - stdcall, importc, ogl.} -proc glMultiTexCoord3svARB*(target: GLenum, v: PGLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord4dARB*(target: GLenum, s: GLdouble, t: GLdouble, - r: GLdouble, q: GLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord4dvARB*(target: GLenum, v: PGLdouble){.stdcall, importc, ogl.} -proc glMultiTexCoord4fARB*(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, - q: GLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord4fvARB*(target: GLenum, v: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexCoord4iARB*(target: GLenum, s: GLint, t: GLint, r: GLint, - q: GLint){.stdcall, importc, ogl.} -proc glMultiTexCoord4ivARB*(target: GLenum, v: PGLint){.stdcall, importc, ogl.} -proc glMultiTexCoord4sARB*(target: GLenum, s: GLshort, t: GLshort, r: GLshort, - q: GLshort){.stdcall, importc, ogl.} -proc glMultiTexCoord4svARB*(target: GLenum, v: PGLshort){.stdcall, importc, ogl.} - # GL_ARB_point_parameters -proc glPointParameterfARB*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glPointParameterfvARB*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} - # GL_ARB_texture_compression -proc glCompressedTexImage3DARB*(target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - height: GLsizei, depth: GLsizei, border: GLint, - imageSize: GLsizei, data: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTexImage2DARB*(target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - height: GLsizei, border: GLint, - imageSize: GLsizei, data: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTexImage1DARB*(target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - border: GLint, imageSize: GLsizei, data: PGLvoid){. - stdcall, importc, ogl.} -proc glCompressedTexSubImage3DARB*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, zoffset: GLint, - width: GLsizei, height: GLsizei, - depth: GLsizei, format: GLenum, - imageSize: GLsizei, data: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTexSubImage2DARB*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, width: GLsizei, - height: GLsizei, format: GLenum, - imageSize: GLsizei, data: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTexSubImage1DARB*(target: GLenum, level: GLint, xoffset: GLint, - width: GLsizei, format: GLenum, - imageSize: GLsizei, data: PGLvoid){.stdcall, importc, ogl.} -proc glGetCompressedTexImageARB*(target: GLenum, level: GLint, img: PGLvoid){. - stdcall, importc, ogl.} - # GL_ARB_transpose_matrix -proc glLoadTransposeMatrixfARB*(m: PGLfloat){.stdcall, importc, ogl.} -proc glLoadTransposeMatrixdARB*(m: PGLdouble){.stdcall, importc, ogl.} -proc glMultTransposeMatrixfARB*(m: PGLfloat){.stdcall, importc, ogl.} -proc glMultTransposeMatrixdARB*(m: PGLdouble){.stdcall, importc, ogl.} - # GL_ARB_vertex_blend -proc glWeightbvARB*(size: GLint, weights: PGLbyte){.stdcall, importc, ogl.} -proc glWeightsvARB*(size: GLint, weights: PGLshort){.stdcall, importc, ogl.} -proc glWeightivARB*(size: GLint, weights: PGLint){.stdcall, importc, ogl.} -proc glWeightfvARB*(size: GLint, weights: PGLfloat){.stdcall, importc, ogl.} -proc glWeightdvARB*(size: GLint, weights: PGLdouble){.stdcall, importc, ogl.} -proc glWeightubvARB*(size: GLint, weights: PGLubyte){.stdcall, importc, ogl.} -proc glWeightusvARB*(size: GLint, weights: PGLushort){.stdcall, importc, ogl.} -proc glWeightuivARB*(size: GLint, weights: PGLuint){.stdcall, importc, ogl.} -proc glWeightPointerARB*(size: GLint, typ: GLenum, stride: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} -proc glVertexBlendARB*(count: GLint){.stdcall, importc, ogl.} - # GL_ARB_vertex_buffer_object -proc glBindBufferARB*(target: GLenum, buffer: GLuint){.stdcall, importc, ogl.} -proc glDeleteBuffersARB*(n: GLsizei, buffers: PGLuint){.stdcall, importc, ogl.} -proc glGenBuffersARB*(n: GLsizei, buffers: PGLuint){.stdcall, importc, ogl.} -proc glIsBufferARB*(buffer: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glBufferDataARB*(target: GLenum, size: GLsizeiptrARB, data: PGLvoid, - usage: GLenum){.stdcall, importc, ogl.} -proc glBufferSubDataARB*(target: GLenum, offset: GLintptrARB, - size: GLsizeiptrARB, data: PGLvoid){.stdcall, importc, ogl.} -proc glGetBufferSubDataARB*(target: GLenum, offset: GLintptrARB, - size: GLsizeiptrARB, data: PGLvoid){.stdcall, importc, ogl.} -proc glMapBufferARB*(target: GLenum, access: GLenum): PGLvoid{.stdcall, importc, ogl.} -proc glUnmapBufferARB*(target: GLenum): GLboolean{.stdcall, importc, ogl.} -proc glGetBufferParameterivARB*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetBufferPointervARB*(target: GLenum, pname: GLenum, params: PGLvoid){. - stdcall, importc, ogl.} - # GL_ARB_vertex_program -proc glVertexAttrib1dARB*(index: GLuint, x: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib1dvARB*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib1fARB*(index: GLuint, x: GLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib1fvARB*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib1sARB*(index: GLuint, x: GLshort){.stdcall, importc, ogl.} -proc glVertexAttrib1svARB*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib2dARB*(index: GLuint, x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib2dvARB*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib2fARB*(index: GLuint, x: GLfloat, y: GLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib2fvARB*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib2sARB*(index: GLuint, x: GLshort, y: GLshort){.stdcall, importc, ogl.} -proc glVertexAttrib2svARB*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib3dARB*(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble){. - stdcall, importc, ogl.} -proc glVertexAttrib3dvARB*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib3fARB*(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat){. - stdcall, importc, ogl.} -proc glVertexAttrib3fvARB*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib3sARB*(index: GLuint, x: GLshort, y: GLshort, z: GLshort){. - stdcall, importc, ogl.} -proc glVertexAttrib3svARB*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4NbvARB*(index: GLuint, v: PGLbyte){.stdcall, importc, ogl.} -proc glVertexAttrib4NivARB*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttrib4NsvARB*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4NubARB*(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, - w: GLubyte){.stdcall, importc, ogl.} -proc glVertexAttrib4NubvARB*(index: GLuint, v: PGLubyte){.stdcall, importc, ogl.} -proc glVertexAttrib4NuivARB*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttrib4NusvARB*(index: GLuint, v: PGLushort){.stdcall, importc, ogl.} -proc glVertexAttrib4bvARB*(index: GLuint, v: PGLbyte){.stdcall, importc, ogl.} -proc glVertexAttrib4dARB*(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, - w: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib4dvARB*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib4fARB*(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, - w: GLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib4fvARB*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib4ivARB*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttrib4sARB*(index: GLuint, x: GLshort, y: GLshort, z: GLshort, - w: GLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4svARB*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4ubvARB*(index: GLuint, v: PGLubyte){.stdcall, importc, ogl.} -proc glVertexAttrib4uivARB*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttrib4usvARB*(index: GLuint, v: PGLushort){.stdcall, importc, ogl.} -proc glVertexAttribPointerARB*(index: GLuint, size: GLint, typ: GLenum, - normalized: GLboolean, stride: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} -proc glEnableVertexAttribArrayARB*(index: GLuint){.stdcall, importc, ogl.} -proc glDisableVertexAttribArrayARB*(index: GLuint){.stdcall, importc, ogl.} -proc glProgramStringARB*(target: GLenum, format: GLenum, length: GLsizei, - string: PGLvoid){.stdcall, importc, ogl.} -proc glBindProgramARB*(target: GLenum, prog: GLuint){.stdcall, importc, ogl.} -proc glDeleteProgramsARB*(n: GLsizei, programs: PGLuint){.stdcall, importc, ogl.} -proc glGenProgramsARB*(n: GLsizei, programs: PGLuint){.stdcall, importc, ogl.} -proc glProgramEnvParameter4dARB*(target: GLenum, index: GLuint, x: GLdouble, - y: GLdouble, z: GLdouble, w: GLdouble){.stdcall, importc, ogl.} -proc glProgramEnvParameter4dvARB*(target: GLenum, index: GLuint, - params: PGLdouble){.stdcall, importc, ogl.} -proc glProgramEnvParameter4fARB*(target: GLenum, index: GLuint, x: GLfloat, - y: GLfloat, z: GLfloat, w: GLfloat){.stdcall, importc, ogl.} -proc glProgramEnvParameter4fvARB*(target: GLenum, index: GLuint, - params: PGLfloat){.stdcall, importc, ogl.} -proc glProgramLocalParameter4dARB*(target: GLenum, index: GLuint, x: GLdouble, - y: GLdouble, z: GLdouble, w: GLdouble){. - stdcall, importc, ogl.} -proc glProgramLocalParameter4dvARB*(target: GLenum, index: GLuint, - params: PGLdouble){.stdcall, importc, ogl.} -proc glProgramLocalParameter4fARB*(target: GLenum, index: GLuint, x: GLfloat, - y: GLfloat, z: GLfloat, w: GLfloat){.stdcall, importc, ogl.} -proc glProgramLocalParameter4fvARB*(target: GLenum, index: GLuint, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetProgramEnvParameterdvARB*(target: GLenum, index: GLuint, - params: PGLdouble){.stdcall, importc, ogl.} -proc glGetProgramEnvParameterfvARB*(target: GLenum, index: GLuint, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetProgramLocalParameterdvARB*(target: GLenum, index: GLuint, - params: PGLdouble){.stdcall, importc, ogl.} -proc glGetProgramLocalParameterfvARB*(target: GLenum, index: GLuint, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetProgramivARB*(target: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetProgramStringARB*(target: GLenum, pname: GLenum, string: PGLvoid){. - stdcall, importc, ogl.} -proc glGetVertexAttribdvARB*(index: GLuint, pname: GLenum, params: PGLdouble){. - stdcall, importc, ogl.} -proc glGetVertexAttribfvARB*(index: GLuint, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetVertexAttribivARB*(index: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetVertexAttribPointervARB*(index: GLuint, pname: GLenum, - pointer: PGLvoid){.stdcall, importc, ogl.} -proc glIsProgramARB*(prog: GLuint): GLboolean{.stdcall, importc, ogl.} - # GL_ARB_window_pos -proc glWindowPos2dARB*(x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glWindowPos2dvARB*(v: PGLdouble){.stdcall, importc, ogl.} -proc glWindowPos2fARB*(x: GLfloat, y: GLfloat){.stdcall, importc, ogl.} -proc glWindowPos2fvARB*(v: PGLfloat){.stdcall, importc, ogl.} -proc glWindowPos2iARB*(x: GLint, y: GLint){.stdcall, importc, ogl.} -proc glWindowPos2ivARB*(v: PGLint){.stdcall, importc, ogl.} -proc glWindowPos2sARB*(x: GLshort, y: GLshort){.stdcall, importc, ogl.} -proc glWindowPos2svARB*(v: PGLshort){.stdcall, importc, ogl.} -proc glWindowPos3dARB*(x: GLdouble, y: GLdouble, z: GLdouble){.stdcall, importc, ogl.} -proc glWindowPos3dvARB*(v: PGLdouble){.stdcall, importc, ogl.} -proc glWindowPos3fARB*(x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glWindowPos3fvARB*(v: PGLfloat){.stdcall, importc, ogl.} -proc glWindowPos3iARB*(x: GLint, y: GLint, z: GLint){.stdcall, importc, ogl.} -proc glWindowPos3ivARB*(v: PGLint){.stdcall, importc, ogl.} -proc glWindowPos3sARB*(x: GLshort, y: GLshort, z: GLshort){.stdcall, importc, ogl.} -proc glWindowPos3svARB*(v: PGLshort){.stdcall, importc, ogl.} - # GL_ARB_draw_buffers -proc glDrawBuffersARB*(n: GLsizei, bufs: PGLenum){.stdcall, importc, ogl.} - # GL_ARB_color_buffer_float -proc glClampColorARB*(target: GLenum, clamp: GLenum){.stdcall, importc, ogl.} - # GL_ARB_vertex_shader -proc glGetActiveAttribARB*(programobj: GLhandleARB, index: GLuint, - maxLength: GLsizei, len: var GLsizei, - size: var GLint, typ: var GLenum, name: PGLcharARB){. - stdcall, importc, ogl.} -proc glGetAttribLocationARB*(programObj: GLhandleARB, char: PGLcharARB): glint{. - stdcall, importc, ogl.} -proc glBindAttribLocationARB*(programObj: GLhandleARB, index: GLuint, - name: PGLcharARB){.stdcall, importc, ogl.} - # GL_ARB_shader_objects -proc glDeleteObjectARB*(Obj: GLHandleARB){.stdcall, importc, ogl.} -proc glGetHandleARB*(pname: GlEnum): GLHandleARB{.stdcall, importc, ogl.} -proc glDetachObjectARB*(container, attached: GLHandleARB){.stdcall, importc, ogl.} -proc glCreateShaderObjectARB*(shaderType: glenum): GLHandleARB{.stdcall, importc, ogl.} -proc glShaderSourceARB*(shaderObj: GLHandleARB, count: glsizei, - string: cstringArray, lengths: pglint){.stdcall, importc, ogl.} -proc glCompileShaderARB*(shaderObj: GLHandleARB){.stdcall, importc, ogl.} -proc glCreateProgramObjectARB*(): GLHandleARB{.stdcall, importc, ogl.} -proc glAttachObjectARB*(programObj, shaderObj: GLhandleARB){.stdcall, importc, ogl.} -proc glLinkProgramARB*(programObj: GLHandleARB){.stdcall, importc, ogl.} -proc glUseProgramObjectARB*(programObj: GLHandleARB){.stdcall, importc, ogl.} -proc glValidateProgramARB*(programObj: GLhandleARB){.stdcall, importc, ogl.} -proc glUniform1fARB*(location: glint, v0: glfloat){.stdcall, importc, ogl.} -proc glUniform2fARB*(location: glint, v0, v1: glfloat){.stdcall, importc, ogl.} -proc glUniform3fARB*(location: glint, v0, v1, v2: glfloat){.stdcall, importc, ogl.} -proc glUniform4fARB*(location: glint, v0, v1, v2, v3: glfloat){.stdcall, importc, ogl.} -proc glUniform1iARB*(location: glint, v0: glint){.stdcall, importc, ogl.} -proc glUniform2iARB*(location: glint, v0, v1: glint){.stdcall, importc, ogl.} -proc glUniform3iARB*(location: glint, v0, v1, v2: glint){.stdcall, importc, ogl.} -proc glUniform4iARB*(location: glint, v0, v1, v2, v3: glint){.stdcall, importc, ogl.} -proc glUniform1fvARB*(location: glint, count: GLsizei, value: pglfloat){.stdcall, importc, ogl.} -proc glUniform2fvARB*(location: glint, count: GLsizei, value: pglfloat){.stdcall, importc, ogl.} -proc glUniform3fvARB*(location: glint, count: GLsizei, value: pglfloat){.stdcall, importc, ogl.} -proc glUniform4fvARB*(location: glint, count: GLsizei, value: pglfloat){.stdcall, importc, ogl.} -proc glUniform1ivARB*(location: glint, count: GLsizei, value: pglint){.stdcall, importc, ogl.} -proc glUniform2ivARB*(location: glint, count: GLsizei, value: pglint){.stdcall, importc, ogl.} -proc glUniform3ivARB*(location: glint, count: GLsizei, value: pglint){.stdcall, importc, ogl.} -proc glUniform4ivARB*(location: glint, count: GLsizei, value: pglint){.stdcall, importc, ogl.} -proc glUniformMatrix2fvARB*(location: glint, count: glsizei, - transpose: glboolean, value: pglfloat){.stdcall, importc, ogl.} -proc glUniformMatrix3fvARB*(location: glint, count: glsizei, - transpose: glboolean, value: pglfloat){.stdcall, importc, ogl.} -proc glUniformMatrix4fvARB*(location: glint, count: glsizei, - transpose: glboolean, value: pglfloat){.stdcall, importc, ogl.} -proc glGetObjectParameterfvARB*(Obj: GLHandleARB, pname: GLEnum, - params: PGLFloat){.stdcall, importc, ogl.} -proc glGetObjectParameterivARB*(Obj: GLHandleARB, pname: GLEnum, params: PGLInt){. - stdcall, importc, ogl.} -proc glGetInfoLogARB*(shaderObj: GLHandleARB, maxLength: glsizei, - len: var glint, infoLog: PGLcharARB){.stdcall, importc, ogl.} -proc glGetAttachedObjectsARB*(programobj: GLhandleARB, maxCount: GLsizei, - count: var GLsizei, objects: PGLhandleARB){. - stdcall, importc, ogl.} -proc glGetUniformLocationARB*(programObj: GLhandleARB, char: PGLcharARB): glint{. - stdcall, importc, ogl.} -proc glGetActiveUniformARB*(programobj: GLhandleARB, index: GLuint, - maxLength: GLsizei, len: var GLsizei, - size: var GLint, typ: var GLenum, name: PGLcharARB){. - stdcall, importc, ogl.} -proc glGetUniformfvARB*(programObj: GLhandleARB, location: GLint, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetUniformivARB*(programObj: GLhandleARB, location: GLint, params: PGLInt){. - stdcall, importc, ogl.} -proc glGetShaderSourceARB*(shader: GLhandleARB, maxLength: GLsizei, - len: var GLsizei, source: PGLcharARB){.stdcall, importc, ogl.} - # GL_ARB_Occlusion_Query -proc glGenQueriesARB*(n: GLsizei, ids: PGLuint){.stdcall, importc, ogl.} -proc glDeleteQueriesARB*(n: GLsizei, ids: PGLuint){.stdcall, importc, ogl.} -proc glIsQueryARB*(id: GLuint): bool{.stdcall, importc, ogl.} -proc glBeginQueryARB*(target: GLenum, id: GLuint){.stdcall, importc, ogl.} -proc glEndQueryARB*(target: GLenum){.stdcall, importc, ogl.} -proc glGetQueryivARB*(target, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetQueryObjectivARB*(id: GLuint, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetQueryObjectuivARB*(id: GLuint, pname: GLenum, params: PGLuint){. - stdcall, importc, ogl.} - # GL_ARB_draw_instanced -proc glDrawArraysInstancedARB*(mode: GLenum, first: GLint, count: GLsizei, - primcount: GLsizei){.stdcall, importc, ogl.} -proc glDrawElementsInstancedARB*(mode: GLenum, count: GLsizei, typ: GLenum, - indices: PGLvoid, primcount: GLsizei){.stdcall, importc, ogl.} - # GL_ARB_framebuffer_object -proc glIsRenderbuffer*(renderbuffer: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glBindRenderbuffer*(target: GLenum, renderbuffer: GLuint){.stdcall, importc, ogl.} -proc glDeleteRenderbuffers*(n: GLsizei, renderbuffers: PGLuint){.stdcall, importc, ogl.} -proc glGenRenderbuffers*(n: GLsizei, renderbuffers: PGLuint){.stdcall, importc, ogl.} -proc glRenderbufferStorage*(target: GLenum, internalformat: GLenum, - width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} -proc glGetRenderbufferParameteriv*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glIsFramebuffer*(framebuffer: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glBindFramebuffer*(target: GLenum, framebuffer: GLuint){.stdcall, importc, ogl.} -proc glDeleteFramebuffers*(n: GLsizei, framebuffers: PGLuint){.stdcall, importc, ogl.} -proc glGenFramebuffers*(n: GLsizei, framebuffers: PGLuint){.stdcall, importc, ogl.} -proc glCheckFramebufferStatus*(target: GLenum): GLenum{.stdcall, importc, ogl.} -proc glFramebufferTexture1D*(target: GLenum, attachment: GLenum, - textarget: GLenum, texture: GLuint, level: GLint){. - stdcall, importc, ogl.} -proc glFramebufferTexture2D*(target: GLenum, attachment: GLenum, - textarget: GLenum, texture: GLuint, level: GLint){. - stdcall, importc, ogl.} -proc glFramebufferTexture3D*(target: GLenum, attachment: GLenum, - textarget: GLenum, texture: GLuint, level: GLint, - zoffset: GLint){.stdcall, importc, ogl.} -proc glFramebufferRenderbuffer*(target: GLenum, attachment: GLenum, - renderbuffertarget: GLenum, renderbuffer: GLuint){. - stdcall, importc, ogl.} -proc glGetFramebufferAttachmentParameteriv*(target: GLenum, attachment: GLenum, - pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGenerateMipmap*(target: GLenum){.stdcall, importc, ogl.} -proc glBlitFramebuffer*(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, - dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, - mask: GLbitfield, filter: GLenum){.stdcall, importc, ogl.} -proc glRenderbufferStorageMultisample*(target: GLenum, samples: GLsizei, - internalformat: GLenum, width: GLsizei, - height: GLsizei){.stdcall, importc, ogl.} -proc glFramebufferTextureLayer*(target: GLenum, attachment: GLenum, - texture: GLuint, level: GLint, layer: GLint){. - stdcall, importc, ogl.} - # GL_ARB_geometry_shader4 -proc glProgramParameteriARB*(prog: GLuint, pname: GLenum, value: GLint){.stdcall, importc, ogl.} -proc glFramebufferTextureARB*(target: GLenum, attachment: GLenum, - texture: GLuint, level: GLint){.stdcall, importc, ogl.} -proc glFramebufferTextureLayerARB*(target: GLenum, attachment: GLenum, - texture: GLuint, level: GLint, layer: GLint){. - stdcall, importc, ogl.} -proc glFramebufferTextureFaceARB*(target: GLenum, attachment: GLenum, - texture: GLuint, level: GLint, face: GLenum){. - stdcall, importc, ogl.} - # GL_ARB_instanced_arrays -proc glVertexAttribDivisorARB*(index: GLuint, divisor: GLuint){.stdcall, importc, ogl.} - # GL_ARB_map_buffer_range -proc glMapBufferRange*(target: GLenum, offset: GLintptr, len: GLsizeiptr, - access: GLbitfield): PGLvoid{.stdcall, importc, ogl.} -proc glFlushMappedBufferRange*(target: GLenum, offset: GLintptr, len: GLsizeiptr){. - stdcall, importc, ogl.} - # GL_ARB_texture_buffer_object -proc glTexBufferARB*(target: GLenum, internalformat: GLenum, buffer: GLuint){. - stdcall, importc, ogl.} - # GL_ARB_vertex_array_object -proc glBindVertexArray*(arr: GLuint){.stdcall, importc, ogl.} -proc glDeleteVertexArrays*(n: GLsizei, arrays: PGLuint){.stdcall, importc, ogl.} -proc glGenVertexArrays*(n: GLsizei, arrays: PGLuint){.stdcall, importc, ogl.} -proc glIsVertexArray*(arr: GLuint): GLboolean{.stdcall, importc, ogl.} - # GL_ARB_uniform_buffer_object -proc glGetUniformIndices*(prog: GLuint, uniformCount: GLsizei, - uniformNames: cstringArray, uniformIndices: PGLuint){. - stdcall, importc, ogl.} -proc glGetActiveUniformsiv*(prog: GLuint, uniformCount: GLsizei, - uniformIndices: PGLuint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetActiveUniformName*(prog: GLuint, uniformIndex: GLuint, - bufSize: GLsizei, len: PGLsizei, - uniformName: PGLchar){.stdcall, importc, ogl.} -proc glGetUniformBlockIndex*(prog: GLuint, uniformBlockName: PGLchar): GLuint{. - stdcall, importc, ogl.} -proc glGetActiveUniformBlockiv*(prog: GLuint, uniformBlockIndex: GLuint, - pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetActiveUniformBlockName*(prog: GLuint, uniformBlockIndex: GLuint, - bufSize: GLsizei, len: PGLsizei, - uniformBlockName: PGLchar){.stdcall, importc, ogl.} -proc glUniformBlockBinding*(prog: GLuint, uniformBlockIndex: GLuint, - uniformBlockBinding: GLuint){.stdcall, importc, ogl.} - # GL_ARB_copy_buffer -proc glCopyBufferSubData*(readTarget: GLenum, writeTarget: GLenum, - readOffset: GLintptr, writeOffset: GLintptr, - size: GLsizeiptr){.stdcall, importc, ogl.} - # GL_ARB_draw_elements_base_vertex -proc glDrawElementsBaseVertex*(mode: GLenum, count: GLsizei, typ: GLenum, - indices: PGLvoid, basevertex: GLint){.stdcall, importc, ogl.} -proc glDrawRangeElementsBaseVertex*(mode: GLenum, start: GLuint, ending: GLuint, - count: GLsizei, typ: GLenum, - indices: PGLvoid, basevertex: GLint){. - stdcall, importc, ogl.} -proc glDrawElementsInstancedBaseVertex*(mode: GLenum, count: GLsizei, - typ: GLenum, indices: PGLvoid, - primcount: GLsizei, basevertex: GLint){. - stdcall, importc, ogl.} -proc glMultiDrawElementsBaseVertex*(mode: GLenum, count: PGLsizei, typ: GLenum, - indices: PPGLvoid, primcount: GLsizei, - basevertex: PGLint){.stdcall, importc, ogl.} - # GL_ARB_provoking_vertex -proc glProvokingVertex*(mode: GLenum){.stdcall, importc, ogl.} - # GL_ARB_sync -proc glFenceSync*(condition: GLenum, flags: GLbitfield): GLsync{.stdcall, importc, ogl.} -proc glIsSync*(sync: GLsync): GLboolean{.stdcall, importc, ogl.} -proc glDeleteSync*(sync: GLsync){.stdcall, importc, ogl.} -proc glClientWaitSync*(sync: GLsync, flags: GLbitfield, timeout: GLuint64): GLenum{. - stdcall, importc, ogl.} -proc glWaitSync*(sync: GLsync, flags: GLbitfield, timeout: GLuint64){.stdcall, importc, ogl.} -proc glGetInteger64v*(pname: GLenum, params: PGLint64){.stdcall, importc, ogl.} -proc glGetSynciv*(sync: GLsync, pname: GLenum, butSize: GLsizei, len: PGLsizei, - values: PGLint){.stdcall, importc, ogl.} - # GL_ARB_texture_multisample -proc glTexImage2DMultisample*(target: GLenum, samples: GLsizei, - internalformat: GLint, width: GLsizei, - height: GLsizei, fixedsamplelocations: GLboolean){. - stdcall, importc, ogl.} -proc glTexImage3DMultisample*(target: GLenum, samples: GLsizei, - internalformat: GLint, width: GLsizei, - height: GLsizei, depth: GLsizei, - fixedsamplelocations: GLboolean){.stdcall, importc, ogl.} -proc glGetMultisamplefv*(pname: GLenum, index: GLuint, val: PGLfloat){.stdcall, importc, ogl.} -proc glSampleMaski*(index: GLuint, mask: GLbitfield){.stdcall, importc, ogl.} - # GL_ARB_draw_buffers_blend -proc glBlendEquationiARB*(buf: GLuint, mode: GLenum){.stdcall, importc, ogl.} -proc glBlendEquationSeparateiARB*(buf: GLuint, modeRGB: GLenum, - modeAlpha: GLenum){.stdcall, importc, ogl.} -proc glBlendFunciARB*(buf: GLuint, src: GLenum, dst: GLenum){.stdcall, importc, ogl.} -proc glBlendFuncSeparateiARB*(buf: GLuint, srcRGB: GLenum, dstRGB: GLenum, - srcAlpha: GLenum, dstAlpha: GLenum){.stdcall, importc, ogl.} - # GL_ARB_sample_shading -proc glMinSampleShadingARB*(value: GLclampf){.stdcall, importc, ogl.} - # GL_ARB_shading_language_include -proc glNamedStringARB*(typ: GLenum, namelen: GLint, name: PGLchar, - stringlen: GLint, string: PGLchar){.stdcall, importc, ogl.} -proc glDeleteNamedStringARB*(namelen: GLint, name: PGLchar){.stdcall, importc, ogl.} -proc glCompileShaderIncludeARB*(shader: GLuint, count: GLsizei, path: PPGLchar, - len: PGLint){.stdcall, importc, ogl.} -proc glIsNamedStringARB*(namelen: GLint, name: PGLchar): GLboolean{.stdcall, importc, ogl.} -proc glGetNamedStringARB*(namelen: GLint, name: PGLchar, bufSize: GLsizei, - stringlen: GLint, string: PGLchar){.stdcall, importc, ogl.} -proc glGetNamedStringivARB*(namelen: GLint, name: PGLchar, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} - # GL_ARB_blend_func_extended -proc glBindFragDataLocationIndexed*(prog: GLuint, colorNumber: GLuint, - index: GLuint, name: PGLchar){.stdcall, importc, ogl.} -proc glGetFragDataIndex*(prog: GLuint, name: PGLchar): GLint{.stdcall, importc, ogl.} - # GL_ARB_sampler_objects -proc glGenSamplers*(count: GLsizei, samplers: PGLuint){.stdcall, importc, ogl.} -proc glDeleteSamplers*(count: GLsizei, samplers: PGLuint){.stdcall, importc, ogl.} -proc glIsSampler*(sampler: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glBindSampler*(theUnit: GLuint, sampler: GLuint){.stdcall, importc, ogl.} -proc glSamplerParameteri*(sampler: GLuint, pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glSamplerParameteriv*(sampler: GLuint, pname: GLenum, param: PGLint){. - stdcall, importc, ogl.} -proc glSamplerParameterf*(sampler: GLuint, pname: GLenum, param: GLfloat){. - stdcall, importc, ogl.} -proc glSamplerParameterfv*(sampler: GLuint, pname: GLenum, param: PGLfloat){. - stdcall, importc, ogl.} -proc glSamplerParameterIiv*(sampler: GLuint, pname: GLenum, param: PGLint){. - stdcall, importc, ogl.} -proc glSamplerParameterIuiv*(sampler: GLuint, pname: GLenum, param: PGLuint){. - stdcall, importc, ogl.} -proc glGetSamplerParameteriv*(sampler: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetSamplerParameterIiv*(sampler: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetSamplerParameterfv*(sampler: GLuint, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetSamplerParameterIuiv*(sampler: GLuint, pname: GLenum, params: PGLuint){. - stdcall, importc, ogl.} - # GL_ARB_timer_query -proc glQueryCounter*(id: GLuint, target: GLenum){.stdcall, importc, ogl.} -proc glGetQueryObjecti64v*(id: GLuint, pname: GLenum, params: PGLint64){.stdcall, importc, ogl.} -proc glGetQueryObjectui64v*(id: GLuint, pname: GLenum, params: PGLuint64){. - stdcall, importc, ogl.} - # GL_ARB_vertextyp_2_10_10_10_rev -proc glVertexP2ui*(typ: GLenum, value: GLuint){.stdcall, importc, ogl.} -proc glVertexP2uiv*(typ: GLenum, value: PGLuint){.stdcall, importc, ogl.} -proc glVertexP3ui*(typ: GLenum, value: GLuint){.stdcall, importc, ogl.} -proc glVertexP3uiv*(typ: GLenum, value: PGLuint){.stdcall, importc, ogl.} -proc glVertexP4ui*(typ: GLenum, value: GLuint){.stdcall, importc, ogl.} -proc glVertexP4uiv*(typ: GLenum, value: PGLuint){.stdcall, importc, ogl.} -proc glTexCoordP1ui*(typ: GLenum, coords: GLuint){.stdcall, importc, ogl.} -proc glTexCoordP1uiv*(typ: GLenum, coords: PGLuint){.stdcall, importc, ogl.} -proc glTexCoordP2ui*(typ: GLenum, coords: GLuint){.stdcall, importc, ogl.} -proc glTexCoordP2uiv*(typ: GLenum, coords: PGLuint){.stdcall, importc, ogl.} -proc glTexCoordP3ui*(typ: GLenum, coords: GLuint){.stdcall, importc, ogl.} -proc glTexCoordP3uiv*(typ: GLenum, coords: PGLuint){.stdcall, importc, ogl.} -proc glTexCoordP4ui*(typ: GLenum, coords: GLuint){.stdcall, importc, ogl.} -proc glTexCoordP4uiv*(typ: GLenum, coords: PGLuint){.stdcall, importc, ogl.} -proc glMultiTexCoordP1ui*(texture: GLenum, typ: GLenum, coords: GLuint){.stdcall, importc, ogl.} -proc glMultiTexCoordP1uiv*(texture: GLenum, typ: GLenum, coords: GLuint){. - stdcall, importc, ogl.} -proc glMultiTexCoordP2ui*(texture: GLenum, typ: GLenum, coords: GLuint){.stdcall, importc, ogl.} -proc glMultiTexCoordP2uiv*(texture: GLenum, typ: GLenum, coords: PGLuint){. - stdcall, importc, ogl.} -proc glMultiTexCoordP3ui*(texture: GLenum, typ: GLenum, coords: GLuint){.stdcall, importc, ogl.} -proc glMultiTexCoordP3uiv*(texture: GLenum, typ: GLenum, coords: PGLuint){. - stdcall, importc, ogl.} -proc glMultiTexCoordP4ui*(texture: GLenum, typ: GLenum, coords: GLuint){.stdcall, importc, ogl.} -proc glMultiTexCoordP4uiv*(texture: GLenum, typ: GLenum, coords: PGLuint){. - stdcall, importc, ogl.} -proc glNormalP3ui*(typ: GLenum, coords: GLuint){.stdcall, importc, ogl.} -proc glNormalP3uiv*(typ: GLenum, coords: PGLuint){.stdcall, importc, ogl.} -proc glColorP3ui*(typ: GLenum, color: GLuint){.stdcall, importc, ogl.} -proc glColorP3uiv*(typ: GLenum, color: PGLuint){.stdcall, importc, ogl.} -proc glColorP4ui*(typ: GLenum, color: GLuint){.stdcall, importc, ogl.} -proc glColorP4uiv*(typ: GLenum, color: GLuint){.stdcall, importc, ogl.} -proc glSecondaryColorP3ui*(typ: GLenum, color: GLuint){.stdcall, importc, ogl.} -proc glSecondaryColorP3uiv*(typ: GLenum, color: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribP1ui*(index: GLuint, typ: GLenum, normalized: GLboolean, - value: GLuint){.stdcall, importc, ogl.} -proc glVertexAttribP1uiv*(index: GLuint, typ: GLenum, normalized: GLboolean, - value: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribP2ui*(index: GLuint, typ: GLenum, normalized: GLboolean, - value: GLuint){.stdcall, importc, ogl.} -proc glVertexAttribP2uiv*(index: GLuint, typ: GLenum, normalized: GLboolean, - value: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribP3ui*(index: GLuint, typ: GLenum, normalized: GLboolean, - value: GLuint){.stdcall, importc, ogl.} -proc glVertexAttribP3uiv*(index: GLuint, typ: GLenum, normalized: GLboolean, - value: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribP4ui*(index: GLuint, typ: GLenum, normalized: GLboolean, - value: GLuint){.stdcall, importc, ogl.} -proc glVertexAttribP4uiv*(index: GLuint, typ: GLenum, normalized: GLboolean, - value: PGLuint){.stdcall, importc, ogl.} - # GL_ARB_draw_indirect -proc glDrawArraysIndirect*(mode: GLenum, indirect: PGLvoid){.stdcall, importc, ogl.} -proc glDrawElementsIndirect*(mode: GLenum, typ: GLenum, indirect: PGLvoid){. - stdcall, importc, ogl.} - # GL_ARB_gpu_shader_fp64 -proc glUniform1d*(location: GLint, x: GLdouble){.stdcall, importc, ogl.} -proc glUniform2d*(location: GLint, x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glUniform3d*(location: GLint, x: GLdouble, y: GLdouble, z: GLdouble){. - stdcall, importc, ogl.} -proc glUniform4d*(location: GLint, x: GLdouble, y: GLdouble, z: GLdouble, - w: GLdouble){.stdcall, importc, ogl.} -proc glUniform1dv*(location: GLint, count: GLsizei, value: PGLdouble){.stdcall, importc, ogl.} -proc glUniform2dv*(location: GLint, count: GLsizei, value: PGLdouble){.stdcall, importc, ogl.} -proc glUniform3dv*(location: GLint, count: GLsizei, value: PGLdouble){.stdcall, importc, ogl.} -proc glUniform4dv*(location: GLint, count: GLsizei, value: PGLdouble){.stdcall, importc, ogl.} -proc glUniformMatrix2dv*(location: GLint, count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glUniformMatrix3dv*(location: GLint, count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glUniformMatrix4dv*(location: GLint, count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glUniformMatrix2x3dv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){.stdcall, importc, ogl.} -proc glUniformMatrix2x4dv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){.stdcall, importc, ogl.} -proc glUniformMatrix3x2dv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){.stdcall, importc, ogl.} -proc glUniformMatrix3x4dv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){.stdcall, importc, ogl.} -proc glUniformMatrix4x2dv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){.stdcall, importc, ogl.} -proc glUniformMatrix4x3dv*(location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){.stdcall, importc, ogl.} -proc glGetUniformdv*(prog: GLuint, location: GLint, params: PGLdouble){.stdcall, importc, ogl.} - # GL_ARB_shader_subroutine -proc glGetSubroutineUniformLocation*(prog: GLuint, shadertype: GLenum, - name: PGLchar): GLint{.stdcall, importc, ogl.} -proc glGetSubroutineIndex*(prog: GLuint, shadertype: GLenum, name: PGLchar): GLuint{. - stdcall, importc, ogl.} -proc glGetActiveSubroutineUniformiv*(prog: GLuint, shadertype: GLenum, - index: GLuint, pname: GLenum, - values: PGLint){.stdcall, importc, ogl.} -proc glGetActiveSubroutineUniformName*(prog: GLuint, shadertype: GLenum, - index: GLuint, bufsize: GLsizei, - len: PGLsizei, name: PGLchar){.stdcall, importc, ogl.} -proc glGetActiveSubroutineName*(prog: GLuint, shadertype: GLenum, index: GLuint, - bufsize: GLsizei, len: PGLsizei, name: PGLchar){. - stdcall, importc, ogl.} -proc glUniformSubroutinesuiv*(shadertype: GLenum, count: GLsizei, - indices: PGLuint){.stdcall, importc, ogl.} -proc glGetUniformSubroutineuiv*(shadertype: GLenum, location: GLint, - params: PGLuint){.stdcall, importc, ogl.} -proc glGetProgramStageiv*(prog: GLuint, shadertype: GLenum, pname: GLenum, - values: PGLint){.stdcall, importc, ogl.} - # GL_ARB_tessellation_shader -proc glPatchParameteri*(pname: GLenum, value: GLint){.stdcall, importc, ogl.} -proc glPatchParameterfv*(pname: GLenum, values: PGLfloat){.stdcall, importc, ogl.} - # GL_ARB_transform_feedback2 -proc glBindTransformFeedback*(target: GLenum, id: GLuint){.stdcall, importc, ogl.} -proc glDeleteTransformFeedbacks*(n: GLsizei, ids: PGLuint){.stdcall, importc, ogl.} -proc glGenTransformFeedbacks*(n: GLsizei, ids: PGLuint){.stdcall, importc, ogl.} -proc glIsTransformFeedback*(id: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glPauseTransformFeedback*(){.stdcall, importc, ogl.} -proc glResumeTransformFeedback*(){.stdcall, importc, ogl.} -proc glDrawTransformFeedback*(mode: GLenum, id: GLuint){.stdcall, importc, ogl.} - # GL_ARB_transform_feedback3 -proc glDrawTransformFeedbackStream*(mode: GLenum, id: GLuint, stream: GLuint){. - stdcall, importc, ogl.} -proc glBeginQueryIndexed*(target: GLenum, index: GLuint, id: GLuint){.stdcall, importc, ogl.} -proc glEndQueryIndexed*(target: GLenum, index: GLuint){.stdcall, importc, ogl.} -proc glGetQueryIndexediv*(target: GLenum, index: GLuint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} - # GL_ARB_ES2_compatibility -proc glReleaseShaderCompiler*(){.stdcall, importc, ogl.} -proc glShaderBinary*(count: GLsizei, shaders: PGLuint, binaryformat: GLenum, - binary: PGLvoid, len: GLsizei){.stdcall, importc, ogl.} -proc glGetShaderPrecisionFormat*(shadertype: GLenum, precisiontype: GLenum, - range: PGLint, precision: PGLint){.stdcall, importc, ogl.} -proc glDepthRangef*(n: GLclampf, f: GLclampf){.stdcall, importc, ogl.} -proc glClearDepthf*(d: GLclampf){.stdcall, importc, ogl.} - # GL_ARB_get_prog_binary -proc glGetProgramBinary*(prog: GLuint, bufSize: GLsizei, len: PGLsizei, - binaryFormat: PGLenum, binary: PGLvoid){.stdcall, importc, ogl.} -proc glProgramBinary*(prog: GLuint, binaryFormat: GLenum, binary: PGLvoid, - len: GLsizei){.stdcall, importc, ogl.} -proc glProgramParameteri*(prog: GLuint, pname: GLenum, value: GLint){.stdcall, importc, ogl.} - # GL_ARB_separate_shader_objects -proc glUseProgramStages*(pipeline: GLuint, stages: GLbitfield, prog: GLuint){. - stdcall, importc, ogl.} -proc glActiveShaderProgram*(pipeline: GLuint, prog: GLuint){.stdcall, importc, ogl.} -proc glCreateShaderProgramv*(typ: GLenum, count: GLsizei, strings: cstringArray): GLuint{. - stdcall, importc, ogl.} -proc glBindProgramPipeline*(pipeline: GLuint){.stdcall, importc, ogl.} -proc glDeleteProgramPipelines*(n: GLsizei, pipelines: PGLuint){.stdcall, importc, ogl.} -proc glGenProgramPipelines*(n: GLsizei, pipelines: PGLuint){.stdcall, importc, ogl.} -proc glIsProgramPipeline*(pipeline: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glGetProgramPipelineiv*(pipeline: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glProgramUniform1i*(prog: GLuint, location: GLint, v0: GLint){.stdcall, importc, ogl.} -proc glProgramUniform1iv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint){.stdcall, importc, ogl.} -proc glProgramUniform1f*(prog: GLuint, location: GLint, v0: GLfloat){.stdcall, importc, ogl.} -proc glProgramUniform1fv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniform1d*(prog: GLuint, location: GLint, v0: GLdouble){.stdcall, importc, ogl.} -proc glProgramUniform1dv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniform1ui*(prog: GLuint, location: GLint, v0: GLuint){.stdcall, importc, ogl.} -proc glProgramUniform1uiv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint){.stdcall, importc, ogl.} -proc glProgramUniform2i*(prog: GLuint, location: GLint, v0: GLint, v1: GLint){. - stdcall, importc, ogl.} -proc glProgramUniform2iv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint){.stdcall, importc, ogl.} -proc glProgramUniform2f*(prog: GLuint, location: GLint, v0: GLfloat, v1: GLfloat){. - stdcall, importc, ogl.} -proc glProgramUniform2fv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniform2d*(prog: GLuint, location: GLint, v0: GLdouble, - v1: GLdouble){.stdcall, importc, ogl.} -proc glProgramUniform2dv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniform2ui*(prog: GLuint, location: GLint, v0: GLuint, v1: GLuint){. - stdcall, importc, ogl.} -proc glProgramUniform2uiv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint){.stdcall, importc, ogl.} -proc glProgramUniform3i*(prog: GLuint, location: GLint, v0: GLint, v1: GLint, - v2: GLint){.stdcall, importc, ogl.} -proc glProgramUniform3iv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint){.stdcall, importc, ogl.} -proc glProgramUniform3f*(prog: GLuint, location: GLint, v0: GLfloat, - v1: GLfloat, v2: GLfloat){.stdcall, importc, ogl.} -proc glProgramUniform3fv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniform3d*(prog: GLuint, location: GLint, v0: GLdouble, - v1: GLdouble, v2: GLdouble){.stdcall, importc, ogl.} -proc glProgramUniform3dv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniform3ui*(prog: GLuint, location: GLint, v0: GLuint, v1: GLuint, - v2: GLuint){.stdcall, importc, ogl.} -proc glProgramUniform3uiv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint){.stdcall, importc, ogl.} -proc glProgramUniform4i*(prog: GLuint, location: GLint, v0: GLint, v1: GLint, - v2: GLint, v3: GLint){.stdcall, importc, ogl.} -proc glProgramUniform4iv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint){.stdcall, importc, ogl.} -proc glProgramUniform4f*(prog: GLuint, location: GLint, v0: GLfloat, - v1: GLfloat, v2: GLfloat, v3: GLfloat){.stdcall, importc, ogl.} -proc glProgramUniform4fv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniform4d*(prog: GLuint, location: GLint, v0: GLdouble, - v1: GLdouble, v2: GLdouble, v3: GLdouble){.stdcall, importc, ogl.} -proc glProgramUniform4dv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniform4ui*(prog: GLuint, location: GLint, v0: GLuint, v1: GLuint, - v2: GLuint, v3: GLuint){.stdcall, importc, ogl.} -proc glProgramUniform4uiv*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint){.stdcall, importc, ogl.} -proc glProgramUniformMatrix2fv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix3fv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix4fv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix2dv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix3dv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix4dv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix2x3fv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix3x2fv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix2x4fv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix4x2fv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix3x4fv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix4x3fv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLfloat){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix2x3dv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix3x2dv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix2x4dv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix4x2dv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix3x4dv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){. - stdcall, importc, ogl.} -proc glProgramUniformMatrix4x3dv*(prog: GLuint, location: GLint, count: GLsizei, - transpose: GLboolean, value: PGLdouble){. - stdcall, importc, ogl.} -proc glValidateProgramPipeline*(pipeline: GLuint){.stdcall, importc, ogl.} -proc glGetProgramPipelineInfoLog*(pipeline: GLuint, bufSize: GLsizei, - len: PGLsizei, infoLog: PGLchar){.stdcall, importc, ogl.} - # GL_ARB_vertex_attrib_64bit -proc glVertexAttribL1d*(index: GLuint, x: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL2d*(index: GLuint, x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL3d*(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble){. - stdcall, importc, ogl.} -proc glVertexAttribL4d*(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, - w: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL1dv*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL2dv*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL3dv*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL4dv*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribLPointer*(index: GLuint, size: GLint, typ: GLenum, - stride: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glGetVertexAttribLdv*(index: GLuint, pname: GLenum, params: PGLdouble){. - stdcall, importc, ogl.} - # GL_ARB_viewport_array -proc glViewportArrayv*(first: GLuint, count: GLsizei, v: PGLfloat){.stdcall, importc, ogl.} -proc glViewportIndexedf*(index: GLuint, x: GLfloat, y: GLfloat, w: GLfloat, - h: GLfloat){.stdcall, importc, ogl.} -proc glViewportIndexedfv*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glScissorArrayv*(first: GLuint, count: GLsizei, v: PGLint){.stdcall, importc, ogl.} -proc glScissorIndexed*(index: GLuint, left: GLint, bottom: GLint, - width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} -proc glScissorIndexedv*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glDepthRangeArrayv*(first: GLuint, count: GLsizei, v: PGLclampd){.stdcall, importc, ogl.} -proc glDepthRangeIndexed*(index: GLuint, n: GLclampd, f: GLclampd){.stdcall, importc, ogl.} -proc glGetFloati_v*(target: GLenum, index: GLuint, data: PGLfloat){.stdcall, importc, ogl.} -proc glGetDoublei_v*(target: GLenum, index: GLuint, data: PGLdouble){.stdcall, importc, ogl.} - # GL 4.2 - # GL_ARB_base_instance -proc glDrawArraysInstancedBaseInstance*(mode: GLenum, first: GLint, - count: GLsizei, primcount: GLsizei, - baseinstance: GLUint){.stdcall, importc, ogl.} -proc glDrawElementsInstancedBaseInstance*(mode: GLEnum, count: GLsizei, - typ: GLenum, indices: PGLVoid, primcount: GLsizei, baseinstance: GLUInt){. - stdcall, importc, ogl.} -proc glDrawElementsInstancedBaseVertexBaseInstance*(mode: GLEnum, - count: GLsizei, typ: GLenum, indices: PGLVoid, primcount: GLsizei, - basevertex: GLint, baseinstance: GLuint){.stdcall, importc, ogl.} - # GL_ARB_transform_feedback_instanced -proc glDrawTransformFeedbackInstanced*(mode: GLenum, id: GLuint, - primcount: GLsizei){.stdcall, importc, ogl.} -proc glDrawTransformFeedbackStreamInstanced*(mode: GLenum, id: GLUInt, - stream: GLUint, primcount: GLsizei){.stdcall, importc, ogl.} - # GL_ARB_internalformat_query -proc glGetInternalformativ*(target: GLenum, internalformat: GLenum, - pname: GLenum, bufSize: GLsizei, params: PGLint){. - stdcall, importc, ogl.} - # GL_ARB_shader_atomic_counters -proc glGetActiveAtomicCounterBufferiv*(prog: GLuint, bufferIndex: GLuint, - pname: GLenum, params: PGLint){.stdcall, importc, ogl.} - #/ GL_ARB_shader_image_load_store -proc glBindImageTexture*(theUnit: GLuint, texture: GLuint, level: GLint, - layered: GLboolean, layer: GLint, access: GLenum, - format: GLenum){.stdcall, importc, ogl.} -proc glMemoryBarrier*(barriers: GLbitfield){.stdcall, importc, ogl.} - # GL_ARB_texture_storage -proc glTexStorage1D*(target: GLenum, levels: GLsizei, internalformat: GLenum, - width: GLsizei){.stdcall, importc, ogl.} -proc glTexStorage2D*(target: GLenum, levels: GLsizei, internalformat: GLenum, - width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} -proc glTexStorage3D*(target: GLenum, levels: GLsizei, internalformat: GLenum, - width: GLsizei, height: GLsizei, depth: GLsizei){.stdcall, importc, ogl.} -proc glTextureStorage1DEXT*(texture: GLuint, target: GLenum, levels: GLsizei, - internalformat: GLenum, width: GLsizei){.stdcall, importc, ogl.} -proc glTextureStorage2DEXT*(texture: GLuint, target: GLenum, levels: GLsizei, - internalformat: GLenum, width: GLsizei, - height: GLsizei){.stdcall, importc, ogl.} -proc glTextureStorage3DEXT*(texture: GLuint, target: GLenum, levels: GLsizei, - internalformat: GLenum, width: GLsizei, - height: GLsizei, depth: GLsizei){.stdcall, importc, ogl.} - # - # GL_ARB_cl_event -proc glCreateSyncFromCLeventARB*(context: p_cl_context, event: p_cl_event, - flags: GLbitfield): GLsync{.stdcall, importc, ogl.} - # GL_ARB_debug_output -proc glDebugMessageControlARB*(source: GLenum, typ: GLenum, severity: GLenum, - count: GLsizei, ids: PGLuint, enabled: GLboolean){. - stdcall, importc, ogl.} -proc glDebugMessageInsertARB*(source: GLenum, typ: GLenum, id: GLuint, - severity: GLenum, len: GLsizei, buf: PGLchar){. - stdcall, importc, ogl.} -proc glDebugMessageCallbackARB*(callback: TglDebugProcARB, userParam: PGLvoid){. - stdcall, importc, ogl.} -proc glGetDebugMessageLogARB*(count: GLuint, bufsize: GLsizei, sources: PGLenum, - types: PGLenum, ids: PGLuint, severities: PGLenum, - lengths: PGLsizei, messageLog: PGLchar): GLuint{. - stdcall, importc, ogl.} - # GL_ARB_robustness -proc glGetGraphicsResetStatusARB*(): GLenum{.stdcall, importc, ogl.} -proc glGetnMapdvARB*(target: GLenum, query: GLenum, bufSize: GLsizei, - v: PGLdouble){.stdcall, importc, ogl.} -proc glGetnMapfvARB*(target: GLenum, query: GLenum, bufSize: GLsizei, - v: PGLfloat){.stdcall, importc, ogl.} -proc glGetnMapivARB*(target: GLenum, query: GLenum, bufSize: GLsizei, v: PGLint){. - stdcall, importc, ogl.} -proc glGetnPixelMapfvARB*(map: GLenum, bufSize: GLsizei, values: PGLfloat){. - stdcall, importc, ogl.} -proc glGetnPixelMapuivARB*(map: GLenum, bufSize: GLsizei, values: PGLuint){. - stdcall, importc, ogl.} -proc glGetnPixelMapusvARB*(map: GLenum, bufSize: GLsizei, values: PGLushort){. - stdcall, importc, ogl.} -proc glGetnPolygonStippleARB*(bufSize: GLsizei, pattern: PGLubyte){.stdcall, importc, ogl.} -proc glGetnColorTableARB*(target: GLenum, format: GLenum, typ: GLenum, - bufSize: GLsizei, table: PGLvoid){.stdcall, importc, ogl.} -proc glGetnConvolutionFilterARB*(target: GLenum, format: GLenum, typ: GLenum, - bufSize: GLsizei, image: PGLvoid){.stdcall, importc, ogl.} -proc glGetnSeparableFilterARB*(target: GLenum, format: GLenum, typ: GLenum, - rowBufSize: GLsizei, row: PGLvoid, - columnBufSize: GLsizei, column: PGLvoid, - span: PGLvoid){.stdcall, importc, ogl.} -proc glGetnHistogramARB*(target: GLenum, reset: GLboolean, format: GLenum, - typ: GLenum, bufSize: GLsizei, values: PGLvoid){. - stdcall, importc, ogl.} -proc glGetnMinmaxARB*(target: GLenum, reset: GLboolean, format: GLenum, - typ: GLenum, bufSize: GLsizei, values: PGLvoid){.stdcall, importc, ogl.} -proc glGetnTexImageARB*(target: GLenum, level: GLint, format: GLenum, - typ: GLenum, bufSize: GLsizei, img: PGLvoid){.stdcall, importc, ogl.} -proc glReadnPixelsARB*(x: GLint, y: GLint, width: GLsizei, height: GLsizei, - format: GLenum, typ: GLenum, bufSize: GLsizei, - data: PGLvoid){.stdcall, importc, ogl.} -proc glGetnCompressedTexImageARB*(target: GLenum, lod: GLint, bufSize: GLsizei, - img: PGLvoid){.stdcall, importc, ogl.} -proc glGetnUniformfvARB*(prog: GLuint, location: GLint, bufSize: GLsizei, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetnUniformivARB*(prog: GLuint, location: GLint, bufSize: GLsizei, - params: PGLint){.stdcall, importc, ogl.} -proc glGetnUniformuivARB*(prog: GLuint, location: GLint, bufSize: GLsizei, - params: PGLuint){.stdcall, importc, ogl.} -proc glGetnUniformdvARB*(prog: GLuint, location: GLint, bufSize: GLsizei, - params: PGLdouble){.stdcall, importc, ogl.} - # GL_ATI_draw_buffers -proc glDrawBuffersATI*(n: GLsizei, bufs: PGLenum){.stdcall, importc, ogl.} - # GL_ATI_element_array -proc glElementPointerATI*(typ: GLenum, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glDrawElementArrayATI*(mode: GLenum, count: GLsizei){.stdcall, importc, ogl.} -proc glDrawRangeElementArrayATI*(mode: GLenum, start: GLuint, ending: GLuint, - count: GLsizei){.stdcall, importc, ogl.} - # GL_ATI_envmap_bumpmap -proc glTexBumpParameterivATI*(pname: GLenum, param: PGLint){.stdcall, importc, ogl.} -proc glTexBumpParameterfvATI*(pname: GLenum, param: PGLfloat){.stdcall, importc, ogl.} -proc glGetTexBumpParameterivATI*(pname: GLenum, param: PGLint){.stdcall, importc, ogl.} -proc glGetTexBumpParameterfvATI*(pname: GLenum, param: PGLfloat){.stdcall, importc, ogl.} - # GL_ATI_fragment_shader -proc glGenFragmentShadersATI*(range: GLuint): GLuint{.stdcall, importc, ogl.} -proc glBindFragmentShaderATI*(id: GLuint){.stdcall, importc, ogl.} -proc glDeleteFragmentShaderATI*(id: GLuint){.stdcall, importc, ogl.} -proc glBeginFragmentShaderATI*(){.stdcall, importc, ogl.} -proc glEndFragmentShaderATI*(){.stdcall, importc, ogl.} -proc glPassTexCoordATI*(dst: GLuint, coord: GLuint, swizzle: GLenum){.stdcall, importc, ogl.} -proc glSampleMapATI*(dst: GLuint, interp: GLuint, swizzle: GLenum){.stdcall, importc, ogl.} -proc glColorFragmentOp1ATI*(op: GLenum, dst: GLuint, dstMask: GLuint, - dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, - arg1Mod: GLuint){.stdcall, importc, ogl.} -proc glColorFragmentOp2ATI*(op: GLenum, dst: GLuint, dstMask: GLuint, - dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, - arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, - arg2Mod: GLuint){.stdcall, importc, ogl.} -proc glColorFragmentOp3ATI*(op: GLenum, dst: GLuint, dstMask: GLuint, - dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, - arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, - arg2Mod: GLuint, arg3: GLuint, arg3Rep: GLuint, - arg3Mod: GLuint){.stdcall, importc, ogl.} -proc glAlphaFragmentOp1ATI*(op: GLenum, dst: GLuint, dstMod: GLuint, - arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint){. - stdcall, importc, ogl.} -proc glAlphaFragmentOp2ATI*(op: GLenum, dst: GLuint, dstMod: GLuint, - arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, - arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint){. - stdcall, importc, ogl.} -proc glAlphaFragmentOp3ATI*(op: GLenum, dst: GLuint, dstMod: GLuint, - arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, - arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint, - arg3: GLuint, arg3Rep: GLuint, arg3Mod: GLuint){. - stdcall, importc, ogl.} -proc glSetFragmentShaderConstantATI*(dst: GLuint, value: PGLfloat){.stdcall, importc, ogl.} - # GL_ATI_map_object_buffer -proc glMapObjectBufferATI*(buffer: GLuint): PGLvoid{.stdcall, importc, ogl.} -proc glUnmapObjectBufferATI*(buffer: GLuint){.stdcall, importc, ogl.} - # GL_ATI_pn_triangles -proc glPNTrianglesiATI*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glPNTrianglesfATI*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} - # GL_ATI_separate_stencil -proc glStencilOpSeparateATI*(face: GLenum, sfail: GLenum, dpfail: GLenum, - dppass: GLenum){.stdcall, importc, ogl.} -proc glStencilFuncSeparateATI*(frontfunc: GLenum, backfunc: GLenum, theRef: GLint, - mask: GLuint){.stdcall, importc, ogl.} - # GL_ATI_vertex_array_object -proc glNewObjectBufferATI*(size: GLsizei, pointer: PGLvoid, usage: GLenum): GLuint{. - stdcall, importc, ogl.} -proc glIsObjectBufferATI*(buffer: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glUpdateObjectBufferATI*(buffer: GLuint, offset: GLuint, size: GLsizei, - pointer: PGLvoid, preserve: GLenum){.stdcall, importc, ogl.} -proc glGetObjectBufferfvATI*(buffer: GLuint, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetObjectBufferivATI*(buffer: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glFreeObjectBufferATI*(buffer: GLuint){.stdcall, importc, ogl.} -proc glArrayObjectATI*(arr: GLenum, size: GLint, typ: GLenum, stride: GLsizei, - buffer: GLuint, offset: GLuint){.stdcall, importc, ogl.} -proc glGetArrayObjectfvATI*(arr: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetArrayObjectivATI*(arr: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glVariantArrayObjectATI*(id: GLuint, typ: GLenum, stride: GLsizei, - buffer: GLuint, offset: GLuint){.stdcall, importc, ogl.} -proc glGetVariantArrayObjectfvATI*(id: GLuint, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetVariantArrayObjectivATI*(id: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} - # GL_ATI_vertex_attrib_array_object -proc glVertexAttribArrayObjectATI*(index: GLuint, size: GLint, typ: GLenum, - normalized: GLboolean, stride: GLsizei, - buffer: GLuint, offset: GLuint){.stdcall, importc, ogl.} -proc glGetVertexAttribArrayObjectfvATI*(index: GLuint, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetVertexAttribArrayObjectivATI*(index: GLuint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} - # GL_ATI_vertex_streams -proc glVertexStream1sATI*(stream: GLenum, x: GLshort){.stdcall, importc, ogl.} -proc glVertexStream1svATI*(stream: GLenum, coords: PGLshort){.stdcall, importc, ogl.} -proc glVertexStream1iATI*(stream: GLenum, x: GLint){.stdcall, importc, ogl.} -proc glVertexStream1ivATI*(stream: GLenum, coords: PGLint){.stdcall, importc, ogl.} -proc glVertexStream1fATI*(stream: GLenum, x: GLfloat){.stdcall, importc, ogl.} -proc glVertexStream1fvATI*(stream: GLenum, coords: PGLfloat){.stdcall, importc, ogl.} -proc glVertexStream1dATI*(stream: GLenum, x: GLdouble){.stdcall, importc, ogl.} -proc glVertexStream1dvATI*(stream: GLenum, coords: PGLdouble){.stdcall, importc, ogl.} -proc glVertexStream2sATI*(stream: GLenum, x: GLshort, y: GLshort){.stdcall, importc, ogl.} -proc glVertexStream2svATI*(stream: GLenum, coords: PGLshort){.stdcall, importc, ogl.} -proc glVertexStream2iATI*(stream: GLenum, x: GLint, y: GLint){.stdcall, importc, ogl.} -proc glVertexStream2ivATI*(stream: GLenum, coords: PGLint){.stdcall, importc, ogl.} -proc glVertexStream2fATI*(stream: GLenum, x: GLfloat, y: GLfloat){.stdcall, importc, ogl.} -proc glVertexStream2fvATI*(stream: GLenum, coords: PGLfloat){.stdcall, importc, ogl.} -proc glVertexStream2dATI*(stream: GLenum, x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glVertexStream2dvATI*(stream: GLenum, coords: PGLdouble){.stdcall, importc, ogl.} -proc glVertexStream3sATI*(stream: GLenum, x: GLshort, y: GLshort, z: GLshort){. - stdcall, importc, ogl.} -proc glVertexStream3svATI*(stream: GLenum, coords: PGLshort){.stdcall, importc, ogl.} -proc glVertexStream3iATI*(stream: GLenum, x: GLint, y: GLint, z: GLint){.stdcall, importc, ogl.} -proc glVertexStream3ivATI*(stream: GLenum, coords: PGLint){.stdcall, importc, ogl.} -proc glVertexStream3fATI*(stream: GLenum, x: GLfloat, y: GLfloat, z: GLfloat){. - stdcall, importc, ogl.} -proc glVertexStream3fvATI*(stream: GLenum, coords: PGLfloat){.stdcall, importc, ogl.} -proc glVertexStream3dATI*(stream: GLenum, x: GLdouble, y: GLdouble, z: GLdouble){. - stdcall, importc, ogl.} -proc glVertexStream3dvATI*(stream: GLenum, coords: PGLdouble){.stdcall, importc, ogl.} -proc glVertexStream4sATI*(stream: GLenum, x: GLshort, y: GLshort, z: GLshort, - w: GLshort){.stdcall, importc, ogl.} -proc glVertexStream4svATI*(stream: GLenum, coords: PGLshort){.stdcall, importc, ogl.} -proc glVertexStream4iATI*(stream: GLenum, x: GLint, y: GLint, z: GLint, w: GLint){. - stdcall, importc, ogl.} -proc glVertexStream4ivATI*(stream: GLenum, coords: PGLint){.stdcall, importc, ogl.} -proc glVertexStream4fATI*(stream: GLenum, x: GLfloat, y: GLfloat, z: GLfloat, - w: GLfloat){.stdcall, importc, ogl.} -proc glVertexStream4fvATI*(stream: GLenum, coords: PGLfloat){.stdcall, importc, ogl.} -proc glVertexStream4dATI*(stream: GLenum, x: GLdouble, y: GLdouble, z: GLdouble, - w: GLdouble){.stdcall, importc, ogl.} -proc glVertexStream4dvATI*(stream: GLenum, coords: PGLdouble){.stdcall, importc, ogl.} -proc glNormalStream3bATI*(stream: GLenum, nx: GLbyte, ny: GLbyte, nz: GLbyte){. - stdcall, importc, ogl.} -proc glNormalStream3bvATI*(stream: GLenum, coords: PGLbyte){.stdcall, importc, ogl.} -proc glNormalStream3sATI*(stream: GLenum, nx: GLshort, ny: GLshort, nz: GLshort){. - stdcall, importc, ogl.} -proc glNormalStream3svATI*(stream: GLenum, coords: PGLshort){.stdcall, importc, ogl.} -proc glNormalStream3iATI*(stream: GLenum, nx: GLint, ny: GLint, nz: GLint){. - stdcall, importc, ogl.} -proc glNormalStream3ivATI*(stream: GLenum, coords: PGLint){.stdcall, importc, ogl.} -proc glNormalStream3fATI*(stream: GLenum, nx: GLfloat, ny: GLfloat, nz: GLfloat){. - stdcall, importc, ogl.} -proc glNormalStream3fvATI*(stream: GLenum, coords: PGLfloat){.stdcall, importc, ogl.} -proc glNormalStream3dATI*(stream: GLenum, nx: GLdouble, ny: GLdouble, - nz: GLdouble){.stdcall, importc, ogl.} -proc glNormalStream3dvATI*(stream: GLenum, coords: PGLdouble){.stdcall, importc, ogl.} -proc glClientActiveVertexStreamATI*(stream: GLenum){.stdcall, importc, ogl.} -proc glVertexBlendEnviATI*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glVertexBlendEnvfATI*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} - # GL_AMD_performance_monitor -proc glGetPerfMonitorGroupsAMD*(numGroups: PGLint, groupsSize: GLsizei, - groups: PGLuint){.stdcall, importc, ogl.} -proc glGetPerfMonitorCountersAMD*(group: GLuint, numCounters: PGLint, - maxActiveCouters: PGLint, - counterSize: GLsizei, counters: PGLuint){. - stdcall, importc, ogl.} -proc glGetPerfMonitorGroupStringAMD*(group: GLuint, bufSize: GLsizei, - len: PGLsizei, groupString: PGLchar){. - stdcall, importc, ogl.} -proc glGetPerfMonitorCounterStringAMD*(group: GLuint, counter: GLuint, - bufSize: GLsizei, len: PGLsizei, - counterString: PGLchar){.stdcall, importc, ogl.} -proc glGetPerfMonitorCounterInfoAMD*(group: GLuint, counter: GLuint, - pname: GLenum, data: PGLvoid){.stdcall, importc, ogl.} -proc glGenPerfMonitorsAMD*(n: GLsizei, monitors: PGLuint){.stdcall, importc, ogl.} -proc glDeletePerfMonitorsAMD*(n: GLsizei, monitors: PGLuint){.stdcall, importc, ogl.} -proc glSelectPerfMonitorCountersAMD*(monitor: GLuint, enable: GLboolean, - group: GLuint, numCounters: GLint, - counterList: PGLuint){.stdcall, importc, ogl.} -proc glBeginPerfMonitorAMD*(monitor: GLuint){.stdcall, importc, ogl.} -proc glEndPerfMonitorAMD*(monitor: GLuint){.stdcall, importc, ogl.} -proc glGetPerfMonitorCounterDataAMD*(monitor: GLuint, pname: GLenum, - dataSize: GLsizei, data: PGLuint, - bytesWritten: PGLint){.stdcall, importc, ogl.} - # GL_AMD_vertex_shader_tesselator -proc glTessellationFactorAMD*(factor: GLfloat){.stdcall, importc, ogl.} -proc glTessellationModeAMD*(mode: GLenum){.stdcall, importc, ogl.} - # GL_AMD_draw_buffers_blend -proc glBlendFuncIndexedAMD*(buf: GLuint, src: GLenum, dst: GLenum){.stdcall, importc, ogl.} -proc glBlendFuncSeparateIndexedAMD*(buf: GLuint, srcRGB: GLenum, dstRGB: GLenum, - srcAlpha: GLenum, dstAlpha: GLenum){.stdcall, importc, ogl.} -proc glBlendEquationIndexedAMD*(buf: GLuint, mode: GLenum){.stdcall, importc, ogl.} -proc glBlendEquationSeparateIndexedAMD*(buf: GLuint, modeRGB: GLenum, - modeAlpha: GLenum){.stdcall, importc, ogl.} - # GL_AMD_name_gen_delete -proc glGenNamesAMD*(identifier: GLenum, num: GLuint, names: PGLuint){.stdcall, importc, ogl.} -proc glDeleteNamesAMD*(identifier: GLenum, num: GLuint, names: PGLuint){.stdcall, importc, ogl.} -proc glIsNameAMD*(identifier: GLenum, name: GLuint): GLboolean{.stdcall, importc, ogl.} - # GL_AMD_debug_output -proc glDebugMessageEnableAMD*(category: GLenum, severity: GLenum, - count: GLsizei, ids: PGLuint, enabled: GLboolean){. - stdcall, importc, ogl.} -proc glDebugMessageInsertAMD*(category: GLenum, severity: GLenum, id: GLuint, - len: GLsizei, buf: PGLchar){.stdcall, importc, ogl.} -proc glDebugMessageCallbackAMD*(callback: TGLDebugProcAMD, userParam: PGLvoid){. - stdcall, importc, ogl.} -proc glGetDebugMessageLogAMD*(count: GLuint, bufsize: GLsizei, - categories: PGLenum, severities: PGLuint, - ids: PGLuint, lengths: PGLsizei, message: PGLchar): GLuint{. - stdcall, importc, ogl.} - # GL_EXT_blend_color -proc glBlendColorEXT*(red: GLclampf, green: GLclampf, blue: GLclampf, - alpha: GLclampf){.stdcall, importc, ogl.} - # GL_EXT_blend_func_separate -proc glBlendFuncSeparateEXT*(sfactorRGB: GLenum, dfactorRGB: GLenum, - sfactorAlpha: GLenum, dfactorAlpha: GLenum){. - stdcall, importc, ogl.} - # GL_EXT_blend_minmax -proc glBlendEquationEXT*(mode: GLenum){.stdcall, importc, ogl.} - # GL_EXT_color_subtable -proc glColorSubTableEXT*(target: GLenum, start: GLsizei, count: GLsizei, - format: GLenum, typ: GLenum, data: PGLvoid){.stdcall, importc, ogl.} -proc glCopyColorSubTableEXT*(target: GLenum, start: GLsizei, x: GLint, y: GLint, - width: GLsizei){.stdcall, importc, ogl.} - # GL_EXT_compiled_vertex_array -proc glLockArraysEXT*(first: GLint, count: GLsizei){.stdcall, importc, ogl.} -proc glUnlockArraysEXT*(){.stdcall, importc, ogl.} - # GL_EXT_convolution -proc glConvolutionFilter1DEXT*(target: GLenum, internalformat: GLenum, - width: GLsizei, format: GLenum, typ: GLenum, - image: PGLvoid){.stdcall, importc, ogl.} -proc glConvolutionFilter2DEXT*(target: GLenum, internalformat: GLenum, - width: GLsizei, height: GLsizei, format: GLenum, - typ: GLenum, image: PGLvoid){.stdcall, importc, ogl.} -proc glConvolutionParameterfEXT*(target: GLenum, pname: GLenum, params: GLfloat){. - stdcall, importc, ogl.} -proc glConvolutionParameterfvEXT*(target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glConvolutionParameteriEXT*(target: GLenum, pname: GLenum, params: GLint){. - stdcall, importc, ogl.} -proc glConvolutionParameterivEXT*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glCopyConvolutionFilter1DEXT*(target: GLenum, internalformat: GLenum, - x: GLint, y: GLint, width: GLsizei){.stdcall, importc, ogl.} -proc glCopyConvolutionFilter2DEXT*(target: GLenum, internalformat: GLenum, - x: GLint, y: GLint, width: GLsizei, - height: GLsizei){.stdcall, importc, ogl.} -proc glGetConvolutionFilterEXT*(target: GLenum, format: GLenum, typ: GLenum, - image: PGLvoid){.stdcall, importc, ogl.} -proc glGetConvolutionParameterfvEXT*(target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetConvolutionParameterivEXT*(target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetSeparableFilterEXT*(target: GLenum, format: GLenum, typ: GLenum, - row: PGLvoid, column: PGLvoid, span: PGLvoid){. - stdcall, importc, ogl.} -proc glSeparableFilter2DEXT*(target: GLenum, internalformat: GLenum, - width: GLsizei, height: GLsizei, format: GLenum, - typ: GLenum, row: PGLvoid, column: PGLvoid){. - stdcall, importc, ogl.} - # GL_EXT_coordinate_frame -proc glTangent3bEXT*(tx: GLbyte, ty: GLbyte, tz: GLbyte){.stdcall, importc, ogl.} -proc glTangent3bvEXT*(v: PGLbyte){.stdcall, importc, ogl.} -proc glTangent3dEXT*(tx: GLdouble, ty: GLdouble, tz: GLdouble){.stdcall, importc, ogl.} -proc glTangent3dvEXT*(v: PGLdouble){.stdcall, importc, ogl.} -proc glTangent3fEXT*(tx: GLfloat, ty: GLfloat, tz: GLfloat){.stdcall, importc, ogl.} -proc glTangent3fvEXT*(v: PGLfloat){.stdcall, importc, ogl.} -proc glTangent3iEXT*(tx: GLint, ty: GLint, tz: GLint){.stdcall, importc, ogl.} -proc glTangent3ivEXT*(v: PGLint){.stdcall, importc, ogl.} -proc glTangent3sEXT*(tx: GLshort, ty: GLshort, tz: GLshort){.stdcall, importc, ogl.} -proc glTangent3svEXT*(v: PGLshort){.stdcall, importc, ogl.} -proc glBinormal3bEXT*(bx: GLbyte, by: GLbyte, bz: GLbyte){.stdcall, importc, ogl.} -proc glBinormal3bvEXT*(v: PGLbyte){.stdcall, importc, ogl.} -proc glBinormal3dEXT*(bx: GLdouble, by: GLdouble, bz: GLdouble){.stdcall, importc, ogl.} -proc glBinormal3dvEXT*(v: PGLdouble){.stdcall, importc, ogl.} -proc glBinormal3fEXT*(bx: GLfloat, by: GLfloat, bz: GLfloat){.stdcall, importc, ogl.} -proc glBinormal3fvEXT*(v: PGLfloat){.stdcall, importc, ogl.} -proc glBinormal3iEXT*(bx: GLint, by: GLint, bz: GLint){.stdcall, importc, ogl.} -proc glBinormal3ivEXT*(v: PGLint){.stdcall, importc, ogl.} -proc glBinormal3sEXT*(bx: GLshort, by: GLshort, bz: GLshort){.stdcall, importc, ogl.} -proc glBinormal3svEXT*(v: PGLshort){.stdcall, importc, ogl.} -proc glTangentPointerEXT*(typ: GLenum, stride: GLsizei, pointer: PGLvoid){. - stdcall, importc, ogl.} -proc glBinormalPointerEXT*(typ: GLenum, stride: GLsizei, pointer: PGLvoid){. - stdcall, importc, ogl.} - # GL_EXT_copy_texture -proc glCopyTexImage1DEXT*(target: GLenum, level: GLint, internalformat: GLenum, - x: GLint, y: GLint, width: GLsizei, border: GLint){. - stdcall, importc, ogl.} -proc glCopyTexImage2DEXT*(target: GLenum, level: GLint, internalformat: GLenum, - x: GLint, y: GLint, width: GLsizei, height: GLsizei, - border: GLint){.stdcall, importc, ogl.} -proc glCopyTexSubImage1DEXT*(target: GLenum, level: GLint, xoffset: GLint, - x: GLint, y: GLint, width: GLsizei){.stdcall, importc, ogl.} -proc glCopyTexSubImage2DEXT*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, x: GLint, y: GLint, width: GLsizei, - height: GLsizei){.stdcall, importc, ogl.} -proc glCopyTexSubImage3DEXT*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, - width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} - # GL_EXT_cull_vertex -proc glCullParameterdvEXT*(pname: GLenum, params: PGLdouble){.stdcall, importc, ogl.} -proc glCullParameterfvEXT*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} - # GL_EXT_draw_range_elements -proc glDrawRangeElementsEXT*(mode: GLenum, start: GLuint, ending: GLuint, - count: GLsizei, typ: GLenum, indices: PGLvoid){. - stdcall, importc, ogl.} - # GL_EXT_fog_coord -proc glFogCoordfEXT*(coord: GLfloat){.stdcall, importc, ogl.} -proc glFogCoordfvEXT*(coord: PGLfloat){.stdcall, importc, ogl.} -proc glFogCoorddEXT*(coord: GLdouble){.stdcall, importc, ogl.} -proc glFogCoorddvEXT*(coord: PGLdouble){.stdcall, importc, ogl.} -proc glFogCoordPointerEXT*(typ: GLenum, stride: GLsizei, pointer: PGLvoid){. - stdcall, importc, ogl.} - # GL_EXT_framebuffer_object -proc glIsRenderbufferEXT*(renderbuffer: GLuint): bool{.stdcall, importc, ogl.} -proc glBindRenderbufferEXT*(target: GLenum, renderbuffer: GLuint){.stdcall, importc, ogl.} -proc glDeleteRenderbuffersEXT*(n: GLsizei, renderbuffers: PGLuint){.stdcall, importc, ogl.} -proc glGenRenderbuffersEXT*(n: GLsizei, renderbuffers: PGLuint){.stdcall, importc, ogl.} -proc glRenderbufferStorageEXT*(target: GLenum, internalformat: GLenum, - width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} -proc glGetRenderbufferParameterivEXT*(target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glIsFramebufferEXT*(framebuffer: GLuint): bool{.stdcall, importc, ogl.} -proc glBindFramebufferEXT*(target: GLenum, framebuffer: GLuint){.stdcall, importc, ogl.} -proc glDeleteFramebuffersEXT*(n: GLsizei, framebuffers: PGLuint){.stdcall, importc, ogl.} -proc glGenFramebuffersEXT*(n: GLsizei, framebuffers: PGLuint){.stdcall, importc, ogl.} -proc glCheckFramebufferStatusEXT*(target: GLenum): GLenum{.stdcall, importc, ogl.} -proc glFramebufferTexture1DEXT*(target: GLenum, attachment: GLenum, - textarget: GLenum, texture: GLuint, level: GLint){. - stdcall, importc, ogl.} -proc glFramebufferTexture2DEXT*(target: GLenum, attachment: GLenum, - textarget: GLenum, texture: GLuint, level: GLint){. - stdcall, importc, ogl.} -proc glFramebufferTexture3DEXT*(target: GLenum, attachment: GLenum, - textarget: GLenum, texture: GLuint, - level: GLint, zoffset: GLint){.stdcall, importc, ogl.} -proc glFramebufferRenderbufferEXT*(target: GLenum, attachment: GLenum, - renderbuffertarget: GLenum, - renderbuffer: GLuint){.stdcall, importc, ogl.} -proc glGetFramebufferAttachmentParameterivEXT*(target: GLenum, - attachment: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGenerateMipmapEXT*(target: GLenum){.stdcall, importc, ogl.} - # GL_EXT_histogram -proc glGetHistogramEXT*(target: GLenum, reset: GLboolean, format: GLenum, - typ: GLenum, values: PGLvoid){.stdcall, importc, ogl.} -proc glGetHistogramParameterfvEXT*(target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetHistogramParameterivEXT*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetMinmaxEXT*(target: GLenum, reset: GLboolean, format: GLenum, - typ: GLenum, values: PGLvoid){.stdcall, importc, ogl.} -proc glGetMinmaxParameterfvEXT*(target: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetMinmaxParameterivEXT*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glHistogramEXT*(target: GLenum, width: GLsizei, internalformat: GLenum, - sink: GLboolean){.stdcall, importc, ogl.} -proc glMinmaxEXT*(target: GLenum, internalformat: GLenum, sink: GLboolean){. - stdcall, importc, ogl.} -proc glResetHistogramEXT*(target: GLenum){.stdcall, importc, ogl.} -proc glResetMinmaxEXT*(target: GLenum){.stdcall, importc, ogl.} - # GL_EXT_index_func -proc glIndexFuncEXT*(func: GLenum, theRef: GLclampf){.stdcall, importc, ogl.} - # GL_EXT_index_material -proc glIndexMaterialEXT*(face: GLenum, mode: GLenum){.stdcall, importc, ogl.} - # GL_EXT_light_texture -proc glApplyTextureEXT*(mode: GLenum){.stdcall, importc, ogl.} -proc glTextureLightEXT*(pname: GLenum){.stdcall, importc, ogl.} -proc glTextureMaterialEXT*(face: GLenum, mode: GLenum){.stdcall, importc, ogl.} - # GL_EXT_multi_draw_arrays -proc glMultiDrawArraysEXT*(mode: GLenum, first: PGLint, count: PGLsizei, - primcount: GLsizei){.stdcall, importc, ogl.} -proc glMultiDrawElementsEXT*(mode: GLenum, count: PGLsizei, typ: GLenum, - indices: PGLvoid, primcount: GLsizei){.stdcall, importc, ogl.} - # GL_EXT_multisample -proc glSampleMaskEXT*(value: GLclampf, invert: GLboolean){.stdcall, importc, ogl.} -proc glSamplePatternEXT*(pattern: GLenum){.stdcall, importc, ogl.} - # GL_EXT_paletted_texture -proc glColorTableEXT*(target: GLenum, internalFormat: GLenum, width: GLsizei, - format: GLenum, typ: GLenum, table: PGLvoid){.stdcall, importc, ogl.} -proc glGetColorTableEXT*(target: GLenum, format: GLenum, typ: GLenum, - data: PGLvoid){.stdcall, importc, ogl.} -proc glGetColorTableParameterivEXT*(target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetColorTableParameterfvEXT*(target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} - # GL_EXT_pixel_transform -proc glPixelTransformParameteriEXT*(target: GLenum, pname: GLenum, param: GLint){. - stdcall, importc, ogl.} -proc glPixelTransformParameterfEXT*(target: GLenum, pname: GLenum, - param: GLfloat){.stdcall, importc, ogl.} -proc glPixelTransformParameterivEXT*(target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glPixelTransformParameterfvEXT*(target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} - # GL_EXT_point_parameters -proc glPointParameterfEXT*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glPointParameterfvEXT*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} - # GL_EXT_polygon_offset -proc glPolygonOffsetEXT*(factor: GLfloat, bias: GLfloat){.stdcall, importc, ogl.} - # GL_EXT_secondary_color -proc glSecondaryColor3bEXT*(red: GLbyte, green: GLbyte, blue: GLbyte){.stdcall, importc, ogl.} -proc glSecondaryColor3bvEXT*(v: PGLbyte){.stdcall, importc, ogl.} -proc glSecondaryColor3dEXT*(red: GLdouble, green: GLdouble, blue: GLdouble){. - stdcall, importc, ogl.} -proc glSecondaryColor3dvEXT*(v: PGLdouble){.stdcall, importc, ogl.} -proc glSecondaryColor3fEXT*(red: GLfloat, green: GLfloat, blue: GLfloat){. - stdcall, importc, ogl.} -proc glSecondaryColor3fvEXT*(v: PGLfloat){.stdcall, importc, ogl.} -proc glSecondaryColor3iEXT*(red: GLint, green: GLint, blue: GLint){.stdcall, importc, ogl.} -proc glSecondaryColor3ivEXT*(v: PGLint){.stdcall, importc, ogl.} -proc glSecondaryColor3sEXT*(red: GLshort, green: GLshort, blue: GLshort){. - stdcall, importc, ogl.} -proc glSecondaryColor3svEXT*(v: PGLshort){.stdcall, importc, ogl.} -proc glSecondaryColor3ubEXT*(red: GLubyte, green: GLubyte, blue: GLubyte){. - stdcall, importc, ogl.} -proc glSecondaryColor3ubvEXT*(v: PGLubyte){.stdcall, importc, ogl.} -proc glSecondaryColor3uiEXT*(red: GLuint, green: GLuint, blue: GLuint){.stdcall, importc, ogl.} -proc glSecondaryColor3uivEXT*(v: PGLuint){.stdcall, importc, ogl.} -proc glSecondaryColor3usEXT*(red: GLushort, green: GLushort, blue: GLushort){. - stdcall, importc, ogl.} -proc glSecondaryColor3usvEXT*(v: PGLushort){.stdcall, importc, ogl.} -proc glSecondaryColorPointerEXT*(size: GLint, typ: GLenum, stride: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} - # GL_EXT_stencil_two_side -proc glActiveStencilFaceEXT*(face: GLenum){.stdcall, importc, ogl.} - # GL_EXT_subtexture -proc glTexSubImage1DEXT*(target: GLenum, level: GLint, xoffset: GLint, - width: GLsizei, format: GLenum, typ: GLenum, - pixels: PGLvoid){.stdcall, importc, ogl.} -proc glTexSubImage2DEXT*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, width: GLsizei, height: GLsizei, - format: GLenum, typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} - # GL_EXT_texture3D -proc glTexImage3DEXT*(target: GLenum, level: GLint, internalformat: GLenum, - width: GLsizei, height: GLsizei, depth: GLsizei, - border: GLint, format: GLenum, typ: GLenum, - pixels: PGLvoid){.stdcall, importc, ogl.} -proc glTexSubImage3DEXT*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, zoffset: GLint, width: GLsizei, - height: GLsizei, depth: GLsizei, format: GLenum, - typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} - # GL_EXT_texture_object -proc glAreTexturesResidentEXT*(n: GLsizei, textures: PGLuint, - residences: PGLboolean): GLboolean{.stdcall, importc, ogl.} -proc glBindTextureEXT*(target: GLenum, texture: GLuint){.stdcall, importc, ogl.} -proc glDeleteTexturesEXT*(n: GLsizei, textures: PGLuint){.stdcall, importc, ogl.} -proc glGenTexturesEXT*(n: GLsizei, textures: PGLuint){.stdcall, importc, ogl.} -proc glIsTextureEXT*(texture: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glPrioritizeTexturesEXT*(n: GLsizei, textures: PGLuint, - priorities: PGLclampf){.stdcall, importc, ogl.} - # GL_EXT_texture_perturb_normal -proc glTextureNormalEXT*(mode: GLenum){.stdcall, importc, ogl.} - # GL_EXT_vertex_array -proc glArrayElementEXT*(i: GLint){.stdcall, importc, ogl.} -proc glColorPointerEXT*(size: GLint, typ: GLenum, stride: GLsizei, - count: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glDrawArraysEXT*(mode: GLenum, first: GLint, count: GLsizei){.stdcall, importc, ogl.} -proc glEdgeFlagPointerEXT*(stride: GLsizei, count: GLsizei, pointer: PGLboolean){. - stdcall, importc, ogl.} -proc glGetPointervEXT*(pname: GLenum, params: PGLvoid){.stdcall, importc, ogl.} -proc glIndexPointerEXT*(typ: GLenum, stride: GLsizei, count: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} -proc glNormalPointerEXT*(typ: GLenum, stride: GLsizei, count: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} -proc glTexCoordPointerEXT*(size: GLint, typ: GLenum, stride: GLsizei, - count: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glVertexPointerEXT*(size: GLint, typ: GLenum, stride: GLsizei, - count: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} - # GL_EXT_vertex_shader -proc glBeginVertexShaderEXT*(){.stdcall, importc, ogl.} -proc glEndVertexShaderEXT*(){.stdcall, importc, ogl.} -proc glBindVertexShaderEXT*(id: GLuint){.stdcall, importc, ogl.} -proc glGenVertexShadersEXT*(range: GLuint): GLuint{.stdcall, importc, ogl.} -proc glDeleteVertexShaderEXT*(id: GLuint){.stdcall, importc, ogl.} -proc glShaderOp1EXT*(op: GLenum, res: GLuint, arg1: GLuint){.stdcall, importc, ogl.} -proc glShaderOp2EXT*(op: GLenum, res: GLuint, arg1: GLuint, arg2: GLuint){. - stdcall, importc, ogl.} -proc glShaderOp3EXT*(op: GLenum, res: GLuint, arg1: GLuint, arg2: GLuint, - arg3: GLuint){.stdcall, importc, ogl.} -proc glSwizzleEXT*(res: GLuint, ain: GLuint, outX: GLenum, outY: GLenum, - outZ: GLenum, outW: GLenum){.stdcall, importc, ogl.} -proc glWriteMaskEXT*(res: GLuint, ain: GLuint, outX: GLenum, outY: GLenum, - outZ: GLenum, outW: GLenum){.stdcall, importc, ogl.} -proc glInsertComponentEXT*(res: GLuint, src: GLuint, num: GLuint){.stdcall, importc, ogl.} -proc glExtractComponentEXT*(res: GLuint, src: GLuint, num: GLuint){.stdcall, importc, ogl.} -proc glGenSymbolsEXT*(datatype: GLenum, storagetype: GLenum, range: GLenum, - components: GLuint): GLuint{.stdcall, importc, ogl.} -proc glSetInvariantEXT*(id: GLuint, typ: GLenum, theAddr: PGLvoid){.stdcall, importc, ogl.} -proc glSetLocalConstantEXT*(id: GLuint, typ: GLenum, theAddr: PGLvoid){.stdcall, importc, ogl.} -proc glVariantbvEXT*(id: GLuint, theAddr: PGLbyte){.stdcall, importc, ogl.} -proc glVariantsvEXT*(id: GLuint, theAddr: PGLshort){.stdcall, importc, ogl.} -proc glVariantivEXT*(id: GLuint, theAddr: PGLint){.stdcall, importc, ogl.} -proc glVariantfvEXT*(id: GLuint, theAddr: PGLfloat){.stdcall, importc, ogl.} -proc glVariantdvEXT*(id: GLuint, theAddr: PGLdouble){.stdcall, importc, ogl.} -proc glVariantubvEXT*(id: GLuint, theAddr: PGLubyte){.stdcall, importc, ogl.} -proc glVariantusvEXT*(id: GLuint, theAddr: PGLushort){.stdcall, importc, ogl.} -proc glVariantuivEXT*(id: GLuint, theAddr: PGLuint){.stdcall, importc, ogl.} -proc glVariantPointerEXT*(id: GLuint, typ: GLenum, stride: GLuint, theAddr: PGLvoid){. - stdcall, importc, ogl.} -proc glEnableVariantClientStateEXT*(id: GLuint){.stdcall, importc, ogl.} -proc glDisableVariantClientStateEXT*(id: GLuint){.stdcall, importc, ogl.} -proc glBindLightParameterEXT*(light: GLenum, value: GLenum): GLuint{.stdcall, importc, ogl.} -proc glBindMaterialParameterEXT*(face: GLenum, value: GLenum): GLuint{.stdcall, importc, ogl.} -proc glBindTexGenParameterEXT*(theUnit: GLenum, coord: GLenum, value: GLenum): GLuint{. - stdcall, importc, ogl.} -proc glBindTextureUnitParameterEXT*(theUnit: GLenum, value: GLenum): GLuint{. - stdcall, importc, ogl.} -proc glBindParameterEXT*(value: GLenum): GLuint{.stdcall, importc, ogl.} -proc glIsVariantEnabledEXT*(id: GLuint, cap: GLenum): GLboolean{.stdcall, importc, ogl.} -proc glGetVariantBooleanvEXT*(id: GLuint, value: GLenum, data: PGLboolean){. - stdcall, importc, ogl.} -proc glGetVariantIntegervEXT*(id: GLuint, value: GLenum, data: PGLint){.stdcall, importc, ogl.} -proc glGetVariantFloatvEXT*(id: GLuint, value: GLenum, data: PGLfloat){.stdcall, importc, ogl.} -proc glGetVariantPointervEXT*(id: GLuint, value: GLenum, data: PGLvoid){.stdcall, importc, ogl.} -proc glGetInvariantBooleanvEXT*(id: GLuint, value: GLenum, data: PGLboolean){. - stdcall, importc, ogl.} -proc glGetInvariantIntegervEXT*(id: GLuint, value: GLenum, data: PGLint){. - stdcall, importc, ogl.} -proc glGetInvariantFloatvEXT*(id: GLuint, value: GLenum, data: PGLfloat){. - stdcall, importc, ogl.} -proc glGetLocalConstantBooleanvEXT*(id: GLuint, value: GLenum, data: PGLboolean){. - stdcall, importc, ogl.} -proc glGetLocalConstantIntegervEXT*(id: GLuint, value: GLenum, data: PGLint){. - stdcall, importc, ogl.} -proc glGetLocalConstantFloatvEXT*(id: GLuint, value: GLenum, data: PGLfloat){. - stdcall, importc, ogl.} - # GL_EXT_vertex_weighting -proc glVertexWeightfEXT*(weight: GLfloat){.stdcall, importc, ogl.} -proc glVertexWeightfvEXT*(weight: PGLfloat){.stdcall, importc, ogl.} -proc glVertexWeightPointerEXT*(size: GLsizei, typ: GLenum, stride: GLsizei, - pointer: PGLvoid){.stdcall, importc, ogl.} - # GL_EXT_stencil_clear_tag -proc glStencilClearTagEXT*(stencilTagBits: GLsizei, stencilClearTag: GLuint){. - stdcall, importc, ogl.} - # GL_EXT_framebuffer_blit -proc glBlitFramebufferEXT*(srcX0: GLint, srcY0: GLint, srcX1: GLint, - srcY1: GLint, dstX0: GLint, dstY0: GLint, - dstX1: GLint, dstY1: GLint, mask: GLbitfield, - filter: GLenum){.stdcall, importc, ogl.} - # GL_EXT_framebuffer_multisample -proc glRenderbufferStorageMultisampleEXT*(target: GLenum, samples: GLsizei, - internalformat: GLenum, width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} - # GL_EXT_timer_query -proc glGetQueryObjecti64vEXT*(id: GLuint, pname: GLenum, params: PGLint64EXT){. - stdcall, importc, ogl.} -proc glGetQueryObjectui64vEXT*(id: GLuint, pname: GLenum, params: PGLuint64EXT){. - stdcall, importc, ogl.} - # GL_EXT_gpu_program_parameters -proc glProgramEnvParameters4fvEXT*(target: GLenum, index: GLuint, - count: GLsizei, params: PGLfloat){.stdcall, importc, ogl.} -proc glProgramLocalParameters4fvEXT*(target: GLenum, index: GLuint, - count: GLsizei, params: PGLfloat){.stdcall, importc, ogl.} - # GL_EXT_bindable_uniform -proc glUniformBufferEXT*(prog: GLuint, location: GLint, buffer: GLuint){.stdcall, importc, ogl.} -proc glGetUniformBufferSizeEXT*(prog: GLuint, location: GLint): GLint{.stdcall, importc, ogl.} -proc glGetUniformOffsetEXT*(prog: GLuint, location: GLint): GLintptr{.stdcall, importc, ogl.} - # GL_EXT_draw_buffers2 -proc glColorMaskIndexedEXT*(buf: GLuint, r: GLboolean, g: GLboolean, - b: GLboolean, a: GLboolean){.stdcall, importc, ogl.} -proc glGetBooleanIndexedvEXT*(value: GLenum, index: GLuint, data: PGLboolean){. - stdcall, importc, ogl.} -proc glGetIntegerIndexedvEXT*(value: GLenum, index: GLuint, data: PGLint){. - stdcall, importc, ogl.} -proc glEnableIndexedEXT*(target: GLenum, index: GLuint){.stdcall, importc, ogl.} -proc glDisableIndexedEXT*(target: GLenum, index: GLuint){.stdcall, importc, ogl.} -proc glIsEnabledIndexedEXT*(target: GLenum, index: GLuint): GLboolean{.stdcall, importc, ogl.} - # GL_EXT_draw_instanced -proc glDrawArraysInstancedEXT*(mode: GLenum, first: GLint, count: GLsizei, - primcount: GLsizei){.stdcall, importc, ogl.} -proc glDrawElementsInstancedEXT*(mode: GLenum, count: GLsizei, typ: GLenum, - indices: Pointer, primcount: GLsizei){.stdcall, importc, ogl.} - # GL_EXT_geometry_shader4 -proc glProgramParameteriEXT*(prog: GLuint, pname: GLenum, value: GLint){.stdcall, importc, ogl.} -proc glFramebufferTextureEXT*(target: GLenum, attachment: GLenum, - texture: GLuint, level: GLint){.stdcall, importc, ogl.} - #procedure glFramebufferTextureLayerEXT(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); stdcall, importc, ogl; -proc glFramebufferTextureFaceEXT*(target: GLenum, attachment: GLenum, - texture: GLuint, level: GLint, face: GLenum){. - stdcall, importc, ogl.} - # GL_EXT_gpu_shader4 -proc glVertexAttribI1iEXT*(index: GLuint, x: GLint){.stdcall, importc, ogl.} -proc glVertexAttribI2iEXT*(index: GLuint, x: GLint, y: GLint){.stdcall, importc, ogl.} -proc glVertexAttribI3iEXT*(index: GLuint, x: GLint, y: GLint, z: GLint){.stdcall, importc, ogl.} -proc glVertexAttribI4iEXT*(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint){. - stdcall, importc, ogl.} -proc glVertexAttribI1uiEXT*(index: GLuint, x: GLuint){.stdcall, importc, ogl.} -proc glVertexAttribI2uiEXT*(index: GLuint, x: GLuint, y: GLuint){.stdcall, importc, ogl.} -proc glVertexAttribI3uiEXT*(index: GLuint, x: GLuint, y: GLuint, z: GLuint){. - stdcall, importc, ogl.} -proc glVertexAttribI4uiEXT*(index: GLuint, x: GLuint, y: GLuint, z: GLuint, - w: GLuint){.stdcall, importc, ogl.} -proc glVertexAttribI1ivEXT*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttribI2ivEXT*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttribI3ivEXT*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttribI4ivEXT*(index: GLuint, v: PGLint){.stdcall, importc, ogl.} -proc glVertexAttribI1uivEXT*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribI2uivEXT*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribI3uivEXT*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribI4uivEXT*(index: GLuint, v: PGLuint){.stdcall, importc, ogl.} -proc glVertexAttribI4bvEXT*(index: GLuint, v: PGLbyte){.stdcall, importc, ogl.} -proc glVertexAttribI4svEXT*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttribI4ubvEXT*(index: GLuint, v: PGLubyte){.stdcall, importc, ogl.} -proc glVertexAttribI4usvEXT*(index: GLuint, v: PGLushort){.stdcall, importc, ogl.} -proc glVertexAttribIPointerEXT*(index: GLuint, size: GLint, typ: GLenum, - stride: GLsizei, pointer: Pointer){.stdcall, importc, ogl.} -proc glGetVertexAttribIivEXT*(index: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetVertexAttribIuivEXT*(index: GLuint, pname: GLenum, params: PGLuint){. - stdcall, importc, ogl.} -proc glUniform1uiEXT*(location: GLint, v0: GLuint){.stdcall, importc, ogl.} -proc glUniform2uiEXT*(location: GLint, v0: GLuint, v1: GLuint){.stdcall, importc, ogl.} -proc glUniform3uiEXT*(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint){. - stdcall, importc, ogl.} -proc glUniform4uiEXT*(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, - v3: GLuint){.stdcall, importc, ogl.} -proc glUniform1uivEXT*(location: GLint, count: GLsizei, value: PGLuint){.stdcall, importc, ogl.} -proc glUniform2uivEXT*(location: GLint, count: GLsizei, value: PGLuint){.stdcall, importc, ogl.} -proc glUniform3uivEXT*(location: GLint, count: GLsizei, value: PGLuint){.stdcall, importc, ogl.} -proc glUniform4uivEXT*(location: GLint, count: GLsizei, value: PGLuint){.stdcall, importc, ogl.} -proc glGetUniformuivEXT*(prog: GLuint, location: GLint, params: PGLuint){. - stdcall, importc, ogl.} -proc glBindFragDataLocationEXT*(prog: GLuint, colorNumber: GLuint, name: PGLchar){. - stdcall, importc, ogl.} -proc glGetFragDataLocationEXT*(prog: GLuint, name: PGLchar): GLint{.stdcall, importc, ogl.} - # GL_EXT_texture_array -proc glFramebufferTextureLayerEXT*(target: GLenum, attachment: GLenum, - texture: GLuint, level: GLint, layer: GLint){. - stdcall, importc, ogl.} - # GL_EXT_texture_buffer_object -proc glTexBufferEXT*(target: GLenum, internalformat: GLenum, buffer: GLuint){. - stdcall, importc, ogl.} - # GL_EXT_texture_integer -proc glClearColorIiEXT*(r: GLint, g: GLint, b: GLint, a: GLint){.stdcall, importc, ogl.} -proc glClearColorIuiEXT*(r: GLuint, g: GLuint, b: GLuint, a: GLuint){.stdcall, importc, ogl.} -proc glTexParameterIivEXT*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glTexParameterIuivEXT*(target: GLenum, pname: GLenum, params: PGLuint){. - stdcall, importc, ogl.} -proc glGetTexParameterIivEXT*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetTexParameterIiuvEXT*(target: GLenum, pname: GLenum, params: PGLuint){. - stdcall, importc, ogl.} - # GL_HP_image_transform -proc glImageTransformParameteriHP*(target: GLenum, pname: GLenum, param: GLint){. - stdcall, importc, ogl.} -proc glImageTransformParameterfHP*(target: GLenum, pname: GLenum, param: GLfloat){. - stdcall, importc, ogl.} -proc glImageTransformParameterivHP*(target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glImageTransformParameterfvHP*(target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetImageTransformParameterivHP*(target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetImageTransformParameterfvHP*(target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} - # GL_EXT_depth_bounds_test -proc glDepthBoundsEXT*(zmin: GLclampd, zmax: GLclampd){.stdcall, importc, ogl.} - # GL_EXT_blend_equation_separate -proc glBlendEquationSeparateEXT*(modeRGB: GLenum, modeAlpha: GLenum){.stdcall, importc, ogl.} - # GL_EXT_transform_feedback -proc glBeginTransformFeedbackEXT*(primitiveMode: GLenum){.stdcall, importc, ogl.} -proc glEndTransformFeedbackEXT*(){.stdcall, importc, ogl.} -proc glBindBufferRangeEXT*(target: GLenum, index: GLuint, buffer: GLuint, - offset: GLintptr, size: GLsizeiptr){.stdcall, importc, ogl.} -proc glBindBufferOffsetEXT*(target: GLenum, index: GLuint, buffer: GLuint, - offset: GLintptr){.stdcall, importc, ogl.} -proc glBindBufferBaseEXT*(target: GLenum, index: GLuint, buffer: GLuint){. - stdcall, importc, ogl.} -proc glTransformFeedbackVaryingsEXT*(prog: GLuint, count: GLsizei, - locations: PGLint, bufferMode: GLenum){. - stdcall, importc, ogl.} -proc glGetTransformFeedbackVaryingEXT*(prog: GLuint, index: GLuint, - location: PGLint){.stdcall, importc, ogl.} - # GL_EXT_direct_state_access -proc glClientAttribDefaultEXT*(mask: GLbitfield){.stdcall, importc, ogl.} -proc glPushClientAttribDefaultEXT*(mask: GLbitfield){.stdcall, importc, ogl.} -proc glMatrixLoadfEXT*(mode: GLenum, m: PGLfloat){.stdcall, importc, ogl.} -proc glMatrixLoaddEXT*(mode: GLenum, m: PGLdouble){.stdcall, importc, ogl.} -proc glMatrixMultfEXT*(mode: GLenum, m: PGLfloat){.stdcall, importc, ogl.} -proc glMatrixMultdEXT*(mode: GLenum, m: PGLdouble){.stdcall, importc, ogl.} -proc glMatrixLoadIdentityEXT*(mode: GLenum){.stdcall, importc, ogl.} -proc glMatrixRotatefEXT*(mode: GLenum, angle: GLfloat, x: GLfloat, y: GLfloat, - z: GLfloat){.stdcall, importc, ogl.} -proc glMatrixRotatedEXT*(mode: GLenum, angle: GLdouble, x: GLdouble, - y: GLdouble, z: GLdouble){.stdcall, importc, ogl.} -proc glMatrixScalefEXT*(mode: GLenum, x: GLfloat, y: GLfloat, z: GLfloat){. - stdcall, importc, ogl.} -proc glMatrixScaledEXT*(mode: GLenum, x: GLdouble, y: GLdouble, z: GLdouble){. - stdcall, importc, ogl.} -proc glMatrixTranslatefEXT*(mode: GLenum, x: GLfloat, y: GLfloat, z: GLfloat){. - stdcall, importc, ogl.} -proc glMatrixTranslatedEXT*(mode: GLenum, x: GLdouble, y: GLdouble, z: GLdouble){. - stdcall, importc, ogl.} -proc glMatrixFrustumEXT*(mode: GLenum, left: GLdouble, right: GLdouble, - bottom: GLdouble, top: GLdouble, zNear: GLdouble, - zFar: GLdouble){.stdcall, importc, ogl.} -proc glMatrixOrthoEXT*(mode: GLenum, left: GLdouble, right: GLdouble, - bottom: GLdouble, top: GLdouble, zNear: GLdouble, - zFar: GLdouble){.stdcall, importc, ogl.} -proc glMatrixPopEXT*(mode: GLenum){.stdcall, importc, ogl.} -proc glMatrixPushEXT*(mode: GLenum){.stdcall, importc, ogl.} -proc glMatrixLoadTransposefEXT*(mode: GLenum, m: PGLfloat){.stdcall, importc, ogl.} -proc glMatrixLoadTransposedEXT*(mode: GLenum, m: PGLdouble){.stdcall, importc, ogl.} -proc glMatrixMultTransposefEXT*(mode: GLenum, m: PGLfloat){.stdcall, importc, ogl.} -proc glMatrixMultTransposedEXT*(mode: GLenum, m: PGLdouble){.stdcall, importc, ogl.} -proc glTextureParameterfEXT*(texture: GLuint, target: GLenum, pname: GLenum, - param: GLfloat){.stdcall, importc, ogl.} -proc glTextureParameterfvEXT*(texture: GLuint, target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glTextureParameteriEXT*(texture: GLuint, target: GLenum, pname: GLenum, - param: GLint){.stdcall, importc, ogl.} -proc glTextureParameterivEXT*(texture: GLuint, target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glTextureImage1DEXT*(texture: GLuint, target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, border: GLint, - format: GLenum, typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glTextureImage2DEXT*(texture: GLuint, target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - height: GLsizei, border: GLint, format: GLenum, - typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glTextureSubImage1DEXT*(texture: GLuint, target: GLenum, level: GLint, - xoffset: GLint, width: GLsizei, format: GLenum, - typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glTextureSubImage2DEXT*(texture: GLuint, target: GLenum, level: GLint, - xoffset: GLint, yoffset: GLint, width: GLsizei, - height: GLsizei, format: GLenum, typ: GLenum, - pixels: PGLvoid){.stdcall, importc, ogl.} -proc glCopyTextureImage1DEXT*(texture: GLuint, target: GLenum, level: GLint, - internalformat: GLenum, x: GLint, y: GLint, - width: GLsizei, border: GLint){.stdcall, importc, ogl.} -proc glCopyTextureImage2DEXT*(texture: GLuint, target: GLenum, level: GLint, - internalformat: GLenum, x: GLint, y: GLint, - width: GLsizei, height: GLsizei, border: GLint){. - stdcall, importc, ogl.} -proc glCopyTextureSubImage1DEXT*(texture: GLuint, target: GLenum, level: GLint, - xoffset: GLint, x: GLint, y: GLint, - width: GLsizei){.stdcall, importc, ogl.} -proc glCopyTextureSubImage2DEXT*(texture: GLuint, target: GLenum, level: GLint, - xoffset: GLint, yoffset: GLint, x: GLint, - y: GLint, width: GLsizei, height: GLsizei){. - stdcall, importc, ogl.} -proc glGetTextureImageEXT*(texture: GLuint, target: GLenum, level: GLint, - format: GLenum, typ: GLenum, pixels: PGLvoid){. - stdcall, importc, ogl.} -proc glGetTextureParameterfvEXT*(texture: GLuint, target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetTextureParameterivEXT*(texture: GLuint, target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetTextureLevelParameterfvEXT*(texture: GLuint, target: GLenum, - level: GLint, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetTextureLevelParameterivEXT*(texture: GLuint, target: GLenum, - level: GLint, pname: GLenum, params: GLint){. - stdcall, importc, ogl.} -proc glTextureImage3DEXT*(texture: GLuint, target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - height: GLsizei, depth: GLsizei, border: GLint, - format: GLenum, typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glTextureSubImage3DEXT*(texture: GLuint, target: GLenum, level: GLint, - xoffset: GLint, yoffset: GLint, zoffset: GLint, - width: GLsizei, height: GLsizei, depth: GLsizei, - format: GLenum, typ: GLenum, pixels: PGLvoid){. - stdcall, importc, ogl.} -proc glCopyTextureSubImage3DEXT*(texture: GLuint, target: GLenum, level: GLint, - xoffset: GLint, yoffset: GLint, zoffset: GLint, - x: GLint, y: GLint, width: GLsizei, - height: GLsizei){.stdcall, importc, ogl.} -proc glMultiTexParameterfEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - param: GLfloat){.stdcall, importc, ogl.} -proc glMultiTexParameterfvEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexParameteriEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - param: GLint){.stdcall, importc, ogl.} -proc glMultiTexParameterivEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glMultiTexImage1DEXT*(texunit: GLenum, target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - border: GLint, format: GLenum, typ: GLenum, - pixels: PGLvoid){.stdcall, importc, ogl.} -proc glMultiTexImage2DEXT*(texunit: GLenum, target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - height: GLsizei, border: GLint, format: GLenum, - typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glMultiTexSubImage1DEXT*(texunit: GLenum, target: GLenum, level: GLint, - xoffset: GLint, width: GLsizei, format: GLenum, - typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glMultiTexSubImage2DEXT*(texunit: GLenum, target: GLenum, level: GLint, - xoffset: GLint, yoffset: GLint, width: GLsizei, - height: GLsizei, format: GLenum, typ: GLenum, - pixels: PGLvoid){.stdcall, importc, ogl.} -proc glCopyMultiTexImage1DEXT*(texunit: GLenum, target: GLenum, level: GLint, - internalformat: GLenum, x: GLint, y: GLint, - width: GLsizei, border: GLint){.stdcall, importc, ogl.} -proc glCopyMultiTexImage2DEXT*(texunit: GLenum, target: GLenum, level: GLint, - internalformat: GLenum, x: GLint, y: GLint, - width: GLsizei, height: GLsizei, border: GLint){. - stdcall, importc, ogl.} -proc glCopyMultiTexSubImage1DEXT*(texunit: GLenum, target: GLenum, level: GLint, - xoffset: GLint, x: GLint, y: GLint, - width: GLsizei){.stdcall, importc, ogl.} -proc glCopyMultiTexSubImage2DEXT*(texunit: GLenum, target: GLenum, level: GLint, - xoffset: GLint, yoffset: GLint, x: GLint, - y: GLint, width: GLsizei, height: GLsizei){. - stdcall, importc, ogl.} -proc glGetMultiTexImageEXT*(texunit: GLenum, target: GLenum, level: GLint, - format: GLenum, typ: GLenum, pixels: PGLvoid){. - stdcall, importc, ogl.} -proc glGetMultiTexParameterfvEXT*(texunit: GLenum, target: GLenum, - pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetMultiTexParameterivEXT*(texunit: GLenum, target: GLenum, - pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetMultiTexLevelParameterfvEXT*(texunit: GLenum, target: GLenum, - level: GLint, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetMultiTexLevelParameterivEXT*(texunit: GLenum, target: GLenum, - level: GLint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glMultiTexImage3DEXT*(texunit: GLenum, target: GLenum, level: GLint, - internalformat: GLenum, width: GLsizei, - height: GLsizei, depth: GLsizei, border: GLint, - format: GLenum, typ: GLenum, pixels: PGLvoid){. - stdcall, importc, ogl.} -proc glMultiTexSubImage3DEXT*(texunit: GLenum, target: GLenum, level: GLint, - xoffset: GLint, yoffset: GLint, zoffset: GLint, - width: GLsizei, height: GLsizei, depth: GLsizei, - format: GLenum, typ: GLenum, pixels: PGLvoid){. - stdcall, importc, ogl.} -proc glCopyMultiTexSubImage3DEXT*(texunit: GLenum, target: GLenum, level: GLint, - xoffset: GLint, yoffset: GLint, - zoffset: GLint, x: GLint, y: GLint, - width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} -proc glBindMultiTextureEXT*(texunit: GLenum, target: GLenum, texture: GLuint){. - stdcall, importc, ogl.} -proc glEnableClientStateIndexedEXT*(arr: GLenum, index: GLuint){.stdcall, importc, ogl.} -proc glDisableClientStateIndexedEXT*(arr: GLenum, index: GLuint){.stdcall, importc, ogl.} -proc glMultiTexCoordPointerEXT*(texunit: GLenum, size: GLint, typ: GLenum, - stride: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glMultiTexEnvfEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - param: GLfloat){.stdcall, importc, ogl.} -proc glMultiTexEnvfvEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexEnviEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - param: GLint){.stdcall, importc, ogl.} -proc glMultiTexEnvivEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glMultiTexGendEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - param: GLdouble){.stdcall, importc, ogl.} -proc glMultiTexGendvEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - params: PGLdouble){.stdcall, importc, ogl.} -proc glMultiTexGenfEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - param: GLfloat){.stdcall, importc, ogl.} -proc glMultiTexGenfvEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glMultiTexGeniEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - param: GLint){.stdcall, importc, ogl.} -proc glMultiTexGenivEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetMultiTexEnvfvEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetMultiTexEnvivEXT*(texunit: GLenum, target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetMultiTexGendvEXT*(texunit: GLenum, coord: GLenum, pname: GLenum, - params: PGLdouble){.stdcall, importc, ogl.} -proc glGetMultiTexGenfvEXT*(texunit: GLenum, coord: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetMultiTexGenivEXT*(texunit: GLenum, coord: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetFloatIndexedvEXT*(target: GLenum, index: GLuint, data: PGLfloat){. - stdcall, importc, ogl.} -proc glGetDoubleIndexedvEXT*(target: GLenum, index: GLuint, data: PGLdouble){. - stdcall, importc, ogl.} -proc glGetPointerIndexedvEXT*(target: GLenum, index: GLuint, data: PPGLvoid){. - stdcall, importc, ogl.} -proc glCompressedTextureImage3DEXT*(texture: GLuint, target: GLenum, - level: GLint, internalformat: GLenum, - width: GLsizei, height: GLsizei, - depth: GLsizei, border: GLint, - imageSize: GLsizei, bits: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTextureImage2DEXT*(texture: GLuint, target: GLenum, - level: GLint, internalformat: GLenum, - width: GLsizei, height: GLsizei, - border: GLint, imageSize: GLsizei, - bits: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTextureImage1DEXT*(texture: GLuint, target: GLenum, - level: GLint, internalformat: GLenum, - width: GLsizei, border: GLint, - imageSize: GLsizei, bits: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedTextureSubImage3DEXT*(texture: GLuint, target: GLenum, - level: GLint, xoffset: GLint, - yoffset: GLint, zoffset: GLint, - width: GLsizei, height: GLsizei, - depth: GLsizei, format: GLenum, - imageSize: GLsizei, bits: PGLvoid){. - stdcall, importc, ogl.} -proc glCompressedTextureSubImage2DEXT*(texture: GLuint, target: GLenum, - level: GLint, xoffset: GLint, - yoffset: GLint, width: GLsizei, - height: GLsizei, format: GLenum, - imageSize: GLsizei, bits: PGLvoid){. - stdcall, importc, ogl.} -proc glCompressedTextureSubImage1DEXT*(texture: GLuint, target: GLenum, - level: GLint, xoffset: GLint, - width: GLsizei, format: GLenum, - imageSize: GLsizei, bits: PGLvoid){. - stdcall, importc, ogl.} -proc glGetCompressedTextureImageEXT*(texture: GLuint, target: GLenum, - lod: GLint, img: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedMultiTexImage3DEXT*(texunit: GLenum, target: GLenum, - level: GLint, internalformat: GLenum, - width: GLsizei, height: GLsizei, - depth: GLsizei, border: GLint, - imageSize: GLsizei, bits: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedMultiTexImage2DEXT*(texunit: GLenum, target: GLenum, - level: GLint, internalformat: GLenum, - width: GLsizei, height: GLsizei, - border: GLint, imageSize: GLsizei, - bits: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedMultiTexImage1DEXT*(texunit: GLenum, target: GLenum, - level: GLint, internalformat: GLenum, - width: GLsizei, border: GLint, - imageSize: GLsizei, bits: PGLvoid){.stdcall, importc, ogl.} -proc glCompressedMultiTexSubImage3DEXT*(texunit: GLenum, target: GLenum, - level: GLint, xoffset: GLint, - yoffset: GLint, zoffset: GLint, - width: GLsizei, height: GLsizei, - depth: GLsizei, format: GLenum, - imageSize: GLsizei, bits: PGLvoid){. - stdcall, importc, ogl.} -proc glCompressedMultiTexSubImage2DEXT*(texunit: GLenum, target: GLenum, - level: GLint, xoffset: GLint, - yoffset: GLint, width: GLsizei, - height: GLsizei, format: GLenum, - imageSize: GLsizei, bits: PGLvoid){. - stdcall, importc, ogl.} -proc glCompressedMultiTexSubImage1DEXT*(texunit: GLenum, target: GLenum, - level: GLint, xoffset: GLint, - width: GLsizei, format: GLenum, - imageSize: GLsizei, bits: PGLvoid){. - stdcall, importc, ogl.} -proc glGetCompressedMultiTexImageEXT*(texunit: GLenum, target: GLenum, - lod: GLint, img: PGLvoid){.stdcall, importc, ogl.} -proc glNamedProgramStringEXT*(prog: GLuint, target: GLenum, format: GLenum, - length: GLsizei, string: PGLvoid){.stdcall, importc, ogl.} -proc glNamedProgramLocalParameter4dEXT*(prog: GLuint, target: GLenum, - index: GLuint, x: GLdouble, y: GLdouble, - z: GLdouble, w: GLdouble){.stdcall, importc, ogl.} -proc glNamedProgramLocalParameter4dvEXT*(prog: GLuint, target: GLenum, - index: GLuint, params: PGLdouble){.stdcall, importc, ogl.} -proc glNamedProgramLocalParameter4fEXT*(prog: GLuint, target: GLenum, - index: GLuint, x: GLfloat, y: GLfloat, - z: GLfloat, w: GLfloat){.stdcall, importc, ogl.} -proc glNamedProgramLocalParameter4fvEXT*(prog: GLuint, target: GLenum, - index: GLuint, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetNamedProgramLocalParameterdvEXT*(prog: GLuint, target: GLenum, - index: GLuint, params: PGLdouble){.stdcall, importc, ogl.} -proc glGetNamedProgramLocalParameterfvEXT*(prog: GLuint, target: GLenum, - index: GLuint, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetNamedProgramivEXT*(prog: GLuint, target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetNamedProgramStringEXT*(prog: GLuint, target: GLenum, pname: GLenum, - string: PGLvoid){.stdcall, importc, ogl.} -proc glNamedProgramLocalParameters4fvEXT*(prog: GLuint, target: GLenum, - index: GLuint, count: GLsizei, params: PGLfloat){.stdcall, importc, ogl.} -proc glNamedProgramLocalParameterI4iEXT*(prog: GLuint, target: GLenum, - index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint){.stdcall, importc, ogl.} -proc glNamedProgramLocalParameterI4ivEXT*(prog: GLuint, target: GLenum, - index: GLuint, params: PGLint){.stdcall, importc, ogl.} -proc glNamedProgramLocalParametersI4ivEXT*(prog: GLuint, target: GLenum, - index: GLuint, count: GLsizei, params: PGLint){.stdcall, importc, ogl.} -proc glNamedProgramLocalParameterI4uiEXT*(prog: GLuint, target: GLenum, - index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint){.stdcall, importc, ogl.} -proc glNamedProgramLocalParameterI4uivEXT*(prog: GLuint, target: GLenum, - index: GLuint, params: PGLuint){.stdcall, importc, ogl.} -proc glNamedProgramLocalParametersI4uivEXT*(prog: GLuint, target: GLenum, - index: GLuint, count: GLsizei, params: PGLuint){.stdcall, importc, ogl.} -proc glGetNamedProgramLocalParameterIivEXT*(prog: GLuint, target: GLenum, - index: GLuint, params: PGLint){.stdcall, importc, ogl.} -proc glGetNamedProgramLocalParameterIuivEXT*(prog: GLuint, target: GLenum, - index: GLuint, params: PGLuint){.stdcall, importc, ogl.} -proc glTextureParameterIivEXT*(texture: GLuint, target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glTextureParameterIuivEXT*(texture: GLuint, target: GLenum, pname: GLenum, - params: PGLuint){.stdcall, importc, ogl.} -proc glGetTextureParameterIivEXT*(texture: GLuint, target: GLenum, - pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetTextureParameterIuivEXT*(texture: GLuint, target: GLenum, - pname: GLenum, params: PGLuint){.stdcall, importc, ogl.} -proc glMultiTexParameterIivEXT*(texture: GLuint, target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glMultiTexParameterIuivEXT*(texture: GLuint, target: GLenum, pname: GLenum, - params: PGLuint){.stdcall, importc, ogl.} -proc glGetMultiTexParameterIivEXT*(texture: GLuint, target: GLenum, - pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetMultiTexParameterIuivEXT*(texture: GLuint, target: GLenum, - pname: GLenum, params: PGLuint){.stdcall, importc, ogl.} -proc glProgramUniform1fEXT*(prog: GLuint, location: GLint, v0: GLfloat){.stdcall, importc, ogl.} -proc glProgramUniform2fEXT*(prog: GLuint, location: GLint, v0: GLfloat, - v1: GLfloat){.stdcall, importc, ogl.} -proc glProgramUniform3fEXT*(prog: GLuint, location: GLint, v0: GLfloat, - v1: GLfloat, v2: GLfloat){.stdcall, importc, ogl.} -proc glProgramUniform4fEXT*(prog: GLuint, location: GLint, v0: GLfloat, - v1: GLfloat, v2: GLfloat, v3: GLfloat){.stdcall, importc, ogl.} -proc glProgramUniform1iEXT*(prog: GLuint, location: GLint, v0: GLint){.stdcall, importc, ogl.} -proc glProgramUniform2iEXT*(prog: GLuint, location: GLint, v0: GLint, v1: GLint){. - stdcall, importc, ogl.} -proc glProgramUniform3iEXT*(prog: GLuint, location: GLint, v0: GLint, v1: GLint, - v2: GLint){.stdcall, importc, ogl.} -proc glProgramUniform4iEXT*(prog: GLuint, location: GLint, v0: GLint, v1: GLint, - v2: GLint, v3: GLint){.stdcall, importc, ogl.} -proc glProgramUniform1fvEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniform2fvEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniform3fvEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniform4fvEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniform1ivEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint){.stdcall, importc, ogl.} -proc glProgramUniform2ivEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint){.stdcall, importc, ogl.} -proc glProgramUniform3ivEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint){.stdcall, importc, ogl.} -proc glProgramUniform4ivEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint){.stdcall, importc, ogl.} -proc glProgramUniformMatrix2fvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix3fvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix4fvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix2x3fvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix3x2fvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix2x4fvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix4x2fvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix3x4fvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniformMatrix4x3fvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLfloat){.stdcall, importc, ogl.} -proc glProgramUniform1uiEXT*(prog: GLuint, location: GLint, v0: GLuint){.stdcall, importc, ogl.} -proc glProgramUniform2uiEXT*(prog: GLuint, location: GLint, v0: GLuint, - v1: GLuint){.stdcall, importc, ogl.} -proc glProgramUniform3uiEXT*(prog: GLuint, location: GLint, v0: GLuint, - v1: GLuint, v2: GLuint){.stdcall, importc, ogl.} -proc glProgramUniform4uiEXT*(prog: GLuint, location: GLint, v0: GLuint, - v1: GLuint, v2: GLuint, v3: GLuint){.stdcall, importc, ogl.} -proc glProgramUniform1uivEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint){.stdcall, importc, ogl.} -proc glProgramUniform2uivEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint){.stdcall, importc, ogl.} -proc glProgramUniform3uivEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint){.stdcall, importc, ogl.} -proc glProgramUniform4uivEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint){.stdcall, importc, ogl.} -proc glNamedBufferDataEXT*(buffer: GLuint, size: GLsizei, data: PGLvoid, - usage: GLenum){.stdcall, importc, ogl.} -proc glNamedBufferSubDataEXT*(buffer: GLuint, offset: GLintptr, - size: GLsizeiptr, data: PGLvoid){.stdcall, importc, ogl.} -proc glMapNamedBufferEXT*(buffer: GLuint, access: GLenum): PGLvoid{.stdcall, importc, ogl.} -proc glUnmapNamedBufferEXT*(buffer: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glMapNamedBufferRangeEXT*(buffer: GLuint, offset: GLintptr, - len: GLsizeiptr, access: GLbitfield): PGLvoid{. - stdcall, importc, ogl.} -proc glFlushMappedNamedBufferRangeEXT*(buffer: GLuint, offset: GLintptr, - len: GLsizeiptr){.stdcall, importc, ogl.} -proc glNamedCopyBufferSubDataEXT*(readBuffer: GLuint, writeBuffer: GLuint, - readOffset: GLintptr, writeOffset: GLintptr, - size: GLsizeiptr){.stdcall, importc, ogl.} -proc glGetNamedBufferParameterivEXT*(buffer: GLuint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetNamedBufferPointervEXT*(buffer: GLuint, pname: GLenum, - params: PPGLvoid){.stdcall, importc, ogl.} -proc glGetNamedBufferSubDataEXT*(buffer: GLuint, offset: GLintptr, - size: GLsizeiptr, data: PGLvoid){.stdcall, importc, ogl.} -proc glTextureBufferEXT*(texture: GLuint, target: GLenum, - internalformat: GLenum, buffer: GLuint){.stdcall, importc, ogl.} -proc glMultiTexBufferEXT*(texunit: GLenum, target: GLenum, interformat: GLenum, - buffer: GLuint){.stdcall, importc, ogl.} -proc glNamedRenderbufferStorageEXT*(renderbuffer: GLuint, interformat: GLenum, - width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} -proc glGetNamedRenderbufferParameterivEXT*(renderbuffer: GLuint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glCheckNamedFramebufferStatusEXT*(framebuffer: GLuint, target: GLenum): GLenum{. - stdcall, importc, ogl.} -proc glNamedFramebufferTexture1DEXT*(framebuffer: GLuint, attachment: GLenum, - textarget: GLenum, texture: GLuint, - level: GLint){.stdcall, importc, ogl.} -proc glNamedFramebufferTexture2DEXT*(framebuffer: GLuint, attachment: GLenum, - textarget: GLenum, texture: GLuint, - level: GLint){.stdcall, importc, ogl.} -proc glNamedFramebufferTexture3DEXT*(framebuffer: GLuint, attachment: GLenum, - textarget: GLenum, texture: GLuint, - level: GLint, zoffset: GLint){.stdcall, importc, ogl.} -proc glNamedFramebufferRenderbufferEXT*(framebuffer: GLuint, attachment: GLenum, - renderbuffertarget: GLenum, - renderbuffer: GLuint){.stdcall, importc, ogl.} -proc glGetNamedFramebufferAttachmentParameterivEXT*(framebuffer: GLuint, - attachment: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGenerateTextureMipmapEXT*(texture: GLuint, target: GLenum){.stdcall, importc, ogl.} -proc glGenerateMultiTexMipmapEXT*(texunit: GLenum, target: GLenum){.stdcall, importc, ogl.} -proc glFramebufferDrawBufferEXT*(framebuffer: GLuint, mode: GLenum){.stdcall, importc, ogl.} -proc glFramebufferDrawBuffersEXT*(framebuffer: GLuint, n: GLsizei, bufs: PGLenum){. - stdcall, importc, ogl.} -proc glFramebufferReadBufferEXT*(framebuffer: GLuint, mode: GLenum){.stdcall, importc, ogl.} -proc glGetFramebufferParameterivEXT*(framebuffer: GLuint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glNamedRenderbufferStorageMultisampleEXT*(renderbuffer: GLuint, - samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei){. - stdcall, importc, ogl.} -proc glNamedRenderbufferStorageMultisampleCoverageEXT*(renderbuffer: GLuint, - coverageSamples: GLsizei, colorSamples: GLsizei, internalformat: GLenum, - width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} -proc glNamedFramebufferTextureEXT*(framebuffer: GLuint, attachment: GLenum, - texture: GLuint, level: GLint){.stdcall, importc, ogl.} -proc glNamedFramebufferTextureLayerEXT*(framebuffer: GLuint, attachment: GLenum, - texture: GLuint, level: GLint, - layer: GLint){.stdcall, importc, ogl.} -proc glNamedFramebufferTextureFaceEXT*(framebuffer: GLuint, attachment: GLenum, - texture: GLuint, level: GLint, - face: GLenum){.stdcall, importc, ogl.} -proc glTextureRenderbufferEXT*(texture: GLuint, target: GLenum, - renderbuffer: GLuint){.stdcall, importc, ogl.} -proc glMultiTexRenderbufferEXT*(texunit: GLenum, target: GLenum, - renderbuffer: GLuint){.stdcall, importc, ogl.} -proc glProgramUniform1dEXT*(prog: GLuint, location: GLint, x: GLdouble){.stdcall, importc, ogl.} -proc glProgramUniform2dEXT*(prog: GLuint, location: GLint, x: GLdouble, - y: GLdouble){.stdcall, importc, ogl.} -proc glProgramUniform3dEXT*(prog: GLuint, location: GLint, x: GLdouble, - y: GLdouble, z: GLdouble){.stdcall, importc, ogl.} -proc glProgramUniform4dEXT*(prog: GLuint, location: GLint, x: GLdouble, - y: GLdouble, z: GLdouble, w: GLdouble){.stdcall, importc, ogl.} -proc glProgramUniform1dvEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniform2dvEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniform3dvEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniform4dvEXT*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix2dvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix3dvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix4dvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix2x3dvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix2x4dvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix3x2dvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix3x4dvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix4x2dvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} -proc glProgramUniformMatrix4x3dvEXT*(prog: GLuint, location: GLint, - count: GLsizei, transpose: GLboolean, - value: PGLdouble){.stdcall, importc, ogl.} - # GL_EXT_separate_shader_objects -proc glUseShaderProgramEXT*(typ: GLenum, prog: GLuint){.stdcall, importc, ogl.} -proc glActiveProgramEXT*(prog: GLuint){.stdcall, importc, ogl.} -proc glCreateShaderProgramEXT*(typ: GLenum, string: PGLchar): GLuint{.stdcall, importc, ogl.} - # GL_EXT_shader_image_load_store -proc glBindImageTextureEXT*(index: GLuint, texture: GLuint, level: GLint, - layered: GLboolean, layer: GLint, access: GLenum, - format: GLint){.stdcall, importc, ogl.} -proc glMemoryBarrierEXT*(barriers: GLbitfield){.stdcall, importc, ogl.} - # GL_EXT_vertex_attrib_64bit -proc glVertexAttribL1dEXT*(index: GLuint, x: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL2dEXT*(index: GLuint, x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL3dEXT*(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble){. - stdcall, importc, ogl.} -proc glVertexAttribL4dEXT*(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, - w: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL1dvEXT*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL2dvEXT*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL3dvEXT*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribL4dvEXT*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribLPointerEXT*(index: GLuint, size: GLint, typ: GLenum, - stride: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glGetVertexAttribLdvEXT*(index: GLuint, pname: GLenum, params: PGLdouble){. - stdcall, importc, ogl.} -proc glVertexArrayVertexAttribLOffsetEXT*(vaobj: GLuint, buffer: GLuint, - index: GLuint, size: GLint, typ: GLenum, stride: GLsizei, offset: GLintptr){. - stdcall, importc, ogl.} - # GL_IBM_multimode_draw_arrays -proc glMultiModeDrawArraysIBM*(mode: GLenum, first: PGLint, count: PGLsizei, - primcount: GLsizei, modestride: GLint){.stdcall, importc, ogl.} -proc glMultiModeDrawElementsIBM*(mode: PGLenum, count: PGLsizei, typ: GLenum, - indices: PGLvoid, primcount: GLsizei, - modestride: GLint){.stdcall, importc, ogl.} - # GL_IBM_vertex_array_lists -proc glColorPointerListIBM*(size: GLint, typ: GLenum, stride: GLint, - pointer: PGLvoid, ptrstride: GLint){.stdcall, importc, ogl.} -proc glSecondaryColorPointerListIBM*(size: GLint, typ: GLenum, stride: GLint, - pointer: PGLvoid, ptrstride: GLint){. - stdcall, importc, ogl.} -proc glEdgeFlagPointerListIBM*(stride: GLint, pointer: PGLboolean, - ptrstride: GLint){.stdcall, importc, ogl.} -proc glFogCoordPointerListIBM*(typ: GLenum, stride: GLint, pointer: PGLvoid, - ptrstride: GLint){.stdcall, importc, ogl.} -proc glIndexPointerListIBM*(typ: GLenum, stride: GLint, pointer: PGLvoid, - ptrstride: GLint){.stdcall, importc, ogl.} -proc glNormalPointerListIBM*(typ: GLenum, stride: GLint, pointer: PGLvoid, - ptrstride: GLint){.stdcall, importc, ogl.} -proc glTexCoordPointerListIBM*(size: GLint, typ: GLenum, stride: GLint, - pointer: PGLvoid, ptrstride: GLint){.stdcall, importc, ogl.} -proc glVertexPointerListIBM*(size: GLint, typ: GLenum, stride: GLint, - pointer: PGLvoid, ptrstride: GLint){.stdcall, importc, ogl.} - # GL_INGR_blend_func_separate -proc glBlendFuncSeparateINGR*(sfactorRGB: GLenum, dfactorRGB: GLenum, - sfactorAlpha: GLenum, dfactorAlpha: GLenum){. - stdcall, importc, ogl.} - # GL_INTEL_parallel_arrays -proc glVertexPointervINTEL*(size: GLint, typ: GLenum, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glNormalPointervINTEL*(typ: GLenum, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glColorPointervINTEL*(size: GLint, typ: GLenum, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glTexCoordPointervINTEL*(size: GLint, typ: GLenum, pointer: PGLvoid){. - stdcall, importc, ogl.} - # GL_MESA_resize_buffers -proc glResizeBuffersMESA*(){.stdcall, importc, ogl.} - # GL_MESA_window_pos -proc glWindowPos2dMESA*(x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glWindowPos2dvMESA*(v: PGLdouble){.stdcall, importc, ogl.} -proc glWindowPos2fMESA*(x: GLfloat, y: GLfloat){.stdcall, importc, ogl.} -proc glWindowPos2fvMESA*(v: PGLfloat){.stdcall, importc, ogl.} -proc glWindowPos2iMESA*(x: GLint, y: GLint){.stdcall, importc, ogl.} -proc glWindowPos2ivMESA*(v: PGLint){.stdcall, importc, ogl.} -proc glWindowPos2sMESA*(x: GLshort, y: GLshort){.stdcall, importc, ogl.} -proc glWindowPos2svMESA*(v: PGLshort){.stdcall, importc, ogl.} -proc glWindowPos3dMESA*(x: GLdouble, y: GLdouble, z: GLdouble){.stdcall, importc, ogl.} -proc glWindowPos3dvMESA*(v: PGLdouble){.stdcall, importc, ogl.} -proc glWindowPos3fMESA*(x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glWindowPos3fvMESA*(v: PGLfloat){.stdcall, importc, ogl.} -proc glWindowPos3iMESA*(x: GLint, y: GLint, z: GLint){.stdcall, importc, ogl.} -proc glWindowPos3ivMESA*(v: PGLint){.stdcall, importc, ogl.} -proc glWindowPos3sMESA*(x: GLshort, y: GLshort, z: GLshort){.stdcall, importc, ogl.} -proc glWindowPos3svMESA*(v: PGLshort){.stdcall, importc, ogl.} -proc glWindowPos4dMESA*(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble){. - stdcall, importc, ogl.} -proc glWindowPos4dvMESA*(v: PGLdouble){.stdcall, importc, ogl.} -proc glWindowPos4fMESA*(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat){.stdcall, importc, ogl.} -proc glWindowPos4fvMESA*(v: PGLfloat){.stdcall, importc, ogl.} -proc glWindowPos4iMESA*(x: GLint, y: GLint, z: GLint, w: GLint){.stdcall, importc, ogl.} -proc glWindowPos4ivMESA*(v: PGLint){.stdcall, importc, ogl.} -proc glWindowPos4sMESA*(x: GLshort, y: GLshort, z: GLshort, w: GLshort){.stdcall, importc, ogl.} -proc glWindowPos4svMESA*(v: PGLshort){.stdcall, importc, ogl.} - # GL_NV_evaluators -proc glMapControlPointsNV*(target: GLenum, index: GLuint, typ: GLenum, - ustride: GLsizei, vstride: GLsizei, uorder: GLint, - vorder: GLint, pack: GLboolean, points: PGLvoid){. - stdcall, importc, ogl.} -proc glMapParameterivNV*(target: GLenum, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glMapParameterfvNV*(target: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetMapControlPointsNV*(target: GLenum, index: GLuint, typ: GLenum, - ustride: GLsizei, vstride: GLsizei, - pack: GLboolean, points: PGLvoid){.stdcall, importc, ogl.} -proc glGetMapParameterivNV*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetMapParameterfvNV*(target: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetMapAttribParameterivNV*(target: GLenum, index: GLuint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetMapAttribParameterfvNV*(target: GLenum, index: GLuint, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glEvalMapsNV*(target: GLenum, mode: GLenum){.stdcall, importc, ogl.} - # GL_NV_fence -proc glDeleteFencesNV*(n: GLsizei, fences: PGLuint){.stdcall, importc, ogl.} -proc glGenFencesNV*(n: GLsizei, fences: PGLuint){.stdcall, importc, ogl.} -proc glIsFenceNV*(fence: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glTestFenceNV*(fence: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glGetFenceivNV*(fence: GLuint, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glFinishFenceNV*(fence: GLuint){.stdcall, importc, ogl.} -proc glSetFenceNV*(fence: GLuint, condition: GLenum){.stdcall, importc, ogl.} - # GL_NV_fragment_prog -proc glProgramNamedParameter4fNV*(id: GLuint, length: GLsizei, name: PGLubyte, - x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat){. - stdcall, importc, ogl.} -proc glProgramNamedParameter4dNV*(id: GLuint, length: GLsizei, name: PGLubyte, - x: GLdouble, y: GLdouble, z: GLdouble, - w: GLdouble){.stdcall, importc, ogl.} -proc glProgramNamedParameter4fvNV*(id: GLuint, length: GLsizei, name: PGLubyte, - v: PGLfloat){.stdcall, importc, ogl.} -proc glProgramNamedParameter4dvNV*(id: GLuint, length: GLsizei, name: PGLubyte, - v: PGLdouble){.stdcall, importc, ogl.} -proc glGetProgramNamedParameterfvNV*(id: GLuint, length: GLsizei, - name: PGLubyte, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetProgramNamedParameterdvNV*(id: GLuint, length: GLsizei, - name: PGLubyte, params: PGLdouble){.stdcall, importc, ogl.} - # GL_NV_half_float -proc glVertex2hNV*(x: GLhalfNV, y: GLhalfNV){.stdcall, importc, ogl.} -proc glVertex2hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertex3hNV*(x: GLhalfNV, y: GLhalfNV, z: GLhalfNV){.stdcall, importc, ogl.} -proc glVertex3hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertex4hNV*(x: GLhalfNV, y: GLhalfNV, z: GLhalfNV, w: GLhalfNV){.stdcall, importc, ogl.} -proc glVertex4hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glNormal3hNV*(nx: GLhalfNV, ny: GLhalfNV, nz: GLhalfNV){.stdcall, importc, ogl.} -proc glNormal3hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glColor3hNV*(red: GLhalfNV, green: GLhalfNV, blue: GLhalfNV){.stdcall, importc, ogl.} -proc glColor3hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glColor4hNV*(red: GLhalfNV, green: GLhalfNV, blue: GLhalfNV, - alpha: GLhalfNV){.stdcall, importc, ogl.} -proc glColor4hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glTexCoord1hNV*(s: GLhalfNV){.stdcall, importc, ogl.} -proc glTexCoord1hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glTexCoord2hNV*(s: GLhalfNV, t: GLhalfNV){.stdcall, importc, ogl.} -proc glTexCoord2hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glTexCoord3hNV*(s: GLhalfNV, t: GLhalfNV, r: GLhalfNV){.stdcall, importc, ogl.} -proc glTexCoord3hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glTexCoord4hNV*(s: GLhalfNV, t: GLhalfNV, r: GLhalfNV, q: GLhalfNV){. - stdcall, importc, ogl.} -proc glTexCoord4hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glMultiTexCoord1hNV*(target: GLenum, s: GLhalfNV){.stdcall, importc, ogl.} -proc glMultiTexCoord1hvNV*(target: GLenum, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glMultiTexCoord2hNV*(target: GLenum, s: GLhalfNV, t: GLhalfNV){.stdcall, importc, ogl.} -proc glMultiTexCoord2hvNV*(target: GLenum, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glMultiTexCoord3hNV*(target: GLenum, s: GLhalfNV, t: GLhalfNV, r: GLhalfNV){. - stdcall, importc, ogl.} -proc glMultiTexCoord3hvNV*(target: GLenum, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glMultiTexCoord4hNV*(target: GLenum, s: GLhalfNV, t: GLhalfNV, r: GLhalfNV, - q: GLhalfNV){.stdcall, importc, ogl.} -proc glMultiTexCoord4hvNV*(target: GLenum, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glFogCoordhNV*(fog: GLhalfNV){.stdcall, importc, ogl.} -proc glFogCoordhvNV*(fog: PGLhalfNV){.stdcall, importc, ogl.} -proc glSecondaryColor3hNV*(red: GLhalfNV, green: GLhalfNV, blue: GLhalfNV){. - stdcall, importc, ogl.} -proc glSecondaryColor3hvNV*(v: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertexWeighthNV*(weight: GLhalfNV){.stdcall, importc, ogl.} -proc glVertexWeighthvNV*(weight: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttrib1hNV*(index: GLuint, x: GLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttrib1hvNV*(index: GLuint, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttrib2hNV*(index: GLuint, x: GLhalfNV, y: GLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttrib2hvNV*(index: GLuint, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttrib3hNV*(index: GLuint, x: GLhalfNV, y: GLhalfNV, z: GLhalfNV){. - stdcall, importc, ogl.} -proc glVertexAttrib3hvNV*(index: GLuint, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttrib4hNV*(index: GLuint, x: GLhalfNV, y: GLhalfNV, z: GLhalfNV, - w: GLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttrib4hvNV*(index: GLuint, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttribs1hvNV*(index: GLuint, n: GLsizei, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttribs2hvNV*(index: GLuint, n: GLsizei, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttribs3hvNV*(index: GLuint, n: GLsizei, v: PGLhalfNV){.stdcall, importc, ogl.} -proc glVertexAttribs4hvNV*(index: GLuint, n: GLsizei, v: PGLhalfNV){.stdcall, importc, ogl.} - # GL_NV_occlusion_query -proc glGenOcclusionQueriesNV*(n: GLsizei, ids: PGLuint){.stdcall, importc, ogl.} -proc glDeleteOcclusionQueriesNV*(n: GLsizei, ids: PGLuint){.stdcall, importc, ogl.} -proc glIsOcclusionQueryNV*(id: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glBeginOcclusionQueryNV*(id: GLuint){.stdcall, importc, ogl.} -proc glEndOcclusionQueryNV*(){.stdcall, importc, ogl.} -proc glGetOcclusionQueryivNV*(id: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetOcclusionQueryuivNV*(id: GLuint, pname: GLenum, params: PGLuint){. - stdcall, importc, ogl.} - # GL_NV_pixel_data_range -proc glPixelDataRangeNV*(target: GLenum, len: GLsizei, pointer: PGLvoid){. - stdcall, importc, ogl.} -proc glFlushPixelDataRangeNV*(target: GLenum){.stdcall, importc, ogl.} - # GL_NV_point_sprite -proc glPointParameteriNV*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glPointParameterivNV*(pname: GLenum, params: PGLint){.stdcall, importc, ogl.} - # GL_NV_primitive_restart -proc glPrimitiveRestartNV*(){.stdcall, importc, ogl.} -proc glPrimitiveRestartIndexNV*(index: GLuint){.stdcall, importc, ogl.} - # GL_NV_register_combiners -proc glCombinerParameterfvNV*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glCombinerParameterfNV*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glCombinerParameterivNV*(pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glCombinerParameteriNV*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glCombinerInputNV*(stage: GLenum, portion: GLenum, variable: GLenum, - input: GLenum, mapping: GLenum, componentUsage: GLenum){. - stdcall, importc, ogl.} -proc glCombinerOutputNV*(stage: GLenum, portion: GLenum, abOutput: GLenum, - cdOutput: GLenum, sumOutput: GLenum, scale: GLenum, - bias: GLenum, abDotProduct: GLboolean, - cdDotProduct: GLboolean, muxSum: GLboolean){.stdcall, importc, ogl.} -proc glFinalCombinerInputNV*(variable: GLenum, input: GLenum, mapping: GLenum, - componentUsage: GLenum){.stdcall, importc, ogl.} -proc glGetCombinerInputParameterfvNV*(stage: GLenum, portion: GLenum, - variable: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetCombinerInputParameterivNV*(stage: GLenum, portion: GLenum, - variable: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetCombinerOutputParameterfvNV*(stage: GLenum, portion: GLenum, - pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetCombinerOutputParameterivNV*(stage: GLenum, portion: GLenum, - pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetFinalCombinerInputParameterfvNV*(variable: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetFinalCombinerInputParameterivNV*(variable: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} - # GL_NV_register_combiners2 -proc glCombinerStageParameterfvNV*(stage: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetCombinerStageParameterfvNV*(stage: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} - # GL_NV_vertex_array_range -proc glFlushVertexArrayRangeNV*(){.stdcall, importc, ogl.} -proc glVertexArrayRangeNV*(len: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} - # GL_NV_vertex_prog -proc glAreProgramsResidentNV*(n: GLsizei, programs: PGLuint, - residences: PGLboolean): GLboolean{.stdcall, importc, ogl.} -proc glBindProgramNV*(target: GLenum, id: GLuint){.stdcall, importc, ogl.} -proc glDeleteProgramsNV*(n: GLsizei, programs: PGLuint){.stdcall, importc, ogl.} -proc glExecuteProgramNV*(target: GLenum, id: GLuint, params: PGLfloat){.stdcall, importc, ogl.} -proc glGenProgramsNV*(n: GLsizei, programs: PGLuint){.stdcall, importc, ogl.} -proc glGetProgramParameterdvNV*(target: GLenum, index: GLuint, pname: GLenum, - params: PGLdouble){.stdcall, importc, ogl.} -proc glGetProgramParameterfvNV*(target: GLenum, index: GLuint, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetProgramivNV*(id: GLuint, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetProgramStringNV*(id: GLuint, pname: GLenum, prog: PGLubyte){.stdcall, importc, ogl.} -proc glGetTrackMatrixivNV*(target: GLenum, address: GLuint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetVertexAttribdvNV*(index: GLuint, pname: GLenum, params: PGLdouble){. - stdcall, importc, ogl.} -proc glGetVertexAttribfvNV*(index: GLuint, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetVertexAttribivNV*(index: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetVertexAttribPointervNV*(index: GLuint, pname: GLenum, pointer: PGLvoid){. - stdcall, importc, ogl.} -proc glIsProgramNV*(id: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glLoadProgramNV*(target: GLenum, id: GLuint, length: GLsizei, - prog: PGLubyte){.stdcall, importc, ogl.} -proc glProgramParameter4dNV*(target: GLenum, index: GLuint, x: GLdouble, - y: GLdouble, z: GLdouble, w: GLdouble){.stdcall, importc, ogl.} -proc glProgramParameter4dvNV*(target: GLenum, index: GLuint, v: PGLdouble){. - stdcall, importc, ogl.} -proc glProgramParameter4fNV*(target: GLenum, index: GLuint, x: GLfloat, - y: GLfloat, z: GLfloat, w: GLfloat){.stdcall, importc, ogl.} -proc glProgramParameter4fvNV*(target: GLenum, index: GLuint, v: PGLfloat){. - stdcall, importc, ogl.} -proc glProgramParameters4dvNV*(target: GLenum, index: GLuint, count: GLuint, - v: PGLdouble){.stdcall, importc, ogl.} -proc glProgramParameters4fvNV*(target: GLenum, index: GLuint, count: GLuint, - v: PGLfloat){.stdcall, importc, ogl.} -proc glRequestResidentProgramsNV*(n: GLsizei, programs: PGLuint){.stdcall, importc, ogl.} -proc glTrackMatrixNV*(target: GLenum, address: GLuint, matrix: GLenum, - transform: GLenum){.stdcall, importc, ogl.} -proc glVertexAttribPointerNV*(index: GLuint, fsize: GLint, typ: GLenum, - stride: GLsizei, pointer: PGLvoid){.stdcall, importc, ogl.} -proc glVertexAttrib1dNV*(index: GLuint, x: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib1dvNV*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib1fNV*(index: GLuint, x: GLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib1fvNV*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib1sNV*(index: GLuint, x: GLshort){.stdcall, importc, ogl.} -proc glVertexAttrib1svNV*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib2dNV*(index: GLuint, x: GLdouble, y: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib2dvNV*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib2fNV*(index: GLuint, x: GLfloat, y: GLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib2fvNV*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib2sNV*(index: GLuint, x: GLshort, y: GLshort){.stdcall, importc, ogl.} -proc glVertexAttrib2svNV*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib3dNV*(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble){. - stdcall, importc, ogl.} -proc glVertexAttrib3dvNV*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib3fNV*(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat){. - stdcall, importc, ogl.} -proc glVertexAttrib3fvNV*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib3sNV*(index: GLuint, x: GLshort, y: GLshort, z: GLshort){. - stdcall, importc, ogl.} -proc glVertexAttrib3svNV*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4dNV*(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, - w: GLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib4dvNV*(index: GLuint, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttrib4fNV*(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, - w: GLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib4fvNV*(index: GLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttrib4sNV*(index: GLuint, x: GLshort, y: GLshort, z: GLshort, - w: GLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4svNV*(index: GLuint, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttrib4ubNV*(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, - w: GLubyte){.stdcall, importc, ogl.} -proc glVertexAttrib4ubvNV*(index: GLuint, v: PGLubyte){.stdcall, importc, ogl.} -proc glVertexAttribs1dvNV*(index: GLuint, count: GLsizei, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribs1fvNV*(index: GLuint, count: GLsizei, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttribs1svNV*(index: GLuint, count: GLsizei, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttribs2dvNV*(index: GLuint, count: GLsizei, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribs2fvNV*(index: GLuint, count: GLsizei, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttribs2svNV*(index: GLuint, count: GLsizei, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttribs3dvNV*(index: GLuint, count: GLsizei, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribs3fvNV*(index: GLuint, count: GLsizei, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttribs3svNV*(index: GLuint, count: GLsizei, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttribs4dvNV*(index: GLuint, count: GLsizei, v: PGLdouble){.stdcall, importc, ogl.} -proc glVertexAttribs4fvNV*(index: GLuint, count: GLsizei, v: PGLfloat){.stdcall, importc, ogl.} -proc glVertexAttribs4svNV*(index: GLuint, count: GLsizei, v: PGLshort){.stdcall, importc, ogl.} -proc glVertexAttribs4ubvNV*(index: GLuint, count: GLsizei, v: PGLubyte){.stdcall, importc, ogl.} - # GL_NV_depth_buffer_float -proc glDepthRangedNV*(n: GLdouble, f: GLdouble){.stdcall, importc, ogl.} -proc glClearDepthdNV*(d: GLdouble){.stdcall, importc, ogl.} -proc glDepthBoundsdNV*(zmin: GLdouble, zmax: GLdouble){.stdcall, importc, ogl.} - # GL_NV_framebuffer_multisample_coverage -proc glRenderbufferStorageMultsampleCoverageNV*(target: GLenum, - coverageSamples: GLsizei, colorSamples: GLsizei, internalformat: GLenum, - width: GLsizei, height: GLsizei){.stdcall, importc, ogl.} - # GL_NV_geometry_program4 -proc glProgramVertexLimitNV*(target: GLenum, limit: GLint){.stdcall, importc, ogl.} - # GL_NV_gpu_program4 -proc glProgramLocalParameterI4iNV*(target: GLenum, index: GLuint, x: GLint, - y: GLint, z: GLint, w: GLint){.stdcall, importc, ogl.} -proc glProgramLocalParameterI4ivNV*(target: GLenum, index: GLuint, - params: PGLint){.stdcall, importc, ogl.} -proc glProgramLocalParametersI4ivNV*(target: GLenum, index: GLuint, - count: GLsizei, params: PGLint){.stdcall, importc, ogl.} -proc glProgramLocalParameterI4uiNV*(target: GLenum, index: GLuint, x: GLuint, - y: GLuint, z: GLuint, w: GLuint){.stdcall, importc, ogl.} -proc glProgramLocalParameterI4uivNV*(target: GLenum, index: GLuint, - params: PGLuint){.stdcall, importc, ogl.} -proc glProgramLocalParametersI4uivNV*(target: GLenum, index: GLuint, - count: GLsizei, params: PGLuint){.stdcall, importc, ogl.} -proc glProgramEnvParameterI4iNV*(target: GLenum, index: GLuint, x: GLint, - y: GLint, z: GLint, w: GLint){.stdcall, importc, ogl.} -proc glProgramEnvParameterI4ivNV*(target: GLenum, index: GLuint, params: PGLint){. - stdcall, importc, ogl.} -proc glProgramEnvParametersI4ivNV*(target: GLenum, index: GLuint, - count: GLsizei, params: PGLint){.stdcall, importc, ogl.} -proc glProgramEnvParameterI4uiNV*(target: GLenum, index: GLuint, x: GLuint, - y: GLuint, z: GLuint, w: GLuint){.stdcall, importc, ogl.} -proc glProgramEnvParameterI4uivNV*(target: GLenum, index: GLuint, - params: PGLuint){.stdcall, importc, ogl.} -proc glProgramEnvParametersI4uivNV*(target: GLenum, index: GLuint, - count: GLsizei, params: PGLuint){.stdcall, importc, ogl.} -proc glGetProgramLocalParameterIivNV*(target: GLenum, index: GLuint, - params: PGLint){.stdcall, importc, ogl.} -proc glGetProgramLocalParameterIuivNV*(target: GLenum, index: GLuint, - params: PGLuint){.stdcall, importc, ogl.} -proc glGetProgramEnvParameterIivNV*(target: GLenum, index: GLuint, - params: PGLint){.stdcall, importc, ogl.} -proc glGetProgramEnvParameterIuivNV*(target: GLenum, index: GLuint, - params: PGLuint){.stdcall, importc, ogl.} - # GL_NV_parameter_buffer_object -proc glProgramBufferParametersfvNV*(target: GLenum, buffer: GLuint, - index: GLuint, count: GLsizei, - params: PGLfloat){.stdcall, importc, ogl.} -proc glProgramBufferParametersIivNV*(target: GLenum, buffer: GLuint, - index: GLuint, count: GLsizei, - params: GLint){.stdcall, importc, ogl.} -proc glProgramBufferParametersIuivNV*(target: GLenum, buffer: GLuint, - index: GLuint, count: GLuint, - params: PGLuint){.stdcall, importc, ogl.} - # GL_NV_transform_feedback -proc glBeginTransformFeedbackNV*(primitiveMode: GLenum){.stdcall, importc, ogl.} -proc glEndTransformFeedbackNV*(){.stdcall, importc, ogl.} -proc glTransformFeedbackAttribsNV*(count: GLsizei, attribs: GLint, - bufferMode: GLenum){.stdcall, importc, ogl.} -proc glBindBufferRangeNV*(target: GLenum, index: GLuint, buffer: GLuint, - offset: GLintptr, size: GLsizeiptr){.stdcall, importc, ogl.} -proc glBindBufferOffsetNV*(target: GLenum, index: GLuint, buffer: GLuint, - offset: GLintptr){.stdcall, importc, ogl.} -proc glBindBufferBaseNV*(target: GLenum, index: GLuint, buffer: GLuint){.stdcall, importc, ogl.} -proc glTransformFeedbackVaryingsNV*(prog: GLuint, count: GLsizei, - locations: PGLint, bufferMode: GLenum){. - stdcall, importc, ogl.} -proc glActiveVaryingNV*(prog: GLuint, name: PGLchar){.stdcall, importc, ogl.} -proc glGetVaryingLocationNV*(prog: GLuint, name: PGLchar): GLint{.stdcall, importc, ogl.} -proc glGetActiveVaryingNV*(prog: GLuint, index: GLuint, bufSize: GLsizei, - len: PGLsizei, size: PGLsizei, typ: PGLenum, - name: PGLchar){.stdcall, importc, ogl.} -proc glGetTransformFeedbackVaryingNV*(prog: GLuint, index: GLuint, - location: PGLint){.stdcall, importc, ogl.} -proc glTransformFeedbackStreamAttribsNV*(count: GLsizei, attribs: PGLint, - nbuffers: GLsizei, bufstreams: PGLint, bufferMode: GLenum){.stdcall, importc, ogl.} - # GL_NV_conditional_render -proc glBeginConditionalRenderNV*(id: GLuint, mode: GLenum){.stdcall, importc, ogl.} -proc glEndConditionalRenderNV*(){.stdcall, importc, ogl.} - # GL_NV_present_video -proc glPresentFrameKeyedNV*(video_slot: GLuint, minPresentTime: GLuint64EXT, - beginPresentTimeId: GLuint, - presentDuratioId: GLuint, typ: GLenum, - target0: GLenum, fill0: GLuint, key0: GLuint, - target1: GLenum, fill1: GLuint, key1: GLuint){. - stdcall, importc, ogl.} -proc glPresentFrameDualFillNV*(video_slot: GLuint, minPresentTime: GLuint64EXT, - beginPresentTimeId: GLuint, - presentDurationId: GLuint, typ: GLenum, - target0: GLenum, fill0: GLuint, target1: GLenum, - fill1: GLuint, target2: GLenum, fill2: GLuint, - target3: GLenum, fill3: GLuint){.stdcall, importc, ogl.} -proc glGetVideoivNV*(video_slot: GLuint, pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetVideouivNV*(video_slot: GLuint, pname: GLenum, params: PGLuint){. - stdcall, importc, ogl.} -proc glGetVideoi64vNV*(video_slot: GLuint, pname: GLenum, params: PGLint64EXT){. - stdcall, importc, ogl.} -proc glGetVideoui64vNV*(video_slot: GLuint, pname: GLenum, params: PGLuint64EXT){. - stdcall, importc, ogl.} - #procedure glVideoParameterivNV(video_slot: GLuint; pname: GLenum; const params: PGLint); stdcall, importc, ogl; - # GL_NV_explicit_multisample -proc glGetMultisamplefvNV*(pname: GLenum, index: GLuint, val: PGLfloat){.stdcall, importc, ogl.} -proc glSampleMaskIndexedNV*(index: GLuint, mask: GLbitfield){.stdcall, importc, ogl.} -proc glTexRenderbufferNV*(target: GLenum, renderbuffer: GLuint){.stdcall, importc, ogl.} - # GL_NV_transform_feedback2 -proc glBindTransformFeedbackNV*(target: GLenum, id: GLuint){.stdcall, importc, ogl.} -proc glDeleteTransformFeedbacksNV*(n: GLsizei, ids: PGLuint){.stdcall, importc, ogl.} -proc glGenTransformFeedbacksNV*(n: GLsizei, ids: PGLuint){.stdcall, importc, ogl.} -proc glIsTransformFeedbackNV*(id: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glPauseTransformFeedbackNV*(){.stdcall, importc, ogl.} -proc glResumeTransformFeedbackNV*(){.stdcall, importc, ogl.} -proc glDrawTransformFeedbackNV*(mode: GLenum, id: GLuint){.stdcall, importc, ogl.} - # GL_NV_video_capture -proc glBeginVideoCaptureNV*(video_capture_slot: GLuint){.stdcall, importc, ogl.} -proc glBindVideoCaptureStreamBufferNV*(video_capture_slot: GLuint, - stream: GLuint, frame_region: GLenum, - offset: GLintptrARB){.stdcall, importc, ogl.} -proc glBindVideoCaptureStreamTextureNV*(video_capture_slot: GLuint, - stream: GLuint, frame_region: GLenum, - target: GLenum, texture: GLuint){. - stdcall, importc, ogl.} -proc glEndVideoCaptureNV*(video_capture_slot: GLuint){.stdcall, importc, ogl.} -proc glGetVideoCaptureivNV*(video_capture_slot: GLuint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glGetVideoCaptureStreamivNV*(video_capture_slot: GLuint, stream: GLuint, - pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetVideoCaptureStreamfvNV*(video_capture_slot: GLuint, stream: GLuint, - pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetVideoCaptureStreamdvNV*(video_capture_slot: GLuint, stream: GLuint, - pname: GLenum, params: PGLdouble){.stdcall, importc, ogl.} -proc glVideoCaptureNV*(video_capture_slot: GLuint, sequence_num: PGLuint, - capture_time: PGLuint64EXT): GLenum{.stdcall, importc, ogl.} -proc glVideoCaptureStreamParameterivNV*(video_capture_slot: GLuint, - stream: GLuint, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} -proc glVideoCaptureStreamParameterfvNV*(video_capture_slot: GLuint, - stream: GLuint, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glVideoCaptureStreamParameterdvNV*(video_capture_slot: GLuint, - stream: GLuint, pname: GLenum, - params: PGLdouble){.stdcall, importc, ogl.} - # GL_NV_copy_image -proc glCopyImageSubDataNV*(srcName: GLuint, srcTarget: GLenum, srcLevel: GLint, - srcX: GLint, srcY: GLint, srcZ: GLint, - dstName: GLuint, dstTarget: GLenum, dstLevel: GLint, - dstX: GLint, dstY: GLint, dstZ: GLint, - width: GLsizei, height: GLsizei, depth: GLsizei){. - stdcall, importc, ogl.} - # GL_NV_shader_buffer_load -proc glMakeBufferResidentNV*(target: GLenum, access: GLenum){.stdcall, importc, ogl.} -proc glMakeBufferNonResidentNV*(target: GLenum){.stdcall, importc, ogl.} -proc glIsBufferResidentNV*(target: GLenum): GLboolean{.stdcall, importc, ogl.} -proc glMakeNamedBufferResidentNV*(buffer: GLuint, access: GLenum){.stdcall, importc, ogl.} -proc glMakeNamedBufferNonResidentNV*(buffer: GLuint){.stdcall, importc, ogl.} -proc glIsNamedBufferResidentNV*(buffer: GLuint): GLboolean{.stdcall, importc, ogl.} -proc glGetBufferParameterui64vNV*(target: GLenum, pname: GLenum, - params: PGLuint64EXT){.stdcall, importc, ogl.} -proc glGetNamedBufferParameterui64vNV*(buffer: GLuint, pname: GLenum, - params: PGLuint64EXT){.stdcall, importc, ogl.} -proc glGetIntegerui64vNV*(value: GLenum, result: PGLuint64EXT){.stdcall, importc, ogl.} -proc glUniformui64NV*(location: GLint, value: GLuint64EXT){.stdcall, importc, ogl.} -proc glUniformui64vNV*(location: GLint, count: GLsizei, value: PGLuint64EXT){. - stdcall, importc, ogl.} -proc glGetUniformui64vNV*(prog: GLuint, location: GLint, params: PGLuint64EXT){. - stdcall, importc, ogl.} -proc glProgramUniformui64NV*(prog: GLuint, location: GLint, value: GLuint64EXT){. - stdcall, importc, ogl.} -proc glProgramUniformui64vNV*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint64EXT){.stdcall, importc, ogl.} - # GL_NV_vertex_buffer_unified_memory -proc glBufferAddressRangeNV*(pname: GLenum, index: GLuint, adress: GLuint64EXT, - len: GLsizeiptr){.stdcall, importc, ogl.} -proc glVertexFormatNV*(size: GLint, typ: GLenum, stride: GLsizei){.stdcall, importc, ogl.} -proc glNormalFormatNV*(typ: GLenum, stride: GLsizei){.stdcall, importc, ogl.} -proc glColorFormatNV*(size: GLint, typ: GLenum, stride: GLsizei){.stdcall, importc, ogl.} -proc glIndexFormatNV*(typ: GLenum, stride: GLsizei){.stdcall, importc, ogl.} -proc glTexCoordFormatNV*(size: GLint, typ: GLenum, stride: GLsizei){.stdcall, importc, ogl.} -proc glEdgeFlagFormatNV*(stride: GLsizei){.stdcall, importc, ogl.} -proc glSecondaryColorFormatNV*(size: GLint, typ: GLenum, stride: GLsizei){. - stdcall, importc, ogl.} -proc glFogCoordFormatNV*(typ: GLenum, stride: GLsizei){.stdcall, importc, ogl.} -proc glVertexAttribFormatNV*(index: GLuint, size: GLint, typ: GLenum, - normalized: GLboolean, stride: GLsizei){.stdcall, importc, ogl.} -proc glVertexAttribIFormatNV*(index: GLuint, size: GLint, typ: GLenum, - stride: GLsizei){.stdcall, importc, ogl.} -proc glGetIntegerui64i_vNV*(value: GLenum, index: GLuint, Result: PGLuint64EXT){. - stdcall, importc, ogl.} - # GL_NV_gpu_program5 -proc glProgramSubroutineParametersuivNV*(target: GLenum, count: GLsizei, - params: PGLuint){.stdcall, importc, ogl.} -proc glGetProgramSubroutineParameteruivNV*(target: GLenum, index: GLuint, - param: PGLuint){.stdcall, importc, ogl.} - # GL_NV_gpu_shader5 -proc glUniform1i64NV*(location: GLint, x: GLint64EXT){.stdcall, importc, ogl.} -proc glUniform2i64NV*(location: GLint, x: GLint64EXT, y: GLint64EXT){.stdcall, importc, ogl.} -proc glUniform3i64NV*(location: GLint, x: GLint64EXT, y: GLint64EXT, - z: GLint64EXT){.stdcall, importc, ogl.} -proc glUniform4i64NV*(location: GLint, x: GLint64EXT, y: GLint64EXT, - z: GLint64EXT, w: GLint64EXT){.stdcall, importc, ogl.} -proc glUniform1i64vNV*(location: GLint, count: GLsizei, value: PGLint64EXT){. - stdcall, importc, ogl.} -proc glUniform2i64vNV*(location: GLint, count: GLsizei, value: PGLint64EXT){. - stdcall, importc, ogl.} -proc glUniform3i64vNV*(location: GLint, count: GLsizei, value: PGLint64EXT){. - stdcall, importc, ogl.} -proc glUniform4i64vNV*(location: GLint, count: GLsizei, value: PGLint64EXT){. - stdcall, importc, ogl.} -proc glUniform1ui64NV*(location: GLint, x: GLuint64EXT){.stdcall, importc, ogl.} -proc glUniform2ui64NV*(location: GLint, x: GLuint64EXT, y: GLuint64EXT){.stdcall, importc, ogl.} -proc glUniform3ui64NV*(location: GLint, x: GLuint64EXT, y: GLuint64EXT, - z: GLuint64EXT){.stdcall, importc, ogl.} -proc glUniform4ui64NV*(location: GLint, x: GLuint64EXT, y: GLuint64EXT, - z: GLuint64EXT, w: GLuint64EXT){.stdcall, importc, ogl.} -proc glUniform1ui64vNV*(location: GLint, count: GLsizei, value: PGLuint64EXT){. - stdcall, importc, ogl.} -proc glUniform2ui64vNV*(location: GLint, count: GLsizei, value: PGLuint64EXT){. - stdcall, importc, ogl.} -proc glUniform3ui64vNV*(location: GLint, count: GLsizei, value: PGLuint64EXT){. - stdcall, importc, ogl.} -proc glUniform4ui64vNV*(location: GLint, count: GLsizei, value: PGLuint64EXT){. - stdcall, importc, ogl.} -proc glGetUniformi64vNV*(prog: GLuint, location: GLint, params: PGLint64EXT){. - stdcall, importc, ogl.} -proc glProgramUniform1i64NV*(prog: GLuint, location: GLint, x: GLint64EXT){. - stdcall, importc, ogl.} -proc glProgramUniform2i64NV*(prog: GLuint, location: GLint, x: GLint64EXT, - y: GLint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform3i64NV*(prog: GLuint, location: GLint, x: GLint64EXT, - y: GLint64EXT, z: GLint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform4i64NV*(prog: GLuint, location: GLint, x: GLint64EXT, - y: GLint64EXT, z: GLint64EXT, w: GLint64EXT){. - stdcall, importc, ogl.} -proc glProgramUniform1i64vNV*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform2i64vNV*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform3i64vNV*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform4i64vNV*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform1ui64NV*(prog: GLuint, location: GLint, x: GLuint64EXT){. - stdcall, importc, ogl.} -proc glProgramUniform2ui64NV*(prog: GLuint, location: GLint, x: GLuint64EXT, - y: GLuint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform3ui64NV*(prog: GLuint, location: GLint, x: GLuint64EXT, - y: GLuint64EXT, z: GLuint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform4ui64NV*(prog: GLuint, location: GLint, x: GLuint64EXT, - y: GLuint64EXT, z: GLuint64EXT, w: GLuint64EXT){. - stdcall, importc, ogl.} -proc glProgramUniform1ui64vNV*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform2ui64vNV*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform3ui64vNV*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint64EXT){.stdcall, importc, ogl.} -proc glProgramUniform4ui64vNV*(prog: GLuint, location: GLint, count: GLsizei, - value: PGLuint64EXT){.stdcall, importc, ogl.} - # GL_NV_vertex_attrib_integer_64bit -proc glVertexAttribL1i64NV*(index: GLuint, x: GLint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL2i64NV*(index: GLuint, x: GLint64EXT, y: GLint64EXT){. - stdcall, importc, ogl.} -proc glVertexAttribL3i64NV*(index: GLuint, x: GLint64EXT, y: GLint64EXT, - z: GLint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL4i64NV*(index: GLuint, x: GLint64EXT, y: GLint64EXT, - z: GLint64EXT, w: GLint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL1i64vNV*(index: GLuint, v: PGLint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL2i64vNV*(index: GLuint, v: PGLint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL3i64vNV*(index: GLuint, v: PGLint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL4i64vNV*(index: GLuint, v: PGLint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL1ui64NV*(index: GLuint, x: GLuint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL2ui64NV*(index: GLuint, x: GLuint64EXT, y: GLuint64EXT){. - stdcall, importc, ogl.} -proc glVertexAttribL3ui64NV*(index: GLuint, x: GLuint64EXT, y: GLuint64EXT, - z: GLuint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL4ui64NV*(index: GLuint, x: GLuint64EXT, y: GLuint64EXT, - z: GLuint64EXT, w: GLuint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL1ui64vNV*(index: GLuint, v: PGLuint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL2ui64vNV*(index: GLuint, v: PGLuint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL3ui64vNV*(index: GLuint, v: PGLuint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribL4ui64vNV*(index: GLuint, v: PGLuint64EXT){.stdcall, importc, ogl.} -proc glGetVertexAttribLi64vNV*(index: GLuint, pname: GLenum, params: PGLint64EXT){. - stdcall, importc, ogl.} -proc glGetVertexAttribLui64vNV*(index: GLuint, pname: GLenum, - params: PGLuint64EXT){.stdcall, importc, ogl.} -proc glVertexAttribLFormatNV*(index: GLuint, size: GLint, typ: GLenum, - stride: GLsizei){.stdcall, importc, ogl.} - # GL_NV_vdpau_interop -proc glVDPAUInitNV*(vdpDevice: PGLvoid, getProcAddress: PGLvoid){.stdcall, importc, ogl.} -proc glVDPAUFiniNV*(){.stdcall, importc, ogl.} -proc glVDPAURegisterVideoSurfaceNV*(vdpSurface: PGLvoid, target: GLenum, - numTextureNames: GLsizei, - textureNames: PGLuint): GLvdpauSurfaceNV{. - stdcall, importc, ogl.} -proc glVDPAURegisterOutputSurfaceNV*(vdpSurface: PGLvoid, target: GLenum, - numTextureNames: GLsizei, - textureNames: PGLuint): GLvdpauSurfaceNV{. - stdcall, importc, ogl.} -proc glVDPAUIsSurfaceNV*(surface: GLvdpauSurfaceNV){.stdcall, importc, ogl.} -proc glVDPAUUnregisterSurfaceNV*(surface: GLvdpauSurfaceNV){.stdcall, importc, ogl.} -proc glVDPAUGetSurfaceivNV*(surface: GLvdpauSurfaceNV, pname: GLenum, - bufSize: GLsizei, len: PGLsizei, values: PGLint){. - stdcall, importc, ogl.} -proc glVDPAUSurfaceAccessNV*(surface: GLvdpauSurfaceNV, access: GLenum){.stdcall, importc, ogl.} -proc glVDPAUMapSurfacesNV*(numSurfaces: GLsizei, surfaces: PGLvdpauSurfaceNV){. - stdcall, importc, ogl.} -proc glVDPAUUnmapSurfacesNV*(numSurface: GLsizei, surfaces: PGLvdpauSurfaceNV){. - stdcall, importc, ogl.} - # GL_NV_texture_barrier -proc glTextureBarrierNV*(){.stdcall, importc, ogl.} - # GL_PGI_misc_hints -proc glHintPGI*(target: GLenum, mode: GLint){.stdcall, importc, ogl.} - # GL_SGIS_detail_texture -proc glDetailTexFuncSGIS*(target: GLenum, n: GLsizei, points: PGLfloat){.stdcall, importc, ogl.} -proc glGetDetailTexFuncSGIS*(target: GLenum, points: PGLfloat){.stdcall, importc, ogl.} - # GL_SGIS_fog_function -proc glFogFuncSGIS*(n: GLsizei, points: PGLfloat){.stdcall, importc, ogl.} -proc glGetFogFuncSGIS*(points: PGLfloat){.stdcall, importc, ogl.} - # GL_SGIS_multisample -proc glSampleMaskSGIS*(value: GLclampf, invert: GLboolean){.stdcall, importc, ogl.} -proc glSamplePatternSGIS*(pattern: GLenum){.stdcall, importc, ogl.} - # GL_SGIS_pixel_texture -proc glPixelTexGenParameteriSGIS*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glPixelTexGenParameterivSGIS*(pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glPixelTexGenParameterfSGIS*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glPixelTexGenParameterfvSGIS*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glGetPixelTexGenParameterivSGIS*(pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glGetPixelTexGenParameterfvSGIS*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} - # GL_SGIS_point_parameters -proc glPointParameterfSGIS*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glPointParameterfvSGIS*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} - # GL_SGIS_sharpen_texture -proc glSharpenTexFuncSGIS*(target: GLenum, n: GLsizei, points: PGLfloat){. - stdcall, importc, ogl.} -proc glGetSharpenTexFuncSGIS*(target: GLenum, points: PGLfloat){.stdcall, importc, ogl.} - # GL_SGIS_texture4D -proc glTexImage4DSGIS*(target: GLenum, level: GLint, internalformat: GLenum, - width: GLsizei, height: GLsizei, depth: GLsizei, - size4d: GLsizei, border: GLint, format: GLenum, - typ: GLenum, pixels: PGLvoid){.stdcall, importc, ogl.} -proc glTexSubImage4DSGIS*(target: GLenum, level: GLint, xoffset: GLint, - yoffset: GLint, zoffset: GLint, woffset: GLint, - width: GLsizei, height: GLsizei, depth: GLsizei, - size4d: GLsizei, format: GLenum, typ: GLenum, - pixels: PGLvoid){.stdcall, importc, ogl.} - # GL_SGIS_texture_color_mask -proc glTextureColorMaskSGIS*(red: GLboolean, green: GLboolean, blue: GLboolean, - alpha: GLboolean){.stdcall, importc, ogl.} - # GL_SGIS_texture_filter4 -proc glGetTexFilterFuncSGIS*(target: GLenum, filter: GLenum, weights: PGLfloat){. - stdcall, importc, ogl.} -proc glTexFilterFuncSGIS*(target: GLenum, filter: GLenum, n: GLsizei, - weights: PGLfloat){.stdcall, importc, ogl.} - # GL_SGIX_async -proc glAsyncMarkerSGIX*(marker: GLuint){.stdcall, importc, ogl.} -proc glFinishAsyncSGIX*(markerp: PGLuint): GLint{.stdcall, importc, ogl.} -proc glPollAsyncSGIX*(markerp: PGLuint): GLint{.stdcall, importc, ogl.} -proc glGenAsyncMarkersSGIX*(range: GLsizei): GLuint{.stdcall, importc, ogl.} -proc glDeleteAsyncMarkersSGIX*(marker: GLuint, range: GLsizei){.stdcall, importc, ogl.} -proc glIsAsyncMarkerSGIX*(marker: GLuint): GLboolean{.stdcall, importc, ogl.} - # GL_SGIX_flush_raster -proc glFlushRasterSGIX*(){.stdcall, importc, ogl.} - # GL_SGIX_fragment_lighting -proc glFragmentColorMaterialSGIX*(face: GLenum, mode: GLenum){.stdcall, importc, ogl.} -proc glFragmentLightfSGIX*(light: GLenum, pname: GLenum, param: GLfloat){. - stdcall, importc, ogl.} -proc glFragmentLightfvSGIX*(light: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glFragmentLightiSGIX*(light: GLenum, pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glFragmentLightivSGIX*(light: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glFragmentLightModelfSGIX*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glFragmentLightModelfvSGIX*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glFragmentLightModeliSGIX*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glFragmentLightModelivSGIX*(pname: GLenum, params: PGLint){.stdcall, importc, ogl.} -proc glFragmentMaterialfSGIX*(face: GLenum, pname: GLenum, param: GLfloat){. - stdcall, importc, ogl.} -proc glFragmentMaterialfvSGIX*(face: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glFragmentMaterialiSGIX*(face: GLenum, pname: GLenum, param: GLint){. - stdcall, importc, ogl.} -proc glFragmentMaterialivSGIX*(face: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetFragmentLightfvSGIX*(light: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetFragmentLightivSGIX*(light: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glGetFragmentMaterialfvSGIX*(face: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetFragmentMaterialivSGIX*(face: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glLightEnviSGIX*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} - # GL_SGIX_framezoom -proc glFrameZoomSGIX*(factor: GLint){.stdcall, importc, ogl.} - # GL_SGIX_igloo_interface -proc glIglooInterfaceSGIX*(pname: GLenum, params: PGLvoid){.stdcall, importc, ogl.} - # GL_SGIX_instruments -proc glGetInstrumentsSGIX*(): GLint{.stdcall, importc, ogl.} -proc glInstrumentsBufferSGIX*(size: GLsizei, buffer: PGLint){.stdcall, importc, ogl.} -proc glPollInstrumentsSGIX*(marker_p: PGLint): GLint{.stdcall, importc, ogl.} -proc glReadInstrumentsSGIX*(marker: GLint){.stdcall, importc, ogl.} -proc glStartInstrumentsSGIX*(){.stdcall, importc, ogl.} -proc glStopInstrumentsSGIX*(marker: GLint){.stdcall, importc, ogl.} - # GL_SGIX_list_priority -proc glGetListParameterfvSGIX*(list: GLuint, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glGetListParameterivSGIX*(list: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glListParameterfSGIX*(list: GLuint, pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glListParameterfvSGIX*(list: GLuint, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glListParameteriSGIX*(list: GLuint, pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glListParameterivSGIX*(list: GLuint, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} - # GL_SGIX_pixel_texture -proc glPixelTexGenSGIX*(mode: GLenum){.stdcall, importc, ogl.} - # GL_SGIX_polynomial_ffd -proc glDeformationMap3dSGIX*(target: GLenum, u1: GLdouble, u2: GLdouble, - ustride: GLint, uorder: GLint, v1: GLdouble, - v2: GLdouble, vstride: GLint, vorder: GLint, - w1: GLdouble, w2: GLdouble, wstride: GLint, - worder: GLint, points: PGLdouble){.stdcall, importc, ogl.} -proc glDeformationMap3fSGIX*(target: GLenum, u1: GLfloat, u2: GLfloat, - ustride: GLint, uorder: GLint, v1: GLfloat, - v2: GLfloat, vstride: GLint, vorder: GLint, - w1: GLfloat, w2: GLfloat, wstride: GLint, - worder: GLint, points: PGLfloat){.stdcall, importc, ogl.} -proc glDeformSGIX*(mask: GLbitfield){.stdcall, importc, ogl.} -proc glLoadIdentityDeformationMapSGIX*(mask: GLbitfield){.stdcall, importc, ogl.} - # GL_SGIX_reference_plane -proc glReferencePlaneSGIX*(equation: PGLdouble){.stdcall, importc, ogl.} - # GL_SGIX_sprite -proc glSpriteParameterfSGIX*(pname: GLenum, param: GLfloat){.stdcall, importc, ogl.} -proc glSpriteParameterfvSGIX*(pname: GLenum, params: PGLfloat){.stdcall, importc, ogl.} -proc glSpriteParameteriSGIX*(pname: GLenum, param: GLint){.stdcall, importc, ogl.} -proc glSpriteParameterivSGIX*(pname: GLenum, params: PGLint){.stdcall, importc, ogl.} - # GL_SGIX_tag_sample_buffer -proc glTagSampleBufferSGIX*(){.stdcall, importc, ogl.} - # GL_SGI_color_table -proc glColorTableSGI*(target: GLenum, internalformat: GLenum, width: GLsizei, - format: GLenum, typ: GLenum, table: PGLvoid){.stdcall, importc, ogl.} -proc glColorTableParameterfvSGI*(target: GLenum, pname: GLenum, params: PGLfloat){. - stdcall, importc, ogl.} -proc glColorTableParameterivSGI*(target: GLenum, pname: GLenum, params: PGLint){. - stdcall, importc, ogl.} -proc glCopyColorTableSGI*(target: GLenum, internalformat: GLenum, x: GLint, - y: GLint, width: GLsizei){.stdcall, importc, ogl.} -proc glGetColorTableSGI*(target: GLenum, format: GLenum, typ: GLenum, - table: PGLvoid){.stdcall, importc, ogl.} -proc glGetColorTableParameterfvSGI*(target: GLenum, pname: GLenum, - params: PGLfloat){.stdcall, importc, ogl.} -proc glGetColorTableParameterivSGI*(target: GLenum, pname: GLenum, - params: PGLint){.stdcall, importc, ogl.} - # GL_SUNX_constant_data -proc glFinishTextureSUNX*(){.stdcall, importc, ogl.} - # GL_SUN_global_alpha -proc glGlobalAlphaFactorbSUN*(factor: GLbyte){.stdcall, importc, ogl.} -proc glGlobalAlphaFactorsSUN*(factor: GLshort){.stdcall, importc, ogl.} -proc glGlobalAlphaFactoriSUN*(factor: GLint){.stdcall, importc, ogl.} -proc glGlobalAlphaFactorfSUN*(factor: GLfloat){.stdcall, importc, ogl.} -proc glGlobalAlphaFactordSUN*(factor: GLdouble){.stdcall, importc, ogl.} -proc glGlobalAlphaFactorubSUN*(factor: GLubyte){.stdcall, importc, ogl.} -proc glGlobalAlphaFactorusSUN*(factor: GLushort){.stdcall, importc, ogl.} -proc glGlobalAlphaFactoruiSUN*(factor: GLuint){.stdcall, importc, ogl.} - # GL_SUN_mesh_array -proc glDrawMeshArraysSUN*(mode: GLenum, first: GLint, count: GLsizei, - width: GLsizei){.stdcall, importc, ogl.} - # GL_SUN_triangle_list -proc glReplacementCodeuiSUN*(code: GLuint){.stdcall, importc, ogl.} -proc glReplacementCodeusSUN*(code: GLushort){.stdcall, importc, ogl.} -proc glReplacementCodeubSUN*(code: GLubyte){.stdcall, importc, ogl.} -proc glReplacementCodeuivSUN*(code: PGLuint){.stdcall, importc, ogl.} -proc glReplacementCodeusvSUN*(code: PGLushort){.stdcall, importc, ogl.} -proc glReplacementCodeubvSUN*(code: PGLubyte){.stdcall, importc, ogl.} -proc glReplacementCodePointerSUN*(typ: GLenum, stride: GLsizei, pointer: PGLvoid){. - stdcall, importc, ogl.} - # GL_SUN_vertex -proc glColor4ubVertex2fSUN*(r: GLubyte, g: GLubyte, b: GLubyte, a: GLubyte, - x: GLfloat, y: GLfloat){.stdcall, importc, ogl.} -proc glColor4ubVertex2fvSUN*(c: PGLubyte, v: PGLfloat){.stdcall, importc, ogl.} -proc glColor4ubVertex3fSUN*(r: GLubyte, g: GLubyte, b: GLubyte, a: GLubyte, - x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glColor4ubVertex3fvSUN*(c: PGLubyte, v: PGLfloat){.stdcall, importc, ogl.} -proc glColor3fVertex3fSUN*(r: GLfloat, g: GLfloat, b: GLfloat, x: GLfloat, - y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glColor3fVertex3fvSUN*(c: PGLfloat, v: PGLfloat){.stdcall, importc, ogl.} -proc glNormal3fVertex3fSUN*(nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, - y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glNormal3fVertex3fvSUN*(n: PGLfloat, v: PGLfloat){.stdcall, importc, ogl.} -proc glColor4fNormal3fVertex3fSUN*(r: GLfloat, g: GLfloat, b: GLfloat, - a: GLfloat, nx: GLfloat, ny: GLfloat, - nz: GLfloat, x: GLfloat, y: GLfloat, - z: GLfloat){.stdcall, importc, ogl.} -proc glColor4fNormal3fVertex3fvSUN*(c: PGLfloat, n: PGLfloat, v: PGLfloat){. - stdcall, importc, ogl.} -proc glTexCoord2fVertex3fSUN*(s: GLfloat, t: GLfloat, x: GLfloat, y: GLfloat, - z: GLfloat){.stdcall, importc, ogl.} -proc glTexCoord2fVertex3fvSUN*(tc: PGLfloat, v: PGLfloat){.stdcall, importc, ogl.} -proc glTexCoord4fVertex4fSUN*(s: GLfloat, t: GLfloat, p: GLfloat, q: GLfloat, - x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat){. - stdcall, importc, ogl.} -proc glTexCoord4fVertex4fvSUN*(tc: PGLfloat, v: PGLfloat){.stdcall, importc, ogl.} -proc glTexCoord2fColor4ubVertex3fSUN*(s: GLfloat, t: GLfloat, r: GLubyte, - g: GLubyte, b: GLubyte, a: GLubyte, - x: GLfloat, y: GLfloat, z: GLfloat){. - stdcall, importc, ogl.} -proc glTexCoord2fColor4ubVertex3fvSUN*(tc: PGLfloat, c: PGLubyte, v: PGLfloat){. - stdcall, importc, ogl.} -proc glTexCoord2fColor3fVertex3fSUN*(s: GLfloat, t: GLfloat, r: GLfloat, - g: GLfloat, b: GLfloat, x: GLfloat, - y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glTexCoord2fColor3fVertex3fvSUN*(tc: PGLfloat, c: PGLfloat, v: PGLfloat){. - stdcall, importc, ogl.} -proc glTexCoord2fNormal3fVertex3fSUN*(s: GLfloat, t: GLfloat, nx: GLfloat, - ny: GLfloat, nz: GLfloat, x: GLfloat, - y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glTexCoord2fNormal3fVertex3fvSUN*(tc: PGLfloat, n: PGLfloat, v: PGLfloat){. - stdcall, importc, ogl.} -proc glTexCoord2fColor4fNormal3fVertex3fSUN*(s: GLfloat, t: GLfloat, r: GLfloat, - g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, - x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glTexCoord2fColor4fNormal3fVertex3fvSUN*(tc: PGLfloat, c: PGLfloat, - n: PGLfloat, v: PGLfloat){.stdcall, importc, ogl.} -proc glTexCoord4fColor4fNormal3fVertex4fSUN*(s: GLfloat, t: GLfloat, p: GLfloat, - q: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, - ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat){. - stdcall, importc, ogl.} -proc glTexCoord4fColor4fNormal3fVertex4fvSUN*(tc: PGLfloat, c: PGLfloat, - n: PGLfloat, v: PGLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiVertex3fSUN*(rc: GLuint, x: GLfloat, y: GLfloat, - z: GLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiVertex3fvSUN*(rc: PGLuint, v: PGLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiColor4ubVertex3fSUN*(rc: GLuint, r: GLubyte, g: GLubyte, - b: GLubyte, a: GLubyte, x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiColor4ubVertex3fvSUN*(rc: PGLuint, c: PGLubyte, - v: PGLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiColor3fVertex3fSUN*(rc: GLuint, r: GLfloat, g: GLfloat, - b: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiColor3fVertex3fvSUN*(rc: PGLuint, c: PGLfloat, - v: PGLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiNormal3fVertex3fSUN*(rc: GLuint, nx: GLfloat, - ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiNormal3fVertex3fvSUN*(rc: PGLuint, n: PGLfloat, - v: PGLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiColor4fNormal3fVertex3fSUN*(rc: GLuint, r: GLfloat, - g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, - x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiColor4fNormal3fVertex3fvSUN*(rc: PGLuint, c: PGLfloat, - n: PGLfloat, v: PGLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiTexCoord2fVertex3fSUN*(rc: GLuint, s: GLfloat, - t: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiTexCoord2fVertex3fvSUN*(rc: PGLuint, tc: PGLfloat, - v: PGLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN*(rc: GLuint, s: GLfloat, - t: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, - z: GLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN*(rc: PGLuint, - tc: PGLfloat, n: PGLfloat, v: PGLfloat){.stdcall, importc, ogl.} -proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN*(rc: GLuint, - s: GLfloat, t: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, - nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat){. - stdcall, importc, ogl.} -proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN*(rc: PGLuint, - tc: PGLfloat, c: PGLfloat, n: PGLfloat, v: PGLfloat){.stdcall, importc, ogl.} - # window support functions -when defined(windows): - when not defined(wglGetProcAddress): - proc wglGetProcAddress*(ProcName: cstring): Pointer{.stdcall, importc, wgl.} - proc wglCopyContext*(p1: HGLRC, p2: HGLRC, p3: int): BOOL{.stdcall, importc, wgl.} - proc wglCreateContext*(DC: HDC): HGLRC{.stdcall, importc, wgl.} - proc wglCreateLayerContext*(p1: HDC, p2: int): HGLRC{.stdcall, importc, wgl.} - proc wglDeleteContext*(p1: HGLRC): BOOL{.stdcall, importc, wgl.} - proc wglDescribeLayerPlane*(p1: HDC, p2, p3: int, p4: int, - LayerPlaneDescriptor: pointer): BOOL{.stdcall, importc, wgl.} - proc wglGetCurrentContext*(): HGLRC{.stdcall, importc, wgl.} - proc wglGetCurrentDC*(): HDC{.stdcall, importc, wgl.} - proc wglGetLayerPaletteEntries*(p1: HDC, p2, p3, p4: int, pcr: pointer): int{. - stdcall, importc, wgl.} - proc wglMakeCurrent*(DC: HDC, p2: HGLRC): BOOL{.stdcall, importc, wgl.} - proc wglRealizeLayerPalette*(p1: HDC, p2: int, p3: BOOL): BOOL{.stdcall, importc, wgl.} - proc wglSetLayerPaletteEntries*(p1: HDC, p2, p3, p4: int, pcr: pointer): int{. - stdcall, importc, wgl.} - proc wglShareLists*(p1, p2: HGLRC): BOOL{.stdcall, importc, wgl.} - proc wglSwapLayerBuffers*(p1: HDC, p2: int): BOOL{.stdcall, importc, wgl.} - proc wglSwapMultipleBuffers*(p1: int32, p2: PWGLSWAP): int32{.stdcall, importc, wgl.} - proc wglUseFontBitmapsA*(DC: HDC, p2, p3, p4: int32): BOOL{.stdcall, importc, wgl.} - proc wglUseFontBitmapsW*(DC: HDC, p2, p3, p4: int32): BOOL{.stdcall, importc, wgl.} - proc wglUseFontBitmaps*(DC: HDC, p2, p3, p4: int32): BOOL{.stdcall, importc, wgl.} - proc wglUseFontOutlinesA*(p1: HDC, p2, p3, p4: int32, p5, p6: float32, - p7: int, GlyphMetricsFloat: pointer): BOOL{.stdcall, importc, wgl.} - proc wglUseFontOutlinesW*(p1: HDC, p2, p3, p4: int32, p5, p6: float32, - p7: int, GlyphMetricsFloat: pointer): BOOL{.stdcall, importc, wgl.} - proc wglUseFontOutlines*(p1: HDC, p2, p3, p4: int32, p5, p6: float32, p7: int, - GlyphMetricsFloat: pointer): BOOL{.stdcall, importc, wgl.} - # WGL_ARB_buffer_region - proc wglCreateBufferRegionARB*(hDC: HDC, iLayerPlane: GLint, uType: GLuint): THandle{. - stdcall, importc, wgl.} - proc wglDeleteBufferRegionARB*(hRegion: THandle){.stdcall, importc, wgl.} - proc wglSaveBufferRegionARB*(hRegion: THandle, x: GLint, y: GLint, - width: GLint, height: GLint): bool{.stdcall, importc, wgl.} - proc wglRestoreBufferRegionARB*(hRegion: THandle, x: GLint, y: GLint, - width: GLint, height: GLint, xSrc: GLint, - ySrc: GLint): bool{.stdcall, importc, wgl.} - # WGL_ARB_extensions_string - proc wglGetExtensionsStringARB*(hdc: HDC): cstring{.stdcall, importc, wgl.} - # WGL_ARB_make_current_read - proc wglMakeContextCurrentARB*(hDrawDC: HDC, hReadDC: HDC, hglrc: HGLRC): bool{. - stdcall, importc, wgl.} - proc wglGetCurrentReadDCARB*(): HDC{.stdcall, importc, wgl.} - # WGL_ARB_pbuffer - proc wglCreatePbufferARB*(hDC: HDC, iPixelFormat: GLint, iWidth: GLint, - iHeight: GLint, piAttribList: PGLint): HPBUFFERARB{. - stdcall, importc, wgl.} - proc wglGetPbufferDCARB*(hPbuffer: HPBUFFERARB): HDC{.stdcall, importc, wgl.} - proc wglReleasePbufferDCARB*(hPbuffer: HPBUFFERARB, hDC: HDC): GLint{.stdcall, importc, wgl.} - proc wglDestroyPbufferARB*(hPbuffer: HPBUFFERARB): bool{.stdcall, importc, wgl.} - proc wglQueryPbufferARB*(hPbuffer: HPBUFFERARB, iAttribute: GLint, - piValue: PGLint): bool{.stdcall, importc, wgl.} - # WGL_ARB_pixel_format - proc wglGetPixelFormatAttribivARB*(hdc: HDC, iPixelFormat: GLint, - iLayerPlane: GLint, nAttributes: GLuint, - piAttributes: PGLint, piValues: PGLint): bool{. - stdcall, importc, wgl.} - proc wglGetPixelFormatAttribfvARB*(hdc: HDC, iPixelFormat: GLint, - iLayerPlane: GLint, nAttributes: GLuint, - piAttributes: PGLint, pfValues: PGLfloat): bool{. - stdcall, importc, wgl.} - proc wglChoosePixelFormatARB*(hdc: HDC, piAttribIList: PGLint, - pfAttribFList: PGLfloat, nMaxFormats: GLuint, - piFormats: PGLint, nNumFormats: PGLuint): BOOL{. - stdcall, importc, wgl.} - # WGL_ARB_color_buffer_float - proc wglClampColorARB*(target: GLenum, clamp: GLenum){.stdcall, importc, wgl.} - # WGL_ARB_render_texture - proc wglBindTexImageARB*(hPbuffer: HPBUFFERARB, iBuffer: GLint): bool{.stdcall, importc, wgl.} - proc wglReleaseTexImageARB*(hPbuffer: HPBUFFERARB, iBuffer: GLint): bool{. - stdcall, importc, wgl.} - proc wglSetPbufferAttribARB*(hPbuffer: HPBUFFERARB, piAttribList: PGLint): bool{. - stdcall, importc, wgl.} - # WGL_ARB_create_context - proc wglCreateContextAttribsARB*(hDC: HDC, hShareContext: HGLRC, - attribList: PGLint): HGLRC{.stdcall, importc, wgl.} - # WGL_AMD_gpu_association - proc wglGetGPUIDsAMD*(maxCount: int, ids: ptr int): int{.stdcall, importc, wgl.} - proc wglGetGPUInfoAMD*(id: int, prop: int, dataType: GLenum, size: int, - data: Pointer): int{.stdcall, importc, wgl.} - proc wglGetContextGPUIDAMD*(hglrc: HGLRC): int{.stdcall, importc, wgl.} - proc wglCreateAssociatedContextAMD*(id: int): HGLRC{.stdcall, importc, wgl.} - proc wglCreateAssociatedContextAttribsAMD*(id: int, hShareContext: HGLRC, - attribList: ptr int32): HGLRC{.stdcall, importc, wgl.} - proc wglDeleteAssociatedContextAMD*(hglrc: HGLRC): bool{.stdcall, importc, wgl.} - proc wglMakeAssociatedContextCurrentAMD*(hglrc: HGLRC): bool{.stdcall, importc, wgl.} - proc wglGetCurrentAssociatedContextAMD*(): HGLRC{.stdcall, importc, wgl.} - proc wglBlitContextFramebufferAMD*(dstCtx: HGLRC, srcX0: GLint, srcY0: GLint, - srcX1: GLint, srcY1: GLint, dstX0: GLint, - dstY0: GLint, dstX1: GLint, dstY1: GLint, - mask: GLbitfield, filter: GLenum){.stdcall, importc, wgl.} - # WGL_EXT_display_color_table - proc wglCreateDisplayColorTableEXT*(id: GLushort): GLboolean{.stdcall, importc, wgl.} - proc wglLoadDisplayColorTableEXT*(table: PGLushort, len: GLuint): GLboolean{. - stdcall, importc, wgl.} - proc wglBindDisplayColorTableEXT*(id: GLushort): GLboolean{.stdcall, importc, wgl.} - proc wglDestroyDisplayColorTableEXT*(id: GLushort){.stdcall, importc, wgl.} - # WGL_EXT_extensions_string - proc wglGetExtensionsStringEXT*(): cstring{.stdcall, importc, wgl.} - # WGL_EXT_make_current_read - proc wglMakeContextCurrentEXT*(hDrawDC: HDC, hReadDC: HDC, hglrc: HGLRC): bool{. - stdcall, importc, wgl.} - proc wglGetCurrentReadDCEXT*(): HDC{.stdcall, importc, wgl.} - # WGL_EXT_pbuffer - proc wglCreatePbufferEXT*(hDC: HDC, iPixelFormat: GLint, iWidth: GLint, - iHeight: GLint, piAttribList: PGLint): HPBUFFEREXT{. - stdcall, importc, wgl.} - proc wglGetPbufferDCEXT*(hPbuffer: HPBUFFEREXT): HDC{.stdcall, importc, wgl.} - proc wglReleasePbufferDCEXT*(hPbuffer: HPBUFFEREXT, hDC: HDC): GLint{.stdcall, importc, wgl.} - proc wglDestroyPbufferEXT*(hPbuffer: HPBUFFEREXT): bool{.stdcall, importc, wgl.} - proc wglQueryPbufferEXT*(hPbuffer: HPBUFFEREXT, iAttribute: GLint, - piValue: PGLint): bool{.stdcall, importc, wgl.} - # WGL_EXT_pixel_format - proc wglGetPixelFormatAttribivEXT*(hdc: HDC, iPixelFormat: GLint, - iLayerPlane: GLint, nAttributes: GLuint, - piAttributes: PGLint, piValues: PGLint): bool{. - stdcall, importc, wgl.} - proc wglGetPixelFormatAttribfvEXT*(hdc: HDC, iPixelFormat: GLint, - iLayerPlane: GLint, nAttributes: GLuint, - piAttributes: PGLint, pfValues: PGLfloat): bool{. - stdcall, importc, wgl.} - proc wglChoosePixelFormatEXT*(hdc: HDC, piAttribIList: PGLint, - pfAttribFList: PGLfloat, nMaxFormats: GLuint, - piFormats: PGLint, nNumFormats: PGLuint): bool{. - stdcall, importc, wgl.} - # WGL_EXT_swap_control - proc wglSwapIntervalEXT*(interval: GLint): bool{.stdcall, importc, wgl.} - proc wglGetSwapIntervalEXT*(): GLint{.stdcall, importc, wgl.} - # WGL_I3D_digital_video_control - proc wglGetDigitalVideoParametersI3D*(hDC: HDC, iAttribute: GLint, - piValue: PGLint): bool{.stdcall, importc, wgl.} - proc wglSetDigitalVideoParametersI3D*(hDC: HDC, iAttribute: GLint, - piValue: PGLint): bool{.stdcall, importc, wgl.} - # WGL_I3D_gamma - proc wglGetGammaTableParametersI3D*(hDC: HDC, iAttribute: GLint, - piValue: PGLint): bool{.stdcall, importc, wgl.} - proc wglSetGammaTableParametersI3D*(hDC: HDC, iAttribute: GLint, - piValue: PGLint): bool{.stdcall, importc, wgl.} - proc wglGetGammaTableI3D*(hDC: HDC, iEntries: GLint, puRed: PGLushort, - puGreen: PGLushort, puBlue: PGLushort): bool{. - stdcall, importc, wgl.} - proc wglSetGammaTableI3D*(hDC: HDC, iEntries: GLint, puRed: PGLushort, - puGreen: PGLushort, puBlue: PGLushort): bool{. - stdcall, importc, wgl.} - # WGL_I3D_genlock - proc wglEnableGenlockI3D*(hDC: HDC): bool{.stdcall, importc, wgl.} - proc wglDisableGenlockI3D*(hDC: HDC): bool{.stdcall, importc, wgl.} - proc wglIsEnabledGenlockI3D*(hDC: HDC, pFlag: bool): bool{.stdcall, importc, wgl.} - proc wglGenlockSourceI3D*(hDC: HDC, uSource: GLuint): bool{.stdcall, importc, wgl.} - proc wglGetGenlockSourceI3D*(hDC: HDC, uSource: PGLuint): bool{.stdcall, importc, wgl.} - proc wglGenlockSourceEdgeI3D*(hDC: HDC, uEdge: GLuint): bool{.stdcall, importc, wgl.} - proc wglGetGenlockSourceEdgeI3D*(hDC: HDC, uEdge: PGLuint): bool{.stdcall, importc, wgl.} - proc wglGenlockSampleRateI3D*(hDC: HDC, uRate: GLuint): bool{.stdcall, importc, wgl.} - proc wglGetGenlockSampleRateI3D*(hDC: HDC, uRate: PGLuint): bool{.stdcall, importc, wgl.} - proc wglGenlockSourceDelayI3D*(hDC: HDC, uDelay: GLuint): bool{.stdcall, importc, wgl.} - proc wglGetGenlockSourceDelayI3D*(hDC: HDC, uDelay: PGLuint): bool{.stdcall, importc, wgl.} - proc wglQueryGenlockMaxSourceDelayI3D*(hDC: HDC, uMaxLineDelay: PGLuint, - uMaxPixelDelay: PGLuint): bool{.stdcall, importc, wgl.} - # WGL_I3D_image_buffer - proc wglCreateImageBufferI3D*(hDC: HDC, dwSize: GLuint, uFlags: GLuint): GLvoid{. - stdcall, importc, wgl.} - proc wglDestroyImageBufferI3D*(hDC: HDC, pAddress: GLvoid): bool{.stdcall, importc, wgl.} - proc wglAssociateImageBufferEventsI3D*(hDC: HDC, pEvent: THandle, - pAddress: PGLvoid, pSize: PGLuint, count: GLuint): bool{.stdcall, importc, wgl.} - proc wglReleaseImageBufferEventsI3D*(hDC: HDC, pAddress: PGLvoid, - count: GLuint): bool{.stdcall, importc, wgl.} - # WGL_I3D_swap_frame_lock - proc wglEnableFrameLockI3D*(): bool{.stdcall, importc, wgl.} - proc wglDisableFrameLockI3D*(): bool{.stdcall, importc, wgl.} - proc wglIsEnabledFrameLockI3D*(pFlag: bool): bool{.stdcall, importc, wgl.} - proc wglQueryFrameLockMasterI3D*(pFlag: bool): bool{.stdcall, importc, wgl.} - # WGL_I3D_swap_frame_usage - proc wglGetFrameUsageI3D*(pUsage: PGLfloat): bool{.stdcall, importc, wgl.} - proc wglBeginFrameTrackingI3D*(): bool{.stdcall, importc, wgl.} - proc wglEndFrameTrackingI3D*(): bool{.stdcall, importc, wgl.} - proc wglQueryFrameTrackingI3D*(pFrameCount: PGLuint, pMissedFrames: PGLuint, - pLastMissedUsage: PGLfloat): bool{.stdcall, importc, wgl.} - # WGL_NV_vertex_array_range - proc wglAllocateMemoryNV*(size: GLsizei, readfreq: GLfloat, - writefreq: GLfloat, priority: GLfloat){.stdcall, importc, wgl.} - proc wglFreeMemoryNV*(pointer: Pointer){.stdcall, importc, wgl.} - # WGL_NV_present_video - proc wglEnumerateVideoDevicesNV*(hdc: HDC, phDeviceList: PHVIDEOOUTPUTDEVICENV): int{. - stdcall, importc, wgl.} - proc wglBindVideoDeviceNV*(hd: HDC, uVideoSlot: int, - hVideoDevice: HVIDEOOUTPUTDEVICENV, - piAttribList: ptr int32): bool{.stdcall, importc, wgl.} - proc wglQueryCurrentContextNV*(iAttribute: int, piValue: ptr int32): bool{. - stdcall, importc, wgl.} - # WGL_NV_video_output - proc wglGetVideoDeviceNV*(hDC: HDC, numDevices: int, hVideoDevice: PHPVIDEODEV): bool{. - stdcall, importc, wgl.} - proc wglReleaseVideoDeviceNV*(hVideoDevice: HPVIDEODEV): bool{.stdcall, importc, wgl.} - proc wglBindVideoImageNV*(hVideoDevice: HPVIDEODEV, hPbuffer: HPBUFFERARB, - iVideoBuffer: int): bool{.stdcall, importc, wgl.} - proc wglReleaseVideoImageNV*(hPbuffer: HPBUFFERARB, iVideoBuffer: int): bool{. - stdcall, importc, wgl.} - proc wglSendPbufferToVideoNV*(hPbuffer: HPBUFFERARB, iBufferType: int, - pulCounterPbuffer: ptr int, bBlock: bool): bool{. - stdcall, importc, wgl.} - proc wglGetVideoInfoNV*(hpVideoDevice: HPVIDEODEV, - pulCounterOutputPbuffer: ptr int, - pulCounterOutputVideo: ptr int): bool{.stdcall, importc, wgl.} - # WGL_NV_swap_group - proc wglJoinSwapGroupNV*(hDC: HDC, group: GLuint): bool{.stdcall, importc, wgl.} - proc wglBindSwapBarrierNV*(group: GLuint, barrier: GLuint): bool{.stdcall, importc, wgl.} - proc wglQuerySwapGroupNV*(hDC: HDC, group: PGLuint, barrier: PGLuint): bool{. - stdcall, importc, wgl.} - proc wglQueryMaxSwapGroupsNV*(hDC: HDC, mxGroups: PGLuint, - maxBarriers: PGLuint): bool{.stdcall, importc, wgl.} - proc wglQueryFrameCountNV*(hDC: HDC, count: PGLuint): bool{.stdcall, importc, wgl.} - proc wglResetFrameCountNV*(hDC: HDC): bool{.stdcall, importc, wgl.} - # WGL_NV_gpu_affinity - proc wglEnumGpusNV*(iGpuIndex: int, phGpu: PHGPUNV): bool{.stdcall, importc, wgl.} - proc wglEnumGpuDevicesNV*(hGpu: HGPUNV, iDeviceIndex: int, - lpGpuDevice: PGPU_DEVICE): bool{.stdcall, importc, wgl.} - proc wglCreateAffinityDCNV*(phGpuList: PHGPUNV): HDC{.stdcall, importc, wgl.} - proc wglEnumGpusFromAffinityDCNV*(hAffinityDC: HDC, iGpuIndex: int, - hGpu: PHGPUNV): bool{.stdcall, importc, wgl.} - proc wglDeleteDCNV*(hDC: HDC): bool{.stdcall, importc, wgl.} - # WGL_NV_video_capture - proc wglBindVideoCaptureDeviceNV*(uVideoSlot: int, - hDevice: HVIDEOINPUTDEVICENV): bool{.stdcall, importc, wgl.} - proc wglEnumerateVideoCaptureDevicesNV*(hDc: HDC, - phDeviceList: PHVIDEOINPUTDEVICENV): int{.stdcall, importc, wgl.} - proc wglLockVideoCaptureDeviceNV*(hDc: HDC, hDevice: HVIDEOINPUTDEVICENV): bool{. - stdcall, importc, wgl.} - proc wglQueryVideoCaptureDeviceNV*(hDc: HDC, hDevice: HVIDEOINPUTDEVICENV, - iAttribute: int, piValue: ptr int32): bool{. - stdcall, importc, wgl.} - proc wglReleaseVideoCaptureDeviceNV*(hDc: HDC, hDevice: HVIDEOINPUTDEVICENV): bool{. - stdcall, importc, wgl.} - # WGL_NV_copy_image - proc wglCopyImageSubDataNV*(hSrcRc: HGLRC, srcName: GLuint, srcTarget: GLenum, - srcLevel: GLint, srcX: GLint, srcY: GLint, - srcZ: GLint, hDstRC: HGLRC, dstName: GLuint, - dstTarget: GLenum, dstLevel: GLint, dstX: GLint, - dstY: GLint, dstZ: GLint, width: GLsizei, - height: GLsizei, depth: GLsizei): bool{.stdcall, importc, wgl.} - # WGL_NV_DX_interop - proc wglDXSetResourceShareHandleNV*(dxObject: PGLVoid, hareHandle: int): bool{. - stdcall, importc, wgl.} - proc wglDXOpenDeviceNV*(dxDevice: PGLVoid): int{.stdcall, importc, wgl.} - proc wglDXCloseDeviceNV*(hDevice: int): bool{.stdcall, importc, wgl.} - proc wglDXRegisterObjectNV*(hDevice: int, dxObject: PGLVoid, name: GLUInt, - typ: TGLEnum, access: TGLenum): int{.stdcall, importc, wgl.} - proc wglDXUnregisterObjectNV*(hDevice: int, hObject: int): bool{.stdcall, importc, wgl.} - proc wglDXObjectAccessNV*(hObject: int, access: GLenum): bool{.stdcall, importc, wgl.} - proc wglDXLockObjectsNV*(hDevice: int, count: GLint, hObjects: ptr int): bool{. - stdcall, importc, wgl.} - proc wglDXUnlockObjectsNV*(hDevice: int, count: GLint, hObjects: ptr int): bool{. - stdcall, importc, wgl.} - # WGL_OML_sync_control - proc wglGetSyncValuesOML*(hdc: HDC, ust: PGLint64, msc: PGLint64, - sbc: PGLint64): bool{.stdcall, importc, wgl.} - proc wglGetMscRateOML*(hdc: HDC, numerator: PGLint, denominator: PGLint): bool{. - stdcall, importc, wgl.} - proc wglSwapBuffersMscOML*(hdc: HDC, target_msc: GLint64, divisor: GLint64, - remainder: GLint64): GLint64{.stdcall, importc, wgl.} - proc wglSwapLayerBuffersMscOML*(hdc: HDC, fuPlanes: GLint, - target_msc: GLint64, divisor: GLint64, - remainder: GLint64): GLint64{.stdcall, importc, wgl.} - proc wglWaitForMscOML*(hdc: HDC, target_msc: GLint64, divisor: GLint64, - remainder: GLint64, ust: PGLint64, msc: PGLint64, - sbc: PGLint64): bool{.stdcall, importc, wgl.} - proc wglWaitForSbcOML*(hdc: HDC, target_sbc: GLint64, ust: PGLint64, - msc: PGLint64, sbc: PGLint64): bool{.stdcall, importc, wgl.} - # WGL_3DL_stereo_control - proc wglSetStereoEmitterState3DL*(hDC: HDC, uState: int32): bool{.stdcall, importc, wgl.} - # WIN_draw_range_elements - proc glDrawRangeElementsWIN*(mode: GLenum, start: GLuint, ending: GLuint, - count: GLsizei, typ: GLenum, indices: PGLvoid){. - stdcall, importc, wgl.} - # WIN_swap_hint - proc glAddSwapHintRectWIN*(x: GLint, y: GLint, width: GLsizei, height: GLsizei){. - stdcall, importc, wgl.} -when defined(LINUX): - proc glXChooseVisual*(dpy: PDisplay, screen: GLint, attribList: PGLint): PXVisualInfo{. - stdcall, importc, oglx.} - proc glXCopyContext*(dpy: PDisplay, src: GLXContext, dst: GLXContext, - mask: GLuint){.stdcall, importc, oglx.} - proc glXCreateContext*(dpy: PDisplay, vis: PXVisualInfo, - shareList: GLXContext, direct: GLboolean): GLXContext{. - stdcall, importc, oglx.} - proc glXCreateGLXPixmap*(dpy: PDisplay, vis: PXVisualInfo, pixmap: Pixmap): GLXPixmap{. - stdcall, importc, oglx.} - proc glXDestroyContext*(dpy: PDisplay, ctx: GLXContext){.stdcall, importc, oglx.} - proc glXDestroyGLXPixmap*(dpy: PDisplay, pix: GLXPixmap){.stdcall, importc, oglx.} - proc glXGetConfig*(dpy: PDisplay, vis: PXVisualInfo, attrib: GLint, - value: PGLint): GLint{.stdcall, importc, oglx.} - proc glXGetCurrentContext*(): GLXContext{.stdcall, importc, oglx.} - proc glXGetCurrentDrawable*(): GLXDrawable{.stdcall, importc, oglx.} - proc glXIsDirect*(dpy: PDisplay, ctx: GLXContext): glboolean{.stdcall, importc, oglx.} - proc glXMakeCurrent*(dpy: PDisplay, drawable: GLXDrawable, ctx: GLXContext): GLboolean{. - stdcall, importc, oglx.} - proc glXQueryExtension*(dpy: PDisplay, errorBase: PGLint, eventBase: PGLint): GLboolean{. - stdcall, importc, oglx.} - proc glXQueryVersion*(dpy: PDisplay, major: PGLint, minor: PGLint): GLboolean{. - stdcall, importc, oglx.} - proc glXSwapBuffers*(dpy: PDisplay, drawable: GLXDrawable){.stdcall, importc, oglx.} - proc glXUseXFont*(font: Font, first: GLint, count: GLint, listBase: GLint){. - stdcall, importc, oglx.} - proc glXWaitGL*(){.stdcall, importc, oglx.} - proc glXWaitX*(){.stdcall, importc, oglx.} - proc glXGetClientString*(dpy: PDisplay, name: GLint): PGLchar{.stdcall, importc, oglx.} - proc glXQueryServerString*(dpy: PDisplay, screen: GLint, name: GLint): PGLchar{. - stdcall, importc, oglx.} - proc glXQueryExtensionsString*(dpy: PDisplay, screen: GLint): PGLchar{.stdcall, importc, oglx.} - # GLX_VERSION_1_3 - proc glXGetFBConfigs*(dpy: PDisplay, screen: GLint, nelements: PGLint): GLXFBConfig{. - stdcall, importc, oglx.} - proc glXChooseFBConfig*(dpy: PDisplay, screen: GLint, attrib_list: PGLint, - nelements: PGLint): GLXFBConfig{.stdcall, importc, oglx.} - proc glXGetFBConfigAttrib*(dpy: PDisplay, config: GLXFBConfig, - attribute: GLint, value: PGLint): glint{.stdcall, importc, oglx.} - proc glXGetVisualFromFBConfig*(dpy: PDisplay, config: GLXFBConfig): PXVisualInfo{.stdcall, importc, oglx.} - proc glXCreateWindow*(dpy: PDisplay, config: GLXFBConfig, win: Window, - attrib_list: PGLint): GLXWindow{.stdcall, importc, oglx.} - proc glXDestroyWindow*(dpy: PDisplay, win: GLXWindow){.stdcall, importc, oglx.} - proc glXCreatePixmap*(dpy: PDisplay, config: GLXFBConfig, pixmap: Pixmap, - attrib_list: PGLint): GLXPixmap{.stdcall, importc, oglx.} - proc glXDestroyPixmap*(dpy: PDisplay, pixmap: GLXPixmap){.stdcall, importc, oglx.} - proc glXCreatePbuffer*(dpy: PDisplay, config: GLXFBConfig, attrib_list: PGLint): GLXPbuffer{. - stdcall, importc, oglx.} - proc glXDestroyPbuffer*(dpy: PDisplay, pbuf: GLXPbuffer){.stdcall, importc, oglx.} - proc glXQueryDrawable*(dpy: PDisplay, draw: GLXDrawable, attribute: GLint, - value: PGLuint){.stdcall, importc, oglx.} - proc glXCreateNewContext*(dpy: PDisplay, config: GLXFBConfig, - rendertyp: GLint, share_list: GLXContext, - direct: GLboolean): GLXContext{.stdcall, importc, oglx.} - proc glXMakeContextCurrent*(display: PDisplay, draw: GLXDrawable, - read: GLXDrawable, ctx: GLXContext): GLboolean{. - stdcall, importc, oglx.} - proc glXGetCurrentReadDrawable*(): GLXDrawable{.stdcall, importc, oglx.} - proc glXGetCurreentDisplay*(): PDisplay{.stdcall, importc, oglx.} - proc glXQueryContext*(dpy: PDisplay, ctx: GLXContext, attribute: GLint, - value: PGLint): GLint{.stdcall, importc, oglx.} - proc glXSelectEvent*(dpy: PDisplay, draw: GLXDrawable, event_mask: GLuint){. - stdcall, importc, oglx.} - proc glXGetSelectedEvent*(dpy: PDisplay, draw: GLXDrawable, - event_mask: PGLuint){.stdcall, importc, oglx.} - # GLX_VERSION_1_4 - when not defined(glXGetProcAddress): - proc glXGetProcAddress*(name: cstring): pointer{.stdcall, importc, oglx.} - # GLX_ARB_get_proc_address - when not defined(glXGetProcAddressARB): - proc glXGetProcAddressARB*(name: cstring): pointer{.stdcall, importc, oglx.} - # GLX_ARB_create_context - proc glXCreateContextAttribsARB*(dpy: PDisplay, config: GLXFBConfig, - share_context: GLXContext, direct: GLboolean, - attrib_list: PGLint): GLXContext{.stdcall, importc, oglx.} - # GLX_EXT_import_context - proc glXGetCurrentDisplayEXT*(): PDisplay{.stdcall, importc, oglx.} - proc glXQueryContextInfoEXT*(dpy: PDisplay, context: GLXContext, - attribute: GLint, value: PGLint): GLint{.stdcall, importc, oglx.} - proc glXGetContextIDEXT*(context: GLXContext): GLXContextID{.stdcall, importc, oglx.} - proc glXImportContextEXT*(dpy: PDisplay, contextID: GLXContextID): GLXContext{. - stdcall, importc, oglx.} - proc glXFreeContextEXT*(dpy: PDisplay, context: GLXContext){.stdcall, importc, oglx.} - # GLX_EXT_texture_from_pixmap - proc glXBindTexImageEXT*(dpy: PDisplay, drawable: GLXDrawable, buffer: GLint, - attrib_list: PGLint){.stdcall, importc, oglx.} - proc glXReleaseTexImageEXT*(dpy: PDisplay, drawable: GLXDrawable, - buffer: GLint){.stdcall, importc, oglx.} -# GL utility functions and procedures - -proc gluErrorString*(errCode: GLEnum): cstring{.stdcall, importc, glu.} -proc gluGetString*(name: GLEnum): cstring{.stdcall, importc, glu.} -proc gluOrtho2D*(left, right, bottom, top: GLdouble){.stdcall, importc, glu.} -proc gluPerspective*(fovy, aspect, zNear, zFar: GLdouble){.stdcall, importc, glu.} -proc gluPickMatrix*(x, y, width, height: GLdouble, viewport: TVector4i){.stdcall, importc, glu.} -proc gluLookAt*(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: GLdouble){. - stdcall, importc, glu.} -proc gluProject*(objx, objy, objz: GLdouble, modelMatrix: TGLMatrixd4, - projMatrix: TGLMatrixd4, viewport: TVector4i, - winx, winy, winz: PGLdouble): GLint{.stdcall, importc, glu.} -proc gluUnProject*(winx, winy, winz: GLdouble, modelMatrix: TGLMatrixd4, - projMatrix: TGLMatrixd4, viewport: TVector4i, - objx, objy, objz: PGLdouble): GLint{.stdcall, importc, glu.} -proc gluScaleImage*(format: GLEnum, widthin, heightin: GLint, typein: GLEnum, - datain: Pointer, widthout, heightout: GLint, - typeout: GLEnum, dataout: Pointer): GLint{.stdcall, importc, glu.} -proc gluBuild1DMipmaps*(target: GLEnum, components, width: GLint, - format, atype: GLEnum, data: Pointer): GLint{.stdcall, importc, glu.} -proc gluBuild2DMipmaps*(target: GLEnum, components, width, height: GLint, - format, atype: GLEnum, Data: Pointer): GLint{.stdcall, importc, glu.} -proc gluNewQuadric*(): PGLUquadric{.stdcall, importc, glu.} -proc gluDeleteQuadric*(state: PGLUquadric){.stdcall, importc, glu.} -proc gluQuadricNormals*(quadObject: PGLUquadric, normals: GLEnum){.stdcall, importc, glu.} -proc gluQuadricTexture*(quadObject: PGLUquadric, textureCoords: GLboolean){. - stdcall, importc, glu.} -proc gluQuadricOrientation*(quadObject: PGLUquadric, orientation: GLEnum){. - stdcall, importc, glu.} -proc gluQuadricDrawStyle*(quadObject: PGLUquadric, drawStyle: GLEnum){.stdcall, importc, glu.} -proc gluCylinder*(quadObject: PGLUquadric, - baseRadius, topRadius, height: GLdouble, slices, stacks: GLint){. - stdcall, importc, glu.} -proc gluDisk*(quadObject: PGLUquadric, innerRadius, outerRadius: GLdouble, - slices, loops: GLint){.stdcall, importc, glu.} -proc gluPartialDisk*(quadObject: PGLUquadric, - innerRadius, outerRadius: GLdouble, slices, loops: GLint, - startAngle, sweepAngle: GLdouble){.stdcall, importc, glu.} -proc gluSphere*(quadObject: PGLUquadric, radius: GLdouble, slices, stacks: GLint){. - stdcall, importc, glu.} -proc gluQuadricCallback*(quadObject: PGLUquadric, which: GLEnum, - fn: TGLUQuadricErrorProc){.stdcall, importc, glu.} -proc gluNewTess*(): PGLUtesselator{.stdcall, importc, glu.} -proc gluDeleteTess*(tess: PGLUtesselator){.stdcall, importc, glu.} -proc gluTessBeginPolygon*(tess: PGLUtesselator, polygon_data: Pointer){.stdcall, importc, glu.} -proc gluTessBeginContour*(tess: PGLUtesselator){.stdcall, importc, glu.} -proc gluTessVertex*(tess: PGLUtesselator, coords: TGLArrayd3, data: Pointer){. - stdcall, importc, glu.} -proc gluTessEndContour*(tess: PGLUtesselator){.stdcall, importc, glu.} -proc gluTessEndPolygon*(tess: PGLUtesselator){.stdcall, importc, glu.} -proc gluTessProperty*(tess: PGLUtesselator, which: GLEnum, value: GLdouble){. - stdcall, importc, glu.} -proc gluTessNormal*(tess: PGLUtesselator, x, y, z: GLdouble){.stdcall, importc, glu.} -proc gluTessCallback*(tess: PGLUtesselator, which: GLEnum, fn: Pointer){.stdcall, importc, glu.} -proc gluGetTessProperty*(tess: PGLUtesselator, which: GLEnum, value: PGLdouble){. - stdcall, importc, glu.} -proc gluNewNurbsRenderer*(): PGLUnurbs{.stdcall, importc, glu.} -proc gluDeleteNurbsRenderer*(nobj: PGLUnurbs){.stdcall, importc, glu.} -proc gluBeginSurface*(nobj: PGLUnurbs){.stdcall, importc, glu.} -proc gluBeginCurve*(nobj: PGLUnurbs){.stdcall, importc, glu.} -proc gluEndCurve*(nobj: PGLUnurbs){.stdcall, importc, glu.} -proc gluEndSurface*(nobj: PGLUnurbs){.stdcall, importc, glu.} -proc gluBeginTrim*(nobj: PGLUnurbs){.stdcall, importc, glu.} -proc gluEndTrim*(nobj: PGLUnurbs){.stdcall, importc, glu.} -proc gluPwlCurve*(nobj: PGLUnurbs, count: GLint, points: PGLfloat, - stride: GLint, atype: GLEnum){.stdcall, importc, glu.} -proc gluNurbsCurve*(nobj: PGLUnurbs, nknots: GLint, knot: PGLfloat, - stride: GLint, ctlarray: PGLfloat, order: GLint, - atype: GLEnum){.stdcall, importc, glu.} -proc gluNurbsSurface*(nobj: PGLUnurbs, sknot_count: GLint, sknot: PGLfloat, - tknot_count: GLint, tknot: PGLfloat, - s_stride, t_stride: GLint, ctlarray: PGLfloat, - sorder, torder: GLint, atype: GLEnum){.stdcall, importc, glu.} -proc gluLoadSamplingMatrices*(nobj: PGLUnurbs, - modelMatrix, projMatrix: TGLMatrixf4, - viewport: TVector4i){.stdcall, importc, glu.} -proc gluNurbsProperty*(nobj: PGLUnurbs, aproperty: GLEnum, value: GLfloat){. - stdcall, importc, glu.} -proc gluGetNurbsProperty*(nobj: PGLUnurbs, aproperty: GLEnum, value: PGLfloat){. - stdcall, importc, glu.} -proc gluNurbsCallback*(nobj: PGLUnurbs, which: GLEnum, fn: TGLUNurbsErrorProc){. - stdcall, importc, glu.} -proc gluBeginPolygon*(tess: PGLUtesselator){.stdcall, importc, glu.} -proc gluNextContour*(tess: PGLUtesselator, atype: GLEnum){.stdcall, importc, glu.} -proc gluEndPolygon*(tess: PGLUtesselator){.stdcall, importc, glu.} - -type - TRCOption* = enum - opDoubleBuffered, opGDI, opStereo - TRCOptions* = set[TRCOption] - -var LastPixelFormat*: int - -when defined(windows): - proc CreateRenderingContext*(DC: HDC, Options: TRCOptions, ColorBits, ZBits, - StencilBits, AccumBits, AuxBuffers: int, Layer: int): HGLRC - proc DestroyRenderingContext*(RC: HGLRC) - proc ActivateRenderingContext*(DC: HDC, RC: HGLRC) - proc DeactivateRenderingContext*() -# implementation - -proc GetExtensionString*(): string = - when defined(windows): - result = $glGetString(GL_EXTENSIONS) & ' ' & $wglGetExtensionsStringEXT() & - ' ' & $wglGetExtensionsStringARB(wglGetCurrentDC()) - else: - result = $glGetString(GL_EXTENSIONS) - -when defined(windows): - proc CreateRenderingContext(DC: HDC, Options: TRCOptions, ColorBits, ZBits, - StencilBits, AccumBits, AuxBuffers: int, Layer: int): HGLRC = - type - TPIXELFORMATDESCRIPTOR {.final, pure.} = object - nSize: int16 - nVersion: int16 - dwFlags: DWORD - iPixelType: int8 - cColorBits: int8 - cRedBits: int8 - cRedShift: int8 - cGreenBits: int8 - cGreenShift: int8 - cBlueBits: int8 - cBlueShift: int8 - cAlphaBits: int8 - cAlphaShift: int8 - cAccumBits: int8 - cAccumRedBits: int8 - cAccumGreenBits: int8 - cAccumBlueBits: int8 - cAccumAlphaBits: int8 - cDepthBits: int8 - cStencilBits: int8 - cAuxBuffers: int8 - iLayerType: int8 - bReserved: int8 - dwLayerMask: DWORD - dwVisibleMask: DWORD - dwDamageMask: DWORD - - proc GetObjectType(h: HDC): DWORD{.stdcall, dynlib: "gdi32", - importc: "GetObjectType".} - proc ChoosePixelFormat(para1: HDC, para2: ptr TPIXELFORMATDESCRIPTOR): int32{. - stdcall, dynlib: "gdi32", importc: "ChoosePixelFormat".} - proc GetPixelFormat(para1: HDC): int32{.stdcall, dynlib: "gdi32", - importc: "GetPixelFormat".} - proc SetPixelFormat(para1: HDC, para2: int32, - para3: ptr TPIXELFORMATDESCRIPTOR): WINBOOL{. - stdcall, dynlib: "gdi32", importc: "SetPixelFormat".} - proc DescribePixelFormat(para1: HDC, para2, para3: int32, - para4: ptr TPIXELFORMATDESCRIPTOR) {.stdcall, - dynlib: "gdi32", importc: "DescribePixelFormat".} - - const - OBJ_MEMDC = 10'i32 - OBJ_ENHMETADC = 12'i32 - OBJ_METADC = 4'i32 - PFD_DOUBLEBUFFER = 0x00000001 - PFD_STEREO = 0x00000002 - PFD_DRAW_TO_WINDOW = 0x00000004 - PFD_DRAW_TO_BITMAP = 0x00000008 - PFD_SUPPORT_GDI = 0x00000010 - PFD_SUPPORT_OPENGL = 0x00000020 - PFDtyp_RGBA = 0'i8 - PFD_MAIN_PLANE = 0'i8 - PFD_OVERLAY_PLANE = 1'i8 - PFD_UNDERLAY_PLANE = int32(- 1) - var - PFDescriptor: TPixelFormatDescriptor - PixelFormat: int32 - AType: int32 - PFDescriptor.nSize = SizeOf(PFDescriptor).int16 - PFDescriptor.nVersion = 1'i16 - PFDescriptor.dwFlags = PFD_SUPPORT_OPENGL - AType = GetObjectType(DC) - if AType == 0: OSError() - if AType == OBJ_MEMDC or AType == OBJ_METADC or AType == OBJ_ENHMETADC: - PFDescriptor.dwFlags = PFDescriptor.dwFlags or PFD_DRAW_TO_BITMAP - else: - PFDescriptor.dwFlags = PFDescriptor.dwFlags or PFD_DRAW_TO_WINDOW - if opDoubleBuffered in Options: - PFDescriptor.dwFlags = PFDescriptor.dwFlags or PFD_DOUBLEBUFFER - if opGDI in Options: - PFDescriptor.dwFlags = PFDescriptor.dwFlags or PFD_SUPPORT_GDI - if opStereo in Options: - PFDescriptor.dwFlags = PFDescriptor.dwFlags or PFD_STEREO - PFDescriptor.iPixelType = PFDtyp_RGBA - PFDescriptor.cColorBits = ColorBits.toU8 - PFDescriptor.cDepthBits = zBits.toU8 - PFDescriptor.cStencilBits = StencilBits.toU8 - PFDescriptor.cAccumBits = AccumBits.toU8 - PFDescriptor.cAuxBuffers = AuxBuffers.toU8 - if Layer == 0: PFDescriptor.iLayerType = PFD_MAIN_PLANE - elif Layer > 0: PFDescriptor.iLayerType = PFD_OVERLAY_PLANE - else: PFDescriptor.iLayerType = int8(PFD_UNDERLAY_PLANE) - PixelFormat = ChoosePixelFormat(DC, addr(PFDescriptor)) - if PixelFormat == 0: OSError() - if GetPixelFormat(DC) != PixelFormat: - if SetPixelFormat(DC, PixelFormat, addr(PFDescriptor)) == 0'i32: - OSError() - DescribePixelFormat(DC, PixelFormat.int32, SizeOf(PFDescriptor).int32, - addr(PFDescriptor)) - Result = wglCreateContext(DC) - if Result == 0: OSError() - else: LastPixelFormat = 0 - - proc DestroyRenderingContext(RC: HGLRC) = - discard wglDeleteContext(RC) - - proc ActivateRenderingContext(DC: HDC, RC: HGLRC) = - discard wglMakeCurrent(DC, RC) - - proc DeactivateRenderingContext() = - discard wglMakeCurrent(0, 0) + +# +# +# Nimrod's Runtime Library +# (c) Copyright 2012 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +## This module is a wrapper around `opengl`:idx:. If you define the symbol +## ``useGlew`` this wrapper does not use Nimrod's ``dynlib`` mechanism, +## but `glew`:idx: instead. However, this shouldn't be necessary anymore; even +## extension loading for the different operating systems is handled here. +## +## You need to call ``loadExtensions`` after a rendering context has been +## created to load any extension proc that your code uses. + +import macros, sequtils + +when defined(linux): + import X, XLib, XUtil +elif defined(windows): + import winlean, os + +when defined(windows): + const + ogldll* = "OpenGL32.dll" + gludll* = "GLU32.dll" +elif defined(macosx): + #macosx has this notion of a framework, thus the path to the openGL dylib files + #is absolute + const + ogldll* = "/System/Library/Frameworks/OpenGL.framework/Versions/Current/Libraries/libGL.dylib" + gludll* = "/System/Library/Frameworks/OpenGL.framework/Versions/Current/Libraries/libGLU.dylib" +else: + const + ogldll* = "libGL.so.1" + gludll* = "libGLU.so.1" + +when defined(useGlew): + {.pragma: ogl, header: "".} + {.pragma: oglx, header: "".} + {.pragma: wgl, header: "".} + {.pragma: glu, dynlib: gludll.} +else: + # quite complex ... thanks to extension support for various platforms: + import dynlib + + let oglHandle = LoadLib(ogldll) + if isNil(oglHandle): quit("could not load: " & ogldll) + + when defined(windows): + var wglGetProcAddress = cast[proc (s: cstring): pointer {.stdcall.}]( + symAddr(oglHandle, "wglGetProcAddress")) + elif defined(linux): + var glXGetProcAddress = cast[proc (s: cstring): pointer {.cdecl.}]( + symAddr(oglHandle, "glXGetProcAddress")) + var glXGetProcAddressARB = cast[proc (s: cstring): pointer {.cdecl.}]( + symAddr(oglHandle, "glXGetProcAddressARB")) + + proc glGetProc(h: TLibHandle; procName: cstring): pointer = + when defined(windows): + result = symAddr(h, procname) + if result != nil: return + if not isNil(wglGetProcAddress): result = wglGetProcAddress(ProcName) + elif defined(linux): + if not isNil(glXGetProcAddress): result = glXGetProcAddress(ProcName) + if result != nil: return + if not isNil(glXGetProcAddressARB): + result = glXGetProcAddressARB(ProcName) + if result != nil: return + result = symAddr(h, procname) + else: + result = symAddr(h, procName) + if result == nil: raiseInvalidLibrary(procName) + + var gluHandle: TLibHandle + + proc gluGetProc(procname: cstring): pointer = + if gluHandle == nil: + gluHandle = LoadLib(gludll) + if gluHandle == nil: quit("could not load: " & gludll) + result = glGetProc(gluHandle, procname) + + # undocumented 'dynlib' feature: the string literal is replaced by + # the imported proc name: + {.pragma: ogl, dynlib: glGetProc(oglHandle, "0").} + {.pragma: oglx, dynlib: glGetProc(oglHandle, "0").} + {.pragma: wgl, dynlib: glGetProc(oglHandle, "0").} + {.pragma: glu, dynlib: gluGetProc("").} + + proc nimLoadProcs0() {.importc.} + + template loadExtensions*() = + ## call this after your rendering context has been setup if you use + ## extensions. + bind nimLoadProcs0 + nimLoadProcs0() + +type + TGLenum* = uint32 + TGLboolean* = bool + TGLbitfield* = uint32 + TGLvoid* = void + TGLbyte* = int8 + TGLshort* = int64 + TGLint* = int32 + TGLclampx* = int32 + TGLubyte* = uint8 + TGLushort* = uint16 + TGLuint* = uint32 + TGLsizei* = int32 + TGLfloat* = float32 + TGLclampf* = float32 + TGLdouble* = float64 + TGLclampd* = float64 + TGLeglImageOES* = pointer + TGLchar* = char + TGLcharARB* = cchar + TGLfixed* = int32 + TGLhalfNV* = uint16 + TGLvdpauSurfaceNV* = uint + TGLintptr* = int32 + TGLintptrARB* = int32 + TGLint64EXT* = int64 + TGLuint64EXT* = uint64 + TGLint64* = int64 + TGLsizeiptrARB* = int32 + TGLsizeiptr* = int32 + TGLsync* = pointer + TGLuint64* = uint64 + TCL_context* = distinct pointer + TCL_event* = distinct pointer + TGLDebugProc* = proc ( + source: TGLenum, + typ: TGLenum, + id: TGLuint, + severity: TGLenum, + length: TGLsizei, + message: ptr TGLchar, + userParam: pointer) {.stdcall.} + TGlDebugProcARB* = proc ( + source: TGLenum, + typ: TGLenum, + id: TGLuint, + severity: TGLenum, + len: TGLsizei, + message: ptr TGLchar, + userParam: pointer) {.stdcall.} + TGlDebugProcAMD* = proc ( + id: TGLuint, + category: TGLenum, + severity: TGLenum, + len: TGLsizei, + message: ptr TGLchar, + userParam: pointer) {.stdcall.} + TGlDebugProcKHR* = proc ( + source, typ: TGLenum, + id: TGLuint, + severity: TGLenum, + length: TGLsizei, + message: ptr TGLchar, + userParam: pointer) {.stdcall.} + +when defined(macosx): + type + TGLhandleARB = pointer +else: + type + TGLhandleARB = uint32 + +type + TGlError* {.size: TGLenum.sizeof.} = enum + gleNoError = (0, "no error") + gleInvalidEnum = (0x0500, "invalid enum") + gleInvalidValue = (0x0501, "invalid value") + gleInvalidOperation = (0x0502, "invalid operation") + gleStackOverflow = (0x0503, "stack overflow") + gleStackUnderflow = (0x0504, "stack underflow") + gleOutOfMem = (0x0505, "out of memory") + gleInvalidFramebufferOperation = (0x0506, "invalid framebuffer operation") + gleTableTooLarge = (0x8031, "table too large") + gleUnknown = (0x384623812, "unknown") + +proc glGetError*: TGLenum {.stdcall, importc, ogl.} +proc getGlError*: TGlError = glGetError().TGlError + +type + E_GL* = object of E_Base + code: TGlError + +proc checkGlError = + let error = getGlError() + if error == gleNoError: + return + + var + exc = new(E_GL) + exc.code = gleUnknown + exc.msg = "OpenGL error: unknown" + for e in TGlError: + if e == error and e != gleUnknown: + exc.msg = "OpenGL error: " & $e + exc.code = e + break + + raise exc + +const NoGlAutoErrorCheck = defined(noglautoerrorcheck) + +var glAutoErrorCheck = true + +proc enableGlAutoErrorCheck*(yes: bool) = + glAutoErrorCheck = yes + +macro wrapErrorChecking(f: stmt): stmt = + f.expectKind nnkStmtList + result = newStmtList() + + for child in f.children: + child.expectKind nnkProcDef + let params = toSeq(child.params.children) + var glProc = copy child + glProc.pragma = newNimNode(nnkPragma).add( + newNimNode(nnkExprColonExpr).add( + ident"importc" , newLit($child.name)) + ).add( + ident"inline").add( + ident"ogl") + + glProc.name = ident($glProc.name & "Impl") + var + body = newStmtList glProc + returnsSomething = child.params[0].kind != nnkEmpty + callParams = newSeq[PNimrodNode]() + for param in params[1 .. Date: Tue, 15 Apr 2014 15:34:45 +0200 Subject: [PATCH 02/18] src -> lib. --- {src => lib}/gl.nim | 0 {src => lib}/glext.nim | 0 {src => lib}/glu.nim | 0 {src => lib}/glut.nim | 0 {src => lib}/glx.nim | 0 {src => lib}/opengl.nim | 0 {src => lib}/wingl.nim | 0 opengl.babel | 2 +- 8 files changed, 1 insertion(+), 1 deletion(-) rename {src => lib}/gl.nim (100%) rename {src => lib}/glext.nim (100%) rename {src => lib}/glu.nim (100%) rename {src => lib}/glut.nim (100%) rename {src => lib}/glx.nim (100%) rename {src => lib}/opengl.nim (100%) rename {src => lib}/wingl.nim (100%) diff --git a/src/gl.nim b/lib/gl.nim similarity index 100% rename from src/gl.nim rename to lib/gl.nim diff --git a/src/glext.nim b/lib/glext.nim similarity index 100% rename from src/glext.nim rename to lib/glext.nim diff --git a/src/glu.nim b/lib/glu.nim similarity index 100% rename from src/glu.nim rename to lib/glu.nim diff --git a/src/glut.nim b/lib/glut.nim similarity index 100% rename from src/glut.nim rename to lib/glut.nim diff --git a/src/glx.nim b/lib/glx.nim similarity index 100% rename from src/glx.nim rename to lib/glx.nim diff --git a/src/opengl.nim b/lib/opengl.nim similarity index 100% rename from src/opengl.nim rename to lib/opengl.nim diff --git a/src/wingl.nim b/lib/wingl.nim similarity index 100% rename from src/wingl.nim rename to lib/wingl.nim diff --git a/opengl.babel b/opengl.babel index a5dfe9c..7f22fd8 100644 --- a/opengl.babel +++ b/opengl.babel @@ -5,7 +5,7 @@ author: "Andreas Rumpf" description: "High-level and low-level wrapper for OpenGL" license: "MIT" -srcDir: "src" +srcDir: "lib" [Deps] requires: "nimrod > 0.9.2, x11" From 411268a5887cbb86d03191fbbe15f2e9e6440ad5 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Tue, 15 Apr 2014 15:37:17 +0200 Subject: [PATCH 03/18] Remove old module. --- lib/gl.nim | 1536 ---------------------------------------------------- 1 file changed, 1536 deletions(-) delete mode 100644 lib/gl.nim diff --git a/lib/gl.nim b/lib/gl.nim deleted file mode 100644 index 9387b5b..0000000 --- a/lib/gl.nim +++ /dev/null @@ -1,1536 +0,0 @@ -# -# -# Adaption of the delphi3d.net OpenGL units to FreePascal -# Sebastian Guenther (sg@freepascal.org) in 2002 -# These units are free to use -# -#****************************************************************************** -# Converted to Delphi by Tom Nuydens (tom@delphi3d.net) -# For the latest updates, visit Delphi3D: http://www.delphi3d.net -#****************************************************************************** - -when defined(windows): - {.push, callconv: stdcall.} -else: - {.push, callconv: cdecl.} -when defined(windows): - const - dllname* = "opengl32.dll" -elif defined(macosx): - const - dllname* = "/System/Library/Frameworks/OpenGL.framework/Libraries/libGL.dylib" -else: - const - dllname* = "libGL.so.1" -type - PGLenum* = ptr TGLenum - PGLboolean* = ptr TGLboolean - PGLbitfield* = ptr TGLbitfield - TGLbyte* = int8 - PGLbyte* = ptr TGlbyte - PGLshort* = ptr TGLshort - PGLint* = ptr TGLint - PGLsizei* = ptr TGLsizei - PGLubyte* = ptr TGLubyte - PGLushort* = ptr TGLushort - PGLuint* = ptr TGLuint - PGLfloat* = ptr TGLfloat - PGLclampf* = ptr TGLclampf - PGLdouble* = ptr TGLdouble - PGLclampd* = ptr TGLclampd - PGLvoid* = Pointer - PPGLvoid* = ptr PGLvoid - TGLenum* = cint - TGLboolean* = bool - TGLbitfield* = cint - TGLshort* = int16 - TGLint* = cint - TGLsizei* = int - TGLubyte* = int8 - TGLushort* = int16 - TGLuint* = cint - TGLfloat* = float32 - TGLclampf* = float32 - TGLdouble* = float - TGLclampd* = float - -const # Version - GL_VERSION_1_1* = 1 # AccumOp - constGL_ACCUM* = 0x00000100 - GL_LOAD* = 0x00000101 - GL_RETURN* = 0x00000102 - GL_MULT* = 0x00000103 - GL_ADD* = 0x00000104 # AlphaFunction - GL_NEVER* = 0x00000200 - GL_LESS* = 0x00000201 - GL_EQUAL* = 0x00000202 - GL_LEQUAL* = 0x00000203 - GL_GREATER* = 0x00000204 - GL_NOTEQUAL* = 0x00000205 - GL_GEQUAL* = 0x00000206 - GL_ALWAYS* = 0x00000207 # AttribMask - GL_CURRENT_BIT* = 0x00000001 - GL_POINT_BIT* = 0x00000002 - GL_LINE_BIT* = 0x00000004 - GL_POLYGON_BIT* = 0x00000008 - GL_POLYGON_STIPPLE_BIT* = 0x00000010 - GL_PIXEL_MODE_BIT* = 0x00000020 - GL_LIGHTING_BIT* = 0x00000040 - GL_FOG_BIT* = 0x00000080 - GL_DEPTH_BUFFER_BIT* = 0x00000100 - GL_ACCUM_BUFFER_BIT* = 0x00000200 - GL_STENCIL_BUFFER_BIT* = 0x00000400 - GL_VIEWPORT_BIT* = 0x00000800 - GL_TRANSFORM_BIT* = 0x00001000 - GL_ENABLE_BIT* = 0x00002000 - GL_COLOR_BUFFER_BIT* = 0x00004000 - GL_HINT_BIT* = 0x00008000 - GL_EVAL_BIT* = 0x00010000 - GL_LIST_BIT* = 0x00020000 - GL_TEXTURE_BIT* = 0x00040000 - GL_SCISSOR_BIT* = 0x00080000 - GL_ALL_ATTRIB_BITS* = 0x000FFFFF # BeginMode - GL_POINTS* = 0x00000000 - GL_LINES* = 0x00000001 - GL_LINE_LOOP* = 0x00000002 - GL_LINE_STRIP* = 0x00000003 - GL_TRIANGLES* = 0x00000004 - GL_TRIANGLE_STRIP* = 0x00000005 - GL_TRIANGLE_FAN* = 0x00000006 - GL_QUADS* = 0x00000007 - GL_QUAD_STRIP* = 0x00000008 - GL_POLYGON* = 0x00000009 # BlendingFactorDest - GL_ZERO* = 0 - GL_ONE* = 1 - GL_SRC_COLOR* = 0x00000300 - GL_ONE_MINUS_SRC_COLOR* = 0x00000301 - GL_SRC_ALPHA* = 0x00000302 - GL_ONE_MINUS_SRC_ALPHA* = 0x00000303 - GL_DST_ALPHA* = 0x00000304 - GL_ONE_MINUS_DST_ALPHA* = 0x00000305 # BlendingFactorSrc - # GL_ZERO - # GL_ONE - GL_DST_COLOR* = 0x00000306 - GL_ONE_MINUS_DST_COLOR* = 0x00000307 - GL_SRC_ALPHA_SATURATE* = 0x00000308 # GL_SRC_ALPHA - # GL_ONE_MINUS_SRC_ALPHA - # GL_DST_ALPHA - # GL_ONE_MINUS_DST_ALPHA - # Boolean - GL_TRUE* = 1 - GL_FALSE* = 0 # ClearBufferMask - # GL_COLOR_BUFFER_BIT - # GL_ACCUM_BUFFER_BIT - # GL_STENCIL_BUFFER_BIT - # GL_DEPTH_BUFFER_BIT - # ClientArrayType - # GL_VERTEX_ARRAY - # GL_NORMAL_ARRAY - # GL_COLOR_ARRAY - # GL_INDEX_ARRAY - # GL_TEXTURE_COORD_ARRAY - # GL_EDGE_FLAG_ARRAY - # ClipPlaneName - GL_CLIP_PLANE0* = 0x00003000 - GL_CLIP_PLANE1* = 0x00003001 - GL_CLIP_PLANE2* = 0x00003002 - GL_CLIP_PLANE3* = 0x00003003 - GL_CLIP_PLANE4* = 0x00003004 - GL_CLIP_PLANE5* = 0x00003005 # ColorMaterialFace - # GL_FRONT - # GL_BACK - # GL_FRONT_AND_BACK - # ColorMaterialParameter - # GL_AMBIENT - # GL_DIFFUSE - # GL_SPECULAR - # GL_EMISSION - # GL_AMBIENT_AND_DIFFUSE - # ColorPointerType - # GL_BYTE - # GL_UNSIGNED_BYTE - # GL_SHORT - # GL_UNSIGNED_SHORT - # GL_INT - # GL_UNSIGNED_INT - # GL_FLOAT - # GL_DOUBLE - # CullFaceMode - # GL_FRONT - # GL_BACK - # GL_FRONT_AND_BACK - # DataType - GL_BYTE* = 0x00001400 - GL_UNSIGNED_BYTE* = 0x00001401 - GL_SHORT* = 0x00001402 - GL_UNSIGNED_SHORT* = 0x00001403 - GL_INT* = 0x00001404 - GL_UNSIGNED_INT* = 0x00001405 - GL_FLOAT* = 0x00001406 - GL_2_BYTES* = 0x00001407 - GL_3_BYTES* = 0x00001408 - GL_4_BYTES* = 0x00001409 - GL_DOUBLE* = 0x0000140A # DepthFunction - # GL_NEVER - # GL_LESS - # GL_EQUAL - # GL_LEQUAL - # GL_GREATER - # GL_NOTEQUAL - # GL_GEQUAL - # GL_ALWAYS - # DrawBufferMode - GL_NONE* = 0 - GL_FRONT_LEFT* = 0x00000400 - GL_FRONT_RIGHT* = 0x00000401 - GL_BACK_LEFT* = 0x00000402 - GL_BACK_RIGHT* = 0x00000403 - GL_FRONT* = 0x00000404 - GL_BACK* = 0x00000405 - GL_LEFT* = 0x00000406 - GL_RIGHT* = 0x00000407 - GL_FRONT_AND_BACK* = 0x00000408 - GL_AUX0* = 0x00000409 - GL_AUX1* = 0x0000040A - GL_AUX2* = 0x0000040B - GL_AUX3* = 0x0000040C # Enable - # GL_FOG - # GL_LIGHTING - # GL_TEXTURE_1D - # GL_TEXTURE_2D - # GL_LINE_STIPPLE - # GL_POLYGON_STIPPLE - # GL_CULL_FACE - # GL_ALPHA_TEST - # GL_BLEND - # GL_INDEX_LOGIC_OP - # GL_COLOR_LOGIC_OP - # GL_DITHER - # GL_STENCIL_TEST - # GL_DEPTH_TEST - # GL_CLIP_PLANE0 - # GL_CLIP_PLANE1 - # GL_CLIP_PLANE2 - # GL_CLIP_PLANE3 - # GL_CLIP_PLANE4 - # GL_CLIP_PLANE5 - # GL_LIGHT0 - # GL_LIGHT1 - # GL_LIGHT2 - # GL_LIGHT3 - # GL_LIGHT4 - # GL_LIGHT5 - # GL_LIGHT6 - # GL_LIGHT7 - # GL_TEXTURE_GEN_S - # GL_TEXTURE_GEN_T - # GL_TEXTURE_GEN_R - # GL_TEXTURE_GEN_Q - # GL_MAP1_VERTEX_3 - # GL_MAP1_VERTEX_4 - # GL_MAP1_COLOR_4 - # GL_MAP1_INDEX - # GL_MAP1_NORMAL - # GL_MAP1_TEXTURE_COORD_1 - # GL_MAP1_TEXTURE_COORD_2 - # GL_MAP1_TEXTURE_COORD_3 - # GL_MAP1_TEXTURE_COORD_4 - # GL_MAP2_VERTEX_3 - # GL_MAP2_VERTEX_4 - # GL_MAP2_COLOR_4 - # GL_MAP2_INDEX - # GL_MAP2_NORMAL - # GL_MAP2_TEXTURE_COORD_1 - # GL_MAP2_TEXTURE_COORD_2 - # GL_MAP2_TEXTURE_COORD_3 - # GL_MAP2_TEXTURE_COORD_4 - # GL_POINT_SMOOTH - # GL_LINE_SMOOTH - # GL_POLYGON_SMOOTH - # GL_SCISSOR_TEST - # GL_COLOR_MATERIAL - # GL_NORMALIZE - # GL_AUTO_NORMAL - # GL_VERTEX_ARRAY - # GL_NORMAL_ARRAY - # GL_COLOR_ARRAY - # GL_INDEX_ARRAY - # GL_TEXTURE_COORD_ARRAY - # GL_EDGE_FLAG_ARRAY - # GL_POLYGON_OFFSET_POINT - # GL_POLYGON_OFFSET_LINE - # GL_POLYGON_OFFSET_FILL - # ErrorCode - GL_NO_ERROR* = 0 - GL_INVALID_ENUM* = 0x00000500 - GL_INVALID_VALUE* = 0x00000501 - GL_INVALID_OPERATION* = 0x00000502 - GL_STACK_OVERFLOW* = 0x00000503 - GL_STACK_UNDERFLOW* = 0x00000504 - GL_OUT_OF_MEMORY* = 0x00000505 # FeedBackMode - GL_2D* = 0x00000600 - GL_3D* = 0x00000601 - GL_3D_COLOR* = 0x00000602 - GL_3D_COLOR_TEXTURE* = 0x00000603 - GL_4D_COLOR_TEXTURE* = 0x00000604 # FeedBackToken - GL_PASS_THROUGH_TOKEN* = 0x00000700 - GL_POINT_TOKEN* = 0x00000701 - GL_LINE_TOKEN* = 0x00000702 - GL_POLYGON_TOKEN* = 0x00000703 - GL_BITMAP_TOKEN* = 0x00000704 - GL_DRAW_PIXEL_TOKEN* = 0x00000705 - GL_COPY_PIXEL_TOKEN* = 0x00000706 - GL_LINE_RESET_TOKEN* = 0x00000707 # FogMode - # GL_LINEAR - GL_EXP* = 0x00000800 - GL_EXP2* = 0x00000801 # FogParameter - # GL_FOG_COLOR - # GL_FOG_DENSITY - # GL_FOG_END - # GL_FOG_INDEX - # GL_FOG_MODE - # GL_FOG_START - # FrontFaceDirection - GL_CW* = 0x00000900 - GL_CCW* = 0x00000901 # GetMapTarget - GL_COEFF* = 0x00000A00 - GL_ORDER* = 0x00000A01 - GL_DOMAIN* = 0x00000A02 # GetPixelMap - # GL_PIXEL_MAP_I_TO_I - # GL_PIXEL_MAP_S_TO_S - # GL_PIXEL_MAP_I_TO_R - # GL_PIXEL_MAP_I_TO_G - # GL_PIXEL_MAP_I_TO_B - # GL_PIXEL_MAP_I_TO_A - # GL_PIXEL_MAP_R_TO_R - # GL_PIXEL_MAP_G_TO_G - # GL_PIXEL_MAP_B_TO_B - # GL_PIXEL_MAP_A_TO_A - # GetPointerTarget - # GL_VERTEX_ARRAY_POINTER - # GL_NORMAL_ARRAY_POINTER - # GL_COLOR_ARRAY_POINTER - # GL_INDEX_ARRAY_POINTER - # GL_TEXTURE_COORD_ARRAY_POINTER - # GL_EDGE_FLAG_ARRAY_POINTER - # GetTarget - GL_CURRENT_COLOR* = 0x00000B00 - GL_CURRENT_INDEX* = 0x00000B01 - GL_CURRENT_NORMAL* = 0x00000B02 - GL_CURRENT_TEXTURE_COORDS* = 0x00000B03 - GL_CURRENT_RASTER_COLOR* = 0x00000B04 - GL_CURRENT_RASTER_INDEX* = 0x00000B05 - GL_CURRENT_RASTER_TEXTURE_COORDS* = 0x00000B06 - GL_CURRENT_RASTER_POSITION* = 0x00000B07 - GL_CURRENT_RASTER_POSITION_VALID* = 0x00000B08 - GL_CURRENT_RASTER_DISTANCE* = 0x00000B09 - GL_POINT_SMOOTH* = 0x00000B10 - constGL_POINT_SIZE* = 0x00000B11 - GL_POINT_SIZE_RANGE* = 0x00000B12 - GL_POINT_SIZE_GRANULARITY* = 0x00000B13 - GL_LINE_SMOOTH* = 0x00000B20 - constGL_LINE_WIDTH* = 0x00000B21 - GL_LINE_WIDTH_RANGE* = 0x00000B22 - GL_LINE_WIDTH_GRANULARITY* = 0x00000B23 - constGL_LINE_STIPPLE* = 0x00000B24 - GL_LINE_STIPPLE_PATTERN* = 0x00000B25 - GL_LINE_STIPPLE_REPEAT* = 0x00000B26 - GL_LIST_MODE* = 0x00000B30 - GL_MAX_LIST_NESTING* = 0x00000B31 - constGL_LIST_BASE* = 0x00000B32 - GL_LIST_INDEX* = 0x00000B33 - constGL_POLYGON_MODE* = 0x00000B40 - GL_POLYGON_SMOOTH* = 0x00000B41 - constGL_POLYGON_STIPPLE* = 0x00000B42 - constGL_EDGE_FLAG* = 0x00000B43 - constGL_CULL_FACE* = 0x00000B44 - GL_CULL_FACE_MODE* = 0x00000B45 - constGL_FRONT_FACE* = 0x00000B46 - GL_LIGHTING* = 0x00000B50 - GL_LIGHT_MODEL_LOCAL_VIEWER* = 0x00000B51 - GL_LIGHT_MODEL_TWO_SIDE* = 0x00000B52 - GL_LIGHT_MODEL_AMBIENT* = 0x00000B53 - constGL_SHADE_MODEL* = 0x00000B54 - GL_COLOR_MATERIAL_FACE* = 0x00000B55 - GL_COLOR_MATERIAL_PARAMETER* = 0x00000B56 - constGL_COLOR_MATERIAL* = 0x00000B57 - GL_FOG* = 0x00000B60 - GL_FOG_INDEX* = 0x00000B61 - GL_FOG_DENSITY* = 0x00000B62 - GL_FOG_START* = 0x00000B63 - GL_FOG_END* = 0x00000B64 - GL_FOG_MODE* = 0x00000B65 - GL_FOG_COLOR* = 0x00000B66 - constGL_DEPTH_RANGE* = 0x00000B70 - GL_DEPTH_TEST* = 0x00000B71 - GL_DEPTH_WRITEMASK* = 0x00000B72 - GL_DEPTH_CLEAR_VALUE* = 0x00000B73 - constGL_DEPTH_FUNC* = 0x00000B74 - GL_ACCUM_CLEAR_VALUE* = 0x00000B80 - GL_STENCIL_TEST* = 0x00000B90 - GL_STENCIL_CLEAR_VALUE* = 0x00000B91 - constGL_STENCIL_FUNC* = 0x00000B92 - GL_STENCIL_VALUE_MASK* = 0x00000B93 - GL_STENCIL_FAIL* = 0x00000B94 - GL_STENCIL_PASS_DEPTH_FAIL* = 0x00000B95 - GL_STENCIL_PASS_DEPTH_PASS* = 0x00000B96 - GL_STENCIL_REF* = 0x00000B97 - GL_STENCIL_WRITEMASK* = 0x00000B98 - constGL_MATRIX_MODE* = 0x00000BA0 - GL_NORMALIZE* = 0x00000BA1 - constGL_VIEWPORT* = 0x00000BA2 - GL_MODELVIEW_STACK_DEPTH* = 0x00000BA3 - GL_PROJECTION_STACK_DEPTH* = 0x00000BA4 - GL_TEXTURE_STACK_DEPTH* = 0x00000BA5 - GL_MODELVIEW_MATRIX* = 0x00000BA6 - GL_PROJECTION_MATRIX* = 0x00000BA7 - GL_TEXTURE_MATRIX* = 0x00000BA8 - GL_ATTRIB_STACK_DEPTH* = 0x00000BB0 - GL_CLIENT_ATTRIB_STACK_DEPTH* = 0x00000BB1 - GL_ALPHA_TEST* = 0x00000BC0 - GL_ALPHA_TEST_FUNC* = 0x00000BC1 - GL_ALPHA_TEST_REF* = 0x00000BC2 - GL_DITHER* = 0x00000BD0 - GL_BLEND_DST* = 0x00000BE0 - GL_BLEND_SRC* = 0x00000BE1 - GL_BLEND* = 0x00000BE2 - GL_LOGIC_OP_MODE* = 0x00000BF0 - GL_INDEX_LOGIC_OP* = 0x00000BF1 - GL_COLOR_LOGIC_OP* = 0x00000BF2 - GL_AUX_BUFFERS* = 0x00000C00 - constGL_DRAW_BUFFER* = 0x00000C01 - constGL_READ_BUFFER* = 0x00000C02 - GL_SCISSOR_BOX* = 0x00000C10 - GL_SCISSOR_TEST* = 0x00000C11 - GL_INDEX_CLEAR_VALUE* = 0x00000C20 - GL_INDEX_WRITEMASK* = 0x00000C21 - GL_COLOR_CLEAR_VALUE* = 0x00000C22 - GL_COLOR_WRITEMASK* = 0x00000C23 - GL_INDEX_MODE* = 0x00000C30 - GL_RGBA_MODE* = 0x00000C31 - GL_DOUBLEBUFFER* = 0x00000C32 - GL_STEREO* = 0x00000C33 - constGL_RENDER_MODE* = 0x00000C40 - GL_PERSPECTIVE_CORRECTION_HINT* = 0x00000C50 - GL_POINT_SMOOTH_HINT* = 0x00000C51 - GL_LINE_SMOOTH_HINT* = 0x00000C52 - GL_POLYGON_SMOOTH_HINT* = 0x00000C53 - GL_FOG_HINT* = 0x00000C54 - GL_TEXTURE_GEN_S* = 0x00000C60 - GL_TEXTURE_GEN_T* = 0x00000C61 - GL_TEXTURE_GEN_R* = 0x00000C62 - GL_TEXTURE_GEN_Q* = 0x00000C63 - GL_PIXEL_MAP_I_TO_I* = 0x00000C70 - GL_PIXEL_MAP_S_TO_S* = 0x00000C71 - GL_PIXEL_MAP_I_TO_R* = 0x00000C72 - GL_PIXEL_MAP_I_TO_G* = 0x00000C73 - GL_PIXEL_MAP_I_TO_B* = 0x00000C74 - GL_PIXEL_MAP_I_TO_A* = 0x00000C75 - GL_PIXEL_MAP_R_TO_R* = 0x00000C76 - GL_PIXEL_MAP_G_TO_G* = 0x00000C77 - GL_PIXEL_MAP_B_TO_B* = 0x00000C78 - GL_PIXEL_MAP_A_TO_A* = 0x00000C79 - GL_PIXEL_MAP_I_TO_I_SIZE* = 0x00000CB0 - GL_PIXEL_MAP_S_TO_S_SIZE* = 0x00000CB1 - GL_PIXEL_MAP_I_TO_R_SIZE* = 0x00000CB2 - GL_PIXEL_MAP_I_TO_G_SIZE* = 0x00000CB3 - GL_PIXEL_MAP_I_TO_B_SIZE* = 0x00000CB4 - GL_PIXEL_MAP_I_TO_A_SIZE* = 0x00000CB5 - GL_PIXEL_MAP_R_TO_R_SIZE* = 0x00000CB6 - GL_PIXEL_MAP_G_TO_G_SIZE* = 0x00000CB7 - GL_PIXEL_MAP_B_TO_B_SIZE* = 0x00000CB8 - GL_PIXEL_MAP_A_TO_A_SIZE* = 0x00000CB9 - GL_UNPACK_SWAP_BYTES* = 0x00000CF0 - GL_UNPACK_LSB_FIRST* = 0x00000CF1 - GL_UNPACK_ROW_LENGTH* = 0x00000CF2 - GL_UNPACK_SKIP_ROWS* = 0x00000CF3 - GL_UNPACK_SKIP_PIXELS* = 0x00000CF4 - GL_UNPACK_ALIGNMENT* = 0x00000CF5 - GL_PACK_SWAP_BYTES* = 0x00000D00 - GL_PACK_LSB_FIRST* = 0x00000D01 - GL_PACK_ROW_LENGTH* = 0x00000D02 - GL_PACK_SKIP_ROWS* = 0x00000D03 - GL_PACK_SKIP_PIXELS* = 0x00000D04 - GL_PACK_ALIGNMENT* = 0x00000D05 - GL_MAP_COLOR* = 0x00000D10 - GL_MAP_STENCIL* = 0x00000D11 - GL_INDEX_SHIFT* = 0x00000D12 - GL_INDEX_OFFSET* = 0x00000D13 - GL_RED_SCALE* = 0x00000D14 - GL_RED_BIAS* = 0x00000D15 - GL_ZOOM_X* = 0x00000D16 - GL_ZOOM_Y* = 0x00000D17 - GL_GREEN_SCALE* = 0x00000D18 - GL_GREEN_BIAS* = 0x00000D19 - GL_BLUE_SCALE* = 0x00000D1A - GL_BLUE_BIAS* = 0x00000D1B - GL_ALPHA_SCALE* = 0x00000D1C - GL_ALPHA_BIAS* = 0x00000D1D - GL_DEPTH_SCALE* = 0x00000D1E - GL_DEPTH_BIAS* = 0x00000D1F - GL_MAX_EVAL_ORDER* = 0x00000D30 - GL_MAX_LIGHTS* = 0x00000D31 - GL_MAX_CLIP_PLANES* = 0x00000D32 - GL_MAX_TEXTURE_SIZE* = 0x00000D33 - GL_MAX_PIXEL_MAP_TABLE* = 0x00000D34 - GL_MAX_ATTRIB_STACK_DEPTH* = 0x00000D35 - GL_MAX_MODELVIEW_STACK_DEPTH* = 0x00000D36 - GL_MAX_NAME_STACK_DEPTH* = 0x00000D37 - GL_MAX_PROJECTION_STACK_DEPTH* = 0x00000D38 - GL_MAX_TEXTURE_STACK_DEPTH* = 0x00000D39 - GL_MAX_VIEWPORT_DIMS* = 0x00000D3A - GL_MAX_CLIENT_ATTRIB_STACK_DEPTH* = 0x00000D3B - GL_SUBPIXEL_BITS* = 0x00000D50 - GL_INDEX_BITS* = 0x00000D51 - GL_RED_BITS* = 0x00000D52 - GL_GREEN_BITS* = 0x00000D53 - GL_BLUE_BITS* = 0x00000D54 - GL_ALPHA_BITS* = 0x00000D55 - GL_DEPTH_BITS* = 0x00000D56 - GL_STENCIL_BITS* = 0x00000D57 - GL_ACCUM_RED_BITS* = 0x00000D58 - GL_ACCUM_GREEN_BITS* = 0x00000D59 - GL_ACCUM_BLUE_BITS* = 0x00000D5A - GL_ACCUM_ALPHA_BITS* = 0x00000D5B - GL_NAME_STACK_DEPTH* = 0x00000D70 - GL_AUTO_NORMAL* = 0x00000D80 - GL_MAP1_COLOR_4* = 0x00000D90 - GL_MAP1_INDEX* = 0x00000D91 - GL_MAP1_NORMAL* = 0x00000D92 - GL_MAP1_TEXTURE_COORD_1* = 0x00000D93 - GL_MAP1_TEXTURE_COORD_2* = 0x00000D94 - GL_MAP1_TEXTURE_COORD_3* = 0x00000D95 - GL_MAP1_TEXTURE_COORD_4* = 0x00000D96 - GL_MAP1_VERTEX_3* = 0x00000D97 - GL_MAP1_VERTEX_4* = 0x00000D98 - GL_MAP2_COLOR_4* = 0x00000DB0 - GL_MAP2_INDEX* = 0x00000DB1 - GL_MAP2_NORMAL* = 0x00000DB2 - GL_MAP2_TEXTURE_COORD_1* = 0x00000DB3 - GL_MAP2_TEXTURE_COORD_2* = 0x00000DB4 - GL_MAP2_TEXTURE_COORD_3* = 0x00000DB5 - GL_MAP2_TEXTURE_COORD_4* = 0x00000DB6 - GL_MAP2_VERTEX_3* = 0x00000DB7 - GL_MAP2_VERTEX_4* = 0x00000DB8 - GL_MAP1_GRID_DOMAIN* = 0x00000DD0 - GL_MAP1_GRID_SEGMENTS* = 0x00000DD1 - GL_MAP2_GRID_DOMAIN* = 0x00000DD2 - GL_MAP2_GRID_SEGMENTS* = 0x00000DD3 - GL_TEXTURE_1D* = 0x00000DE0 - GL_TEXTURE_2D* = 0x00000DE1 - GL_FEEDBACK_BUFFER_POINTER* = 0x00000DF0 - GL_FEEDBACK_BUFFER_SIZE* = 0x00000DF1 - GL_FEEDBACK_BUFFER_TYPE* = 0x00000DF2 - GL_SELECTION_BUFFER_POINTER* = 0x00000DF3 - GL_SELECTION_BUFFER_SIZE* = 0x00000DF4 # GL_TEXTURE_BINDING_1D - # GL_TEXTURE_BINDING_2D - # GL_VERTEX_ARRAY - # GL_NORMAL_ARRAY - # GL_COLOR_ARRAY - # GL_INDEX_ARRAY - # GL_TEXTURE_COORD_ARRAY - # GL_EDGE_FLAG_ARRAY - # GL_VERTEX_ARRAY_SIZE - # GL_VERTEX_ARRAY_TYPE - # GL_VERTEX_ARRAY_STRIDE - # GL_NORMAL_ARRAY_TYPE - # GL_NORMAL_ARRAY_STRIDE - # GL_COLOR_ARRAY_SIZE - # GL_COLOR_ARRAY_TYPE - # GL_COLOR_ARRAY_STRIDE - # GL_INDEX_ARRAY_TYPE - # GL_INDEX_ARRAY_STRIDE - # GL_TEXTURE_COORD_ARRAY_SIZE - # GL_TEXTURE_COORD_ARRAY_TYPE - # GL_TEXTURE_COORD_ARRAY_STRIDE - # GL_EDGE_FLAG_ARRAY_STRIDE - # GL_POLYGON_OFFSET_FACTOR - # GL_POLYGON_OFFSET_UNITS - # GetTextureParameter - # GL_TEXTURE_MAG_FILTER - # GL_TEXTURE_MIN_FILTER - # GL_TEXTURE_WRAP_S - # GL_TEXTURE_WRAP_T - GL_TEXTURE_WIDTH* = 0x00001000 - GL_TEXTURE_HEIGHT* = 0x00001001 - GL_TEXTURE_INTERNAL_FORMAT* = 0x00001003 - GL_TEXTURE_BORDER_COLOR* = 0x00001004 - GL_TEXTURE_BORDER* = 0x00001005 # GL_TEXTURE_RED_SIZE - # GL_TEXTURE_GREEN_SIZE - # GL_TEXTURE_BLUE_SIZE - # GL_TEXTURE_ALPHA_SIZE - # GL_TEXTURE_LUMINANCE_SIZE - # GL_TEXTURE_INTENSITY_SIZE - # GL_TEXTURE_PRIORITY - # GL_TEXTURE_RESIDENT - # HintMode - GL_DONT_CARE* = 0x00001100 - GL_FASTEST* = 0x00001101 - GL_NICEST* = 0x00001102 # HintTarget - # GL_PERSPECTIVE_CORRECTION_HINT - # GL_POINT_SMOOTH_HINT - # GL_LINE_SMOOTH_HINT - # GL_POLYGON_SMOOTH_HINT - # GL_FOG_HINT - # IndexPointerType - # GL_SHORT - # GL_INT - # GL_FLOAT - # GL_DOUBLE - # LightModelParameter - # GL_LIGHT_MODEL_AMBIENT - # GL_LIGHT_MODEL_LOCAL_VIEWER - # GL_LIGHT_MODEL_TWO_SIDE - # LightName - GL_LIGHT0* = 0x00004000 - GL_LIGHT1* = 0x00004001 - GL_LIGHT2* = 0x00004002 - GL_LIGHT3* = 0x00004003 - GL_LIGHT4* = 0x00004004 - GL_LIGHT5* = 0x00004005 - GL_LIGHT6* = 0x00004006 - GL_LIGHT7* = 0x00004007 # LightParameter - GL_AMBIENT* = 0x00001200 - GL_DIFFUSE* = 0x00001201 - GL_SPECULAR* = 0x00001202 - GL_POSITION* = 0x00001203 - GL_SPOT_DIRECTION* = 0x00001204 - GL_SPOT_EXPONENT* = 0x00001205 - GL_SPOT_CUTOFF* = 0x00001206 - GL_CONSTANT_ATTENUATION* = 0x00001207 - GL_LINEAR_ATTENUATION* = 0x00001208 - GL_QUADRATIC_ATTENUATION* = 0x00001209 # InterleavedArrays - # GL_V2F - # GL_V3F - # GL_C4UB_V2F - # GL_C4UB_V3F - # GL_C3F_V3F - # GL_N3F_V3F - # GL_C4F_N3F_V3F - # GL_T2F_V3F - # GL_T4F_V4F - # GL_T2F_C4UB_V3F - # GL_T2F_C3F_V3F - # GL_T2F_N3F_V3F - # GL_T2F_C4F_N3F_V3F - # GL_T4F_C4F_N3F_V4F - # ListMode - GL_COMPILE* = 0x00001300 - GL_COMPILE_AND_EXECUTE* = 0x00001301 # ListNameType - # GL_BYTE - # GL_UNSIGNED_BYTE - # GL_SHORT - # GL_UNSIGNED_SHORT - # GL_INT - # GL_UNSIGNED_INT - # GL_FLOAT - # GL_2_BYTES - # GL_3_BYTES - # GL_4_BYTES - # LogicOp - constGL_CLEAR* = 0x00001500 - GL_AND* = 0x00001501 - GL_AND_REVERSE* = 0x00001502 - GL_COPY* = 0x00001503 - GL_AND_INVERTED* = 0x00001504 - GL_NOOP* = 0x00001505 - GL_XOR* = 0x00001506 - GL_OR* = 0x00001507 - GL_NOR* = 0x00001508 - GL_EQUIV* = 0x00001509 - GL_INVERT* = 0x0000150A - GL_OR_REVERSE* = 0x0000150B - GL_COPY_INVERTED* = 0x0000150C - GL_OR_INVERTED* = 0x0000150D - GL_NAND* = 0x0000150E - GL_SET* = 0x0000150F # MapTarget - # GL_MAP1_COLOR_4 - # GL_MAP1_INDEX - # GL_MAP1_NORMAL - # GL_MAP1_TEXTURE_COORD_1 - # GL_MAP1_TEXTURE_COORD_2 - # GL_MAP1_TEXTURE_COORD_3 - # GL_MAP1_TEXTURE_COORD_4 - # GL_MAP1_VERTEX_3 - # GL_MAP1_VERTEX_4 - # GL_MAP2_COLOR_4 - # GL_MAP2_INDEX - # GL_MAP2_NORMAL - # GL_MAP2_TEXTURE_COORD_1 - # GL_MAP2_TEXTURE_COORD_2 - # GL_MAP2_TEXTURE_COORD_3 - # GL_MAP2_TEXTURE_COORD_4 - # GL_MAP2_VERTEX_3 - # GL_MAP2_VERTEX_4 - # MaterialFace - # GL_FRONT - # GL_BACK - # GL_FRONT_AND_BACK - # MaterialParameter - GL_EMISSION* = 0x00001600 - GL_SHININESS* = 0x00001601 - GL_AMBIENT_AND_DIFFUSE* = 0x00001602 - GL_COLOR_INDEXES* = 0x00001603 # GL_AMBIENT - # GL_DIFFUSE - # GL_SPECULAR - # MatrixMode - GL_MODELVIEW* = 0x00001700 - GL_PROJECTION* = 0x00001701 - GL_TEXTURE* = 0x00001702 # MeshMode1 - # GL_POINT - # GL_LINE - # MeshMode2 - # GL_POINT - # GL_LINE - # GL_FILL - # NormalPointerType - # GL_BYTE - # GL_SHORT - # GL_INT - # GL_FLOAT - # GL_DOUBLE - # PixelCopyType - GL_COLOR* = 0x00001800 - GL_DEPTH* = 0x00001801 - GL_STENCIL* = 0x00001802 # PixelFormat - GL_COLOR_INDEX* = 0x00001900 - GL_STENCIL_INDEX* = 0x00001901 - GL_DEPTH_COMPONENT* = 0x00001902 - GL_RED* = 0x00001903 - GL_GREEN* = 0x00001904 - GL_BLUE* = 0x00001905 - GL_ALPHA* = 0x00001906 - GL_RGB* = 0x00001907 - GL_RGBA* = 0x00001908 - GL_LUMINANCE* = 0x00001909 - GL_LUMINANCE_ALPHA* = 0x0000190A # PixelMap - # GL_PIXEL_MAP_I_TO_I - # GL_PIXEL_MAP_S_TO_S - # GL_PIXEL_MAP_I_TO_R - # GL_PIXEL_MAP_I_TO_G - # GL_PIXEL_MAP_I_TO_B - # GL_PIXEL_MAP_I_TO_A - # GL_PIXEL_MAP_R_TO_R - # GL_PIXEL_MAP_G_TO_G - # GL_PIXEL_MAP_B_TO_B - # GL_PIXEL_MAP_A_TO_A - # PixelStore - # GL_UNPACK_SWAP_BYTES - # GL_UNPACK_LSB_FIRST - # GL_UNPACK_ROW_LENGTH - # GL_UNPACK_SKIP_ROWS - # GL_UNPACK_SKIP_PIXELS - # GL_UNPACK_ALIGNMENT - # GL_PACK_SWAP_BYTES - # GL_PACK_LSB_FIRST - # GL_PACK_ROW_LENGTH - # GL_PACK_SKIP_ROWS - # GL_PACK_SKIP_PIXELS - # GL_PACK_ALIGNMENT - # PixelTransfer - # GL_MAP_COLOR - # GL_MAP_STENCIL - # GL_INDEX_SHIFT - # GL_INDEX_OFFSET - # GL_RED_SCALE - # GL_RED_BIAS - # GL_GREEN_SCALE - # GL_GREEN_BIAS - # GL_BLUE_SCALE - # GL_BLUE_BIAS - # GL_ALPHA_SCALE - # GL_ALPHA_BIAS - # GL_DEPTH_SCALE - # GL_DEPTH_BIAS - # PixelType - constGL_BITMAP* = 0x00001A00 - GL_POINT* = 0x00001B00 - GL_LINE* = 0x00001B01 - GL_FILL* = 0x00001B02 # ReadBufferMode - # GL_FRONT_LEFT - # GL_FRONT_RIGHT - # GL_BACK_LEFT - # GL_BACK_RIGHT - # GL_FRONT - # GL_BACK - # GL_LEFT - # GL_RIGHT - # GL_AUX0 - # GL_AUX1 - # GL_AUX2 - # GL_AUX3 - # RenderingMode - GL_RENDER* = 0x00001C00 - GL_FEEDBACK* = 0x00001C01 - GL_SELECT* = 0x00001C02 # ShadingModel - GL_FLAT* = 0x00001D00 - GL_SMOOTH* = 0x00001D01 # StencilFunction - # GL_NEVER - # GL_LESS - # GL_EQUAL - # GL_LEQUAL - # GL_GREATER - # GL_NOTEQUAL - # GL_GEQUAL - # GL_ALWAYS - # StencilOp - # GL_ZERO - GL_KEEP* = 0x00001E00 - GL_REPLACE* = 0x00001E01 - GL_INCR* = 0x00001E02 - GL_DECR* = 0x00001E03 # GL_INVERT - # StringName - GL_VENDOR* = 0x00001F00 - GL_RENDERER* = 0x00001F01 - GL_VERSION* = 0x00001F02 - GL_EXTENSIONS* = 0x00001F03 # TextureCoordName - GL_S* = 0x00002000 - GL_T* = 0x00002001 - GL_R* = 0x00002002 - GL_Q* = 0x00002003 # TexCoordPointerType - # GL_SHORT - # GL_INT - # GL_FLOAT - # GL_DOUBLE - # TextureEnvMode - GL_MODULATE* = 0x00002100 - GL_DECAL* = 0x00002101 # GL_BLEND - # GL_REPLACE - # TextureEnvParameter - GL_TEXTURE_ENV_MODE* = 0x00002200 - GL_TEXTURE_ENV_COLOR* = 0x00002201 # TextureEnvTarget - GL_TEXTURE_ENV* = 0x00002300 # TextureGenMode - GL_EYE_LINEAR* = 0x00002400 - GL_OBJECT_LINEAR* = 0x00002401 - GL_SPHERE_MAP* = 0x00002402 # TextureGenParameter - GL_TEXTURE_GEN_MODE* = 0x00002500 - GL_OBJECT_PLANE* = 0x00002501 - GL_EYE_PLANE* = 0x00002502 # TextureMagFilter - GL_NEAREST* = 0x00002600 - GL_LINEAR* = 0x00002601 # TextureMinFilter - # GL_NEAREST - # GL_LINEAR - GL_NEAREST_MIPMAP_NEAREST* = 0x00002700 - GL_LINEAR_MIPMAP_NEAREST* = 0x00002701 - GL_NEAREST_MIPMAP_LINEAR* = 0x00002702 - GL_LINEAR_MIPMAP_LINEAR* = 0x00002703 # TextureParameterName - GL_TEXTURE_MAG_FILTER* = 0x00002800 - GL_TEXTURE_MIN_FILTER* = 0x00002801 - GL_TEXTURE_WRAP_S* = 0x00002802 - GL_TEXTURE_WRAP_T* = 0x00002803 # GL_TEXTURE_BORDER_COLOR - # GL_TEXTURE_PRIORITY - # TextureTarget - # GL_TEXTURE_1D - # GL_TEXTURE_2D - # GL_PROXY_TEXTURE_1D - # GL_PROXY_TEXTURE_2D - # TextureWrapMode - GL_CLAMP* = 0x00002900 - GL_REPEAT* = 0x00002901 # VertexPointerType - # GL_SHORT - # GL_INT - # GL_FLOAT - # GL_DOUBLE - # ClientAttribMask - GL_CLIENT_PIXEL_STORE_BIT* = 0x00000001 - GL_CLIENT_VERTEX_ARRAY_BIT* = 0x00000002 - GL_CLIENT_ALL_ATTRIB_BITS* = 0xFFFFFFFF # polygon_offset - GL_POLYGON_OFFSET_FACTOR* = 0x00008038 - GL_POLYGON_OFFSET_UNITS* = 0x00002A00 - GL_POLYGON_OFFSET_POINT* = 0x00002A01 - GL_POLYGON_OFFSET_LINE* = 0x00002A02 - GL_POLYGON_OFFSET_FILL* = 0x00008037 # texture - GL_ALPHA4* = 0x0000803B - GL_ALPHA8* = 0x0000803C - GL_ALPHA12* = 0x0000803D - GL_ALPHA16* = 0x0000803E - GL_LUMINANCE4* = 0x0000803F - GL_LUMINANCE8* = 0x00008040 - GL_LUMINANCE12* = 0x00008041 - GL_LUMINANCE16* = 0x00008042 - GL_LUMINANCE4_ALPHA4* = 0x00008043 - GL_LUMINANCE6_ALPHA2* = 0x00008044 - GL_LUMINANCE8_ALPHA8* = 0x00008045 - GL_LUMINANCE12_ALPHA4* = 0x00008046 - GL_LUMINANCE12_ALPHA12* = 0x00008047 - GL_LUMINANCE16_ALPHA16* = 0x00008048 - GL_INTENSITY* = 0x00008049 - GL_INTENSITY4* = 0x0000804A - GL_INTENSITY8* = 0x0000804B - GL_INTENSITY12* = 0x0000804C - GL_INTENSITY16* = 0x0000804D - GL_R3_G3_B2* = 0x00002A10 - GL_RGB4* = 0x0000804F - GL_RGB5* = 0x00008050 - GL_RGB8* = 0x00008051 - GL_RGB10* = 0x00008052 - GL_RGB12* = 0x00008053 - GL_RGB16* = 0x00008054 - GL_RGBA2* = 0x00008055 - GL_RGBA4* = 0x00008056 - GL_RGB5_A1* = 0x00008057 - GL_RGBA8* = 0x00008058 - GL_RGB10_A2* = 0x00008059 - GL_RGBA12* = 0x0000805A - GL_RGBA16* = 0x0000805B - GL_TEXTURE_RED_SIZE* = 0x0000805C - GL_TEXTURE_GREEN_SIZE* = 0x0000805D - GL_TEXTURE_BLUE_SIZE* = 0x0000805E - GL_TEXTURE_ALPHA_SIZE* = 0x0000805F - GL_TEXTURE_LUMINANCE_SIZE* = 0x00008060 - GL_TEXTURE_INTENSITY_SIZE* = 0x00008061 - GL_PROXY_TEXTURE_1D* = 0x00008063 - GL_PROXY_TEXTURE_2D* = 0x00008064 # texture_object - GL_TEXTURE_PRIORITY* = 0x00008066 - GL_TEXTURE_RESIDENT* = 0x00008067 - GL_TEXTURE_BINDING_1D* = 0x00008068 - GL_TEXTURE_BINDING_2D* = 0x00008069 # vertex_array - GL_VERTEX_ARRAY* = 0x00008074 - GL_NORMAL_ARRAY* = 0x00008075 - GL_COLOR_ARRAY* = 0x00008076 - GL_INDEX_ARRAY* = 0x00008077 - GL_TEXTURE_COORD_ARRAY* = 0x00008078 - GL_EDGE_FLAG_ARRAY* = 0x00008079 - GL_VERTEX_ARRAY_SIZE* = 0x0000807A - GL_VERTEX_ARRAY_TYPE* = 0x0000807B - GL_VERTEX_ARRAY_STRIDE* = 0x0000807C - GL_NORMAL_ARRAY_TYPE* = 0x0000807E - GL_NORMAL_ARRAY_STRIDE* = 0x0000807F - GL_COLOR_ARRAY_SIZE* = 0x00008081 - GL_COLOR_ARRAY_TYPE* = 0x00008082 - GL_COLOR_ARRAY_STRIDE* = 0x00008083 - GL_INDEX_ARRAY_TYPE* = 0x00008085 - GL_INDEX_ARRAY_STRIDE* = 0x00008086 - GL_TEXTURE_COORD_ARRAY_SIZE* = 0x00008088 - GL_TEXTURE_COORD_ARRAY_TYPE* = 0x00008089 - GL_TEXTURE_COORD_ARRAY_STRIDE* = 0x0000808A - GL_EDGE_FLAG_ARRAY_STRIDE* = 0x0000808C - GL_VERTEX_ARRAY_POINTER* = 0x0000808E - GL_NORMAL_ARRAY_POINTER* = 0x0000808F - GL_COLOR_ARRAY_POINTER* = 0x00008090 - GL_INDEX_ARRAY_POINTER* = 0x00008091 - GL_TEXTURE_COORD_ARRAY_POINTER* = 0x00008092 - GL_EDGE_FLAG_ARRAY_POINTER* = 0x00008093 - GL_V2F* = 0x00002A20 - GL_V3F* = 0x00002A21 - GL_C4UB_V2F* = 0x00002A22 - GL_C4UB_V3F* = 0x00002A23 - GL_C3F_V3F* = 0x00002A24 - GL_N3F_V3F* = 0x00002A25 - GL_C4F_N3F_V3F* = 0x00002A26 - GL_T2F_V3F* = 0x00002A27 - GL_T4F_V4F* = 0x00002A28 - GL_T2F_C4UB_V3F* = 0x00002A29 - GL_T2F_C3F_V3F* = 0x00002A2A - GL_T2F_N3F_V3F* = 0x00002A2B - GL_T2F_C4F_N3F_V3F* = 0x00002A2C - GL_T4F_C4F_N3F_V4F* = 0x00002A2D # Extensions - GL_EXT_vertex_array* = 1 - GL_WIN_swap_hint* = 1 - GL_EXT_bgra* = 1 - GL_EXT_paletted_texture* = 1 # EXT_vertex_array - GL_VERTEX_ARRAY_EXT* = 0x00008074 - GL_NORMAL_ARRAY_EXT* = 0x00008075 - GL_COLOR_ARRAY_EXT* = 0x00008076 - GL_INDEX_ARRAY_EXT* = 0x00008077 - GL_TEXTURE_COORD_ARRAY_EXT* = 0x00008078 - GL_EDGE_FLAG_ARRAY_EXT* = 0x00008079 - GL_VERTEX_ARRAY_SIZE_EXT* = 0x0000807A - GL_VERTEX_ARRAY_TYPE_EXT* = 0x0000807B - GL_VERTEX_ARRAY_STRIDE_EXT* = 0x0000807C - GL_VERTEX_ARRAY_COUNT_EXT* = 0x0000807D - GL_NORMAL_ARRAY_TYPE_EXT* = 0x0000807E - GL_NORMAL_ARRAY_STRIDE_EXT* = 0x0000807F - GL_NORMAL_ARRAY_COUNT_EXT* = 0x00008080 - GL_COLOR_ARRAY_SIZE_EXT* = 0x00008081 - GL_COLOR_ARRAY_TYPE_EXT* = 0x00008082 - GL_COLOR_ARRAY_STRIDE_EXT* = 0x00008083 - GL_COLOR_ARRAY_COUNT_EXT* = 0x00008084 - GL_INDEX_ARRAY_TYPE_EXT* = 0x00008085 - GL_INDEX_ARRAY_STRIDE_EXT* = 0x00008086 - GL_INDEX_ARRAY_COUNT_EXT* = 0x00008087 - GL_TEXTURE_COORD_ARRAY_SIZE_EXT* = 0x00008088 - GL_TEXTURE_COORD_ARRAY_TYPE_EXT* = 0x00008089 - GL_TEXTURE_COORD_ARRAY_STRIDE_EXT* = 0x0000808A - GL_TEXTURE_COORD_ARRAY_COUNT_EXT* = 0x0000808B - GL_EDGE_FLAG_ARRAY_STRIDE_EXT* = 0x0000808C - GL_EDGE_FLAG_ARRAY_COUNT_EXT* = 0x0000808D - GL_VERTEX_ARRAY_POINTER_EXT* = 0x0000808E - GL_NORMAL_ARRAY_POINTER_EXT* = 0x0000808F - GL_COLOR_ARRAY_POINTER_EXT* = 0x00008090 - GL_INDEX_ARRAY_POINTER_EXT* = 0x00008091 - GL_TEXTURE_COORD_ARRAY_POINTER_EXT* = 0x00008092 - GL_EDGE_FLAG_ARRAY_POINTER_EXT* = 0x00008093 - GL_DOUBLE_EXT* = GL_DOUBLE # EXT_bgra - GL_BGR_EXT* = 0x000080E0 - GL_BGRA_EXT* = 0x000080E1 # EXT_paletted_texture - # These must match the GL_COLOR_TABLE_*_SGI enumerants - GL_COLOR_TABLE_FORMAT_EXT* = 0x000080D8 - GL_COLOR_TABLE_WIDTH_EXT* = 0x000080D9 - GL_COLOR_TABLE_RED_SIZE_EXT* = 0x000080DA - GL_COLOR_TABLE_GREEN_SIZE_EXT* = 0x000080DB - GL_COLOR_TABLE_BLUE_SIZE_EXT* = 0x000080DC - GL_COLOR_TABLE_ALPHA_SIZE_EXT* = 0x000080DD - GL_COLOR_TABLE_LUMINANCE_SIZE_EXT* = 0x000080DE - GL_COLOR_TABLE_INTENSITY_SIZE_EXT* = 0x000080DF - GL_COLOR_INDEX1_EXT* = 0x000080E2 - GL_COLOR_INDEX2_EXT* = 0x000080E3 - GL_COLOR_INDEX4_EXT* = 0x000080E4 - GL_COLOR_INDEX8_EXT* = 0x000080E5 - GL_COLOR_INDEX12_EXT* = 0x000080E6 - GL_COLOR_INDEX16_EXT* = 0x000080E7 # For compatibility with OpenGL v1.0 - constGL_LOGIC_OP* = GL_INDEX_LOGIC_OP - GL_TEXTURE_COMPONENTS* = GL_TEXTURE_INTERNAL_FORMAT - -proc glAccum*(op: TGLenum, value: TGLfloat){.dynlib: dllname, importc: "glAccum".} -proc glAlphaFunc*(func: TGLenum, theref: TGLclampf){.dynlib: dllname, - importc: "glAlphaFunc".} -proc glAreTexturesResident*(n: TGLsizei, textures: PGLuint, - residences: PGLboolean): TGLboolean{. - dynlib: dllname, importc: "glAreTexturesResident".} -proc glArrayElement*(i: TGLint){.dynlib: dllname, importc: "glArrayElement".} -proc glBegin*(mode: TGLenum){.dynlib: dllname, importc: "glBegin".} -proc glBindTexture*(target: TGLenum, texture: TGLuint){.dynlib: dllname, - importc: "glBindTexture".} -proc glBitmap*(width, height: TGLsizei, xorig, yorig: TGLfloat, - xmove, ymove: TGLfloat, bitmap: PGLubyte){.dynlib: dllname, - importc: "glBitmap".} -proc glBlendFunc*(sfactor, dfactor: TGLenum){.dynlib: dllname, - importc: "glBlendFunc".} -proc glCallList*(list: TGLuint){.dynlib: dllname, importc: "glCallList".} -proc glCallLists*(n: TGLsizei, atype: TGLenum, lists: Pointer){.dynlib: dllname, - importc: "glCallLists".} -proc glClear*(mask: TGLbitfield){.dynlib: dllname, importc: "glClear".} -proc glClearAccum*(red, green, blue, alpha: TGLfloat){.dynlib: dllname, - importc: "glClearAccum".} -proc glClearColor*(red, green, blue, alpha: TGLclampf){.dynlib: dllname, - importc: "glClearColor".} -proc glClearDepth*(depth: TGLclampd){.dynlib: dllname, importc: "glClearDepth".} -proc glClearIndex*(c: TGLfloat){.dynlib: dllname, importc: "glClearIndex".} -proc glClearStencil*(s: TGLint){.dynlib: dllname, importc: "glClearStencil".} -proc glClipPlane*(plane: TGLenum, equation: PGLdouble){.dynlib: dllname, - importc: "glClipPlane".} -proc glColor3b*(red, green, blue: TGlbyte){.dynlib: dllname, - importc: "glColor3b".} -proc glColor3bv*(v: PGLbyte){.dynlib: dllname, importc: "glColor3bv".} -proc glColor3d*(red, green, blue: TGLdouble){.dynlib: dllname, - importc: "glColor3d".} -proc glColor3dv*(v: PGLdouble){.dynlib: dllname, importc: "glColor3dv".} -proc glColor3f*(red, green, blue: TGLfloat){.dynlib: dllname, - importc: "glColor3f".} -proc glColor3fv*(v: PGLfloat){.dynlib: dllname, importc: "glColor3fv".} -proc glColor3i*(red, green, blue: TGLint){.dynlib: dllname, importc: "glColor3i".} -proc glColor3iv*(v: PGLint){.dynlib: dllname, importc: "glColor3iv".} -proc glColor3s*(red, green, blue: TGLshort){.dynlib: dllname, - importc: "glColor3s".} -proc glColor3sv*(v: PGLshort){.dynlib: dllname, importc: "glColor3sv".} -proc glColor3ub*(red, green, blue: TGLubyte){.dynlib: dllname, - importc: "glColor3ub".} -proc glColor3ubv*(v: PGLubyte){.dynlib: dllname, importc: "glColor3ubv".} -proc glColor3ui*(red, green, blue: TGLuint){.dynlib: dllname, - importc: "glColor3ui".} -proc glColor3uiv*(v: PGLuint){.dynlib: dllname, importc: "glColor3uiv".} -proc glColor3us*(red, green, blue: TGLushort){.dynlib: dllname, - importc: "glColor3us".} -proc glColor3usv*(v: PGLushort){.dynlib: dllname, importc: "glColor3usv".} -proc glColor4b*(red, green, blue, alpha: TGlbyte){.dynlib: dllname, - importc: "glColor4b".} -proc glColor4bv*(v: PGLbyte){.dynlib: dllname, importc: "glColor4bv".} -proc glColor4d*(red, green, blue, alpha: TGLdouble){.dynlib: dllname, - importc: "glColor4d".} -proc glColor4dv*(v: PGLdouble){.dynlib: dllname, importc: "glColor4dv".} -proc glColor4f*(red, green, blue, alpha: TGLfloat){.dynlib: dllname, - importc: "glColor4f".} -proc glColor4fv*(v: PGLfloat){.dynlib: dllname, importc: "glColor4fv".} -proc glColor4i*(red, green, blue, alpha: TGLint){.dynlib: dllname, - importc: "glColor4i".} -proc glColor4iv*(v: PGLint){.dynlib: dllname, importc: "glColor4iv".} -proc glColor4s*(red, green, blue, alpha: TGLshort){.dynlib: dllname, - importc: "glColor4s".} -proc glColor4sv*(v: PGLshort){.dynlib: dllname, importc: "glColor4sv".} -proc glColor4ub*(red, green, blue, alpha: TGLubyte){.dynlib: dllname, - importc: "glColor4ub".} -proc glColor4ubv*(v: PGLubyte){.dynlib: dllname, importc: "glColor4ubv".} -proc glColor4ui*(red, green, blue, alpha: TGLuint){.dynlib: dllname, - importc: "glColor4ui".} -proc glColor4uiv*(v: PGLuint){.dynlib: dllname, importc: "glColor4uiv".} -proc glColor4us*(red, green, blue, alpha: TGLushort){.dynlib: dllname, - importc: "glColor4us".} -proc glColor4usv*(v: PGLushort){.dynlib: dllname, importc: "glColor4usv".} -proc glColorMask*(red, green, blue, alpha: TGLboolean){.dynlib: dllname, - importc: "glColorMask".} -proc glColorMaterial*(face, mode: TGLenum){.dynlib: dllname, - importc: "glColorMaterial".} -proc glColorPointer*(size: TGLint, atype: TGLenum, stride: TGLsizei, - pointer: Pointer){.dynlib: dllname, - importc: "glColorPointer".} -proc glCopyPixels*(x, y: TGLint, width, height: TGLsizei, atype: TGLenum){. - dynlib: dllname, importc: "glCopyPixels".} -proc glCopyTexImage1D*(target: TGLenum, level: TGLint, internalFormat: TGLenum, - x, y: TGLint, width: TGLsizei, border: TGLint){. - dynlib: dllname, importc: "glCopyTexImage1D".} -proc glCopyTexImage2D*(target: TGLenum, level: TGLint, internalFormat: TGLenum, - x, y: TGLint, width, height: TGLsizei, border: TGLint){. - dynlib: dllname, importc: "glCopyTexImage2D".} -proc glCopyTexSubImage1D*(target: TGLenum, level, xoffset, x, y: TGLint, - width: TGLsizei){.dynlib: dllname, - importc: "glCopyTexSubImage1D".} -proc glCopyTexSubImage2D*(target: TGLenum, - level, xoffset, yoffset, x, y: TGLint, - width, height: TGLsizei){.dynlib: dllname, - importc: "glCopyTexSubImage2D".} -proc glCullFace*(mode: TGLenum){.dynlib: dllname, importc: "glCullFace".} -proc glDeleteLists*(list: TGLuint, range: TGLsizei){.dynlib: dllname, - importc: "glDeleteLists".} -proc glDeleteTextures*(n: TGLsizei, textures: PGLuint){.dynlib: dllname, - importc: "glDeleteTextures".} -proc glDepthFunc*(func: TGLenum){.dynlib: dllname, importc: "glDepthFunc".} -proc glDepthMask*(flag: TGLboolean){.dynlib: dllname, importc: "glDepthMask".} -proc glDepthRange*(zNear, zFar: TGLclampd){.dynlib: dllname, - importc: "glDepthRange".} -proc glDisable*(cap: TGLenum){.dynlib: dllname, importc: "glDisable".} -proc glDisableClientState*(aarray: TGLenum){.dynlib: dllname, - importc: "glDisableClientState".} -proc glDrawArrays*(mode: TGLenum, first: TGLint, count: TGLsizei){. - dynlib: dllname, importc: "glDrawArrays".} -proc glDrawBuffer*(mode: TGLenum){.dynlib: dllname, importc: "glDrawBuffer".} -proc glDrawElements*(mode: TGLenum, count: TGLsizei, atype: TGLenum, - indices: Pointer){.dynlib: dllname, - importc: "glDrawElements".} -proc glDrawPixels*(width, height: TGLsizei, format, atype: TGLenum, - pixels: Pointer){.dynlib: dllname, importc: "glDrawPixels".} -proc glEdgeFlag*(flag: TGLboolean){.dynlib: dllname, importc: "glEdgeFlag".} -proc glEdgeFlagPointer*(stride: TGLsizei, pointer: Pointer){.dynlib: dllname, - importc: "glEdgeFlagPointer".} -proc glEdgeFlagv*(flag: PGLboolean){.dynlib: dllname, importc: "glEdgeFlagv".} -proc glEnable*(cap: TGLenum){.dynlib: dllname, importc: "glEnable".} -proc glEnableClientState*(aarray: TGLenum){.dynlib: dllname, - importc: "glEnableClientState".} -proc glEnd*(){.dynlib: dllname, importc: "glEnd".} -proc glEndList*(){.dynlib: dllname, importc: "glEndList".} -proc glEvalCoord1d*(u: TGLdouble){.dynlib: dllname, importc: "glEvalCoord1d".} -proc glEvalCoord1dv*(u: PGLdouble){.dynlib: dllname, importc: "glEvalCoord1dv".} -proc glEvalCoord1f*(u: TGLfloat){.dynlib: dllname, importc: "glEvalCoord1f".} -proc glEvalCoord1fv*(u: PGLfloat){.dynlib: dllname, importc: "glEvalCoord1fv".} -proc glEvalCoord2d*(u, v: TGLdouble){.dynlib: dllname, importc: "glEvalCoord2d".} -proc glEvalCoord2dv*(u: PGLdouble){.dynlib: dllname, importc: "glEvalCoord2dv".} -proc glEvalCoord2f*(u, v: TGLfloat){.dynlib: dllname, importc: "glEvalCoord2f".} -proc glEvalCoord2fv*(u: PGLfloat){.dynlib: dllname, importc: "glEvalCoord2fv".} -proc glEvalMesh1*(mode: TGLenum, i1, i2: TGLint){.dynlib: dllname, - importc: "glEvalMesh1".} -proc glEvalMesh2*(mode: TGLenum, i1, i2, j1, j2: TGLint){.dynlib: dllname, - importc: "glEvalMesh2".} -proc glEvalPoint1*(i: TGLint){.dynlib: dllname, importc: "glEvalPoint1".} -proc glEvalPoint2*(i, j: TGLint){.dynlib: dllname, importc: "glEvalPoint2".} -proc glFeedbackBuffer*(size: TGLsizei, atype: TGLenum, buffer: PGLfloat){. - dynlib: dllname, importc: "glFeedbackBuffer".} -proc glFinish*(){.dynlib: dllname, importc: "glFinish".} -proc glFlush*(){.dynlib: dllname, importc: "glFlush".} -proc glFogf*(pname: TGLenum, param: TGLfloat){.dynlib: dllname, - importc: "glFogf".} -proc glFogfv*(pname: TGLenum, params: PGLfloat){.dynlib: dllname, - importc: "glFogfv".} -proc glFogi*(pname: TGLenum, param: TGLint){.dynlib: dllname, importc: "glFogi".} -proc glFogiv*(pname: TGLenum, params: PGLint){.dynlib: dllname, - importc: "glFogiv".} -proc glFrontFace*(mode: TGLenum){.dynlib: dllname, importc: "glFrontFace".} -proc glFrustum*(left, right, bottom, top, zNear, zFar: TGLdouble){. - dynlib: dllname, importc: "glFrustum".} -proc glGenLists*(range: TGLsizei): TGLuint{.dynlib: dllname, - importc: "glGenLists".} -proc glGenTextures*(n: TGLsizei, textures: PGLuint){.dynlib: dllname, - importc: "glGenTextures".} -proc glGetBooleanv*(pname: TGLenum, params: PGLboolean){.dynlib: dllname, - importc: "glGetBooleanv".} -proc glGetClipPlane*(plane: TGLenum, equation: PGLdouble){.dynlib: dllname, - importc: "glGetClipPlane".} -proc glGetDoublev*(pname: TGLenum, params: PGLdouble){.dynlib: dllname, - importc: "glGetDoublev".} -proc glGetError*(): TGLenum{.dynlib: dllname, importc: "glGetError".} -proc glGetFloatv*(pname: TGLenum, params: PGLfloat){.dynlib: dllname, - importc: "glGetFloatv".} -proc glGetIntegerv*(pname: TGLenum, params: PGLint){.dynlib: dllname, - importc: "glGetIntegerv".} -proc glGetLightfv*(light, pname: TGLenum, params: PGLfloat){.dynlib: dllname, - importc: "glGetLightfv".} -proc glGetLightiv*(light, pname: TGLenum, params: PGLint){.dynlib: dllname, - importc: "glGetLightiv".} -proc glGetMapdv*(target, query: TGLenum, v: PGLdouble){.dynlib: dllname, - importc: "glGetMapdv".} -proc glGetMapfv*(target, query: TGLenum, v: PGLfloat){.dynlib: dllname, - importc: "glGetMapfv".} -proc glGetMapiv*(target, query: TGLenum, v: PGLint){.dynlib: dllname, - importc: "glGetMapiv".} -proc glGetMaterialfv*(face, pname: TGLenum, params: PGLfloat){.dynlib: dllname, - importc: "glGetMaterialfv".} -proc glGetMaterialiv*(face, pname: TGLenum, params: PGLint){.dynlib: dllname, - importc: "glGetMaterialiv".} -proc glGetPixelMapfv*(map: TGLenum, values: PGLfloat){.dynlib: dllname, - importc: "glGetPixelMapfv".} -proc glGetPixelMapuiv*(map: TGLenum, values: PGLuint){.dynlib: dllname, - importc: "glGetPixelMapuiv".} -proc glGetPixelMapusv*(map: TGLenum, values: PGLushort){.dynlib: dllname, - importc: "glGetPixelMapusv".} -proc glGetPointerv*(pname: TGLenum, params: Pointer){.dynlib: dllname, - importc: "glGetPointerv".} -proc glGetPolygonStipple*(mask: PGLubyte){.dynlib: dllname, - importc: "glGetPolygonStipple".} -proc glGetString*(name: TGLenum): cstring{.dynlib: dllname, - importc: "glGetString".} -proc glGetTexEnvfv*(target, pname: TGLenum, params: PGLfloat){.dynlib: dllname, - importc: "glGetTexEnvfv".} -proc glGetTexEnviv*(target, pname: TGLenum, params: PGLint){.dynlib: dllname, - importc: "glGetTexEnviv".} -proc glGetTexGendv*(coord, pname: TGLenum, params: PGLdouble){.dynlib: dllname, - importc: "glGetTexGendv".} -proc glGetTexGenfv*(coord, pname: TGLenum, params: PGLfloat){.dynlib: dllname, - importc: "glGetTexGenfv".} -proc glGetTexGeniv*(coord, pname: TGLenum, params: PGLint){.dynlib: dllname, - importc: "glGetTexGeniv".} -proc glGetTexImage*(target: TGLenum, level: TGLint, format: TGLenum, - atype: TGLenum, pixels: Pointer){.dynlib: dllname, - importc: "glGetTexImage".} -proc glGetTexLevelParameterfv*(target: TGLenum, level: TGLint, pname: TGLenum, - params: Pointer){.dynlib: dllname, - importc: "glGetTexLevelParameterfv".} -proc glGetTexLevelParameteriv*(target: TGLenum, level: TGLint, pname: TGLenum, - params: PGLint){.dynlib: dllname, - importc: "glGetTexLevelParameteriv".} -proc glGetTexParameterfv*(target, pname: TGLenum, params: PGLfloat){. - dynlib: dllname, importc: "glGetTexParameterfv".} -proc glGetTexParameteriv*(target, pname: TGLenum, params: PGLint){. - dynlib: dllname, importc: "glGetTexParameteriv".} -proc glHint*(target, mode: TGLenum){.dynlib: dllname, importc: "glHint".} -proc glIndexMask*(mask: TGLuint){.dynlib: dllname, importc: "glIndexMask".} -proc glIndexPointer*(atype: TGLenum, stride: TGLsizei, pointer: Pointer){. - dynlib: dllname, importc: "glIndexPointer".} -proc glIndexd*(c: TGLdouble){.dynlib: dllname, importc: "glIndexd".} -proc glIndexdv*(c: PGLdouble){.dynlib: dllname, importc: "glIndexdv".} -proc glIndexf*(c: TGLfloat){.dynlib: dllname, importc: "glIndexf".} -proc glIndexfv*(c: PGLfloat){.dynlib: dllname, importc: "glIndexfv".} -proc glIndexi*(c: TGLint){.dynlib: dllname, importc: "glIndexi".} -proc glIndexiv*(c: PGLint){.dynlib: dllname, importc: "glIndexiv".} -proc glIndexs*(c: TGLshort){.dynlib: dllname, importc: "glIndexs".} -proc glIndexsv*(c: PGLshort){.dynlib: dllname, importc: "glIndexsv".} -proc glIndexub*(c: TGLubyte){.dynlib: dllname, importc: "glIndexub".} -proc glIndexubv*(c: PGLubyte){.dynlib: dllname, importc: "glIndexubv".} -proc glInitNames*(){.dynlib: dllname, importc: "glInitNames".} -proc glInterleavedArrays*(format: TGLenum, stride: TGLsizei, pointer: Pointer){. - dynlib: dllname, importc: "glInterleavedArrays".} -proc glIsEnabled*(cap: TGLenum): TGLboolean{.dynlib: dllname, - importc: "glIsEnabled".} -proc glIsList*(list: TGLuint): TGLboolean{.dynlib: dllname, importc: "glIsList".} -proc glIsTexture*(texture: TGLuint): TGLboolean{.dynlib: dllname, - importc: "glIsTexture".} -proc glLightModelf*(pname: TGLenum, param: TGLfloat){.dynlib: dllname, - importc: "glLightModelf".} -proc glLightModelfv*(pname: TGLenum, params: PGLfloat){.dynlib: dllname, - importc: "glLightModelfv".} -proc glLightModeli*(pname: TGLenum, param: TGLint){.dynlib: dllname, - importc: "glLightModeli".} -proc glLightModeliv*(pname: TGLenum, params: PGLint){.dynlib: dllname, - importc: "glLightModeliv".} -proc glLightf*(light, pname: TGLenum, param: TGLfloat){.dynlib: dllname, - importc: "glLightf".} -proc glLightfv*(light, pname: TGLenum, params: PGLfloat){.dynlib: dllname, - importc: "glLightfv".} -proc glLighti*(light, pname: TGLenum, param: TGLint){.dynlib: dllname, - importc: "glLighti".} -proc glLightiv*(light, pname: TGLenum, params: PGLint){.dynlib: dllname, - importc: "glLightiv".} -proc glLineStipple*(factor: TGLint, pattern: TGLushort){.dynlib: dllname, - importc: "glLineStipple".} -proc glLineWidth*(width: TGLfloat){.dynlib: dllname, importc: "glLineWidth".} -proc glListBase*(base: TGLuint){.dynlib: dllname, importc: "glListBase".} -proc glLoadIdentity*(){.dynlib: dllname, importc: "glLoadIdentity".} -proc glLoadMatrixd*(m: PGLdouble){.dynlib: dllname, importc: "glLoadMatrixd".} -proc glLoadMatrixf*(m: PGLfloat){.dynlib: dllname, importc: "glLoadMatrixf".} -proc glLoadName*(name: TGLuint){.dynlib: dllname, importc: "glLoadName".} -proc glLogicOp*(opcode: TGLenum){.dynlib: dllname, importc: "glLogicOp".} -proc glMap1d*(target: TGLenum, u1, u2: TGLdouble, stride, order: TGLint, - points: PGLdouble){.dynlib: dllname, importc: "glMap1d".} -proc glMap1f*(target: TGLenum, u1, u2: TGLfloat, stride, order: TGLint, - points: PGLfloat){.dynlib: dllname, importc: "glMap1f".} -proc glMap2d*(target: TGLenum, u1, u2: TGLdouble, ustride, uorder: TGLint, - v1, v2: TGLdouble, vstride, vorder: TGLint, points: PGLdouble){. - dynlib: dllname, importc: "glMap2d".} -proc glMap2f*(target: TGLenum, u1, u2: TGLfloat, ustride, uorder: TGLint, - v1, v2: TGLfloat, vstride, vorder: TGLint, points: PGLfloat){. - dynlib: dllname, importc: "glMap2f".} -proc glMapGrid1d*(un: TGLint, u1, u2: TGLdouble){.dynlib: dllname, - importc: "glMapGrid1d".} -proc glMapGrid1f*(un: TGLint, u1, u2: TGLfloat){.dynlib: dllname, - importc: "glMapGrid1f".} -proc glMapGrid2d*(un: TGLint, u1, u2: TGLdouble, vn: TGLint, v1, v2: TGLdouble){. - dynlib: dllname, importc: "glMapGrid2d".} -proc glMapGrid2f*(un: TGLint, u1, u2: TGLfloat, vn: TGLint, v1, v2: TGLfloat){. - dynlib: dllname, importc: "glMapGrid2f".} -proc glMaterialf*(face, pname: TGLenum, param: TGLfloat){.dynlib: dllname, - importc: "glMaterialf".} -proc glMaterialfv*(face, pname: TGLenum, params: PGLfloat){.dynlib: dllname, - importc: "glMaterialfv".} -proc glMateriali*(face, pname: TGLenum, param: TGLint){.dynlib: dllname, - importc: "glMateriali".} -proc glMaterialiv*(face, pname: TGLenum, params: PGLint){.dynlib: dllname, - importc: "glMaterialiv".} -proc glMatrixMode*(mode: TGLenum){.dynlib: dllname, importc: "glMatrixMode".} -proc glMultMatrixd*(m: PGLdouble){.dynlib: dllname, importc: "glMultMatrixd".} -proc glMultMatrixf*(m: PGLfloat){.dynlib: dllname, importc: "glMultMatrixf".} -proc glNewList*(list: TGLuint, mode: TGLenum){.dynlib: dllname, - importc: "glNewList".} -proc glNormal3b*(nx, ny, nz: TGlbyte){.dynlib: dllname, importc: "glNormal3b".} -proc glNormal3bv*(v: PGLbyte){.dynlib: dllname, importc: "glNormal3bv".} -proc glNormal3d*(nx, ny, nz: TGLdouble){.dynlib: dllname, importc: "glNormal3d".} -proc glNormal3dv*(v: PGLdouble){.dynlib: dllname, importc: "glNormal3dv".} -proc glNormal3f*(nx, ny, nz: TGLfloat){.dynlib: dllname, importc: "glNormal3f".} -proc glNormal3fv*(v: PGLfloat){.dynlib: dllname, importc: "glNormal3fv".} -proc glNormal3i*(nx, ny, nz: TGLint){.dynlib: dllname, importc: "glNormal3i".} -proc glNormal3iv*(v: PGLint){.dynlib: dllname, importc: "glNormal3iv".} -proc glNormal3s*(nx, ny, nz: TGLshort){.dynlib: dllname, importc: "glNormal3s".} -proc glNormal3sv*(v: PGLshort){.dynlib: dllname, importc: "glNormal3sv".} -proc glNormalPointer*(atype: TGLenum, stride: TGLsizei, pointer: Pointer){. - dynlib: dllname, importc: "glNormalPointer".} -proc glOrtho*(left, right, bottom, top, zNear, zFar: TGLdouble){. - dynlib: dllname, importc: "glOrtho".} -proc glPassThrough*(token: TGLfloat){.dynlib: dllname, importc: "glPassThrough".} -proc glPixelMapfv*(map: TGLenum, mapsize: TGLsizei, values: PGLfloat){. - dynlib: dllname, importc: "glPixelMapfv".} -proc glPixelMapuiv*(map: TGLenum, mapsize: TGLsizei, values: PGLuint){. - dynlib: dllname, importc: "glPixelMapuiv".} -proc glPixelMapusv*(map: TGLenum, mapsize: TGLsizei, values: PGLushort){. - dynlib: dllname, importc: "glPixelMapusv".} -proc glPixelStoref*(pname: TGLenum, param: TGLfloat){.dynlib: dllname, - importc: "glPixelStoref".} -proc glPixelStorei*(pname: TGLenum, param: TGLint){.dynlib: dllname, - importc: "glPixelStorei".} -proc glPixelTransferf*(pname: TGLenum, param: TGLfloat){.dynlib: dllname, - importc: "glPixelTransferf".} -proc glPixelTransferi*(pname: TGLenum, param: TGLint){.dynlib: dllname, - importc: "glPixelTransferi".} -proc glPixelZoom*(xfactor, yfactor: TGLfloat){.dynlib: dllname, - importc: "glPixelZoom".} -proc glPointSize*(size: TGLfloat){.dynlib: dllname, importc: "glPointSize".} -proc glPolygonMode*(face, mode: TGLenum){.dynlib: dllname, - importc: "glPolygonMode".} -proc glPolygonOffset*(factor, units: TGLfloat){.dynlib: dllname, - importc: "glPolygonOffset".} -proc glPolygonStipple*(mask: PGLubyte){.dynlib: dllname, - importc: "glPolygonStipple".} -proc glPopAttrib*(){.dynlib: dllname, importc: "glPopAttrib".} -proc glPopClientAttrib*(){.dynlib: dllname, importc: "glPopClientAttrib".} -proc glPopMatrix*(){.dynlib: dllname, importc: "glPopMatrix".} -proc glPopName*(){.dynlib: dllname, importc: "glPopName".} -proc glPrioritizeTextures*(n: TGLsizei, textures: PGLuint, priorities: PGLclampf){. - dynlib: dllname, importc: "glPrioritizeTextures".} -proc glPushAttrib*(mask: TGLbitfield){.dynlib: dllname, importc: "glPushAttrib".} -proc glPushClientAttrib*(mask: TGLbitfield){.dynlib: dllname, - importc: "glPushClientAttrib".} -proc glPushMatrix*(){.dynlib: dllname, importc: "glPushMatrix".} -proc glPushName*(name: TGLuint){.dynlib: dllname, importc: "glPushName".} -proc glRasterPos2d*(x, y: TGLdouble){.dynlib: dllname, importc: "glRasterPos2d".} -proc glRasterPos2dv*(v: PGLdouble){.dynlib: dllname, importc: "glRasterPos2dv".} -proc glRasterPos2f*(x, y: TGLfloat){.dynlib: dllname, importc: "glRasterPos2f".} -proc glRasterPos2fv*(v: PGLfloat){.dynlib: dllname, importc: "glRasterPos2fv".} -proc glRasterPos2i*(x, y: TGLint){.dynlib: dllname, importc: "glRasterPos2i".} -proc glRasterPos2iv*(v: PGLint){.dynlib: dllname, importc: "glRasterPos2iv".} -proc glRasterPos2s*(x, y: TGLshort){.dynlib: dllname, importc: "glRasterPos2s".} -proc glRasterPos2sv*(v: PGLshort){.dynlib: dllname, importc: "glRasterPos2sv".} -proc glRasterPos3d*(x, y, z: TGLdouble){.dynlib: dllname, - importc: "glRasterPos3d".} -proc glRasterPos3dv*(v: PGLdouble){.dynlib: dllname, importc: "glRasterPos3dv".} -proc glRasterPos3f*(x, y, z: TGLfloat){.dynlib: dllname, - importc: "glRasterPos3f".} -proc glRasterPos3fv*(v: PGLfloat){.dynlib: dllname, importc: "glRasterPos3fv".} -proc glRasterPos3i*(x, y, z: TGLint){.dynlib: dllname, importc: "glRasterPos3i".} -proc glRasterPos3iv*(v: PGLint){.dynlib: dllname, importc: "glRasterPos3iv".} -proc glRasterPos3s*(x, y, z: TGLshort){.dynlib: dllname, - importc: "glRasterPos3s".} -proc glRasterPos3sv*(v: PGLshort){.dynlib: dllname, importc: "glRasterPos3sv".} -proc glRasterPos4d*(x, y, z, w: TGLdouble){.dynlib: dllname, - importc: "glRasterPos4d".} -proc glRasterPos4dv*(v: PGLdouble){.dynlib: dllname, importc: "glRasterPos4dv".} -proc glRasterPos4f*(x, y, z, w: TGLfloat){.dynlib: dllname, - importc: "glRasterPos4f".} -proc glRasterPos4fv*(v: PGLfloat){.dynlib: dllname, importc: "glRasterPos4fv".} -proc glRasterPos4i*(x, y, z, w: TGLint){.dynlib: dllname, - importc: "glRasterPos4i".} -proc glRasterPos4iv*(v: PGLint){.dynlib: dllname, importc: "glRasterPos4iv".} -proc glRasterPos4s*(x, y, z, w: TGLshort){.dynlib: dllname, - importc: "glRasterPos4s".} -proc glRasterPos4sv*(v: PGLshort){.dynlib: dllname, importc: "glRasterPos4sv".} -proc glReadBuffer*(mode: TGLenum){.dynlib: dllname, importc: "glReadBuffer".} -proc glReadPixels*(x, y: TGLint, width, height: TGLsizei, - format, atype: TGLenum, pixels: Pointer){.dynlib: dllname, - importc: "glReadPixels".} -proc glRectd*(x1, y1, x2, y2: TGLdouble){.dynlib: dllname, importc: "glRectd".} -proc glRectdv*(v1: PGLdouble, v2: PGLdouble){.dynlib: dllname, - importc: "glRectdv".} -proc glRectf*(x1, y1, x2, y2: TGLfloat){.dynlib: dllname, importc: "glRectf".} -proc glRectfv*(v1: PGLfloat, v2: PGLfloat){.dynlib: dllname, importc: "glRectfv".} -proc glRecti*(x1, y1, x2, y2: TGLint){.dynlib: dllname, importc: "glRecti".} -proc glRectiv*(v1: PGLint, v2: PGLint){.dynlib: dllname, importc: "glRectiv".} -proc glRects*(x1, y1, x2, y2: TGLshort){.dynlib: dllname, importc: "glRects".} -proc glRectsv*(v1: PGLshort, v2: PGLshort){.dynlib: dllname, importc: "glRectsv".} -proc glRenderMode*(mode: TGLint): TGLint{.dynlib: dllname, - importc: "glRenderMode".} -proc glRotated*(angle, x, y, z: TGLdouble){.dynlib: dllname, - importc: "glRotated".} -proc glRotatef*(angle, x, y, z: TGLfloat){.dynlib: dllname, importc: "glRotatef".} -proc glScaled*(x, y, z: TGLdouble){.dynlib: dllname, importc: "glScaled".} -proc glScalef*(x, y, z: TGLfloat){.dynlib: dllname, importc: "glScalef".} -proc glScissor*(x, y: TGLint, width, height: TGLsizei){.dynlib: dllname, - importc: "glScissor".} -proc glSelectBuffer*(size: TGLsizei, buffer: PGLuint){.dynlib: dllname, - importc: "glSelectBuffer".} -proc glShadeModel*(mode: TGLenum){.dynlib: dllname, importc: "glShadeModel".} -proc glStencilFunc*(func: TGLenum, theref: TGLint, mask: TGLuint){. - dynlib: dllname, importc: "glStencilFunc".} -proc glStencilMask*(mask: TGLuint){.dynlib: dllname, importc: "glStencilMask".} -proc glStencilOp*(fail, zfail, zpass: TGLenum){.dynlib: dllname, - importc: "glStencilOp".} -proc glTexCoord1d*(s: TGLdouble){.dynlib: dllname, importc: "glTexCoord1d".} -proc glTexCoord1dv*(v: PGLdouble){.dynlib: dllname, importc: "glTexCoord1dv".} -proc glTexCoord1f*(s: TGLfloat){.dynlib: dllname, importc: "glTexCoord1f".} -proc glTexCoord1fv*(v: PGLfloat){.dynlib: dllname, importc: "glTexCoord1fv".} -proc glTexCoord1i*(s: TGLint){.dynlib: dllname, importc: "glTexCoord1i".} -proc glTexCoord1iv*(v: PGLint){.dynlib: dllname, importc: "glTexCoord1iv".} -proc glTexCoord1s*(s: TGLshort){.dynlib: dllname, importc: "glTexCoord1s".} -proc glTexCoord1sv*(v: PGLshort){.dynlib: dllname, importc: "glTexCoord1sv".} -proc glTexCoord2d*(s, t: TGLdouble){.dynlib: dllname, importc: "glTexCoord2d".} -proc glTexCoord2dv*(v: PGLdouble){.dynlib: dllname, importc: "glTexCoord2dv".} -proc glTexCoord2f*(s, t: TGLfloat){.dynlib: dllname, importc: "glTexCoord2f".} -proc glTexCoord2fv*(v: PGLfloat){.dynlib: dllname, importc: "glTexCoord2fv".} -proc glTexCoord2i*(s, t: TGLint){.dynlib: dllname, importc: "glTexCoord2i".} -proc glTexCoord2iv*(v: PGLint){.dynlib: dllname, importc: "glTexCoord2iv".} -proc glTexCoord2s*(s, t: TGLshort){.dynlib: dllname, importc: "glTexCoord2s".} -proc glTexCoord2sv*(v: PGLshort){.dynlib: dllname, importc: "glTexCoord2sv".} -proc glTexCoord3d*(s, t, r: TGLdouble){.dynlib: dllname, importc: "glTexCoord3d".} -proc glTexCoord3dv*(v: PGLdouble){.dynlib: dllname, importc: "glTexCoord3dv".} -proc glTexCoord3f*(s, t, r: TGLfloat){.dynlib: dllname, importc: "glTexCoord3f".} -proc glTexCoord3fv*(v: PGLfloat){.dynlib: dllname, importc: "glTexCoord3fv".} -proc glTexCoord3i*(s, t, r: TGLint){.dynlib: dllname, importc: "glTexCoord3i".} -proc glTexCoord3iv*(v: PGLint){.dynlib: dllname, importc: "glTexCoord3iv".} -proc glTexCoord3s*(s, t, r: TGLshort){.dynlib: dllname, importc: "glTexCoord3s".} -proc glTexCoord3sv*(v: PGLshort){.dynlib: dllname, importc: "glTexCoord3sv".} -proc glTexCoord4d*(s, t, r, q: TGLdouble){.dynlib: dllname, - importc: "glTexCoord4d".} -proc glTexCoord4dv*(v: PGLdouble){.dynlib: dllname, importc: "glTexCoord4dv".} -proc glTexCoord4f*(s, t, r, q: TGLfloat){.dynlib: dllname, - importc: "glTexCoord4f".} -proc glTexCoord4fv*(v: PGLfloat){.dynlib: dllname, importc: "glTexCoord4fv".} -proc glTexCoord4i*(s, t, r, q: TGLint){.dynlib: dllname, importc: "glTexCoord4i".} -proc glTexCoord4iv*(v: PGLint){.dynlib: dllname, importc: "glTexCoord4iv".} -proc glTexCoord4s*(s, t, r, q: TGLshort){.dynlib: dllname, - importc: "glTexCoord4s".} -proc glTexCoord4sv*(v: PGLshort){.dynlib: dllname, importc: "glTexCoord4sv".} -proc glTexCoordPointer*(size: TGLint, atype: TGLenum, stride: TGLsizei, - pointer: Pointer){.dynlib: dllname, - importc: "glTexCoordPointer".} -proc glTexEnvf*(target: TGLenum, pname: TGLenum, param: TGLfloat){. - dynlib: dllname, importc: "glTexEnvf".} -proc glTexEnvfv*(target: TGLenum, pname: TGLenum, params: PGLfloat){. - dynlib: dllname, importc: "glTexEnvfv".} -proc glTexEnvi*(target: TGLenum, pname: TGLenum, param: TGLint){. - dynlib: dllname, importc: "glTexEnvi".} -proc glTexEnviv*(target: TGLenum, pname: TGLenum, params: PGLint){. - dynlib: dllname, importc: "glTexEnviv".} -proc glTexGend*(coord: TGLenum, pname: TGLenum, param: TGLdouble){. - dynlib: dllname, importc: "glTexGend".} -proc glTexGendv*(coord: TGLenum, pname: TGLenum, params: PGLdouble){. - dynlib: dllname, importc: "glTexGendv".} -proc glTexGenf*(coord: TGLenum, pname: TGLenum, param: TGLfloat){. - dynlib: dllname, importc: "glTexGenf".} -proc glTexGenfv*(coord: TGLenum, pname: TGLenum, params: PGLfloat){. - dynlib: dllname, importc: "glTexGenfv".} -proc glTexGeni*(coord: TGLenum, pname: TGLenum, param: TGLint){.dynlib: dllname, - importc: "glTexGeni".} -proc glTexGeniv*(coord: TGLenum, pname: TGLenum, params: PGLint){. - dynlib: dllname, importc: "glTexGeniv".} -proc glTexImage1D*(target: TGLenum, level, internalformat: TGLint, - width: TGLsizei, border: TGLint, format, atype: TGLenum, - pixels: Pointer){.dynlib: dllname, importc: "glTexImage1D".} -proc glTexImage2D*(target: TGLenum, level, internalformat: TGLint, - width, height: TGLsizei, border: TGLint, - format, atype: TGLenum, pixels: Pointer){.dynlib: dllname, - importc: "glTexImage2D".} -proc glTexParameterf*(target: TGLenum, pname: TGLenum, param: TGLfloat){. - dynlib: dllname, importc: "glTexParameterf".} -proc glTexParameterfv*(target: TGLenum, pname: TGLenum, params: PGLfloat){. - dynlib: dllname, importc: "glTexParameterfv".} -proc glTexParameteri*(target: TGLenum, pname: TGLenum, param: TGLint){. - dynlib: dllname, importc: "glTexParameteri".} -proc glTexParameteriv*(target: TGLenum, pname: TGLenum, params: PGLint){. - dynlib: dllname, importc: "glTexParameteriv".} -proc glTexSubImage1D*(target: TGLenum, level, xoffset: TGLint, width: TGLsizei, - format, atype: TGLenum, pixels: Pointer){.dynlib: dllname, - importc: "glTexSubImage1D".} -proc glTexSubImage2D*(target: TGLenum, level, xoffset, yoffset: TGLint, - width, height: TGLsizei, format, atype: TGLenum, - pixels: Pointer){.dynlib: dllname, - importc: "glTexSubImage2D".} -proc glTranslated*(x, y, z: TGLdouble){.dynlib: dllname, importc: "glTranslated".} -proc glTranslatef*(x, y, z: TGLfloat){.dynlib: dllname, importc: "glTranslatef".} -proc glVertex2d*(x, y: TGLdouble){.dynlib: dllname, importc: "glVertex2d".} -proc glVertex2dv*(v: PGLdouble){.dynlib: dllname, importc: "glVertex2dv".} -proc glVertex2f*(x, y: TGLfloat){.dynlib: dllname, importc: "glVertex2f".} -proc glVertex2fv*(v: PGLfloat){.dynlib: dllname, importc: "glVertex2fv".} -proc glVertex2i*(x, y: TGLint){.dynlib: dllname, importc: "glVertex2i".} -proc glVertex2iv*(v: PGLint){.dynlib: dllname, importc: "glVertex2iv".} -proc glVertex2s*(x, y: TGLshort){.dynlib: dllname, importc: "glVertex2s".} -proc glVertex2sv*(v: PGLshort){.dynlib: dllname, importc: "glVertex2sv".} -proc glVertex3d*(x, y, z: TGLdouble){.dynlib: dllname, importc: "glVertex3d".} -proc glVertex3dv*(v: PGLdouble){.dynlib: dllname, importc: "glVertex3dv".} -proc glVertex3f*(x, y, z: TGLfloat){.dynlib: dllname, importc: "glVertex3f".} -proc glVertex3fv*(v: PGLfloat){.dynlib: dllname, importc: "glVertex3fv".} -proc glVertex3i*(x, y, z: TGLint){.dynlib: dllname, importc: "glVertex3i".} -proc glVertex3iv*(v: PGLint){.dynlib: dllname, importc: "glVertex3iv".} -proc glVertex3s*(x, y, z: TGLshort){.dynlib: dllname, importc: "glVertex3s".} -proc glVertex3sv*(v: PGLshort){.dynlib: dllname, importc: "glVertex3sv".} -proc glVertex4d*(x, y, z, w: TGLdouble){.dynlib: dllname, importc: "glVertex4d".} -proc glVertex4dv*(v: PGLdouble){.dynlib: dllname, importc: "glVertex4dv".} -proc glVertex4f*(x, y, z, w: TGLfloat){.dynlib: dllname, importc: "glVertex4f".} -proc glVertex4fv*(v: PGLfloat){.dynlib: dllname, importc: "glVertex4fv".} -proc glVertex4i*(x, y, z, w: TGLint){.dynlib: dllname, importc: "glVertex4i".} -proc glVertex4iv*(v: PGLint){.dynlib: dllname, importc: "glVertex4iv".} -proc glVertex4s*(x, y, z, w: TGLshort){.dynlib: dllname, importc: "glVertex4s".} -proc glVertex4sv*(v: PGLshort){.dynlib: dllname, importc: "glVertex4sv".} -proc glVertexPointer*(size: TGLint, atype: TGLenum, stride: TGLsizei, - pointer: Pointer){.dynlib: dllname, - importc: "glVertexPointer".} -proc glViewport*(x, y: TGLint, width, height: TGLsizei){.dynlib: dllname, - importc: "glViewport".} -type - PFN_GLARRAY_ELEMENT_EXTPROC* = proc (i: TGLint) - PFN_GLDRAW_ARRAYS_EXTPROC* = proc (mode: TGLenum, first: TGLint, - count: TGLsizei) - PFN_GLVERTEX_POINTER_EXTPROC* = proc (size: TGLint, atype: TGLenum, - stride, count: TGLsizei, - pointer: Pointer) - PFN_GLNORMAL_POINTER_EXTPROC* = proc (atype: TGLenum, stride, count: TGLsizei, - pointer: Pointer) - PFN_GLCOLOR_POINTER_EXTPROC* = proc (size: TGLint, atype: TGLenum, - stride, count: TGLsizei, pointer: Pointer) - PFN_GLINDEX_POINTER_EXTPROC* = proc (atype: TGLenum, stride, count: TGLsizei, - pointer: Pointer) - PFN_GLTEXCOORD_POINTER_EXTPROC* = proc (size: TGLint, atype: TGLenum, - stride, count: TGLsizei, pointer: Pointer) - PFN_GLEDGEFLAG_POINTER_EXTPROC* = proc (stride, count: TGLsizei, - pointer: PGLboolean) - PFN_GLGET_POINTER_VEXT_PROC* = proc (pname: TGLenum, params: Pointer) - PFN_GLARRAY_ELEMENT_ARRAY_EXTPROC* = proc (mode: TGLenum, count: TGLsizei, - pi: Pointer) # WIN_swap_hint - PFN_GLADDSWAPHINT_RECT_WINPROC* = proc (x, y: TGLint, width, height: TGLsizei) - PFN_GLCOLOR_TABLE_EXTPROC* = proc (target, internalFormat: TGLenum, - width: TGLsizei, format, atype: TGLenum, - data: Pointer) - PFN_GLCOLOR_SUBTABLE_EXTPROC* = proc (target: TGLenum, start, count: TGLsizei, - format, atype: TGLenum, data: Pointer) - PFN_GLGETCOLOR_TABLE_EXTPROC* = proc (target, format, atype: TGLenum, - data: Pointer) - PFN_GLGETCOLOR_TABLE_PARAMETER_IVEXTPROC* = proc (target, pname: TGLenum, - params: PGLint) - PFN_GLGETCOLOR_TABLE_PARAMETER_FVEXTPROC* = proc (target, pname: TGLenum, - params: PGLfloat) - -{.pop.} -# implementation From 30bb01eece1a7c555699f870fa7c871a0319c2d7 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Tue, 15 Apr 2014 15:42:08 +0200 Subject: [PATCH 04/18] Fix comment; remove unrelated code. --- lib/opengl.nim | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/lib/opengl.nim b/lib/opengl.nim index 2c18c90..098c320 100644 --- a/lib/opengl.nim +++ b/lib/opengl.nim @@ -3075,7 +3075,8 @@ wrapErrorChecking: proc glVertexAttribPointerNV(index: TGLuint, fsize: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glVertexAttribPointerNV", ogl.} proc glColorTable(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc: "glColorTable", ogl.} proc glProgramUniformMatrix2x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix2x3dv", ogl.} -{.pop.} # stdcall, errCheck. +{.pop.} # stdcall. + const GL_2X_BIT_ATI* = 0x00000001 GL_MODELVIEW6_ARB* = 0x8726 @@ -8084,6 +8085,3 @@ const GL_XOR* = 0x1506 GL_VIDEO_CAPTURE_FRAME_WIDTH_NV* = 0x9038 GL_RGBA* = 0x1908 - -loadExtensions() -glEnable(47843784) From 394aff32710b6f97fe9f31d47da33ef642738581 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Tue, 15 Apr 2014 16:05:17 +0200 Subject: [PATCH 05/18] Shorten dummy pragma expression. --- lib/opengl.nim | 5636 ++++++++++++++++++++++++------------------------ 1 file changed, 2818 insertions(+), 2818 deletions(-) diff --git a/lib/opengl.nim b/lib/opengl.nim index 098c320..6be77fd 100644 --- a/lib/opengl.nim +++ b/lib/opengl.nim @@ -257,2824 +257,2824 @@ macro wrapErrorChecking(f: stmt): stmt = {.deadCodeElim: on.} {.push stdcall.} wrapErrorChecking: - proc glMultiTexCoord2d(target: TGLenum, s: TGLdouble, t: TGLdouble) {.importc: "glMultiTexCoord2d", ogl.} - proc glDrawElementsIndirect(mode: TGLenum, `type`: TGLenum, indirect: pointer) {.importc: "glDrawElementsIndirect", ogl.} - proc glEnableVertexArrayEXT(vaobj: TGLuint, `array`: TGLenum) {.importc: "glEnableVertexArrayEXT", ogl.} - proc glDeleteFramebuffers(n: TGLsizei, framebuffers: TGLuint) {.importc: "glDeleteFramebuffers", ogl.} - proc glMultiTexCoord3dv(target: TGLenum, v: TGLdouble) {.importc: "glMultiTexCoord3dv", ogl.} - proc glVertexAttrib4d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glVertexAttrib4d", ogl.} - proc glLoadPaletteFromModelViewMatrixOES() {.importc: "glLoadPaletteFromModelViewMatrixOES", ogl.} - proc glVertex3xvOES(coords: TGLfixed) {.importc: "glVertex3xvOES", ogl.} - proc glNormalStream3sATI(stream: TGLenum, nx: TGLshort, ny: TGLshort, nz: TGLshort) {.importc: "glNormalStream3sATI", ogl.} - proc glMatrixFrustumEXT(mode: TGLenum, left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc: "glMatrixFrustumEXT", ogl.} - proc glUniformMatrix2fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix2fvARB", ogl.} - proc glColor4dv(v: TGLdouble) {.importc: "glColor4dv", ogl.} - proc glColor3fv(v: TGLfloat) {.importc: "glColor3fv", ogl.} - proc glVertexAttribI1uiEXT(index: TGLuint, x: TGLuint) {.importc: "glVertexAttribI1uiEXT", ogl.} - proc glGetDebugMessageLogKHR(count: TGLuint, bufsize: TGLsizei, sources: TGLenum, types: TGLenum, ids: TGLuint, severities: TGLenum, lengths: TGLsizei, messageLog: TGLchar): TGLuint {.importc: "glGetDebugMessageLogKHR", ogl.} - proc glVertexAttribI2iv(index: TGLuint, v: TGLint) {.importc: "glVertexAttribI2iv", ogl.} - proc glTexCoord1xvOES(coords: TGLfixed) {.importc: "glTexCoord1xvOES", ogl.} - proc glVertex3hNV(x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV) {.importc: "glVertex3hNV", ogl.} - proc glIsShader(shader: TGLuint): TGLboolean {.importc: "glIsShader", ogl.} - proc glDeleteRenderbuffersEXT(n: TGLsizei, renderbuffers: TGLuint) {.importc: "glDeleteRenderbuffersEXT", ogl.} - proc glVertex3hvNV(v: TGLhalfNV) {.importc: "glVertex3hvNV", ogl.} - proc glGetPointervKHR(pname: TGLenum, params: ptr pointer) {.importc: "glGetPointervKHR", ogl.} - proc glProgramUniform3i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc: "glProgramUniform3i64vNV", ogl.} - proc glNamedFramebufferTexture1DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glNamedFramebufferTexture1DEXT", ogl.} - proc glGetNamedProgramLocalParameterfvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLfloat) {.importc: "glGetNamedProgramLocalParameterfvEXT", ogl.} - proc glGenRenderbuffersOES(n: TGLsizei, renderbuffers: TGLuint) {.importc: "glGenRenderbuffersOES", ogl.} - proc glVertex4dv(v: TGLdouble) {.importc: "glVertex4dv", ogl.} - proc glTexCoord2fColor4ubVertex3fvSUN(tc: TGLfloat, c: TGLubyte, v: TGLfloat) {.importc: "glTexCoord2fColor4ubVertex3fvSUN", ogl.} - proc glTexStorage2DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glTexStorage2DEXT", ogl.} - proc glVertexAttrib2d(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc: "glVertexAttrib2d", ogl.} - proc glVertexAttrib1dv(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib1dv", ogl.} - proc glBindProgramARB(target: TGLenum, program: TGLuint) {.importc: "glBindProgramARB", ogl.} - proc glRasterPos2dv(v: TGLdouble) {.importc: "glRasterPos2dv", ogl.} - proc glCompressedTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedTextureSubImage2DEXT", ogl.} - proc glNormalPointervINTEL(`type`: TGLenum, `pointer`: ptr pointer) {.importc: "glNormalPointervINTEL", ogl.} - proc glGetInteger64vAPPLE(pname: TGLenum, params: TGLint64) {.importc: "glGetInteger64vAPPLE", ogl.} - proc glPushMatrix() {.importc: "glPushMatrix", ogl.} - proc glGetCompressedTexImageARB(target: TGLenum, level: TGLint, img: pointer) {.importc: "glGetCompressedTexImageARB", ogl.} - proc glBindMaterialParameterEXT(face: TGLenum, value: TGLenum): TGLuint {.importc: "glBindMaterialParameterEXT", ogl.} - proc glBlendEquationIndexedAMD(buf: TGLuint, mode: TGLenum) {.importc: "glBlendEquationIndexedAMD", ogl.} - proc glGetObjectBufferfvATI(buffer: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetObjectBufferfvATI", ogl.} - proc glMakeNamedBufferNonResidentNV(buffer: TGLuint) {.importc: "glMakeNamedBufferNonResidentNV", ogl.} - proc glUniform2ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc: "glUniform2ui64NV", ogl.} - proc glRasterPos4fv(v: TGLfloat) {.importc: "glRasterPos4fv", ogl.} - proc glDeleteTextures(n: TGLsizei, textures: TGLuint) {.importc: "glDeleteTextures", ogl.} - proc glSecondaryColorPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glSecondaryColorPointer", ogl.} - proc glTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTextureSubImage1DEXT", ogl.} - proc glEndTilingQCOM(preserveMask: TGLbitfield) {.importc: "glEndTilingQCOM", ogl.} - proc glBindBuffer(target: TGLenum, buffer: TGLuint) {.importc: "glBindBuffer", ogl.} - proc glUniformMatrix3fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix3fvARB", ogl.} - proc glSamplerParameterf(sampler: TGLuint, pname: TGLenum, param: TGLfloat) {.importc: "glSamplerParameterf", ogl.} - proc glSecondaryColor3d(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc: "glSecondaryColor3d", ogl.} - proc glVertexAttrib4sARB(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc: "glVertexAttrib4sARB", ogl.} - proc glNamedProgramLocalParameterI4iEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc: "glNamedProgramLocalParameterI4iEXT", ogl.} - proc glProgramUniform2iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint) {.importc: "glProgramUniform2iEXT", ogl.} - proc glPopAttrib() {.importc: "glPopAttrib", ogl.} - proc glGetnColorTableARB(target: TGLenum, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, table: pointer) {.importc: "glGetnColorTableARB", ogl.} - proc glMatrixLoadIdentityEXT(mode: TGLenum) {.importc: "glMatrixLoadIdentityEXT", ogl.} - proc glGetNamedProgramivEXT(program: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetNamedProgramivEXT", ogl.} - proc glCopyTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyTextureSubImage2DEXT", ogl.} - proc glUniform4i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc: "glUniform4i64NV", ogl.} - proc glDeleteTexturesEXT(n: TGLsizei, textures: TGLuint) {.importc: "glDeleteTexturesEXT", ogl.} - proc glMultiTexCoord1dv(target: TGLenum, v: TGLdouble) {.importc: "glMultiTexCoord1dv", ogl.} - proc glMultiTexRenderbufferEXT(texunit: TGLenum, target: TGLenum, renderbuffer: TGLuint) {.importc: "glMultiTexRenderbufferEXT", ogl.} - proc glMultiDrawArraysIndirect(mode: TGLenum, indirect: pointer, drawcount: TGLsizei, stride: TGLsizei) {.importc: "glMultiDrawArraysIndirect", ogl.} - proc glGetUniformfvARB(programObj: TGLhandleARB, location: TGLint, params: TGLfloat) {.importc: "glGetUniformfvARB", ogl.} - proc glBufferDataARB(target: TGLenum, size: TGLsizeiptrARB, data: pointer, usage: TGLenum) {.importc: "glBufferDataARB", ogl.} - proc glTexCoord2d(s: TGLdouble, t: TGLdouble) {.importc: "glTexCoord2d", ogl.} - proc glGetArrayObjectfvATI(`array`: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetArrayObjectfvATI", ogl.} - proc glShaderOp1EXT(op: TGLenum, res: TGLuint, arg1: TGLuint) {.importc: "glShaderOp1EXT", ogl.} - proc glColor3s(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc: "glColor3s", ogl.} - proc glStencilFuncSeparate(face: TGLenum, func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc: "glStencilFuncSeparate", ogl.} - proc glTextureImage2DMultisampleCoverageNV(texture: TGLuint, target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc: "glTextureImage2DMultisampleCoverageNV", ogl.} - proc glMultiTexCoord2xvOES(texture: TGLenum, coords: TGLfixed) {.importc: "glMultiTexCoord2xvOES", ogl.} - proc glGetVertexAttribLui64vNV(index: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc: "glGetVertexAttribLui64vNV", ogl.} - proc glNormal3xOES(nx: TGLfixed, ny: TGLfixed, nz: TGLfixed) {.importc: "glNormal3xOES", ogl.} - proc glMapBufferRangeEXT(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc: "glMapBufferRangeEXT", ogl.} - proc glCreateShader(`type`: TGLenum): TGLuint {.importc: "glCreateShader", ogl.} - proc glDrawRangeElementArrayAPPLE(mode: TGLenum, start: TGLuint, `end`: TGLuint, first: TGLint, count: TGLsizei) {.importc: "glDrawRangeElementArrayAPPLE", ogl.} - proc glVertex2bOES(x: TGLbyte) {.importc: "glVertex2bOES", ogl.} - proc glGetMapxvOES(target: TGLenum, query: TGLenum, v: TGLfixed) {.importc: "glGetMapxvOES", ogl.} - proc glRasterPos3sv(v: TGLshort) {.importc: "glRasterPos3sv", ogl.} - proc glDeleteQueriesARB(n: TGLsizei, ids: TGLuint) {.importc: "glDeleteQueriesARB", ogl.} - proc glProgramUniform1iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glProgramUniform1iv", ogl.} - proc glVertexStream2dvATI(stream: TGLenum, coords: TGLdouble) {.importc: "glVertexStream2dvATI", ogl.} - proc glBindVertexArrayOES(`array`: TGLuint) {.importc: "glBindVertexArrayOES", ogl.} - proc glLightModelfv(pname: TGLenum, params: TGLfloat) {.importc: "glLightModelfv", ogl.} - proc glEvalCoord2dv(u: TGLdouble) {.importc: "glEvalCoord2dv", ogl.} - proc glColor3hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV) {.importc: "glColor3hNV", ogl.} - proc glSecondaryColor3iEXT(red: TGLint, green: TGLint, blue: TGLint) {.importc: "glSecondaryColor3iEXT", ogl.} - proc glBindTexture(target: TGLenum, texture: TGLuint) {.importc: "glBindTexture", ogl.} - proc glUniformBufferEXT(program: TGLuint, location: TGLint, buffer: TGLuint) {.importc: "glUniformBufferEXT", ogl.} - proc glGetCombinerInputParameterfvNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetCombinerInputParameterfvNV", ogl.} - proc glUniform2ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc: "glUniform2ui64vNV", ogl.} - proc glMatrixMultTransposefEXT(mode: TGLenum, m: TGLfloat) {.importc: "glMatrixMultTransposefEXT", ogl.} - proc glLineWidth(width: TGLfloat) {.importc: "glLineWidth", ogl.} - proc glRotatef(angle: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glRotatef", ogl.} - proc glNormalStream3svATI(stream: TGLenum, coords: TGLshort) {.importc: "glNormalStream3svATI", ogl.} - proc glTexCoordP4ui(`type`: TGLenum, coords: TGLuint) {.importc: "glTexCoordP4ui", ogl.} - proc glImageTransformParameterfvHP(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glImageTransformParameterfvHP", ogl.} - proc glUniform3uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc: "glUniform3uiEXT", ogl.} - proc glGetInvariantIntegervEXT(id: TGLuint, value: TGLenum, data: TGLint) {.importc: "glGetInvariantIntegervEXT", ogl.} - proc glGetTransformFeedbackVaryingEXT(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLsizei, `type`: TGLenum, name: TGLchar) {.importc: "glGetTransformFeedbackVaryingEXT", ogl.} - proc glSamplerParameterIuiv(sampler: TGLuint, pname: TGLenum, param: TGLuint) {.importc: "glSamplerParameterIuiv", ogl.} - proc glProgramUniform2fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc: "glProgramUniform2fEXT", ogl.} - proc glMultiTexCoord2hvNV(target: TGLenum, v: TGLhalfNV) {.importc: "glMultiTexCoord2hvNV", ogl.} - proc glDeleteRenderbuffersOES(n: TGLsizei, renderbuffers: TGLuint) {.importc: "glDeleteRenderbuffersOES", ogl.} - proc glRenderbufferStorageMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glRenderbufferStorageMultisampleCoverageNV", ogl.} - proc glStencilClearTagEXT(stencilTagBits: TGLsizei, stencilClearTag: TGLuint) {.importc: "glStencilClearTagEXT", ogl.} - proc glConvolutionParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glConvolutionParameteriv", ogl.} - proc glFenceSyncAPPLE(condition: TGLenum, flags: TGLbitfield): TGLsync {.importc: "glFenceSyncAPPLE", ogl.} - proc glGetVariantArrayObjectivATI(id: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetVariantArrayObjectivATI", ogl.} - proc glProgramUniform4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glProgramUniform4dvEXT", ogl.} - proc glPushDebugGroupKHR(source: TGLenum, id: TGLuint, length: TGLsizei, message: TGLchar) {.importc: "glPushDebugGroupKHR", ogl.} - proc glFragmentLightivSGIX(light: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glFragmentLightivSGIX", ogl.} - proc glFramebufferTexture2DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glFramebufferTexture2DEXT", ogl.} - proc glGetActiveSubroutineUniformiv(program: TGLuint, shadertype: TGLenum, index: TGLuint, pname: TGLenum, values: TGLint) {.importc: "glGetActiveSubroutineUniformiv", ogl.} - proc glFrustumf(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc: "glFrustumf", ogl.} - proc glEndQueryIndexed(target: TGLenum, index: TGLuint) {.importc: "glEndQueryIndexed", ogl.} - proc glCompressedTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedTextureSubImage3DEXT", ogl.} - proc glGetProgramPipelineInfoLogEXT(pipeline: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc: "glGetProgramPipelineInfoLogEXT", ogl.} - proc glGetVertexAttribfvNV(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetVertexAttribfvNV", ogl.} - proc glVertexArrayIndexOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayIndexOffsetEXT", ogl.} - proc glDrawTexsvOES(coords: TGLshort) {.importc: "glDrawTexsvOES", ogl.} - proc glMultiTexCoord1hNV(target: TGLenum, s: TGLhalfNV) {.importc: "glMultiTexCoord1hNV", ogl.} - proc glWindowPos2iv(v: TGLint) {.importc: "glWindowPos2iv", ogl.} - proc glMultiTexCoordP1ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc: "glMultiTexCoordP1ui", ogl.} - proc glTexCoord1i(s: TGLint) {.importc: "glTexCoord1i", ogl.} - proc glVertex4hvNV(v: TGLhalfNV) {.importc: "glVertex4hvNV", ogl.} - proc glCallLists(n: TGLsizei, `type`: TGLenum, lists: pointer) {.importc: "glCallLists", ogl.} - proc glIndexFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc: "glIndexFormatNV", ogl.} - proc glPointParameterfARB(pname: TGLenum, param: TGLfloat) {.importc: "glPointParameterfARB", ogl.} - proc glProgramUniform1dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glProgramUniform1dv", ogl.} - proc glGetVertexAttribArrayObjectfvATI(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetVertexAttribArrayObjectfvATI", ogl.} - proc glVDPAUUnmapSurfacesNV(numSurface: TGLsizei, surfaces: TGLvdpauSurfaceNV) {.importc: "glVDPAUUnmapSurfacesNV", ogl.} - proc glVertexAttribIFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc: "glVertexAttribIFormat", ogl.} - proc glClearColorx(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc: "glClearColorx", ogl.} - proc glColor3bv(v: TGLbyte) {.importc: "glColor3bv", ogl.} - proc glNamedProgramLocalParameter4dEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glNamedProgramLocalParameter4dEXT", ogl.} - proc glVertexPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glVertexPointer", ogl.} - proc glGetObjectLabelKHR(identifier: TGLenum, name: TGLuint, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc: "glGetObjectLabelKHR", ogl.} - proc glCombinerStageParameterfvNV(stage: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glCombinerStageParameterfvNV", ogl.} - proc glNormal3hvNV(v: TGLhalfNV) {.importc: "glNormal3hvNV", ogl.} - proc glUniform2i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT) {.importc: "glUniform2i64NV", ogl.} - proc glMultiTexCoord2iv(target: TGLenum, v: TGLint) {.importc: "glMultiTexCoord2iv", ogl.} - proc glProgramUniform3i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc: "glProgramUniform3i", ogl.} - proc glDeleteAsyncMarkersSGIX(marker: TGLuint, range: TGLsizei) {.importc: "glDeleteAsyncMarkersSGIX", ogl.} - proc glStencilOp(fail: TGLenum, zfail: TGLenum, zpass: TGLenum) {.importc: "glStencilOp", ogl.} - proc glColorP4ui(`type`: TGLenum, color: TGLuint) {.importc: "glColorP4ui", ogl.} - proc glFinishAsyncSGIX(markerp: TGLuint): TGLint {.importc: "glFinishAsyncSGIX", ogl.} - proc glDrawTexsOES(x: TGLshort, y: TGLshort, z: TGLshort, width: TGLshort, height: TGLshort) {.importc: "glDrawTexsOES", ogl.} - proc glLineStipple(factor: TGLint, pattern: TGLushort) {.importc: "glLineStipple", ogl.} - proc glAlphaFragmentOp1ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint) {.importc: "glAlphaFragmentOp1ATI", ogl.} - proc glMapTexture2DINTEL(texture: TGLuint, level: TGLint, access: TGLbitfield, stride: TGLint, layout: TGLenum) {.importc: "glMapTexture2DINTEL", ogl.} - proc glVertex4f(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glVertex4f", ogl.} - proc glFramebufferTextureARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glFramebufferTextureARB", ogl.} - proc glProgramUniform3ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc: "glProgramUniform3ui64NV", ogl.} - proc glMultTransposeMatrixxOES(m: TGLfixed) {.importc: "glMultTransposeMatrixxOES", ogl.} - proc glNormal3fv(v: TGLfloat) {.importc: "glNormal3fv", ogl.} - proc glUniform4fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc: "glUniform4fARB", ogl.} - proc glBinormal3bEXT(bx: TGLbyte, by: TGLbyte, bz: TGLbyte) {.importc: "glBinormal3bEXT", ogl.} - proc glGenProgramPipelinesEXT(n: TGLsizei, pipelines: TGLuint) {.importc: "glGenProgramPipelinesEXT", ogl.} - proc glDispatchComputeIndirect(indirect: TGLintptr) {.importc: "glDispatchComputeIndirect", ogl.} - proc glGetPerfMonitorCounterDataAMD(monitor: TGLuint, pname: TGLenum, dataSize: TGLsizei, data: TGLuint, bytesWritten: TGLint) {.importc: "glGetPerfMonitorCounterDataAMD", ogl.} - proc glStencilOpValueAMD(face: TGLenum, value: TGLuint) {.importc: "glStencilOpValueAMD", ogl.} - proc glTangent3fvEXT(v: TGLfloat) {.importc: "glTangent3fvEXT", ogl.} - proc glUniform3iARB(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc: "glUniform3iARB", ogl.} - proc glMatrixScalefEXT(mode: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glMatrixScalefEXT", ogl.} - proc glVertexAttrib2dARB(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc: "glVertexAttrib2dARB", ogl.} - proc glIsVertexArray(`array`: TGLuint): TGLboolean {.importc: "glIsVertexArray", ogl.} - proc glGetMaterialx(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glGetMaterialx", ogl.} - proc glMultiTexCoord1dARB(target: TGLenum, s: TGLdouble) {.importc: "glMultiTexCoord1dARB", ogl.} - proc glColor3usv(v: TGLushort) {.importc: "glColor3usv", ogl.} - proc glVertexStream3svATI(stream: TGLenum, coords: TGLshort) {.importc: "glVertexStream3svATI", ogl.} - proc glRasterPos3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc: "glRasterPos3s", ogl.} - proc glMultiTexCoord2bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte) {.importc: "glMultiTexCoord2bOES", ogl.} - proc glGetClipPlanefOES(plane: TGLenum, equation: TGLfloat) {.importc: "glGetClipPlanefOES", ogl.} - proc glFramebufferTextureEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glFramebufferTextureEXT", ogl.} - proc glVertexAttrib1dNV(index: TGLuint, x: TGLdouble) {.importc: "glVertexAttrib1dNV", ogl.} - proc glSampleCoverageOES(value: TGLfixed, invert: TGLboolean) {.importc: "glSampleCoverageOES", ogl.} - proc glCompressedTexSubImage2DARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexSubImage2DARB", ogl.} - proc glUniform1iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glUniform1iv", ogl.} - proc glExtGetProgramsQCOM(programs: TGLuint, maxPrograms: TGLint, numPrograms: TGLint) {.importc: "glExtGetProgramsQCOM", ogl.} - proc glFogx(pname: TGLenum, param: TGLfixed) {.importc: "glFogx", ogl.} - proc glMultiTexCoord3hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV) {.importc: "glMultiTexCoord3hNV", ogl.} - proc glClipPlane(plane: TGLenum, equation: TGLdouble) {.importc: "glClipPlane", ogl.} - proc glConvolutionParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glConvolutionParameterxvOES", ogl.} - proc glInvalidateBufferData(buffer: TGLuint) {.importc: "glInvalidateBufferData", ogl.} - proc glCheckNamedFramebufferStatusEXT(framebuffer: TGLuint, target: TGLenum): TGLenum {.importc: "glCheckNamedFramebufferStatusEXT", ogl.} - proc glLinkProgram(program: TGLuint) {.importc: "glLinkProgram", ogl.} - proc glCheckFramebufferStatus(target: TGLenum): TGLenum {.importc: "glCheckFramebufferStatus", ogl.} - proc glBlendFunci(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc: "glBlendFunci", ogl.} - proc glProgramUniform4uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glProgramUniform4uiv", ogl.} - proc glConvolutionFilter2D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc: "glConvolutionFilter2D", ogl.} - proc glVertex4bvOES(coords: TGLbyte) {.importc: "glVertex4bvOES", ogl.} - proc glCopyTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc: "glCopyTextureSubImage1DEXT", ogl.} - proc glColor4uiv(v: TGLuint) {.importc: "glColor4uiv", ogl.} - proc glGetBufferParameteri64v(target: TGLenum, pname: TGLenum, params: TGLint64) {.importc: "glGetBufferParameteri64v", ogl.} - proc glGetLocalConstantBooleanvEXT(id: TGLuint, value: TGLenum, data: TGLboolean) {.importc: "glGetLocalConstantBooleanvEXT", ogl.} - proc glCoverStrokePathNV(path: TGLuint, coverMode: TGLenum) {.importc: "glCoverStrokePathNV", ogl.} - proc glScaled(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glScaled", ogl.} - proc glLightfv(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glLightfv", ogl.} - proc glTexParameterIiv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glTexParameterIiv", ogl.} - proc glMakeImageHandleResidentNV(handle: TGLuint64, access: TGLenum) {.importc: "glMakeImageHandleResidentNV", ogl.} - proc glWindowPos3iARB(x: TGLint, y: TGLint, z: TGLint) {.importc: "glWindowPos3iARB", ogl.} - proc glListBase(base: TGLuint) {.importc: "glListBase", ogl.} - proc glFlushMappedBufferRangeEXT(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr) {.importc: "glFlushMappedBufferRangeEXT", ogl.} - proc glNormal3dv(v: TGLdouble) {.importc: "glNormal3dv", ogl.} - proc glProgramUniform4d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble, v2: TGLdouble, v3: TGLdouble) {.importc: "glProgramUniform4d", ogl.} - proc glCreateShaderProgramEXT(`type`: TGLenum, string: TGLchar): TGLuint {.importc: "glCreateShaderProgramEXT", ogl.} - proc glGetLightxvOES(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetLightxvOES", ogl.} - proc glGetObjectPtrLabelKHR(`ptr`: pointer, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc: "glGetObjectPtrLabelKHR", ogl.} - proc glTransformPathNV(resultPath: TGLuint, srcPath: TGLuint, transformType: TGLenum, transformValues: TGLfloat) {.importc: "glTransformPathNV", ogl.} - proc glMultTransposeMatrixf(m: TGLfloat) {.importc: "glMultTransposeMatrixf", ogl.} - proc glMapVertexAttrib2dAPPLE(index: TGLuint, size: TGLuint, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, points: TGLdouble) {.importc: "glMapVertexAttrib2dAPPLE", ogl.} - proc glIsSync(sync: TGLsync): TGLboolean {.importc: "glIsSync", ogl.} - proc glMultMatrixx(m: TGLfixed) {.importc: "glMultMatrixx", ogl.} - proc glInterpolatePathsNV(resultPath: TGLuint, pathA: TGLuint, pathB: TGLuint, weight: TGLfloat) {.importc: "glInterpolatePathsNV", ogl.} - proc glEnableClientStateIndexedEXT(`array`: TGLenum, index: TGLuint) {.importc: "glEnableClientStateIndexedEXT", ogl.} - proc glProgramEnvParameter4fARB(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glProgramEnvParameter4fARB", ogl.} - proc glVertexAttrib2svARB(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib2svARB", ogl.} - proc glLighti(light: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glLighti", ogl.} - proc glSelectBuffer(size: TGLsizei, buffer: TGLuint) {.importc: "glSelectBuffer", ogl.} - proc glReplacementCodeusvSUN(code: TGLushort) {.importc: "glReplacementCodeusvSUN", ogl.} - proc glMapVertexAttrib1fAPPLE(index: TGLuint, size: TGLuint, u1: TGLfloat, u2: TGLfloat, stride: TGLint, order: TGLint, points: TGLfloat) {.importc: "glMapVertexAttrib1fAPPLE", ogl.} - proc glMaterialx(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glMaterialx", ogl.} - proc glDrawTransformFeedback(mode: TGLenum, id: TGLuint) {.importc: "glDrawTransformFeedback", ogl.} - proc glWindowPos2i(x: TGLint, y: TGLint) {.importc: "glWindowPos2i", ogl.} - proc glMultiTexEnviEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glMultiTexEnviEXT", ogl.} - proc glProgramUniform1fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glProgramUniform1fv", ogl.} - proc glDrawBuffersARB(n: TGLsizei, bufs: TGLenum) {.importc: "glDrawBuffersARB", ogl.} - proc glGetUniformLocationARB(programObj: TGLhandleARB, name: TGLcharARB): TGLint {.importc: "glGetUniformLocationARB", ogl.} - proc glResumeTransformFeedback() {.importc: "glResumeTransformFeedback", ogl.} - proc glMap1f(target: TGLenum, u1: TGLfloat, u2: TGLfloat, stride: TGLint, order: TGLint, points: TGLfloat) {.importc: "glMap1f", ogl.} - proc glVertex3xOES(x: TGLfixed, y: TGLfixed) {.importc: "glVertex3xOES", ogl.} - proc glPathCoordsNV(path: TGLuint, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc: "glPathCoordsNV", ogl.} - proc glListParameterfSGIX(list: TGLuint, pname: TGLenum, param: TGLfloat) {.importc: "glListParameterfSGIX", ogl.} - proc glGetUniformivARB(programObj: TGLhandleARB, location: TGLint, params: TGLint) {.importc: "glGetUniformivARB", ogl.} - proc glBinormal3bvEXT(v: TGLbyte) {.importc: "glBinormal3bvEXT", ogl.} - proc glVertexAttribP3ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc: "glVertexAttribP3ui", ogl.} - proc glGetVertexArrayPointeri_vEXT(vaobj: TGLuint, index: TGLuint, pname: TGLenum, param: ptr pointer) {.importc: "glGetVertexArrayPointeri_vEXT", ogl.} - proc glProgramParameter4fvNV(target: TGLenum, index: TGLuint, v: TGLfloat) {.importc: "glProgramParameter4fvNV", ogl.} - proc glDiscardFramebufferEXT(target: TGLenum, numAttachments: TGLsizei, attachments: TGLenum) {.importc: "glDiscardFramebufferEXT", ogl.} - proc glGetDebugMessageLogARB(count: TGLuint, bufsize: TGLsizei, sources: TGLenum, types: TGLenum, ids: TGLuint, severities: TGLenum, lengths: TGLsizei, messageLog: TGLchar): TGLuint {.importc: "glGetDebugMessageLogARB", ogl.} - proc glResolveMultisampleFramebufferAPPLE() {.importc: "glResolveMultisampleFramebufferAPPLE", ogl.} - proc glGetIntegeri_vEXT(target: TGLenum, index: TGLuint, data: TGLint) {.importc: "glGetIntegeri_vEXT", ogl.} - proc glDepthBoundsdNV(zmin: TGLdouble, zmax: TGLdouble) {.importc: "glDepthBoundsdNV", ogl.} - proc glEnd() {.importc: "glEnd", ogl.} - proc glBindBufferBaseEXT(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc: "glBindBufferBaseEXT", ogl.} - proc glVertexAttribDivisor(index: TGLuint, divisor: TGLuint) {.importc: "glVertexAttribDivisor", ogl.} - proc glFogCoorddEXT(coord: TGLdouble) {.importc: "glFogCoorddEXT", ogl.} - proc glFrontFace(mode: TGLenum) {.importc: "glFrontFace", ogl.} - proc glVertexAttrib1hNV(index: TGLuint, x: TGLhalfNV) {.importc: "glVertexAttrib1hNV", ogl.} - proc glNamedProgramLocalParametersI4uivEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLuint) {.importc: "glNamedProgramLocalParametersI4uivEXT", ogl.} - proc glTexCoord1dv(v: TGLdouble) {.importc: "glTexCoord1dv", ogl.} - proc glBindVideoCaptureStreamTextureNV(video_capture_slot: TGLuint, stream: TGLuint, frame_region: TGLenum, target: TGLenum, texture: TGLuint) {.importc: "glBindVideoCaptureStreamTextureNV", ogl.} - proc glWindowPos2iARB(x: TGLint, y: TGLint) {.importc: "glWindowPos2iARB", ogl.} - proc glVertexAttribFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei) {.importc: "glVertexAttribFormatNV", ogl.} - proc glUniform1uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glUniform1uivEXT", ogl.} - proc glGetVideoivNV(video_slot: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetVideoivNV", ogl.} - proc glVertexAttrib3fvARB(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib3fvARB", ogl.} - proc glVertexArraySecondaryColorOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArraySecondaryColorOffsetEXT", ogl.} - proc glSecondaryColor3bv(v: TGLbyte) {.importc: "glSecondaryColor3bv", ogl.} - proc glDispatchComputeGroupSizeARB(num_groups_x: TGLuint, num_groups_y: TGLuint, num_groups_z: TGLuint, group_size_x: TGLuint, group_size_y: TGLuint, group_size_z: TGLuint) {.importc: "glDispatchComputeGroupSizeARB", ogl.} - proc glNamedCopyBufferSubDataEXT(readBuffer: TGLuint, writeBuffer: TGLuint, readOffset: TGLintptr, writeOffset: TGLintptr, size: TGLsizeiptr) {.importc: "glNamedCopyBufferSubDataEXT", ogl.} - proc glSampleCoverage(value: TGLfloat, invert: TGLboolean) {.importc: "glSampleCoverage", ogl.} - proc glGetnMapfvARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: TGLfloat) {.importc: "glGetnMapfvARB", ogl.} - proc glVertexStream2svATI(stream: TGLenum, coords: TGLshort) {.importc: "glVertexStream2svATI", ogl.} - proc glProgramParameters4fvNV(target: TGLenum, index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc: "glProgramParameters4fvNV", ogl.} - proc glVertexAttrib4fARB(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glVertexAttrib4fARB", ogl.} - proc glIndexd(c: TGLdouble) {.importc: "glIndexd", ogl.} - proc glGetInteger64v(pname: TGLenum, params: TGLint64) {.importc: "glGetInteger64v", ogl.} - proc glGetMultiTexImageEXT(texunit: TGLenum, target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glGetMultiTexImageEXT", ogl.} - proc glLightModelx(pname: TGLenum, param: TGLfixed) {.importc: "glLightModelx", ogl.} - proc glMap2f(target: TGLenum, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, points: TGLfloat) {.importc: "glMap2f", ogl.} - proc glSecondaryColorPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc: "glSecondaryColorPointerListIBM", ogl.} - proc glVertexArrayVertexAttribIOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayVertexAttribIOffsetEXT", ogl.} - proc glProgramUniformHandleui64vARB(program: TGLuint, location: TGLint, count: TGLsizei, values: TGLuint64) {.importc: "glProgramUniformHandleui64vARB", ogl.} - proc glActiveProgramEXT(program: TGLuint) {.importc: "glActiveProgramEXT", ogl.} - proc glProgramUniformMatrix4x3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix4x3fv", ogl.} - proc glCompressedTexSubImage3DARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexSubImage3DARB", ogl.} - proc glBindProgramPipelineEXT(pipeline: TGLuint) {.importc: "glBindProgramPipelineEXT", ogl.} - proc glDetailTexFuncSGIS(target: TGLenum, n: TGLsizei, points: TGLfloat) {.importc: "glDetailTexFuncSGIS", ogl.} - proc glSecondaryColor3ubEXT(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc: "glSecondaryColor3ubEXT", ogl.} - proc glDrawArraysInstanced(mode: TGLenum, first: TGLint, count: TGLsizei, instancecount: TGLsizei) {.importc: "glDrawArraysInstanced", ogl.} - proc glWindowPos3fARB(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glWindowPos3fARB", ogl.} - proc glNamedProgramLocalParameter4fEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glNamedProgramLocalParameter4fEXT", ogl.} - proc glTextureParameterfvEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glTextureParameterfvEXT", ogl.} - proc glProgramUniformHandleui64ARB(program: TGLuint, location: TGLint, value: TGLuint64) {.importc: "glProgramUniformHandleui64ARB", ogl.} - proc glHistogramEXT(target: TGLenum, width: TGLsizei, internalformat: TGLenum, sink: TGLboolean) {.importc: "glHistogramEXT", ogl.} - proc glResumeTransformFeedbackNV() {.importc: "glResumeTransformFeedbackNV", ogl.} - proc glGetMaterialxv(face: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetMaterialxv", ogl.} - proc glMultiTexCoord1sv(target: TGLenum, v: TGLshort) {.importc: "glMultiTexCoord1sv", ogl.} - proc glReadInstrumentsSGIX(marker: TGLint) {.importc: "glReadInstrumentsSGIX", ogl.} - proc glTexCoord4hNV(s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV, q: TGLhalfNV) {.importc: "glTexCoord4hNV", ogl.} - proc glVertexAttribL4i64vNV(index: TGLuint, v: TGLint64EXT) {.importc: "glVertexAttribL4i64vNV", ogl.} - proc glEnableVariantClientStateEXT(id: TGLuint) {.importc: "glEnableVariantClientStateEXT", ogl.} - proc glSyncTextureINTEL(texture: TGLuint) {.importc: "glSyncTextureINTEL", ogl.} - proc glGetObjectPtrLabel(`ptr`: pointer, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc: "glGetObjectPtrLabel", ogl.} - proc glCopyTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc: "glCopyTexSubImage1D", ogl.} - proc glOrthofOES(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc: "glOrthofOES", ogl.} - proc glWindowPos3sARB(x: TGLshort, y: TGLshort, z: TGLshort) {.importc: "glWindowPos3sARB", ogl.} - proc glIsBufferARB(buffer: TGLuint): TGLboolean {.importc: "glIsBufferARB", ogl.} - proc glColor3sv(v: TGLshort) {.importc: "glColor3sv", ogl.} - proc glEvalMesh1(mode: TGLenum, i1: TGLint, i2: TGLint) {.importc: "glEvalMesh1", ogl.} - proc glMultiDrawArrays(mode: TGLenum, first: TGLint, count: TGLsizei, drawcount: TGLsizei) {.importc: "glMultiDrawArrays", ogl.} - proc glGetMultiTexEnvfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetMultiTexEnvfvEXT", ogl.} - proc glWindowPos3fMESA(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glWindowPos3fMESA", ogl.} - proc glExtGetFramebuffersQCOM(framebuffers: TGLuint, maxFramebuffers: TGLint, numFramebuffers: TGLint) {.importc: "glExtGetFramebuffersQCOM", ogl.} - proc glTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexSubImage3D", ogl.} - proc glVertexAttrib4uiv(index: TGLuint, v: TGLuint) {.importc: "glVertexAttrib4uiv", ogl.} - proc glProgramUniformui64NV(program: TGLuint, location: TGLint, value: TGLuint64EXT) {.importc: "glProgramUniformui64NV", ogl.} - proc glMultiTexCoord2ivARB(target: TGLenum, v: TGLint) {.importc: "glMultiTexCoord2ivARB", ogl.} - proc glProgramUniform4i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc: "glProgramUniform4i64NV", ogl.} - proc glWindowPos2svMESA(v: TGLshort) {.importc: "glWindowPos2svMESA", ogl.} - proc glVertexAttrib3dv(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib3dv", ogl.} - proc glColor4i(red: TGLint, green: TGLint, blue: TGLint, alpha: TGLint) {.importc: "glColor4i", ogl.} - proc glClampColor(target: TGLenum, clamp: TGLenum) {.importc: "glClampColor", ogl.} - proc glVertexP2ui(`type`: TGLenum, value: TGLuint) {.importc: "glVertexP2ui", ogl.} - proc glGenQueries(n: TGLsizei, ids: TGLuint) {.importc: "glGenQueries", ogl.} - proc glBindBufferOffsetNV(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr) {.importc: "glBindBufferOffsetNV", ogl.} - proc glGetFragDataLocation(program: TGLuint, name: TGLchar): TGLint {.importc: "glGetFragDataLocation", ogl.} - proc glVertexAttribs2svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc: "glVertexAttribs2svNV", ogl.} - proc glGetPathLengthNV(path: TGLuint, startSegment: TGLsizei, numSegments: TGLsizei): TGLfloat {.importc: "glGetPathLengthNV", ogl.} - proc glVertexAttrib3dARB(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glVertexAttrib3dARB", ogl.} - proc glMultiTexGenfvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glMultiTexGenfvEXT", ogl.} - proc glFlushPixelDataRangeNV(target: TGLenum) {.importc: "glFlushPixelDataRangeNV", ogl.} - proc glReplacementCodeuiNormal3fVertex3fSUN(rc: TGLuint, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glReplacementCodeuiNormal3fVertex3fSUN", ogl.} - proc glPathParameteriNV(path: TGLuint, pname: TGLenum, value: TGLint) {.importc: "glPathParameteriNV", ogl.} - proc glVertexAttribI2iEXT(index: TGLuint, x: TGLint, y: TGLint) {.importc: "glVertexAttribI2iEXT", ogl.} - proc glPixelStorei(pname: TGLenum, param: TGLint) {.importc: "glPixelStorei", ogl.} - proc glGetNamedFramebufferParameterivEXT(framebuffer: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetNamedFramebufferParameterivEXT", ogl.} - proc glGetTexEnvxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetTexEnvxv", ogl.} - proc glPathStringNV(path: TGLuint, format: TGLenum, length: TGLsizei, pathString: pointer) {.importc: "glPathStringNV", ogl.} - proc glDepthMask(flag: TGLboolean) {.importc: "glDepthMask", ogl.} - proc glCopyTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc: "glCopyTexImage1D", ogl.} - proc glDepthRangexOES(n: TGLfixed, f: TGLfixed) {.importc: "glDepthRangexOES", ogl.} - proc glUniform2i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc: "glUniform2i64vNV", ogl.} - proc glSetFragmentShaderConstantATI(dst: TGLuint, value: TGLfloat) {.importc: "glSetFragmentShaderConstantATI", ogl.} - proc glAttachShader(program: TGLuint, shader: TGLuint) {.importc: "glAttachShader", ogl.} - proc glGetFramebufferParameterivEXT(framebuffer: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetFramebufferParameterivEXT", ogl.} - proc glPointParameteriNV(pname: TGLenum, param: TGLint) {.importc: "glPointParameteriNV", ogl.} - proc glWindowPos2dMESA(x: TGLdouble, y: TGLdouble) {.importc: "glWindowPos2dMESA", ogl.} - proc glGetTextureParameterfvEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetTextureParameterfvEXT", ogl.} - proc glTexBumpParameterfvATI(pname: TGLenum, param: TGLfloat) {.importc: "glTexBumpParameterfvATI", ogl.} - proc glCompressedTexImage1DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexImage1DARB", ogl.} - proc glGetTexGendv(coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc: "glGetTexGendv", ogl.} - proc glGetFragmentMaterialfvSGIX(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetFragmentMaterialfvSGIX", ogl.} - proc glBeginConditionalRenderNVX(id: TGLuint) {.importc: "glBeginConditionalRenderNVX", ogl.} - proc glLightModelxOES(pname: TGLenum, param: TGLfixed) {.importc: "glLightModelxOES", ogl.} - proc glTexCoord2xOES(s: TGLfixed, t: TGLfixed) {.importc: "glTexCoord2xOES", ogl.} - proc glProgramUniformMatrix2x4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix2x4fvEXT", ogl.} - proc glRasterPos2xvOES(coords: TGLfixed) {.importc: "glRasterPos2xvOES", ogl.} - proc glGetMapiv(target: TGLenum, query: TGLenum, v: TGLint) {.importc: "glGetMapiv", ogl.} - proc glGetImageHandleARB(texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, format: TGLenum): TGLuint64 {.importc: "glGetImageHandleARB", ogl.} - proc glVDPAURegisterVideoSurfaceNV(vdpSurface: pointer, target: TGLenum, numTextureNames: TGLsizei, textureNames: TGLuint): TGLvdpauSurfaceNV {.importc: "glVDPAURegisterVideoSurfaceNV", ogl.} - proc glVertexAttribL2dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc: "glVertexAttribL2dEXT", ogl.} - proc glVertexAttrib1dvNV(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib1dvNV", ogl.} - proc glPollAsyncSGIX(markerp: TGLuint): TGLint {.importc: "glPollAsyncSGIX", ogl.} - proc glCullParameterfvEXT(pname: TGLenum, params: TGLfloat) {.importc: "glCullParameterfvEXT", ogl.} - proc glMakeNamedBufferResidentNV(buffer: TGLuint, access: TGLenum) {.importc: "glMakeNamedBufferResidentNV", ogl.} - proc glPointParameterfSGIS(pname: TGLenum, param: TGLfloat) {.importc: "glPointParameterfSGIS", ogl.} - proc glGenLists(range: TGLsizei): TGLuint {.importc: "glGenLists", ogl.} - proc glGetTexBumpParameterfvATI(pname: TGLenum, param: TGLfloat) {.importc: "glGetTexBumpParameterfvATI", ogl.} - proc glCompressedMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedMultiTexSubImage2DEXT", ogl.} - proc glFinishFenceNV(fence: TGLuint) {.importc: "glFinishFenceNV", ogl.} - proc glPointSize(size: TGLfloat) {.importc: "glPointSize", ogl.} - proc glCompressedTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedTextureImage2DEXT", ogl.} - proc glGetUniformui64vNV(program: TGLuint, location: TGLint, params: TGLuint64EXT) {.importc: "glGetUniformui64vNV", ogl.} - proc glGetMapControlPointsNV(target: TGLenum, index: TGLuint, `type`: TGLenum, ustride: TGLsizei, vstride: TGLsizei, packed: TGLboolean, points: pointer) {.importc: "glGetMapControlPointsNV", ogl.} - proc glGetPathColorGenfvNV(color: TGLenum, pname: TGLenum, value: TGLfloat) {.importc: "glGetPathColorGenfvNV", ogl.} - proc glTexCoord2f(s: TGLfloat, t: TGLfloat) {.importc: "glTexCoord2f", ogl.} - proc glSampleMaski(index: TGLuint, mask: TGLbitfield) {.importc: "glSampleMaski", ogl.} - proc glReadBufferIndexedEXT(src: TGLenum, index: TGLint) {.importc: "glReadBufferIndexedEXT", ogl.} - proc glCoverFillPathNV(path: TGLuint, coverMode: TGLenum) {.importc: "glCoverFillPathNV", ogl.} - proc glColorTableParameterfvSGI(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glColorTableParameterfvSGI", ogl.} - proc glDeleteVertexArraysAPPLE(n: TGLsizei, arrays: TGLuint) {.importc: "glDeleteVertexArraysAPPLE", ogl.} - proc glGetVertexAttribIiv(index: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetVertexAttribIiv", ogl.} - proc glWeightbvARB(size: TGLint, weights: TGLbyte) {.importc: "glWeightbvARB", ogl.} - proc glGetNamedBufferPointervEXT(buffer: TGLuint, pname: TGLenum, params: ptr pointer) {.importc: "glGetNamedBufferPointervEXT", ogl.} - proc glTexCoordPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glTexCoordPointer", ogl.} - proc glColor4fv(v: TGLfloat) {.importc: "glColor4fv", ogl.} - proc glGetnUniformfvARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLfloat) {.importc: "glGetnUniformfvARB", ogl.} - proc glMaterialxOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glMaterialxOES", ogl.} - proc glGetFixedv(pname: TGLenum, params: TGLfixed) {.importc: "glGetFixedv", ogl.} - proc glMaterialf(face: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glMaterialf", ogl.} - proc glVideoCaptureStreamParameterfvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glVideoCaptureStreamParameterfvNV", ogl.} - proc glGetDebugMessageLogAMD(count: TGLuint, bufsize: TGLsizei, categories: TGLenum, severities: TGLuint, ids: TGLuint, lengths: TGLsizei, message: TGLchar): TGLuint {.importc: "glGetDebugMessageLogAMD", ogl.} - proc glProgramUniform2uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glProgramUniform2uiv", ogl.} - proc glMatrixMultTransposedEXT(mode: TGLenum, m: TGLdouble) {.importc: "glMatrixMultTransposedEXT", ogl.} - proc glIsPointInStrokePathNV(path: TGLuint, x: TGLfloat, y: TGLfloat): TGLboolean {.importc: "glIsPointInStrokePathNV", ogl.} - proc glDisable(cap: TGLenum) {.importc: "glDisable", ogl.} - proc glCompileShader(shader: TGLuint) {.importc: "glCompileShader", ogl.} - proc glLoadTransposeMatrixd(m: TGLdouble) {.importc: "glLoadTransposeMatrixd", ogl.} - proc glGetMultiTexParameterIuivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc: "glGetMultiTexParameterIuivEXT", ogl.} - proc glGetHistogram(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc: "glGetHistogram", ogl.} - proc glMultiTexCoord3fvARB(target: TGLenum, v: TGLfloat) {.importc: "glMultiTexCoord3fvARB", ogl.} - proc glColor4xvOES(components: TGLfixed) {.importc: "glColor4xvOES", ogl.} - proc glIsBuffer(buffer: TGLuint): TGLboolean {.importc: "glIsBuffer", ogl.} - proc glVertex2dv(v: TGLdouble) {.importc: "glVertex2dv", ogl.} - proc glNamedProgramLocalParameterI4uivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLuint) {.importc: "glNamedProgramLocalParameterI4uivEXT", ogl.} - proc glPixelTexGenParameteriSGIS(pname: TGLenum, param: TGLint) {.importc: "glPixelTexGenParameteriSGIS", ogl.} - proc glBindVertexBuffers(first: TGLuint, count: TGLsizei, buffers: TGLuint, offsets: TGLintptr, strides: TGLsizei) {.importc: "glBindVertexBuffers", ogl.} - proc glUniform1ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc: "glUniform1ui64vNV", ogl.} - proc glColor4ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte, alpha: TGLubyte) {.importc: "glColor4ub", ogl.} - proc glConvolutionParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glConvolutionParameterfv", ogl.} - proc glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc: TGLuint, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glReplacementCodeuiColor4fNormal3fVertex3fSUN", ogl.} - proc glVertexAttribI2ui(index: TGLuint, x: TGLuint, y: TGLuint) {.importc: "glVertexAttribI2ui", ogl.} - proc glDeleteNamesAMD(identifier: TGLenum, num: TGLuint, names: TGLuint) {.importc: "glDeleteNamesAMD", ogl.} - proc glPixelTransferxOES(pname: TGLenum, param: TGLfixed) {.importc: "glPixelTransferxOES", ogl.} - proc glVertexAttrib4ivARB(index: TGLuint, v: TGLint) {.importc: "glVertexAttrib4ivARB", ogl.} - proc glLightModeli(pname: TGLenum, param: TGLint) {.importc: "glLightModeli", ogl.} - proc glGetHistogramEXT(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc: "glGetHistogramEXT", ogl.} - proc glWindowPos3svMESA(v: TGLshort) {.importc: "glWindowPos3svMESA", ogl.} - proc glRasterPos3iv(v: TGLint) {.importc: "glRasterPos3iv", ogl.} - proc glCopyTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyTextureSubImage3DEXT", ogl.} - proc glTextureStorage3DMultisampleEXT(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc: "glTextureStorage3DMultisampleEXT", ogl.} - proc glIsNameAMD(identifier: TGLenum, name: TGLuint): TGLboolean {.importc: "glIsNameAMD", ogl.} - proc glProgramUniformMatrix3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix3fv", ogl.} - proc glGetProgramParameterfvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetProgramParameterfvNV", ogl.} - proc glTexStorage3D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc: "glTexStorage3D", ogl.} - proc glMultiTexCoord2xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed) {.importc: "glMultiTexCoord2xOES", ogl.} - proc glWindowPos2fARB(x: TGLfloat, y: TGLfloat) {.importc: "glWindowPos2fARB", ogl.} - proc glGetProgramResourceIndex(program: TGLuint, programInterface: TGLenum, name: TGLchar): TGLuint {.importc: "glGetProgramResourceIndex", ogl.} - proc glProgramUniform2uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glProgramUniform2uivEXT", ogl.} - proc glMakeImageHandleNonResidentNV(handle: TGLuint64) {.importc: "glMakeImageHandleNonResidentNV", ogl.} - proc glNamedProgramLocalParameter4fvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLfloat) {.importc: "glNamedProgramLocalParameter4fvEXT", ogl.} - proc glInvalidateFramebuffer(target: TGLenum, numAttachments: TGLsizei, attachments: TGLenum) {.importc: "glInvalidateFramebuffer", ogl.} - proc glTexStorage3DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc: "glTexStorage3DMultisample", ogl.} - proc glMapVertexAttrib2fAPPLE(index: TGLuint, size: TGLuint, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, points: TGLfloat) {.importc: "glMapVertexAttrib2fAPPLE", ogl.} - proc glCombinerParameterfNV(pname: TGLenum, param: TGLfloat) {.importc: "glCombinerParameterfNV", ogl.} - proc glCopyMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc: "glCopyMultiTexImage2DEXT", ogl.} - proc glBindVertexShaderEXT(id: TGLuint) {.importc: "glBindVertexShaderEXT", ogl.} - proc glPathGlyphsNV(firstPathName: TGLuint, fontTarget: TGLenum, fontName: pointer, fontStyle: TGLbitfield, numGlyphs: TGLsizei, `type`: TGLenum, charcodes: pointer, handleMissingGlyphs: TGLenum, pathParameterTemplate: TGLuint, emScale: TGLfloat) {.importc: "glPathGlyphsNV", ogl.} - proc glProgramLocalParametersI4uivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLuint) {.importc: "glProgramLocalParametersI4uivNV", ogl.} - proc glMultiTexCoord3hvNV(target: TGLenum, v: TGLhalfNV) {.importc: "glMultiTexCoord3hvNV", ogl.} - proc glMultiTexCoordP2uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc: "glMultiTexCoordP2uiv", ogl.} - proc glDisableVariantClientStateEXT(id: TGLuint) {.importc: "glDisableVariantClientStateEXT", ogl.} - proc glGetTexLevelParameterxvOES(target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfixed) {.importc: "glGetTexLevelParameterxvOES", ogl.} - proc glRasterPos2sv(v: TGLshort) {.importc: "glRasterPos2sv", ogl.} - proc glWeightPathsNV(resultPath: TGLuint, numPaths: TGLsizei, paths: TGLuint, weights: TGLfloat) {.importc: "glWeightPathsNV", ogl.} - proc glDrawBuffersNV(n: TGLsizei, bufs: TGLenum) {.importc: "glDrawBuffersNV", ogl.} - proc glBindBufferARB(target: TGLenum, buffer: TGLuint) {.importc: "glBindBufferARB", ogl.} - proc glVariantbvEXT(id: TGLuint, `addr`: TGLbyte) {.importc: "glVariantbvEXT", ogl.} - proc glColorP3uiv(`type`: TGLenum, color: TGLuint) {.importc: "glColorP3uiv", ogl.} - proc glBlendEquationEXT(mode: TGLenum) {.importc: "glBlendEquationEXT", ogl.} - proc glProgramLocalParameterI4uivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc: "glProgramLocalParameterI4uivNV", ogl.} - proc glRenderMode(mode: TGLenum): TGLint {.importc: "glRenderMode", ogl.} - proc glVertexStream4fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glVertexStream4fATI", ogl.} - proc glGetObjectLabelEXT(`type`: TGLenum, `object`: TGLuint, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc: "glGetObjectLabelEXT", ogl.} - proc glNamedFramebufferTexture3DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc: "glNamedFramebufferTexture3DEXT", ogl.} - proc glLoadMatrixf(m: TGLfloat) {.importc: "glLoadMatrixf", ogl.} - proc glGetQueryObjectuivEXT(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc: "glGetQueryObjectuivEXT", ogl.} - proc glBindVideoCaptureStreamBufferNV(video_capture_slot: TGLuint, stream: TGLuint, frame_region: TGLenum, offset: TGLintptrARB) {.importc: "glBindVideoCaptureStreamBufferNV", ogl.} - proc glMatrixOrthoEXT(mode: TGLenum, left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc: "glMatrixOrthoEXT", ogl.} - proc glBlendFunc(sfactor: TGLenum, dfactor: TGLenum) {.importc: "glBlendFunc", ogl.} - proc glTexGenxvOES(coord: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glTexGenxvOES", ogl.} - proc glMatrixMode(mode: TGLenum) {.importc: "glMatrixMode", ogl.} - proc glColorTableParameterivSGI(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glColorTableParameterivSGI", ogl.} - proc glGetProgramInfoLog(program: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc: "glGetProgramInfoLog", ogl.} - proc glGetSeparableFilter(target: TGLenum, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer, span: pointer) {.importc: "glGetSeparableFilter", ogl.} - proc glFogfv(pname: TGLenum, params: TGLfloat) {.importc: "glFogfv", ogl.} - proc glDrawTexfvOES(coords: TGLfloat) {.importc: "glDrawTexfvOES", ogl.} - proc glClipPlanexIMG(p: TGLenum, eqn: TGLfixed) {.importc: "glClipPlanexIMG", ogl.} - proc glResetHistogramEXT(target: TGLenum) {.importc: "glResetHistogramEXT", ogl.} - proc glMemoryBarrier(barriers: TGLbitfield) {.importc: "glMemoryBarrier", ogl.} - proc glGetPixelMapusv(map: TGLenum, values: TGLushort) {.importc: "glGetPixelMapusv", ogl.} - proc glEvalCoord2f(u: TGLfloat, v: TGLfloat) {.importc: "glEvalCoord2f", ogl.} - proc glUniform4uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glUniform4uiv", ogl.} - proc glIsProgramARB(program: TGLuint): TGLboolean {.importc: "glIsProgramARB", ogl.} - proc glPointParameterfv(pname: TGLenum, params: TGLfloat) {.importc: "glPointParameterfv", ogl.} - proc glTexBuffer(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc: "glTexBuffer", ogl.} - proc glVertexAttrib1s(index: TGLuint, x: TGLshort) {.importc: "glVertexAttrib1s", ogl.} - proc glRenderbufferStorageMultisampleEXT(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glRenderbufferStorageMultisampleEXT", ogl.} - proc glMapNamedBufferEXT(buffer: TGLuint, access: TGLenum) {.importc: "glMapNamedBufferEXT", ogl.} - proc glDebugMessageCallbackAMD(callback: TGLDEBUGPROCAMD, userParam: pointer) {.importc: "glDebugMessageCallbackAMD", ogl.} - proc glGetTexEnvfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetTexEnvfv", ogl.} - proc glVertexAttribI3uivEXT(index: TGLuint, v: TGLuint) {.importc: "glVertexAttribI3uivEXT", ogl.} - proc glMultiTexEnvfEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glMultiTexEnvfEXT", ogl.} - proc glGetUniformiv(program: TGLuint, location: TGLint, params: TGLint) {.importc: "glGetUniformiv", ogl.} - proc glProgramLocalParameters4fvEXT(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLfloat) {.importc: "glProgramLocalParameters4fvEXT", ogl.} - proc glStencilStrokePathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, reference: TGLint, mask: TGLuint, transformType: TGLenum, transformValues: TGLfloat) {.importc: "glStencilStrokePathInstancedNV", ogl.} - proc glBeginConditionalRender(id: TGLuint, mode: TGLenum) {.importc: "glBeginConditionalRender", ogl.} - proc glVertexAttribI3uiEXT(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint) {.importc: "glVertexAttribI3uiEXT", ogl.} - proc glVDPAUMapSurfacesNV(numSurfaces: TGLsizei, surfaces: TGLvdpauSurfaceNV) {.importc: "glVDPAUMapSurfacesNV", ogl.} - proc glGetProgramResourceName(program: TGLuint, programInterface: TGLenum, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, name: TGLchar) {.importc: "glGetProgramResourceName", ogl.} - proc glMultiTexCoord4f(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc: "glMultiTexCoord4f", ogl.} - proc glVertexAttrib2hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV) {.importc: "glVertexAttrib2hNV", ogl.} - proc glDrawArraysInstancedNV(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc: "glDrawArraysInstancedNV", ogl.} - proc glClearAccum(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc: "glClearAccum", ogl.} - proc glVertexAttribI4usv(index: TGLuint, v: TGLushort) {.importc: "glVertexAttribI4usv", ogl.} - proc glGetProgramNamedParameterfvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, params: TGLfloat) {.importc: "glGetProgramNamedParameterfvNV", ogl.} - proc glTextureLightEXT(pname: TGLenum) {.importc: "glTextureLightEXT", ogl.} - proc glPathSubCoordsNV(path: TGLuint, coordStart: TGLsizei, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc: "glPathSubCoordsNV", ogl.} - proc glBindImageTexture(unit: TGLuint, texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, access: TGLenum, format: TGLenum) {.importc: "glBindImageTexture", ogl.} - proc glGenVertexArraysAPPLE(n: TGLsizei, arrays: TGLuint) {.importc: "glGenVertexArraysAPPLE", ogl.} - proc glFogCoordf(coord: TGLfloat) {.importc: "glFogCoordf", ogl.} - proc glFrameTerminatorGREMEDY() {.importc: "glFrameTerminatorGREMEDY", ogl.} - proc glValidateProgramPipelineEXT(pipeline: TGLuint) {.importc: "glValidateProgramPipelineEXT", ogl.} - proc glScalexOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc: "glScalexOES", ogl.} - proc glReplacementCodeuiColor3fVertex3fvSUN(rc: TGLuint, c: TGLfloat, v: TGLfloat) {.importc: "glReplacementCodeuiColor3fVertex3fvSUN", ogl.} - proc glProgramNamedParameter4dNV(id: TGLuint, len: TGLsizei, name: TGLubyte, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glProgramNamedParameter4dNV", ogl.} - proc glMultiDrawElementsIndirectCountARB(mode: TGLenum, `type`: TGLenum, indirect: TGLintptr, drawcount: TGLintptr, maxdrawcount: TGLsizei, stride: TGLsizei) {.importc: "glMultiDrawElementsIndirectCountARB", ogl.} - proc glReferencePlaneSGIX(equation: TGLdouble) {.importc: "glReferencePlaneSGIX", ogl.} - proc glNormalStream3iATI(stream: TGLenum, nx: TGLint, ny: TGLint, nz: TGLint) {.importc: "glNormalStream3iATI", ogl.} - proc glGetColorTableParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetColorTableParameterfvEXT", ogl.} - proc glGetAttribLocation(program: TGLuint, name: TGLchar): TGLint {.importc: "glGetAttribLocation", ogl.} - proc glMultiTexParameterfEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glMultiTexParameterfEXT", ogl.} - proc glGenFencesNV(n: TGLsizei, fences: TGLuint) {.importc: "glGenFencesNV", ogl.} - proc glUniform4dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glUniform4dv", ogl.} - proc glGetTexLevelParameterfv(target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfloat) {.importc: "glGetTexLevelParameterfv", ogl.} - proc glProgramUniform1ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glProgramUniform1ivEXT", ogl.} - proc glProgramUniform1dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glProgramUniform1dvEXT", ogl.} - proc glLoadTransposeMatrixdARB(m: TGLdouble) {.importc: "glLoadTransposeMatrixdARB", ogl.} - proc glVertexAttrib2fvARB(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib2fvARB", ogl.} - proc glMultiTexGendEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLdouble) {.importc: "glMultiTexGendEXT", ogl.} - proc glProgramUniformMatrix4x3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix4x3dvEXT", ogl.} - proc glUniform4ui(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc: "glUniform4ui", ogl.} - proc glTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexSubImage2D", ogl.} - proc glVertexAttrib3hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV) {.importc: "glVertexAttrib3hNV", ogl.} - proc glRotatexOES(angle: TGLfixed, x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc: "glRotatexOES", ogl.} - proc glGenTextures(n: TGLsizei, textures: TGLuint) {.importc: "glGenTextures", ogl.} - proc glCheckFramebufferStatusOES(target: TGLenum): TGLenum {.importc: "glCheckFramebufferStatusOES", ogl.} - proc glGetVideoCaptureStreamdvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLdouble) {.importc: "glGetVideoCaptureStreamdvNV", ogl.} - proc glCompressedTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedTextureSubImage1DEXT", ogl.} - proc glCurrentPaletteMatrixOES(matrixpaletteindex: TGLuint) {.importc: "glCurrentPaletteMatrixOES", ogl.} - proc glCompressedMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedMultiTexSubImage1DEXT", ogl.} - proc glNormal3d(nx: TGLdouble, ny: TGLdouble, nz: TGLdouble) {.importc: "glNormal3d", ogl.} - proc glMultiTexCoord1fv(target: TGLenum, v: TGLfloat) {.importc: "glMultiTexCoord1fv", ogl.} - proc glProgramUniform2uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint) {.importc: "glProgramUniform2uiEXT", ogl.} - proc glMultiTexCoord3fARB(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc: "glMultiTexCoord3fARB", ogl.} - proc glRasterPos3xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc: "glRasterPos3xOES", ogl.} - proc glEGLImageTargetRenderbufferStorageOES(target: TGLenum, image: TGLeglImageOES) {.importc: "glEGLImageTargetRenderbufferStorageOES", ogl.} - proc glGetAttribLocationARB(programObj: TGLhandleARB, name: TGLcharARB): TGLint {.importc: "glGetAttribLocationARB", ogl.} - proc glProgramNamedParameter4dvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, v: TGLdouble) {.importc: "glProgramNamedParameter4dvNV", ogl.} - proc glProgramLocalParameterI4uiNV(target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc: "glProgramLocalParameterI4uiNV", ogl.} - proc glNamedFramebufferTextureFaceEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc: "glNamedFramebufferTextureFaceEXT", ogl.} - proc glIndexf(c: TGLfloat) {.importc: "glIndexf", ogl.} - proc glExtTexObjectStateOverrideiQCOM(target: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glExtTexObjectStateOverrideiQCOM", ogl.} - proc glCoverageOperationNV(operation: TGLenum) {.importc: "glCoverageOperationNV", ogl.} - proc glColorP4uiv(`type`: TGLenum, color: TGLuint) {.importc: "glColorP4uiv", ogl.} - proc glDeleteSync(sync: TGLsync) {.importc: "glDeleteSync", ogl.} - proc glGetHistogramParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetHistogramParameterfvEXT", ogl.} - proc glTexCoord4fColor4fNormal3fVertex4fSUN(s: TGLfloat, t: TGLfloat, p: TGLfloat, q: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glTexCoord4fColor4fNormal3fVertex4fSUN", ogl.} - proc glEndPerfMonitorAMD(monitor: TGLuint) {.importc: "glEndPerfMonitorAMD", ogl.} - proc glGetInternalformati64v(target: TGLenum, internalformat: TGLenum, pname: TGLenum, bufSize: TGLsizei, params: TGLint64) {.importc: "glGetInternalformati64v", ogl.} - proc glGenNamesAMD(identifier: TGLenum, num: TGLuint, names: TGLuint) {.importc: "glGenNamesAMD", ogl.} - proc glDrawElementsInstancedBaseVertexBaseInstance(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei, basevertex: TGLint, baseinstance: TGLuint) {.importc: "glDrawElementsInstancedBaseVertexBaseInstance", ogl.} - proc glMultiTexCoord4i(target: TGLenum, s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc: "glMultiTexCoord4i", ogl.} - proc glVertexAttribL1dv(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttribL1dv", ogl.} - proc glGetProgramNamedParameterdvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, params: TGLdouble) {.importc: "glGetProgramNamedParameterdvNV", ogl.} - proc glSetLocalConstantEXT(id: TGLuint, `type`: TGLenum, `addr`: pointer) {.importc: "glSetLocalConstantEXT", ogl.} - proc glProgramBinary(program: TGLuint, binaryFormat: TGLenum, binary: pointer, length: TGLsizei) {.importc: "glProgramBinary", ogl.} - proc glVideoCaptureNV(video_capture_slot: TGLuint, sequence_num: TGLuint, capture_time: TGLuint64EXT): TGLenum {.importc: "glVideoCaptureNV", ogl.} - proc glDebugMessageEnableAMD(category: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc: "glDebugMessageEnableAMD", ogl.} - proc glVertexAttribI1i(index: TGLuint, x: TGLint) {.importc: "glVertexAttribI1i", ogl.} - proc glVertexWeighthNV(weight: TGLhalfNV) {.importc: "glVertexWeighthNV", ogl.} - proc glTextureParameterIivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glTextureParameterIivEXT", ogl.} - proc glClipPlanefIMG(p: TGLenum, eqn: TGLfloat) {.importc: "glClipPlanefIMG", ogl.} - proc glGetLightxv(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetLightxv", ogl.} - proc glGetAttachedObjectsARB(containerObj: TGLhandleARB, maxCount: TGLsizei, count: TGLsizei, obj: TGLhandleARB) {.importc: "glGetAttachedObjectsARB", ogl.} - proc glVertexAttrib4fv(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib4fv", ogl.} - proc glDisableVertexAttribArrayARB(index: TGLuint) {.importc: "glDisableVertexAttribArrayARB", ogl.} - proc glWindowPos3fvARB(v: TGLfloat) {.importc: "glWindowPos3fvARB", ogl.} - proc glClearDepthdNV(depth: TGLdouble) {.importc: "glClearDepthdNV", ogl.} - proc glMapParameterivNV(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glMapParameterivNV", ogl.} - proc glEndConditionalRenderNVX() {.importc: "glEndConditionalRenderNVX", ogl.} - proc glGetFragmentLightivSGIX(light: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetFragmentLightivSGIX", ogl.} - proc glProgramUniformMatrix4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix4fv", ogl.} - proc glVertexStream1iATI(stream: TGLenum, x: TGLint) {.importc: "glVertexStream1iATI", ogl.} - proc glColorP3ui(`type`: TGLenum, color: TGLuint) {.importc: "glColorP3ui", ogl.} - proc glGetLightxOES(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetLightxOES", ogl.} - proc glGetLightiv(light: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetLightiv", ogl.} - proc glVertexStream3dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glVertexStream3dATI", ogl.} - proc glProgramUniform1iEXT(program: TGLuint, location: TGLint, v0: TGLint) {.importc: "glProgramUniform1iEXT", ogl.} - proc glSecondaryColorFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc: "glSecondaryColorFormatNV", ogl.} - proc glDrawElementsBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, basevertex: TGLint) {.importc: "glDrawElementsBaseVertex", ogl.} - proc glGenFencesAPPLE(n: TGLsizei, fences: TGLuint) {.importc: "glGenFencesAPPLE", ogl.} - proc glBinormal3svEXT(v: TGLshort) {.importc: "glBinormal3svEXT", ogl.} - proc glUseProgramStagesEXT(pipeline: TGLuint, stages: TGLbitfield, program: TGLuint) {.importc: "glUseProgramStagesEXT", ogl.} - proc glDebugMessageCallbackKHR(callback: TGLDEBUGPROCKHR, userParam: pointer) {.importc: "glDebugMessageCallbackKHR", ogl.} - proc glCopyMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyMultiTexSubImage3DEXT", ogl.} - proc glColor4hvNV(v: TGLhalfNV) {.importc: "glColor4hvNV", ogl.} - proc glFenceSync(condition: TGLenum, flags: TGLbitfield): TGLsync {.importc: "glFenceSync", ogl.} - proc glTexCoordPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc: "glTexCoordPointerListIBM", ogl.} - proc glPopName() {.importc: "glPopName", ogl.} - proc glColor3fVertex3fvSUN(c: TGLfloat, v: TGLfloat) {.importc: "glColor3fVertex3fvSUN", ogl.} - proc glGetUniformfv(program: TGLuint, location: TGLint, params: TGLfloat) {.importc: "glGetUniformfv", ogl.} - proc glMultiTexCoord2hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV) {.importc: "glMultiTexCoord2hNV", ogl.} - proc glLightxv(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glLightxv", ogl.} - proc glVideoCaptureStreamParameterivNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glVideoCaptureStreamParameterivNV", ogl.} - proc glEvalCoord1xvOES(coords: TGLfixed) {.importc: "glEvalCoord1xvOES", ogl.} - proc glGetProgramEnvParameterIivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc: "glGetProgramEnvParameterIivNV", ogl.} - proc glObjectPurgeableAPPLE(objectType: TGLenum, name: TGLuint, option: TGLenum): TGLenum {.importc: "glObjectPurgeableAPPLE", ogl.} - proc glRequestResidentProgramsNV(n: TGLsizei, programs: TGLuint) {.importc: "glRequestResidentProgramsNV", ogl.} - proc glIsImageHandleResidentNV(handle: TGLuint64): TGLboolean {.importc: "glIsImageHandleResidentNV", ogl.} - proc glColor3hvNV(v: TGLhalfNV) {.importc: "glColor3hvNV", ogl.} - proc glMultiTexCoord2dARB(target: TGLenum, s: TGLdouble, t: TGLdouble) {.importc: "glMultiTexCoord2dARB", ogl.} - proc glDeletePathsNV(path: TGLuint, range: TGLsizei) {.importc: "glDeletePathsNV", ogl.} - proc glVertexAttrib4Nsv(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib4Nsv", ogl.} - proc glTexEnvf(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glTexEnvf", ogl.} - proc glGlobalAlphaFactoriSUN(factor: TGLint) {.importc: "glGlobalAlphaFactoriSUN", ogl.} - proc glBlendColorEXT(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc: "glBlendColorEXT", ogl.} - proc glSecondaryColor3usvEXT(v: TGLushort) {.importc: "glSecondaryColor3usvEXT", ogl.} - proc glProgramEnvParameterI4uiNV(target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc: "glProgramEnvParameterI4uiNV", ogl.} - proc glTexImage4DSGIS(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, size4d: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexImage4DSGIS", ogl.} - proc glMatrixPushEXT(mode: TGLenum) {.importc: "glMatrixPushEXT", ogl.} - proc glGetPixelTexGenParameterivSGIS(pname: TGLenum, params: TGLint) {.importc: "glGetPixelTexGenParameterivSGIS", ogl.} - proc glVariantuivEXT(id: TGLuint, `addr`: TGLuint) {.importc: "glVariantuivEXT", ogl.} - proc glTexParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glTexParameterfv", ogl.} - proc glGetSubroutineUniformLocation(program: TGLuint, shadertype: TGLenum, name: TGLchar): TGLint {.importc: "glGetSubroutineUniformLocation", ogl.} - proc glProgramUniformMatrix3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix3fvEXT", ogl.} - proc glDrawBuffersATI(n: TGLsizei, bufs: TGLenum) {.importc: "glDrawBuffersATI", ogl.} - proc glGetVertexAttribivNV(index: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetVertexAttribivNV", ogl.} - proc glMultiTexCoord4bvOES(texture: TGLenum, coords: TGLbyte) {.importc: "glMultiTexCoord4bvOES", ogl.} - proc glCompressedTexSubImage1DARB(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexSubImage1DARB", ogl.} - proc glClientActiveTexture(texture: TGLenum) {.importc: "glClientActiveTexture", ogl.} - proc glVertexAttrib2fARB(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc: "glVertexAttrib2fARB", ogl.} - proc glProgramUniform2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glProgramUniform2fvEXT", ogl.} - proc glGetBufferParameterui64vNV(target: TGLenum, pname: TGLenum, params: TGLuint64EXT) {.importc: "glGetBufferParameterui64vNV", ogl.} - proc glVertexStream3dvATI(stream: TGLenum, coords: TGLdouble) {.importc: "glVertexStream3dvATI", ogl.} - proc glReplacementCodeuiNormal3fVertex3fvSUN(rc: TGLuint, n: TGLfloat, v: TGLfloat) {.importc: "glReplacementCodeuiNormal3fVertex3fvSUN", ogl.} - proc glVertexAttrib4svNV(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib4svNV", ogl.} - proc glClearBufferSubData(target: TGLenum, internalformat: TGLenum, offset: TGLintptr, size: TGLsizeiptr, format: TGLenum, `type`: TGLenum, data: pointer) {.importc: "glClearBufferSubData", ogl.} - proc glVertexStream2sATI(stream: TGLenum, x: TGLshort, y: TGLshort) {.importc: "glVertexStream2sATI", ogl.} - proc glTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTextureImage2DEXT", ogl.} - proc glGetListParameterfvSGIX(list: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetListParameterfvSGIX", ogl.} - proc glUniform3uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glUniform3uiv", ogl.} - proc glIsTexture(texture: TGLuint): TGLboolean {.importc: "glIsTexture", ogl.} - proc glObjectUnpurgeableAPPLE(objectType: TGLenum, name: TGLuint, option: TGLenum): TGLenum {.importc: "glObjectUnpurgeableAPPLE", ogl.} - proc glGetVertexAttribdv(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc: "glGetVertexAttribdv", ogl.} - proc glGetPointeri_vEXT(pname: TGLenum, index: TGLuint, params: ptr pointer) {.importc: "glGetPointeri_vEXT", ogl.} - proc glSampleCoveragex(value: TGLclampx, invert: TGLboolean) {.importc: "glSampleCoveragex", ogl.} - proc glColor3f(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc: "glColor3f", ogl.} - proc glGetnMapivARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: TGLint) {.importc: "glGetnMapivARB", ogl.} - proc glMakeTextureHandleResidentARB(handle: TGLuint64) {.importc: "glMakeTextureHandleResidentARB", ogl.} - proc glSecondaryColorP3ui(`type`: TGLenum, color: TGLuint) {.importc: "glSecondaryColorP3ui", ogl.} - proc glMultiTexCoord4sARB(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc: "glMultiTexCoord4sARB", ogl.} - proc glUniform3i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc: "glUniform3i64NV", ogl.} - proc glVDPAUGetSurfaceivNV(surface: TGLvdpauSurfaceNV, pname: TGLenum, bufSize: TGLsizei, length: TGLsizei, values: TGLint) {.importc: "glVDPAUGetSurfaceivNV", ogl.} - proc glTexBufferEXT(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc: "glTexBufferEXT", ogl.} - proc glVertexAttribI4ubvEXT(index: TGLuint, v: TGLubyte) {.importc: "glVertexAttribI4ubvEXT", ogl.} - proc glDeleteFramebuffersOES(n: TGLsizei, framebuffers: TGLuint) {.importc: "glDeleteFramebuffersOES", ogl.} - proc glColor3fVertex3fSUN(r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glColor3fVertex3fSUN", ogl.} - proc glCombinerInputNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, input: TGLenum, mapping: TGLenum, componentUsage: TGLenum) {.importc: "glCombinerInputNV", ogl.} - proc glPolygonOffsetEXT(factor: TGLfloat, bias: TGLfloat) {.importc: "glPolygonOffsetEXT", ogl.} - proc glWindowPos4dMESA(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glWindowPos4dMESA", ogl.} - proc glVertex3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glVertex3f", ogl.} - proc glTexCoord3f(s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc: "glTexCoord3f", ogl.} - proc glMultiTexCoord1fARB(target: TGLenum, s: TGLfloat) {.importc: "glMultiTexCoord1fARB", ogl.} - proc glVertexAttrib4f(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glVertexAttrib4f", ogl.} - proc glGetFragDataLocationEXT(program: TGLuint, name: TGLchar): TGLint {.importc: "glGetFragDataLocationEXT", ogl.} - proc glFlushMappedNamedBufferRangeEXT(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr) {.importc: "glFlushMappedNamedBufferRangeEXT", ogl.} - proc glVertexAttrib1sARB(index: TGLuint, x: TGLshort) {.importc: "glVertexAttrib1sARB", ogl.} - proc glBitmapxOES(width: TGLsizei, height: TGLsizei, xorig: TGLfixed, yorig: TGLfixed, xmove: TGLfixed, ymove: TGLfixed, bitmap: TGLubyte) {.importc: "glBitmapxOES", ogl.} - proc glEnableVertexArrayAttribEXT(vaobj: TGLuint, index: TGLuint) {.importc: "glEnableVertexArrayAttribEXT", ogl.} - proc glDeleteRenderbuffers(n: TGLsizei, renderbuffers: TGLuint) {.importc: "glDeleteRenderbuffers", ogl.} - proc glFramebufferRenderbuffer(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc: "glFramebufferRenderbuffer", ogl.} - proc glInvalidateTexImage(texture: TGLuint, level: TGLint) {.importc: "glInvalidateTexImage", ogl.} - proc glProgramUniform2i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT) {.importc: "glProgramUniform2i64NV", ogl.} - proc glTextureImage3DMultisampleNV(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc: "glTextureImage3DMultisampleNV", ogl.} - proc glValidateProgram(program: TGLuint) {.importc: "glValidateProgram", ogl.} - proc glUniform1dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glUniform1dv", ogl.} - proc glNormalStream3dvATI(stream: TGLenum, coords: TGLdouble) {.importc: "glNormalStream3dvATI", ogl.} - proc glMultiDrawElementsIndirect(mode: TGLenum, `type`: TGLenum, indirect: pointer, drawcount: TGLsizei, stride: TGLsizei) {.importc: "glMultiDrawElementsIndirect", ogl.} - proc glVertexBlendARB(count: TGLint) {.importc: "glVertexBlendARB", ogl.} - proc glIsSampler(sampler: TGLuint): TGLboolean {.importc: "glIsSampler", ogl.} - proc glVariantdvEXT(id: TGLuint, `addr`: TGLdouble) {.importc: "glVariantdvEXT", ogl.} - proc glProgramUniformMatrix3x2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix3x2fvEXT", ogl.} - proc glVertexStream4fvATI(stream: TGLenum, coords: TGLfloat) {.importc: "glVertexStream4fvATI", ogl.} - proc glOrthoxOES(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc: "glOrthoxOES", ogl.} - proc glColorFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc: "glColorFormatNV", ogl.} - proc glFogCoordPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glFogCoordPointer", ogl.} - proc glVertexAttrib3dvARB(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib3dvARB", ogl.} - proc glVertex3bOES(x: TGLbyte, y: TGLbyte) {.importc: "glVertex3bOES", ogl.} - proc glVertexAttribFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, relativeoffset: TGLuint) {.importc: "glVertexAttribFormat", ogl.} - proc glTexCoord4fVertex4fSUN(s: TGLfloat, t: TGLfloat, p: TGLfloat, q: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glTexCoord4fVertex4fSUN", ogl.} - proc glEnableDriverControlQCOM(driverControl: TGLuint) {.importc: "glEnableDriverControlQCOM", ogl.} - proc glPointParameteri(pname: TGLenum, param: TGLint) {.importc: "glPointParameteri", ogl.} - proc glVertexAttribI2i(index: TGLuint, x: TGLint, y: TGLint) {.importc: "glVertexAttribI2i", ogl.} - proc glGetDriverControlStringQCOM(driverControl: TGLuint, bufSize: TGLsizei, length: TGLsizei, driverControlString: TGLchar) {.importc: "glGetDriverControlStringQCOM", ogl.} - proc glGetTexLevelParameteriv(target: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc: "glGetTexLevelParameteriv", ogl.} - proc glGetHandleARB(pname: TGLenum): TGLhandleARB {.importc: "glGetHandleARB", ogl.} - proc glIndexubv(c: TGLubyte) {.importc: "glIndexubv", ogl.} - proc glBlendFunciARB(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc: "glBlendFunciARB", ogl.} - proc glColor4usv(v: TGLushort) {.importc: "glColor4usv", ogl.} - proc glBlendEquationSeparateOES(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc: "glBlendEquationSeparateOES", ogl.} - proc glVertexAttribI4ui(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc: "glVertexAttribI4ui", ogl.} - proc glProgramUniform3f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc: "glProgramUniform3f", ogl.} - proc glVertexAttribL3i64vNV(index: TGLuint, v: TGLint64EXT) {.importc: "glVertexAttribL3i64vNV", ogl.} - proc glWeightdvARB(size: TGLint, weights: TGLdouble) {.importc: "glWeightdvARB", ogl.} - proc glVertexArrayRangeAPPLE(length: TGLsizei, `pointer`: pointer) {.importc: "glVertexArrayRangeAPPLE", ogl.} - proc glMapGrid2d(un: TGLint, u1: TGLdouble, u2: TGLdouble, vn: TGLint, v1: TGLdouble, v2: TGLdouble) {.importc: "glMapGrid2d", ogl.} - proc glFogiv(pname: TGLenum, params: TGLint) {.importc: "glFogiv", ogl.} - proc glUniform2f(location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc: "glUniform2f", ogl.} - proc glGetDoublei_v(target: TGLenum, index: TGLuint, data: TGLdouble) {.importc: "glGetDoublei_v", ogl.} - proc glGetVertexAttribfv(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetVertexAttribfv", ogl.} - proc glVertexAttribI2ivEXT(index: TGLuint, v: TGLint) {.importc: "glVertexAttribI2ivEXT", ogl.} - proc glIsProgramNV(id: TGLuint): TGLboolean {.importc: "glIsProgramNV", ogl.} - proc glTexCoord1hNV(s: TGLhalfNV) {.importc: "glTexCoord1hNV", ogl.} - proc glMinSampleShadingARB(value: TGLfloat) {.importc: "glMinSampleShadingARB", ogl.} - proc glMultiDrawElements(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, drawcount: TGLsizei) {.importc: "glMultiDrawElements", ogl.} - proc glGetQueryObjectuiv(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc: "glGetQueryObjectuiv", ogl.} - proc glReadBuffer(mode: TGLenum) {.importc: "glReadBuffer", ogl.} - proc glMultiTexCoordP3uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc: "glMultiTexCoordP3uiv", ogl.} - proc glUniformMatrix3x2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix3x2fv", ogl.} - proc glBindRenderbuffer(target: TGLenum, renderbuffer: TGLuint) {.importc: "glBindRenderbuffer", ogl.} - proc glBinormal3sEXT(bx: TGLshort, by: TGLshort, bz: TGLshort) {.importc: "glBinormal3sEXT", ogl.} - proc glUniform4iARB(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc: "glUniform4iARB", ogl.} - proc glGetUniformOffsetEXT(program: TGLuint, location: TGLint): TGLintptr {.importc: "glGetUniformOffsetEXT", ogl.} - proc glDeleteLists(list: TGLuint, range: TGLsizei) {.importc: "glDeleteLists", ogl.} - proc glVertexAttribI1iEXT(index: TGLuint, x: TGLint) {.importc: "glVertexAttribI1iEXT", ogl.} - proc glFramebufferTexture1D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glFramebufferTexture1D", ogl.} - proc glVertexAttribI2uiv(index: TGLuint, v: TGLuint) {.importc: "glVertexAttribI2uiv", ogl.} - proc glBindFragDataLocation(program: TGLuint, color: TGLuint, name: TGLchar) {.importc: "glBindFragDataLocation", ogl.} - proc glClearStencil(s: TGLint) {.importc: "glClearStencil", ogl.} - proc glVertexAttrib4Nubv(index: TGLuint, v: TGLubyte) {.importc: "glVertexAttrib4Nubv", ogl.} - proc glConvolutionFilter2DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc: "glConvolutionFilter2DEXT", ogl.} - proc glGenFramebuffersEXT(n: TGLsizei, framebuffers: TGLuint) {.importc: "glGenFramebuffersEXT", ogl.} - proc glFogCoordfvEXT(coord: TGLfloat) {.importc: "glFogCoordfvEXT", ogl.} - proc glGetRenderbufferParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetRenderbufferParameterivEXT", ogl.} - proc glVertexAttribs1fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc: "glVertexAttribs1fvNV", ogl.} - proc glTexCoord2fColor3fVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glTexCoord2fColor3fVertex3fSUN", ogl.} - proc glRasterPos3i(x: TGLint, y: TGLint, z: TGLint) {.importc: "glRasterPos3i", ogl.} - proc glMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glMultiTexSubImage2DEXT", ogl.} - proc glConvolutionParameteriEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glConvolutionParameteriEXT", ogl.} - proc glVertexAttribI4iEXT(index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc: "glVertexAttribI4iEXT", ogl.} - proc glVertexAttribL2i64vNV(index: TGLuint, v: TGLint64EXT) {.importc: "glVertexAttribL2i64vNV", ogl.} - proc glBlendColor(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc: "glBlendColor", ogl.} - proc glGetPathColorGenivNV(color: TGLenum, pname: TGLenum, value: TGLint) {.importc: "glGetPathColorGenivNV", ogl.} - proc glCompressedTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedTextureImage1DEXT", ogl.} - proc glDrawElementsInstanced(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei) {.importc: "glDrawElementsInstanced", ogl.} - proc glFogCoordd(coord: TGLdouble) {.importc: "glFogCoordd", ogl.} - proc glTexParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glTexParameterxvOES", ogl.} - proc glWindowPos3svARB(v: TGLshort) {.importc: "glWindowPos3svARB", ogl.} - proc glGetVertexArrayPointervEXT(vaobj: TGLuint, pname: TGLenum, param: ptr pointer) {.importc: "glGetVertexArrayPointervEXT", ogl.} - proc glDrawTextureNV(texture: TGLuint, sampler: TGLuint, x0: TGLfloat, y0: TGLfloat, x1: TGLfloat, y1: TGLfloat, z: TGLfloat, s0: TGLfloat, t0: TGLfloat, s1: TGLfloat, t1: TGLfloat) {.importc: "glDrawTextureNV", ogl.} - proc glUniformMatrix2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glUniformMatrix2dv", ogl.} - proc glTexImage3DOES(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexImage3DOES", ogl.} - proc glClampColorARB(target: TGLenum, clamp: TGLenum) {.importc: "glClampColorARB", ogl.} - proc glTexParameteri(target: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glTexParameteri", ogl.} - proc glWindowPos4svMESA(v: TGLshort) {.importc: "glWindowPos4svMESA", ogl.} - proc glMultiTexCoordP4ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc: "glMultiTexCoordP4ui", ogl.} - proc glVertexP4uiv(`type`: TGLenum, value: TGLuint) {.importc: "glVertexP4uiv", ogl.} - proc glProgramUniform4iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc: "glProgramUniform4iEXT", ogl.} - proc glTexCoord3xvOES(coords: TGLfixed) {.importc: "glTexCoord3xvOES", ogl.} - proc glCopyTexImage2DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc: "glCopyTexImage2DEXT", ogl.} - proc glGenSamplers(count: TGLsizei, samplers: TGLuint) {.importc: "glGenSamplers", ogl.} - proc glRasterPos4iv(v: TGLint) {.importc: "glRasterPos4iv", ogl.} - proc glWindowPos4sMESA(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc: "glWindowPos4sMESA", ogl.} - proc glProgramUniform2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glProgramUniform2dvEXT", ogl.} - proc glPrioritizeTexturesEXT(n: TGLsizei, textures: TGLuint, priorities: TGLclampf) {.importc: "glPrioritizeTexturesEXT", ogl.} - proc glRects(x1: TGLshort, y1: TGLshort, x2: TGLshort, y2: TGLshort) {.importc: "glRects", ogl.} - proc glMultiDrawElementsBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, drawcount: TGLsizei, basevertex: TGLint) {.importc: "glMultiDrawElementsBaseVertex", ogl.} - proc glProgramBinaryOES(program: TGLuint, binaryFormat: TGLenum, binary: pointer, length: TGLint) {.importc: "glProgramBinaryOES", ogl.} - proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc: TGLuint, tc: TGLfloat, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc: "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", ogl.} - proc glGetMinmaxParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetMinmaxParameterfv", ogl.} - proc glColor4fNormal3fVertex3fSUN(r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glColor4fNormal3fVertex3fSUN", ogl.} - proc glWindowPos2d(x: TGLdouble, y: TGLdouble) {.importc: "glWindowPos2d", ogl.} - proc glGetPerfMonitorGroupStringAMD(group: TGLuint, bufSize: TGLsizei, length: TGLsizei, groupString: TGLchar) {.importc: "glGetPerfMonitorGroupStringAMD", ogl.} - proc glUniformHandleui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64) {.importc: "glUniformHandleui64vNV", ogl.} - proc glBlendEquation(mode: TGLenum) {.importc: "glBlendEquation", ogl.} - proc glMapBufferARB(target: TGLenum, access: TGLenum) {.importc: "glMapBufferARB", ogl.} - proc glGetMaterialxvOES(face: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetMaterialxvOES", ogl.} - proc glVertexAttribI1ivEXT(index: TGLuint, v: TGLint) {.importc: "glVertexAttribI1ivEXT", ogl.} - proc glTexCoord4hvNV(v: TGLhalfNV) {.importc: "glTexCoord4hvNV", ogl.} - proc glVertexArrayVertexAttribLOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayVertexAttribLOffsetEXT", ogl.} - proc glExtGetShadersQCOM(shaders: TGLuint, maxShaders: TGLint, numShaders: TGLint) {.importc: "glExtGetShadersQCOM", ogl.} - proc glWindowPos4ivMESA(v: TGLint) {.importc: "glWindowPos4ivMESA", ogl.} - proc glVertexAttrib1sNV(index: TGLuint, x: TGLshort) {.importc: "glVertexAttrib1sNV", ogl.} - proc glNormalStream3ivATI(stream: TGLenum, coords: TGLint) {.importc: "glNormalStream3ivATI", ogl.} - proc glSecondaryColor3fEXT(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc: "glSecondaryColor3fEXT", ogl.} - proc glVertexArrayFogCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayFogCoordOffsetEXT", ogl.} - proc glGetTextureImageEXT(texture: TGLuint, target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glGetTextureImageEXT", ogl.} - proc glVertexAttrib4hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV, w: TGLhalfNV) {.importc: "glVertexAttrib4hNV", ogl.} - proc glReplacementCodeusSUN(code: TGLushort) {.importc: "glReplacementCodeusSUN", ogl.} - proc glPixelTexGenSGIX(mode: TGLenum) {.importc: "glPixelTexGenSGIX", ogl.} - proc glMultiDrawRangeElementArrayAPPLE(mode: TGLenum, start: TGLuint, `end`: TGLuint, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc: "glMultiDrawRangeElementArrayAPPLE", ogl.} - proc glDrawElements(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc: "glDrawElements", ogl.} - proc glTexCoord1hvNV(v: TGLhalfNV) {.importc: "glTexCoord1hvNV", ogl.} - proc glGetPixelMapuiv(map: TGLenum, values: TGLuint) {.importc: "glGetPixelMapuiv", ogl.} - proc glRasterPos4d(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glRasterPos4d", ogl.} - proc glTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexImage1D", ogl.} - proc glConvolutionParameterxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glConvolutionParameterxOES", ogl.} - proc glSecondaryColor3dEXT(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc: "glSecondaryColor3dEXT", ogl.} - proc glGetCombinerOutputParameterivNV(stage: TGLenum, portion: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetCombinerOutputParameterivNV", ogl.} - proc glQueryCounter(id: TGLuint, target: TGLenum) {.importc: "glQueryCounter", ogl.} - proc glGetUniformi64vNV(program: TGLuint, location: TGLint, params: TGLint64EXT) {.importc: "glGetUniformi64vNV", ogl.} - proc glTexCoord2fv(v: TGLfloat) {.importc: "glTexCoord2fv", ogl.} - proc glWindowPos3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glWindowPos3d", ogl.} - proc glBlendFuncSeparateINGR(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc: "glBlendFuncSeparateINGR", ogl.} - proc glTextureNormalEXT(mode: TGLenum) {.importc: "glTextureNormalEXT", ogl.} - proc glVertexStream2fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat) {.importc: "glVertexStream2fATI", ogl.} - proc glViewportIndexedf(index: TGLuint, x: TGLfloat, y: TGLfloat, w: TGLfloat, h: TGLfloat) {.importc: "glViewportIndexedf", ogl.} - proc glMultiTexCoord4ivARB(target: TGLenum, v: TGLint) {.importc: "glMultiTexCoord4ivARB", ogl.} - proc glBindBufferOffsetEXT(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr) {.importc: "glBindBufferOffsetEXT", ogl.} - proc glTexCoord3sv(v: TGLshort) {.importc: "glTexCoord3sv", ogl.} - proc glVertexArrayVertexAttribBindingEXT(vaobj: TGLuint, attribindex: TGLuint, bindingindex: TGLuint) {.importc: "glVertexArrayVertexAttribBindingEXT", ogl.} - proc glVertexAttrib2f(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc: "glVertexAttrib2f", ogl.} - proc glMultiTexGenivEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glMultiTexGenivEXT", ogl.} - proc glUniformui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc: "glUniformui64vNV", ogl.} - proc glGetInfoLogARB(obj: TGLhandleARB, maxLength: TGLsizei, length: TGLsizei, infoLog: TGLcharARB) {.importc: "glGetInfoLogARB", ogl.} - proc glGetNamedProgramLocalParameterIivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLint) {.importc: "glGetNamedProgramLocalParameterIivEXT", ogl.} - proc glVertexAttrib4s(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc: "glVertexAttrib4s", ogl.} - proc glUniformMatrix4x2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glUniformMatrix4x2dv", ogl.} - proc glVertexAttribs3dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc: "glVertexAttribs3dvNV", ogl.} - proc glSecondaryColor3dvEXT(v: TGLdouble) {.importc: "glSecondaryColor3dvEXT", ogl.} - proc glTextureRenderbufferEXT(texture: TGLuint, target: TGLenum, renderbuffer: TGLuint) {.importc: "glTextureRenderbufferEXT", ogl.} - proc glVertexAttribL2ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc: "glVertexAttribL2ui64vNV", ogl.} - proc glBlendFuncSeparateOES(srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc: "glBlendFuncSeparateOES", ogl.} - proc glVertexAttribDivisorARB(index: TGLuint, divisor: TGLuint) {.importc: "glVertexAttribDivisorARB", ogl.} - proc glWindowPos2sv(v: TGLshort) {.importc: "glWindowPos2sv", ogl.} - proc glMultiTexCoord3svARB(target: TGLenum, v: TGLshort) {.importc: "glMultiTexCoord3svARB", ogl.} - proc glCombinerParameterfvNV(pname: TGLenum, params: TGLfloat) {.importc: "glCombinerParameterfvNV", ogl.} - proc glGetImageTransformParameterfvHP(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetImageTransformParameterfvHP", ogl.} - proc glTexParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glTexParameteriv", ogl.} - proc glGetArrayObjectivATI(`array`: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetArrayObjectivATI", ogl.} - proc glGetTexParameterIuiv(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc: "glGetTexParameterIuiv", ogl.} - proc glGetProgramPipelineInfoLog(pipeline: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc: "glGetProgramPipelineInfoLog", ogl.} - proc glGetOcclusionQueryuivNV(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc: "glGetOcclusionQueryuivNV", ogl.} - proc glVertexAttrib4bvARB(index: TGLuint, v: TGLbyte) {.importc: "glVertexAttrib4bvARB", ogl.} - proc glListParameterfvSGIX(list: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glListParameterfvSGIX", ogl.} - proc glDeleteSamplers(count: TGLsizei, samplers: TGLuint) {.importc: "glDeleteSamplers", ogl.} - proc glNormalStream3dATI(stream: TGLenum, nx: TGLdouble, ny: TGLdouble, nz: TGLdouble) {.importc: "glNormalStream3dATI", ogl.} - proc glProgramUniform4i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc: "glProgramUniform4i64vNV", ogl.} - proc glBlendFuncSeparateiARB(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc: "glBlendFuncSeparateiARB", ogl.} - proc glEndTransformFeedbackEXT() {.importc: "glEndTransformFeedbackEXT", ogl.} - proc glMultiTexCoord3i(target: TGLenum, s: TGLint, t: TGLint, r: TGLint) {.importc: "glMultiTexCoord3i", ogl.} - proc glMakeBufferResidentNV(target: TGLenum, access: TGLenum) {.importc: "glMakeBufferResidentNV", ogl.} - proc glTangent3dvEXT(v: TGLdouble) {.importc: "glTangent3dvEXT", ogl.} - proc glMatrixPopEXT(mode: TGLenum) {.importc: "glMatrixPopEXT", ogl.} - proc glVertexAttrib4NivARB(index: TGLuint, v: TGLint) {.importc: "glVertexAttrib4NivARB", ogl.} - proc glProgramUniform2ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc: "glProgramUniform2ui64NV", ogl.} - proc glWeightPointerARB(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glWeightPointerARB", ogl.} - proc glCullParameterdvEXT(pname: TGLenum, params: TGLdouble) {.importc: "glCullParameterdvEXT", ogl.} - proc glFramebufferTexture2D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glFramebufferTexture2D", ogl.} - proc glGenVertexArrays(n: TGLsizei, arrays: TGLuint) {.importc: "glGenVertexArrays", ogl.} - proc glUniformHandleui64NV(location: TGLint, value: TGLuint64) {.importc: "glUniformHandleui64NV", ogl.} - proc glIndexPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glIndexPointer", ogl.} - proc glGetProgramSubroutineParameteruivNV(target: TGLenum, index: TGLuint, param: TGLuint) {.importc: "glGetProgramSubroutineParameteruivNV", ogl.} - proc glVertexAttrib1svARB(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib1svARB", ogl.} - proc glDetachObjectARB(containerObj: TGLhandleARB, attachedObj: TGLhandleARB) {.importc: "glDetachObjectARB", ogl.} - proc glCompressedTexImage3D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexImage3D", ogl.} - proc glBlendFuncSeparate(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc: "glBlendFuncSeparate", ogl.} - proc glExecuteProgramNV(target: TGLenum, id: TGLuint, params: TGLfloat) {.importc: "glExecuteProgramNV", ogl.} - proc glAttachObjectARB(containerObj: TGLhandleARB, obj: TGLhandleARB) {.importc: "glAttachObjectARB", ogl.} - proc glCompressedTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexSubImage1D", ogl.} - proc glProgramUniform4iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glProgramUniform4iv", ogl.} - proc glVertexAttrib3sv(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib3sv", ogl.} - proc glTexCoord3bvOES(coords: TGLbyte) {.importc: "glTexCoord3bvOES", ogl.} - proc glGenTexturesEXT(n: TGLsizei, textures: TGLuint) {.importc: "glGenTexturesEXT", ogl.} - proc glColor4f(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc: "glColor4f", ogl.} - proc glGetFramebufferAttachmentParameterivOES(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetFramebufferAttachmentParameterivOES", ogl.} - proc glClearColor(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc: "glClearColor", ogl.} - proc glNamedProgramLocalParametersI4ivEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLint) {.importc: "glNamedProgramLocalParametersI4ivEXT", ogl.} - proc glMakeImageHandleNonResidentARB(handle: TGLuint64) {.importc: "glMakeImageHandleNonResidentARB", ogl.} - proc glGenRenderbuffers(n: TGLsizei, renderbuffers: TGLuint) {.importc: "glGenRenderbuffers", ogl.} - proc glVertexAttribL1ui64vARB(index: TGLuint, v: TGLuint64EXT) {.importc: "glVertexAttribL1ui64vARB", ogl.} - proc glBindFramebufferEXT(target: TGLenum, framebuffer: TGLuint) {.importc: "glBindFramebufferEXT", ogl.} - proc glProgramUniform2dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble) {.importc: "glProgramUniform2dEXT", ogl.} - proc glCompressedMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedMultiTexImage2DEXT", ogl.} - proc glDeleteSyncAPPLE(sync: TGLsync) {.importc: "glDeleteSyncAPPLE", ogl.} - proc glDebugMessageInsertAMD(category: TGLenum, severity: TGLenum, id: TGLuint, length: TGLsizei, buf: TGLchar) {.importc: "glDebugMessageInsertAMD", ogl.} - proc glSecondaryColorPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glSecondaryColorPointerEXT", ogl.} - proc glTextureImage2DMultisampleNV(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc: "glTextureImage2DMultisampleNV", ogl.} - proc glBeginFragmentShaderATI() {.importc: "glBeginFragmentShaderATI", ogl.} - proc glClearDepth(depth: TGLdouble) {.importc: "glClearDepth", ogl.} - proc glBindTextures(first: TGLuint, count: TGLsizei, textures: TGLuint) {.importc: "glBindTextures", ogl.} - proc glEvalCoord1d(u: TGLdouble) {.importc: "glEvalCoord1d", ogl.} - proc glSecondaryColor3b(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc: "glSecondaryColor3b", ogl.} - proc glExtGetTexSubImageQCOM(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, texels: pointer) {.importc: "glExtGetTexSubImageQCOM", ogl.} - proc glClearColorIiEXT(red: TGLint, green: TGLint, blue: TGLint, alpha: TGLint) {.importc: "glClearColorIiEXT", ogl.} - proc glVertex2xOES(x: TGLfixed) {.importc: "glVertex2xOES", ogl.} - proc glVertexAttrib2s(index: TGLuint, x: TGLshort, y: TGLshort) {.importc: "glVertexAttrib2s", ogl.} - proc glUniformHandleui64vARB(location: TGLint, count: TGLsizei, value: TGLuint64) {.importc: "glUniformHandleui64vARB", ogl.} - proc glAreTexturesResidentEXT(n: TGLsizei, textures: TGLuint, residences: TGLboolean): TGLboolean {.importc: "glAreTexturesResidentEXT", ogl.} - proc glDrawElementsInstancedBaseInstance(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei, baseinstance: TGLuint) {.importc: "glDrawElementsInstancedBaseInstance", ogl.} - proc glGetString(name: TGLenum): TGLubyte {.importc: "glGetString", ogl.} - proc glDrawTransformFeedbackStream(mode: TGLenum, id: TGLuint, stream: TGLuint) {.importc: "glDrawTransformFeedbackStream", ogl.} - proc glSecondaryColor3uiv(v: TGLuint) {.importc: "glSecondaryColor3uiv", ogl.} - proc glNamedFramebufferParameteriEXT(framebuffer: TGLuint, pname: TGLenum, param: TGLint) {.importc: "glNamedFramebufferParameteriEXT", ogl.} - proc glVertexAttrib4hvNV(index: TGLuint, v: TGLhalfNV) {.importc: "glVertexAttrib4hvNV", ogl.} - proc glGetnUniformuivARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLuint) {.importc: "glGetnUniformuivARB", ogl.} - proc glProgramUniform4ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc: "glProgramUniform4ui", ogl.} - proc glPointParameterxvOES(pname: TGLenum, params: TGLfixed) {.importc: "glPointParameterxvOES", ogl.} - proc glIsEnabledi(target: TGLenum, index: TGLuint): TGLboolean {.importc: "glIsEnabledi", ogl.} - proc glColorPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc: "glColorPointerEXT", ogl.} - proc glFragmentLightModelfvSGIX(pname: TGLenum, params: TGLfloat) {.importc: "glFragmentLightModelfvSGIX", ogl.} - proc glRasterPos3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glRasterPos3f", ogl.} - proc glDeleteObjectARB(obj: TGLhandleARB) {.importc: "glDeleteObjectARB", ogl.} - proc glSetFenceNV(fence: TGLuint, condition: TGLenum) {.importc: "glSetFenceNV", ogl.} - proc glTransformFeedbackAttribsNV(count: TGLuint, attribs: TGLint, bufferMode: TGLenum) {.importc: "glTransformFeedbackAttribsNV", ogl.} - proc glProgramUniformMatrix2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix2fvEXT", ogl.} - proc glGetPointerv(pname: TGLenum, params: ptr pointer) {.importc: "glGetPointerv", ogl.} - proc glWindowPos2dvMESA(v: TGLdouble) {.importc: "glWindowPos2dvMESA", ogl.} - proc glTexImage2DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLint, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc: "glTexImage2DMultisample", ogl.} - proc glGenFragmentShadersATI(range: TGLuint): TGLuint {.importc: "glGenFragmentShadersATI", ogl.} - proc glTexCoord4fv(v: TGLfloat) {.importc: "glTexCoord4fv", ogl.} - proc glCompressedTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexImage1D", ogl.} - proc glGetNamedBufferSubDataEXT(buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc: "glGetNamedBufferSubDataEXT", ogl.} - proc glFinish() {.importc: "glFinish", ogl.} - proc glDeleteVertexShaderEXT(id: TGLuint) {.importc: "glDeleteVertexShaderEXT", ogl.} - proc glFinishObjectAPPLE(`object`: TGLenum, name: TGLint) {.importc: "glFinishObjectAPPLE", ogl.} - proc glGetActiveAttribARB(programObj: TGLhandleARB, index: TGLuint, maxLength: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLcharARB) {.importc: "glGetActiveAttribARB", ogl.} - proc glPointParameterx(pname: TGLenum, param: TGLfixed) {.importc: "glPointParameterx", ogl.} - proc glProgramUniformui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc: "glProgramUniformui64vNV", ogl.} - proc glSecondaryColor3ubv(v: TGLubyte) {.importc: "glSecondaryColor3ubv", ogl.} - proc glGetProgramLocalParameterIivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc: "glGetProgramLocalParameterIivNV", ogl.} - proc glDeleteProgramPipelinesEXT(n: TGLsizei, pipelines: TGLuint) {.importc: "glDeleteProgramPipelinesEXT", ogl.} - proc glVertexAttrib4fNV(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glVertexAttrib4fNV", ogl.} - proc glGetColorTableParameterfvSGI(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetColorTableParameterfvSGI", ogl.} - proc glGetFloati_v(target: TGLenum, index: TGLuint, data: TGLfloat) {.importc: "glGetFloati_v", ogl.} - proc glGenBuffers(n: TGLsizei, buffers: TGLuint) {.importc: "glGenBuffers", ogl.} - proc glNormal3b(nx: TGLbyte, ny: TGLbyte, nz: TGLbyte) {.importc: "glNormal3b", ogl.} - proc glDrawArraysInstancedARB(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc: "glDrawArraysInstancedARB", ogl.} - proc glTexStorage2DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc: "glTexStorage2DMultisample", ogl.} - proc glGetVariantIntegervEXT(id: TGLuint, value: TGLenum, data: TGLint) {.importc: "glGetVariantIntegervEXT", ogl.} - proc glColor3ubv(v: TGLubyte) {.importc: "glColor3ubv", ogl.} - proc glVertexAttribP4uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc: "glVertexAttribP4uiv", ogl.} - proc glProgramUniform2ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glProgramUniform2ivEXT", ogl.} - proc glVertexStream4dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glVertexStream4dATI", ogl.} - proc glVertexAttribL2ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc: "glVertexAttribL2ui64NV", ogl.} - proc glSecondaryColor3bEXT(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc: "glSecondaryColor3bEXT", ogl.} - proc glGetBufferPointervOES(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc: "glGetBufferPointervOES", ogl.} - proc glGetMaterialfv(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetMaterialfv", ogl.} - proc glVertexStream3sATI(stream: TGLenum, x: TGLshort, y: TGLshort, z: TGLshort) {.importc: "glVertexStream3sATI", ogl.} - proc glUniform1i(location: TGLint, v0: TGLint) {.importc: "glUniform1i", ogl.} - proc glVertexAttribL2d(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc: "glVertexAttribL2d", ogl.} - proc glTestObjectAPPLE(`object`: TGLenum, name: TGLuint): TGLboolean {.importc: "glTestObjectAPPLE", ogl.} - proc glGetTransformFeedbackVarying(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLsizei, `type`: TGLenum, name: TGLchar) {.importc: "glGetTransformFeedbackVarying", ogl.} - proc glFramebufferRenderbufferOES(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc: "glFramebufferRenderbufferOES", ogl.} - proc glVertexStream3iATI(stream: TGLenum, x: TGLint, y: TGLint, z: TGLint) {.importc: "glVertexStream3iATI", ogl.} - proc glMakeTextureHandleNonResidentNV(handle: TGLuint64) {.importc: "glMakeTextureHandleNonResidentNV", ogl.} - proc glVertexAttrib4fvNV(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib4fvNV", ogl.} - proc glArrayElement(i: TGLint) {.importc: "glArrayElement", ogl.} - proc glClearBufferData(target: TGLenum, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, data: pointer) {.importc: "glClearBufferData", ogl.} - proc glSecondaryColor3usEXT(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc: "glSecondaryColor3usEXT", ogl.} - proc glRenderbufferStorageMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glRenderbufferStorageMultisample", ogl.} - proc glTexCoord2xvOES(coords: TGLfixed) {.importc: "glTexCoord2xvOES", ogl.} - proc glWindowPos3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glWindowPos3f", ogl.} - proc glTangent3svEXT(v: TGLshort) {.importc: "glTangent3svEXT", ogl.} - proc glPointParameterf(pname: TGLenum, param: TGLfloat) {.importc: "glPointParameterf", ogl.} - proc glVertexAttribI4uivEXT(index: TGLuint, v: TGLuint) {.importc: "glVertexAttribI4uivEXT", ogl.} - proc glColorTableParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glColorTableParameteriv", ogl.} - proc glMatrixMultdEXT(mode: TGLenum, m: TGLdouble) {.importc: "glMatrixMultdEXT", ogl.} - proc glUseProgramStages(pipeline: TGLuint, stages: TGLbitfield, program: TGLuint) {.importc: "glUseProgramStages", ogl.} - proc glVertexStream4sATI(stream: TGLenum, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc: "glVertexStream4sATI", ogl.} - proc glDrawElementsInstancedNV(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc: "glDrawElementsInstancedNV", ogl.} - proc glUniform3d(location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glUniform3d", ogl.} - proc glDebugMessageControlARB(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc: "glDebugMessageControlARB", ogl.} - proc glVertexAttribs3svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc: "glVertexAttribs3svNV", ogl.} - proc glElementPointerATI(`type`: TGLenum, `pointer`: pointer) {.importc: "glElementPointerATI", ogl.} - proc glColor4fNormal3fVertex3fvSUN(c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc: "glColor4fNormal3fVertex3fvSUN", ogl.} - proc glGetPerfMonitorCountersAMD(group: TGLuint, numCounters: TGLint, maxActiveCounters: TGLint, counterSize: TGLsizei, counters: TGLuint) {.importc: "glGetPerfMonitorCountersAMD", ogl.} - proc glDispatchCompute(num_groups_x: TGLuint, num_groups_y: TGLuint, num_groups_z: TGLuint) {.importc: "glDispatchCompute", ogl.} - proc glVertexAttribDivisorNV(index: TGLuint, divisor: TGLuint) {.importc: "glVertexAttribDivisorNV", ogl.} - proc glProgramUniform3uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc: "glProgramUniform3uiEXT", ogl.} - proc glRenderbufferStorageMultisampleNV(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glRenderbufferStorageMultisampleNV", ogl.} - proc glBinormalPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glBinormalPointerEXT", ogl.} - proc glRectxvOES(v1: TGLfixed, v2: TGLfixed) {.importc: "glRectxvOES", ogl.} - proc glGenVertexArraysOES(n: TGLsizei, arrays: TGLuint) {.importc: "glGenVertexArraysOES", ogl.} - proc glDebugMessageControlKHR(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc: "glDebugMessageControlKHR", ogl.} - proc glProgramUniform1uiEXT(program: TGLuint, location: TGLint, v0: TGLuint) {.importc: "glProgramUniform1uiEXT", ogl.} - proc glPixelTransferi(pname: TGLenum, param: TGLint) {.importc: "glPixelTransferi", ogl.} - proc glIsPointInFillPathNV(path: TGLuint, mask: TGLuint, x: TGLfloat, y: TGLfloat): TGLboolean {.importc: "glIsPointInFillPathNV", ogl.} - proc glVertexBindingDivisor(bindingindex: TGLuint, divisor: TGLuint) {.importc: "glVertexBindingDivisor", ogl.} - proc glGetVertexAttribLui64vARB(index: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc: "glGetVertexAttribLui64vARB", ogl.} - proc glProgramUniformMatrix3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix3dvEXT", ogl.} - proc glDrawBuffer(mode: TGLenum) {.importc: "glDrawBuffer", ogl.} - proc glMultiTexCoord1sARB(target: TGLenum, s: TGLshort) {.importc: "glMultiTexCoord1sARB", ogl.} - proc glSeparableFilter2DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer) {.importc: "glSeparableFilter2DEXT", ogl.} - proc glTangent3bvEXT(v: TGLbyte) {.importc: "glTangent3bvEXT", ogl.} - proc glTexParameterIuiv(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc: "glTexParameterIuiv", ogl.} - proc glVertexAttribL4i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc: "glVertexAttribL4i64NV", ogl.} - proc glDebugMessageCallbackARB(callback: TGLDEBUGPROCARB, userParam: pointer) {.importc: "glDebugMessageCallbackARB", ogl.} - proc glMultiTexCoordP1uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc: "glMultiTexCoordP1uiv", ogl.} - proc glLabelObjectEXT(`type`: TGLenum, `object`: TGLuint, length: TGLsizei, label: TGLchar) {.importc: "glLabelObjectEXT", ogl.} - proc glGetnPolygonStippleARB(bufSize: TGLsizei, pattern: TGLubyte) {.importc: "glGetnPolygonStippleARB", ogl.} - proc glTexCoord3xOES(s: TGLfixed, t: TGLfixed, r: TGLfixed) {.importc: "glTexCoord3xOES", ogl.} - proc glCopyPixels(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, `type`: TGLenum) {.importc: "glCopyPixels", ogl.} - proc glGetnUniformfvEXT(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLfloat) {.importc: "glGetnUniformfvEXT", ogl.} - proc glColorMaski(index: TGLuint, r: TGLboolean, g: TGLboolean, b: TGLboolean, a: TGLboolean) {.importc: "glColorMaski", ogl.} - proc glRasterPos2fv(v: TGLfloat) {.importc: "glRasterPos2fv", ogl.} - proc glBindBuffersBase(target: TGLenum, first: TGLuint, count: TGLsizei, buffers: TGLuint) {.importc: "glBindBuffersBase", ogl.} - proc glSpriteParameterfvSGIX(pname: TGLenum, params: TGLfloat) {.importc: "glSpriteParameterfvSGIX", ogl.} - proc glGetSyncivAPPLE(sync: TGLsync, pname: TGLenum, bufSize: TGLsizei, length: TGLsizei, values: TGLint) {.importc: "glGetSyncivAPPLE", ogl.} - proc glVertexAttribI3i(index: TGLuint, x: TGLint, y: TGLint, z: TGLint) {.importc: "glVertexAttribI3i", ogl.} - proc glPixelTransformParameteriEXT(target: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glPixelTransformParameteriEXT", ogl.} - proc glMultiDrawArraysEXT(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc: "glMultiDrawArraysEXT", ogl.} - proc glGetTextureHandleNV(texture: TGLuint): TGLuint64 {.importc: "glGetTextureHandleNV", ogl.} - proc glTexCoordP2ui(`type`: TGLenum, coords: TGLuint) {.importc: "glTexCoordP2ui", ogl.} - proc glDeleteQueries(n: TGLsizei, ids: TGLuint) {.importc: "glDeleteQueries", ogl.} - proc glGetVertexAttribArrayObjectivATI(index: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetVertexAttribArrayObjectivATI", ogl.} - proc glVertexArrayVertexBindingDivisorEXT(vaobj: TGLuint, bindingindex: TGLuint, divisor: TGLuint) {.importc: "glVertexArrayVertexBindingDivisorEXT", ogl.} - proc glVertex3i(x: TGLint, y: TGLint, z: TGLint) {.importc: "glVertex3i", ogl.} - proc glBlendEquationSeparatei(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc: "glBlendEquationSeparatei", ogl.} - proc glGetMapAttribParameterivNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetMapAttribParameterivNV", ogl.} - proc glGetVideoCaptureivNV(video_capture_slot: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetVideoCaptureivNV", ogl.} - proc glFragmentMaterialfvSGIX(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glFragmentMaterialfvSGIX", ogl.} - proc glEGLImageTargetTexture2DOES(target: TGLenum, image: TGLeglImageOES) {.importc: "glEGLImageTargetTexture2DOES", ogl.} - proc glCopyImageSubDataNV(srcName: TGLuint, srcTarget: TGLenum, srcLevel: TGLint, srcX: TGLint, srcY: TGLint, srcZ: TGLint, dstName: TGLuint, dstTarget: TGLenum, dstLevel: TGLint, dstX: TGLint, dstY: TGLint, dstZ: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc: "glCopyImageSubDataNV", ogl.} - proc glUniform2i(location: TGLint, v0: TGLint, v1: TGLint) {.importc: "glUniform2i", ogl.} - proc glVertexAttrib3fvNV(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib3fvNV", ogl.} - proc glNamedBufferStorageEXT(buffer: TGLuint, size: TGLsizeiptr, data: pointer, flags: TGLbitfield) {.importc: "glNamedBufferStorageEXT", ogl.} - proc glProgramEnvParameterI4uivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc: "glProgramEnvParameterI4uivNV", ogl.} - proc glGetVertexAttribdvARB(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc: "glGetVertexAttribdvARB", ogl.} - proc glVertexAttribL3ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc: "glVertexAttribL3ui64vNV", ogl.} - proc glUniform4fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glUniform4fvARB", ogl.} - proc glWeightsvARB(size: TGLint, weights: TGLshort) {.importc: "glWeightsvARB", ogl.} - proc glMakeTextureHandleNonResidentARB(handle: TGLuint64) {.importc: "glMakeTextureHandleNonResidentARB", ogl.} - proc glEvalCoord1xOES(u: TGLfixed) {.importc: "glEvalCoord1xOES", ogl.} - proc glVertexAttrib2sv(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib2sv", ogl.} - proc glVertexAttrib4dvNV(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib4dvNV", ogl.} - proc glProgramNamedParameter4fNV(id: TGLuint, len: TGLsizei, name: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glProgramNamedParameter4fNV", ogl.} - proc glCompileShaderARB(shaderObj: TGLhandleARB) {.importc: "glCompileShaderARB", ogl.} - proc glProgramEnvParameter4fvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc: "glProgramEnvParameter4fvARB", ogl.} - proc glGetVertexAttribiv(index: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetVertexAttribiv", ogl.} - proc glEvalPoint1(i: TGLint) {.importc: "glEvalPoint1", ogl.} - proc glEvalMapsNV(target: TGLenum, mode: TGLenum) {.importc: "glEvalMapsNV", ogl.} - proc glGetTexGenxvOES(coord: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetTexGenxvOES", ogl.} - proc glBlendEquationSeparate(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc: "glBlendEquationSeparate", ogl.} - proc glGetColorTableParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetColorTableParameterfv", ogl.} - proc glQueryCounterEXT(id: TGLuint, target: TGLenum) {.importc: "glQueryCounterEXT", ogl.} - proc glExtGetProgramBinarySourceQCOM(program: TGLuint, shadertype: TGLenum, source: TGLchar, length: TGLint) {.importc: "glExtGetProgramBinarySourceQCOM", ogl.} - proc glGetConvolutionParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetConvolutionParameteriv", ogl.} - proc glIsProgramPipeline(pipeline: TGLuint): TGLboolean {.importc: "glIsProgramPipeline", ogl.} - proc glVertexWeightfvEXT(weight: TGLfloat) {.importc: "glVertexWeightfvEXT", ogl.} - proc glDisableDriverControlQCOM(driverControl: TGLuint) {.importc: "glDisableDriverControlQCOM", ogl.} - proc glVertexStream1fvATI(stream: TGLenum, coords: TGLfloat) {.importc: "glVertexStream1fvATI", ogl.} - proc glMakeTextureHandleResidentNV(handle: TGLuint64) {.importc: "glMakeTextureHandleResidentNV", ogl.} - proc glSamplerParameteriv(sampler: TGLuint, pname: TGLenum, param: TGLint) {.importc: "glSamplerParameteriv", ogl.} - proc glTexEnvxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glTexEnvxOES", ogl.} - proc glEndOcclusionQueryNV() {.importc: "glEndOcclusionQueryNV", ogl.} - proc glFlushMappedBufferRangeAPPLE(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr) {.importc: "glFlushMappedBufferRangeAPPLE", ogl.} - proc glVertex4iv(v: TGLint) {.importc: "glVertex4iv", ogl.} - proc glVertexArrayVertexAttribIFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc: "glVertexArrayVertexAttribIFormatEXT", ogl.} - proc glDisableIndexedEXT(target: TGLenum, index: TGLuint) {.importc: "glDisableIndexedEXT", ogl.} - proc glVertexAttribL1dEXT(index: TGLuint, x: TGLdouble) {.importc: "glVertexAttribL1dEXT", ogl.} - proc glBeginPerfMonitorAMD(monitor: TGLuint) {.importc: "glBeginPerfMonitorAMD", ogl.} - proc glConvolutionFilter1DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc: "glConvolutionFilter1DEXT", ogl.} - proc glPrimitiveRestartIndex(index: TGLuint) {.importc: "glPrimitiveRestartIndex", ogl.} - proc glWindowPos2dv(v: TGLdouble) {.importc: "glWindowPos2dv", ogl.} - proc glBindFramebufferOES(target: TGLenum, framebuffer: TGLuint) {.importc: "glBindFramebufferOES", ogl.} - proc glTessellationModeAMD(mode: TGLenum) {.importc: "glTessellationModeAMD", ogl.} - proc glIsVariantEnabledEXT(id: TGLuint, cap: TGLenum): TGLboolean {.importc: "glIsVariantEnabledEXT", ogl.} - proc glColor3iv(v: TGLint) {.importc: "glColor3iv", ogl.} - proc glFogCoordFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc: "glFogCoordFormatNV", ogl.} - proc glClearNamedBufferDataEXT(buffer: TGLuint, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, data: pointer) {.importc: "glClearNamedBufferDataEXT", ogl.} - proc glTextureRangeAPPLE(target: TGLenum, length: TGLsizei, `pointer`: pointer) {.importc: "glTextureRangeAPPLE", ogl.} - proc glTexCoord4bvOES(coords: TGLbyte) {.importc: "glTexCoord4bvOES", ogl.} - proc glRotated(angle: TGLdouble, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glRotated", ogl.} - proc glAccum(op: TGLenum, value: TGLfloat) {.importc: "glAccum", ogl.} - proc glVertex3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glVertex3d", ogl.} - proc glGetPathMetricRangeNV(metricQueryMask: TGLbitfield, firstPathName: TGLuint, numPaths: TGLsizei, stride: TGLsizei, metrics: TGLfloat) {.importc: "glGetPathMetricRangeNV", ogl.} - proc glUniform4d(location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glUniform4d", ogl.} - proc glTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTextureSubImage2DEXT", ogl.} - proc glMultiTexCoord1iv(target: TGLenum, v: TGLint) {.importc: "glMultiTexCoord1iv", ogl.} - proc glFogFuncSGIS(n: TGLsizei, points: TGLfloat) {.importc: "glFogFuncSGIS", ogl.} - proc glGetMaterialxOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glGetMaterialxOES", ogl.} - proc glGlobalAlphaFactorbSUN(factor: TGLbyte) {.importc: "glGlobalAlphaFactorbSUN", ogl.} - proc glGetProgramLocalParameterdvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc: "glGetProgramLocalParameterdvARB", ogl.} - proc glDeleteProgramsARB(n: TGLsizei, programs: TGLuint) {.importc: "glDeleteProgramsARB", ogl.} - proc glVertexStream1sATI(stream: TGLenum, x: TGLshort) {.importc: "glVertexStream1sATI", ogl.} - proc glMatrixTranslatedEXT(mode: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glMatrixTranslatedEXT", ogl.} - proc glTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexSubImage1D", ogl.} - proc glGetBufferSubData(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc: "glGetBufferSubData", ogl.} - proc glUniform4uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc: "glUniform4uiEXT", ogl.} - proc glGetShaderiv(shader: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetShaderiv", ogl.} - proc glGetQueryIndexediv(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetQueryIndexediv", ogl.} - proc glDebugMessageInsert(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: TGLchar) {.importc: "glDebugMessageInsert", ogl.} - proc glVertexAttribs2dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc: "glVertexAttribs2dvNV", ogl.} - proc glGetFixedvOES(pname: TGLenum, params: TGLfixed) {.importc: "glGetFixedvOES", ogl.} - proc glUniform2iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glUniform2iv", ogl.} - proc glTextureView(texture: TGLuint, target: TGLenum, origtexture: TGLuint, internalformat: TGLenum, minlevel: TGLuint, numlevels: TGLuint, minlayer: TGLuint, numlayers: TGLuint) {.importc: "glTextureView", ogl.} - proc glMultiTexCoord1xvOES(texture: TGLenum, coords: TGLfixed) {.importc: "glMultiTexCoord1xvOES", ogl.} - proc glTexBufferRange(target: TGLenum, internalformat: TGLenum, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc: "glTexBufferRange", ogl.} - proc glMultiTexCoordPointerEXT(texunit: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glMultiTexCoordPointerEXT", ogl.} - proc glBlendColorxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc: "glBlendColorxOES", ogl.} - proc glReadPixels(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glReadPixels", ogl.} - proc glWindowPos3dARB(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glWindowPos3dARB", ogl.} - proc glPixelTexGenParameterivSGIS(pname: TGLenum, params: TGLint) {.importc: "glPixelTexGenParameterivSGIS", ogl.} - proc glSecondaryColor3svEXT(v: TGLshort) {.importc: "glSecondaryColor3svEXT", ogl.} - proc glPopGroupMarkerEXT() {.importc: "glPopGroupMarkerEXT", ogl.} - proc glImportSyncEXT(external_sync_type: TGLenum, external_sync: TGLintptr, flags: TGLbitfield): TGLsync {.importc: "glImportSyncEXT", ogl.} - proc glVertexAttribLFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc: "glVertexAttribLFormatNV", ogl.} - proc glVertexAttrib2sNV(index: TGLuint, x: TGLshort, y: TGLshort) {.importc: "glVertexAttrib2sNV", ogl.} - proc glGetIntegeri_v(target: TGLenum, index: TGLuint, data: TGLint) {.importc: "glGetIntegeri_v", ogl.} - proc glProgramUniform3uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glProgramUniform3uiv", ogl.} - proc glGetActiveUniformBlockiv(program: TGLuint, uniformBlockIndex: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetActiveUniformBlockiv", ogl.} - proc glCreateShaderProgramv(`type`: TGLenum, count: TGLsizei, strings: ptr TGLchar): TGLuint {.importc: "glCreateShaderProgramv", ogl.} - proc glUniform2fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc: "glUniform2fARB", ogl.} - proc glVertexStream4ivATI(stream: TGLenum, coords: TGLint) {.importc: "glVertexStream4ivATI", ogl.} - proc glNormalP3uiv(`type`: TGLenum, coords: TGLuint) {.importc: "glNormalP3uiv", ogl.} - proc glVertexAttribLFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc: "glVertexAttribLFormat", ogl.} - proc glTexCoord2bvOES(coords: TGLbyte) {.importc: "glTexCoord2bvOES", ogl.} - proc glGetActiveUniformName(program: TGLuint, uniformIndex: TGLuint, bufSize: TGLsizei, length: TGLsizei, uniformName: TGLchar) {.importc: "glGetActiveUniformName", ogl.} - proc glTexCoord2sv(v: TGLshort) {.importc: "glTexCoord2sv", ogl.} - proc glVertexAttrib2dNV(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc: "glVertexAttrib2dNV", ogl.} - proc glGetFogFuncSGIS(points: TGLfloat) {.importc: "glGetFogFuncSGIS", ogl.} - proc glSetFenceAPPLE(fence: TGLuint) {.importc: "glSetFenceAPPLE", ogl.} - proc glRasterPos2f(x: TGLfloat, y: TGLfloat) {.importc: "glRasterPos2f", ogl.} - proc glVertexWeightPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glVertexWeightPointerEXT", ogl.} - proc glEndList() {.importc: "glEndList", ogl.} - proc glVDPAUFiniNV() {.importc: "glVDPAUFiniNV", ogl.} - proc glTbufferMask3DFX(mask: TGLuint) {.importc: "glTbufferMask3DFX", ogl.} - proc glVertexP4ui(`type`: TGLenum, value: TGLuint) {.importc: "glVertexP4ui", ogl.} - proc glTexEnviv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glTexEnviv", ogl.} - proc glColor4xOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc: "glColor4xOES", ogl.} - proc glBlendEquationi(buf: TGLuint, mode: TGLenum) {.importc: "glBlendEquationi", ogl.} - proc glLoadMatrixxOES(m: TGLfixed) {.importc: "glLoadMatrixxOES", ogl.} - proc glFogxOES(pname: TGLenum, param: TGLfixed) {.importc: "glFogxOES", ogl.} - proc glTexCoord4dv(v: TGLdouble) {.importc: "glTexCoord4dv", ogl.} - proc glFogCoordPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc: "glFogCoordPointerListIBM", ogl.} - proc glGetPerfMonitorGroupsAMD(numGroups: TGLint, groupsSize: TGLsizei, groups: TGLuint) {.importc: "glGetPerfMonitorGroupsAMD", ogl.} - proc glVertex2hNV(x: TGLhalfNV, y: TGLhalfNV) {.importc: "glVertex2hNV", ogl.} - proc glDeleteFragmentShaderATI(id: TGLuint) {.importc: "glDeleteFragmentShaderATI", ogl.} - proc glGetSamplerParameterIiv(sampler: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetSamplerParameterIiv", ogl.} - proc glUniform2fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glUniform2fvARB", ogl.} - proc glFogf(pname: TGLenum, param: TGLfloat) {.importc: "glFogf", ogl.} - proc glMultiTexCoord1iARB(target: TGLenum, s: TGLint) {.importc: "glMultiTexCoord1iARB", ogl.} - proc glGetActiveUniformARB(programObj: TGLhandleARB, index: TGLuint, maxLength: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLcharARB) {.importc: "glGetActiveUniformARB", ogl.} - proc glMapGrid1xOES(n: TGLint, u1: TGLfixed, u2: TGLfixed) {.importc: "glMapGrid1xOES", ogl.} - proc glIndexsv(c: TGLshort) {.importc: "glIndexsv", ogl.} - proc glFragmentMaterialfSGIX(face: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glFragmentMaterialfSGIX", ogl.} - proc glBindTextureEXT(target: TGLenum, texture: TGLuint) {.importc: "glBindTextureEXT", ogl.} - proc glRectiv(v1: TGLint, v2: TGLint) {.importc: "glRectiv", ogl.} - proc glTangent3dEXT(tx: TGLdouble, ty: TGLdouble, tz: TGLdouble) {.importc: "glTangent3dEXT", ogl.} - proc glProgramUniformMatrix3x4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix3x4fvEXT", ogl.} - proc glNormal3hNV(nx: TGLhalfNV, ny: TGLhalfNV, nz: TGLhalfNV) {.importc: "glNormal3hNV", ogl.} - proc glPushClientAttribDefaultEXT(mask: TGLbitfield) {.importc: "glPushClientAttribDefaultEXT", ogl.} - proc glUnmapBufferARB(target: TGLenum): TGLboolean {.importc: "glUnmapBufferARB", ogl.} - proc glVertexAttribs1dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc: "glVertexAttribs1dvNV", ogl.} - proc glUniformMatrix2x3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glUniformMatrix2x3dv", ogl.} - proc glUniform3f(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc: "glUniform3f", ogl.} - proc glTexEnvxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glTexEnvxv", ogl.} - proc glMapBufferOES(target: TGLenum, access: TGLenum) {.importc: "glMapBufferOES", ogl.} - proc glBufferData(target: TGLenum, size: TGLsizeiptr, data: pointer, usage: TGLenum) {.importc: "glBufferData", ogl.} - proc glDrawElementsInstancedANGLE(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc: "glDrawElementsInstancedANGLE", ogl.} - proc glGetTextureHandleARB(texture: TGLuint): TGLuint64 {.importc: "glGetTextureHandleARB", ogl.} - proc glNormal3f(nx: TGLfloat, ny: TGLfloat, nz: TGLfloat) {.importc: "glNormal3f", ogl.} - proc glTexCoordP3uiv(`type`: TGLenum, coords: TGLuint) {.importc: "glTexCoordP3uiv", ogl.} - proc glTexParameterx(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glTexParameterx", ogl.} - proc glMapBufferRange(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc: "glMapBufferRange", ogl.} - proc glTexCoord2fVertex3fSUN(s: TGLfloat, t: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glTexCoord2fVertex3fSUN", ogl.} - proc glVariantArrayObjectATI(id: TGLuint, `type`: TGLenum, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc: "glVariantArrayObjectATI", ogl.} - proc glGetnHistogramARB(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, values: pointer) {.importc: "glGetnHistogramARB", ogl.} - proc glWindowPos3sv(v: TGLshort) {.importc: "glWindowPos3sv", ogl.} - proc glGetVariantPointervEXT(id: TGLuint, value: TGLenum, data: ptr pointer) {.importc: "glGetVariantPointervEXT", ogl.} - proc glGetLightfv(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetLightfv", ogl.} - proc glGetnTexImageARB(target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, img: pointer) {.importc: "glGetnTexImageARB", ogl.} - proc glGenRenderbuffersEXT(n: TGLsizei, renderbuffers: TGLuint) {.importc: "glGenRenderbuffersEXT", ogl.} - proc glMultiDrawArraysIndirectBindlessNV(mode: TGLenum, indirect: pointer, drawCount: TGLsizei, stride: TGLsizei, vertexBufferCount: TGLint) {.importc: "glMultiDrawArraysIndirectBindlessNV", ogl.} - proc glDisableClientStateIndexedEXT(`array`: TGLenum, index: TGLuint) {.importc: "glDisableClientStateIndexedEXT", ogl.} - proc glMapGrid1f(un: TGLint, u1: TGLfloat, u2: TGLfloat) {.importc: "glMapGrid1f", ogl.} - proc glTexStorage2D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glTexStorage2D", ogl.} - proc glShaderStorageBlockBinding(program: TGLuint, storageBlockIndex: TGLuint, storageBlockBinding: TGLuint) {.importc: "glShaderStorageBlockBinding", ogl.} - proc glBlendBarrierNV() {.importc: "glBlendBarrierNV", ogl.} - proc glGetVideoui64vNV(video_slot: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc: "glGetVideoui64vNV", ogl.} - proc glUniform3ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc: "glUniform3ui64NV", ogl.} - proc glUniform4ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glUniform4ivARB", ogl.} - proc glGetQueryObjectivARB(id: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetQueryObjectivARB", ogl.} - proc glCompressedTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexSubImage3DOES", ogl.} - proc glEnableIndexedEXT(target: TGLenum, index: TGLuint) {.importc: "glEnableIndexedEXT", ogl.} - proc glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: TGLuint, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glNamedRenderbufferStorageMultisampleCoverageEXT", ogl.} - proc glVertexAttribI3iEXT(index: TGLuint, x: TGLint, y: TGLint, z: TGLint) {.importc: "glVertexAttribI3iEXT", ogl.} - proc glUniform4uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glUniform4uivEXT", ogl.} - proc glGetUniformLocation(program: TGLuint, name: TGLchar): TGLint {.importc: "glGetUniformLocation", ogl.} - proc glCurrentPaletteMatrixARB(index: TGLint) {.importc: "glCurrentPaletteMatrixARB", ogl.} - proc glVertexAttribLPointerEXT(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glVertexAttribLPointerEXT", ogl.} - proc glFogCoorddvEXT(coord: TGLdouble) {.importc: "glFogCoorddvEXT", ogl.} - proc glInitNames() {.importc: "glInitNames", ogl.} - proc glGetPathSpacingNV(pathListMode: TGLenum, numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, advanceScale: TGLfloat, kerningScale: TGLfloat, transformType: TGLenum, returnedSpacing: TGLfloat) {.importc: "glGetPathSpacingNV", ogl.} - proc glNormal3fVertex3fvSUN(n: TGLfloat, v: TGLfloat) {.importc: "glNormal3fVertex3fvSUN", ogl.} - proc glTexCoord2iv(v: TGLint) {.importc: "glTexCoord2iv", ogl.} - proc glWindowPos3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc: "glWindowPos3s", ogl.} - proc glProgramUniformMatrix3x4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix3x4fv", ogl.} - proc glVertexAttribP4ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc: "glVertexAttribP4ui", ogl.} - proc glVertexAttribs4ubvNV(index: TGLuint, count: TGLsizei, v: TGLubyte) {.importc: "glVertexAttribs4ubvNV", ogl.} - proc glProgramLocalParameterI4iNV(target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc: "glProgramLocalParameterI4iNV", ogl.} - proc glStencilMaskSeparate(face: TGLenum, mask: TGLuint) {.importc: "glStencilMaskSeparate", ogl.} - proc glClientWaitSync(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64): TGLenum {.importc: "glClientWaitSync", ogl.} - proc glPolygonOffsetx(factor: TGLfixed, units: TGLfixed) {.importc: "glPolygonOffsetx", ogl.} - proc glCreateProgramObjectARB(): TGLhandleARB {.importc: "glCreateProgramObjectARB", ogl.} - proc glClearColorIuiEXT(red: TGLuint, green: TGLuint, blue: TGLuint, alpha: TGLuint) {.importc: "glClearColorIuiEXT", ogl.} - proc glDeleteTransformFeedbacksNV(n: TGLsizei, ids: TGLuint) {.importc: "glDeleteTransformFeedbacksNV", ogl.} - proc glFramebufferDrawBuffersEXT(framebuffer: TGLuint, n: TGLsizei, bufs: TGLenum) {.importc: "glFramebufferDrawBuffersEXT", ogl.} - proc glAreTexturesResident(n: TGLsizei, textures: TGLuint, residences: TGLboolean): TGLboolean {.importc: "glAreTexturesResident", ogl.} - proc glNamedBufferDataEXT(buffer: TGLuint, size: TGLsizeiptr, data: pointer, usage: TGLenum) {.importc: "glNamedBufferDataEXT", ogl.} - proc glGetInvariantFloatvEXT(id: TGLuint, value: TGLenum, data: TGLfloat) {.importc: "glGetInvariantFloatvEXT", ogl.} - proc glMultiTexCoord4d(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc: "glMultiTexCoord4d", ogl.} - proc glGetPixelTransformParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetPixelTransformParameterfvEXT", ogl.} - proc glGetStringi(name: TGLenum, index: TGLuint): TGLubyte {.importc: "glGetStringi", ogl.} - proc glMakeBufferNonResidentNV(target: TGLenum) {.importc: "glMakeBufferNonResidentNV", ogl.} - proc glVertex4bOES(x: TGLbyte, y: TGLbyte, z: TGLbyte) {.importc: "glVertex4bOES", ogl.} - proc glGetObjectLabel(identifier: TGLenum, name: TGLuint, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc: "glGetObjectLabel", ogl.} - proc glClipPlanexOES(plane: TGLenum, equation: TGLfixed) {.importc: "glClipPlanexOES", ogl.} - proc glElementPointerAPPLE(`type`: TGLenum, `pointer`: pointer) {.importc: "glElementPointerAPPLE", ogl.} - proc glIsAsyncMarkerSGIX(marker: TGLuint): TGLboolean {.importc: "glIsAsyncMarkerSGIX", ogl.} - proc glUseShaderProgramEXT(`type`: TGLenum, program: TGLuint) {.importc: "glUseShaderProgramEXT", ogl.} - proc glReplacementCodeuiColor4ubVertex3fSUN(rc: TGLuint, r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glReplacementCodeuiColor4ubVertex3fSUN", ogl.} - proc glIsTransformFeedback(id: TGLuint): TGLboolean {.importc: "glIsTransformFeedback", ogl.} - proc glEdgeFlag(flag: TGLboolean) {.importc: "glEdgeFlag", ogl.} - proc glGetTexGeniv(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetTexGeniv", ogl.} - proc glBeginQueryEXT(target: TGLenum, id: TGLuint) {.importc: "glBeginQueryEXT", ogl.} - proc glUniform1uiEXT(location: TGLint, v0: TGLuint) {.importc: "glUniform1uiEXT", ogl.} - proc glProgramUniform3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glProgramUniform3fvEXT", ogl.} - proc glGetVideoi64vNV(video_slot: TGLuint, pname: TGLenum, params: TGLint64EXT) {.importc: "glGetVideoi64vNV", ogl.} - proc glProgramUniform3ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc: "glProgramUniform3ui", ogl.} - proc glSecondaryColor3uiEXT(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc: "glSecondaryColor3uiEXT", ogl.} - proc glPathStencilFuncNV(func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc: "glPathStencilFuncNV", ogl.} - proc glVertexAttribP1ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc: "glVertexAttribP1ui", ogl.} - proc glStencilFillPathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, fillMode: TGLenum, mask: TGLuint, transformType: TGLenum, transformValues: TGLfloat) {.importc: "glStencilFillPathInstancedNV", ogl.} - proc glFogCoordfEXT(coord: TGLfloat) {.importc: "glFogCoordfEXT", ogl.} - proc glTextureParameterIuivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc: "glTextureParameterIuivEXT", ogl.} - proc glProgramUniform4dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glProgramUniform4dEXT", ogl.} - proc glFramebufferTextureFaceARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc: "glFramebufferTextureFaceARB", ogl.} - proc glTexCoord3s(s: TGLshort, t: TGLshort, r: TGLshort) {.importc: "glTexCoord3s", ogl.} - proc glGetFramebufferAttachmentParameteriv(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetFramebufferAttachmentParameteriv", ogl.} - proc glEndVideoCaptureNV(video_capture_slot: TGLuint) {.importc: "glEndVideoCaptureNV", ogl.} - proc glProgramUniformMatrix2x4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix2x4dv", ogl.} - proc glGetFloatIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLfloat) {.importc: "glGetFloatIndexedvEXT", ogl.} - proc glTexCoord1xOES(s: TGLfixed) {.importc: "glTexCoord1xOES", ogl.} - proc glTexCoord4f(s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc: "glTexCoord4f", ogl.} - proc glShaderSource(shader: TGLuint, count: TGLsizei, string: ptr TGLchar, length: TGLint) {.importc: "glShaderSource", ogl.} - proc glGetDetailTexFuncSGIS(target: TGLenum, points: TGLfloat) {.importc: "glGetDetailTexFuncSGIS", ogl.} - proc glResetHistogram(target: TGLenum) {.importc: "glResetHistogram", ogl.} - proc glVertexAttribP2ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc: "glVertexAttribP2ui", ogl.} - proc glDrawTransformFeedbackNV(mode: TGLenum, id: TGLuint) {.importc: "glDrawTransformFeedbackNV", ogl.} - proc glWindowPos2fMESA(x: TGLfloat, y: TGLfloat) {.importc: "glWindowPos2fMESA", ogl.} - proc glObjectLabelKHR(identifier: TGLenum, name: TGLuint, length: TGLsizei, label: TGLchar) {.importc: "glObjectLabelKHR", ogl.} - proc glMultiTexCoord2iARB(target: TGLenum, s: TGLint, t: TGLint) {.importc: "glMultiTexCoord2iARB", ogl.} - proc glVertexAttrib4usv(index: TGLuint, v: TGLushort) {.importc: "glVertexAttrib4usv", ogl.} - proc glGetGraphicsResetStatusARB(): TGLenum {.importc: "glGetGraphicsResetStatusARB", ogl.} - proc glProgramUniform3dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glProgramUniform3dEXT", ogl.} - proc glPathSubCommandsNV(path: TGLuint, commandStart: TGLsizei, commandsToDelete: TGLsizei, numCommands: TGLsizei, commands: TGLubyte, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc: "glPathSubCommandsNV", ogl.} - proc glEndTransformFeedbackNV() {.importc: "glEndTransformFeedbackNV", ogl.} - proc glWindowPos2sMESA(x: TGLshort, y: TGLshort) {.importc: "glWindowPos2sMESA", ogl.} - proc glTangent3sEXT(tx: TGLshort, ty: TGLshort, tz: TGLshort) {.importc: "glTangent3sEXT", ogl.} - proc glLineWidthx(width: TGLfixed) {.importc: "glLineWidthx", ogl.} - proc glGetUniformBufferSizeEXT(program: TGLuint, location: TGLint): TGLint {.importc: "glGetUniformBufferSizeEXT", ogl.} - proc glTexCoord2bOES(s: TGLbyte, t: TGLbyte) {.importc: "glTexCoord2bOES", ogl.} - proc glWindowPos3iMESA(x: TGLint, y: TGLint, z: TGLint) {.importc: "glWindowPos3iMESA", ogl.} - proc glTexGend(coord: TGLenum, pname: TGLenum, param: TGLdouble) {.importc: "glTexGend", ogl.} - proc glRenderbufferStorageMultisampleANGLE(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glRenderbufferStorageMultisampleANGLE", ogl.} - proc glGetProgramiv(program: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetProgramiv", ogl.} - proc glDrawTransformFeedbackStreamInstanced(mode: TGLenum, id: TGLuint, stream: TGLuint, instancecount: TGLsizei) {.importc: "glDrawTransformFeedbackStreamInstanced", ogl.} - proc glMatrixTranslatefEXT(mode: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glMatrixTranslatefEXT", ogl.} - proc glColor4iv(v: TGLint) {.importc: "glColor4iv", ogl.} - proc glSecondaryColor3ivEXT(v: TGLint) {.importc: "glSecondaryColor3ivEXT", ogl.} - proc glIsNamedStringARB(namelen: TGLint, name: TGLchar): TGLboolean {.importc: "glIsNamedStringARB", ogl.} - proc glVertexAttribL4dv(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttribL4dv", ogl.} - proc glEndTransformFeedback() {.importc: "glEndTransformFeedback", ogl.} - proc glVertexStream3fvATI(stream: TGLenum, coords: TGLfloat) {.importc: "glVertexStream3fvATI", ogl.} - proc glProgramUniformMatrix4x2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix4x2dv", ogl.} - proc glTextureBufferRangeEXT(texture: TGLuint, target: TGLenum, internalformat: TGLenum, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc: "glTextureBufferRangeEXT", ogl.} - proc glTexCoord2fNormal3fVertex3fvSUN(tc: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc: "glTexCoord2fNormal3fVertex3fvSUN", ogl.} - proc glProgramUniform2f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc: "glProgramUniform2f", ogl.} - proc glMultiTexCoord2sv(target: TGLenum, v: TGLshort) {.importc: "glMultiTexCoord2sv", ogl.} - proc glTexCoord3bOES(s: TGLbyte, t: TGLbyte, r: TGLbyte) {.importc: "glTexCoord3bOES", ogl.} - proc glGenFramebuffersOES(n: TGLsizei, framebuffers: TGLuint) {.importc: "glGenFramebuffersOES", ogl.} - proc glMultiTexCoord3sv(target: TGLenum, v: TGLshort) {.importc: "glMultiTexCoord3sv", ogl.} - proc glVertexAttrib4Nub(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc: "glVertexAttrib4Nub", ogl.} - proc glColor3d(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc: "glColor3d", ogl.} - proc glGetActiveAttrib(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLchar) {.importc: "glGetActiveAttrib", ogl.} - proc glConvolutionParameterfEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glConvolutionParameterfEXT", ogl.} - proc glTexSubImage2DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexSubImage2DEXT", ogl.} - proc glBinormal3fvEXT(v: TGLfloat) {.importc: "glBinormal3fvEXT", ogl.} - proc glDebugMessageControl(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc: "glDebugMessageControl", ogl.} - proc glProgramUniform3uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glProgramUniform3uivEXT", ogl.} - proc glPNTrianglesiATI(pname: TGLenum, param: TGLint) {.importc: "glPNTrianglesiATI", ogl.} - proc glGetPerfMonitorCounterInfoAMD(group: TGLuint, counter: TGLuint, pname: TGLenum, data: pointer) {.importc: "glGetPerfMonitorCounterInfoAMD", ogl.} - proc glVertexAttribL3ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc: "glVertexAttribL3ui64NV", ogl.} - proc glIsRenderbufferOES(renderbuffer: TGLuint): TGLboolean {.importc: "glIsRenderbufferOES", ogl.} - proc glColorSubTable(target: TGLenum, start: TGLsizei, count: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc: "glColorSubTable", ogl.} - proc glCompressedMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedMultiTexImage1DEXT", ogl.} - proc glBindSampler(unit: TGLuint, sampler: TGLuint) {.importc: "glBindSampler", ogl.} - proc glVariantubvEXT(id: TGLuint, `addr`: TGLubyte) {.importc: "glVariantubvEXT", ogl.} - proc glDisablei(target: TGLenum, index: TGLuint) {.importc: "glDisablei", ogl.} - proc glVertexAttribI2uiEXT(index: TGLuint, x: TGLuint, y: TGLuint) {.importc: "glVertexAttribI2uiEXT", ogl.} - proc glDrawElementArrayATI(mode: TGLenum, count: TGLsizei) {.importc: "glDrawElementArrayATI", ogl.} - proc glTagSampleBufferSGIX() {.importc: "glTagSampleBufferSGIX", ogl.} - proc glVertexPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc: "glVertexPointerEXT", ogl.} - proc glFragmentLightiSGIX(light: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glFragmentLightiSGIX", ogl.} - proc glLoadTransposeMatrixxOES(m: TGLfixed) {.importc: "glLoadTransposeMatrixxOES", ogl.} - proc glProgramLocalParameter4fvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc: "glProgramLocalParameter4fvARB", ogl.} - proc glGetVariantFloatvEXT(id: TGLuint, value: TGLenum, data: TGLfloat) {.importc: "glGetVariantFloatvEXT", ogl.} - proc glProgramUniform4ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc: "glProgramUniform4ui64vNV", ogl.} - proc glFragmentLightfSGIX(light: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glFragmentLightfSGIX", ogl.} - proc glIsVertexArrayAPPLE(`array`: TGLuint): TGLboolean {.importc: "glIsVertexArrayAPPLE", ogl.} - proc glTexCoord1bvOES(coords: TGLbyte) {.importc: "glTexCoord1bvOES", ogl.} - proc glUniform4fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glUniform4fv", ogl.} - proc glPixelDataRangeNV(target: TGLenum, length: TGLsizei, `pointer`: pointer) {.importc: "glPixelDataRangeNV", ogl.} - proc glUniformMatrix4x2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix4x2fv", ogl.} - proc glRectf(x1: TGLfloat, y1: TGLfloat, x2: TGLfloat, y2: TGLfloat) {.importc: "glRectf", ogl.} - proc glCoverageMaskNV(mask: TGLboolean) {.importc: "glCoverageMaskNV", ogl.} - proc glPointParameterfvSGIS(pname: TGLenum, params: TGLfloat) {.importc: "glPointParameterfvSGIS", ogl.} - proc glProgramUniformMatrix4x2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix4x2dvEXT", ogl.} - proc glFragmentLightModelfSGIX(pname: TGLenum, param: TGLfloat) {.importc: "glFragmentLightModelfSGIX", ogl.} - proc glDisableVertexAttribAPPLE(index: TGLuint, pname: TGLenum) {.importc: "glDisableVertexAttribAPPLE", ogl.} - proc glMultiTexCoord3dvARB(target: TGLenum, v: TGLdouble) {.importc: "glMultiTexCoord3dvARB", ogl.} - proc glTexCoord4iv(v: TGLint) {.importc: "glTexCoord4iv", ogl.} - proc glUniform1f(location: TGLint, v0: TGLfloat) {.importc: "glUniform1f", ogl.} - proc glVertexAttribParameteriAMD(index: TGLuint, pname: TGLenum, param: TGLint) {.importc: "glVertexAttribParameteriAMD", ogl.} - proc glGetConvolutionParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetConvolutionParameterfv", ogl.} - proc glRecti(x1: TGLint, y1: TGLint, x2: TGLint, y2: TGLint) {.importc: "glRecti", ogl.} - proc glTexEnvxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glTexEnvxvOES", ogl.} - proc glGetRenderbufferParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetRenderbufferParameteriv", ogl.} - proc glBlendFuncIndexedAMD(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc: "glBlendFuncIndexedAMD", ogl.} - proc glProgramUniformMatrix3x2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix3x2fv", ogl.} - proc glDrawArraysInstancedANGLE(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc: "glDrawArraysInstancedANGLE", ogl.} - proc glTextureBarrierNV() {.importc: "glTextureBarrierNV", ogl.} - proc glDrawBuffersIndexedEXT(n: TGLint, location: TGLenum, indices: TGLint) {.importc: "glDrawBuffersIndexedEXT", ogl.} - proc glUniformMatrix4fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix4fvARB", ogl.} - proc glInstrumentsBufferSGIX(size: TGLsizei, buffer: TGLint) {.importc: "glInstrumentsBufferSGIX", ogl.} - proc glAlphaFuncQCOM(func: TGLenum, `ref`: TGLclampf) {.importc: "glAlphaFuncQCOM", ogl.} - proc glUniformMatrix4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix4fv", ogl.} - proc glGetMinmaxParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetMinmaxParameteriv", ogl.} - proc glGetInvariantBooleanvEXT(id: TGLuint, value: TGLenum, data: TGLboolean) {.importc: "glGetInvariantBooleanvEXT", ogl.} - proc glVDPAUIsSurfaceNV(surface: TGLvdpauSurfaceNV) {.importc: "glVDPAUIsSurfaceNV", ogl.} - proc glGenProgramsARB(n: TGLsizei, programs: TGLuint) {.importc: "glGenProgramsARB", ogl.} - proc glDrawRangeElementArrayATI(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei) {.importc: "glDrawRangeElementArrayATI", ogl.} - proc glFramebufferRenderbufferEXT(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc: "glFramebufferRenderbufferEXT", ogl.} - proc glClearIndex(c: TGLfloat) {.importc: "glClearIndex", ogl.} - proc glDepthRangeIndexed(index: TGLuint, n: TGLdouble, f: TGLdouble) {.importc: "glDepthRangeIndexed", ogl.} - proc glDrawTexivOES(coords: TGLint) {.importc: "glDrawTexivOES", ogl.} - proc glTangent3iEXT(tx: TGLint, ty: TGLint, tz: TGLint) {.importc: "glTangent3iEXT", ogl.} - proc glStringMarkerGREMEDY(len: TGLsizei, string: pointer) {.importc: "glStringMarkerGREMEDY", ogl.} - proc glTexCoordP1ui(`type`: TGLenum, coords: TGLuint) {.importc: "glTexCoordP1ui", ogl.} - proc glOrthox(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc: "glOrthox", ogl.} - proc glReplacementCodeuiVertex3fvSUN(rc: TGLuint, v: TGLfloat) {.importc: "glReplacementCodeuiVertex3fvSUN", ogl.} - proc glMultiTexCoord1bvOES(texture: TGLenum, coords: TGLbyte) {.importc: "glMultiTexCoord1bvOES", ogl.} - proc glDrawArraysInstancedBaseInstance(mode: TGLenum, first: TGLint, count: TGLsizei, instancecount: TGLsizei, baseinstance: TGLuint) {.importc: "glDrawArraysInstancedBaseInstance", ogl.} - proc glMultMatrixf(m: TGLfloat) {.importc: "glMultMatrixf", ogl.} - proc glProgramUniform4i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc: "glProgramUniform4i", ogl.} - proc glScissorArrayv(first: TGLuint, count: TGLsizei, v: TGLint) {.importc: "glScissorArrayv", ogl.} - proc glGetnUniformivEXT(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLint) {.importc: "glGetnUniformivEXT", ogl.} - proc glGetTexEnvxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetTexEnvxvOES", ogl.} - proc glWindowPos3ivARB(v: TGLint) {.importc: "glWindowPos3ivARB", ogl.} - proc glProgramStringARB(target: TGLenum, format: TGLenum, len: TGLsizei, string: pointer) {.importc: "glProgramStringARB", ogl.} - proc glTextureColorMaskSGIS(red: TGLboolean, green: TGLboolean, blue: TGLboolean, alpha: TGLboolean) {.importc: "glTextureColorMaskSGIS", ogl.} - proc glMultiTexCoord4fv(target: TGLenum, v: TGLfloat) {.importc: "glMultiTexCoord4fv", ogl.} - proc glUniformMatrix4x3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix4x3fv", ogl.} - proc glIsPathNV(path: TGLuint): TGLboolean {.importc: "glIsPathNV", ogl.} - proc glStartTilingQCOM(x: TGLuint, y: TGLuint, width: TGLuint, height: TGLuint, preserveMask: TGLbitfield) {.importc: "glStartTilingQCOM", ogl.} - proc glVariantivEXT(id: TGLuint, `addr`: TGLint) {.importc: "glVariantivEXT", ogl.} - proc glGetnMinmaxARB(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, values: pointer) {.importc: "glGetnMinmaxARB", ogl.} - proc glTransformFeedbackVaryings(program: TGLuint, count: TGLsizei, varyings: ptr TGLchar, bufferMode: TGLenum) {.importc: "glTransformFeedbackVaryings", ogl.} - proc glShaderOp2EXT(op: TGLenum, res: TGLuint, arg1: TGLuint, arg2: TGLuint) {.importc: "glShaderOp2EXT", ogl.} - proc glVertexAttribPointer(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, `pointer`: pointer) {.importc: "glVertexAttribPointer", ogl.} - proc glMultiTexCoord4dvARB(target: TGLenum, v: TGLdouble) {.importc: "glMultiTexCoord4dvARB", ogl.} - proc glProgramUniform1ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT) {.importc: "glProgramUniform1ui64NV", ogl.} - proc glGetShaderSourceARB(obj: TGLhandleARB, maxLength: TGLsizei, length: TGLsizei, source: TGLcharARB) {.importc: "glGetShaderSourceARB", ogl.} - proc glGetBufferSubDataARB(target: TGLenum, offset: TGLintptrARB, size: TGLsizeiptrARB, data: pointer) {.importc: "glGetBufferSubDataARB", ogl.} - proc glCopyTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyTexSubImage2D", ogl.} - proc glProgramEnvParameterI4iNV(target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc: "glProgramEnvParameterI4iNV", ogl.} - proc glGetVertexAttribivARB(index: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetVertexAttribivARB", ogl.} - proc glGetFinalCombinerInputParameterivNV(variable: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetFinalCombinerInputParameterivNV", ogl.} - proc glIndexFuncEXT(func: TGLenum, `ref`: TGLclampf) {.importc: "glIndexFuncEXT", ogl.} - proc glProgramUniformMatrix3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix3dv", ogl.} - proc glTexStorage1DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc: "glTexStorage1DEXT", ogl.} - proc glUniformMatrix2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix2fv", ogl.} - proc glConvolutionParameterf(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glConvolutionParameterf", ogl.} - proc glGlobalAlphaFactordSUN(factor: TGLdouble) {.importc: "glGlobalAlphaFactordSUN", ogl.} - proc glCopyTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc: "glCopyTextureImage2DEXT", ogl.} - proc glVertex4xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc: "glVertex4xOES", ogl.} - proc glClearDepthx(depth: TGLfixed) {.importc: "glClearDepthx", ogl.} - proc glGetColorTableParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetColorTableParameteriv", ogl.} - proc glGenProgramPipelines(n: TGLsizei, pipelines: TGLuint) {.importc: "glGenProgramPipelines", ogl.} - proc glVertexAttribL4ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc: "glVertexAttribL4ui64vNV", ogl.} - proc glUniform1fARB(location: TGLint, v0: TGLfloat) {.importc: "glUniform1fARB", ogl.} - proc glUniformMatrix3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix3fv", ogl.} - proc glUniform3dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glUniform3dv", ogl.} - proc glVertexAttribI4iv(index: TGLuint, v: TGLint) {.importc: "glVertexAttribI4iv", ogl.} - proc glPixelZoom(xfactor: TGLfloat, yfactor: TGLfloat) {.importc: "glPixelZoom", ogl.} - proc glShadeModel(mode: TGLenum) {.importc: "glShadeModel", ogl.} - proc glFramebufferTexture3DOES(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc: "glFramebufferTexture3DOES", ogl.} - proc glMultiTexCoord2i(target: TGLenum, s: TGLint, t: TGLint) {.importc: "glMultiTexCoord2i", ogl.} - proc glBlendEquationSeparateIndexedAMD(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc: "glBlendEquationSeparateIndexedAMD", ogl.} - proc glIsEnabled(cap: TGLenum): TGLboolean {.importc: "glIsEnabled", ogl.} - proc glTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexImage2D", ogl.} - proc glPolygonOffsetxOES(factor: TGLfixed, units: TGLfixed) {.importc: "glPolygonOffsetxOES", ogl.} - proc glDrawBuffersEXT(n: TGLsizei, bufs: TGLenum) {.importc: "glDrawBuffersEXT", ogl.} - proc glPixelTexGenParameterfSGIS(pname: TGLenum, param: TGLfloat) {.importc: "glPixelTexGenParameterfSGIS", ogl.} - proc glExtGetRenderbuffersQCOM(renderbuffers: TGLuint, maxRenderbuffers: TGLint, numRenderbuffers: TGLint) {.importc: "glExtGetRenderbuffersQCOM", ogl.} - proc glBindImageTextures(first: TGLuint, count: TGLsizei, textures: TGLuint) {.importc: "glBindImageTextures", ogl.} - proc glVertexAttribP2uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc: "glVertexAttribP2uiv", ogl.} - proc glTextureImage3DMultisampleCoverageNV(texture: TGLuint, target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc: "glTextureImage3DMultisampleCoverageNV", ogl.} - proc glRasterPos2s(x: TGLshort, y: TGLshort) {.importc: "glRasterPos2s", ogl.} - proc glVertexAttrib4dvARB(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib4dvARB", ogl.} - proc glProgramUniformMatrix2x3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix2x3fvEXT", ogl.} - proc glProgramUniformMatrix2x4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix2x4dvEXT", ogl.} - proc glMultiTexCoord1d(target: TGLenum, s: TGLdouble) {.importc: "glMultiTexCoord1d", ogl.} - proc glGetProgramParameterdvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc: "glGetProgramParameterdvNV", ogl.} - proc glPNTrianglesfATI(pname: TGLenum, param: TGLfloat) {.importc: "glPNTrianglesfATI", ogl.} - proc glUniformMatrix3x4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix3x4fv", ogl.} - proc glVertexAttrib3sNV(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc: "glVertexAttrib3sNV", ogl.} - proc glGetVideoCaptureStreamfvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetVideoCaptureStreamfvNV", ogl.} - proc glCombinerParameterivNV(pname: TGLenum, params: TGLint) {.importc: "glCombinerParameterivNV", ogl.} - proc glGetTexGenfvOES(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetTexGenfvOES", ogl.} - proc glCopyTexSubImage2DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyTexSubImage2DEXT", ogl.} - proc glGetProgramLocalParameterfvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc: "glGetProgramLocalParameterfvARB", ogl.} - proc glTexCoord3iv(v: TGLint) {.importc: "glTexCoord3iv", ogl.} - proc glVertexAttribs2hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc: "glVertexAttribs2hvNV", ogl.} - proc glNormal3sv(v: TGLshort) {.importc: "glNormal3sv", ogl.} - proc glUniform2dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glUniform2dv", ogl.} - proc glSecondaryColor3hvNV(v: TGLhalfNV) {.importc: "glSecondaryColor3hvNV", ogl.} - proc glDrawArraysInstancedEXT(mode: TGLenum, start: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc: "glDrawArraysInstancedEXT", ogl.} - proc glBeginTransformFeedback(primitiveMode: TGLenum) {.importc: "glBeginTransformFeedback", ogl.} - proc glTexParameterIuivEXT(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc: "glTexParameterIuivEXT", ogl.} - proc glProgramBufferParametersfvNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: TGLfloat) {.importc: "glProgramBufferParametersfvNV", ogl.} - proc glVertexArrayBindVertexBufferEXT(vaobj: TGLuint, bindingindex: TGLuint, buffer: TGLuint, offset: TGLintptr, stride: TGLsizei) {.importc: "glVertexArrayBindVertexBufferEXT", ogl.} - proc glPathParameterfNV(path: TGLuint, pname: TGLenum, value: TGLfloat) {.importc: "glPathParameterfNV", ogl.} - proc glGetClipPlanexOES(plane: TGLenum, equation: TGLfixed) {.importc: "glGetClipPlanexOES", ogl.} - proc glSecondaryColor3ubvEXT(v: TGLubyte) {.importc: "glSecondaryColor3ubvEXT", ogl.} - proc glGetPixelMapxv(map: TGLenum, size: TGLint, values: TGLfixed) {.importc: "glGetPixelMapxv", ogl.} - proc glVertexAttribI1uivEXT(index: TGLuint, v: TGLuint) {.importc: "glVertexAttribI1uivEXT", ogl.} - proc glMultiTexImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glMultiTexImage3DEXT", ogl.} - proc glAlphaFuncxOES(func: TGLenum, `ref`: TGLfixed) {.importc: "glAlphaFuncxOES", ogl.} - proc glMultiTexCoord2dv(target: TGLenum, v: TGLdouble) {.importc: "glMultiTexCoord2dv", ogl.} - proc glBindRenderbufferOES(target: TGLenum, renderbuffer: TGLuint) {.importc: "glBindRenderbufferOES", ogl.} - proc glPathStencilDepthOffsetNV(factor: TGLfloat, units: TGLfloat) {.importc: "glPathStencilDepthOffsetNV", ogl.} - proc glPointParameterfvEXT(pname: TGLenum, params: TGLfloat) {.importc: "glPointParameterfvEXT", ogl.} - proc glSampleCoverageARB(value: TGLfloat, invert: TGLboolean) {.importc: "glSampleCoverageARB", ogl.} - proc glVertexAttrib3dNV(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glVertexAttrib3dNV", ogl.} - proc glNamedProgramLocalParameter4dvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLdouble) {.importc: "glNamedProgramLocalParameter4dvEXT", ogl.} - proc glGenFramebuffers(n: TGLsizei, framebuffers: TGLuint) {.importc: "glGenFramebuffers", ogl.} - proc glMultiDrawElementsEXT(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei) {.importc: "glMultiDrawElementsEXT", ogl.} - proc glVertexAttrib2fNV(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc: "glVertexAttrib2fNV", ogl.} - proc glProgramUniform4ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glProgramUniform4ivEXT", ogl.} - proc glTexGeniOES(coord: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glTexGeniOES", ogl.} - proc glBindProgramPipeline(pipeline: TGLuint) {.importc: "glBindProgramPipeline", ogl.} - proc glBindSamplers(first: TGLuint, count: TGLsizei, samplers: TGLuint) {.importc: "glBindSamplers", ogl.} - proc glColorTableSGI(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc: "glColorTableSGI", ogl.} - proc glMultiTexCoord3xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed) {.importc: "glMultiTexCoord3xOES", ogl.} - proc glIsQueryEXT(id: TGLuint): TGLboolean {.importc: "glIsQueryEXT", ogl.} - proc glGenBuffersARB(n: TGLsizei, buffers: TGLuint) {.importc: "glGenBuffersARB", ogl.} - proc glVertex4xvOES(coords: TGLfixed) {.importc: "glVertex4xvOES", ogl.} - proc glPixelMapuiv(map: TGLenum, mapsize: TGLsizei, values: TGLuint) {.importc: "glPixelMapuiv", ogl.} - proc glDrawTexfOES(x: TGLfloat, y: TGLfloat, z: TGLfloat, width: TGLfloat, height: TGLfloat) {.importc: "glDrawTexfOES", ogl.} - proc glPointParameterfEXT(pname: TGLenum, param: TGLfloat) {.importc: "glPointParameterfEXT", ogl.} - proc glPathDashArrayNV(path: TGLuint, dashCount: TGLsizei, dashArray: TGLfloat) {.importc: "glPathDashArrayNV", ogl.} - proc glClearTexImage(texture: TGLuint, level: TGLint, format: TGLenum, `type`: TGLenum, data: pointer) {.importc: "glClearTexImage", ogl.} - proc glIndexdv(c: TGLdouble) {.importc: "glIndexdv", ogl.} - proc glMultTransposeMatrixfARB(m: TGLfloat) {.importc: "glMultTransposeMatrixfARB", ogl.} - proc glVertexAttribL3d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glVertexAttribL3d", ogl.} - proc glUniform3fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glUniform3fv", ogl.} - proc glGetProgramInterfaceiv(program: TGLuint, programInterface: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetProgramInterfaceiv", ogl.} - proc glFogCoordfv(coord: TGLfloat) {.importc: "glFogCoordfv", ogl.} - proc glTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexSubImage3DOES", ogl.} - proc glGetPolygonStipple(mask: TGLubyte) {.importc: "glGetPolygonStipple", ogl.} - proc glGetQueryObjectivEXT(id: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetQueryObjectivEXT", ogl.} - proc glColor3xOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed) {.importc: "glColor3xOES", ogl.} - proc glMultiTexParameterIivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glMultiTexParameterIivEXT", ogl.} - proc glGetMaterialiv(face: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetMaterialiv", ogl.} - proc glVertex2fv(v: TGLfloat) {.importc: "glVertex2fv", ogl.} - proc glConvolutionParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glConvolutionParameterivEXT", ogl.} - proc glGenOcclusionQueriesNV(n: TGLsizei, ids: TGLuint) {.importc: "glGenOcclusionQueriesNV", ogl.} - proc glGetVertexAttribdvNV(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc: "glGetVertexAttribdvNV", ogl.} - proc glVertexAttribs4fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc: "glVertexAttribs4fvNV", ogl.} - proc glVertexAttribL3dv(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttribL3dv", ogl.} - proc glTexEnvi(target: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glTexEnvi", ogl.} - proc glObjectPtrLabel(`ptr`: pointer, length: TGLsizei, label: TGLchar) {.importc: "glObjectPtrLabel", ogl.} - proc glGetTexGenfv(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetTexGenfv", ogl.} - proc glMapVertexAttrib1dAPPLE(index: TGLuint, size: TGLuint, u1: TGLdouble, u2: TGLdouble, stride: TGLint, order: TGLint, points: TGLdouble) {.importc: "glMapVertexAttrib1dAPPLE", ogl.} - proc glTexCoord3dv(v: TGLdouble) {.importc: "glTexCoord3dv", ogl.} - proc glIsEnabledIndexedEXT(target: TGLenum, index: TGLuint): TGLboolean {.importc: "glIsEnabledIndexedEXT", ogl.} - proc glGlobalAlphaFactoruiSUN(factor: TGLuint) {.importc: "glGlobalAlphaFactoruiSUN", ogl.} - proc glMatrixIndexPointerARB(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glMatrixIndexPointerARB", ogl.} - proc glUniformHandleui64ARB(location: TGLint, value: TGLuint64) {.importc: "glUniformHandleui64ARB", ogl.} - proc glUniform1fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glUniform1fvARB", ogl.} - proc glGetActiveSubroutineUniformName(program: TGLuint, shadertype: TGLenum, index: TGLuint, bufsize: TGLsizei, length: TGLsizei, name: TGLchar) {.importc: "glGetActiveSubroutineUniformName", ogl.} - proc glProgramUniformMatrix4x2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix4x2fvEXT", ogl.} - proc glMultiTexCoord4fARB(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc: "glMultiTexCoord4fARB", ogl.} - proc glGetDriverControlsQCOM(num: TGLint, size: TGLsizei, driverControls: TGLuint) {.importc: "glGetDriverControlsQCOM", ogl.} - proc glBindBufferRange(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc: "glBindBufferRange", ogl.} - proc glMapGrid2f(un: TGLint, u1: TGLfloat, u2: TGLfloat, vn: TGLint, v1: TGLfloat, v2: TGLfloat) {.importc: "glMapGrid2f", ogl.} - proc glUniform2fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glUniform2fv", ogl.} - proc glOrtho(left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc: "glOrtho", ogl.} - proc glGetImageHandleNV(texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, format: TGLenum): TGLuint64 {.importc: "glGetImageHandleNV", ogl.} - proc glIsImageHandleResidentARB(handle: TGLuint64): TGLboolean {.importc: "glIsImageHandleResidentARB", ogl.} - proc glGetConvolutionParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetConvolutionParameterivEXT", ogl.} - proc glLineWidthxOES(width: TGLfixed) {.importc: "glLineWidthxOES", ogl.} - proc glPathCommandsNV(path: TGLuint, numCommands: TGLsizei, commands: TGLubyte, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc: "glPathCommandsNV", ogl.} - proc glMaterialxvOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glMaterialxvOES", ogl.} - proc glPauseTransformFeedbackNV() {.importc: "glPauseTransformFeedbackNV", ogl.} - proc glTexCoord4d(s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc: "glTexCoord4d", ogl.} - proc glUniform3ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc: "glUniform3ui64vNV", ogl.} - proc glMultiTexCoord3dARB(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc: "glMultiTexCoord3dARB", ogl.} - proc glProgramUniform3fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc: "glProgramUniform3fEXT", ogl.} - proc glTexImage3DMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc: "glTexImage3DMultisampleCoverageNV", ogl.} - proc glNormalPointerEXT(`type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc: "glNormalPointerEXT", ogl.} - proc glPathColorGenNV(color: TGLenum, genMode: TGLenum, colorFormat: TGLenum, coeffs: TGLfloat) {.importc: "glPathColorGenNV", ogl.} - proc glGetMultiTexGendvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc: "glGetMultiTexGendvEXT", ogl.} - proc glColor3i(red: TGLint, green: TGLint, blue: TGLint) {.importc: "glColor3i", ogl.} - proc glPointSizex(size: TGLfixed) {.importc: "glPointSizex", ogl.} - proc glGetConvolutionFilterEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, image: pointer) {.importc: "glGetConvolutionFilterEXT", ogl.} - proc glBindBufferBaseNV(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc: "glBindBufferBaseNV", ogl.} - proc glInsertComponentEXT(res: TGLuint, src: TGLuint, num: TGLuint) {.importc: "glInsertComponentEXT", ogl.} - proc glVertex2d(x: TGLdouble, y: TGLdouble) {.importc: "glVertex2d", ogl.} - proc glGetPathDashArrayNV(path: TGLuint, dashArray: TGLfloat) {.importc: "glGetPathDashArrayNV", ogl.} - proc glVertexAttrib2sARB(index: TGLuint, x: TGLshort, y: TGLshort) {.importc: "glVertexAttrib2sARB", ogl.} - proc glScissor(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glScissor", ogl.} - proc glLoadMatrixd(m: TGLdouble) {.importc: "glLoadMatrixd", ogl.} - proc glVertex2bvOES(coords: TGLbyte) {.importc: "glVertex2bvOES", ogl.} - proc glTexCoord2i(s: TGLint, t: TGLint) {.importc: "glTexCoord2i", ogl.} - proc glWriteMaskEXT(res: TGLuint, `in`: TGLuint, outX: TGLenum, outY: TGLenum, outZ: TGLenum, outW: TGLenum) {.importc: "glWriteMaskEXT", ogl.} - proc glClientWaitSyncAPPLE(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64): TGLenum {.importc: "glClientWaitSyncAPPLE", ogl.} - proc glGetObjectBufferivATI(buffer: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetObjectBufferivATI", ogl.} - proc glGetNamedBufferParameterivEXT(buffer: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetNamedBufferParameterivEXT", ogl.} - proc glTexCoord1bOES(s: TGLbyte) {.importc: "glTexCoord1bOES", ogl.} - proc glVertexAttrib4dARB(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glVertexAttrib4dARB", ogl.} - proc glUniform3fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc: "glUniform3fARB", ogl.} - proc glWindowPos2ivARB(v: TGLint) {.importc: "glWindowPos2ivARB", ogl.} - proc glCreateShaderProgramvEXT(`type`: TGLenum, count: TGLsizei, strings: ptr TGLchar): TGLuint {.importc: "glCreateShaderProgramvEXT", ogl.} - proc glListParameterivSGIX(list: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glListParameterivSGIX", ogl.} - proc glGetGraphicsResetStatusEXT(): TGLenum {.importc: "glGetGraphicsResetStatusEXT", ogl.} - proc glActiveShaderProgramEXT(pipeline: TGLuint, program: TGLuint) {.importc: "glActiveShaderProgramEXT", ogl.} - proc glTexCoordP1uiv(`type`: TGLenum, coords: TGLuint) {.importc: "glTexCoordP1uiv", ogl.} - proc glVideoCaptureStreamParameterdvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLdouble) {.importc: "glVideoCaptureStreamParameterdvNV", ogl.} - proc glGetVertexAttribPointerv(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc: "glGetVertexAttribPointerv", ogl.} - proc glGetCompressedMultiTexImageEXT(texunit: TGLenum, target: TGLenum, lod: TGLint, img: pointer) {.importc: "glGetCompressedMultiTexImageEXT", ogl.} - proc glWindowPos4fMESA(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glWindowPos4fMESA", ogl.} - proc glDrawElementsInstancedARB(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc: "glDrawElementsInstancedARB", ogl.} - proc glVertexStream1dATI(stream: TGLenum, x: TGLdouble) {.importc: "glVertexStream1dATI", ogl.} - proc glMatrixMultfEXT(mode: TGLenum, m: TGLfloat) {.importc: "glMatrixMultfEXT", ogl.} - proc glGetPathParameterivNV(path: TGLuint, pname: TGLenum, value: TGLint) {.importc: "glGetPathParameterivNV", ogl.} - proc glCombinerParameteriNV(pname: TGLenum, param: TGLint) {.importc: "glCombinerParameteriNV", ogl.} - proc glUpdateObjectBufferATI(buffer: TGLuint, offset: TGLuint, size: TGLsizei, `pointer`: pointer, preserve: TGLenum) {.importc: "glUpdateObjectBufferATI", ogl.} - proc glVertexAttrib4uivARB(index: TGLuint, v: TGLuint) {.importc: "glVertexAttrib4uivARB", ogl.} - proc glVertexAttrib4iv(index: TGLuint, v: TGLint) {.importc: "glVertexAttrib4iv", ogl.} - proc glFrustum(left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc: "glFrustum", ogl.} - proc glDrawTexxvOES(coords: TGLfixed) {.importc: "glDrawTexxvOES", ogl.} - proc glTexCoord2fColor4ubVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glTexCoord2fColor4ubVertex3fSUN", ogl.} - proc glMultiTexCoord2fARB(target: TGLenum, s: TGLfloat, t: TGLfloat) {.importc: "glMultiTexCoord2fARB", ogl.} - proc glGenTransformFeedbacksNV(n: TGLsizei, ids: TGLuint) {.importc: "glGenTransformFeedbacksNV", ogl.} - proc glMultiTexGenfEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glMultiTexGenfEXT", ogl.} - proc glGetMinmax(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc: "glGetMinmax", ogl.} - proc glBindTransformFeedback(target: TGLenum, id: TGLuint) {.importc: "glBindTransformFeedback", ogl.} - proc glEnableVertexAttribArrayARB(index: TGLuint) {.importc: "glEnableVertexAttribArrayARB", ogl.} - proc glIsFenceAPPLE(fence: TGLuint): TGLboolean {.importc: "glIsFenceAPPLE", ogl.} - proc glMultiTexGendvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc: "glMultiTexGendvEXT", ogl.} - proc glRotatex(angle: TGLfixed, x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc: "glRotatex", ogl.} - proc glGetFragmentLightfvSGIX(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetFragmentLightfvSGIX", ogl.} - proc glMultiTexCoord4dv(target: TGLenum, v: TGLdouble) {.importc: "glMultiTexCoord4dv", ogl.} - proc glBlendFuncSeparateEXT(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc: "glBlendFuncSeparateEXT", ogl.} - proc glMultiTexCoord1f(target: TGLenum, s: TGLfloat) {.importc: "glMultiTexCoord1f", ogl.} - proc glWindowPos2f(x: TGLfloat, y: TGLfloat) {.importc: "glWindowPos2f", ogl.} - proc glGetPathTexGenivNV(texCoordSet: TGLenum, pname: TGLenum, value: TGLint) {.importc: "glGetPathTexGenivNV", ogl.} - proc glIndexxvOES(component: TGLfixed) {.importc: "glIndexxvOES", ogl.} - proc glDisableVertexArrayAttribEXT(vaobj: TGLuint, index: TGLuint) {.importc: "glDisableVertexArrayAttribEXT", ogl.} - proc glGetProgramivARB(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetProgramivARB", ogl.} - proc glPatchParameteri(pname: TGLenum, value: TGLint) {.importc: "glPatchParameteri", ogl.} - proc glMultiTexCoord2fv(target: TGLenum, v: TGLfloat) {.importc: "glMultiTexCoord2fv", ogl.} - proc glTexSubImage3DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexSubImage3DEXT", ogl.} - proc glFramebufferTexture1DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glFramebufferTexture1DEXT", ogl.} - proc glTangent3fEXT(tx: TGLfloat, ty: TGLfloat, tz: TGLfloat) {.importc: "glTangent3fEXT", ogl.} - proc glIsVertexAttribEnabledAPPLE(index: TGLuint, pname: TGLenum): TGLboolean {.importc: "glIsVertexAttribEnabledAPPLE", ogl.} - proc glGetShaderInfoLog(shader: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc: "glGetShaderInfoLog", ogl.} - proc glFrustumx(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc: "glFrustumx", ogl.} - proc glTexGenfv(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glTexGenfv", ogl.} - proc glCompressedTexImage2DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexImage2DARB", ogl.} - proc glMultiTexCoord2bvOES(texture: TGLenum, coords: TGLbyte) {.importc: "glMultiTexCoord2bvOES", ogl.} - proc glGetTexBumpParameterivATI(pname: TGLenum, param: TGLint) {.importc: "glGetTexBumpParameterivATI", ogl.} - proc glMultiTexCoord2svARB(target: TGLenum, v: TGLshort) {.importc: "glMultiTexCoord2svARB", ogl.} - proc glProgramBufferParametersIivNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: TGLint) {.importc: "glProgramBufferParametersIivNV", ogl.} - proc glIsQueryARB(id: TGLuint): TGLboolean {.importc: "glIsQueryARB", ogl.} - proc glFramebufferTextureLayer(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc: "glFramebufferTextureLayer", ogl.} - proc glUniform4i(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc: "glUniform4i", ogl.} - proc glDrawArrays(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc: "glDrawArrays", ogl.} - proc glWeightubvARB(size: TGLint, weights: TGLubyte) {.importc: "glWeightubvARB", ogl.} - proc glGetUniformSubroutineuiv(shadertype: TGLenum, location: TGLint, params: TGLuint) {.importc: "glGetUniformSubroutineuiv", ogl.} - proc glMultTransposeMatrixdARB(m: TGLdouble) {.importc: "glMultTransposeMatrixdARB", ogl.} - proc glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc: TGLuint, tc: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc: "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", ogl.} - proc glGetMapdv(target: TGLenum, query: TGLenum, v: TGLdouble) {.importc: "glGetMapdv", ogl.} - proc glGetMultisamplefvNV(pname: TGLenum, index: TGLuint, val: TGLfloat) {.importc: "glGetMultisamplefvNV", ogl.} - proc glVertex2hvNV(v: TGLhalfNV) {.importc: "glVertex2hvNV", ogl.} - proc glProgramUniformMatrix2x3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix2x3fv", ogl.} - proc glProgramUniform3iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc: "glProgramUniform3iEXT", ogl.} - proc glGetnPixelMapusvARB(map: TGLenum, bufSize: TGLsizei, values: TGLushort) {.importc: "glGetnPixelMapusvARB", ogl.} - proc glVertexWeighthvNV(weight: TGLhalfNV) {.importc: "glVertexWeighthvNV", ogl.} - proc glDrawTransformFeedbackInstanced(mode: TGLenum, id: TGLuint, instancecount: TGLsizei) {.importc: "glDrawTransformFeedbackInstanced", ogl.} - proc glFlushStaticDataIBM(target: TGLenum) {.importc: "glFlushStaticDataIBM", ogl.} - proc glWindowPos2fvARB(v: TGLfloat) {.importc: "glWindowPos2fvARB", ogl.} - proc glMultiTexCoord3sARB(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort) {.importc: "glMultiTexCoord3sARB", ogl.} - proc glWindowPos3fv(v: TGLfloat) {.importc: "glWindowPos3fv", ogl.} - proc glFlushVertexArrayRangeNV() {.importc: "glFlushVertexArrayRangeNV", ogl.} - proc glTangent3bEXT(tx: TGLbyte, ty: TGLbyte, tz: TGLbyte) {.importc: "glTangent3bEXT", ogl.} - proc glIglooInterfaceSGIX(pname: TGLenum, params: pointer) {.importc: "glIglooInterfaceSGIX", ogl.} - proc glProgramUniformMatrix4x2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix4x2fv", ogl.} - proc glVertexAttribIFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc: "glVertexAttribIFormatNV", ogl.} - proc glNamedRenderbufferStorageMultisampleEXT(renderbuffer: TGLuint, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glNamedRenderbufferStorageMultisampleEXT", ogl.} - proc glCopyTexImage1DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc: "glCopyTexImage1DEXT", ogl.} - proc glBindTexGenParameterEXT(unit: TGLenum, coord: TGLenum, value: TGLenum): TGLuint {.importc: "glBindTexGenParameterEXT", ogl.} - proc glVertex4hNV(x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV, w: TGLhalfNV) {.importc: "glVertex4hNV", ogl.} - proc glGetMapfv(target: TGLenum, query: TGLenum, v: TGLfloat) {.importc: "glGetMapfv", ogl.} - proc glSamplePatternEXT(pattern: TGLenum) {.importc: "glSamplePatternEXT", ogl.} - proc glIndexxOES(component: TGLfixed) {.importc: "glIndexxOES", ogl.} - proc glVertexAttrib4ubv(index: TGLuint, v: TGLubyte) {.importc: "glVertexAttrib4ubv", ogl.} - proc glGetColorTable(target: TGLenum, format: TGLenum, `type`: TGLenum, table: pointer) {.importc: "glGetColorTable", ogl.} - proc glFragmentLightModelivSGIX(pname: TGLenum, params: TGLint) {.importc: "glFragmentLightModelivSGIX", ogl.} - proc glPixelTransformParameterfEXT(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glPixelTransformParameterfEXT", ogl.} - proc glSamplerParameterfv(sampler: TGLuint, pname: TGLenum, param: TGLfloat) {.importc: "glSamplerParameterfv", ogl.} - proc glBindTextureUnitParameterEXT(unit: TGLenum, value: TGLenum): TGLuint {.importc: "glBindTextureUnitParameterEXT", ogl.} - proc glColor3ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc: "glColor3ub", ogl.} - proc glGetMultiTexGenivEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetMultiTexGenivEXT", ogl.} - proc glVariantusvEXT(id: TGLuint, `addr`: TGLushort) {.importc: "glVariantusvEXT", ogl.} - proc glMaterialiv(face: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glMaterialiv", ogl.} - proc glPassTexCoordATI(dst: TGLuint, coord: TGLuint, swizzle: TGLenum) {.importc: "glPassTexCoordATI", ogl.} - proc glGetIntegerui64vNV(value: TGLenum, result: TGLuint64EXT) {.importc: "glGetIntegerui64vNV", ogl.} - proc glProgramParameteriEXT(program: TGLuint, pname: TGLenum, value: TGLint) {.importc: "glProgramParameteriEXT", ogl.} - proc glVertexArrayEdgeFlagOffsetEXT(vaobj: TGLuint, buffer: TGLuint, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayEdgeFlagOffsetEXT", ogl.} - proc glGetCombinerInputParameterivNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetCombinerInputParameterivNV", ogl.} - proc glLogicOp(opcode: TGLenum) {.importc: "glLogicOp", ogl.} - proc glConvolutionParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glConvolutionParameterfvEXT", ogl.} - proc glIsBufferResidentNV(target: TGLenum): TGLboolean {.importc: "glIsBufferResidentNV", ogl.} - proc glIsProgram(program: TGLuint): TGLboolean {.importc: "glIsProgram", ogl.} - proc glEndQueryARB(target: TGLenum) {.importc: "glEndQueryARB", ogl.} - proc glRenderbufferStorage(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glRenderbufferStorage", ogl.} - proc glMaterialfv(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glMaterialfv", ogl.} - proc glTranslatex(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc: "glTranslatex", ogl.} - proc glPathParameterivNV(path: TGLuint, pname: TGLenum, value: TGLint) {.importc: "glPathParameterivNV", ogl.} - proc glLightxOES(light: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glLightxOES", ogl.} - proc glSampleMaskEXT(value: TGLclampf, invert: TGLboolean) {.importc: "glSampleMaskEXT", ogl.} - proc glReplacementCodeubvSUN(code: TGLubyte) {.importc: "glReplacementCodeubvSUN", ogl.} - proc glVertexAttribArrayObjectATI(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc: "glVertexAttribArrayObjectATI", ogl.} - proc glBeginTransformFeedbackNV(primitiveMode: TGLenum) {.importc: "glBeginTransformFeedbackNV", ogl.} - proc glEvalCoord1fv(u: TGLfloat) {.importc: "glEvalCoord1fv", ogl.} - proc glProgramUniformMatrix2x3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix2x3dvEXT", ogl.} - proc glMaterialxv(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glMaterialxv", ogl.} - proc glGetIntegerui64i_vNV(value: TGLenum, index: TGLuint, result: TGLuint64EXT) {.importc: "glGetIntegerui64i_vNV", ogl.} - proc glUniformBlockBinding(program: TGLuint, uniformBlockIndex: TGLuint, uniformBlockBinding: TGLuint) {.importc: "glUniformBlockBinding", ogl.} - proc glColor4ui(red: TGLuint, green: TGLuint, blue: TGLuint, alpha: TGLuint) {.importc: "glColor4ui", ogl.} - proc glColor4ubVertex2fvSUN(c: TGLubyte, v: TGLfloat) {.importc: "glColor4ubVertex2fvSUN", ogl.} - proc glRectd(x1: TGLdouble, y1: TGLdouble, x2: TGLdouble, y2: TGLdouble) {.importc: "glRectd", ogl.} - proc glGenVertexShadersEXT(range: TGLuint): TGLuint {.importc: "glGenVertexShadersEXT", ogl.} - proc glLinkProgramARB(programObj: TGLhandleARB) {.importc: "glLinkProgramARB", ogl.} - proc glVertexAttribL4dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glVertexAttribL4dEXT", ogl.} - proc glBlitFramebuffer(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc: "glBlitFramebuffer", ogl.} - proc glUseProgram(program: TGLuint) {.importc: "glUseProgram", ogl.} - proc glNamedProgramLocalParameterI4ivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLint) {.importc: "glNamedProgramLocalParameterI4ivEXT", ogl.} - proc glMatrixLoadTransposedEXT(mode: TGLenum, m: TGLdouble) {.importc: "glMatrixLoadTransposedEXT", ogl.} - proc glTranslatef(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glTranslatef", ogl.} - proc glGetBooleani_v(target: TGLenum, index: TGLuint, data: TGLboolean) {.importc: "glGetBooleani_v", ogl.} - proc glEndFragmentShaderATI() {.importc: "glEndFragmentShaderATI", ogl.} - proc glVertexAttribI4ivEXT(index: TGLuint, v: TGLint) {.importc: "glVertexAttribI4ivEXT", ogl.} - proc glMultiDrawElementsIndirectBindlessNV(mode: TGLenum, `type`: TGLenum, indirect: pointer, drawCount: TGLsizei, stride: TGLsizei, vertexBufferCount: TGLint) {.importc: "glMultiDrawElementsIndirectBindlessNV", ogl.} - proc glTexCoord2s(s: TGLshort, t: TGLshort) {.importc: "glTexCoord2s", ogl.} - proc glProgramUniform1i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc: "glProgramUniform1i64vNV", ogl.} - proc glPointSizePointerOES(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glPointSizePointerOES", ogl.} - proc glGetTexFilterFuncSGIS(target: TGLenum, filter: TGLenum, weights: TGLfloat) {.importc: "glGetTexFilterFuncSGIS", ogl.} - proc glMapGrid2xOES(n: TGLint, u1: TGLfixed, u2: TGLfixed, v1: TGLfixed, v2: TGLfixed) {.importc: "glMapGrid2xOES", ogl.} - proc glRasterPos4xvOES(coords: TGLfixed) {.importc: "glRasterPos4xvOES", ogl.} - proc glGetProgramBinary(program: TGLuint, bufSize: TGLsizei, length: TGLsizei, binaryFormat: TGLenum, binary: pointer) {.importc: "glGetProgramBinary", ogl.} - proc glNamedProgramLocalParameterI4uiEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc: "glNamedProgramLocalParameterI4uiEXT", ogl.} - proc glGetTexImage(target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glGetTexImage", ogl.} - proc glColor4d(red: TGLdouble, green: TGLdouble, blue: TGLdouble, alpha: TGLdouble) {.importc: "glColor4d", ogl.} - proc glTexCoord2fColor4fNormal3fVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glTexCoord2fColor4fNormal3fVertex3fSUN", ogl.} - proc glIndexi(c: TGLint) {.importc: "glIndexi", ogl.} - proc glGetSamplerParameterIuiv(sampler: TGLuint, pname: TGLenum, params: TGLuint) {.importc: "glGetSamplerParameterIuiv", ogl.} - proc glGetnUniformivARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLint) {.importc: "glGetnUniformivARB", ogl.} - proc glCopyTexSubImage3DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyTexSubImage3DEXT", ogl.} - proc glVertexAttribI2uivEXT(index: TGLuint, v: TGLuint) {.importc: "glVertexAttribI2uivEXT", ogl.} - proc glVertexStream2fvATI(stream: TGLenum, coords: TGLfloat) {.importc: "glVertexStream2fvATI", ogl.} - proc glArrayElementEXT(i: TGLint) {.importc: "glArrayElementEXT", ogl.} - proc glVertexAttrib2fv(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib2fv", ogl.} - proc glCopyMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc: "glCopyMultiTexSubImage1DEXT", ogl.} - proc glTexCoord4sv(v: TGLshort) {.importc: "glTexCoord4sv", ogl.} - proc glTexGenfvOES(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glTexGenfvOES", ogl.} - proc glPointParameteriv(pname: TGLenum, params: TGLint) {.importc: "glPointParameteriv", ogl.} - proc glGetNamedRenderbufferParameterivEXT(renderbuffer: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetNamedRenderbufferParameterivEXT", ogl.} - proc glProgramVertexLimitNV(target: TGLenum, limit: TGLint) {.importc: "glProgramVertexLimitNV", ogl.} - proc glSetMultisamplefvAMD(pname: TGLenum, index: TGLuint, val: TGLfloat) {.importc: "glSetMultisamplefvAMD", ogl.} - proc glLoadIdentityDeformationMapSGIX(mask: TGLbitfield) {.importc: "glLoadIdentityDeformationMapSGIX", ogl.} - proc glIsSyncAPPLE(sync: TGLsync): TGLboolean {.importc: "glIsSyncAPPLE", ogl.} - proc glProgramUniform1ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc: "glProgramUniform1ui64vNV", ogl.} - proc glEdgeFlagPointerListIBM(stride: TGLint, `pointer`: ptr TGLboolean, ptrstride: TGLint) {.importc: "glEdgeFlagPointerListIBM", ogl.} - proc glBeginVertexShaderEXT() {.importc: "glBeginVertexShaderEXT", ogl.} - proc glGetIntegerv(pname: TGLenum, params: TGLint) {.importc: "glGetIntegerv", ogl.} - proc glVertexAttrib2dvARB(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib2dvARB", ogl.} - proc glBeginConditionalRenderNV(id: TGLuint, mode: TGLenum) {.importc: "glBeginConditionalRenderNV", ogl.} - proc glEdgeFlagv(flag: TGLboolean) {.importc: "glEdgeFlagv", ogl.} - proc glReplacementCodeubSUN(code: TGLubyte) {.importc: "glReplacementCodeubSUN", ogl.} - proc glObjectLabel(identifier: TGLenum, name: TGLuint, length: TGLsizei, label: TGLchar) {.importc: "glObjectLabel", ogl.} - proc glMultiTexCoord3xvOES(texture: TGLenum, coords: TGLfixed) {.importc: "glMultiTexCoord3xvOES", ogl.} - proc glNormal3iv(v: TGLint) {.importc: "glNormal3iv", ogl.} - proc glSamplerParameteri(sampler: TGLuint, pname: TGLenum, param: TGLint) {.importc: "glSamplerParameteri", ogl.} - proc glTextureStorage1DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc: "glTextureStorage1DEXT", ogl.} - proc glVertexStream4dvATI(stream: TGLenum, coords: TGLdouble) {.importc: "glVertexStream4dvATI", ogl.} - proc glWindowPos2fv(v: TGLfloat) {.importc: "glWindowPos2fv", ogl.} - proc glTexCoord4i(s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc: "glTexCoord4i", ogl.} - proc glVertexAttrib4NusvARB(index: TGLuint, v: TGLushort) {.importc: "glVertexAttrib4NusvARB", ogl.} - proc glVertexAttribL4d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glVertexAttribL4d", ogl.} - proc glVertexAttribDivisorANGLE(index: TGLuint, divisor: TGLuint) {.importc: "glVertexAttribDivisorANGLE", ogl.} - proc glMatrixIndexPointerOES(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glMatrixIndexPointerOES", ogl.} - proc glMultMatrixxOES(m: TGLfixed) {.importc: "glMultMatrixxOES", ogl.} - proc glMultiTexCoordP2ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc: "glMultiTexCoordP2ui", ogl.} - proc glDeformationMap3dSGIX(target: TGLenum, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, w1: TGLdouble, w2: TGLdouble, wstride: TGLint, worder: TGLint, points: TGLdouble) {.importc: "glDeformationMap3dSGIX", ogl.} - proc glClearDepthfOES(depth: TGLclampf) {.importc: "glClearDepthfOES", ogl.} - proc glVertexStream1ivATI(stream: TGLenum, coords: TGLint) {.importc: "glVertexStream1ivATI", ogl.} - proc glHint(target: TGLenum, mode: TGLenum) {.importc: "glHint", ogl.} - proc glVertex3fv(v: TGLfloat) {.importc: "glVertex3fv", ogl.} - proc glWaitSyncAPPLE(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64) {.importc: "glWaitSyncAPPLE", ogl.} - proc glWindowPos3i(x: TGLint, y: TGLint, z: TGLint) {.importc: "glWindowPos3i", ogl.} - proc glCompressedTexImage3DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexImage3DARB", ogl.} - proc glVertexAttrib1fvARB(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib1fvARB", ogl.} - proc glMultiTexCoord4xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc: "glMultiTexCoord4xOES", ogl.} - proc glUniform4ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc: "glUniform4ui64NV", ogl.} - proc glProgramUniform4uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc: "glProgramUniform4uiEXT", ogl.} - proc glUnmapNamedBufferEXT(buffer: TGLuint): TGLboolean {.importc: "glUnmapNamedBufferEXT", ogl.} - proc glBitmap(width: TGLsizei, height: TGLsizei, xorig: TGLfloat, yorig: TGLfloat, xmove: TGLfloat, ymove: TGLfloat, bitmap: TGLubyte) {.importc: "glBitmap", ogl.} - proc glNamedProgramLocalParameters4fvEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLfloat) {.importc: "glNamedProgramLocalParameters4fvEXT", ogl.} - proc glGetPathCommandsNV(path: TGLuint, commands: TGLubyte) {.importc: "glGetPathCommandsNV", ogl.} - proc glVertexAttrib3fNV(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glVertexAttrib3fNV", ogl.} - proc glNamedProgramStringEXT(program: TGLuint, target: TGLenum, format: TGLenum, len: TGLsizei, string: pointer) {.importc: "glNamedProgramStringEXT", ogl.} - proc glMatrixIndexusvARB(size: TGLint, indices: TGLushort) {.importc: "glMatrixIndexusvARB", ogl.} - proc glBlitFramebufferNV(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc: "glBlitFramebufferNV", ogl.} - proc glVertexAttribI1uiv(index: TGLuint, v: TGLuint) {.importc: "glVertexAttribI1uiv", ogl.} - proc glEndConditionalRenderNV() {.importc: "glEndConditionalRenderNV", ogl.} - proc glFeedbackBuffer(size: TGLsizei, `type`: TGLenum, buffer: TGLfloat) {.importc: "glFeedbackBuffer", ogl.} - proc glMultiTexCoord3bvOES(texture: TGLenum, coords: TGLbyte) {.importc: "glMultiTexCoord3bvOES", ogl.} - proc glCopyColorTableSGI(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc: "glCopyColorTableSGI", ogl.} - proc glActiveTexture(texture: TGLenum) {.importc: "glActiveTexture", ogl.} - proc glFogCoordhNV(fog: TGLhalfNV) {.importc: "glFogCoordhNV", ogl.} - proc glColorMaskIndexedEXT(index: TGLuint, r: TGLboolean, g: TGLboolean, b: TGLboolean, a: TGLboolean) {.importc: "glColorMaskIndexedEXT", ogl.} - proc glGetCompressedTexImage(target: TGLenum, level: TGLint, img: pointer) {.importc: "glGetCompressedTexImage", ogl.} - proc glRasterPos2iv(v: TGLint) {.importc: "glRasterPos2iv", ogl.} - proc glGetBufferParameterivARB(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetBufferParameterivARB", ogl.} - proc glProgramUniform3d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble, v2: TGLdouble) {.importc: "glProgramUniform3d", ogl.} - proc glRasterPos3xvOES(coords: TGLfixed) {.importc: "glRasterPos3xvOES", ogl.} - proc glGetTextureParameterIuivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc: "glGetTextureParameterIuivEXT", ogl.} - proc glBindImageTextureEXT(index: TGLuint, texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, access: TGLenum, format: TGLint) {.importc: "glBindImageTextureEXT", ogl.} - proc glWindowPos2iMESA(x: TGLint, y: TGLint) {.importc: "glWindowPos2iMESA", ogl.} - proc glVertexPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc: "glVertexPointervINTEL", ogl.} - proc glPixelTexGenParameterfvSGIS(pname: TGLenum, params: TGLfloat) {.importc: "glPixelTexGenParameterfvSGIS", ogl.} - proc glUniform1iARB(location: TGLint, v0: TGLint) {.importc: "glUniform1iARB", ogl.} - proc glTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTextureSubImage3DEXT", ogl.} - proc glStencilOpSeparate(face: TGLenum, sfail: TGLenum, dpfail: TGLenum, dppass: TGLenum) {.importc: "glStencilOpSeparate", ogl.} - proc glVertexAttrib1dARB(index: TGLuint, x: TGLdouble) {.importc: "glVertexAttrib1dARB", ogl.} - proc glGetVideoCaptureStreamivNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetVideoCaptureStreamivNV", ogl.} - proc glIsFramebufferEXT(framebuffer: TGLuint): TGLboolean {.importc: "glIsFramebufferEXT", ogl.} - proc glPointParameterxv(pname: TGLenum, params: TGLfixed) {.importc: "glPointParameterxv", ogl.} - proc glProgramUniform4dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glProgramUniform4dv", ogl.} - proc glPassThrough(token: TGLfloat) {.importc: "glPassThrough", ogl.} - proc glGetProgramPipelineiv(pipeline: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetProgramPipelineiv", ogl.} - proc glApplyTextureEXT(mode: TGLenum) {.importc: "glApplyTextureEXT", ogl.} - proc glVertexArrayNormalOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayNormalOffsetEXT", ogl.} - proc glTexFilterFuncSGIS(target: TGLenum, filter: TGLenum, n: TGLsizei, weights: TGLfloat) {.importc: "glTexFilterFuncSGIS", ogl.} - proc glRenderbufferStorageOES(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glRenderbufferStorageOES", ogl.} - proc glBindParameterEXT(value: TGLenum): TGLuint {.importc: "glBindParameterEXT", ogl.} - proc glVertex4s(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc: "glVertex4s", ogl.} - proc glLoadTransposeMatrixf(m: TGLfloat) {.importc: "glLoadTransposeMatrixf", ogl.} - proc glDepthFunc(func: TGLenum) {.importc: "glDepthFunc", ogl.} - proc glGetFramebufferAttachmentParameterivEXT(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetFramebufferAttachmentParameterivEXT", ogl.} - proc glSampleMaskSGIS(value: TGLclampf, invert: TGLboolean) {.importc: "glSampleMaskSGIS", ogl.} - proc glGetPointerIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr pointer) {.importc: "glGetPointerIndexedvEXT", ogl.} - proc glVertexStream4iATI(stream: TGLenum, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc: "glVertexStream4iATI", ogl.} - proc glUnlockArraysEXT() {.importc: "glUnlockArraysEXT", ogl.} - proc glReplacementCodeuivSUN(code: TGLuint) {.importc: "glReplacementCodeuivSUN", ogl.} - proc glMatrixScaledEXT(mode: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glMatrixScaledEXT", ogl.} - proc glMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glMultiTexImage2DEXT", ogl.} - proc glFeedbackBufferxOES(n: TGLsizei, `type`: TGLenum, buffer: TGLfixed) {.importc: "glFeedbackBufferxOES", ogl.} - proc glLightEnviSGIX(pname: TGLenum, param: TGLint) {.importc: "glLightEnviSGIX", ogl.} - proc glMultiTexCoord4dARB(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc: "glMultiTexCoord4dARB", ogl.} - proc glExtGetTexLevelParameterivQCOM(texture: TGLuint, face: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc: "glExtGetTexLevelParameterivQCOM", ogl.} - proc glVertexAttribI4usvEXT(index: TGLuint, v: TGLushort) {.importc: "glVertexAttribI4usvEXT", ogl.} - proc glWindowPos2dvARB(v: TGLdouble) {.importc: "glWindowPos2dvARB", ogl.} - proc glBindFramebuffer(target: TGLenum, framebuffer: TGLuint) {.importc: "glBindFramebuffer", ogl.} - proc glGetProgramPipelineivEXT(pipeline: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetProgramPipelineivEXT", ogl.} - proc glProgramUniformHandleui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, values: TGLuint64) {.importc: "glProgramUniformHandleui64vNV", ogl.} - proc glFogCoordhvNV(fog: TGLhalfNV) {.importc: "glFogCoordhvNV", ogl.} - proc glTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTextureImage1DEXT", ogl.} - proc glGetActiveAtomicCounterBufferiv(program: TGLuint, bufferIndex: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetActiveAtomicCounterBufferiv", ogl.} - proc glBeginQueryARB(target: TGLenum, id: TGLuint) {.importc: "glBeginQueryARB", ogl.} - proc glGetTexParameterIuivEXT(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc: "glGetTexParameterIuivEXT", ogl.} - proc glUniform4ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc: "glUniform4ui64vNV", ogl.} - proc glClearAccumxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc: "glClearAccumxOES", ogl.} - proc glFreeObjectBufferATI(buffer: TGLuint) {.importc: "glFreeObjectBufferATI", ogl.} - proc glGetVideouivNV(video_slot: TGLuint, pname: TGLenum, params: TGLuint) {.importc: "glGetVideouivNV", ogl.} - proc glVertexAttribL4ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc: "glVertexAttribL4ui64NV", ogl.} - proc glGetUniformBlockIndex(program: TGLuint, uniformBlockName: TGLchar): TGLuint {.importc: "glGetUniformBlockIndex", ogl.} - proc glCopyMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyMultiTexSubImage2DEXT", ogl.} - proc glVertex3bvOES(coords: TGLbyte) {.importc: "glVertex3bvOES", ogl.} - proc glMultiDrawElementArrayAPPLE(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc: "glMultiDrawElementArrayAPPLE", ogl.} - proc glPrimitiveRestartNV() {.importc: "glPrimitiveRestartNV", ogl.} - proc glMateriali(face: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glMateriali", ogl.} - proc glBegin(mode: TGLenum) {.importc: "glBegin", ogl.} - proc glFogCoordPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glFogCoordPointerEXT", ogl.} - proc glTexCoord1sv(v: TGLshort) {.importc: "glTexCoord1sv", ogl.} - proc glVertexAttribI4sv(index: TGLuint, v: TGLshort) {.importc: "glVertexAttribI4sv", ogl.} - proc glTexEnvx(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glTexEnvx", ogl.} - proc glTexParameterIivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glTexParameterIivEXT", ogl.} - proc glLoadTransposeMatrixfARB(m: TGLfloat) {.importc: "glLoadTransposeMatrixfARB", ogl.} - proc glGetTextureSamplerHandleARB(texture: TGLuint, sampler: TGLuint): TGLuint64 {.importc: "glGetTextureSamplerHandleARB", ogl.} - proc glVertexP3uiv(`type`: TGLenum, value: TGLuint) {.importc: "glVertexP3uiv", ogl.} - proc glProgramUniform2dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glProgramUniform2dv", ogl.} - proc glTexCoord4xvOES(coords: TGLfixed) {.importc: "glTexCoord4xvOES", ogl.} - proc glTexStorage1D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc: "glTexStorage1D", ogl.} - proc glTextureParameterfEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glTextureParameterfEXT", ogl.} - proc glVertexAttrib1d(index: TGLuint, x: TGLdouble) {.importc: "glVertexAttrib1d", ogl.} - proc glGetnPixelMapfvARB(map: TGLenum, bufSize: TGLsizei, values: TGLfloat) {.importc: "glGetnPixelMapfvARB", ogl.} - proc glDisableVertexAttribArray(index: TGLuint) {.importc: "glDisableVertexAttribArray", ogl.} - proc glUniformMatrix4x3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glUniformMatrix4x3dv", ogl.} - proc glRasterPos4f(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glRasterPos4f", ogl.} - proc glProgramUniform1fEXT(program: TGLuint, location: TGLint, v0: TGLfloat) {.importc: "glProgramUniform1fEXT", ogl.} - proc glPathTexGenNV(texCoordSet: TGLenum, genMode: TGLenum, components: TGLint, coeffs: TGLfloat) {.importc: "glPathTexGenNV", ogl.} - proc glUniform3ui(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc: "glUniform3ui", ogl.} - proc glVDPAURegisterOutputSurfaceNV(vdpSurface: pointer, target: TGLenum, numTextureNames: TGLsizei, textureNames: TGLuint): TGLvdpauSurfaceNV {.importc: "glVDPAURegisterOutputSurfaceNV", ogl.} - proc glGetProgramLocalParameterIuivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc: "glGetProgramLocalParameterIuivNV", ogl.} - proc glIsTextureHandleResidentNV(handle: TGLuint64): TGLboolean {.importc: "glIsTextureHandleResidentNV", ogl.} - proc glProgramEnvParameters4fvEXT(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLfloat) {.importc: "glProgramEnvParameters4fvEXT", ogl.} - proc glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", ogl.} - proc glGetMultiTexEnvivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetMultiTexEnvivEXT", ogl.} - proc glGetFloatv(pname: TGLenum, params: TGLfloat) {.importc: "glGetFloatv", ogl.} - proc glInsertEventMarkerEXT(length: TGLsizei, marker: TGLchar) {.importc: "glInsertEventMarkerEXT", ogl.} - proc glRasterPos3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glRasterPos3d", ogl.} - proc glNamedFramebufferRenderbufferEXT(framebuffer: TGLuint, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc: "glNamedFramebufferRenderbufferEXT", ogl.} - proc glGetConvolutionFilter(target: TGLenum, format: TGLenum, `type`: TGLenum, image: pointer) {.importc: "glGetConvolutionFilter", ogl.} - proc glIsOcclusionQueryNV(id: TGLuint): TGLboolean {.importc: "glIsOcclusionQueryNV", ogl.} - proc glGetnPixelMapuivARB(map: TGLenum, bufSize: TGLsizei, values: TGLuint) {.importc: "glGetnPixelMapuivARB", ogl.} - proc glMapParameterfvNV(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glMapParameterfvNV", ogl.} - proc glPushDebugGroup(source: TGLenum, id: TGLuint, length: TGLsizei, message: TGLchar) {.importc: "glPushDebugGroup", ogl.} - proc glMakeImageHandleResidentARB(handle: TGLuint64, access: TGLenum) {.importc: "glMakeImageHandleResidentARB", ogl.} - proc glProgramUniformMatrix2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix2fv", ogl.} - proc glUniform3i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc: "glUniform3i64vNV", ogl.} - proc glImageTransformParameteriHP(target: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glImageTransformParameteriHP", ogl.} - proc glMultiTexCoord1s(target: TGLenum, s: TGLshort) {.importc: "glMultiTexCoord1s", ogl.} - proc glVertexAttribL4dvEXT(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttribL4dvEXT", ogl.} - proc glGetProgramEnvParameterfvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc: "glGetProgramEnvParameterfvARB", ogl.} - proc glVertexArrayColorOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayColorOffsetEXT", ogl.} - proc glGetHistogramParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetHistogramParameterivEXT", ogl.} - proc glGetRenderbufferParameterivOES(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetRenderbufferParameterivOES", ogl.} - proc glGetBufferPointerv(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc: "glGetBufferPointerv", ogl.} - proc glSecondaryColor3ui(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc: "glSecondaryColor3ui", ogl.} - proc glGetDebugMessageLog(count: TGLuint, bufsize: TGLsizei, sources: TGLenum, types: TGLenum, ids: TGLuint, severities: TGLenum, lengths: TGLsizei, messageLog: TGLchar): TGLuint {.importc: "glGetDebugMessageLog", ogl.} - proc glNormal3i(nx: TGLint, ny: TGLint, nz: TGLint) {.importc: "glNormal3i", ogl.} - proc glTestFenceNV(fence: TGLuint): TGLboolean {.importc: "glTestFenceNV", ogl.} - proc glSecondaryColor3usv(v: TGLushort) {.importc: "glSecondaryColor3usv", ogl.} - proc glGenPathsNV(range: TGLsizei): TGLuint {.importc: "glGenPathsNV", ogl.} - proc glDeleteBuffersARB(n: TGLsizei, buffers: TGLuint) {.importc: "glDeleteBuffersARB", ogl.} - proc glProgramUniform4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glProgramUniform4fvEXT", ogl.} - proc glGetSharpenTexFuncSGIS(target: TGLenum, points: TGLfloat) {.importc: "glGetSharpenTexFuncSGIS", ogl.} - proc glDrawMeshArraysSUN(mode: TGLenum, first: TGLint, count: TGLsizei, width: TGLsizei) {.importc: "glDrawMeshArraysSUN", ogl.} - proc glVertexAttribs4hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc: "glVertexAttribs4hvNV", ogl.} - proc glGetClipPlane(plane: TGLenum, equation: TGLdouble) {.importc: "glGetClipPlane", ogl.} - proc glEvalCoord2fv(u: TGLfloat) {.importc: "glEvalCoord2fv", ogl.} - proc glAsyncMarkerSGIX(marker: TGLuint) {.importc: "glAsyncMarkerSGIX", ogl.} - proc glGetSynciv(sync: TGLsync, pname: TGLenum, bufSize: TGLsizei, length: TGLsizei, values: TGLint) {.importc: "glGetSynciv", ogl.} - proc glGetPathTexGenfvNV(texCoordSet: TGLenum, pname: TGLenum, value: TGLfloat) {.importc: "glGetPathTexGenfvNV", ogl.} - proc glTexParameterf(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glTexParameterf", ogl.} - proc glMultiTexCoord1fvARB(target: TGLenum, v: TGLfloat) {.importc: "glMultiTexCoord1fvARB", ogl.} - proc glNormalPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc: "glNormalPointerListIBM", ogl.} - proc glFragmentLightfvSGIX(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glFragmentLightfvSGIX", ogl.} - proc glViewportArrayv(first: TGLuint, count: TGLsizei, v: TGLfloat) {.importc: "glViewportArrayv", ogl.} - proc glNormal3fVertex3fSUN(nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glNormal3fVertex3fSUN", ogl.} - proc glMultiTexCoord2dvARB(target: TGLenum, v: TGLdouble) {.importc: "glMultiTexCoord2dvARB", ogl.} - proc glCopyColorSubTable(target: TGLenum, start: TGLsizei, x: TGLint, y: TGLint, width: TGLsizei) {.importc: "glCopyColorSubTable", ogl.} - proc glTexCoord2hvNV(v: TGLhalfNV) {.importc: "glTexCoord2hvNV", ogl.} - proc glGetQueryObjectiv(id: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetQueryObjectiv", ogl.} - proc glColor4hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV, alpha: TGLhalfNV) {.importc: "glColor4hNV", ogl.} - proc glProgramUniform2fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glProgramUniform2fv", ogl.} - proc glMultiTexCoord4hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV, q: TGLhalfNV) {.importc: "glMultiTexCoord4hNV", ogl.} - proc glWindowPos2fvMESA(v: TGLfloat) {.importc: "glWindowPos2fvMESA", ogl.} - proc glVertexAttrib3s(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc: "glVertexAttrib3s", ogl.} - proc glGetIntegerIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLint) {.importc: "glGetIntegerIndexedvEXT", ogl.} - proc glVertexAttrib4Niv(index: TGLuint, v: TGLint) {.importc: "glVertexAttrib4Niv", ogl.} - proc glProgramLocalParameter4dvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc: "glProgramLocalParameter4dvARB", ogl.} - proc glFramebufferTextureLayerEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc: "glFramebufferTextureLayerEXT", ogl.} - proc glVertexAttribI1ui(index: TGLuint, x: TGLuint) {.importc: "glVertexAttribI1ui", ogl.} - proc glFogCoorddv(coord: TGLdouble) {.importc: "glFogCoorddv", ogl.} - proc glLightModelxv(pname: TGLenum, param: TGLfixed) {.importc: "glLightModelxv", ogl.} - proc glGetCombinerOutputParameterfvNV(stage: TGLenum, portion: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetCombinerOutputParameterfvNV", ogl.} - proc glFramebufferReadBufferEXT(framebuffer: TGLuint, mode: TGLenum) {.importc: "glFramebufferReadBufferEXT", ogl.} - proc glGetActiveUniformsiv(program: TGLuint, uniformCount: TGLsizei, uniformIndices: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetActiveUniformsiv", ogl.} - proc glGetProgramStringNV(id: TGLuint, pname: TGLenum, program: TGLubyte) {.importc: "glGetProgramStringNV", ogl.} - proc glCopyConvolutionFilter2D(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyConvolutionFilter2D", ogl.} - proc glMultiTexCoord3iARB(target: TGLenum, s: TGLint, t: TGLint, r: TGLint) {.importc: "glMultiTexCoord3iARB", ogl.} - proc glPushName(name: TGLuint) {.importc: "glPushName", ogl.} - proc glProgramParameter4dNV(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glProgramParameter4dNV", ogl.} - proc glVertexAttrib4svARB(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib4svARB", ogl.} - proc glSecondaryColor3iv(v: TGLint) {.importc: "glSecondaryColor3iv", ogl.} - proc glCopyColorSubTableEXT(target: TGLenum, start: TGLsizei, x: TGLint, y: TGLint, width: TGLsizei) {.importc: "glCopyColorSubTableEXT", ogl.} - proc glCallList(list: TGLuint) {.importc: "glCallList", ogl.} - proc glGetMultiTexLevelParameterivEXT(texunit: TGLenum, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc: "glGetMultiTexLevelParameterivEXT", ogl.} - proc glProgramUniformMatrix2x4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix2x4fv", ogl.} - proc glTexBumpParameterivATI(pname: TGLenum, param: TGLint) {.importc: "glTexBumpParameterivATI", ogl.} - proc glTexGeni(coord: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glTexGeni", ogl.} - proc glSecondaryColor3dv(v: TGLdouble) {.importc: "glSecondaryColor3dv", ogl.} - proc glGetnUniformdvARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLdouble) {.importc: "glGetnUniformdvARB", ogl.} - proc glGetNamedProgramLocalParameterdvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLdouble) {.importc: "glGetNamedProgramLocalParameterdvEXT", ogl.} - proc glGetVertexAttribPointervARB(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc: "glGetVertexAttribPointervARB", ogl.} - proc glCopyColorTable(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc: "glCopyColorTable", ogl.} - proc glNamedFramebufferTextureLayerEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc: "glNamedFramebufferTextureLayerEXT", ogl.} - proc glLoadProgramNV(target: TGLenum, id: TGLuint, len: TGLsizei, program: TGLubyte) {.importc: "glLoadProgramNV", ogl.} - proc glAlphaFragmentOp2ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint) {.importc: "glAlphaFragmentOp2ATI", ogl.} - proc glBindLightParameterEXT(light: TGLenum, value: TGLenum): TGLuint {.importc: "glBindLightParameterEXT", ogl.} - proc glVertexAttrib1fv(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib1fv", ogl.} - proc glLoadIdentity() {.importc: "glLoadIdentity", ogl.} - proc glFramebufferTexture2DMultisampleEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, samples: TGLsizei) {.importc: "glFramebufferTexture2DMultisampleEXT", ogl.} - proc glVertexAttrib1dvARB(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib1dvARB", ogl.} - proc glDrawRangeElementsBaseVertex(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer, basevertex: TGLint) {.importc: "glDrawRangeElementsBaseVertex", ogl.} - proc glPixelMapfv(map: TGLenum, mapsize: TGLsizei, values: TGLfloat) {.importc: "glPixelMapfv", ogl.} - proc glPointParameterxOES(pname: TGLenum, param: TGLfixed) {.importc: "glPointParameterxOES", ogl.} - proc glBindBufferRangeNV(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc: "glBindBufferRangeNV", ogl.} - proc glDepthBoundsEXT(zmin: TGLclampd, zmax: TGLclampd) {.importc: "glDepthBoundsEXT", ogl.} - proc glProgramUniformMatrix2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix2dv", ogl.} - proc glSecondaryColor3s(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc: "glSecondaryColor3s", ogl.} - proc glEdgeFlagPointerEXT(stride: TGLsizei, count: TGLsizei, `pointer`: TGLboolean) {.importc: "glEdgeFlagPointerEXT", ogl.} - proc glVertexStream1fATI(stream: TGLenum, x: TGLfloat) {.importc: "glVertexStream1fATI", ogl.} - proc glUniformui64NV(location: TGLint, value: TGLuint64EXT) {.importc: "glUniformui64NV", ogl.} - proc glTexCoordP4uiv(`type`: TGLenum, coords: TGLuint) {.importc: "glTexCoordP4uiv", ogl.} - proc glTexCoord3d(s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc: "glTexCoord3d", ogl.} - proc glDeleteProgramPipelines(n: TGLsizei, pipelines: TGLuint) {.importc: "glDeleteProgramPipelines", ogl.} - proc glVertex2iv(v: TGLint) {.importc: "glVertex2iv", ogl.} - proc glGetMultisamplefv(pname: TGLenum, index: TGLuint, val: TGLfloat) {.importc: "glGetMultisamplefv", ogl.} - proc glStartInstrumentsSGIX() {.importc: "glStartInstrumentsSGIX", ogl.} - proc glGetOcclusionQueryivNV(id: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetOcclusionQueryivNV", ogl.} - proc glDebugMessageCallback(callback: TGLDEBUGPROC, userParam: pointer) {.importc: "glDebugMessageCallback", ogl.} - proc glPixelZoomxOES(xfactor: TGLfixed, yfactor: TGLfixed) {.importc: "glPixelZoomxOES", ogl.} - proc glTexCoord3i(s: TGLint, t: TGLint, r: TGLint) {.importc: "glTexCoord3i", ogl.} - proc glEdgeFlagFormatNV(stride: TGLsizei) {.importc: "glEdgeFlagFormatNV", ogl.} - proc glProgramUniform2i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint) {.importc: "glProgramUniform2i", ogl.} - proc glColor3b(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc: "glColor3b", ogl.} - proc glDepthRangefOES(n: TGLclampf, f: TGLclampf) {.importc: "glDepthRangefOES", ogl.} - proc glEndVertexShaderEXT() {.importc: "glEndVertexShaderEXT", ogl.} - proc glBindVertexArrayAPPLE(`array`: TGLuint) {.importc: "glBindVertexArrayAPPLE", ogl.} - proc glColor4bv(v: TGLbyte) {.importc: "glColor4bv", ogl.} - proc glNamedFramebufferTexture2DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glNamedFramebufferTexture2DEXT", ogl.} - proc glTexCoord1f(s: TGLfloat) {.importc: "glTexCoord1f", ogl.} - proc glUniform3fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glUniform3fvARB", ogl.} - proc glGetQueryObjectuivARB(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc: "glGetQueryObjectuivARB", ogl.} - proc glVertexAttrib4bv(index: TGLuint, v: TGLbyte) {.importc: "glVertexAttrib4bv", ogl.} - proc glGetPixelTransformParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetPixelTransformParameterivEXT", ogl.} - proc glVertexAttrib3svNV(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib3svNV", ogl.} - proc glDeleteQueriesEXT(n: TGLsizei, ids: TGLuint) {.importc: "glDeleteQueriesEXT", ogl.} - proc glUniform3ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glUniform3ivARB", ogl.} - proc glNormal3xvOES(coords: TGLfixed) {.importc: "glNormal3xvOES", ogl.} - proc glMatrixLoadfEXT(mode: TGLenum, m: TGLfloat) {.importc: "glMatrixLoadfEXT", ogl.} - proc glGetNamedFramebufferAttachmentParameterivEXT(framebuffer: TGLuint, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetNamedFramebufferAttachmentParameterivEXT", ogl.} - proc glSeparableFilter2D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer) {.importc: "glSeparableFilter2D", ogl.} - proc glVertexAttribI3uiv(index: TGLuint, v: TGLuint) {.importc: "glVertexAttribI3uiv", ogl.} - proc glTextureStorageSparseAMD(texture: TGLuint, target: TGLenum, internalFormat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, layers: TGLsizei, flags: TGLbitfield) {.importc: "glTextureStorageSparseAMD", ogl.} - proc glMultiDrawArraysIndirectCountARB(mode: TGLenum, indirect: TGLintptr, drawcount: TGLintptr, maxdrawcount: TGLsizei, stride: TGLsizei) {.importc: "glMultiDrawArraysIndirectCountARB", ogl.} - proc glTranslated(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glTranslated", ogl.} - proc glColorPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glColorPointer", ogl.} - proc glDrawElementsInstancedBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei, basevertex: TGLint) {.importc: "glDrawElementsInstancedBaseVertex", ogl.} - proc glBindAttribLocationARB(programObj: TGLhandleARB, index: TGLuint, name: TGLcharARB) {.importc: "glBindAttribLocationARB", ogl.} - proc glTexGendv(coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc: "glTexGendv", ogl.} - proc glGetPathCoordsNV(path: TGLuint, coords: TGLfloat) {.importc: "glGetPathCoordsNV", ogl.} - proc glGetMapParameterivNV(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetMapParameterivNV", ogl.} - proc glClientAttribDefaultEXT(mask: TGLbitfield) {.importc: "glClientAttribDefaultEXT", ogl.} - proc glProgramUniformMatrix4x3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix4x3fvEXT", ogl.} - proc glEnable(cap: TGLenum) {.importc: "glEnable", ogl.} - proc glGetVertexAttribPointervNV(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc: "glGetVertexAttribPointervNV", ogl.} - proc glBindMultiTextureEXT(texunit: TGLenum, target: TGLenum, texture: TGLuint) {.importc: "glBindMultiTextureEXT", ogl.} - proc glGetConvolutionParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetConvolutionParameterfvEXT", ogl.} - proc glLightModelxvOES(pname: TGLenum, param: TGLfixed) {.importc: "glLightModelxvOES", ogl.} - proc glMultiTexCoord4sv(target: TGLenum, v: TGLshort) {.importc: "glMultiTexCoord4sv", ogl.} - proc glGetColorTableParameterivSGI(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetColorTableParameterivSGI", ogl.} - proc glFramebufferTexture2DOES(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glFramebufferTexture2DOES", ogl.} - proc glClearDepthxOES(depth: TGLfixed) {.importc: "glClearDepthxOES", ogl.} - proc glDisableClientStateiEXT(`array`: TGLenum, index: TGLuint) {.importc: "glDisableClientStateiEXT", ogl.} - proc glWindowPos2dARB(x: TGLdouble, y: TGLdouble) {.importc: "glWindowPos2dARB", ogl.} - proc glVertexAttrib1fvNV(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib1fvNV", ogl.} - proc glDepthRangedNV(zNear: TGLdouble, zFar: TGLdouble) {.importc: "glDepthRangedNV", ogl.} - proc glClear(mask: TGLbitfield) {.importc: "glClear", ogl.} - proc glUnmapTexture2DINTEL(texture: TGLuint, level: TGLint) {.importc: "glUnmapTexture2DINTEL", ogl.} - proc glSecondaryColor3ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc: "glSecondaryColor3ub", ogl.} - proc glVertexAttribI4bv(index: TGLuint, v: TGLbyte) {.importc: "glVertexAttribI4bv", ogl.} - proc glTexRenderbufferNV(target: TGLenum, renderbuffer: TGLuint) {.importc: "glTexRenderbufferNV", ogl.} - proc glColor4ubVertex3fvSUN(c: TGLubyte, v: TGLfloat) {.importc: "glColor4ubVertex3fvSUN", ogl.} - proc glVertexAttrib2svNV(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib2svNV", ogl.} - proc glMultiTexCoord1ivARB(target: TGLenum, v: TGLint) {.importc: "glMultiTexCoord1ivARB", ogl.} - proc glUniformMatrix3x2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glUniformMatrix3x2dv", ogl.} - proc glVertexAttribL3dvEXT(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttribL3dvEXT", ogl.} - proc glMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glMultiTexSubImage1DEXT", ogl.} - proc glGetBufferPointervARB(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc: "glGetBufferPointervARB", ogl.} - proc glGetMultiTexLevelParameterfvEXT(texunit: TGLenum, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfloat) {.importc: "glGetMultiTexLevelParameterfvEXT", ogl.} - proc glMultiTexParameterIuivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc: "glMultiTexParameterIuivEXT", ogl.} - proc glGetShaderSource(shader: TGLuint, bufSize: TGLsizei, length: TGLsizei, source: TGLchar) {.importc: "glGetShaderSource", ogl.} - proc glStencilFunc(func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc: "glStencilFunc", ogl.} - proc glVertexAttribI4bvEXT(index: TGLuint, v: TGLbyte) {.importc: "glVertexAttribI4bvEXT", ogl.} - proc glVertexAttrib4NuivARB(index: TGLuint, v: TGLuint) {.importc: "glVertexAttrib4NuivARB", ogl.} - proc glIsObjectBufferATI(buffer: TGLuint): TGLboolean {.importc: "glIsObjectBufferATI", ogl.} - proc glRasterPos2xOES(x: TGLfixed, y: TGLfixed) {.importc: "glRasterPos2xOES", ogl.} - proc glIsFenceNV(fence: TGLuint): TGLboolean {.importc: "glIsFenceNV", ogl.} - proc glGetFramebufferParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetFramebufferParameteriv", ogl.} - proc glClearBufferfv(buffer: TGLenum, drawbuffer: TGLint, value: TGLfloat) {.importc: "glClearBufferfv", ogl.} - proc glClearColorxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc: "glClearColorxOES", ogl.} - proc glVertexWeightfEXT(weight: TGLfloat) {.importc: "glVertexWeightfEXT", ogl.} - proc glExtIsProgramBinaryQCOM(program: TGLuint): TGLboolean {.importc: "glExtIsProgramBinaryQCOM", ogl.} - proc glTextureStorage2DMultisampleEXT(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc: "glTextureStorage2DMultisampleEXT", ogl.} - proc glGetHistogramParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetHistogramParameterxvOES", ogl.} - proc glVertexAttrib4dNV(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glVertexAttrib4dNV", ogl.} - proc glGetPerfMonitorCounterStringAMD(group: TGLuint, counter: TGLuint, bufSize: TGLsizei, length: TGLsizei, counterString: TGLchar) {.importc: "glGetPerfMonitorCounterStringAMD", ogl.} - proc glMultiTexCoord2sARB(target: TGLenum, s: TGLshort, t: TGLshort) {.importc: "glMultiTexCoord2sARB", ogl.} - proc glSpriteParameterivSGIX(pname: TGLenum, params: TGLint) {.importc: "glSpriteParameterivSGIX", ogl.} - proc glCompressedTextureImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedTextureImage3DEXT", ogl.} - proc glBufferSubData(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc: "glBufferSubData", ogl.} - proc glBlendParameteriNV(pname: TGLenum, value: TGLint) {.importc: "glBlendParameteriNV", ogl.} - proc glVertexAttrib2fvNV(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib2fvNV", ogl.} - proc glGetVariantBooleanvEXT(id: TGLuint, value: TGLenum, data: TGLboolean) {.importc: "glGetVariantBooleanvEXT", ogl.} - proc glProgramParameteri(program: TGLuint, pname: TGLenum, value: TGLint) {.importc: "glProgramParameteri", ogl.} - proc glGetLocalConstantIntegervEXT(id: TGLuint, value: TGLenum, data: TGLint) {.importc: "glGetLocalConstantIntegervEXT", ogl.} - proc glFragmentMaterialiSGIX(face: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glFragmentMaterialiSGIX", ogl.} - proc glGetNamedStringivARB(namelen: TGLint, name: TGLchar, pname: TGLenum, params: TGLint) {.importc: "glGetNamedStringivARB", ogl.} - proc glBinormal3ivEXT(v: TGLint) {.importc: "glBinormal3ivEXT", ogl.} - proc glCheckFramebufferStatusEXT(target: TGLenum): TGLenum {.importc: "glCheckFramebufferStatusEXT", ogl.} - proc glVertexAttrib1fNV(index: TGLuint, x: TGLfloat) {.importc: "glVertexAttrib1fNV", ogl.} - proc glNamedRenderbufferStorageEXT(renderbuffer: TGLuint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glNamedRenderbufferStorageEXT", ogl.} - proc glPresentFrameKeyedNV(video_slot: TGLuint, minPresentTime: TGLuint64EXT, beginPresentTimeId: TGLuint, presentDurationId: TGLuint, `type`: TGLenum, target0: TGLenum, fill0: TGLuint, key0: TGLuint, target1: TGLenum, fill1: TGLuint, key1: TGLuint) {.importc: "glPresentFrameKeyedNV", ogl.} - proc glGetObjectParameterfvARB(obj: TGLhandleARB, pname: TGLenum, params: TGLfloat) {.importc: "glGetObjectParameterfvARB", ogl.} - proc glVertex3sv(v: TGLshort) {.importc: "glVertex3sv", ogl.} - proc glColor4s(red: TGLshort, green: TGLshort, blue: TGLshort, alpha: TGLshort) {.importc: "glColor4s", ogl.} - proc glGetQueryObjecti64vEXT(id: TGLuint, pname: TGLenum, params: TGLint64) {.importc: "glGetQueryObjecti64vEXT", ogl.} - proc glEvalMesh2(mode: TGLenum, i1: TGLint, i2: TGLint, j1: TGLint, j2: TGLint) {.importc: "glEvalMesh2", ogl.} - proc glBeginTransformFeedbackEXT(primitiveMode: TGLenum) {.importc: "glBeginTransformFeedbackEXT", ogl.} - proc glBufferAddressRangeNV(pname: TGLenum, index: TGLuint, address: TGLuint64EXT, length: TGLsizeiptr) {.importc: "glBufferAddressRangeNV", ogl.} - proc glPointParameterfvARB(pname: TGLenum, params: TGLfloat) {.importc: "glPointParameterfvARB", ogl.} - proc glGetActiveVaryingNV(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLsizei, `type`: TGLenum, name: TGLchar) {.importc: "glGetActiveVaryingNV", ogl.} - proc glIndexMask(mask: TGLuint) {.importc: "glIndexMask", ogl.} - proc glVertexAttribBinding(attribindex: TGLuint, bindingindex: TGLuint) {.importc: "glVertexAttribBinding", ogl.} - proc glDeleteFencesNV(n: TGLsizei, fences: TGLuint) {.importc: "glDeleteFencesNV", ogl.} - proc glVertexAttribI4ubv(index: TGLuint, v: TGLubyte) {.importc: "glVertexAttribI4ubv", ogl.} - proc glPathParameterfvNV(path: TGLuint, pname: TGLenum, value: TGLfloat) {.importc: "glPathParameterfvNV", ogl.} - proc glVertexStream3fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glVertexStream3fATI", ogl.} - proc glVertexAttribs4svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc: "glVertexAttribs4svNV", ogl.} - proc glVertexAttrib4sNV(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc: "glVertexAttrib4sNV", ogl.} - proc glAlphaFragmentOp3ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint, arg3: TGLuint, arg3Rep: TGLuint, arg3Mod: TGLuint) {.importc: "glAlphaFragmentOp3ATI", ogl.} - proc glGetHistogramParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetHistogramParameterfv", ogl.} - proc glVertexAttribL1ui64NV(index: TGLuint, x: TGLuint64EXT) {.importc: "glVertexAttribL1ui64NV", ogl.} - proc glVertexAttribs3fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc: "glVertexAttribs3fvNV", ogl.} - proc glMultiTexCoord3ivARB(target: TGLenum, v: TGLint) {.importc: "glMultiTexCoord3ivARB", ogl.} - proc glClipPlanefOES(plane: TGLenum, equation: TGLfloat) {.importc: "glClipPlanefOES", ogl.} - proc glVertex3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc: "glVertex3s", ogl.} - proc glVertex3dv(v: TGLdouble) {.importc: "glVertex3dv", ogl.} - proc glWeightPointerOES(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glWeightPointerOES", ogl.} - proc glBindBufferBase(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc: "glBindBufferBase", ogl.} - proc glIndexs(c: TGLshort) {.importc: "glIndexs", ogl.} - proc glTessellationFactorAMD(factor: TGLfloat) {.importc: "glTessellationFactorAMD", ogl.} - proc glColor4ubVertex3fSUN(r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glColor4ubVertex3fSUN", ogl.} - proc glPauseTransformFeedback() {.importc: "glPauseTransformFeedback", ogl.} - proc glImageTransformParameterivHP(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glImageTransformParameterivHP", ogl.} - proc glColor3dv(v: TGLdouble) {.importc: "glColor3dv", ogl.} - proc glRasterPos4sv(v: TGLshort) {.importc: "glRasterPos4sv", ogl.} - proc glInvalidateTexSubImage(texture: TGLuint, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc: "glInvalidateTexSubImage", ogl.} - proc glNormalStream3bvATI(stream: TGLenum, coords: TGLbyte) {.importc: "glNormalStream3bvATI", ogl.} - proc glUniformMatrix2x4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix2x4fv", ogl.} - proc glMinmax(target: TGLenum, internalformat: TGLenum, sink: TGLboolean) {.importc: "glMinmax", ogl.} - proc glGetProgramStageiv(program: TGLuint, shadertype: TGLenum, pname: TGLenum, values: TGLint) {.importc: "glGetProgramStageiv", ogl.} - proc glScalex(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc: "glScalex", ogl.} - proc glTexBufferARB(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc: "glTexBufferARB", ogl.} - proc glDrawArraysIndirect(mode: TGLenum, indirect: pointer) {.importc: "glDrawArraysIndirect", ogl.} - proc glMatrixLoadTransposefEXT(mode: TGLenum, m: TGLfloat) {.importc: "glMatrixLoadTransposefEXT", ogl.} - proc glMultiTexCoord2f(target: TGLenum, s: TGLfloat, t: TGLfloat) {.importc: "glMultiTexCoord2f", ogl.} - proc glDrawRangeElements(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc: "glDrawRangeElements", ogl.} - proc glVertexAttrib4NubARB(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc: "glVertexAttrib4NubARB", ogl.} - proc glMultiTexCoord4xvOES(texture: TGLenum, coords: TGLfixed) {.importc: "glMultiTexCoord4xvOES", ogl.} - proc glVertexArrayVertexAttribOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayVertexAttribOffsetEXT", ogl.} - proc glVertexAttribL1i64vNV(index: TGLuint, v: TGLint64EXT) {.importc: "glVertexAttribL1i64vNV", ogl.} - proc glMapBuffer(target: TGLenum, access: TGLenum) {.importc: "glMapBuffer", ogl.} - proc glUniform1ui(location: TGLint, v0: TGLuint) {.importc: "glUniform1ui", ogl.} - proc glGetPixelMapfv(map: TGLenum, values: TGLfloat) {.importc: "glGetPixelMapfv", ogl.} - proc glTexImage2DMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc: "glTexImage2DMultisampleCoverageNV", ogl.} - proc glUniform2ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glUniform2ivARB", ogl.} - proc glVertexAttribI3ui(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint) {.importc: "glVertexAttribI3ui", ogl.} - proc glGetProgramResourceiv(program: TGLuint, programInterface: TGLenum, index: TGLuint, propCount: TGLsizei, props: TGLenum, bufSize: TGLsizei, length: TGLsizei, params: TGLint) {.importc: "glGetProgramResourceiv", ogl.} - proc glUniform4iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glUniform4iv", ogl.} - proc glVertexAttrib3f(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glVertexAttrib3f", ogl.} - proc glClientActiveVertexStreamATI(stream: TGLenum) {.importc: "glClientActiveVertexStreamATI", ogl.} - proc glTexCoord4fColor4fNormal3fVertex4fvSUN(tc: TGLfloat, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc: "glTexCoord4fColor4fNormal3fVertex4fvSUN", ogl.} - proc glColor3xvOES(components: TGLfixed) {.importc: "glColor3xvOES", ogl.} - proc glVertexPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc: "glVertexPointerListIBM", ogl.} - proc glProgramEnvParameter4dARB(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glProgramEnvParameter4dARB", ogl.} - proc glGetLocalConstantFloatvEXT(id: TGLuint, value: TGLenum, data: TGLfloat) {.importc: "glGetLocalConstantFloatvEXT", ogl.} - proc glTexCoordPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc: "glTexCoordPointerEXT", ogl.} - proc glTexCoordPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc: "glTexCoordPointervINTEL", ogl.} - proc glSelectPerfMonitorCountersAMD(monitor: TGLuint, enable: TGLboolean, group: TGLuint, numCounters: TGLint, counterList: TGLuint) {.importc: "glSelectPerfMonitorCountersAMD", ogl.} - proc glVertexStream4svATI(stream: TGLenum, coords: TGLshort) {.importc: "glVertexStream4svATI", ogl.} - proc glColor3ui(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc: "glColor3ui", ogl.} - proc glBindTransformFeedbackNV(target: TGLenum, id: TGLuint) {.importc: "glBindTransformFeedbackNV", ogl.} - proc glDeformSGIX(mask: TGLbitfield) {.importc: "glDeformSGIX", ogl.} - proc glDeformationMap3fSGIX(target: TGLenum, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, w1: TGLfloat, w2: TGLfloat, wstride: TGLint, worder: TGLint, points: TGLfloat) {.importc: "glDeformationMap3fSGIX", ogl.} - proc glNamedBufferSubDataEXT(buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc: "glNamedBufferSubDataEXT", ogl.} - proc glGetNamedProgramStringEXT(program: TGLuint, target: TGLenum, pname: TGLenum, string: pointer) {.importc: "glGetNamedProgramStringEXT", ogl.} - proc glCopyPathNV(resultPath: TGLuint, srcPath: TGLuint) {.importc: "glCopyPathNV", ogl.} - proc glMapControlPointsNV(target: TGLenum, index: TGLuint, `type`: TGLenum, ustride: TGLsizei, vstride: TGLsizei, uorder: TGLint, vorder: TGLint, packed: TGLboolean, points: pointer) {.importc: "glMapControlPointsNV", ogl.} - proc glGetBufferParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetBufferParameteriv", ogl.} - proc glUnmapObjectBufferATI(buffer: TGLuint) {.importc: "glUnmapObjectBufferATI", ogl.} - proc glGetProgramResourceLocation(program: TGLuint, programInterface: TGLenum, name: TGLchar): TGLint {.importc: "glGetProgramResourceLocation", ogl.} - proc glUniform4i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc: "glUniform4i64vNV", ogl.} - proc glImageTransformParameterfHP(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glImageTransformParameterfHP", ogl.} - proc glArrayObjectATI(`array`: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc: "glArrayObjectATI", ogl.} - proc glBindBufferRangeEXT(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc: "glBindBufferRangeEXT", ogl.} - proc glVertexArrayVertexAttribFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, relativeoffset: TGLuint) {.importc: "glVertexArrayVertexAttribFormatEXT", ogl.} - proc glBindRenderbufferEXT(target: TGLenum, renderbuffer: TGLuint) {.importc: "glBindRenderbufferEXT", ogl.} - proc glListParameteriSGIX(list: TGLuint, pname: TGLenum, param: TGLint) {.importc: "glListParameteriSGIX", ogl.} - proc glProgramUniformMatrix2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix2dvEXT", ogl.} - proc glProgramUniform2i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc: "glProgramUniform2i64vNV", ogl.} - proc glObjectPtrLabelKHR(`ptr`: pointer, length: TGLsizei, label: TGLchar) {.importc: "glObjectPtrLabelKHR", ogl.} - proc glVertexAttribL1i64NV(index: TGLuint, x: TGLint64EXT) {.importc: "glVertexAttribL1i64NV", ogl.} - proc glMultiTexBufferEXT(texunit: TGLenum, target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc: "glMultiTexBufferEXT", ogl.} - proc glCoverFillPathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, coverMode: TGLenum, transformType: TGLenum, transformValues: TGLfloat) {.importc: "glCoverFillPathInstancedNV", ogl.} - proc glGetVertexAttribIivEXT(index: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetVertexAttribIivEXT", ogl.} - proc glLightf(light: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glLightf", ogl.} - proc glGetMinmaxParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetMinmaxParameterfvEXT", ogl.} - proc glUniform1d(location: TGLint, x: TGLdouble) {.importc: "glUniform1d", ogl.} - proc glLightiv(light: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glLightiv", ogl.} - proc glVertexAttrib2dvNV(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib2dvNV", ogl.} - proc glNormalP3ui(`type`: TGLenum, coords: TGLuint) {.importc: "glNormalP3ui", ogl.} - proc glFinalCombinerInputNV(variable: TGLenum, input: TGLenum, mapping: TGLenum, componentUsage: TGLenum) {.importc: "glFinalCombinerInputNV", ogl.} - proc glUniform1uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glUniform1uiv", ogl.} - proc glValidateProgramARB(programObj: TGLhandleARB) {.importc: "glValidateProgramARB", ogl.} - proc glNormalPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glNormalPointer", ogl.} - proc glProgramNamedParameter4fvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, v: TGLfloat) {.importc: "glProgramNamedParameter4fvNV", ogl.} - proc glGetBooleanv(pname: TGLenum, params: TGLboolean) {.importc: "glGetBooleanv", ogl.} - proc glTangent3ivEXT(v: TGLint) {.importc: "glTangent3ivEXT", ogl.} - proc glTexImage3DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc: "glTexImage3DMultisample", ogl.} - proc glGetUniformIndices(program: TGLuint, uniformCount: TGLsizei, uniformNames: ptr TGLchar, uniformIndices: TGLuint) {.importc: "glGetUniformIndices", ogl.} - proc glVDPAUInitNV(vdpDevice: pointer, getProcAddress: pointer) {.importc: "glVDPAUInitNV", ogl.} - proc glGetMinmaxParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetMinmaxParameterivEXT", ogl.} - proc glMultiTexCoord2fvARB(target: TGLenum, v: TGLfloat) {.importc: "glMultiTexCoord2fvARB", ogl.} - proc glProgramEnvParametersI4ivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLint) {.importc: "glProgramEnvParametersI4ivNV", ogl.} - proc glClearTexSubImage(texture: TGLuint, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc: "glClearTexSubImage", ogl.} - proc glRectxOES(x1: TGLfixed, y1: TGLfixed, x2: TGLfixed, y2: TGLfixed) {.importc: "glRectxOES", ogl.} - proc glBlendEquationOES(mode: TGLenum) {.importc: "glBlendEquationOES", ogl.} - proc glFramebufferTexture(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glFramebufferTexture", ogl.} - proc glGetInstrumentsSGIX(): TGLint {.importc: "glGetInstrumentsSGIX", ogl.} - proc glFramebufferParameteri(target: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glFramebufferParameteri", ogl.} - proc glPathCoverDepthFuncNV(func: TGLenum) {.importc: "glPathCoverDepthFuncNV", ogl.} - proc glGetTranslatedShaderSourceANGLE(shader: TGLuint, bufsize: TGLsizei, length: TGLsizei, source: TGLchar) {.importc: "glGetTranslatedShaderSourceANGLE", ogl.} - proc glIndexfv(c: TGLfloat) {.importc: "glIndexfv", ogl.} - proc glGetActiveUniformBlockName(program: TGLuint, uniformBlockIndex: TGLuint, bufSize: TGLsizei, length: TGLsizei, uniformBlockName: TGLchar) {.importc: "glGetActiveUniformBlockName", ogl.} - proc glNormal3s(nx: TGLshort, ny: TGLshort, nz: TGLshort) {.importc: "glNormal3s", ogl.} - proc glColorFragmentOp3ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint, arg3: TGLuint, arg3Rep: TGLuint, arg3Mod: TGLuint) {.importc: "glColorFragmentOp3ATI", ogl.} - proc glGetProgramResourceLocationIndex(program: TGLuint, programInterface: TGLenum, name: TGLchar): TGLint {.importc: "glGetProgramResourceLocationIndex", ogl.} - proc glGetBooleanIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLboolean) {.importc: "glGetBooleanIndexedvEXT", ogl.} - proc glGenPerfMonitorsAMD(n: TGLsizei, monitors: TGLuint) {.importc: "glGenPerfMonitorsAMD", ogl.} - proc glDrawRangeElementsEXT(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc: "glDrawRangeElementsEXT", ogl.} - proc glFramebufferTexture3D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc: "glFramebufferTexture3D", ogl.} - proc glGetTexParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetTexParameterxvOES", ogl.} - proc glCompileShaderIncludeARB(shader: TGLuint, count: TGLsizei, path: ptr TGLchar, length: TGLint) {.importc: "glCompileShaderIncludeARB", ogl.} - proc glGetMultiTexParameterfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetMultiTexParameterfvEXT", ogl.} - proc glEvalPoint2(i: TGLint, j: TGLint) {.importc: "glEvalPoint2", ogl.} - proc glGetProgramivNV(id: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetProgramivNV", ogl.} - proc glProgramParameter4fNV(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glProgramParameter4fNV", ogl.} - proc glMultiTexParameterfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glMultiTexParameterfvEXT", ogl.} - proc glVertexAttrib3svARB(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib3svARB", ogl.} - proc glDrawElementArrayAPPLE(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc: "glDrawElementArrayAPPLE", ogl.} - proc glMultiTexCoord4x(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc: "glMultiTexCoord4x", ogl.} - proc glUniformMatrix3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glUniformMatrix3dv", ogl.} - proc glVertexAttribPointerARB(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, `pointer`: pointer) {.importc: "glVertexAttribPointerARB", ogl.} - proc glProgramUniformMatrix3x4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix3x4dv", ogl.} - proc glGetFloati_vEXT(pname: TGLenum, index: TGLuint, params: TGLfloat) {.importc: "glGetFloati_vEXT", ogl.} - proc glGetObjectParameterivAPPLE(objectType: TGLenum, name: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetObjectParameterivAPPLE", ogl.} - proc glPushGroupMarkerEXT(length: TGLsizei, marker: TGLchar) {.importc: "glPushGroupMarkerEXT", ogl.} - proc glProgramUniform4uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glProgramUniform4uivEXT", ogl.} - proc glReplacementCodeuiVertex3fSUN(rc: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glReplacementCodeuiVertex3fSUN", ogl.} - proc glTexSubImage1DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexSubImage1DEXT", ogl.} - proc glProgramUniform1uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glProgramUniform1uivEXT", ogl.} - proc glGetFenceivNV(fence: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetFenceivNV", ogl.} - proc glGetnCompressedTexImageARB(target: TGLenum, lod: TGLint, bufSize: TGLsizei, img: pointer) {.importc: "glGetnCompressedTexImageARB", ogl.} - proc glTexGenfOES(coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glTexGenfOES", ogl.} - proc glVertexAttrib4dv(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib4dv", ogl.} - proc glVertexAttribL1ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc: "glVertexAttribL1ui64vNV", ogl.} - proc glVertexAttrib4fvARB(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib4fvARB", ogl.} - proc glDeleteVertexArraysOES(n: TGLsizei, arrays: TGLuint) {.importc: "glDeleteVertexArraysOES", ogl.} - proc glSamplerParameterIiv(sampler: TGLuint, pname: TGLenum, param: TGLint) {.importc: "glSamplerParameterIiv", ogl.} - proc glMapGrid1d(un: TGLint, u1: TGLdouble, u2: TGLdouble) {.importc: "glMapGrid1d", ogl.} - proc glTranslatexOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc: "glTranslatexOES", ogl.} - proc glCullFace(mode: TGLenum) {.importc: "glCullFace", ogl.} - proc glPrioritizeTextures(n: TGLsizei, textures: TGLuint, priorities: TGLfloat) {.importc: "glPrioritizeTextures", ogl.} - proc glGetSeparableFilterEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer, span: pointer) {.importc: "glGetSeparableFilterEXT", ogl.} - proc glVertexAttrib4NubvARB(index: TGLuint, v: TGLubyte) {.importc: "glVertexAttrib4NubvARB", ogl.} - proc glGetTransformFeedbackVaryingNV(program: TGLuint, index: TGLuint, location: TGLint) {.importc: "glGetTransformFeedbackVaryingNV", ogl.} - proc glTexCoord4xOES(s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc: "glTexCoord4xOES", ogl.} - proc glGetProgramEnvParameterdvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc: "glGetProgramEnvParameterdvARB", ogl.} - proc glWindowPos2ivMESA(v: TGLint) {.importc: "glWindowPos2ivMESA", ogl.} - proc glGlobalAlphaFactorfSUN(factor: TGLfloat) {.importc: "glGlobalAlphaFactorfSUN", ogl.} - proc glNormalStream3fvATI(stream: TGLenum, coords: TGLfloat) {.importc: "glNormalStream3fvATI", ogl.} - proc glRasterPos4i(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc: "glRasterPos4i", ogl.} - proc glReleaseShaderCompiler() {.importc: "glReleaseShaderCompiler", ogl.} - proc glProgramUniformMatrix4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glProgramUniformMatrix4fvEXT", ogl.} - proc glCopyMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc: "glCopyMultiTexImage1DEXT", ogl.} - proc glColorTableParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glColorTableParameterfv", ogl.} - proc glSecondaryColor3bvEXT(v: TGLbyte) {.importc: "glSecondaryColor3bvEXT", ogl.} - proc glMap1xOES(target: TGLenum, u1: TGLfixed, u2: TGLfixed, stride: TGLint, order: TGLint, points: TGLfixed) {.importc: "glMap1xOES", ogl.} - proc glVertexStream1svATI(stream: TGLenum, coords: TGLshort) {.importc: "glVertexStream1svATI", ogl.} - proc glIsRenderbuffer(renderbuffer: TGLuint): TGLboolean {.importc: "glIsRenderbuffer", ogl.} - proc glPatchParameterfv(pname: TGLenum, values: TGLfloat) {.importc: "glPatchParameterfv", ogl.} - proc glProgramUniformMatrix4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix4dvEXT", ogl.} - proc glVertexAttrib4ubNV(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc: "glVertexAttrib4ubNV", ogl.} - proc glVertex2i(x: TGLint, y: TGLint) {.importc: "glVertex2i", ogl.} - proc glPushClientAttrib(mask: TGLbitfield) {.importc: "glPushClientAttrib", ogl.} - proc glDrawArraysEXT(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc: "glDrawArraysEXT", ogl.} - proc glCreateProgram(): TGLuint {.importc: "glCreateProgram", ogl.} - proc glPolygonStipple(mask: TGLubyte) {.importc: "glPolygonStipple", ogl.} - proc glGetColorTableEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, data: pointer) {.importc: "glGetColorTableEXT", ogl.} - proc glSharpenTexFuncSGIS(target: TGLenum, n: TGLsizei, points: TGLfloat) {.importc: "glSharpenTexFuncSGIS", ogl.} - proc glNamedFramebufferTextureEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc: "glNamedFramebufferTextureEXT", ogl.} - proc glWindowPos3fvMESA(v: TGLfloat) {.importc: "glWindowPos3fvMESA", ogl.} - proc glBinormal3iEXT(bx: TGLint, by: TGLint, bz: TGLint) {.importc: "glBinormal3iEXT", ogl.} - proc glEnableClientStateiEXT(`array`: TGLenum, index: TGLuint) {.importc: "glEnableClientStateiEXT", ogl.} - proc glProgramUniform3iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glProgramUniform3iv", ogl.} - proc glProgramUniform1dEXT(program: TGLuint, location: TGLint, x: TGLdouble) {.importc: "glProgramUniform1dEXT", ogl.} - proc glPollInstrumentsSGIX(marker_p: TGLint): TGLint {.importc: "glPollInstrumentsSGIX", ogl.} - proc glSecondaryColor3f(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc: "glSecondaryColor3f", ogl.} - proc glDeleteTransformFeedbacks(n: TGLsizei, ids: TGLuint) {.importc: "glDeleteTransformFeedbacks", ogl.} - proc glCoverStrokePathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, coverMode: TGLenum, transformType: TGLenum, transformValues: TGLfloat) {.importc: "glCoverStrokePathInstancedNV", ogl.} - proc glIsTextureHandleResidentARB(handle: TGLuint64): TGLboolean {.importc: "glIsTextureHandleResidentARB", ogl.} - proc glVariantsvEXT(id: TGLuint, `addr`: TGLshort) {.importc: "glVariantsvEXT", ogl.} - proc glTexCoordFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc: "glTexCoordFormatNV", ogl.} - proc glTexStorage3DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc: "glTexStorage3DEXT", ogl.} - proc glUniform2ui(location: TGLint, v0: TGLuint, v1: TGLuint) {.importc: "glUniform2ui", ogl.} - proc glReplacementCodePointerSUN(`type`: TGLenum, stride: TGLsizei, `pointer`: ptr pointer) {.importc: "glReplacementCodePointerSUN", ogl.} - proc glFramebufferTextureLayerARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc: "glFramebufferTextureLayerARB", ogl.} - proc glBinormal3dvEXT(v: TGLdouble) {.importc: "glBinormal3dvEXT", ogl.} - proc glProgramUniform2ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc: "glProgramUniform2ui64vNV", ogl.} - proc glGetnConvolutionFilterARB(target: TGLenum, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, image: pointer) {.importc: "glGetnConvolutionFilterARB", ogl.} - proc glStopInstrumentsSGIX(marker: TGLint) {.importc: "glStopInstrumentsSGIX", ogl.} - proc glVertexAttrib1svNV(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib1svNV", ogl.} - proc glVertexAttribs2fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc: "glVertexAttribs2fvNV", ogl.} - proc glGetInternalformativ(target: TGLenum, internalformat: TGLenum, pname: TGLenum, bufSize: TGLsizei, params: TGLint) {.importc: "glGetInternalformativ", ogl.} - proc glIsProgramPipelineEXT(pipeline: TGLuint): TGLboolean {.importc: "glIsProgramPipelineEXT", ogl.} - proc glMatrixIndexubvARB(size: TGLint, indices: TGLubyte) {.importc: "glMatrixIndexubvARB", ogl.} - proc glTexCoord4bOES(s: TGLbyte, t: TGLbyte, r: TGLbyte, q: TGLbyte) {.importc: "glTexCoord4bOES", ogl.} - proc glSecondaryColor3us(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc: "glSecondaryColor3us", ogl.} - proc glGlobalAlphaFactorubSUN(factor: TGLubyte) {.importc: "glGlobalAlphaFactorubSUN", ogl.} - proc glNamedStringARB(`type`: TGLenum, namelen: TGLint, name: TGLchar, stringlen: TGLint, string: TGLchar) {.importc: "glNamedStringARB", ogl.} - proc glGetAttachedShaders(program: TGLuint, maxCount: TGLsizei, count: TGLsizei, shaders: TGLuint) {.importc: "glGetAttachedShaders", ogl.} - proc glMatrixRotatefEXT(mode: TGLenum, angle: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glMatrixRotatefEXT", ogl.} - proc glVertexStream3ivATI(stream: TGLenum, coords: TGLint) {.importc: "glVertexStream3ivATI", ogl.} - proc glMatrixIndexuivARB(size: TGLint, indices: TGLuint) {.importc: "glMatrixIndexuivARB", ogl.} - proc glMatrixRotatedEXT(mode: TGLenum, angle: TGLdouble, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glMatrixRotatedEXT", ogl.} - proc glPathFogGenNV(genMode: TGLenum) {.importc: "glPathFogGenNV", ogl.} - proc glMultiTexCoord4hvNV(target: TGLenum, v: TGLhalfNV) {.importc: "glMultiTexCoord4hvNV", ogl.} - proc glVertexAttribIPointer(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glVertexAttribIPointer", ogl.} - proc glMultiTexCoord3bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte, r: TGLbyte) {.importc: "glMultiTexCoord3bOES", ogl.} - proc glResizeBuffersMESA() {.importc: "glResizeBuffersMESA", ogl.} - proc glPrimitiveRestartIndexNV(index: TGLuint) {.importc: "glPrimitiveRestartIndexNV", ogl.} - proc glProgramUniform4f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc: "glProgramUniform4f", ogl.} - proc glColor4ubVertex2fSUN(r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat) {.importc: "glColor4ubVertex2fSUN", ogl.} - proc glGetColorTableParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetColorTableParameterivEXT", ogl.} - proc glDepthRangef(n: TGLfloat, f: TGLfloat) {.importc: "glDepthRangef", ogl.} - proc glVertexArrayVertexOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayVertexOffsetEXT", ogl.} - proc glMatrixLoaddEXT(mode: TGLenum, m: TGLdouble) {.importc: "glMatrixLoaddEXT", ogl.} - proc glVariantfvEXT(id: TGLuint, `addr`: TGLfloat) {.importc: "glVariantfvEXT", ogl.} - proc glReplacementCodeuiTexCoord2fVertex3fvSUN(rc: TGLuint, tc: TGLfloat, v: TGLfloat) {.importc: "glReplacementCodeuiTexCoord2fVertex3fvSUN", ogl.} - proc glSamplePatternSGIS(pattern: TGLenum) {.importc: "glSamplePatternSGIS", ogl.} - proc glProgramUniform3i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc: "glProgramUniform3i64NV", ogl.} - proc glUniform3uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glUniform3uivEXT", ogl.} - proc glGetImageTransformParameterivHP(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetImageTransformParameterivHP", ogl.} - proc glPopMatrix() {.importc: "glPopMatrix", ogl.} - proc glVertexAttrib3sARB(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc: "glVertexAttrib3sARB", ogl.} - proc glGenQueriesEXT(n: TGLsizei, ids: TGLuint) {.importc: "glGenQueriesEXT", ogl.} - proc glGetQueryObjectui64v(id: TGLuint, pname: TGLenum, params: TGLuint64) {.importc: "glGetQueryObjectui64v", ogl.} - proc glWeightusvARB(size: TGLint, weights: TGLushort) {.importc: "glWeightusvARB", ogl.} - proc glWindowPos2sARB(x: TGLshort, y: TGLshort) {.importc: "glWindowPos2sARB", ogl.} - proc glGetTextureLevelParameterivEXT(texture: TGLuint, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc: "glGetTextureLevelParameterivEXT", ogl.} - proc glBufferParameteriAPPLE(target: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glBufferParameteriAPPLE", ogl.} - proc glMultiModeDrawArraysIBM(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei, modestride: TGLint) {.importc: "glMultiModeDrawArraysIBM", ogl.} - proc glUniformMatrix2x3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc: "glUniformMatrix2x3fv", ogl.} - proc glTangentPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glTangentPointerEXT", ogl.} - proc glResetMinmax(target: TGLenum) {.importc: "glResetMinmax", ogl.} - proc glVertexAttribP1uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc: "glVertexAttribP1uiv", ogl.} - proc glPixelMapx(map: TGLenum, size: TGLint, values: TGLfixed) {.importc: "glPixelMapx", ogl.} - proc glPixelStoref(pname: TGLenum, param: TGLfloat) {.importc: "glPixelStoref", ogl.} - proc glBinormal3dEXT(bx: TGLdouble, by: TGLdouble, bz: TGLdouble) {.importc: "glBinormal3dEXT", ogl.} - proc glVertexAttribs1hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc: "glVertexAttribs1hvNV", ogl.} - proc glVertexAttrib4usvARB(index: TGLuint, v: TGLushort) {.importc: "glVertexAttrib4usvARB", ogl.} - proc glUnmapBuffer(target: TGLenum): TGLboolean {.importc: "glUnmapBuffer", ogl.} - proc glFlushRasterSGIX() {.importc: "glFlushRasterSGIX", ogl.} - proc glColor3uiv(v: TGLuint) {.importc: "glColor3uiv", ogl.} - proc glInvalidateBufferSubData(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr) {.importc: "glInvalidateBufferSubData", ogl.} - proc glPassThroughxOES(token: TGLfixed) {.importc: "glPassThroughxOES", ogl.} - proc glLockArraysEXT(first: TGLint, count: TGLsizei) {.importc: "glLockArraysEXT", ogl.} - proc glStencilFuncSeparateATI(frontfunc: TGLenum, backfunc: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc: "glStencilFuncSeparateATI", ogl.} - proc glProgramUniform3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glProgramUniform3dvEXT", ogl.} - proc glGenTransformFeedbacks(n: TGLsizei, ids: TGLuint) {.importc: "glGenTransformFeedbacks", ogl.} - proc glCopyTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyTexSubImage3DOES", ogl.} - proc glIsNamedBufferResidentNV(buffer: TGLuint): TGLboolean {.importc: "glIsNamedBufferResidentNV", ogl.} - proc glSampleMaskIndexedNV(index: TGLuint, mask: TGLbitfield) {.importc: "glSampleMaskIndexedNV", ogl.} - proc glVDPAUSurfaceAccessNV(surface: TGLvdpauSurfaceNV, access: TGLenum) {.importc: "glVDPAUSurfaceAccessNV", ogl.} - proc glProgramUniform3dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc: "glProgramUniform3dv", ogl.} - proc glDeleteProgram(program: TGLuint) {.importc: "glDeleteProgram", ogl.} - proc glConvolutionFilter1D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc: "glConvolutionFilter1D", ogl.} - proc glVertex2f(x: TGLfloat, y: TGLfloat) {.importc: "glVertex2f", ogl.} - proc glWindowPos4dvMESA(v: TGLdouble) {.importc: "glWindowPos4dvMESA", ogl.} - proc glColor4us(red: TGLushort, green: TGLushort, blue: TGLushort, alpha: TGLushort) {.importc: "glColor4us", ogl.} - proc glColorMask(red: TGLboolean, green: TGLboolean, blue: TGLboolean, alpha: TGLboolean) {.importc: "glColorMask", ogl.} - proc glGetTexEnviv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetTexEnviv", ogl.} - proc glProgramUniform3ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glProgramUniform3ivEXT", ogl.} - proc glSecondaryColor3i(red: TGLint, green: TGLint, blue: TGLint) {.importc: "glSecondaryColor3i", ogl.} - proc glGetSamplerParameteriv(sampler: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetSamplerParameteriv", ogl.} - proc glDeleteFramebuffersEXT(n: TGLsizei, framebuffers: TGLuint) {.importc: "glDeleteFramebuffersEXT", ogl.} - proc glCompressedTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexSubImage3D", ogl.} - proc glVertex2s(x: TGLshort, y: TGLshort) {.importc: "glVertex2s", ogl.} - proc glIsQuery(id: TGLuint): TGLboolean {.importc: "glIsQuery", ogl.} - proc glFogxv(pname: TGLenum, param: TGLfixed) {.importc: "glFogxv", ogl.} - proc glAreProgramsResidentNV(n: TGLsizei, programs: TGLuint, residences: TGLboolean): TGLboolean {.importc: "glAreProgramsResidentNV", ogl.} - proc glShaderSourceARB(shaderObj: TGLhandleARB, count: TGLsizei, string: ptr TGLcharARB, length: TGLint) {.importc: "glShaderSourceARB", ogl.} - proc glPointSizexOES(size: TGLfixed) {.importc: "glPointSizexOES", ogl.} - proc glPixelTransferf(pname: TGLenum, param: TGLfloat) {.importc: "glPixelTransferf", ogl.} - proc glExtractComponentEXT(res: TGLuint, src: TGLuint, num: TGLuint) {.importc: "glExtractComponentEXT", ogl.} - proc glUniform1fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glUniform1fv", ogl.} - proc glGetNamedStringARB(namelen: TGLint, name: TGLchar, bufSize: TGLsizei, stringlen: TGLint, string: TGLchar) {.importc: "glGetNamedStringARB", ogl.} - proc glGetProgramBinaryOES(program: TGLuint, bufSize: TGLsizei, length: TGLsizei, binaryFormat: TGLenum, binary: pointer) {.importc: "glGetProgramBinaryOES", ogl.} - proc glDeleteOcclusionQueriesNV(n: TGLsizei, ids: TGLuint) {.importc: "glDeleteOcclusionQueriesNV", ogl.} - proc glEnableClientState(`array`: TGLenum) {.importc: "glEnableClientState", ogl.} - proc glProgramBufferParametersIuivNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: TGLuint) {.importc: "glProgramBufferParametersIuivNV", ogl.} - proc glProgramUniform2ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint) {.importc: "glProgramUniform2ui", ogl.} - proc glReplacementCodeuiSUN(code: TGLuint) {.importc: "glReplacementCodeuiSUN", ogl.} - proc glMultMatrixd(m: TGLdouble) {.importc: "glMultMatrixd", ogl.} - proc glInvalidateSubFramebuffer(target: TGLenum, numAttachments: TGLsizei, attachments: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glInvalidateSubFramebuffer", ogl.} - proc glGenerateMultiTexMipmapEXT(texunit: TGLenum, target: TGLenum) {.importc: "glGenerateMultiTexMipmapEXT", ogl.} - proc glDepthRangex(n: TGLfixed, f: TGLfixed) {.importc: "glDepthRangex", ogl.} - proc glGetInteger64i_v(target: TGLenum, index: TGLuint, data: TGLint64) {.importc: "glGetInteger64i_v", ogl.} - proc glDrawBuffers(n: TGLsizei, bufs: TGLenum) {.importc: "glDrawBuffers", ogl.} - proc glGetPointervEXT(pname: TGLenum, params: ptr pointer) {.importc: "glGetPointervEXT", ogl.} - proc glFogxvOES(pname: TGLenum, param: TGLfixed) {.importc: "glFogxvOES", ogl.} - proc glTexCoordP2uiv(`type`: TGLenum, coords: TGLuint) {.importc: "glTexCoordP2uiv", ogl.} - proc glVertexFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc: "glVertexFormatNV", ogl.} - proc glColorPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc: "glColorPointervINTEL", ogl.} - proc glGetMultiTexParameterivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetMultiTexParameterivEXT", ogl.} - proc glMultiTexCoordP4uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc: "glMultiTexCoordP4uiv", ogl.} - proc glResetMinmaxEXT(target: TGLenum) {.importc: "glResetMinmaxEXT", ogl.} - proc glCopyBufferSubData(readTarget: TGLenum, writeTarget: TGLenum, readOffset: TGLintptr, writeOffset: TGLintptr, size: TGLsizeiptr) {.importc: "glCopyBufferSubData", ogl.} - proc glSecondaryColor3sv(v: TGLshort) {.importc: "glSecondaryColor3sv", ogl.} - proc glPixelStorex(pname: TGLenum, param: TGLfixed) {.importc: "glPixelStorex", ogl.} - proc glWaitSync(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64) {.importc: "glWaitSync", ogl.} - proc glVertexAttribI1iv(index: TGLuint, v: TGLint) {.importc: "glVertexAttribI1iv", ogl.} - proc glColorSubTableEXT(target: TGLenum, start: TGLsizei, count: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc: "glColorSubTableEXT", ogl.} - proc glGetDoublev(pname: TGLenum, params: TGLdouble) {.importc: "glGetDoublev", ogl.} - proc glMultiTexParameterivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glMultiTexParameterivEXT", ogl.} - proc glMultiTexCoord4svARB(target: TGLenum, v: TGLshort) {.importc: "glMultiTexCoord4svARB", ogl.} - proc glColorPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc: "glColorPointerListIBM", ogl.} - proc glScissorIndexed(index: TGLuint, left: TGLint, bottom: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glScissorIndexed", ogl.} - proc glStencilOpSeparateATI(face: TGLenum, sfail: TGLenum, dpfail: TGLenum, dppass: TGLenum) {.importc: "glStencilOpSeparateATI", ogl.} - proc glLoadName(name: TGLuint) {.importc: "glLoadName", ogl.} - proc glIsTransformFeedbackNV(id: TGLuint): TGLboolean {.importc: "glIsTransformFeedbackNV", ogl.} - proc glPopDebugGroup() {.importc: "glPopDebugGroup", ogl.} - proc glClipPlanef(p: TGLenum, eqn: TGLfloat) {.importc: "glClipPlanef", ogl.} - proc glDeleteFencesAPPLE(n: TGLsizei, fences: TGLuint) {.importc: "glDeleteFencesAPPLE", ogl.} - proc glGetQueryObjecti64v(id: TGLuint, pname: TGLenum, params: TGLint64) {.importc: "glGetQueryObjecti64v", ogl.} - proc glAlphaFunc(func: TGLenum, `ref`: TGLfloat) {.importc: "glAlphaFunc", ogl.} - proc glIndexPointerEXT(`type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc: "glIndexPointerEXT", ogl.} - proc glVertexAttribI3ivEXT(index: TGLuint, v: TGLint) {.importc: "glVertexAttribI3ivEXT", ogl.} - proc glIndexub(c: TGLubyte) {.importc: "glIndexub", ogl.} - proc glVertexP2uiv(`type`: TGLenum, value: TGLuint) {.importc: "glVertexP2uiv", ogl.} - proc glProgramUniform1uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glProgramUniform1uiv", ogl.} - proc glDebugMessageInsertKHR(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: TGLchar) {.importc: "glDebugMessageInsertKHR", ogl.} - proc glColor4b(red: TGLbyte, green: TGLbyte, blue: TGLbyte, alpha: TGLbyte) {.importc: "glColor4b", ogl.} - proc glRenderbufferStorageMultisampleAPPLE(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glRenderbufferStorageMultisampleAPPLE", ogl.} - proc glMinSampleShading(value: TGLfloat) {.importc: "glMinSampleShading", ogl.} - proc glBindProgramNV(target: TGLenum, id: TGLuint) {.importc: "glBindProgramNV", ogl.} - proc glWindowPos3dMESA(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glWindowPos3dMESA", ogl.} - proc glEdgeFlagPointer(stride: TGLsizei, `pointer`: pointer) {.importc: "glEdgeFlagPointer", ogl.} - proc glGetFragDataIndex(program: TGLuint, name: TGLchar): TGLint {.importc: "glGetFragDataIndex", ogl.} - proc glTexCoord3hNV(s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV) {.importc: "glTexCoord3hNV", ogl.} - proc glMultiDrawArraysIndirectAMD(mode: TGLenum, indirect: pointer, primcount: TGLsizei, stride: TGLsizei) {.importc: "glMultiDrawArraysIndirectAMD", ogl.} - proc glFragmentColorMaterialSGIX(face: TGLenum, mode: TGLenum) {.importc: "glFragmentColorMaterialSGIX", ogl.} - proc glTexGenf(coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc: "glTexGenf", ogl.} - proc glVertexAttrib4ubvARB(index: TGLuint, v: TGLubyte) {.importc: "glVertexAttrib4ubvARB", ogl.} - proc glClearBufferiv(buffer: TGLenum, drawbuffer: TGLint, value: TGLint) {.importc: "glClearBufferiv", ogl.} - proc glGenQueriesARB(n: TGLsizei, ids: TGLuint) {.importc: "glGenQueriesARB", ogl.} - proc glRectdv(v1: TGLdouble, v2: TGLdouble) {.importc: "glRectdv", ogl.} - proc glBlendEquationSeparateEXT(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc: "glBlendEquationSeparateEXT", ogl.} - proc glTestFenceAPPLE(fence: TGLuint): TGLboolean {.importc: "glTestFenceAPPLE", ogl.} - proc glTexGeniv(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glTexGeniv", ogl.} - proc glPolygonMode(face: TGLenum, mode: TGLenum) {.importc: "glPolygonMode", ogl.} - proc glFrameZoomSGIX(factor: TGLint) {.importc: "glFrameZoomSGIX", ogl.} - proc glReplacementCodeuiTexCoord2fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glReplacementCodeuiTexCoord2fVertex3fSUN", ogl.} - proc glUniformSubroutinesuiv(shadertype: TGLenum, count: TGLsizei, indices: TGLuint) {.importc: "glUniformSubroutinesuiv", ogl.} - proc glBeginQueryIndexed(target: TGLenum, index: TGLuint, id: TGLuint) {.importc: "glBeginQueryIndexed", ogl.} - proc glMultiTexGeniEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glMultiTexGeniEXT", ogl.} - proc glRasterPos3fv(v: TGLfloat) {.importc: "glRasterPos3fv", ogl.} - proc glMapObjectBufferATI(buffer: TGLuint) {.importc: "glMapObjectBufferATI", ogl.} - proc glIndexiv(c: TGLint) {.importc: "glIndexiv", ogl.} - proc glVertexAttribLPointer(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glVertexAttribLPointer", ogl.} - proc glMultiTexCoord4s(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc: "glMultiTexCoord4s", ogl.} - proc glSecondaryColorP3uiv(`type`: TGLenum, color: TGLuint) {.importc: "glSecondaryColorP3uiv", ogl.} - proc glNormalFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc: "glNormalFormatNV", ogl.} - proc glVertex4i(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc: "glVertex4i", ogl.} - proc glUniform1ui64NV(location: TGLint, x: TGLuint64EXT) {.importc: "glUniform1ui64NV", ogl.} - proc glScissorIndexedv(index: TGLuint, v: TGLint) {.importc: "glScissorIndexedv", ogl.} - proc glProgramUniform1i(program: TGLuint, location: TGLint, v0: TGLint) {.importc: "glProgramUniform1i", ogl.} - proc glCompressedMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedMultiTexSubImage3DEXT", ogl.} - proc glFinishTextureSUNX() {.importc: "glFinishTextureSUNX", ogl.} - proc glFramebufferTexture3DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc: "glFramebufferTexture3DEXT", ogl.} - proc glSetInvariantEXT(id: TGLuint, `type`: TGLenum, `addr`: pointer) {.importc: "glSetInvariantEXT", ogl.} - proc glGetTexParameterIivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetTexParameterIivEXT", ogl.} - proc glMultiTexCoordP3ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc: "glMultiTexCoordP3ui", ogl.} - proc glMultiTexCoord3f(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc: "glMultiTexCoord3f", ogl.} - proc glNormalStream3fATI(stream: TGLenum, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat) {.importc: "glNormalStream3fATI", ogl.} - proc glActiveShaderProgram(pipeline: TGLuint, program: TGLuint) {.importc: "glActiveShaderProgram", ogl.} - proc glDisableVertexArrayEXT(vaobj: TGLuint, `array`: TGLenum) {.importc: "glDisableVertexArrayEXT", ogl.} - proc glVertexAttribI3iv(index: TGLuint, v: TGLint) {.importc: "glVertexAttribI3iv", ogl.} - proc glProvokingVertex(mode: TGLenum) {.importc: "glProvokingVertex", ogl.} - proc glTexCoord1fv(v: TGLfloat) {.importc: "glTexCoord1fv", ogl.} - proc glVertexAttrib3fv(index: TGLuint, v: TGLfloat) {.importc: "glVertexAttrib3fv", ogl.} - proc glWindowPos3iv(v: TGLint) {.importc: "glWindowPos3iv", ogl.} - proc glProgramUniform4ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc: "glProgramUniform4ui64NV", ogl.} - proc glProgramUniform2d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble) {.importc: "glProgramUniform2d", ogl.} - proc glDebugMessageInsertARB(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: TGLchar) {.importc: "glDebugMessageInsertARB", ogl.} - proc glMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glMultiTexSubImage3DEXT", ogl.} - proc glMap1d(target: TGLenum, u1: TGLdouble, u2: TGLdouble, stride: TGLint, order: TGLint, points: TGLdouble) {.importc: "glMap1d", ogl.} - proc glDeleteShader(shader: TGLuint) {.importc: "glDeleteShader", ogl.} - proc glTexturePageCommitmentEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, resident: TGLboolean) {.importc: "glTexturePageCommitmentEXT", ogl.} - proc glFramebufferDrawBufferEXT(framebuffer: TGLuint, mode: TGLenum) {.importc: "glFramebufferDrawBufferEXT", ogl.} - proc glTexCoord2fNormal3fVertex3fSUN(s: TGLfloat, t: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glTexCoord2fNormal3fVertex3fSUN", ogl.} - proc glDeleteProgramsNV(n: TGLsizei, programs: TGLuint) {.importc: "glDeleteProgramsNV", ogl.} - proc glPointAlongPathNV(path: TGLuint, startSegment: TGLsizei, numSegments: TGLsizei, distance: TGLfloat, x: TGLfloat, y: TGLfloat, tangentX: TGLfloat, tangentY: TGLfloat): TGLboolean {.importc: "glPointAlongPathNV", ogl.} - proc glTexCoord1d(s: TGLdouble) {.importc: "glTexCoord1d", ogl.} - proc glStencilStrokePathNV(path: TGLuint, reference: TGLint, mask: TGLuint) {.importc: "glStencilStrokePathNV", ogl.} - proc glQueryMatrixxOES(mantissa: TGLfixed, exponent: TGLint): TGLbitfield {.importc: "glQueryMatrixxOES", ogl.} - proc glGetNamedProgramLocalParameterIuivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLuint) {.importc: "glGetNamedProgramLocalParameterIuivEXT", ogl.} - proc glGenerateMipmapOES(target: TGLenum) {.importc: "glGenerateMipmapOES", ogl.} - proc glRenderbufferStorageMultisampleIMG(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glRenderbufferStorageMultisampleIMG", ogl.} - proc glVertexBlendEnviATI(pname: TGLenum, param: TGLint) {.importc: "glVertexBlendEnviATI", ogl.} - proc glPushAttrib(mask: TGLbitfield) {.importc: "glPushAttrib", ogl.} - proc glShaderOp3EXT(op: TGLenum, res: TGLuint, arg1: TGLuint, arg2: TGLuint, arg3: TGLuint) {.importc: "glShaderOp3EXT", ogl.} - proc glEnableVertexAttribArray(index: TGLuint) {.importc: "glEnableVertexAttribArray", ogl.} - proc glVertexAttrib4Nbv(index: TGLuint, v: TGLbyte) {.importc: "glVertexAttrib4Nbv", ogl.} - proc glExtGetBuffersQCOM(buffers: TGLuint, maxBuffers: TGLint, numBuffers: TGLint) {.importc: "glExtGetBuffersQCOM", ogl.} - proc glCopyTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyTexSubImage3D", ogl.} - proc glDeletePerfMonitorsAMD(n: TGLsizei, monitors: TGLuint) {.importc: "glDeletePerfMonitorsAMD", ogl.} - proc glGetTrackMatrixivNV(target: TGLenum, address: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetTrackMatrixivNV", ogl.} - proc glEndConditionalRender() {.importc: "glEndConditionalRender", ogl.} - proc glVertexAttribL3i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc: "glVertexAttribL3i64NV", ogl.} - proc glProgramLocalParametersI4ivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLint) {.importc: "glProgramLocalParametersI4ivNV", ogl.} - proc glFlush() {.importc: "glFlush", ogl.} - proc glGetNamedBufferParameterui64vNV(buffer: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc: "glGetNamedBufferParameterui64vNV", ogl.} - proc glGetVertexArrayIntegeri_vEXT(vaobj: TGLuint, index: TGLuint, pname: TGLenum, param: TGLint) {.importc: "glGetVertexArrayIntegeri_vEXT", ogl.} - proc glReadnPixelsEXT(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, data: pointer) {.importc: "glReadnPixelsEXT", ogl.} - proc glMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glMultiTexImage1DEXT", ogl.} - proc glGetVaryingLocationNV(program: TGLuint, name: TGLchar): TGLint {.importc: "glGetVaryingLocationNV", ogl.} - proc glMultiTexCoord4fvARB(target: TGLenum, v: TGLfloat) {.importc: "glMultiTexCoord4fvARB", ogl.} - proc glMultiTexCoord3iv(target: TGLenum, v: TGLint) {.importc: "glMultiTexCoord3iv", ogl.} - proc glVertexAttribL2dvEXT(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttribL2dvEXT", ogl.} - proc glTexParameterxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glTexParameterxOES", ogl.} - proc glSecondaryColor3uivEXT(v: TGLuint) {.importc: "glSecondaryColor3uivEXT", ogl.} - proc glReadnPixelsARB(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, data: pointer) {.importc: "glReadnPixelsARB", ogl.} - proc glCopyTexSubImage1DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc: "glCopyTexSubImage1DEXT", ogl.} - proc glGetDoublei_vEXT(pname: TGLenum, index: TGLuint, params: TGLdouble) {.importc: "glGetDoublei_vEXT", ogl.} - proc glVariantPointerEXT(id: TGLuint, `type`: TGLenum, stride: TGLuint, `addr`: pointer) {.importc: "glVariantPointerEXT", ogl.} - proc glProgramUniform3ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc: "glProgramUniform3ui64vNV", ogl.} - proc glTexCoord2fColor3fVertex3fvSUN(tc: TGLfloat, c: TGLfloat, v: TGLfloat) {.importc: "glTexCoord2fColor3fVertex3fvSUN", ogl.} - proc glProgramUniform3fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glProgramUniform3fv", ogl.} - proc glBindFragDataLocationIndexed(program: TGLuint, colorNumber: TGLuint, index: TGLuint, name: TGLchar) {.importc: "glBindFragDataLocationIndexed", ogl.} - proc glGetnSeparableFilterARB(target: TGLenum, format: TGLenum, `type`: TGLenum, rowBufSize: TGLsizei, row: pointer, columnBufSize: TGLsizei, column: pointer, span: pointer) {.importc: "glGetnSeparableFilterARB", ogl.} - proc glTextureParameteriEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glTextureParameteriEXT", ogl.} - proc glGetUniformuivEXT(program: TGLuint, location: TGLint, params: TGLuint) {.importc: "glGetUniformuivEXT", ogl.} - proc glFragmentMaterialivSGIX(face: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glFragmentMaterialivSGIX", ogl.} - proc glMultiTexCoord1svARB(target: TGLenum, v: TGLshort) {.importc: "glMultiTexCoord1svARB", ogl.} - proc glClientActiveTextureARB(texture: TGLenum) {.importc: "glClientActiveTextureARB", ogl.} - proc glVertexAttrib1fARB(index: TGLuint, x: TGLfloat) {.importc: "glVertexAttrib1fARB", ogl.} - proc glVertexAttrib4NbvARB(index: TGLuint, v: TGLbyte) {.importc: "glVertexAttrib4NbvARB", ogl.} - proc glRasterPos2d(x: TGLdouble, y: TGLdouble) {.importc: "glRasterPos2d", ogl.} - proc glMultiTexCoord4iARB(target: TGLenum, s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc: "glMultiTexCoord4iARB", ogl.} - proc glGetPixelTexGenParameterfvSGIS(pname: TGLenum, params: TGLfloat) {.importc: "glGetPixelTexGenParameterfvSGIS", ogl.} - proc glVertexAttribL2dv(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttribL2dv", ogl.} - proc glGetProgramStringARB(target: TGLenum, pname: TGLenum, string: pointer) {.importc: "glGetProgramStringARB", ogl.} - proc glRasterPos2i(x: TGLint, y: TGLint) {.importc: "glRasterPos2i", ogl.} - proc glTexCoord2fColor4fNormal3fVertex3fvSUN(tc: TGLfloat, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc: "glTexCoord2fColor4fNormal3fVertex3fvSUN", ogl.} - proc glMultiTexCoord3s(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort) {.importc: "glMultiTexCoord3s", ogl.} - proc glMultTransposeMatrixd(m: TGLdouble) {.importc: "glMultTransposeMatrixd", ogl.} - proc glActiveVaryingNV(program: TGLuint, name: TGLchar) {.importc: "glActiveVaryingNV", ogl.} - proc glProgramUniform1f(program: TGLuint, location: TGLint, v0: TGLfloat) {.importc: "glProgramUniform1f", ogl.} - proc glGetActiveSubroutineName(program: TGLuint, shadertype: TGLenum, index: TGLuint, bufsize: TGLsizei, length: TGLsizei, name: TGLchar) {.importc: "glGetActiveSubroutineName", ogl.} - proc glClipPlanex(plane: TGLenum, equation: TGLfixed) {.importc: "glClipPlanex", ogl.} - proc glMultiTexCoord4iv(target: TGLenum, v: TGLint) {.importc: "glMultiTexCoord4iv", ogl.} - proc glTransformFeedbackVaryingsEXT(program: TGLuint, count: TGLsizei, varyings: ptr TGLchar, bufferMode: TGLenum) {.importc: "glTransformFeedbackVaryingsEXT", ogl.} - proc glBlendEquationSeparateiARB(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc: "glBlendEquationSeparateiARB", ogl.} - proc glVertex2sv(v: TGLshort) {.importc: "glVertex2sv", ogl.} - proc glAccumxOES(op: TGLenum, value: TGLfixed) {.importc: "glAccumxOES", ogl.} - proc glProgramLocalParameter4dARB(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glProgramLocalParameter4dARB", ogl.} - proc glIsRenderbufferEXT(renderbuffer: TGLuint): TGLboolean {.importc: "glIsRenderbufferEXT", ogl.} - proc glMultiDrawElementsIndirectAMD(mode: TGLenum, `type`: TGLenum, indirect: pointer, primcount: TGLsizei, stride: TGLsizei) {.importc: "glMultiDrawElementsIndirectAMD", ogl.} - proc glVertexAttribI4uiEXT(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc: "glVertexAttribI4uiEXT", ogl.} - proc glVertex4fv(v: TGLfloat) {.importc: "glVertex4fv", ogl.} - proc glGenerateMipmapEXT(target: TGLenum) {.importc: "glGenerateMipmapEXT", ogl.} - proc glVertexP3ui(`type`: TGLenum, value: TGLuint) {.importc: "glVertexP3ui", ogl.} - proc glTexCoord2dv(v: TGLdouble) {.importc: "glTexCoord2dv", ogl.} - proc glFlushMappedBufferRange(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr) {.importc: "glFlushMappedBufferRange", ogl.} - proc glTrackMatrixNV(target: TGLenum, address: TGLuint, matrix: TGLenum, transform: TGLenum) {.importc: "glTrackMatrixNV", ogl.} - proc glFragmentLightModeliSGIX(pname: TGLenum, param: TGLint) {.importc: "glFragmentLightModeliSGIX", ogl.} - proc glVertexAttrib4Nusv(index: TGLuint, v: TGLushort) {.importc: "glVertexAttrib4Nusv", ogl.} - proc glScalef(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glScalef", ogl.} - proc glLightxvOES(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glLightxvOES", ogl.} - proc glTextureParameterivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glTextureParameterivEXT", ogl.} - proc glCompressedMultiTexImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc: "glCompressedMultiTexImage3DEXT", ogl.} - proc glVertexAttribL1d(index: TGLuint, x: TGLdouble) {.importc: "glVertexAttribL1d", ogl.} - proc glVertexAttrib3fARB(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glVertexAttrib3fARB", ogl.} - proc glVertexAttrib3hvNV(index: TGLuint, v: TGLhalfNV) {.importc: "glVertexAttrib3hvNV", ogl.} - proc glSpriteParameteriSGIX(pname: TGLenum, param: TGLint) {.importc: "glSpriteParameteriSGIX", ogl.} - proc glFrustumxOES(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc: "glFrustumxOES", ogl.} - proc glGetnMapdvARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: TGLdouble) {.importc: "glGetnMapdvARB", ogl.} - proc glGetMinmaxEXT(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc: "glGetMinmaxEXT", ogl.} - proc glProgramUniformHandleui64NV(program: TGLuint, location: TGLint, value: TGLuint64) {.importc: "glProgramUniformHandleui64NV", ogl.} - proc glWindowPos4fvMESA(v: TGLfloat) {.importc: "glWindowPos4fvMESA", ogl.} - proc glExtGetTexturesQCOM(textures: TGLuint, maxTextures: TGLint, numTextures: TGLint) {.importc: "glExtGetTexturesQCOM", ogl.} - proc glProgramSubroutineParametersuivNV(target: TGLenum, count: TGLsizei, params: TGLuint) {.importc: "glProgramSubroutineParametersuivNV", ogl.} - proc glSampleCoveragexOES(value: TGLclampx, invert: TGLboolean) {.importc: "glSampleCoveragexOES", ogl.} - proc glMultiTexEnvivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glMultiTexEnvivEXT", ogl.} - proc glGetFinalCombinerInputParameterfvNV(variable: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetFinalCombinerInputParameterfvNV", ogl.} - proc glLightModeliv(pname: TGLenum, params: TGLint) {.importc: "glLightModeliv", ogl.} - proc glUniform4f(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc: "glUniform4f", ogl.} - proc glDepthRange(near: TGLdouble, far: TGLdouble) {.importc: "glDepthRange", ogl.} - proc glProgramUniformMatrix4x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix4x3dv", ogl.} - proc glProgramUniform4fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glProgramUniform4fv", ogl.} - proc glGetTexParameterIiv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetTexParameterIiv", ogl.} - proc glVertexAttribs4dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc: "glVertexAttribs4dvNV", ogl.} - proc glConvolutionParameteri(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glConvolutionParameteri", ogl.} - proc glVertexAttribI4uiv(index: TGLuint, v: TGLuint) {.importc: "glVertexAttribI4uiv", ogl.} - proc glEvalCoord1dv(u: TGLdouble) {.importc: "glEvalCoord1dv", ogl.} - proc glIsFramebuffer(framebuffer: TGLuint): TGLboolean {.importc: "glIsFramebuffer", ogl.} - proc glEvalCoord2d(u: TGLdouble, v: TGLdouble) {.importc: "glEvalCoord2d", ogl.} - proc glClearDepthf(d: TGLfloat) {.importc: "glClearDepthf", ogl.} - proc glCompressedTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexSubImage2D", ogl.} - proc glProgramUniformMatrix3x2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix3x2dvEXT", ogl.} - proc glGetTexParameterxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetTexParameterxv", ogl.} - proc glBinormal3fEXT(bx: TGLfloat, by: TGLfloat, bz: TGLfloat) {.importc: "glBinormal3fEXT", ogl.} - proc glProgramParameteriARB(program: TGLuint, pname: TGLenum, value: TGLint) {.importc: "glProgramParameteriARB", ogl.} - proc glWindowPos3ivMESA(v: TGLint) {.importc: "glWindowPos3ivMESA", ogl.} - proc glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc: TGLuint, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc: "glReplacementCodeuiColor4fNormal3fVertex3fvSUN", ogl.} - proc glPresentFrameDualFillNV(video_slot: TGLuint, minPresentTime: TGLuint64EXT, beginPresentTimeId: TGLuint, presentDurationId: TGLuint, `type`: TGLenum, target0: TGLenum, fill0: TGLuint, target1: TGLenum, fill1: TGLuint, target2: TGLenum, fill2: TGLuint, target3: TGLenum, fill3: TGLuint) {.importc: "glPresentFrameDualFillNV", ogl.} - proc glIndexPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc: "glIndexPointerListIBM", ogl.} - proc glVertexStream2dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble) {.importc: "glVertexStream2dATI", ogl.} - proc glUniformMatrix3x4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glUniformMatrix3x4dv", ogl.} - proc glMapNamedBufferRangeEXT(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc: "glMapNamedBufferRangeEXT", ogl.} - proc glColor4sv(v: TGLshort) {.importc: "glColor4sv", ogl.} - proc glStencilFillPathNV(path: TGLuint, fillMode: TGLenum, mask: TGLuint) {.importc: "glStencilFillPathNV", ogl.} - proc glGetVertexAttribfvARB(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetVertexAttribfvARB", ogl.} - proc glWindowPos3dv(v: TGLdouble) {.importc: "glWindowPos3dv", ogl.} - proc glHintPGI(target: TGLenum, mode: TGLint) {.importc: "glHintPGI", ogl.} - proc glVertexAttribs3hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc: "glVertexAttribs3hvNV", ogl.} - proc glProgramUniform1i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT) {.importc: "glProgramUniform1i64NV", ogl.} - proc glReplacementCodeuiColor3fVertex3fSUN(rc: TGLuint, r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glReplacementCodeuiColor3fVertex3fSUN", ogl.} - proc glUniform2iARB(location: TGLint, v0: TGLint, v1: TGLint) {.importc: "glUniform2iARB", ogl.} - proc glViewport(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glViewport", ogl.} - proc glBlendFuncSeparateIndexedAMD(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc: "glBlendFuncSeparateIndexedAMD", ogl.} - proc glColor3us(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc: "glColor3us", ogl.} - proc glVertexAttrib2hvNV(index: TGLuint, v: TGLhalfNV) {.importc: "glVertexAttrib2hvNV", ogl.} - proc glGenerateMipmap(target: TGLenum) {.importc: "glGenerateMipmap", ogl.} - proc glGetProgramEnvParameterIuivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc: "glGetProgramEnvParameterIuivNV", ogl.} - proc glBlendEquationiARB(buf: TGLuint, mode: TGLenum) {.importc: "glBlendEquationiARB", ogl.} - proc glReadBufferNV(mode: TGLenum) {.importc: "glReadBufferNV", ogl.} - proc glProvokingVertexEXT(mode: TGLenum) {.importc: "glProvokingVertexEXT", ogl.} - proc glPointParameterivNV(pname: TGLenum, params: TGLint) {.importc: "glPointParameterivNV", ogl.} - proc glBlitFramebufferANGLE(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc: "glBlitFramebufferANGLE", ogl.} - proc glGetObjectParameterivARB(obj: TGLhandleARB, pname: TGLenum, params: TGLint) {.importc: "glGetObjectParameterivARB", ogl.} - proc glGetSubroutineIndex(program: TGLuint, shadertype: TGLenum, name: TGLchar): TGLuint {.importc: "glGetSubroutineIndex", ogl.} - proc glMap2d(target: TGLenum, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, points: TGLdouble) {.importc: "glMap2d", ogl.} - proc glRectfv(v1: TGLfloat, v2: TGLfloat) {.importc: "glRectfv", ogl.} - proc glDepthRangeArrayv(first: TGLuint, count: TGLsizei, v: TGLdouble) {.importc: "glDepthRangeArrayv", ogl.} - proc glMultiTexParameteriEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLint) {.importc: "glMultiTexParameteriEXT", ogl.} - proc glTexStorageSparseAMD(target: TGLenum, internalFormat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, layers: TGLsizei, flags: TGLbitfield) {.importc: "glTexStorageSparseAMD", ogl.} - proc glGenerateTextureMipmapEXT(texture: TGLuint, target: TGLenum) {.importc: "glGenerateTextureMipmapEXT", ogl.} - proc glCopyConvolutionFilter1D(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc: "glCopyConvolutionFilter1D", ogl.} - proc glVertex4d(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc: "glVertex4d", ogl.} - proc glGetPathParameterfvNV(path: TGLuint, pname: TGLenum, value: TGLfloat) {.importc: "glGetPathParameterfvNV", ogl.} - proc glDetachShader(program: TGLuint, shader: TGLuint) {.importc: "glDetachShader", ogl.} - proc glGetColorTableSGI(target: TGLenum, format: TGLenum, `type`: TGLenum, table: pointer) {.importc: "glGetColorTableSGI", ogl.} - proc glPixelTransformParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glPixelTransformParameterfvEXT", ogl.} - proc glBufferSubDataARB(target: TGLenum, offset: TGLintptrARB, size: TGLsizeiptrARB, data: pointer) {.importc: "glBufferSubDataARB", ogl.} - proc glVertexAttrib4ubvNV(index: TGLuint, v: TGLubyte) {.importc: "glVertexAttrib4ubvNV", ogl.} - proc glCopyTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc: "glCopyTextureImage1DEXT", ogl.} - proc glGetQueryivARB(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetQueryivARB", ogl.} - proc glVertexAttribIPointerEXT(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glVertexAttribIPointerEXT", ogl.} - proc glVertexAttribL3dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glVertexAttribL3dEXT", ogl.} - proc glGetQueryObjectui64vEXT(id: TGLuint, pname: TGLenum, params: TGLuint64) {.importc: "glGetQueryObjectui64vEXT", ogl.} - proc glColor4x(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc: "glColor4x", ogl.} - proc glProgramUniformMatrix3x2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix3x2dv", ogl.} - proc glVertexAttribI4i(index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc: "glVertexAttribI4i", ogl.} - proc glVertexAttrib1f(index: TGLuint, x: TGLfloat) {.importc: "glVertexAttrib1f", ogl.} - proc glUnmapBufferOES(target: TGLenum): TGLboolean {.importc: "glUnmapBufferOES", ogl.} - proc glVertexStream2ivATI(stream: TGLenum, coords: TGLint) {.importc: "glVertexStream2ivATI", ogl.} - proc glBeginOcclusionQueryNV(id: TGLuint) {.importc: "glBeginOcclusionQueryNV", ogl.} - proc glVertex4sv(v: TGLshort) {.importc: "glVertex4sv", ogl.} - proc glEnablei(target: TGLenum, index: TGLuint) {.importc: "glEnablei", ogl.} - proc glUseProgramObjectARB(programObj: TGLhandleARB) {.importc: "glUseProgramObjectARB", ogl.} - proc glGetVertexAttribLdvEXT(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc: "glGetVertexAttribLdvEXT", ogl.} - proc glUniform2d(location: TGLint, x: TGLdouble, y: TGLdouble) {.importc: "glUniform2d", ogl.} - proc glMinmaxEXT(target: TGLenum, internalformat: TGLenum, sink: TGLboolean) {.importc: "glMinmaxEXT", ogl.} - proc glTexImage3D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexImage3D", ogl.} - proc glGenSymbolsEXT(datatype: TGLenum, storagetype: TGLenum, range: TGLenum, components: TGLuint): TGLuint {.importc: "glGenSymbolsEXT", ogl.} - proc glVertexAttribI4svEXT(index: TGLuint, v: TGLshort) {.importc: "glVertexAttribI4svEXT", ogl.} - proc glProgramEnvParameter4dvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc: "glProgramEnvParameter4dvARB", ogl.} - proc glProgramUniformMatrix4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix4dv", ogl.} - proc glGetSamplerParameterfv(sampler: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetSamplerParameterfv", ogl.} - proc glPopClientAttrib() {.importc: "glPopClientAttrib", ogl.} - proc glHistogram(target: TGLenum, width: TGLsizei, internalformat: TGLenum, sink: TGLboolean) {.importc: "glHistogram", ogl.} - proc glTexEnvfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glTexEnvfv", ogl.} - proc glMultiTexCoord1dvARB(target: TGLenum, v: TGLdouble) {.importc: "glMultiTexCoord1dvARB", ogl.} - proc glGetTexGenivOES(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetTexGenivOES", ogl.} - proc glUniform1ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glUniform1ivARB", ogl.} - proc glTexCoord3fv(v: TGLfloat) {.importc: "glTexCoord3fv", ogl.} - proc glVertex2xvOES(coords: TGLfixed) {.importc: "glVertex2xvOES", ogl.} - proc glTexCoord4fVertex4fvSUN(tc: TGLfloat, v: TGLfloat) {.importc: "glTexCoord4fVertex4fvSUN", ogl.} - proc glUniform2uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glUniform2uiv", ogl.} - proc glMultiTexEnvfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glMultiTexEnvfvEXT", ogl.} - proc glGetTextureParameterIivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetTextureParameterIivEXT", ogl.} - proc glMemoryBarrierEXT(barriers: TGLbitfield) {.importc: "glMemoryBarrierEXT", ogl.} - proc glGetTexParameterPointervAPPLE(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc: "glGetTexParameterPointervAPPLE", ogl.} - proc glWindowPos2svARB(v: TGLshort) {.importc: "glWindowPos2svARB", ogl.} - proc glEndQuery(target: TGLenum) {.importc: "glEndQuery", ogl.} - proc glBlitFramebufferEXT(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc: "glBlitFramebufferEXT", ogl.} - proc glProgramEnvParametersI4uivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLuint) {.importc: "glProgramEnvParametersI4uivNV", ogl.} - proc glGetActiveUniform(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLchar) {.importc: "glGetActiveUniform", ogl.} - proc glGenAsyncMarkersSGIX(range: TGLsizei): TGLuint {.importc: "glGenAsyncMarkersSGIX", ogl.} - proc glClipControlARB(origin: TGLenum, depth: TGLenum) {.importc: "glClipControlARB", ogl.} - proc glDrawElementsInstancedEXT(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc: "glDrawElementsInstancedEXT", ogl.} - proc glGetFragmentMaterialivSGIX(face: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetFragmentMaterialivSGIX", ogl.} - proc glSwizzleEXT(res: TGLuint, `in`: TGLuint, outX: TGLenum, outY: TGLenum, outZ: TGLenum, outW: TGLenum) {.importc: "glSwizzleEXT", ogl.} - proc glMultiTexCoord1bOES(texture: TGLenum, s: TGLbyte) {.importc: "glMultiTexCoord1bOES", ogl.} - proc glProgramParameters4dvNV(target: TGLenum, index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc: "glProgramParameters4dvNV", ogl.} - proc glWindowPos2s(x: TGLshort, y: TGLshort) {.importc: "glWindowPos2s", ogl.} - proc glBlendFuncSeparatei(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc: "glBlendFuncSeparatei", ogl.} - proc glMultiModeDrawElementsIBM(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei, modestride: TGLint) {.importc: "glMultiModeDrawElementsIBM", ogl.} - proc glNormal3x(nx: TGLfixed, ny: TGLfixed, nz: TGLfixed) {.importc: "glNormal3x", ogl.} - proc glProgramUniform1fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc: "glProgramUniform1fvEXT", ogl.} - proc glTexCoord2hNV(s: TGLhalfNV, t: TGLhalfNV) {.importc: "glTexCoord2hNV", ogl.} - proc glViewportIndexedfv(index: TGLuint, v: TGLfloat) {.importc: "glViewportIndexedfv", ogl.} - proc glDrawTexxOES(x: TGLfixed, y: TGLfixed, z: TGLfixed, width: TGLfixed, height: TGLfixed) {.importc: "glDrawTexxOES", ogl.} - proc glProgramParameter4dvNV(target: TGLenum, index: TGLuint, v: TGLdouble) {.importc: "glProgramParameter4dvNV", ogl.} - proc glDeleteBuffers(n: TGLsizei, buffers: TGLuint) {.importc: "glDeleteBuffers", ogl.} - proc glGetVertexArrayIntegervEXT(vaobj: TGLuint, pname: TGLenum, param: TGLint) {.importc: "glGetVertexArrayIntegervEXT", ogl.} - proc glBindFragDataLocationEXT(program: TGLuint, color: TGLuint, name: TGLchar) {.importc: "glBindFragDataLocationEXT", ogl.} - proc glGenProgramsNV(n: TGLsizei, programs: TGLuint) {.importc: "glGenProgramsNV", ogl.} - proc glMultiTexCoord1i(target: TGLenum, s: TGLint) {.importc: "glMultiTexCoord1i", ogl.} - proc glCompressedTexImage3DOES(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexImage3DOES", ogl.} - proc glGetQueryivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetQueryivEXT", ogl.} - proc glExtGetBufferPointervQCOM(target: TGLenum, params: ptr pointer) {.importc: "glExtGetBufferPointervQCOM", ogl.} - proc glVertex3iv(v: TGLint) {.importc: "glVertex3iv", ogl.} - proc glVertexAttribL1dvEXT(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttribL1dvEXT", ogl.} - proc glValidateProgramPipeline(pipeline: TGLuint) {.importc: "glValidateProgramPipeline", ogl.} - proc glBindVertexArray(`array`: TGLuint) {.importc: "glBindVertexArray", ogl.} - proc glUniform2uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint) {.importc: "glUniform2uiEXT", ogl.} - proc glUniform3i(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc: "glUniform3i", ogl.} - proc glGetVertexAttribIuiv(index: TGLuint, pname: TGLenum, params: TGLuint) {.importc: "glGetVertexAttribIuiv", ogl.} - proc glVertexArrayParameteriAPPLE(pname: TGLenum, param: TGLint) {.importc: "glVertexArrayParameteriAPPLE", ogl.} - proc glVertexAttribL2i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT) {.importc: "glVertexAttribL2i64NV", ogl.} - proc glTexGenivOES(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glTexGenivOES", ogl.} - proc glIsFramebufferOES(framebuffer: TGLuint): TGLboolean {.importc: "glIsFramebufferOES", ogl.} - proc glColor4ubv(v: TGLubyte) {.importc: "glColor4ubv", ogl.} - proc glDeleteNamedStringARB(namelen: TGLint, name: TGLchar) {.importc: "glDeleteNamedStringARB", ogl.} - proc glCopyConvolutionFilter1DEXT(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc: "glCopyConvolutionFilter1DEXT", ogl.} - proc glBufferStorage(target: TGLenum, size: TGLsizeiptr, data: pointer, flags: TGLbitfield) {.importc: "glBufferStorage", ogl.} - proc glDrawTexiOES(x: TGLint, y: TGLint, z: TGLint, width: TGLint, height: TGLint) {.importc: "glDrawTexiOES", ogl.} - proc glRasterPos3dv(v: TGLdouble) {.importc: "glRasterPos3dv", ogl.} - proc glIndexMaterialEXT(face: TGLenum, mode: TGLenum) {.importc: "glIndexMaterialEXT", ogl.} - proc glGetClipPlanex(plane: TGLenum, equation: TGLfixed) {.importc: "glGetClipPlanex", ogl.} - proc glIsVertexArrayOES(`array`: TGLuint): TGLboolean {.importc: "glIsVertexArrayOES", ogl.} - proc glColorTableEXT(target: TGLenum, internalFormat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc: "glColorTableEXT", ogl.} - proc glCompressedTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc: "glCompressedTexImage2D", ogl.} - proc glLightx(light: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glLightx", ogl.} - proc glGetTexParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetTexParameterfv", ogl.} - proc glVertexAttrib4NsvARB(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib4NsvARB", ogl.} - proc glInterleavedArrays(format: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glInterleavedArrays", ogl.} - proc glProgramLocalParameter4fARB(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc: "glProgramLocalParameter4fARB", ogl.} - proc glPopDebugGroupKHR() {.importc: "glPopDebugGroupKHR", ogl.} - proc glVDPAUUnregisterSurfaceNV(surface: TGLvdpauSurfaceNV) {.importc: "glVDPAUUnregisterSurfaceNV", ogl.} - proc glTexCoord1s(s: TGLshort) {.importc: "glTexCoord1s", ogl.} - proc glFramebufferTexture2DMultisampleIMG(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, samples: TGLsizei) {.importc: "glFramebufferTexture2DMultisampleIMG", ogl.} - proc glShaderBinary(count: TGLsizei, shaders: TGLuint, binaryformat: TGLenum, binary: pointer, length: TGLsizei) {.importc: "glShaderBinary", ogl.} - proc glVertexAttrib2dv(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib2dv", ogl.} - proc glUniformMatrix4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glUniformMatrix4dv", ogl.} - proc glWeightivARB(size: TGLint, weights: TGLint) {.importc: "glWeightivARB", ogl.} - proc glGetMultiTexParameterIivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetMultiTexParameterIivEXT", ogl.} - proc glCopyConvolutionFilter2DEXT(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc: "glCopyConvolutionFilter2DEXT", ogl.} - proc glSecondaryColor3hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV) {.importc: "glSecondaryColor3hNV", ogl.} - proc glVertexAttrib1sv(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib1sv", ogl.} - proc glFrustumfOES(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc: "glFrustumfOES", ogl.} - proc glVertexStream2iATI(stream: TGLenum, x: TGLint, y: TGLint) {.importc: "glVertexStream2iATI", ogl.} - proc glNormalStream3bATI(stream: TGLenum, nx: TGLbyte, ny: TGLbyte, nz: TGLbyte) {.importc: "glNormalStream3bATI", ogl.} - proc glVertexArrayTexCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayTexCoordOffsetEXT", ogl.} - proc glGetQueryiv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetQueryiv", ogl.} - proc glTransformFeedbackStreamAttribsNV(count: TGLsizei, attribs: TGLint, nbuffers: TGLsizei, bufstreams: TGLint, bufferMode: TGLenum) {.importc: "glTransformFeedbackStreamAttribsNV", ogl.} - proc glTextureStorage3DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc: "glTextureStorage3DEXT", ogl.} - proc glWindowPos3dvMESA(v: TGLdouble) {.importc: "glWindowPos3dvMESA", ogl.} - proc glUniform2uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc: "glUniform2uivEXT", ogl.} - proc glTextureStorage2DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glTextureStorage2DEXT", ogl.} - proc glVertexArrayMultiTexCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, texunit: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc: "glVertexArrayMultiTexCoordOffsetEXT", ogl.} - proc glVertexStream1dvATI(stream: TGLenum, coords: TGLdouble) {.importc: "glVertexStream1dvATI", ogl.} - proc glCopyImageSubData(srcName: TGLuint, srcTarget: TGLenum, srcLevel: TGLint, srcX: TGLint, srcY: TGLint, srcZ: TGLint, dstName: TGLuint, dstTarget: TGLenum, dstLevel: TGLint, dstX: TGLint, dstY: TGLint, dstZ: TGLint, srcWidth: TGLsizei, srcHeight: TGLsizei, srcDepth: TGLsizei) {.importc: "glCopyImageSubData", ogl.} - proc glClearNamedBufferSubDataEXT(buffer: TGLuint, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, offset: TGLsizeiptr, size: TGLsizeiptr, data: pointer) {.importc: "glClearNamedBufferSubDataEXT", ogl.} - proc glBindBuffersRange(target: TGLenum, first: TGLuint, count: TGLsizei, buffers: TGLuint, offsets: TGLintptr, sizes: TGLsizeiptr) {.importc: "glBindBuffersRange", ogl.} - proc glGetVertexAttribIuivEXT(index: TGLuint, pname: TGLenum, params: TGLuint) {.importc: "glGetVertexAttribIuivEXT", ogl.} - proc glLoadMatrixx(m: TGLfixed) {.importc: "glLoadMatrixx", ogl.} - proc glTransformFeedbackVaryingsNV(program: TGLuint, count: TGLsizei, locations: TGLint, bufferMode: TGLenum) {.importc: "glTransformFeedbackVaryingsNV", ogl.} - proc glUniform1i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc: "glUniform1i64vNV", ogl.} - proc glVertexArrayVertexAttribLFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc: "glVertexArrayVertexAttribLFormatEXT", ogl.} - proc glClearBufferuiv(buffer: TGLenum, drawbuffer: TGLint, value: TGLuint) {.importc: "glClearBufferuiv", ogl.} - proc glCombinerOutputNV(stage: TGLenum, portion: TGLenum, abOutput: TGLenum, cdOutput: TGLenum, sumOutput: TGLenum, scale: TGLenum, bias: TGLenum, abDotProduct: TGLboolean, cdDotProduct: TGLboolean, muxSum: TGLboolean) {.importc: "glCombinerOutputNV", ogl.} - proc glTexImage3DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexImage3DEXT", ogl.} - proc glPixelTransformParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glPixelTransformParameterivEXT", ogl.} - proc glActiveStencilFaceEXT(face: TGLenum) {.importc: "glActiveStencilFaceEXT", ogl.} - proc glCreateShaderObjectARB(shaderType: TGLenum): TGLhandleARB {.importc: "glCreateShaderObjectARB", ogl.} - proc glGetTextureParameterivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetTextureParameterivEXT", ogl.} - proc glCopyTextureLevelsAPPLE(destinationTexture: TGLuint, sourceTexture: TGLuint, sourceBaseLevel: TGLint, sourceLevelCount: TGLsizei) {.importc: "glCopyTextureLevelsAPPLE", ogl.} - proc glVertexAttrib4Nuiv(index: TGLuint, v: TGLuint) {.importc: "glVertexAttrib4Nuiv", ogl.} - proc glDrawPixels(width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glDrawPixels", ogl.} - proc glWindowPos3dvARB(v: TGLdouble) {.importc: "glWindowPos3dvARB", ogl.} - proc glProgramLocalParameterI4ivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc: "glProgramLocalParameterI4ivNV", ogl.} - proc glRasterPos4s(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc: "glRasterPos4s", ogl.} - proc glTexCoord2fVertex3fvSUN(tc: TGLfloat, v: TGLfloat) {.importc: "glTexCoord2fVertex3fvSUN", ogl.} - proc glGetPathMetricsNV(metricQueryMask: TGLbitfield, numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, stride: TGLsizei, metrics: TGLfloat) {.importc: "glGetPathMetricsNV", ogl.} - proc glMultiTexCoord4bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte, r: TGLbyte, q: TGLbyte) {.importc: "glMultiTexCoord4bOES", ogl.} - proc glTextureBufferEXT(texture: TGLuint, target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc: "glTextureBufferEXT", ogl.} - proc glSecondaryColor3fv(v: TGLfloat) {.importc: "glSecondaryColor3fv", ogl.} - proc glMultiTexCoord3fv(target: TGLenum, v: TGLfloat) {.importc: "glMultiTexCoord3fv", ogl.} - proc glGetTexParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetTexParameteriv", ogl.} - proc glMap2xOES(target: TGLenum, u1: TGLfixed, u2: TGLfixed, ustride: TGLint, uorder: TGLint, v1: TGLfixed, v2: TGLfixed, vstride: TGLint, vorder: TGLint, points: TGLfixed) {.importc: "glMap2xOES", ogl.} - proc glFlushVertexArrayRangeAPPLE(length: TGLsizei, `pointer`: pointer) {.importc: "glFlushVertexArrayRangeAPPLE", ogl.} - proc glActiveTextureARB(texture: TGLenum) {.importc: "glActiveTextureARB", ogl.} - proc glGetVertexAttribLi64vNV(index: TGLuint, pname: TGLenum, params: TGLint64EXT) {.importc: "glGetVertexAttribLi64vNV", ogl.} - proc glNormal3bv(v: TGLbyte) {.importc: "glNormal3bv", ogl.} - proc glCreateSyncFromCLeventARB(context: TCL_context, event: TCL_context, flags: TGLbitfield): TGLsync {.importc: "glCreateSyncFromCLeventARB", ogl.} - proc glRenderbufferStorageEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc: "glRenderbufferStorageEXT", ogl.} - proc glGetCompressedTextureImageEXT(texture: TGLuint, target: TGLenum, lod: TGLint, img: pointer) {.importc: "glGetCompressedTextureImageEXT", ogl.} - proc glColorFragmentOp2ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint) {.importc: "glColorFragmentOp2ATI", ogl.} - proc glPixelMapusv(map: TGLenum, mapsize: TGLsizei, values: TGLushort) {.importc: "glPixelMapusv", ogl.} - proc glGlobalAlphaFactorsSUN(factor: TGLshort) {.importc: "glGlobalAlphaFactorsSUN", ogl.} - proc glTexParameterxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glTexParameterxv", ogl.} - proc glEvalCoord2xOES(u: TGLfixed, v: TGLfixed) {.importc: "glEvalCoord2xOES", ogl.} - proc glIsList(list: TGLuint): TGLboolean {.importc: "glIsList", ogl.} - proc glVertexAttrib3d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc: "glVertexAttrib3d", ogl.} - proc glSpriteParameterfSGIX(pname: TGLenum, param: TGLfloat) {.importc: "glSpriteParameterfSGIX", ogl.} - proc glPathGlyphRangeNV(firstPathName: TGLuint, fontTarget: TGLenum, fontName: pointer, fontStyle: TGLbitfield, firstGlyph: TGLuint, numGlyphs: TGLsizei, handleMissingGlyphs: TGLenum, pathParameterTemplate: TGLuint, emScale: TGLfloat) {.importc: "glPathGlyphRangeNV", ogl.} - proc glUniform3iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glUniform3iv", ogl.} - proc glClearBufferfi(buffer: TGLenum, drawbuffer: TGLint, depth: TGLfloat, stencil: TGLint) {.importc: "glClearBufferfi", ogl.} - proc glWindowPos3sMESA(x: TGLshort, y: TGLshort, z: TGLshort) {.importc: "glWindowPos3sMESA", ogl.} - proc glGetMapParameterfvNV(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetMapParameterfvNV", ogl.} - proc glBindFragmentShaderATI(id: TGLuint) {.importc: "glBindFragmentShaderATI", ogl.} - proc glTexCoord4s(s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc: "glTexCoord4s", ogl.} - proc glGetMultiTexGenfvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetMultiTexGenfvEXT", ogl.} - proc glColorMaterial(face: TGLenum, mode: TGLenum) {.importc: "glColorMaterial", ogl.} - proc glVertexAttribs1svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc: "glVertexAttribs1svNV", ogl.} - proc glEnableVertexAttribAPPLE(index: TGLuint, pname: TGLenum) {.importc: "glEnableVertexAttribAPPLE", ogl.} - proc glGetDoubleIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLdouble) {.importc: "glGetDoubleIndexedvEXT", ogl.} - proc glOrthof(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc: "glOrthof", ogl.} - proc glVertexBlendEnvfATI(pname: TGLenum, param: TGLfloat) {.importc: "glVertexBlendEnvfATI", ogl.} - proc glUniformMatrix2x4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glUniformMatrix2x4dv", ogl.} - proc glPrioritizeTexturesxOES(n: TGLsizei, textures: TGLuint, priorities: TGLfixed) {.importc: "glPrioritizeTexturesxOES", ogl.} - proc glGetTextureSamplerHandleNV(texture: TGLuint, sampler: TGLuint): TGLuint64 {.importc: "glGetTextureSamplerHandleNV", ogl.} - proc glDeleteVertexArrays(n: TGLsizei, arrays: TGLuint) {.importc: "glDeleteVertexArrays", ogl.} - proc glMultiTexCoord1xOES(texture: TGLenum, s: TGLfixed) {.importc: "glMultiTexCoord1xOES", ogl.} - proc glGlobalAlphaFactorusSUN(factor: TGLushort) {.importc: "glGlobalAlphaFactorusSUN", ogl.} - proc glGetConvolutionParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetConvolutionParameterxvOES", ogl.} - proc glProgramUniform4fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc: "glProgramUniform4fEXT", ogl.} - proc glProgramUniformMatrix3x4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix3x4dvEXT", ogl.} - proc glBindVertexBuffer(bindingindex: TGLuint, buffer: TGLuint, offset: TGLintptr, stride: TGLsizei) {.importc: "glBindVertexBuffer", ogl.} - proc glGetHistogramParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc: "glGetHistogramParameteriv", ogl.} - proc glGetShaderPrecisionFormat(shadertype: TGLenum, precisiontype: TGLenum, range: TGLint, precision: TGLint) {.importc: "glGetShaderPrecisionFormat", ogl.} - proc glTextureMaterialEXT(face: TGLenum, mode: TGLenum) {.importc: "glTextureMaterialEXT", ogl.} - proc glEvalCoord2xvOES(coords: TGLfixed) {.importc: "glEvalCoord2xvOES", ogl.} - proc glWeightuivARB(size: TGLint, weights: TGLuint) {.importc: "glWeightuivARB", ogl.} - proc glGetTextureLevelParameterfvEXT(texture: TGLuint, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfloat) {.importc: "glGetTextureLevelParameterfvEXT", ogl.} - proc glVertexAttribP3uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc: "glVertexAttribP3uiv", ogl.} - proc glProgramEnvParameterI4ivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc: "glProgramEnvParameterI4ivNV", ogl.} - proc glFogi(pname: TGLenum, param: TGLint) {.importc: "glFogi", ogl.} - proc glTexCoord1iv(v: TGLint) {.importc: "glTexCoord1iv", ogl.} - proc glReplacementCodeuiColor4ubVertex3fvSUN(rc: TGLuint, c: TGLubyte, v: TGLfloat) {.importc: "glReplacementCodeuiColor4ubVertex3fvSUN", ogl.} - proc glProgramUniform1ui(program: TGLuint, location: TGLint, v0: TGLuint) {.importc: "glProgramUniform1ui", ogl.} - proc glMultiTexCoord3d(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc: "glMultiTexCoord3d", ogl.} - proc glBeginVideoCaptureNV(video_capture_slot: TGLuint) {.importc: "glBeginVideoCaptureNV", ogl.} - proc glEvalCoord1f(u: TGLfloat) {.importc: "glEvalCoord1f", ogl.} - proc glMultiTexCoord1hvNV(target: TGLenum, v: TGLhalfNV) {.importc: "glMultiTexCoord1hvNV", ogl.} - proc glSecondaryColor3sEXT(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc: "glSecondaryColor3sEXT", ogl.} - proc glTextureImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTextureImage3DEXT", ogl.} - proc glCopyTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc: "glCopyTexImage2D", ogl.} - proc glFinishFenceAPPLE(fence: TGLuint) {.importc: "glFinishFenceAPPLE", ogl.} - proc glVertexArrayRangeNV(length: TGLsizei, `pointer`: pointer) {.importc: "glVertexArrayRangeNV", ogl.} - proc glLightModelf(pname: TGLenum, param: TGLfloat) {.importc: "glLightModelf", ogl.} - proc glVertexAttribL1ui64ARB(index: TGLuint, x: TGLuint64EXT) {.importc: "glVertexAttribL1ui64ARB", ogl.} - proc glPolygonOffset(factor: TGLfloat, units: TGLfloat) {.importc: "glPolygonOffset", ogl.} - proc glRasterPos4xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed, w: TGLfixed) {.importc: "glRasterPos4xOES", ogl.} - proc glVertexAttrib3dvNV(index: TGLuint, v: TGLdouble) {.importc: "glVertexAttrib3dvNV", ogl.} - proc glBeginQuery(target: TGLenum, id: TGLuint) {.importc: "glBeginQuery", ogl.} - proc glWeightfvARB(size: TGLint, weights: TGLfloat) {.importc: "glWeightfvARB", ogl.} - proc glGetUniformuiv(program: TGLuint, location: TGLint, params: TGLuint) {.importc: "glGetUniformuiv", ogl.} - proc glIsTextureEXT(texture: TGLuint): TGLboolean {.importc: "glIsTextureEXT", ogl.} - proc glGetClipPlanef(plane: TGLenum, equation: TGLfloat) {.importc: "glGetClipPlanef", ogl.} - proc glTexGenxOES(coord: TGLenum, pname: TGLenum, param: TGLfixed) {.importc: "glTexGenxOES", ogl.} - proc glFramebufferTextureFaceEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc: "glFramebufferTextureFaceEXT", ogl.} - proc glDisableClientState(`array`: TGLenum) {.importc: "glDisableClientState", ogl.} - proc glTexPageCommitmentARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, resident: TGLboolean) {.importc: "glTexPageCommitmentARB", ogl.} - proc glRasterPos4dv(v: TGLdouble) {.importc: "glRasterPos4dv", ogl.} - proc glGetLightx(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc: "glGetLightx", ogl.} - proc glVertexAttrib1hvNV(index: TGLuint, v: TGLhalfNV) {.importc: "glVertexAttrib1hvNV", ogl.} - proc glMultiTexCoord2s(target: TGLenum, s: TGLshort, t: TGLshort) {.importc: "glMultiTexCoord2s", ogl.} - proc glProgramUniform2iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc: "glProgramUniform2iv", ogl.} - proc glGetListParameterivSGIX(list: TGLuint, pname: TGLenum, params: TGLint) {.importc: "glGetListParameterivSGIX", ogl.} - proc glColorFragmentOp1ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint) {.importc: "glColorFragmentOp1ATI", ogl.} - proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc: "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", ogl.} - proc glSampleMapATI(dst: TGLuint, interp: TGLuint, swizzle: TGLenum) {.importc: "glSampleMapATI", ogl.} - proc glProgramUniform1d(program: TGLuint, location: TGLint, v0: TGLdouble) {.importc: "glProgramUniform1d", ogl.} - proc glBindAttribLocation(program: TGLuint, index: TGLuint, name: TGLchar) {.importc: "glBindAttribLocation", ogl.} - proc glGetCombinerStageParameterfvNV(stage: TGLenum, pname: TGLenum, params: TGLfloat) {.importc: "glGetCombinerStageParameterfvNV", ogl.} - proc glTexSubImage4DSGIS(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, woffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, size4d: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc: "glTexSubImage4DSGIS", ogl.} - proc glGetMapAttribParameterfvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetMapAttribParameterfvNV", ogl.} - proc glNewObjectBufferATI(size: TGLsizei, `pointer`: pointer, usage: TGLenum): TGLuint {.importc: "glNewObjectBufferATI", ogl.} - proc glWindowPos4iMESA(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc: "glWindowPos4iMESA", ogl.} - proc glNewList(list: TGLuint, mode: TGLenum) {.importc: "glNewList", ogl.} - proc glUniform1i64NV(location: TGLint, x: TGLint64EXT) {.importc: "glUniform1i64NV", ogl.} - proc glTexCoordP3ui(`type`: TGLenum, coords: TGLuint) {.importc: "glTexCoordP3ui", ogl.} - proc glEndQueryEXT(target: TGLenum) {.importc: "glEndQueryEXT", ogl.} - proc glGetVertexAttribLdv(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc: "glGetVertexAttribLdv", ogl.} - proc glStencilMask(mask: TGLuint) {.importc: "glStencilMask", ogl.} - proc glVertexAttrib4sv(index: TGLuint, v: TGLshort) {.importc: "glVertexAttrib4sv", ogl.} - proc glRectsv(v1: TGLshort, v2: TGLshort) {.importc: "glRectsv", ogl.} - proc glGetVariantArrayObjectfvATI(id: TGLuint, pname: TGLenum, params: TGLfloat) {.importc: "glGetVariantArrayObjectfvATI", ogl.} - proc glTexCoord3hvNV(v: TGLhalfNV) {.importc: "glTexCoord3hvNV", ogl.} - proc glGetUniformdv(program: TGLuint, location: TGLint, params: TGLdouble) {.importc: "glGetUniformdv", ogl.} - proc glSecondaryColor3fvEXT(v: TGLfloat) {.importc: "glSecondaryColor3fvEXT", ogl.} - proc glAlphaFuncx(func: TGLenum, `ref`: TGLfixed) {.importc: "glAlphaFuncx", ogl.} - proc glVertexAttribPointerNV(index: TGLuint, fsize: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc: "glVertexAttribPointerNV", ogl.} - proc glColorTable(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc: "glColorTable", ogl.} - proc glProgramUniformMatrix2x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc: "glProgramUniformMatrix2x3dv", ogl.} + proc glMultiTexCoord2d(target: TGLenum, s: TGLdouble, t: TGLdouble) {.importc.} + proc glDrawElementsIndirect(mode: TGLenum, `type`: TGLenum, indirect: pointer) {.importc.} + proc glEnableVertexArrayEXT(vaobj: TGLuint, `array`: TGLenum) {.importc.} + proc glDeleteFramebuffers(n: TGLsizei, framebuffers: TGLuint) {.importc.} + proc glMultiTexCoord3dv(target: TGLenum, v: TGLdouble) {.importc.} + proc glVertexAttrib4d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glLoadPaletteFromModelViewMatrixOES() {.importc.} + proc glVertex3xvOES(coords: TGLfixed) {.importc.} + proc glNormalStream3sATI(stream: TGLenum, nx: TGLshort, ny: TGLshort, nz: TGLshort) {.importc.} + proc glMatrixFrustumEXT(mode: TGLenum, left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} + proc glUniformMatrix2fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glColor4dv(v: TGLdouble) {.importc.} + proc glColor3fv(v: TGLfloat) {.importc.} + proc glVertexAttribI1uiEXT(index: TGLuint, x: TGLuint) {.importc.} + proc glGetDebugMessageLogKHR(count: TGLuint, bufsize: TGLsizei, sources: TGLenum, types: TGLenum, ids: TGLuint, severities: TGLenum, lengths: TGLsizei, messageLog: TGLchar): TGLuint {.importc.} + proc glVertexAttribI2iv(index: TGLuint, v: TGLint) {.importc.} + proc glTexCoord1xvOES(coords: TGLfixed) {.importc.} + proc glVertex3hNV(x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV) {.importc.} + proc glIsShader(shader: TGLuint): TGLboolean {.importc.} + proc glDeleteRenderbuffersEXT(n: TGLsizei, renderbuffers: TGLuint) {.importc.} + proc glVertex3hvNV(v: TGLhalfNV) {.importc.} + proc glGetPointervKHR(pname: TGLenum, params: ptr pointer) {.importc.} + proc glProgramUniform3i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glNamedFramebufferTexture1DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glGetNamedProgramLocalParameterfvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} + proc glGenRenderbuffersOES(n: TGLsizei, renderbuffers: TGLuint) {.importc.} + proc glVertex4dv(v: TGLdouble) {.importc.} + proc glTexCoord2fColor4ubVertex3fvSUN(tc: TGLfloat, c: TGLubyte, v: TGLfloat) {.importc.} + proc glTexStorage2DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glVertexAttrib2d(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} + proc glVertexAttrib1dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glBindProgramARB(target: TGLenum, program: TGLuint) {.importc.} + proc glRasterPos2dv(v: TGLdouble) {.importc.} + proc glCompressedTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glNormalPointervINTEL(`type`: TGLenum, `pointer`: ptr pointer) {.importc.} + proc glGetInteger64vAPPLE(pname: TGLenum, params: TGLint64) {.importc.} + proc glPushMatrix() {.importc.} + proc glGetCompressedTexImageARB(target: TGLenum, level: TGLint, img: pointer) {.importc.} + proc glBindMaterialParameterEXT(face: TGLenum, value: TGLenum): TGLuint {.importc.} + proc glBlendEquationIndexedAMD(buf: TGLuint, mode: TGLenum) {.importc.} + proc glGetObjectBufferfvATI(buffer: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glMakeNamedBufferNonResidentNV(buffer: TGLuint) {.importc.} + proc glUniform2ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc.} + proc glRasterPos4fv(v: TGLfloat) {.importc.} + proc glDeleteTextures(n: TGLsizei, textures: TGLuint) {.importc.} + proc glSecondaryColorPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glEndTilingQCOM(preserveMask: TGLbitfield) {.importc.} + proc glBindBuffer(target: TGLenum, buffer: TGLuint) {.importc.} + proc glUniformMatrix3fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glSamplerParameterf(sampler: TGLuint, pname: TGLenum, param: TGLfloat) {.importc.} + proc glSecondaryColor3d(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc.} + proc glVertexAttrib4sARB(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} + proc glNamedProgramLocalParameterI4iEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glProgramUniform2iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint) {.importc.} + proc glPopAttrib() {.importc.} + proc glGetnColorTableARB(target: TGLenum, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, table: pointer) {.importc.} + proc glMatrixLoadIdentityEXT(mode: TGLenum) {.importc.} + proc glGetNamedProgramivEXT(program: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glCopyTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glUniform4i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc.} + proc glDeleteTexturesEXT(n: TGLsizei, textures: TGLuint) {.importc.} + proc glMultiTexCoord1dv(target: TGLenum, v: TGLdouble) {.importc.} + proc glMultiTexRenderbufferEXT(texunit: TGLenum, target: TGLenum, renderbuffer: TGLuint) {.importc.} + proc glMultiDrawArraysIndirect(mode: TGLenum, indirect: pointer, drawcount: TGLsizei, stride: TGLsizei) {.importc.} + proc glGetUniformfvARB(programObj: TGLhandleARB, location: TGLint, params: TGLfloat) {.importc.} + proc glBufferDataARB(target: TGLenum, size: TGLsizeiptrARB, data: pointer, usage: TGLenum) {.importc.} + proc glTexCoord2d(s: TGLdouble, t: TGLdouble) {.importc.} + proc glGetArrayObjectfvATI(`array`: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glShaderOp1EXT(op: TGLenum, res: TGLuint, arg1: TGLuint) {.importc.} + proc glColor3s(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc.} + proc glStencilFuncSeparate(face: TGLenum, func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} + proc glTextureImage2DMultisampleCoverageNV(texture: TGLuint, target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} + proc glMultiTexCoord2xvOES(texture: TGLenum, coords: TGLfixed) {.importc.} + proc glGetVertexAttribLui64vNV(index: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc.} + proc glNormal3xOES(nx: TGLfixed, ny: TGLfixed, nz: TGLfixed) {.importc.} + proc glMapBufferRangeEXT(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc.} + proc glCreateShader(`type`: TGLenum): TGLuint {.importc.} + proc glDrawRangeElementArrayAPPLE(mode: TGLenum, start: TGLuint, `end`: TGLuint, first: TGLint, count: TGLsizei) {.importc.} + proc glVertex2bOES(x: TGLbyte) {.importc.} + proc glGetMapxvOES(target: TGLenum, query: TGLenum, v: TGLfixed) {.importc.} + proc glRasterPos3sv(v: TGLshort) {.importc.} + proc glDeleteQueriesARB(n: TGLsizei, ids: TGLuint) {.importc.} + proc glProgramUniform1iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glVertexStream2dvATI(stream: TGLenum, coords: TGLdouble) {.importc.} + proc glBindVertexArrayOES(`array`: TGLuint) {.importc.} + proc glLightModelfv(pname: TGLenum, params: TGLfloat) {.importc.} + proc glEvalCoord2dv(u: TGLdouble) {.importc.} + proc glColor3hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV) {.importc.} + proc glSecondaryColor3iEXT(red: TGLint, green: TGLint, blue: TGLint) {.importc.} + proc glBindTexture(target: TGLenum, texture: TGLuint) {.importc.} + proc glUniformBufferEXT(program: TGLuint, location: TGLint, buffer: TGLuint) {.importc.} + proc glGetCombinerInputParameterfvNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glUniform2ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glMatrixMultTransposefEXT(mode: TGLenum, m: TGLfloat) {.importc.} + proc glLineWidth(width: TGLfloat) {.importc.} + proc glRotatef(angle: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glNormalStream3svATI(stream: TGLenum, coords: TGLshort) {.importc.} + proc glTexCoordP4ui(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glImageTransformParameterfvHP(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glUniform3uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} + proc glGetInvariantIntegervEXT(id: TGLuint, value: TGLenum, data: TGLint) {.importc.} + proc glGetTransformFeedbackVaryingEXT(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLsizei, `type`: TGLenum, name: TGLchar) {.importc.} + proc glSamplerParameterIuiv(sampler: TGLuint, pname: TGLenum, param: TGLuint) {.importc.} + proc glProgramUniform2fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} + proc glMultiTexCoord2hvNV(target: TGLenum, v: TGLhalfNV) {.importc.} + proc glDeleteRenderbuffersOES(n: TGLsizei, renderbuffers: TGLuint) {.importc.} + proc glRenderbufferStorageMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glStencilClearTagEXT(stencilTagBits: TGLsizei, stencilClearTag: TGLuint) {.importc.} + proc glConvolutionParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glFenceSyncAPPLE(condition: TGLenum, flags: TGLbitfield): TGLsync {.importc.} + proc glGetVariantArrayObjectivATI(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramUniform4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glPushDebugGroupKHR(source: TGLenum, id: TGLuint, length: TGLsizei, message: TGLchar) {.importc.} + proc glFragmentLightivSGIX(light: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glFramebufferTexture2DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glGetActiveSubroutineUniformiv(program: TGLuint, shadertype: TGLenum, index: TGLuint, pname: TGLenum, values: TGLint) {.importc.} + proc glFrustumf(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} + proc glEndQueryIndexed(target: TGLenum, index: TGLuint) {.importc.} + proc glCompressedTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glGetProgramPipelineInfoLogEXT(pipeline: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc.} + proc glGetVertexAttribfvNV(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexArrayIndexOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glDrawTexsvOES(coords: TGLshort) {.importc.} + proc glMultiTexCoord1hNV(target: TGLenum, s: TGLhalfNV) {.importc.} + proc glWindowPos2iv(v: TGLint) {.importc.} + proc glMultiTexCoordP1ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} + proc glTexCoord1i(s: TGLint) {.importc.} + proc glVertex4hvNV(v: TGLhalfNV) {.importc.} + proc glCallLists(n: TGLsizei, `type`: TGLenum, lists: pointer) {.importc.} + proc glIndexFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc.} + proc glPointParameterfARB(pname: TGLenum, param: TGLfloat) {.importc.} + proc glProgramUniform1dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glGetVertexAttribArrayObjectfvATI(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVDPAUUnmapSurfacesNV(numSurface: TGLsizei, surfaces: TGLvdpauSurfaceNV) {.importc.} + proc glVertexAttribIFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} + proc glClearColorx(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} + proc glColor3bv(v: TGLbyte) {.importc.} + proc glNamedProgramLocalParameter4dEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glVertexPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glGetObjectLabelKHR(identifier: TGLenum, name: TGLuint, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc.} + proc glCombinerStageParameterfvNV(stage: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glNormal3hvNV(v: TGLhalfNV) {.importc.} + proc glUniform2i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT) {.importc.} + proc glMultiTexCoord2iv(target: TGLenum, v: TGLint) {.importc.} + proc glProgramUniform3i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} + proc glDeleteAsyncMarkersSGIX(marker: TGLuint, range: TGLsizei) {.importc.} + proc glStencilOp(fail: TGLenum, zfail: TGLenum, zpass: TGLenum) {.importc.} + proc glColorP4ui(`type`: TGLenum, color: TGLuint) {.importc.} + proc glFinishAsyncSGIX(markerp: TGLuint): TGLint {.importc.} + proc glDrawTexsOES(x: TGLshort, y: TGLshort, z: TGLshort, width: TGLshort, height: TGLshort) {.importc.} + proc glLineStipple(factor: TGLint, pattern: TGLushort) {.importc.} + proc glAlphaFragmentOp1ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint) {.importc.} + proc glMapTexture2DINTEL(texture: TGLuint, level: TGLint, access: TGLbitfield, stride: TGLint, layout: TGLenum) {.importc.} + proc glVertex4f(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glFramebufferTextureARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glProgramUniform3ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc.} + proc glMultTransposeMatrixxOES(m: TGLfixed) {.importc.} + proc glNormal3fv(v: TGLfloat) {.importc.} + proc glUniform4fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} + proc glBinormal3bEXT(bx: TGLbyte, by: TGLbyte, bz: TGLbyte) {.importc.} + proc glGenProgramPipelinesEXT(n: TGLsizei, pipelines: TGLuint) {.importc.} + proc glDispatchComputeIndirect(indirect: TGLintptr) {.importc.} + proc glGetPerfMonitorCounterDataAMD(monitor: TGLuint, pname: TGLenum, dataSize: TGLsizei, data: TGLuint, bytesWritten: TGLint) {.importc.} + proc glStencilOpValueAMD(face: TGLenum, value: TGLuint) {.importc.} + proc glTangent3fvEXT(v: TGLfloat) {.importc.} + proc glUniform3iARB(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} + proc glMatrixScalefEXT(mode: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glVertexAttrib2dARB(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} + proc glIsVertexArray(`array`: TGLuint): TGLboolean {.importc.} + proc glGetMaterialx(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glMultiTexCoord1dARB(target: TGLenum, s: TGLdouble) {.importc.} + proc glColor3usv(v: TGLushort) {.importc.} + proc glVertexStream3svATI(stream: TGLenum, coords: TGLshort) {.importc.} + proc glRasterPos3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} + proc glMultiTexCoord2bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte) {.importc.} + proc glGetClipPlanefOES(plane: TGLenum, equation: TGLfloat) {.importc.} + proc glFramebufferTextureEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glVertexAttrib1dNV(index: TGLuint, x: TGLdouble) {.importc.} + proc glSampleCoverageOES(value: TGLfixed, invert: TGLboolean) {.importc.} + proc glCompressedTexSubImage2DARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} + proc glUniform1iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glExtGetProgramsQCOM(programs: TGLuint, maxPrograms: TGLint, numPrograms: TGLint) {.importc.} + proc glFogx(pname: TGLenum, param: TGLfixed) {.importc.} + proc glMultiTexCoord3hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV) {.importc.} + proc glClipPlane(plane: TGLenum, equation: TGLdouble) {.importc.} + proc glConvolutionParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glInvalidateBufferData(buffer: TGLuint) {.importc.} + proc glCheckNamedFramebufferStatusEXT(framebuffer: TGLuint, target: TGLenum): TGLenum {.importc.} + proc glLinkProgram(program: TGLuint) {.importc.} + proc glCheckFramebufferStatus(target: TGLenum): TGLenum {.importc.} + proc glBlendFunci(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc.} + proc glProgramUniform4uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glConvolutionFilter2D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} + proc glVertex4bvOES(coords: TGLbyte) {.importc.} + proc glCopyTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} + proc glColor4uiv(v: TGLuint) {.importc.} + proc glGetBufferParameteri64v(target: TGLenum, pname: TGLenum, params: TGLint64) {.importc.} + proc glGetLocalConstantBooleanvEXT(id: TGLuint, value: TGLenum, data: TGLboolean) {.importc.} + proc glCoverStrokePathNV(path: TGLuint, coverMode: TGLenum) {.importc.} + proc glScaled(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glLightfv(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTexParameterIiv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glMakeImageHandleResidentNV(handle: TGLuint64, access: TGLenum) {.importc.} + proc glWindowPos3iARB(x: TGLint, y: TGLint, z: TGLint) {.importc.} + proc glListBase(base: TGLuint) {.importc.} + proc glFlushMappedBufferRangeEXT(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr) {.importc.} + proc glNormal3dv(v: TGLdouble) {.importc.} + proc glProgramUniform4d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble, v2: TGLdouble, v3: TGLdouble) {.importc.} + proc glCreateShaderProgramEXT(`type`: TGLenum, string: TGLchar): TGLuint {.importc.} + proc glGetLightxvOES(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glGetObjectPtrLabelKHR(`ptr`: pointer, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc.} + proc glTransformPathNV(resultPath: TGLuint, srcPath: TGLuint, transformType: TGLenum, transformValues: TGLfloat) {.importc.} + proc glMultTransposeMatrixf(m: TGLfloat) {.importc.} + proc glMapVertexAttrib2dAPPLE(index: TGLuint, size: TGLuint, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, points: TGLdouble) {.importc.} + proc glIsSync(sync: TGLsync): TGLboolean {.importc.} + proc glMultMatrixx(m: TGLfixed) {.importc.} + proc glInterpolatePathsNV(resultPath: TGLuint, pathA: TGLuint, pathB: TGLuint, weight: TGLfloat) {.importc.} + proc glEnableClientStateIndexedEXT(`array`: TGLenum, index: TGLuint) {.importc.} + proc glProgramEnvParameter4fARB(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glVertexAttrib2svARB(index: TGLuint, v: TGLshort) {.importc.} + proc glLighti(light: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glSelectBuffer(size: TGLsizei, buffer: TGLuint) {.importc.} + proc glReplacementCodeusvSUN(code: TGLushort) {.importc.} + proc glMapVertexAttrib1fAPPLE(index: TGLuint, size: TGLuint, u1: TGLfloat, u2: TGLfloat, stride: TGLint, order: TGLint, points: TGLfloat) {.importc.} + proc glMaterialx(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glDrawTransformFeedback(mode: TGLenum, id: TGLuint) {.importc.} + proc glWindowPos2i(x: TGLint, y: TGLint) {.importc.} + proc glMultiTexEnviEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glProgramUniform1fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glDrawBuffersARB(n: TGLsizei, bufs: TGLenum) {.importc.} + proc glGetUniformLocationARB(programObj: TGLhandleARB, name: TGLcharARB): TGLint {.importc.} + proc glResumeTransformFeedback() {.importc.} + proc glMap1f(target: TGLenum, u1: TGLfloat, u2: TGLfloat, stride: TGLint, order: TGLint, points: TGLfloat) {.importc.} + proc glVertex3xOES(x: TGLfixed, y: TGLfixed) {.importc.} + proc glPathCoordsNV(path: TGLuint, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} + proc glListParameterfSGIX(list: TGLuint, pname: TGLenum, param: TGLfloat) {.importc.} + proc glGetUniformivARB(programObj: TGLhandleARB, location: TGLint, params: TGLint) {.importc.} + proc glBinormal3bvEXT(v: TGLbyte) {.importc.} + proc glVertexAttribP3ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} + proc glGetVertexArrayPointeri_vEXT(vaobj: TGLuint, index: TGLuint, pname: TGLenum, param: ptr pointer) {.importc.} + proc glProgramParameter4fvNV(target: TGLenum, index: TGLuint, v: TGLfloat) {.importc.} + proc glDiscardFramebufferEXT(target: TGLenum, numAttachments: TGLsizei, attachments: TGLenum) {.importc.} + proc glGetDebugMessageLogARB(count: TGLuint, bufsize: TGLsizei, sources: TGLenum, types: TGLenum, ids: TGLuint, severities: TGLenum, lengths: TGLsizei, messageLog: TGLchar): TGLuint {.importc.} + proc glResolveMultisampleFramebufferAPPLE() {.importc.} + proc glGetIntegeri_vEXT(target: TGLenum, index: TGLuint, data: TGLint) {.importc.} + proc glDepthBoundsdNV(zmin: TGLdouble, zmax: TGLdouble) {.importc.} + proc glEnd() {.importc.} + proc glBindBufferBaseEXT(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc.} + proc glVertexAttribDivisor(index: TGLuint, divisor: TGLuint) {.importc.} + proc glFogCoorddEXT(coord: TGLdouble) {.importc.} + proc glFrontFace(mode: TGLenum) {.importc.} + proc glVertexAttrib1hNV(index: TGLuint, x: TGLhalfNV) {.importc.} + proc glNamedProgramLocalParametersI4uivEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLuint) {.importc.} + proc glTexCoord1dv(v: TGLdouble) {.importc.} + proc glBindVideoCaptureStreamTextureNV(video_capture_slot: TGLuint, stream: TGLuint, frame_region: TGLenum, target: TGLenum, texture: TGLuint) {.importc.} + proc glWindowPos2iARB(x: TGLint, y: TGLint) {.importc.} + proc glVertexAttribFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei) {.importc.} + proc glUniform1uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glGetVideoivNV(video_slot: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexAttrib3fvARB(index: TGLuint, v: TGLfloat) {.importc.} + proc glVertexArraySecondaryColorOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glSecondaryColor3bv(v: TGLbyte) {.importc.} + proc glDispatchComputeGroupSizeARB(num_groups_x: TGLuint, num_groups_y: TGLuint, num_groups_z: TGLuint, group_size_x: TGLuint, group_size_y: TGLuint, group_size_z: TGLuint) {.importc.} + proc glNamedCopyBufferSubDataEXT(readBuffer: TGLuint, writeBuffer: TGLuint, readOffset: TGLintptr, writeOffset: TGLintptr, size: TGLsizeiptr) {.importc.} + proc glSampleCoverage(value: TGLfloat, invert: TGLboolean) {.importc.} + proc glGetnMapfvARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: TGLfloat) {.importc.} + proc glVertexStream2svATI(stream: TGLenum, coords: TGLshort) {.importc.} + proc glProgramParameters4fvNV(target: TGLenum, index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} + proc glVertexAttrib4fARB(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glIndexd(c: TGLdouble) {.importc.} + proc glGetInteger64v(pname: TGLenum, params: TGLint64) {.importc.} + proc glGetMultiTexImageEXT(texunit: TGLenum, target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glLightModelx(pname: TGLenum, param: TGLfixed) {.importc.} + proc glMap2f(target: TGLenum, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, points: TGLfloat) {.importc.} + proc glSecondaryColorPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} + proc glVertexArrayVertexAttribIOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glProgramUniformHandleui64vARB(program: TGLuint, location: TGLint, count: TGLsizei, values: TGLuint64) {.importc.} + proc glActiveProgramEXT(program: TGLuint) {.importc.} + proc glProgramUniformMatrix4x3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glCompressedTexSubImage3DARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} + proc glBindProgramPipelineEXT(pipeline: TGLuint) {.importc.} + proc glDetailTexFuncSGIS(target: TGLenum, n: TGLsizei, points: TGLfloat) {.importc.} + proc glSecondaryColor3ubEXT(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc.} + proc glDrawArraysInstanced(mode: TGLenum, first: TGLint, count: TGLsizei, instancecount: TGLsizei) {.importc.} + proc glWindowPos3fARB(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glNamedProgramLocalParameter4fEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glTextureParameterfvEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glProgramUniformHandleui64ARB(program: TGLuint, location: TGLint, value: TGLuint64) {.importc.} + proc glHistogramEXT(target: TGLenum, width: TGLsizei, internalformat: TGLenum, sink: TGLboolean) {.importc.} + proc glResumeTransformFeedbackNV() {.importc.} + proc glGetMaterialxv(face: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glMultiTexCoord1sv(target: TGLenum, v: TGLshort) {.importc.} + proc glReadInstrumentsSGIX(marker: TGLint) {.importc.} + proc glTexCoord4hNV(s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV, q: TGLhalfNV) {.importc.} + proc glVertexAttribL4i64vNV(index: TGLuint, v: TGLint64EXT) {.importc.} + proc glEnableVariantClientStateEXT(id: TGLuint) {.importc.} + proc glSyncTextureINTEL(texture: TGLuint) {.importc.} + proc glGetObjectPtrLabel(`ptr`: pointer, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc.} + proc glCopyTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} + proc glOrthofOES(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} + proc glWindowPos3sARB(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} + proc glIsBufferARB(buffer: TGLuint): TGLboolean {.importc.} + proc glColor3sv(v: TGLshort) {.importc.} + proc glEvalMesh1(mode: TGLenum, i1: TGLint, i2: TGLint) {.importc.} + proc glMultiDrawArrays(mode: TGLenum, first: TGLint, count: TGLsizei, drawcount: TGLsizei) {.importc.} + proc glGetMultiTexEnvfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glWindowPos3fMESA(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glExtGetFramebuffersQCOM(framebuffers: TGLuint, maxFramebuffers: TGLint, numFramebuffers: TGLint) {.importc.} + proc glTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glVertexAttrib4uiv(index: TGLuint, v: TGLuint) {.importc.} + proc glProgramUniformui64NV(program: TGLuint, location: TGLint, value: TGLuint64EXT) {.importc.} + proc glMultiTexCoord2ivARB(target: TGLenum, v: TGLint) {.importc.} + proc glProgramUniform4i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc.} + proc glWindowPos2svMESA(v: TGLshort) {.importc.} + proc glVertexAttrib3dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glColor4i(red: TGLint, green: TGLint, blue: TGLint, alpha: TGLint) {.importc.} + proc glClampColor(target: TGLenum, clamp: TGLenum) {.importc.} + proc glVertexP2ui(`type`: TGLenum, value: TGLuint) {.importc.} + proc glGenQueries(n: TGLsizei, ids: TGLuint) {.importc.} + proc glBindBufferOffsetNV(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr) {.importc.} + proc glGetFragDataLocation(program: TGLuint, name: TGLchar): TGLint {.importc.} + proc glVertexAttribs2svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc.} + proc glGetPathLengthNV(path: TGLuint, startSegment: TGLsizei, numSegments: TGLsizei): TGLfloat {.importc.} + proc glVertexAttrib3dARB(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glMultiTexGenfvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glFlushPixelDataRangeNV(target: TGLenum) {.importc.} + proc glReplacementCodeuiNormal3fVertex3fSUN(rc: TGLuint, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glPathParameteriNV(path: TGLuint, pname: TGLenum, value: TGLint) {.importc.} + proc glVertexAttribI2iEXT(index: TGLuint, x: TGLint, y: TGLint) {.importc.} + proc glPixelStorei(pname: TGLenum, param: TGLint) {.importc.} + proc glGetNamedFramebufferParameterivEXT(framebuffer: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetTexEnvxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glPathStringNV(path: TGLuint, format: TGLenum, length: TGLsizei, pathString: pointer) {.importc.} + proc glDepthMask(flag: TGLboolean) {.importc.} + proc glCopyTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} + proc glDepthRangexOES(n: TGLfixed, f: TGLfixed) {.importc.} + proc glUniform2i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glSetFragmentShaderConstantATI(dst: TGLuint, value: TGLfloat) {.importc.} + proc glAttachShader(program: TGLuint, shader: TGLuint) {.importc.} + proc glGetFramebufferParameterivEXT(framebuffer: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glPointParameteriNV(pname: TGLenum, param: TGLint) {.importc.} + proc glWindowPos2dMESA(x: TGLdouble, y: TGLdouble) {.importc.} + proc glGetTextureParameterfvEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTexBumpParameterfvATI(pname: TGLenum, param: TGLfloat) {.importc.} + proc glCompressedTexImage1DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} + proc glGetTexGendv(coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc.} + proc glGetFragmentMaterialfvSGIX(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glBeginConditionalRenderNVX(id: TGLuint) {.importc.} + proc glLightModelxOES(pname: TGLenum, param: TGLfixed) {.importc.} + proc glTexCoord2xOES(s: TGLfixed, t: TGLfixed) {.importc.} + proc glProgramUniformMatrix2x4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glRasterPos2xvOES(coords: TGLfixed) {.importc.} + proc glGetMapiv(target: TGLenum, query: TGLenum, v: TGLint) {.importc.} + proc glGetImageHandleARB(texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, format: TGLenum): TGLuint64 {.importc.} + proc glVDPAURegisterVideoSurfaceNV(vdpSurface: pointer, target: TGLenum, numTextureNames: TGLsizei, textureNames: TGLuint): TGLvdpauSurfaceNV {.importc.} + proc glVertexAttribL2dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} + proc glVertexAttrib1dvNV(index: TGLuint, v: TGLdouble) {.importc.} + proc glPollAsyncSGIX(markerp: TGLuint): TGLint {.importc.} + proc glCullParameterfvEXT(pname: TGLenum, params: TGLfloat) {.importc.} + proc glMakeNamedBufferResidentNV(buffer: TGLuint, access: TGLenum) {.importc.} + proc glPointParameterfSGIS(pname: TGLenum, param: TGLfloat) {.importc.} + proc glGenLists(range: TGLsizei): TGLuint {.importc.} + proc glGetTexBumpParameterfvATI(pname: TGLenum, param: TGLfloat) {.importc.} + proc glCompressedMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glFinishFenceNV(fence: TGLuint) {.importc.} + proc glPointSize(size: TGLfloat) {.importc.} + proc glCompressedTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glGetUniformui64vNV(program: TGLuint, location: TGLint, params: TGLuint64EXT) {.importc.} + proc glGetMapControlPointsNV(target: TGLenum, index: TGLuint, `type`: TGLenum, ustride: TGLsizei, vstride: TGLsizei, packed: TGLboolean, points: pointer) {.importc.} + proc glGetPathColorGenfvNV(color: TGLenum, pname: TGLenum, value: TGLfloat) {.importc.} + proc glTexCoord2f(s: TGLfloat, t: TGLfloat) {.importc.} + proc glSampleMaski(index: TGLuint, mask: TGLbitfield) {.importc.} + proc glReadBufferIndexedEXT(src: TGLenum, index: TGLint) {.importc.} + proc glCoverFillPathNV(path: TGLuint, coverMode: TGLenum) {.importc.} + proc glColorTableParameterfvSGI(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glDeleteVertexArraysAPPLE(n: TGLsizei, arrays: TGLuint) {.importc.} + proc glGetVertexAttribIiv(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glWeightbvARB(size: TGLint, weights: TGLbyte) {.importc.} + proc glGetNamedBufferPointervEXT(buffer: TGLuint, pname: TGLenum, params: ptr pointer) {.importc.} + proc glTexCoordPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glColor4fv(v: TGLfloat) {.importc.} + proc glGetnUniformfvARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLfloat) {.importc.} + proc glMaterialxOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glGetFixedv(pname: TGLenum, params: TGLfixed) {.importc.} + proc glMaterialf(face: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glVideoCaptureStreamParameterfvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetDebugMessageLogAMD(count: TGLuint, bufsize: TGLsizei, categories: TGLenum, severities: TGLuint, ids: TGLuint, lengths: TGLsizei, message: TGLchar): TGLuint {.importc.} + proc glProgramUniform2uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glMatrixMultTransposedEXT(mode: TGLenum, m: TGLdouble) {.importc.} + proc glIsPointInStrokePathNV(path: TGLuint, x: TGLfloat, y: TGLfloat): TGLboolean {.importc.} + proc glDisable(cap: TGLenum) {.importc.} + proc glCompileShader(shader: TGLuint) {.importc.} + proc glLoadTransposeMatrixd(m: TGLdouble) {.importc.} + proc glGetMultiTexParameterIuivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glGetHistogram(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} + proc glMultiTexCoord3fvARB(target: TGLenum, v: TGLfloat) {.importc.} + proc glColor4xvOES(components: TGLfixed) {.importc.} + proc glIsBuffer(buffer: TGLuint): TGLboolean {.importc.} + proc glVertex2dv(v: TGLdouble) {.importc.} + proc glNamedProgramLocalParameterI4uivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glPixelTexGenParameteriSGIS(pname: TGLenum, param: TGLint) {.importc.} + proc glBindVertexBuffers(first: TGLuint, count: TGLsizei, buffers: TGLuint, offsets: TGLintptr, strides: TGLsizei) {.importc.} + proc glUniform1ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glColor4ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte, alpha: TGLubyte) {.importc.} + proc glConvolutionParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc: TGLuint, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glVertexAttribI2ui(index: TGLuint, x: TGLuint, y: TGLuint) {.importc.} + proc glDeleteNamesAMD(identifier: TGLenum, num: TGLuint, names: TGLuint) {.importc.} + proc glPixelTransferxOES(pname: TGLenum, param: TGLfixed) {.importc.} + proc glVertexAttrib4ivARB(index: TGLuint, v: TGLint) {.importc.} + proc glLightModeli(pname: TGLenum, param: TGLint) {.importc.} + proc glGetHistogramEXT(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} + proc glWindowPos3svMESA(v: TGLshort) {.importc.} + proc glRasterPos3iv(v: TGLint) {.importc.} + proc glCopyTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glTextureStorage3DMultisampleEXT(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} + proc glIsNameAMD(identifier: TGLenum, name: TGLuint): TGLboolean {.importc.} + proc glProgramUniformMatrix3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glGetProgramParameterfvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTexStorage3D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} + proc glMultiTexCoord2xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed) {.importc.} + proc glWindowPos2fARB(x: TGLfloat, y: TGLfloat) {.importc.} + proc glGetProgramResourceIndex(program: TGLuint, programInterface: TGLenum, name: TGLchar): TGLuint {.importc.} + proc glProgramUniform2uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glMakeImageHandleNonResidentNV(handle: TGLuint64) {.importc.} + proc glNamedProgramLocalParameter4fvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} + proc glInvalidateFramebuffer(target: TGLenum, numAttachments: TGLsizei, attachments: TGLenum) {.importc.} + proc glTexStorage3DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} + proc glMapVertexAttrib2fAPPLE(index: TGLuint, size: TGLuint, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, points: TGLfloat) {.importc.} + proc glCombinerParameterfNV(pname: TGLenum, param: TGLfloat) {.importc.} + proc glCopyMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} + proc glBindVertexShaderEXT(id: TGLuint) {.importc.} + proc glPathGlyphsNV(firstPathName: TGLuint, fontTarget: TGLenum, fontName: pointer, fontStyle: TGLbitfield, numGlyphs: TGLsizei, `type`: TGLenum, charcodes: pointer, handleMissingGlyphs: TGLenum, pathParameterTemplate: TGLuint, emScale: TGLfloat) {.importc.} + proc glProgramLocalParametersI4uivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLuint) {.importc.} + proc glMultiTexCoord3hvNV(target: TGLenum, v: TGLhalfNV) {.importc.} + proc glMultiTexCoordP2uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} + proc glDisableVariantClientStateEXT(id: TGLuint) {.importc.} + proc glGetTexLevelParameterxvOES(target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfixed) {.importc.} + proc glRasterPos2sv(v: TGLshort) {.importc.} + proc glWeightPathsNV(resultPath: TGLuint, numPaths: TGLsizei, paths: TGLuint, weights: TGLfloat) {.importc.} + proc glDrawBuffersNV(n: TGLsizei, bufs: TGLenum) {.importc.} + proc glBindBufferARB(target: TGLenum, buffer: TGLuint) {.importc.} + proc glVariantbvEXT(id: TGLuint, `addr`: TGLbyte) {.importc.} + proc glColorP3uiv(`type`: TGLenum, color: TGLuint) {.importc.} + proc glBlendEquationEXT(mode: TGLenum) {.importc.} + proc glProgramLocalParameterI4uivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glRenderMode(mode: TGLenum): TGLint {.importc.} + proc glVertexStream4fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glGetObjectLabelEXT(`type`: TGLenum, `object`: TGLuint, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc.} + proc glNamedFramebufferTexture3DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} + proc glLoadMatrixf(m: TGLfloat) {.importc.} + proc glGetQueryObjectuivEXT(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glBindVideoCaptureStreamBufferNV(video_capture_slot: TGLuint, stream: TGLuint, frame_region: TGLenum, offset: TGLintptrARB) {.importc.} + proc glMatrixOrthoEXT(mode: TGLenum, left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} + proc glBlendFunc(sfactor: TGLenum, dfactor: TGLenum) {.importc.} + proc glTexGenxvOES(coord: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glMatrixMode(mode: TGLenum) {.importc.} + proc glColorTableParameterivSGI(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetProgramInfoLog(program: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc.} + proc glGetSeparableFilter(target: TGLenum, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer, span: pointer) {.importc.} + proc glFogfv(pname: TGLenum, params: TGLfloat) {.importc.} + proc glDrawTexfvOES(coords: TGLfloat) {.importc.} + proc glClipPlanexIMG(p: TGLenum, eqn: TGLfixed) {.importc.} + proc glResetHistogramEXT(target: TGLenum) {.importc.} + proc glMemoryBarrier(barriers: TGLbitfield) {.importc.} + proc glGetPixelMapusv(map: TGLenum, values: TGLushort) {.importc.} + proc glEvalCoord2f(u: TGLfloat, v: TGLfloat) {.importc.} + proc glUniform4uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glIsProgramARB(program: TGLuint): TGLboolean {.importc.} + proc glPointParameterfv(pname: TGLenum, params: TGLfloat) {.importc.} + proc glTexBuffer(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} + proc glVertexAttrib1s(index: TGLuint, x: TGLshort) {.importc.} + proc glRenderbufferStorageMultisampleEXT(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glMapNamedBufferEXT(buffer: TGLuint, access: TGLenum) {.importc.} + proc glDebugMessageCallbackAMD(callback: TGLDEBUGPROCAMD, userParam: pointer) {.importc.} + proc glGetTexEnvfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexAttribI3uivEXT(index: TGLuint, v: TGLuint) {.importc.} + proc glMultiTexEnvfEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glGetUniformiv(program: TGLuint, location: TGLint, params: TGLint) {.importc.} + proc glProgramLocalParameters4fvEXT(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLfloat) {.importc.} + proc glStencilStrokePathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, reference: TGLint, mask: TGLuint, transformType: TGLenum, transformValues: TGLfloat) {.importc.} + proc glBeginConditionalRender(id: TGLuint, mode: TGLenum) {.importc.} + proc glVertexAttribI3uiEXT(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint) {.importc.} + proc glVDPAUMapSurfacesNV(numSurfaces: TGLsizei, surfaces: TGLvdpauSurfaceNV) {.importc.} + proc glGetProgramResourceName(program: TGLuint, programInterface: TGLenum, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, name: TGLchar) {.importc.} + proc glMultiTexCoord4f(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc.} + proc glVertexAttrib2hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV) {.importc.} + proc glDrawArraysInstancedNV(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glClearAccum(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} + proc glVertexAttribI4usv(index: TGLuint, v: TGLushort) {.importc.} + proc glGetProgramNamedParameterfvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, params: TGLfloat) {.importc.} + proc glTextureLightEXT(pname: TGLenum) {.importc.} + proc glPathSubCoordsNV(path: TGLuint, coordStart: TGLsizei, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} + proc glBindImageTexture(unit: TGLuint, texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, access: TGLenum, format: TGLenum) {.importc.} + proc glGenVertexArraysAPPLE(n: TGLsizei, arrays: TGLuint) {.importc.} + proc glFogCoordf(coord: TGLfloat) {.importc.} + proc glFrameTerminatorGREMEDY() {.importc.} + proc glValidateProgramPipelineEXT(pipeline: TGLuint) {.importc.} + proc glScalexOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} + proc glReplacementCodeuiColor3fVertex3fvSUN(rc: TGLuint, c: TGLfloat, v: TGLfloat) {.importc.} + proc glProgramNamedParameter4dNV(id: TGLuint, len: TGLsizei, name: TGLubyte, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glMultiDrawElementsIndirectCountARB(mode: TGLenum, `type`: TGLenum, indirect: TGLintptr, drawcount: TGLintptr, maxdrawcount: TGLsizei, stride: TGLsizei) {.importc.} + proc glReferencePlaneSGIX(equation: TGLdouble) {.importc.} + proc glNormalStream3iATI(stream: TGLenum, nx: TGLint, ny: TGLint, nz: TGLint) {.importc.} + proc glGetColorTableParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetAttribLocation(program: TGLuint, name: TGLchar): TGLint {.importc.} + proc glMultiTexParameterfEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glGenFencesNV(n: TGLsizei, fences: TGLuint) {.importc.} + proc glUniform4dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glGetTexLevelParameterfv(target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glProgramUniform1ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glProgramUniform1dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glLoadTransposeMatrixdARB(m: TGLdouble) {.importc.} + proc glVertexAttrib2fvARB(index: TGLuint, v: TGLfloat) {.importc.} + proc glMultiTexGendEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLdouble) {.importc.} + proc glProgramUniformMatrix4x3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glUniform4ui(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} + proc glTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glVertexAttrib3hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV) {.importc.} + proc glRotatexOES(angle: TGLfixed, x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} + proc glGenTextures(n: TGLsizei, textures: TGLuint) {.importc.} + proc glCheckFramebufferStatusOES(target: TGLenum): TGLenum {.importc.} + proc glGetVideoCaptureStreamdvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glCompressedTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glCurrentPaletteMatrixOES(matrixpaletteindex: TGLuint) {.importc.} + proc glCompressedMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glNormal3d(nx: TGLdouble, ny: TGLdouble, nz: TGLdouble) {.importc.} + proc glMultiTexCoord1fv(target: TGLenum, v: TGLfloat) {.importc.} + proc glProgramUniform2uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} + proc glMultiTexCoord3fARB(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc.} + proc glRasterPos3xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} + proc glEGLImageTargetRenderbufferStorageOES(target: TGLenum, image: TGLeglImageOES) {.importc.} + proc glGetAttribLocationARB(programObj: TGLhandleARB, name: TGLcharARB): TGLint {.importc.} + proc glProgramNamedParameter4dvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, v: TGLdouble) {.importc.} + proc glProgramLocalParameterI4uiNV(target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} + proc glNamedFramebufferTextureFaceEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc.} + proc glIndexf(c: TGLfloat) {.importc.} + proc glExtTexObjectStateOverrideiQCOM(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glCoverageOperationNV(operation: TGLenum) {.importc.} + proc glColorP4uiv(`type`: TGLenum, color: TGLuint) {.importc.} + proc glDeleteSync(sync: TGLsync) {.importc.} + proc glGetHistogramParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTexCoord4fColor4fNormal3fVertex4fSUN(s: TGLfloat, t: TGLfloat, p: TGLfloat, q: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glEndPerfMonitorAMD(monitor: TGLuint) {.importc.} + proc glGetInternalformati64v(target: TGLenum, internalformat: TGLenum, pname: TGLenum, bufSize: TGLsizei, params: TGLint64) {.importc.} + proc glGenNamesAMD(identifier: TGLenum, num: TGLuint, names: TGLuint) {.importc.} + proc glDrawElementsInstancedBaseVertexBaseInstance(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei, basevertex: TGLint, baseinstance: TGLuint) {.importc.} + proc glMultiTexCoord4i(target: TGLenum, s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc.} + proc glVertexAttribL1dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glGetProgramNamedParameterdvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, params: TGLdouble) {.importc.} + proc glSetLocalConstantEXT(id: TGLuint, `type`: TGLenum, `addr`: pointer) {.importc.} + proc glProgramBinary(program: TGLuint, binaryFormat: TGLenum, binary: pointer, length: TGLsizei) {.importc.} + proc glVideoCaptureNV(video_capture_slot: TGLuint, sequence_num: TGLuint, capture_time: TGLuint64EXT): TGLenum {.importc.} + proc glDebugMessageEnableAMD(category: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc.} + proc glVertexAttribI1i(index: TGLuint, x: TGLint) {.importc.} + proc glVertexWeighthNV(weight: TGLhalfNV) {.importc.} + proc glTextureParameterIivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glClipPlanefIMG(p: TGLenum, eqn: TGLfloat) {.importc.} + proc glGetLightxv(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glGetAttachedObjectsARB(containerObj: TGLhandleARB, maxCount: TGLsizei, count: TGLsizei, obj: TGLhandleARB) {.importc.} + proc glVertexAttrib4fv(index: TGLuint, v: TGLfloat) {.importc.} + proc glDisableVertexAttribArrayARB(index: TGLuint) {.importc.} + proc glWindowPos3fvARB(v: TGLfloat) {.importc.} + proc glClearDepthdNV(depth: TGLdouble) {.importc.} + proc glMapParameterivNV(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glEndConditionalRenderNVX() {.importc.} + proc glGetFragmentLightivSGIX(light: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramUniformMatrix4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glVertexStream1iATI(stream: TGLenum, x: TGLint) {.importc.} + proc glColorP3ui(`type`: TGLenum, color: TGLuint) {.importc.} + proc glGetLightxOES(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glGetLightiv(light: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexStream3dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glProgramUniform1iEXT(program: TGLuint, location: TGLint, v0: TGLint) {.importc.} + proc glSecondaryColorFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} + proc glDrawElementsBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, basevertex: TGLint) {.importc.} + proc glGenFencesAPPLE(n: TGLsizei, fences: TGLuint) {.importc.} + proc glBinormal3svEXT(v: TGLshort) {.importc.} + proc glUseProgramStagesEXT(pipeline: TGLuint, stages: TGLbitfield, program: TGLuint) {.importc.} + proc glDebugMessageCallbackKHR(callback: TGLDEBUGPROCKHR, userParam: pointer) {.importc.} + proc glCopyMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glColor4hvNV(v: TGLhalfNV) {.importc.} + proc glFenceSync(condition: TGLenum, flags: TGLbitfield): TGLsync {.importc.} + proc glTexCoordPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} + proc glPopName() {.importc.} + proc glColor3fVertex3fvSUN(c: TGLfloat, v: TGLfloat) {.importc.} + proc glGetUniformfv(program: TGLuint, location: TGLint, params: TGLfloat) {.importc.} + proc glMultiTexCoord2hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV) {.importc.} + proc glLightxv(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glVideoCaptureStreamParameterivNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glEvalCoord1xvOES(coords: TGLfixed) {.importc.} + proc glGetProgramEnvParameterIivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc.} + proc glObjectPurgeableAPPLE(objectType: TGLenum, name: TGLuint, option: TGLenum): TGLenum {.importc.} + proc glRequestResidentProgramsNV(n: TGLsizei, programs: TGLuint) {.importc.} + proc glIsImageHandleResidentNV(handle: TGLuint64): TGLboolean {.importc.} + proc glColor3hvNV(v: TGLhalfNV) {.importc.} + proc glMultiTexCoord2dARB(target: TGLenum, s: TGLdouble, t: TGLdouble) {.importc.} + proc glDeletePathsNV(path: TGLuint, range: TGLsizei) {.importc.} + proc glVertexAttrib4Nsv(index: TGLuint, v: TGLshort) {.importc.} + proc glTexEnvf(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glGlobalAlphaFactoriSUN(factor: TGLint) {.importc.} + proc glBlendColorEXT(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} + proc glSecondaryColor3usvEXT(v: TGLushort) {.importc.} + proc glProgramEnvParameterI4uiNV(target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} + proc glTexImage4DSGIS(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, size4d: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glMatrixPushEXT(mode: TGLenum) {.importc.} + proc glGetPixelTexGenParameterivSGIS(pname: TGLenum, params: TGLint) {.importc.} + proc glVariantuivEXT(id: TGLuint, `addr`: TGLuint) {.importc.} + proc glTexParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetSubroutineUniformLocation(program: TGLuint, shadertype: TGLenum, name: TGLchar): TGLint {.importc.} + proc glProgramUniformMatrix3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glDrawBuffersATI(n: TGLsizei, bufs: TGLenum) {.importc.} + proc glGetVertexAttribivNV(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glMultiTexCoord4bvOES(texture: TGLenum, coords: TGLbyte) {.importc.} + proc glCompressedTexSubImage1DARB(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} + proc glClientActiveTexture(texture: TGLenum) {.importc.} + proc glVertexAttrib2fARB(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc.} + proc glProgramUniform2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glGetBufferParameterui64vNV(target: TGLenum, pname: TGLenum, params: TGLuint64EXT) {.importc.} + proc glVertexStream3dvATI(stream: TGLenum, coords: TGLdouble) {.importc.} + proc glReplacementCodeuiNormal3fVertex3fvSUN(rc: TGLuint, n: TGLfloat, v: TGLfloat) {.importc.} + proc glVertexAttrib4svNV(index: TGLuint, v: TGLshort) {.importc.} + proc glClearBufferSubData(target: TGLenum, internalformat: TGLenum, offset: TGLintptr, size: TGLsizeiptr, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glVertexStream2sATI(stream: TGLenum, x: TGLshort, y: TGLshort) {.importc.} + proc glTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glGetListParameterfvSGIX(list: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glUniform3uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glIsTexture(texture: TGLuint): TGLboolean {.importc.} + proc glObjectUnpurgeableAPPLE(objectType: TGLenum, name: TGLuint, option: TGLenum): TGLenum {.importc.} + proc glGetVertexAttribdv(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glGetPointeri_vEXT(pname: TGLenum, index: TGLuint, params: ptr pointer) {.importc.} + proc glSampleCoveragex(value: TGLclampx, invert: TGLboolean) {.importc.} + proc glColor3f(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc.} + proc glGetnMapivARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: TGLint) {.importc.} + proc glMakeTextureHandleResidentARB(handle: TGLuint64) {.importc.} + proc glSecondaryColorP3ui(`type`: TGLenum, color: TGLuint) {.importc.} + proc glMultiTexCoord4sARB(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc.} + proc glUniform3i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc.} + proc glVDPAUGetSurfaceivNV(surface: TGLvdpauSurfaceNV, pname: TGLenum, bufSize: TGLsizei, length: TGLsizei, values: TGLint) {.importc.} + proc glTexBufferEXT(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} + proc glVertexAttribI4ubvEXT(index: TGLuint, v: TGLubyte) {.importc.} + proc glDeleteFramebuffersOES(n: TGLsizei, framebuffers: TGLuint) {.importc.} + proc glColor3fVertex3fSUN(r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glCombinerInputNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, input: TGLenum, mapping: TGLenum, componentUsage: TGLenum) {.importc.} + proc glPolygonOffsetEXT(factor: TGLfloat, bias: TGLfloat) {.importc.} + proc glWindowPos4dMESA(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glVertex3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glTexCoord3f(s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc.} + proc glMultiTexCoord1fARB(target: TGLenum, s: TGLfloat) {.importc.} + proc glVertexAttrib4f(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glGetFragDataLocationEXT(program: TGLuint, name: TGLchar): TGLint {.importc.} + proc glFlushMappedNamedBufferRangeEXT(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr) {.importc.} + proc glVertexAttrib1sARB(index: TGLuint, x: TGLshort) {.importc.} + proc glBitmapxOES(width: TGLsizei, height: TGLsizei, xorig: TGLfixed, yorig: TGLfixed, xmove: TGLfixed, ymove: TGLfixed, bitmap: TGLubyte) {.importc.} + proc glEnableVertexArrayAttribEXT(vaobj: TGLuint, index: TGLuint) {.importc.} + proc glDeleteRenderbuffers(n: TGLsizei, renderbuffers: TGLuint) {.importc.} + proc glFramebufferRenderbuffer(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} + proc glInvalidateTexImage(texture: TGLuint, level: TGLint) {.importc.} + proc glProgramUniform2i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT) {.importc.} + proc glTextureImage3DMultisampleNV(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} + proc glValidateProgram(program: TGLuint) {.importc.} + proc glUniform1dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glNormalStream3dvATI(stream: TGLenum, coords: TGLdouble) {.importc.} + proc glMultiDrawElementsIndirect(mode: TGLenum, `type`: TGLenum, indirect: pointer, drawcount: TGLsizei, stride: TGLsizei) {.importc.} + proc glVertexBlendARB(count: TGLint) {.importc.} + proc glIsSampler(sampler: TGLuint): TGLboolean {.importc.} + proc glVariantdvEXT(id: TGLuint, `addr`: TGLdouble) {.importc.} + proc glProgramUniformMatrix3x2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glVertexStream4fvATI(stream: TGLenum, coords: TGLfloat) {.importc.} + proc glOrthoxOES(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} + proc glColorFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} + proc glFogCoordPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glVertexAttrib3dvARB(index: TGLuint, v: TGLdouble) {.importc.} + proc glVertex3bOES(x: TGLbyte, y: TGLbyte) {.importc.} + proc glVertexAttribFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, relativeoffset: TGLuint) {.importc.} + proc glTexCoord4fVertex4fSUN(s: TGLfloat, t: TGLfloat, p: TGLfloat, q: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glEnableDriverControlQCOM(driverControl: TGLuint) {.importc.} + proc glPointParameteri(pname: TGLenum, param: TGLint) {.importc.} + proc glVertexAttribI2i(index: TGLuint, x: TGLint, y: TGLint) {.importc.} + proc glGetDriverControlStringQCOM(driverControl: TGLuint, bufSize: TGLsizei, length: TGLsizei, driverControlString: TGLchar) {.importc.} + proc glGetTexLevelParameteriv(target: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetHandleARB(pname: TGLenum): TGLhandleARB {.importc.} + proc glIndexubv(c: TGLubyte) {.importc.} + proc glBlendFunciARB(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc.} + proc glColor4usv(v: TGLushort) {.importc.} + proc glBlendEquationSeparateOES(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} + proc glVertexAttribI4ui(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} + proc glProgramUniform3f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} + proc glVertexAttribL3i64vNV(index: TGLuint, v: TGLint64EXT) {.importc.} + proc glWeightdvARB(size: TGLint, weights: TGLdouble) {.importc.} + proc glVertexArrayRangeAPPLE(length: TGLsizei, `pointer`: pointer) {.importc.} + proc glMapGrid2d(un: TGLint, u1: TGLdouble, u2: TGLdouble, vn: TGLint, v1: TGLdouble, v2: TGLdouble) {.importc.} + proc glFogiv(pname: TGLenum, params: TGLint) {.importc.} + proc glUniform2f(location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} + proc glGetDoublei_v(target: TGLenum, index: TGLuint, data: TGLdouble) {.importc.} + proc glGetVertexAttribfv(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexAttribI2ivEXT(index: TGLuint, v: TGLint) {.importc.} + proc glIsProgramNV(id: TGLuint): TGLboolean {.importc.} + proc glTexCoord1hNV(s: TGLhalfNV) {.importc.} + proc glMinSampleShadingARB(value: TGLfloat) {.importc.} + proc glMultiDrawElements(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, drawcount: TGLsizei) {.importc.} + proc glGetQueryObjectuiv(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glReadBuffer(mode: TGLenum) {.importc.} + proc glMultiTexCoordP3uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} + proc glUniformMatrix3x2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glBindRenderbuffer(target: TGLenum, renderbuffer: TGLuint) {.importc.} + proc glBinormal3sEXT(bx: TGLshort, by: TGLshort, bz: TGLshort) {.importc.} + proc glUniform4iARB(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} + proc glGetUniformOffsetEXT(program: TGLuint, location: TGLint): TGLintptr {.importc.} + proc glDeleteLists(list: TGLuint, range: TGLsizei) {.importc.} + proc glVertexAttribI1iEXT(index: TGLuint, x: TGLint) {.importc.} + proc glFramebufferTexture1D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glVertexAttribI2uiv(index: TGLuint, v: TGLuint) {.importc.} + proc glBindFragDataLocation(program: TGLuint, color: TGLuint, name: TGLchar) {.importc.} + proc glClearStencil(s: TGLint) {.importc.} + proc glVertexAttrib4Nubv(index: TGLuint, v: TGLubyte) {.importc.} + proc glConvolutionFilter2DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} + proc glGenFramebuffersEXT(n: TGLsizei, framebuffers: TGLuint) {.importc.} + proc glFogCoordfvEXT(coord: TGLfloat) {.importc.} + proc glGetRenderbufferParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexAttribs1fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} + proc glTexCoord2fColor3fVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glRasterPos3i(x: TGLint, y: TGLint, z: TGLint) {.importc.} + proc glMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glConvolutionParameteriEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexAttribI4iEXT(index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glVertexAttribL2i64vNV(index: TGLuint, v: TGLint64EXT) {.importc.} + proc glBlendColor(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} + proc glGetPathColorGenivNV(color: TGLenum, pname: TGLenum, value: TGLint) {.importc.} + proc glCompressedTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glDrawElementsInstanced(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei) {.importc.} + proc glFogCoordd(coord: TGLdouble) {.importc.} + proc glTexParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glWindowPos3svARB(v: TGLshort) {.importc.} + proc glGetVertexArrayPointervEXT(vaobj: TGLuint, pname: TGLenum, param: ptr pointer) {.importc.} + proc glDrawTextureNV(texture: TGLuint, sampler: TGLuint, x0: TGLfloat, y0: TGLfloat, x1: TGLfloat, y1: TGLfloat, z: TGLfloat, s0: TGLfloat, t0: TGLfloat, s1: TGLfloat, t1: TGLfloat) {.importc.} + proc glUniformMatrix2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glTexImage3DOES(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glClampColorARB(target: TGLenum, clamp: TGLenum) {.importc.} + proc glTexParameteri(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glWindowPos4svMESA(v: TGLshort) {.importc.} + proc glMultiTexCoordP4ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} + proc glVertexP4uiv(`type`: TGLenum, value: TGLuint) {.importc.} + proc glProgramUniform4iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} + proc glTexCoord3xvOES(coords: TGLfixed) {.importc.} + proc glCopyTexImage2DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} + proc glGenSamplers(count: TGLsizei, samplers: TGLuint) {.importc.} + proc glRasterPos4iv(v: TGLint) {.importc.} + proc glWindowPos4sMESA(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} + proc glProgramUniform2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glPrioritizeTexturesEXT(n: TGLsizei, textures: TGLuint, priorities: TGLclampf) {.importc.} + proc glRects(x1: TGLshort, y1: TGLshort, x2: TGLshort, y2: TGLshort) {.importc.} + proc glMultiDrawElementsBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, drawcount: TGLsizei, basevertex: TGLint) {.importc.} + proc glProgramBinaryOES(program: TGLuint, binaryFormat: TGLenum, binary: pointer, length: TGLint) {.importc.} + proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc: TGLuint, tc: TGLfloat, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} + proc glGetMinmaxParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glColor4fNormal3fVertex3fSUN(r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glWindowPos2d(x: TGLdouble, y: TGLdouble) {.importc.} + proc glGetPerfMonitorGroupStringAMD(group: TGLuint, bufSize: TGLsizei, length: TGLsizei, groupString: TGLchar) {.importc.} + proc glUniformHandleui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64) {.importc.} + proc glBlendEquation(mode: TGLenum) {.importc.} + proc glMapBufferARB(target: TGLenum, access: TGLenum) {.importc.} + proc glGetMaterialxvOES(face: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glVertexAttribI1ivEXT(index: TGLuint, v: TGLint) {.importc.} + proc glTexCoord4hvNV(v: TGLhalfNV) {.importc.} + proc glVertexArrayVertexAttribLOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glExtGetShadersQCOM(shaders: TGLuint, maxShaders: TGLint, numShaders: TGLint) {.importc.} + proc glWindowPos4ivMESA(v: TGLint) {.importc.} + proc glVertexAttrib1sNV(index: TGLuint, x: TGLshort) {.importc.} + proc glNormalStream3ivATI(stream: TGLenum, coords: TGLint) {.importc.} + proc glSecondaryColor3fEXT(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc.} + proc glVertexArrayFogCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glGetTextureImageEXT(texture: TGLuint, target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glVertexAttrib4hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV, w: TGLhalfNV) {.importc.} + proc glReplacementCodeusSUN(code: TGLushort) {.importc.} + proc glPixelTexGenSGIX(mode: TGLenum) {.importc.} + proc glMultiDrawRangeElementArrayAPPLE(mode: TGLenum, start: TGLuint, `end`: TGLuint, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glDrawElements(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc.} + proc glTexCoord1hvNV(v: TGLhalfNV) {.importc.} + proc glGetPixelMapuiv(map: TGLenum, values: TGLuint) {.importc.} + proc glRasterPos4d(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glConvolutionParameterxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glSecondaryColor3dEXT(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc.} + proc glGetCombinerOutputParameterivNV(stage: TGLenum, portion: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glQueryCounter(id: TGLuint, target: TGLenum) {.importc.} + proc glGetUniformi64vNV(program: TGLuint, location: TGLint, params: TGLint64EXT) {.importc.} + proc glTexCoord2fv(v: TGLfloat) {.importc.} + proc glWindowPos3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glBlendFuncSeparateINGR(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc.} + proc glTextureNormalEXT(mode: TGLenum) {.importc.} + proc glVertexStream2fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat) {.importc.} + proc glViewportIndexedf(index: TGLuint, x: TGLfloat, y: TGLfloat, w: TGLfloat, h: TGLfloat) {.importc.} + proc glMultiTexCoord4ivARB(target: TGLenum, v: TGLint) {.importc.} + proc glBindBufferOffsetEXT(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr) {.importc.} + proc glTexCoord3sv(v: TGLshort) {.importc.} + proc glVertexArrayVertexAttribBindingEXT(vaobj: TGLuint, attribindex: TGLuint, bindingindex: TGLuint) {.importc.} + proc glVertexAttrib2f(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc.} + proc glMultiTexGenivEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glUniformui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glGetInfoLogARB(obj: TGLhandleARB, maxLength: TGLsizei, length: TGLsizei, infoLog: TGLcharARB) {.importc.} + proc glGetNamedProgramLocalParameterIivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLint) {.importc.} + proc glVertexAttrib4s(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} + proc glUniformMatrix4x2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glVertexAttribs3dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} + proc glSecondaryColor3dvEXT(v: TGLdouble) {.importc.} + proc glTextureRenderbufferEXT(texture: TGLuint, target: TGLenum, renderbuffer: TGLuint) {.importc.} + proc glVertexAttribL2ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc.} + proc glBlendFuncSeparateOES(srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} + proc glVertexAttribDivisorARB(index: TGLuint, divisor: TGLuint) {.importc.} + proc glWindowPos2sv(v: TGLshort) {.importc.} + proc glMultiTexCoord3svARB(target: TGLenum, v: TGLshort) {.importc.} + proc glCombinerParameterfvNV(pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetImageTransformParameterfvHP(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTexParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetArrayObjectivATI(`array`: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetTexParameterIuiv(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glGetProgramPipelineInfoLog(pipeline: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc.} + proc glGetOcclusionQueryuivNV(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glVertexAttrib4bvARB(index: TGLuint, v: TGLbyte) {.importc.} + proc glListParameterfvSGIX(list: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glDeleteSamplers(count: TGLsizei, samplers: TGLuint) {.importc.} + proc glNormalStream3dATI(stream: TGLenum, nx: TGLdouble, ny: TGLdouble, nz: TGLdouble) {.importc.} + proc glProgramUniform4i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glBlendFuncSeparateiARB(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} + proc glEndTransformFeedbackEXT() {.importc.} + proc glMultiTexCoord3i(target: TGLenum, s: TGLint, t: TGLint, r: TGLint) {.importc.} + proc glMakeBufferResidentNV(target: TGLenum, access: TGLenum) {.importc.} + proc glTangent3dvEXT(v: TGLdouble) {.importc.} + proc glMatrixPopEXT(mode: TGLenum) {.importc.} + proc glVertexAttrib4NivARB(index: TGLuint, v: TGLint) {.importc.} + proc glProgramUniform2ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc.} + proc glWeightPointerARB(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glCullParameterdvEXT(pname: TGLenum, params: TGLdouble) {.importc.} + proc glFramebufferTexture2D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glGenVertexArrays(n: TGLsizei, arrays: TGLuint) {.importc.} + proc glUniformHandleui64NV(location: TGLint, value: TGLuint64) {.importc.} + proc glIndexPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glGetProgramSubroutineParameteruivNV(target: TGLenum, index: TGLuint, param: TGLuint) {.importc.} + proc glVertexAttrib1svARB(index: TGLuint, v: TGLshort) {.importc.} + proc glDetachObjectARB(containerObj: TGLhandleARB, attachedObj: TGLhandleARB) {.importc.} + proc glCompressedTexImage3D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} + proc glBlendFuncSeparate(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc.} + proc glExecuteProgramNV(target: TGLenum, id: TGLuint, params: TGLfloat) {.importc.} + proc glAttachObjectARB(containerObj: TGLhandleARB, obj: TGLhandleARB) {.importc.} + proc glCompressedTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} + proc glProgramUniform4iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glVertexAttrib3sv(index: TGLuint, v: TGLshort) {.importc.} + proc glTexCoord3bvOES(coords: TGLbyte) {.importc.} + proc glGenTexturesEXT(n: TGLsizei, textures: TGLuint) {.importc.} + proc glColor4f(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} + proc glGetFramebufferAttachmentParameterivOES(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glClearColor(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} + proc glNamedProgramLocalParametersI4ivEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLint) {.importc.} + proc glMakeImageHandleNonResidentARB(handle: TGLuint64) {.importc.} + proc glGenRenderbuffers(n: TGLsizei, renderbuffers: TGLuint) {.importc.} + proc glVertexAttribL1ui64vARB(index: TGLuint, v: TGLuint64EXT) {.importc.} + proc glBindFramebufferEXT(target: TGLenum, framebuffer: TGLuint) {.importc.} + proc glProgramUniform2dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble) {.importc.} + proc glCompressedMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glDeleteSyncAPPLE(sync: TGLsync) {.importc.} + proc glDebugMessageInsertAMD(category: TGLenum, severity: TGLenum, id: TGLuint, length: TGLsizei, buf: TGLchar) {.importc.} + proc glSecondaryColorPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glTextureImage2DMultisampleNV(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} + proc glBeginFragmentShaderATI() {.importc.} + proc glClearDepth(depth: TGLdouble) {.importc.} + proc glBindTextures(first: TGLuint, count: TGLsizei, textures: TGLuint) {.importc.} + proc glEvalCoord1d(u: TGLdouble) {.importc.} + proc glSecondaryColor3b(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc.} + proc glExtGetTexSubImageQCOM(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, texels: pointer) {.importc.} + proc glClearColorIiEXT(red: TGLint, green: TGLint, blue: TGLint, alpha: TGLint) {.importc.} + proc glVertex2xOES(x: TGLfixed) {.importc.} + proc glVertexAttrib2s(index: TGLuint, x: TGLshort, y: TGLshort) {.importc.} + proc glUniformHandleui64vARB(location: TGLint, count: TGLsizei, value: TGLuint64) {.importc.} + proc glAreTexturesResidentEXT(n: TGLsizei, textures: TGLuint, residences: TGLboolean): TGLboolean {.importc.} + proc glDrawElementsInstancedBaseInstance(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei, baseinstance: TGLuint) {.importc.} + proc glGetString(name: TGLenum): TGLubyte {.importc.} + proc glDrawTransformFeedbackStream(mode: TGLenum, id: TGLuint, stream: TGLuint) {.importc.} + proc glSecondaryColor3uiv(v: TGLuint) {.importc.} + proc glNamedFramebufferParameteriEXT(framebuffer: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glVertexAttrib4hvNV(index: TGLuint, v: TGLhalfNV) {.importc.} + proc glGetnUniformuivARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLuint) {.importc.} + proc glProgramUniform4ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} + proc glPointParameterxvOES(pname: TGLenum, params: TGLfixed) {.importc.} + proc glIsEnabledi(target: TGLenum, index: TGLuint): TGLboolean {.importc.} + proc glColorPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} + proc glFragmentLightModelfvSGIX(pname: TGLenum, params: TGLfloat) {.importc.} + proc glRasterPos3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glDeleteObjectARB(obj: TGLhandleARB) {.importc.} + proc glSetFenceNV(fence: TGLuint, condition: TGLenum) {.importc.} + proc glTransformFeedbackAttribsNV(count: TGLuint, attribs: TGLint, bufferMode: TGLenum) {.importc.} + proc glProgramUniformMatrix2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glGetPointerv(pname: TGLenum, params: ptr pointer) {.importc.} + proc glWindowPos2dvMESA(v: TGLdouble) {.importc.} + proc glTexImage2DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLint, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} + proc glGenFragmentShadersATI(range: TGLuint): TGLuint {.importc.} + proc glTexCoord4fv(v: TGLfloat) {.importc.} + proc glCompressedTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} + proc glGetNamedBufferSubDataEXT(buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} + proc glFinish() {.importc.} + proc glDeleteVertexShaderEXT(id: TGLuint) {.importc.} + proc glFinishObjectAPPLE(`object`: TGLenum, name: TGLint) {.importc.} + proc glGetActiveAttribARB(programObj: TGLhandleARB, index: TGLuint, maxLength: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLcharARB) {.importc.} + proc glPointParameterx(pname: TGLenum, param: TGLfixed) {.importc.} + proc glProgramUniformui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glSecondaryColor3ubv(v: TGLubyte) {.importc.} + proc glGetProgramLocalParameterIivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc.} + proc glDeleteProgramPipelinesEXT(n: TGLsizei, pipelines: TGLuint) {.importc.} + proc glVertexAttrib4fNV(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glGetColorTableParameterfvSGI(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetFloati_v(target: TGLenum, index: TGLuint, data: TGLfloat) {.importc.} + proc glGenBuffers(n: TGLsizei, buffers: TGLuint) {.importc.} + proc glNormal3b(nx: TGLbyte, ny: TGLbyte, nz: TGLbyte) {.importc.} + proc glDrawArraysInstancedARB(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glTexStorage2DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} + proc glGetVariantIntegervEXT(id: TGLuint, value: TGLenum, data: TGLint) {.importc.} + proc glColor3ubv(v: TGLubyte) {.importc.} + proc glVertexAttribP4uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} + proc glProgramUniform2ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glVertexStream4dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glVertexAttribL2ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc.} + proc glSecondaryColor3bEXT(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc.} + proc glGetBufferPointervOES(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} + proc glGetMaterialfv(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexStream3sATI(stream: TGLenum, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} + proc glUniform1i(location: TGLint, v0: TGLint) {.importc.} + proc glVertexAttribL2d(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} + proc glTestObjectAPPLE(`object`: TGLenum, name: TGLuint): TGLboolean {.importc.} + proc glGetTransformFeedbackVarying(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLsizei, `type`: TGLenum, name: TGLchar) {.importc.} + proc glFramebufferRenderbufferOES(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} + proc glVertexStream3iATI(stream: TGLenum, x: TGLint, y: TGLint, z: TGLint) {.importc.} + proc glMakeTextureHandleNonResidentNV(handle: TGLuint64) {.importc.} + proc glVertexAttrib4fvNV(index: TGLuint, v: TGLfloat) {.importc.} + proc glArrayElement(i: TGLint) {.importc.} + proc glClearBufferData(target: TGLenum, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glSecondaryColor3usEXT(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc.} + proc glRenderbufferStorageMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glTexCoord2xvOES(coords: TGLfixed) {.importc.} + proc glWindowPos3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glTangent3svEXT(v: TGLshort) {.importc.} + proc glPointParameterf(pname: TGLenum, param: TGLfloat) {.importc.} + proc glVertexAttribI4uivEXT(index: TGLuint, v: TGLuint) {.importc.} + proc glColorTableParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glMatrixMultdEXT(mode: TGLenum, m: TGLdouble) {.importc.} + proc glUseProgramStages(pipeline: TGLuint, stages: TGLbitfield, program: TGLuint) {.importc.} + proc glVertexStream4sATI(stream: TGLenum, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} + proc glDrawElementsInstancedNV(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} + proc glUniform3d(location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glDebugMessageControlARB(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc.} + proc glVertexAttribs3svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc.} + proc glElementPointerATI(`type`: TGLenum, `pointer`: pointer) {.importc.} + proc glColor4fNormal3fVertex3fvSUN(c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} + proc glGetPerfMonitorCountersAMD(group: TGLuint, numCounters: TGLint, maxActiveCounters: TGLint, counterSize: TGLsizei, counters: TGLuint) {.importc.} + proc glDispatchCompute(num_groups_x: TGLuint, num_groups_y: TGLuint, num_groups_z: TGLuint) {.importc.} + proc glVertexAttribDivisorNV(index: TGLuint, divisor: TGLuint) {.importc.} + proc glProgramUniform3uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} + proc glRenderbufferStorageMultisampleNV(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glBinormalPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glRectxvOES(v1: TGLfixed, v2: TGLfixed) {.importc.} + proc glGenVertexArraysOES(n: TGLsizei, arrays: TGLuint) {.importc.} + proc glDebugMessageControlKHR(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc.} + proc glProgramUniform1uiEXT(program: TGLuint, location: TGLint, v0: TGLuint) {.importc.} + proc glPixelTransferi(pname: TGLenum, param: TGLint) {.importc.} + proc glIsPointInFillPathNV(path: TGLuint, mask: TGLuint, x: TGLfloat, y: TGLfloat): TGLboolean {.importc.} + proc glVertexBindingDivisor(bindingindex: TGLuint, divisor: TGLuint) {.importc.} + proc glGetVertexAttribLui64vARB(index: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc.} + proc glProgramUniformMatrix3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glDrawBuffer(mode: TGLenum) {.importc.} + proc glMultiTexCoord1sARB(target: TGLenum, s: TGLshort) {.importc.} + proc glSeparableFilter2DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer) {.importc.} + proc glTangent3bvEXT(v: TGLbyte) {.importc.} + proc glTexParameterIuiv(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glVertexAttribL4i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc.} + proc glDebugMessageCallbackARB(callback: TGLDEBUGPROCARB, userParam: pointer) {.importc.} + proc glMultiTexCoordP1uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} + proc glLabelObjectEXT(`type`: TGLenum, `object`: TGLuint, length: TGLsizei, label: TGLchar) {.importc.} + proc glGetnPolygonStippleARB(bufSize: TGLsizei, pattern: TGLubyte) {.importc.} + proc glTexCoord3xOES(s: TGLfixed, t: TGLfixed, r: TGLfixed) {.importc.} + proc glCopyPixels(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, `type`: TGLenum) {.importc.} + proc glGetnUniformfvEXT(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLfloat) {.importc.} + proc glColorMaski(index: TGLuint, r: TGLboolean, g: TGLboolean, b: TGLboolean, a: TGLboolean) {.importc.} + proc glRasterPos2fv(v: TGLfloat) {.importc.} + proc glBindBuffersBase(target: TGLenum, first: TGLuint, count: TGLsizei, buffers: TGLuint) {.importc.} + proc glSpriteParameterfvSGIX(pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetSyncivAPPLE(sync: TGLsync, pname: TGLenum, bufSize: TGLsizei, length: TGLsizei, values: TGLint) {.importc.} + proc glVertexAttribI3i(index: TGLuint, x: TGLint, y: TGLint, z: TGLint) {.importc.} + proc glPixelTransformParameteriEXT(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glMultiDrawArraysEXT(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glGetTextureHandleNV(texture: TGLuint): TGLuint64 {.importc.} + proc glTexCoordP2ui(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glDeleteQueries(n: TGLsizei, ids: TGLuint) {.importc.} + proc glGetVertexAttribArrayObjectivATI(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexArrayVertexBindingDivisorEXT(vaobj: TGLuint, bindingindex: TGLuint, divisor: TGLuint) {.importc.} + proc glVertex3i(x: TGLint, y: TGLint, z: TGLint) {.importc.} + proc glBlendEquationSeparatei(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} + proc glGetMapAttribParameterivNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetVideoCaptureivNV(video_capture_slot: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glFragmentMaterialfvSGIX(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glEGLImageTargetTexture2DOES(target: TGLenum, image: TGLeglImageOES) {.importc.} + proc glCopyImageSubDataNV(srcName: TGLuint, srcTarget: TGLenum, srcLevel: TGLint, srcX: TGLint, srcY: TGLint, srcZ: TGLint, dstName: TGLuint, dstTarget: TGLenum, dstLevel: TGLint, dstX: TGLint, dstY: TGLint, dstZ: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} + proc glUniform2i(location: TGLint, v0: TGLint, v1: TGLint) {.importc.} + proc glVertexAttrib3fvNV(index: TGLuint, v: TGLfloat) {.importc.} + proc glNamedBufferStorageEXT(buffer: TGLuint, size: TGLsizeiptr, data: pointer, flags: TGLbitfield) {.importc.} + proc glProgramEnvParameterI4uivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glGetVertexAttribdvARB(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glVertexAttribL3ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc.} + proc glUniform4fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glWeightsvARB(size: TGLint, weights: TGLshort) {.importc.} + proc glMakeTextureHandleNonResidentARB(handle: TGLuint64) {.importc.} + proc glEvalCoord1xOES(u: TGLfixed) {.importc.} + proc glVertexAttrib2sv(index: TGLuint, v: TGLshort) {.importc.} + proc glVertexAttrib4dvNV(index: TGLuint, v: TGLdouble) {.importc.} + proc glProgramNamedParameter4fNV(id: TGLuint, len: TGLsizei, name: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glCompileShaderARB(shaderObj: TGLhandleARB) {.importc.} + proc glProgramEnvParameter4fvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} + proc glGetVertexAttribiv(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glEvalPoint1(i: TGLint) {.importc.} + proc glEvalMapsNV(target: TGLenum, mode: TGLenum) {.importc.} + proc glGetTexGenxvOES(coord: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glBlendEquationSeparate(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} + proc glGetColorTableParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glQueryCounterEXT(id: TGLuint, target: TGLenum) {.importc.} + proc glExtGetProgramBinarySourceQCOM(program: TGLuint, shadertype: TGLenum, source: TGLchar, length: TGLint) {.importc.} + proc glGetConvolutionParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glIsProgramPipeline(pipeline: TGLuint): TGLboolean {.importc.} + proc glVertexWeightfvEXT(weight: TGLfloat) {.importc.} + proc glDisableDriverControlQCOM(driverControl: TGLuint) {.importc.} + proc glVertexStream1fvATI(stream: TGLenum, coords: TGLfloat) {.importc.} + proc glMakeTextureHandleResidentNV(handle: TGLuint64) {.importc.} + proc glSamplerParameteriv(sampler: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glTexEnvxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glEndOcclusionQueryNV() {.importc.} + proc glFlushMappedBufferRangeAPPLE(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr) {.importc.} + proc glVertex4iv(v: TGLint) {.importc.} + proc glVertexArrayVertexAttribIFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} + proc glDisableIndexedEXT(target: TGLenum, index: TGLuint) {.importc.} + proc glVertexAttribL1dEXT(index: TGLuint, x: TGLdouble) {.importc.} + proc glBeginPerfMonitorAMD(monitor: TGLuint) {.importc.} + proc glConvolutionFilter1DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} + proc glPrimitiveRestartIndex(index: TGLuint) {.importc.} + proc glWindowPos2dv(v: TGLdouble) {.importc.} + proc glBindFramebufferOES(target: TGLenum, framebuffer: TGLuint) {.importc.} + proc glTessellationModeAMD(mode: TGLenum) {.importc.} + proc glIsVariantEnabledEXT(id: TGLuint, cap: TGLenum): TGLboolean {.importc.} + proc glColor3iv(v: TGLint) {.importc.} + proc glFogCoordFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc.} + proc glClearNamedBufferDataEXT(buffer: TGLuint, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glTextureRangeAPPLE(target: TGLenum, length: TGLsizei, `pointer`: pointer) {.importc.} + proc glTexCoord4bvOES(coords: TGLbyte) {.importc.} + proc glRotated(angle: TGLdouble, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glAccum(op: TGLenum, value: TGLfloat) {.importc.} + proc glVertex3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glGetPathMetricRangeNV(metricQueryMask: TGLbitfield, firstPathName: TGLuint, numPaths: TGLsizei, stride: TGLsizei, metrics: TGLfloat) {.importc.} + proc glUniform4d(location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glMultiTexCoord1iv(target: TGLenum, v: TGLint) {.importc.} + proc glFogFuncSGIS(n: TGLsizei, points: TGLfloat) {.importc.} + proc glGetMaterialxOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glGlobalAlphaFactorbSUN(factor: TGLbyte) {.importc.} + proc glGetProgramLocalParameterdvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} + proc glDeleteProgramsARB(n: TGLsizei, programs: TGLuint) {.importc.} + proc glVertexStream1sATI(stream: TGLenum, x: TGLshort) {.importc.} + proc glMatrixTranslatedEXT(mode: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glGetBufferSubData(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} + proc glUniform4uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} + proc glGetShaderiv(shader: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetQueryIndexediv(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glDebugMessageInsert(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: TGLchar) {.importc.} + proc glVertexAttribs2dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} + proc glGetFixedvOES(pname: TGLenum, params: TGLfixed) {.importc.} + proc glUniform2iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glTextureView(texture: TGLuint, target: TGLenum, origtexture: TGLuint, internalformat: TGLenum, minlevel: TGLuint, numlevels: TGLuint, minlayer: TGLuint, numlayers: TGLuint) {.importc.} + proc glMultiTexCoord1xvOES(texture: TGLenum, coords: TGLfixed) {.importc.} + proc glTexBufferRange(target: TGLenum, internalformat: TGLenum, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} + proc glMultiTexCoordPointerEXT(texunit: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glBlendColorxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} + proc glReadPixels(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glWindowPos3dARB(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glPixelTexGenParameterivSGIS(pname: TGLenum, params: TGLint) {.importc.} + proc glSecondaryColor3svEXT(v: TGLshort) {.importc.} + proc glPopGroupMarkerEXT() {.importc.} + proc glImportSyncEXT(external_sync_type: TGLenum, external_sync: TGLintptr, flags: TGLbitfield): TGLsync {.importc.} + proc glVertexAttribLFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} + proc glVertexAttrib2sNV(index: TGLuint, x: TGLshort, y: TGLshort) {.importc.} + proc glGetIntegeri_v(target: TGLenum, index: TGLuint, data: TGLint) {.importc.} + proc glProgramUniform3uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glGetActiveUniformBlockiv(program: TGLuint, uniformBlockIndex: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glCreateShaderProgramv(`type`: TGLenum, count: TGLsizei, strings: ptr TGLchar): TGLuint {.importc.} + proc glUniform2fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} + proc glVertexStream4ivATI(stream: TGLenum, coords: TGLint) {.importc.} + proc glNormalP3uiv(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glVertexAttribLFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} + proc glTexCoord2bvOES(coords: TGLbyte) {.importc.} + proc glGetActiveUniformName(program: TGLuint, uniformIndex: TGLuint, bufSize: TGLsizei, length: TGLsizei, uniformName: TGLchar) {.importc.} + proc glTexCoord2sv(v: TGLshort) {.importc.} + proc glVertexAttrib2dNV(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} + proc glGetFogFuncSGIS(points: TGLfloat) {.importc.} + proc glSetFenceAPPLE(fence: TGLuint) {.importc.} + proc glRasterPos2f(x: TGLfloat, y: TGLfloat) {.importc.} + proc glVertexWeightPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glEndList() {.importc.} + proc glVDPAUFiniNV() {.importc.} + proc glTbufferMask3DFX(mask: TGLuint) {.importc.} + proc glVertexP4ui(`type`: TGLenum, value: TGLuint) {.importc.} + proc glTexEnviv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glColor4xOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} + proc glBlendEquationi(buf: TGLuint, mode: TGLenum) {.importc.} + proc glLoadMatrixxOES(m: TGLfixed) {.importc.} + proc glFogxOES(pname: TGLenum, param: TGLfixed) {.importc.} + proc glTexCoord4dv(v: TGLdouble) {.importc.} + proc glFogCoordPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} + proc glGetPerfMonitorGroupsAMD(numGroups: TGLint, groupsSize: TGLsizei, groups: TGLuint) {.importc.} + proc glVertex2hNV(x: TGLhalfNV, y: TGLhalfNV) {.importc.} + proc glDeleteFragmentShaderATI(id: TGLuint) {.importc.} + proc glGetSamplerParameterIiv(sampler: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glUniform2fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glFogf(pname: TGLenum, param: TGLfloat) {.importc.} + proc glMultiTexCoord1iARB(target: TGLenum, s: TGLint) {.importc.} + proc glGetActiveUniformARB(programObj: TGLhandleARB, index: TGLuint, maxLength: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLcharARB) {.importc.} + proc glMapGrid1xOES(n: TGLint, u1: TGLfixed, u2: TGLfixed) {.importc.} + proc glIndexsv(c: TGLshort) {.importc.} + proc glFragmentMaterialfSGIX(face: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glBindTextureEXT(target: TGLenum, texture: TGLuint) {.importc.} + proc glRectiv(v1: TGLint, v2: TGLint) {.importc.} + proc glTangent3dEXT(tx: TGLdouble, ty: TGLdouble, tz: TGLdouble) {.importc.} + proc glProgramUniformMatrix3x4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glNormal3hNV(nx: TGLhalfNV, ny: TGLhalfNV, nz: TGLhalfNV) {.importc.} + proc glPushClientAttribDefaultEXT(mask: TGLbitfield) {.importc.} + proc glUnmapBufferARB(target: TGLenum): TGLboolean {.importc.} + proc glVertexAttribs1dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} + proc glUniformMatrix2x3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glUniform3f(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} + proc glTexEnvxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glMapBufferOES(target: TGLenum, access: TGLenum) {.importc.} + proc glBufferData(target: TGLenum, size: TGLsizeiptr, data: pointer, usage: TGLenum) {.importc.} + proc glDrawElementsInstancedANGLE(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} + proc glGetTextureHandleARB(texture: TGLuint): TGLuint64 {.importc.} + proc glNormal3f(nx: TGLfloat, ny: TGLfloat, nz: TGLfloat) {.importc.} + proc glTexCoordP3uiv(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glTexParameterx(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glMapBufferRange(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc.} + proc glTexCoord2fVertex3fSUN(s: TGLfloat, t: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glVariantArrayObjectATI(id: TGLuint, `type`: TGLenum, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc.} + proc glGetnHistogramARB(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, values: pointer) {.importc.} + proc glWindowPos3sv(v: TGLshort) {.importc.} + proc glGetVariantPointervEXT(id: TGLuint, value: TGLenum, data: ptr pointer) {.importc.} + proc glGetLightfv(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetnTexImageARB(target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, img: pointer) {.importc.} + proc glGenRenderbuffersEXT(n: TGLsizei, renderbuffers: TGLuint) {.importc.} + proc glMultiDrawArraysIndirectBindlessNV(mode: TGLenum, indirect: pointer, drawCount: TGLsizei, stride: TGLsizei, vertexBufferCount: TGLint) {.importc.} + proc glDisableClientStateIndexedEXT(`array`: TGLenum, index: TGLuint) {.importc.} + proc glMapGrid1f(un: TGLint, u1: TGLfloat, u2: TGLfloat) {.importc.} + proc glTexStorage2D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glShaderStorageBlockBinding(program: TGLuint, storageBlockIndex: TGLuint, storageBlockBinding: TGLuint) {.importc.} + proc glBlendBarrierNV() {.importc.} + proc glGetVideoui64vNV(video_slot: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc.} + proc glUniform3ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc.} + proc glUniform4ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glGetQueryObjectivARB(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glCompressedTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} + proc glEnableIndexedEXT(target: TGLenum, index: TGLuint) {.importc.} + proc glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: TGLuint, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glVertexAttribI3iEXT(index: TGLuint, x: TGLint, y: TGLint, z: TGLint) {.importc.} + proc glUniform4uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glGetUniformLocation(program: TGLuint, name: TGLchar): TGLint {.importc.} + proc glCurrentPaletteMatrixARB(index: TGLint) {.importc.} + proc glVertexAttribLPointerEXT(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glFogCoorddvEXT(coord: TGLdouble) {.importc.} + proc glInitNames() {.importc.} + proc glGetPathSpacingNV(pathListMode: TGLenum, numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, advanceScale: TGLfloat, kerningScale: TGLfloat, transformType: TGLenum, returnedSpacing: TGLfloat) {.importc.} + proc glNormal3fVertex3fvSUN(n: TGLfloat, v: TGLfloat) {.importc.} + proc glTexCoord2iv(v: TGLint) {.importc.} + proc glWindowPos3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} + proc glProgramUniformMatrix3x4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glVertexAttribP4ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} + proc glVertexAttribs4ubvNV(index: TGLuint, count: TGLsizei, v: TGLubyte) {.importc.} + proc glProgramLocalParameterI4iNV(target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glStencilMaskSeparate(face: TGLenum, mask: TGLuint) {.importc.} + proc glClientWaitSync(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64): TGLenum {.importc.} + proc glPolygonOffsetx(factor: TGLfixed, units: TGLfixed) {.importc.} + proc glCreateProgramObjectARB(): TGLhandleARB {.importc.} + proc glClearColorIuiEXT(red: TGLuint, green: TGLuint, blue: TGLuint, alpha: TGLuint) {.importc.} + proc glDeleteTransformFeedbacksNV(n: TGLsizei, ids: TGLuint) {.importc.} + proc glFramebufferDrawBuffersEXT(framebuffer: TGLuint, n: TGLsizei, bufs: TGLenum) {.importc.} + proc glAreTexturesResident(n: TGLsizei, textures: TGLuint, residences: TGLboolean): TGLboolean {.importc.} + proc glNamedBufferDataEXT(buffer: TGLuint, size: TGLsizeiptr, data: pointer, usage: TGLenum) {.importc.} + proc glGetInvariantFloatvEXT(id: TGLuint, value: TGLenum, data: TGLfloat) {.importc.} + proc glMultiTexCoord4d(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc.} + proc glGetPixelTransformParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetStringi(name: TGLenum, index: TGLuint): TGLubyte {.importc.} + proc glMakeBufferNonResidentNV(target: TGLenum) {.importc.} + proc glVertex4bOES(x: TGLbyte, y: TGLbyte, z: TGLbyte) {.importc.} + proc glGetObjectLabel(identifier: TGLenum, name: TGLuint, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc.} + proc glClipPlanexOES(plane: TGLenum, equation: TGLfixed) {.importc.} + proc glElementPointerAPPLE(`type`: TGLenum, `pointer`: pointer) {.importc.} + proc glIsAsyncMarkerSGIX(marker: TGLuint): TGLboolean {.importc.} + proc glUseShaderProgramEXT(`type`: TGLenum, program: TGLuint) {.importc.} + proc glReplacementCodeuiColor4ubVertex3fSUN(rc: TGLuint, r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glIsTransformFeedback(id: TGLuint): TGLboolean {.importc.} + proc glEdgeFlag(flag: TGLboolean) {.importc.} + proc glGetTexGeniv(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glBeginQueryEXT(target: TGLenum, id: TGLuint) {.importc.} + proc glUniform1uiEXT(location: TGLint, v0: TGLuint) {.importc.} + proc glProgramUniform3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glGetVideoi64vNV(video_slot: TGLuint, pname: TGLenum, params: TGLint64EXT) {.importc.} + proc glProgramUniform3ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} + proc glSecondaryColor3uiEXT(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc.} + proc glPathStencilFuncNV(func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} + proc glVertexAttribP1ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} + proc glStencilFillPathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, fillMode: TGLenum, mask: TGLuint, transformType: TGLenum, transformValues: TGLfloat) {.importc.} + proc glFogCoordfEXT(coord: TGLfloat) {.importc.} + proc glTextureParameterIuivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glProgramUniform4dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glFramebufferTextureFaceARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc.} + proc glTexCoord3s(s: TGLshort, t: TGLshort, r: TGLshort) {.importc.} + proc glGetFramebufferAttachmentParameteriv(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glEndVideoCaptureNV(video_capture_slot: TGLuint) {.importc.} + proc glProgramUniformMatrix2x4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glGetFloatIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLfloat) {.importc.} + proc glTexCoord1xOES(s: TGLfixed) {.importc.} + proc glTexCoord4f(s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc.} + proc glShaderSource(shader: TGLuint, count: TGLsizei, string: ptr TGLchar, length: TGLint) {.importc.} + proc glGetDetailTexFuncSGIS(target: TGLenum, points: TGLfloat) {.importc.} + proc glResetHistogram(target: TGLenum) {.importc.} + proc glVertexAttribP2ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} + proc glDrawTransformFeedbackNV(mode: TGLenum, id: TGLuint) {.importc.} + proc glWindowPos2fMESA(x: TGLfloat, y: TGLfloat) {.importc.} + proc glObjectLabelKHR(identifier: TGLenum, name: TGLuint, length: TGLsizei, label: TGLchar) {.importc.} + proc glMultiTexCoord2iARB(target: TGLenum, s: TGLint, t: TGLint) {.importc.} + proc glVertexAttrib4usv(index: TGLuint, v: TGLushort) {.importc.} + proc glGetGraphicsResetStatusARB(): TGLenum {.importc.} + proc glProgramUniform3dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glPathSubCommandsNV(path: TGLuint, commandStart: TGLsizei, commandsToDelete: TGLsizei, numCommands: TGLsizei, commands: TGLubyte, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} + proc glEndTransformFeedbackNV() {.importc.} + proc glWindowPos2sMESA(x: TGLshort, y: TGLshort) {.importc.} + proc glTangent3sEXT(tx: TGLshort, ty: TGLshort, tz: TGLshort) {.importc.} + proc glLineWidthx(width: TGLfixed) {.importc.} + proc glGetUniformBufferSizeEXT(program: TGLuint, location: TGLint): TGLint {.importc.} + proc glTexCoord2bOES(s: TGLbyte, t: TGLbyte) {.importc.} + proc glWindowPos3iMESA(x: TGLint, y: TGLint, z: TGLint) {.importc.} + proc glTexGend(coord: TGLenum, pname: TGLenum, param: TGLdouble) {.importc.} + proc glRenderbufferStorageMultisampleANGLE(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glGetProgramiv(program: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glDrawTransformFeedbackStreamInstanced(mode: TGLenum, id: TGLuint, stream: TGLuint, instancecount: TGLsizei) {.importc.} + proc glMatrixTranslatefEXT(mode: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glColor4iv(v: TGLint) {.importc.} + proc glSecondaryColor3ivEXT(v: TGLint) {.importc.} + proc glIsNamedStringARB(namelen: TGLint, name: TGLchar): TGLboolean {.importc.} + proc glVertexAttribL4dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glEndTransformFeedback() {.importc.} + proc glVertexStream3fvATI(stream: TGLenum, coords: TGLfloat) {.importc.} + proc glProgramUniformMatrix4x2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glTextureBufferRangeEXT(texture: TGLuint, target: TGLenum, internalformat: TGLenum, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} + proc glTexCoord2fNormal3fVertex3fvSUN(tc: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} + proc glProgramUniform2f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} + proc glMultiTexCoord2sv(target: TGLenum, v: TGLshort) {.importc.} + proc glTexCoord3bOES(s: TGLbyte, t: TGLbyte, r: TGLbyte) {.importc.} + proc glGenFramebuffersOES(n: TGLsizei, framebuffers: TGLuint) {.importc.} + proc glMultiTexCoord3sv(target: TGLenum, v: TGLshort) {.importc.} + proc glVertexAttrib4Nub(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc.} + proc glColor3d(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc.} + proc glGetActiveAttrib(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLchar) {.importc.} + proc glConvolutionParameterfEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTexSubImage2DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glBinormal3fvEXT(v: TGLfloat) {.importc.} + proc glDebugMessageControl(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc.} + proc glProgramUniform3uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glPNTrianglesiATI(pname: TGLenum, param: TGLint) {.importc.} + proc glGetPerfMonitorCounterInfoAMD(group: TGLuint, counter: TGLuint, pname: TGLenum, data: pointer) {.importc.} + proc glVertexAttribL3ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc.} + proc glIsRenderbufferOES(renderbuffer: TGLuint): TGLboolean {.importc.} + proc glColorSubTable(target: TGLenum, start: TGLsizei, count: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glCompressedMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glBindSampler(unit: TGLuint, sampler: TGLuint) {.importc.} + proc glVariantubvEXT(id: TGLuint, `addr`: TGLubyte) {.importc.} + proc glDisablei(target: TGLenum, index: TGLuint) {.importc.} + proc glVertexAttribI2uiEXT(index: TGLuint, x: TGLuint, y: TGLuint) {.importc.} + proc glDrawElementArrayATI(mode: TGLenum, count: TGLsizei) {.importc.} + proc glTagSampleBufferSGIX() {.importc.} + proc glVertexPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} + proc glFragmentLightiSGIX(light: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glLoadTransposeMatrixxOES(m: TGLfixed) {.importc.} + proc glProgramLocalParameter4fvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} + proc glGetVariantFloatvEXT(id: TGLuint, value: TGLenum, data: TGLfloat) {.importc.} + proc glProgramUniform4ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glFragmentLightfSGIX(light: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glIsVertexArrayAPPLE(`array`: TGLuint): TGLboolean {.importc.} + proc glTexCoord1bvOES(coords: TGLbyte) {.importc.} + proc glUniform4fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glPixelDataRangeNV(target: TGLenum, length: TGLsizei, `pointer`: pointer) {.importc.} + proc glUniformMatrix4x2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glRectf(x1: TGLfloat, y1: TGLfloat, x2: TGLfloat, y2: TGLfloat) {.importc.} + proc glCoverageMaskNV(mask: TGLboolean) {.importc.} + proc glPointParameterfvSGIS(pname: TGLenum, params: TGLfloat) {.importc.} + proc glProgramUniformMatrix4x2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glFragmentLightModelfSGIX(pname: TGLenum, param: TGLfloat) {.importc.} + proc glDisableVertexAttribAPPLE(index: TGLuint, pname: TGLenum) {.importc.} + proc glMultiTexCoord3dvARB(target: TGLenum, v: TGLdouble) {.importc.} + proc glTexCoord4iv(v: TGLint) {.importc.} + proc glUniform1f(location: TGLint, v0: TGLfloat) {.importc.} + proc glVertexAttribParameteriAMD(index: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glGetConvolutionParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glRecti(x1: TGLint, y1: TGLint, x2: TGLint, y2: TGLint) {.importc.} + proc glTexEnvxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glGetRenderbufferParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glBlendFuncIndexedAMD(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc.} + proc glProgramUniformMatrix3x2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glDrawArraysInstancedANGLE(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glTextureBarrierNV() {.importc.} + proc glDrawBuffersIndexedEXT(n: TGLint, location: TGLenum, indices: TGLint) {.importc.} + proc glUniformMatrix4fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glInstrumentsBufferSGIX(size: TGLsizei, buffer: TGLint) {.importc.} + proc glAlphaFuncQCOM(func: TGLenum, `ref`: TGLclampf) {.importc.} + proc glUniformMatrix4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glGetMinmaxParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetInvariantBooleanvEXT(id: TGLuint, value: TGLenum, data: TGLboolean) {.importc.} + proc glVDPAUIsSurfaceNV(surface: TGLvdpauSurfaceNV) {.importc.} + proc glGenProgramsARB(n: TGLsizei, programs: TGLuint) {.importc.} + proc glDrawRangeElementArrayATI(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei) {.importc.} + proc glFramebufferRenderbufferEXT(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} + proc glClearIndex(c: TGLfloat) {.importc.} + proc glDepthRangeIndexed(index: TGLuint, n: TGLdouble, f: TGLdouble) {.importc.} + proc glDrawTexivOES(coords: TGLint) {.importc.} + proc glTangent3iEXT(tx: TGLint, ty: TGLint, tz: TGLint) {.importc.} + proc glStringMarkerGREMEDY(len: TGLsizei, string: pointer) {.importc.} + proc glTexCoordP1ui(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glOrthox(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} + proc glReplacementCodeuiVertex3fvSUN(rc: TGLuint, v: TGLfloat) {.importc.} + proc glMultiTexCoord1bvOES(texture: TGLenum, coords: TGLbyte) {.importc.} + proc glDrawArraysInstancedBaseInstance(mode: TGLenum, first: TGLint, count: TGLsizei, instancecount: TGLsizei, baseinstance: TGLuint) {.importc.} + proc glMultMatrixf(m: TGLfloat) {.importc.} + proc glProgramUniform4i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} + proc glScissorArrayv(first: TGLuint, count: TGLsizei, v: TGLint) {.importc.} + proc glGetnUniformivEXT(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLint) {.importc.} + proc glGetTexEnvxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glWindowPos3ivARB(v: TGLint) {.importc.} + proc glProgramStringARB(target: TGLenum, format: TGLenum, len: TGLsizei, string: pointer) {.importc.} + proc glTextureColorMaskSGIS(red: TGLboolean, green: TGLboolean, blue: TGLboolean, alpha: TGLboolean) {.importc.} + proc glMultiTexCoord4fv(target: TGLenum, v: TGLfloat) {.importc.} + proc glUniformMatrix4x3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glIsPathNV(path: TGLuint): TGLboolean {.importc.} + proc glStartTilingQCOM(x: TGLuint, y: TGLuint, width: TGLuint, height: TGLuint, preserveMask: TGLbitfield) {.importc.} + proc glVariantivEXT(id: TGLuint, `addr`: TGLint) {.importc.} + proc glGetnMinmaxARB(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, values: pointer) {.importc.} + proc glTransformFeedbackVaryings(program: TGLuint, count: TGLsizei, varyings: ptr TGLchar, bufferMode: TGLenum) {.importc.} + proc glShaderOp2EXT(op: TGLenum, res: TGLuint, arg1: TGLuint, arg2: TGLuint) {.importc.} + proc glVertexAttribPointer(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glMultiTexCoord4dvARB(target: TGLenum, v: TGLdouble) {.importc.} + proc glProgramUniform1ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT) {.importc.} + proc glGetShaderSourceARB(obj: TGLhandleARB, maxLength: TGLsizei, length: TGLsizei, source: TGLcharARB) {.importc.} + proc glGetBufferSubDataARB(target: TGLenum, offset: TGLintptrARB, size: TGLsizeiptrARB, data: pointer) {.importc.} + proc glCopyTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glProgramEnvParameterI4iNV(target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glGetVertexAttribivARB(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetFinalCombinerInputParameterivNV(variable: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glIndexFuncEXT(func: TGLenum, `ref`: TGLclampf) {.importc.} + proc glProgramUniformMatrix3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glTexStorage1DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc.} + proc glUniformMatrix2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glConvolutionParameterf(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGlobalAlphaFactordSUN(factor: TGLdouble) {.importc.} + proc glCopyTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} + proc glVertex4xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} + proc glClearDepthx(depth: TGLfixed) {.importc.} + proc glGetColorTableParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGenProgramPipelines(n: TGLsizei, pipelines: TGLuint) {.importc.} + proc glVertexAttribL4ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc.} + proc glUniform1fARB(location: TGLint, v0: TGLfloat) {.importc.} + proc glUniformMatrix3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glUniform3dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glVertexAttribI4iv(index: TGLuint, v: TGLint) {.importc.} + proc glPixelZoom(xfactor: TGLfloat, yfactor: TGLfloat) {.importc.} + proc glShadeModel(mode: TGLenum) {.importc.} + proc glFramebufferTexture3DOES(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} + proc glMultiTexCoord2i(target: TGLenum, s: TGLint, t: TGLint) {.importc.} + proc glBlendEquationSeparateIndexedAMD(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} + proc glIsEnabled(cap: TGLenum): TGLboolean {.importc.} + proc glTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glPolygonOffsetxOES(factor: TGLfixed, units: TGLfixed) {.importc.} + proc glDrawBuffersEXT(n: TGLsizei, bufs: TGLenum) {.importc.} + proc glPixelTexGenParameterfSGIS(pname: TGLenum, param: TGLfloat) {.importc.} + proc glExtGetRenderbuffersQCOM(renderbuffers: TGLuint, maxRenderbuffers: TGLint, numRenderbuffers: TGLint) {.importc.} + proc glBindImageTextures(first: TGLuint, count: TGLsizei, textures: TGLuint) {.importc.} + proc glVertexAttribP2uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} + proc glTextureImage3DMultisampleCoverageNV(texture: TGLuint, target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} + proc glRasterPos2s(x: TGLshort, y: TGLshort) {.importc.} + proc glVertexAttrib4dvARB(index: TGLuint, v: TGLdouble) {.importc.} + proc glProgramUniformMatrix2x3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glProgramUniformMatrix2x4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glMultiTexCoord1d(target: TGLenum, s: TGLdouble) {.importc.} + proc glGetProgramParameterdvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glPNTrianglesfATI(pname: TGLenum, param: TGLfloat) {.importc.} + proc glUniformMatrix3x4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glVertexAttrib3sNV(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} + proc glGetVideoCaptureStreamfvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glCombinerParameterivNV(pname: TGLenum, params: TGLint) {.importc.} + proc glGetTexGenfvOES(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glCopyTexSubImage2DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glGetProgramLocalParameterfvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} + proc glTexCoord3iv(v: TGLint) {.importc.} + proc glVertexAttribs2hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc.} + proc glNormal3sv(v: TGLshort) {.importc.} + proc glUniform2dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glSecondaryColor3hvNV(v: TGLhalfNV) {.importc.} + proc glDrawArraysInstancedEXT(mode: TGLenum, start: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glBeginTransformFeedback(primitiveMode: TGLenum) {.importc.} + proc glTexParameterIuivEXT(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glProgramBufferParametersfvNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: TGLfloat) {.importc.} + proc glVertexArrayBindVertexBufferEXT(vaobj: TGLuint, bindingindex: TGLuint, buffer: TGLuint, offset: TGLintptr, stride: TGLsizei) {.importc.} + proc glPathParameterfNV(path: TGLuint, pname: TGLenum, value: TGLfloat) {.importc.} + proc glGetClipPlanexOES(plane: TGLenum, equation: TGLfixed) {.importc.} + proc glSecondaryColor3ubvEXT(v: TGLubyte) {.importc.} + proc glGetPixelMapxv(map: TGLenum, size: TGLint, values: TGLfixed) {.importc.} + proc glVertexAttribI1uivEXT(index: TGLuint, v: TGLuint) {.importc.} + proc glMultiTexImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glAlphaFuncxOES(func: TGLenum, `ref`: TGLfixed) {.importc.} + proc glMultiTexCoord2dv(target: TGLenum, v: TGLdouble) {.importc.} + proc glBindRenderbufferOES(target: TGLenum, renderbuffer: TGLuint) {.importc.} + proc glPathStencilDepthOffsetNV(factor: TGLfloat, units: TGLfloat) {.importc.} + proc glPointParameterfvEXT(pname: TGLenum, params: TGLfloat) {.importc.} + proc glSampleCoverageARB(value: TGLfloat, invert: TGLboolean) {.importc.} + proc glVertexAttrib3dNV(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glNamedProgramLocalParameter4dvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} + proc glGenFramebuffers(n: TGLsizei, framebuffers: TGLuint) {.importc.} + proc glMultiDrawElementsEXT(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei) {.importc.} + proc glVertexAttrib2fNV(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc.} + proc glProgramUniform4ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glTexGeniOES(coord: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glBindProgramPipeline(pipeline: TGLuint) {.importc.} + proc glBindSamplers(first: TGLuint, count: TGLsizei, samplers: TGLuint) {.importc.} + proc glColorTableSGI(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} + proc glMultiTexCoord3xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed) {.importc.} + proc glIsQueryEXT(id: TGLuint): TGLboolean {.importc.} + proc glGenBuffersARB(n: TGLsizei, buffers: TGLuint) {.importc.} + proc glVertex4xvOES(coords: TGLfixed) {.importc.} + proc glPixelMapuiv(map: TGLenum, mapsize: TGLsizei, values: TGLuint) {.importc.} + proc glDrawTexfOES(x: TGLfloat, y: TGLfloat, z: TGLfloat, width: TGLfloat, height: TGLfloat) {.importc.} + proc glPointParameterfEXT(pname: TGLenum, param: TGLfloat) {.importc.} + proc glPathDashArrayNV(path: TGLuint, dashCount: TGLsizei, dashArray: TGLfloat) {.importc.} + proc glClearTexImage(texture: TGLuint, level: TGLint, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glIndexdv(c: TGLdouble) {.importc.} + proc glMultTransposeMatrixfARB(m: TGLfloat) {.importc.} + proc glVertexAttribL3d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glUniform3fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glGetProgramInterfaceiv(program: TGLuint, programInterface: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glFogCoordfv(coord: TGLfloat) {.importc.} + proc glTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glGetPolygonStipple(mask: TGLubyte) {.importc.} + proc glGetQueryObjectivEXT(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glColor3xOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed) {.importc.} + proc glMultiTexParameterIivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetMaterialiv(face: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glVertex2fv(v: TGLfloat) {.importc.} + proc glConvolutionParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGenOcclusionQueriesNV(n: TGLsizei, ids: TGLuint) {.importc.} + proc glGetVertexAttribdvNV(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glVertexAttribs4fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} + proc glVertexAttribL3dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glTexEnvi(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glObjectPtrLabel(`ptr`: pointer, length: TGLsizei, label: TGLchar) {.importc.} + proc glGetTexGenfv(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glMapVertexAttrib1dAPPLE(index: TGLuint, size: TGLuint, u1: TGLdouble, u2: TGLdouble, stride: TGLint, order: TGLint, points: TGLdouble) {.importc.} + proc glTexCoord3dv(v: TGLdouble) {.importc.} + proc glIsEnabledIndexedEXT(target: TGLenum, index: TGLuint): TGLboolean {.importc.} + proc glGlobalAlphaFactoruiSUN(factor: TGLuint) {.importc.} + proc glMatrixIndexPointerARB(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glUniformHandleui64ARB(location: TGLint, value: TGLuint64) {.importc.} + proc glUniform1fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glGetActiveSubroutineUniformName(program: TGLuint, shadertype: TGLenum, index: TGLuint, bufsize: TGLsizei, length: TGLsizei, name: TGLchar) {.importc.} + proc glProgramUniformMatrix4x2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glMultiTexCoord4fARB(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc.} + proc glGetDriverControlsQCOM(num: TGLint, size: TGLsizei, driverControls: TGLuint) {.importc.} + proc glBindBufferRange(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} + proc glMapGrid2f(un: TGLint, u1: TGLfloat, u2: TGLfloat, vn: TGLint, v1: TGLfloat, v2: TGLfloat) {.importc.} + proc glUniform2fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glOrtho(left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} + proc glGetImageHandleNV(texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, format: TGLenum): TGLuint64 {.importc.} + proc glIsImageHandleResidentARB(handle: TGLuint64): TGLboolean {.importc.} + proc glGetConvolutionParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glLineWidthxOES(width: TGLfixed) {.importc.} + proc glPathCommandsNV(path: TGLuint, numCommands: TGLsizei, commands: TGLubyte, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} + proc glMaterialxvOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glPauseTransformFeedbackNV() {.importc.} + proc glTexCoord4d(s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc.} + proc glUniform3ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glMultiTexCoord3dARB(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc.} + proc glProgramUniform3fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} + proc glTexImage3DMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} + proc glNormalPointerEXT(`type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} + proc glPathColorGenNV(color: TGLenum, genMode: TGLenum, colorFormat: TGLenum, coeffs: TGLfloat) {.importc.} + proc glGetMultiTexGendvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc.} + proc glColor3i(red: TGLint, green: TGLint, blue: TGLint) {.importc.} + proc glPointSizex(size: TGLfixed) {.importc.} + proc glGetConvolutionFilterEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} + proc glBindBufferBaseNV(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc.} + proc glInsertComponentEXT(res: TGLuint, src: TGLuint, num: TGLuint) {.importc.} + proc glVertex2d(x: TGLdouble, y: TGLdouble) {.importc.} + proc glGetPathDashArrayNV(path: TGLuint, dashArray: TGLfloat) {.importc.} + proc glVertexAttrib2sARB(index: TGLuint, x: TGLshort, y: TGLshort) {.importc.} + proc glScissor(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glLoadMatrixd(m: TGLdouble) {.importc.} + proc glVertex2bvOES(coords: TGLbyte) {.importc.} + proc glTexCoord2i(s: TGLint, t: TGLint) {.importc.} + proc glWriteMaskEXT(res: TGLuint, `in`: TGLuint, outX: TGLenum, outY: TGLenum, outZ: TGLenum, outW: TGLenum) {.importc.} + proc glClientWaitSyncAPPLE(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64): TGLenum {.importc.} + proc glGetObjectBufferivATI(buffer: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetNamedBufferParameterivEXT(buffer: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glTexCoord1bOES(s: TGLbyte) {.importc.} + proc glVertexAttrib4dARB(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glUniform3fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} + proc glWindowPos2ivARB(v: TGLint) {.importc.} + proc glCreateShaderProgramvEXT(`type`: TGLenum, count: TGLsizei, strings: ptr TGLchar): TGLuint {.importc.} + proc glListParameterivSGIX(list: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetGraphicsResetStatusEXT(): TGLenum {.importc.} + proc glActiveShaderProgramEXT(pipeline: TGLuint, program: TGLuint) {.importc.} + proc glTexCoordP1uiv(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glVideoCaptureStreamParameterdvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glGetVertexAttribPointerv(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc.} + proc glGetCompressedMultiTexImageEXT(texunit: TGLenum, target: TGLenum, lod: TGLint, img: pointer) {.importc.} + proc glWindowPos4fMESA(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glDrawElementsInstancedARB(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} + proc glVertexStream1dATI(stream: TGLenum, x: TGLdouble) {.importc.} + proc glMatrixMultfEXT(mode: TGLenum, m: TGLfloat) {.importc.} + proc glGetPathParameterivNV(path: TGLuint, pname: TGLenum, value: TGLint) {.importc.} + proc glCombinerParameteriNV(pname: TGLenum, param: TGLint) {.importc.} + proc glUpdateObjectBufferATI(buffer: TGLuint, offset: TGLuint, size: TGLsizei, `pointer`: pointer, preserve: TGLenum) {.importc.} + proc glVertexAttrib4uivARB(index: TGLuint, v: TGLuint) {.importc.} + proc glVertexAttrib4iv(index: TGLuint, v: TGLint) {.importc.} + proc glFrustum(left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} + proc glDrawTexxvOES(coords: TGLfixed) {.importc.} + proc glTexCoord2fColor4ubVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glMultiTexCoord2fARB(target: TGLenum, s: TGLfloat, t: TGLfloat) {.importc.} + proc glGenTransformFeedbacksNV(n: TGLsizei, ids: TGLuint) {.importc.} + proc glMultiTexGenfEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glGetMinmax(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} + proc glBindTransformFeedback(target: TGLenum, id: TGLuint) {.importc.} + proc glEnableVertexAttribArrayARB(index: TGLuint) {.importc.} + proc glIsFenceAPPLE(fence: TGLuint): TGLboolean {.importc.} + proc glMultiTexGendvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc.} + proc glRotatex(angle: TGLfixed, x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} + proc glGetFragmentLightfvSGIX(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glMultiTexCoord4dv(target: TGLenum, v: TGLdouble) {.importc.} + proc glBlendFuncSeparateEXT(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc.} + proc glMultiTexCoord1f(target: TGLenum, s: TGLfloat) {.importc.} + proc glWindowPos2f(x: TGLfloat, y: TGLfloat) {.importc.} + proc glGetPathTexGenivNV(texCoordSet: TGLenum, pname: TGLenum, value: TGLint) {.importc.} + proc glIndexxvOES(component: TGLfixed) {.importc.} + proc glDisableVertexArrayAttribEXT(vaobj: TGLuint, index: TGLuint) {.importc.} + proc glGetProgramivARB(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glPatchParameteri(pname: TGLenum, value: TGLint) {.importc.} + proc glMultiTexCoord2fv(target: TGLenum, v: TGLfloat) {.importc.} + proc glTexSubImage3DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glFramebufferTexture1DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glTangent3fEXT(tx: TGLfloat, ty: TGLfloat, tz: TGLfloat) {.importc.} + proc glIsVertexAttribEnabledAPPLE(index: TGLuint, pname: TGLenum): TGLboolean {.importc.} + proc glGetShaderInfoLog(shader: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc.} + proc glFrustumx(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} + proc glTexGenfv(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glCompressedTexImage2DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} + proc glMultiTexCoord2bvOES(texture: TGLenum, coords: TGLbyte) {.importc.} + proc glGetTexBumpParameterivATI(pname: TGLenum, param: TGLint) {.importc.} + proc glMultiTexCoord2svARB(target: TGLenum, v: TGLshort) {.importc.} + proc glProgramBufferParametersIivNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: TGLint) {.importc.} + proc glIsQueryARB(id: TGLuint): TGLboolean {.importc.} + proc glFramebufferTextureLayer(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} + proc glUniform4i(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} + proc glDrawArrays(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc.} + proc glWeightubvARB(size: TGLint, weights: TGLubyte) {.importc.} + proc glGetUniformSubroutineuiv(shadertype: TGLenum, location: TGLint, params: TGLuint) {.importc.} + proc glMultTransposeMatrixdARB(m: TGLdouble) {.importc.} + proc glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc: TGLuint, tc: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} + proc glGetMapdv(target: TGLenum, query: TGLenum, v: TGLdouble) {.importc.} + proc glGetMultisamplefvNV(pname: TGLenum, index: TGLuint, val: TGLfloat) {.importc.} + proc glVertex2hvNV(v: TGLhalfNV) {.importc.} + proc glProgramUniformMatrix2x3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glProgramUniform3iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} + proc glGetnPixelMapusvARB(map: TGLenum, bufSize: TGLsizei, values: TGLushort) {.importc.} + proc glVertexWeighthvNV(weight: TGLhalfNV) {.importc.} + proc glDrawTransformFeedbackInstanced(mode: TGLenum, id: TGLuint, instancecount: TGLsizei) {.importc.} + proc glFlushStaticDataIBM(target: TGLenum) {.importc.} + proc glWindowPos2fvARB(v: TGLfloat) {.importc.} + proc glMultiTexCoord3sARB(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort) {.importc.} + proc glWindowPos3fv(v: TGLfloat) {.importc.} + proc glFlushVertexArrayRangeNV() {.importc.} + proc glTangent3bEXT(tx: TGLbyte, ty: TGLbyte, tz: TGLbyte) {.importc.} + proc glIglooInterfaceSGIX(pname: TGLenum, params: pointer) {.importc.} + proc glProgramUniformMatrix4x2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glVertexAttribIFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} + proc glNamedRenderbufferStorageMultisampleEXT(renderbuffer: TGLuint, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glCopyTexImage1DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} + proc glBindTexGenParameterEXT(unit: TGLenum, coord: TGLenum, value: TGLenum): TGLuint {.importc.} + proc glVertex4hNV(x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV, w: TGLhalfNV) {.importc.} + proc glGetMapfv(target: TGLenum, query: TGLenum, v: TGLfloat) {.importc.} + proc glSamplePatternEXT(pattern: TGLenum) {.importc.} + proc glIndexxOES(component: TGLfixed) {.importc.} + proc glVertexAttrib4ubv(index: TGLuint, v: TGLubyte) {.importc.} + proc glGetColorTable(target: TGLenum, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} + proc glFragmentLightModelivSGIX(pname: TGLenum, params: TGLint) {.importc.} + proc glPixelTransformParameterfEXT(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glSamplerParameterfv(sampler: TGLuint, pname: TGLenum, param: TGLfloat) {.importc.} + proc glBindTextureUnitParameterEXT(unit: TGLenum, value: TGLenum): TGLuint {.importc.} + proc glColor3ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc.} + proc glGetMultiTexGenivEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glVariantusvEXT(id: TGLuint, `addr`: TGLushort) {.importc.} + proc glMaterialiv(face: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glPassTexCoordATI(dst: TGLuint, coord: TGLuint, swizzle: TGLenum) {.importc.} + proc glGetIntegerui64vNV(value: TGLenum, result: TGLuint64EXT) {.importc.} + proc glProgramParameteriEXT(program: TGLuint, pname: TGLenum, value: TGLint) {.importc.} + proc glVertexArrayEdgeFlagOffsetEXT(vaobj: TGLuint, buffer: TGLuint, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glGetCombinerInputParameterivNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glLogicOp(opcode: TGLenum) {.importc.} + proc glConvolutionParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glIsBufferResidentNV(target: TGLenum): TGLboolean {.importc.} + proc glIsProgram(program: TGLuint): TGLboolean {.importc.} + proc glEndQueryARB(target: TGLenum) {.importc.} + proc glRenderbufferStorage(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glMaterialfv(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTranslatex(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} + proc glPathParameterivNV(path: TGLuint, pname: TGLenum, value: TGLint) {.importc.} + proc glLightxOES(light: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glSampleMaskEXT(value: TGLclampf, invert: TGLboolean) {.importc.} + proc glReplacementCodeubvSUN(code: TGLubyte) {.importc.} + proc glVertexAttribArrayObjectATI(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc.} + proc glBeginTransformFeedbackNV(primitiveMode: TGLenum) {.importc.} + proc glEvalCoord1fv(u: TGLfloat) {.importc.} + proc glProgramUniformMatrix2x3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glMaterialxv(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glGetIntegerui64i_vNV(value: TGLenum, index: TGLuint, result: TGLuint64EXT) {.importc.} + proc glUniformBlockBinding(program: TGLuint, uniformBlockIndex: TGLuint, uniformBlockBinding: TGLuint) {.importc.} + proc glColor4ui(red: TGLuint, green: TGLuint, blue: TGLuint, alpha: TGLuint) {.importc.} + proc glColor4ubVertex2fvSUN(c: TGLubyte, v: TGLfloat) {.importc.} + proc glRectd(x1: TGLdouble, y1: TGLdouble, x2: TGLdouble, y2: TGLdouble) {.importc.} + proc glGenVertexShadersEXT(range: TGLuint): TGLuint {.importc.} + proc glLinkProgramARB(programObj: TGLhandleARB) {.importc.} + proc glVertexAttribL4dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glBlitFramebuffer(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} + proc glUseProgram(program: TGLuint) {.importc.} + proc glNamedProgramLocalParameterI4ivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLint) {.importc.} + proc glMatrixLoadTransposedEXT(mode: TGLenum, m: TGLdouble) {.importc.} + proc glTranslatef(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glGetBooleani_v(target: TGLenum, index: TGLuint, data: TGLboolean) {.importc.} + proc glEndFragmentShaderATI() {.importc.} + proc glVertexAttribI4ivEXT(index: TGLuint, v: TGLint) {.importc.} + proc glMultiDrawElementsIndirectBindlessNV(mode: TGLenum, `type`: TGLenum, indirect: pointer, drawCount: TGLsizei, stride: TGLsizei, vertexBufferCount: TGLint) {.importc.} + proc glTexCoord2s(s: TGLshort, t: TGLshort) {.importc.} + proc glProgramUniform1i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glPointSizePointerOES(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glGetTexFilterFuncSGIS(target: TGLenum, filter: TGLenum, weights: TGLfloat) {.importc.} + proc glMapGrid2xOES(n: TGLint, u1: TGLfixed, u2: TGLfixed, v1: TGLfixed, v2: TGLfixed) {.importc.} + proc glRasterPos4xvOES(coords: TGLfixed) {.importc.} + proc glGetProgramBinary(program: TGLuint, bufSize: TGLsizei, length: TGLsizei, binaryFormat: TGLenum, binary: pointer) {.importc.} + proc glNamedProgramLocalParameterI4uiEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} + proc glGetTexImage(target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glColor4d(red: TGLdouble, green: TGLdouble, blue: TGLdouble, alpha: TGLdouble) {.importc.} + proc glTexCoord2fColor4fNormal3fVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glIndexi(c: TGLint) {.importc.} + proc glGetSamplerParameterIuiv(sampler: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glGetnUniformivARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLint) {.importc.} + proc glCopyTexSubImage3DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glVertexAttribI2uivEXT(index: TGLuint, v: TGLuint) {.importc.} + proc glVertexStream2fvATI(stream: TGLenum, coords: TGLfloat) {.importc.} + proc glArrayElementEXT(i: TGLint) {.importc.} + proc glVertexAttrib2fv(index: TGLuint, v: TGLfloat) {.importc.} + proc glCopyMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} + proc glTexCoord4sv(v: TGLshort) {.importc.} + proc glTexGenfvOES(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glPointParameteriv(pname: TGLenum, params: TGLint) {.importc.} + proc glGetNamedRenderbufferParameterivEXT(renderbuffer: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramVertexLimitNV(target: TGLenum, limit: TGLint) {.importc.} + proc glSetMultisamplefvAMD(pname: TGLenum, index: TGLuint, val: TGLfloat) {.importc.} + proc glLoadIdentityDeformationMapSGIX(mask: TGLbitfield) {.importc.} + proc glIsSyncAPPLE(sync: TGLsync): TGLboolean {.importc.} + proc glProgramUniform1ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glEdgeFlagPointerListIBM(stride: TGLint, `pointer`: ptr TGLboolean, ptrstride: TGLint) {.importc.} + proc glBeginVertexShaderEXT() {.importc.} + proc glGetIntegerv(pname: TGLenum, params: TGLint) {.importc.} + proc glVertexAttrib2dvARB(index: TGLuint, v: TGLdouble) {.importc.} + proc glBeginConditionalRenderNV(id: TGLuint, mode: TGLenum) {.importc.} + proc glEdgeFlagv(flag: TGLboolean) {.importc.} + proc glReplacementCodeubSUN(code: TGLubyte) {.importc.} + proc glObjectLabel(identifier: TGLenum, name: TGLuint, length: TGLsizei, label: TGLchar) {.importc.} + proc glMultiTexCoord3xvOES(texture: TGLenum, coords: TGLfixed) {.importc.} + proc glNormal3iv(v: TGLint) {.importc.} + proc glSamplerParameteri(sampler: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glTextureStorage1DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc.} + proc glVertexStream4dvATI(stream: TGLenum, coords: TGLdouble) {.importc.} + proc glWindowPos2fv(v: TGLfloat) {.importc.} + proc glTexCoord4i(s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc.} + proc glVertexAttrib4NusvARB(index: TGLuint, v: TGLushort) {.importc.} + proc glVertexAttribL4d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glVertexAttribDivisorANGLE(index: TGLuint, divisor: TGLuint) {.importc.} + proc glMatrixIndexPointerOES(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glMultMatrixxOES(m: TGLfixed) {.importc.} + proc glMultiTexCoordP2ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} + proc glDeformationMap3dSGIX(target: TGLenum, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, w1: TGLdouble, w2: TGLdouble, wstride: TGLint, worder: TGLint, points: TGLdouble) {.importc.} + proc glClearDepthfOES(depth: TGLclampf) {.importc.} + proc glVertexStream1ivATI(stream: TGLenum, coords: TGLint) {.importc.} + proc glHint(target: TGLenum, mode: TGLenum) {.importc.} + proc glVertex3fv(v: TGLfloat) {.importc.} + proc glWaitSyncAPPLE(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64) {.importc.} + proc glWindowPos3i(x: TGLint, y: TGLint, z: TGLint) {.importc.} + proc glCompressedTexImage3DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} + proc glVertexAttrib1fvARB(index: TGLuint, v: TGLfloat) {.importc.} + proc glMultiTexCoord4xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc.} + proc glUniform4ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc.} + proc glProgramUniform4uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} + proc glUnmapNamedBufferEXT(buffer: TGLuint): TGLboolean {.importc.} + proc glBitmap(width: TGLsizei, height: TGLsizei, xorig: TGLfloat, yorig: TGLfloat, xmove: TGLfloat, ymove: TGLfloat, bitmap: TGLubyte) {.importc.} + proc glNamedProgramLocalParameters4fvEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLfloat) {.importc.} + proc glGetPathCommandsNV(path: TGLuint, commands: TGLubyte) {.importc.} + proc glVertexAttrib3fNV(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glNamedProgramStringEXT(program: TGLuint, target: TGLenum, format: TGLenum, len: TGLsizei, string: pointer) {.importc.} + proc glMatrixIndexusvARB(size: TGLint, indices: TGLushort) {.importc.} + proc glBlitFramebufferNV(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} + proc glVertexAttribI1uiv(index: TGLuint, v: TGLuint) {.importc.} + proc glEndConditionalRenderNV() {.importc.} + proc glFeedbackBuffer(size: TGLsizei, `type`: TGLenum, buffer: TGLfloat) {.importc.} + proc glMultiTexCoord3bvOES(texture: TGLenum, coords: TGLbyte) {.importc.} + proc glCopyColorTableSGI(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} + proc glActiveTexture(texture: TGLenum) {.importc.} + proc glFogCoordhNV(fog: TGLhalfNV) {.importc.} + proc glColorMaskIndexedEXT(index: TGLuint, r: TGLboolean, g: TGLboolean, b: TGLboolean, a: TGLboolean) {.importc.} + proc glGetCompressedTexImage(target: TGLenum, level: TGLint, img: pointer) {.importc.} + proc glRasterPos2iv(v: TGLint) {.importc.} + proc glGetBufferParameterivARB(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramUniform3d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble, v2: TGLdouble) {.importc.} + proc glRasterPos3xvOES(coords: TGLfixed) {.importc.} + proc glGetTextureParameterIuivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glBindImageTextureEXT(index: TGLuint, texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, access: TGLenum, format: TGLint) {.importc.} + proc glWindowPos2iMESA(x: TGLint, y: TGLint) {.importc.} + proc glVertexPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc.} + proc glPixelTexGenParameterfvSGIS(pname: TGLenum, params: TGLfloat) {.importc.} + proc glUniform1iARB(location: TGLint, v0: TGLint) {.importc.} + proc glTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glStencilOpSeparate(face: TGLenum, sfail: TGLenum, dpfail: TGLenum, dppass: TGLenum) {.importc.} + proc glVertexAttrib1dARB(index: TGLuint, x: TGLdouble) {.importc.} + proc glGetVideoCaptureStreamivNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glIsFramebufferEXT(framebuffer: TGLuint): TGLboolean {.importc.} + proc glPointParameterxv(pname: TGLenum, params: TGLfixed) {.importc.} + proc glProgramUniform4dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glPassThrough(token: TGLfloat) {.importc.} + proc glGetProgramPipelineiv(pipeline: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glApplyTextureEXT(mode: TGLenum) {.importc.} + proc glVertexArrayNormalOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glTexFilterFuncSGIS(target: TGLenum, filter: TGLenum, n: TGLsizei, weights: TGLfloat) {.importc.} + proc glRenderbufferStorageOES(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glBindParameterEXT(value: TGLenum): TGLuint {.importc.} + proc glVertex4s(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} + proc glLoadTransposeMatrixf(m: TGLfloat) {.importc.} + proc glDepthFunc(func: TGLenum) {.importc.} + proc glGetFramebufferAttachmentParameterivEXT(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glSampleMaskSGIS(value: TGLclampf, invert: TGLboolean) {.importc.} + proc glGetPointerIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr pointer) {.importc.} + proc glVertexStream4iATI(stream: TGLenum, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glUnlockArraysEXT() {.importc.} + proc glReplacementCodeuivSUN(code: TGLuint) {.importc.} + proc glMatrixScaledEXT(mode: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glFeedbackBufferxOES(n: TGLsizei, `type`: TGLenum, buffer: TGLfixed) {.importc.} + proc glLightEnviSGIX(pname: TGLenum, param: TGLint) {.importc.} + proc glMultiTexCoord4dARB(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc.} + proc glExtGetTexLevelParameterivQCOM(texture: TGLuint, face: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexAttribI4usvEXT(index: TGLuint, v: TGLushort) {.importc.} + proc glWindowPos2dvARB(v: TGLdouble) {.importc.} + proc glBindFramebuffer(target: TGLenum, framebuffer: TGLuint) {.importc.} + proc glGetProgramPipelineivEXT(pipeline: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramUniformHandleui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, values: TGLuint64) {.importc.} + proc glFogCoordhvNV(fog: TGLhalfNV) {.importc.} + proc glTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glGetActiveAtomicCounterBufferiv(program: TGLuint, bufferIndex: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glBeginQueryARB(target: TGLenum, id: TGLuint) {.importc.} + proc glGetTexParameterIuivEXT(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glUniform4ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glClearAccumxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} + proc glFreeObjectBufferATI(buffer: TGLuint) {.importc.} + proc glGetVideouivNV(video_slot: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glVertexAttribL4ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc.} + proc glGetUniformBlockIndex(program: TGLuint, uniformBlockName: TGLchar): TGLuint {.importc.} + proc glCopyMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glVertex3bvOES(coords: TGLbyte) {.importc.} + proc glMultiDrawElementArrayAPPLE(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glPrimitiveRestartNV() {.importc.} + proc glMateriali(face: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glBegin(mode: TGLenum) {.importc.} + proc glFogCoordPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glTexCoord1sv(v: TGLshort) {.importc.} + proc glVertexAttribI4sv(index: TGLuint, v: TGLshort) {.importc.} + proc glTexEnvx(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glTexParameterIivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glLoadTransposeMatrixfARB(m: TGLfloat) {.importc.} + proc glGetTextureSamplerHandleARB(texture: TGLuint, sampler: TGLuint): TGLuint64 {.importc.} + proc glVertexP3uiv(`type`: TGLenum, value: TGLuint) {.importc.} + proc glProgramUniform2dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glTexCoord4xvOES(coords: TGLfixed) {.importc.} + proc glTexStorage1D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc.} + proc glTextureParameterfEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glVertexAttrib1d(index: TGLuint, x: TGLdouble) {.importc.} + proc glGetnPixelMapfvARB(map: TGLenum, bufSize: TGLsizei, values: TGLfloat) {.importc.} + proc glDisableVertexAttribArray(index: TGLuint) {.importc.} + proc glUniformMatrix4x3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glRasterPos4f(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glProgramUniform1fEXT(program: TGLuint, location: TGLint, v0: TGLfloat) {.importc.} + proc glPathTexGenNV(texCoordSet: TGLenum, genMode: TGLenum, components: TGLint, coeffs: TGLfloat) {.importc.} + proc glUniform3ui(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} + proc glVDPAURegisterOutputSurfaceNV(vdpSurface: pointer, target: TGLenum, numTextureNames: TGLsizei, textureNames: TGLuint): TGLvdpauSurfaceNV {.importc.} + proc glGetProgramLocalParameterIuivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glIsTextureHandleResidentNV(handle: TGLuint64): TGLboolean {.importc.} + proc glProgramEnvParameters4fvEXT(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLfloat) {.importc.} + proc glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glGetMultiTexEnvivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetFloatv(pname: TGLenum, params: TGLfloat) {.importc.} + proc glInsertEventMarkerEXT(length: TGLsizei, marker: TGLchar) {.importc.} + proc glRasterPos3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glNamedFramebufferRenderbufferEXT(framebuffer: TGLuint, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} + proc glGetConvolutionFilter(target: TGLenum, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} + proc glIsOcclusionQueryNV(id: TGLuint): TGLboolean {.importc.} + proc glGetnPixelMapuivARB(map: TGLenum, bufSize: TGLsizei, values: TGLuint) {.importc.} + proc glMapParameterfvNV(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glPushDebugGroup(source: TGLenum, id: TGLuint, length: TGLsizei, message: TGLchar) {.importc.} + proc glMakeImageHandleResidentARB(handle: TGLuint64, access: TGLenum) {.importc.} + proc glProgramUniformMatrix2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glUniform3i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glImageTransformParameteriHP(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glMultiTexCoord1s(target: TGLenum, s: TGLshort) {.importc.} + proc glVertexAttribL4dvEXT(index: TGLuint, v: TGLdouble) {.importc.} + proc glGetProgramEnvParameterfvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} + proc glVertexArrayColorOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glGetHistogramParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetRenderbufferParameterivOES(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetBufferPointerv(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} + proc glSecondaryColor3ui(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc.} + proc glGetDebugMessageLog(count: TGLuint, bufsize: TGLsizei, sources: TGLenum, types: TGLenum, ids: TGLuint, severities: TGLenum, lengths: TGLsizei, messageLog: TGLchar): TGLuint {.importc.} + proc glNormal3i(nx: TGLint, ny: TGLint, nz: TGLint) {.importc.} + proc glTestFenceNV(fence: TGLuint): TGLboolean {.importc.} + proc glSecondaryColor3usv(v: TGLushort) {.importc.} + proc glGenPathsNV(range: TGLsizei): TGLuint {.importc.} + proc glDeleteBuffersARB(n: TGLsizei, buffers: TGLuint) {.importc.} + proc glProgramUniform4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glGetSharpenTexFuncSGIS(target: TGLenum, points: TGLfloat) {.importc.} + proc glDrawMeshArraysSUN(mode: TGLenum, first: TGLint, count: TGLsizei, width: TGLsizei) {.importc.} + proc glVertexAttribs4hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc.} + proc glGetClipPlane(plane: TGLenum, equation: TGLdouble) {.importc.} + proc glEvalCoord2fv(u: TGLfloat) {.importc.} + proc glAsyncMarkerSGIX(marker: TGLuint) {.importc.} + proc glGetSynciv(sync: TGLsync, pname: TGLenum, bufSize: TGLsizei, length: TGLsizei, values: TGLint) {.importc.} + proc glGetPathTexGenfvNV(texCoordSet: TGLenum, pname: TGLenum, value: TGLfloat) {.importc.} + proc glTexParameterf(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glMultiTexCoord1fvARB(target: TGLenum, v: TGLfloat) {.importc.} + proc glNormalPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} + proc glFragmentLightfvSGIX(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glViewportArrayv(first: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} + proc glNormal3fVertex3fSUN(nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glMultiTexCoord2dvARB(target: TGLenum, v: TGLdouble) {.importc.} + proc glCopyColorSubTable(target: TGLenum, start: TGLsizei, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} + proc glTexCoord2hvNV(v: TGLhalfNV) {.importc.} + proc glGetQueryObjectiv(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glColor4hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV, alpha: TGLhalfNV) {.importc.} + proc glProgramUniform2fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glMultiTexCoord4hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV, q: TGLhalfNV) {.importc.} + proc glWindowPos2fvMESA(v: TGLfloat) {.importc.} + proc glVertexAttrib3s(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} + proc glGetIntegerIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLint) {.importc.} + proc glVertexAttrib4Niv(index: TGLuint, v: TGLint) {.importc.} + proc glProgramLocalParameter4dvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} + proc glFramebufferTextureLayerEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} + proc glVertexAttribI1ui(index: TGLuint, x: TGLuint) {.importc.} + proc glFogCoorddv(coord: TGLdouble) {.importc.} + proc glLightModelxv(pname: TGLenum, param: TGLfixed) {.importc.} + proc glGetCombinerOutputParameterfvNV(stage: TGLenum, portion: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glFramebufferReadBufferEXT(framebuffer: TGLuint, mode: TGLenum) {.importc.} + proc glGetActiveUniformsiv(program: TGLuint, uniformCount: TGLsizei, uniformIndices: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetProgramStringNV(id: TGLuint, pname: TGLenum, program: TGLubyte) {.importc.} + proc glCopyConvolutionFilter2D(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glMultiTexCoord3iARB(target: TGLenum, s: TGLint, t: TGLint, r: TGLint) {.importc.} + proc glPushName(name: TGLuint) {.importc.} + proc glProgramParameter4dNV(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glVertexAttrib4svARB(index: TGLuint, v: TGLshort) {.importc.} + proc glSecondaryColor3iv(v: TGLint) {.importc.} + proc glCopyColorSubTableEXT(target: TGLenum, start: TGLsizei, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} + proc glCallList(list: TGLuint) {.importc.} + proc glGetMultiTexLevelParameterivEXT(texunit: TGLenum, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramUniformMatrix2x4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glTexBumpParameterivATI(pname: TGLenum, param: TGLint) {.importc.} + proc glTexGeni(coord: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glSecondaryColor3dv(v: TGLdouble) {.importc.} + proc glGetnUniformdvARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLdouble) {.importc.} + proc glGetNamedProgramLocalParameterdvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} + proc glGetVertexAttribPointervARB(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc.} + proc glCopyColorTable(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} + proc glNamedFramebufferTextureLayerEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} + proc glLoadProgramNV(target: TGLenum, id: TGLuint, len: TGLsizei, program: TGLubyte) {.importc.} + proc glAlphaFragmentOp2ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint) {.importc.} + proc glBindLightParameterEXT(light: TGLenum, value: TGLenum): TGLuint {.importc.} + proc glVertexAttrib1fv(index: TGLuint, v: TGLfloat) {.importc.} + proc glLoadIdentity() {.importc.} + proc glFramebufferTexture2DMultisampleEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, samples: TGLsizei) {.importc.} + proc glVertexAttrib1dvARB(index: TGLuint, v: TGLdouble) {.importc.} + proc glDrawRangeElementsBaseVertex(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer, basevertex: TGLint) {.importc.} + proc glPixelMapfv(map: TGLenum, mapsize: TGLsizei, values: TGLfloat) {.importc.} + proc glPointParameterxOES(pname: TGLenum, param: TGLfixed) {.importc.} + proc glBindBufferRangeNV(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} + proc glDepthBoundsEXT(zmin: TGLclampd, zmax: TGLclampd) {.importc.} + proc glProgramUniformMatrix2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glSecondaryColor3s(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc.} + proc glEdgeFlagPointerEXT(stride: TGLsizei, count: TGLsizei, `pointer`: TGLboolean) {.importc.} + proc glVertexStream1fATI(stream: TGLenum, x: TGLfloat) {.importc.} + proc glUniformui64NV(location: TGLint, value: TGLuint64EXT) {.importc.} + proc glTexCoordP4uiv(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glTexCoord3d(s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc.} + proc glDeleteProgramPipelines(n: TGLsizei, pipelines: TGLuint) {.importc.} + proc glVertex2iv(v: TGLint) {.importc.} + proc glGetMultisamplefv(pname: TGLenum, index: TGLuint, val: TGLfloat) {.importc.} + proc glStartInstrumentsSGIX() {.importc.} + proc glGetOcclusionQueryivNV(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glDebugMessageCallback(callback: TGLDEBUGPROC, userParam: pointer) {.importc.} + proc glPixelZoomxOES(xfactor: TGLfixed, yfactor: TGLfixed) {.importc.} + proc glTexCoord3i(s: TGLint, t: TGLint, r: TGLint) {.importc.} + proc glEdgeFlagFormatNV(stride: TGLsizei) {.importc.} + proc glProgramUniform2i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint) {.importc.} + proc glColor3b(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc.} + proc glDepthRangefOES(n: TGLclampf, f: TGLclampf) {.importc.} + proc glEndVertexShaderEXT() {.importc.} + proc glBindVertexArrayAPPLE(`array`: TGLuint) {.importc.} + proc glColor4bv(v: TGLbyte) {.importc.} + proc glNamedFramebufferTexture2DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glTexCoord1f(s: TGLfloat) {.importc.} + proc glUniform3fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glGetQueryObjectuivARB(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glVertexAttrib4bv(index: TGLuint, v: TGLbyte) {.importc.} + proc glGetPixelTransformParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexAttrib3svNV(index: TGLuint, v: TGLshort) {.importc.} + proc glDeleteQueriesEXT(n: TGLsizei, ids: TGLuint) {.importc.} + proc glUniform3ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glNormal3xvOES(coords: TGLfixed) {.importc.} + proc glMatrixLoadfEXT(mode: TGLenum, m: TGLfloat) {.importc.} + proc glGetNamedFramebufferAttachmentParameterivEXT(framebuffer: TGLuint, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glSeparableFilter2D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer) {.importc.} + proc glVertexAttribI3uiv(index: TGLuint, v: TGLuint) {.importc.} + proc glTextureStorageSparseAMD(texture: TGLuint, target: TGLenum, internalFormat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, layers: TGLsizei, flags: TGLbitfield) {.importc.} + proc glMultiDrawArraysIndirectCountARB(mode: TGLenum, indirect: TGLintptr, drawcount: TGLintptr, maxdrawcount: TGLsizei, stride: TGLsizei) {.importc.} + proc glTranslated(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glColorPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glDrawElementsInstancedBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei, basevertex: TGLint) {.importc.} + proc glBindAttribLocationARB(programObj: TGLhandleARB, index: TGLuint, name: TGLcharARB) {.importc.} + proc glTexGendv(coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc.} + proc glGetPathCoordsNV(path: TGLuint, coords: TGLfloat) {.importc.} + proc glGetMapParameterivNV(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glClientAttribDefaultEXT(mask: TGLbitfield) {.importc.} + proc glProgramUniformMatrix4x3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glEnable(cap: TGLenum) {.importc.} + proc glGetVertexAttribPointervNV(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc.} + proc glBindMultiTextureEXT(texunit: TGLenum, target: TGLenum, texture: TGLuint) {.importc.} + proc glGetConvolutionParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glLightModelxvOES(pname: TGLenum, param: TGLfixed) {.importc.} + proc glMultiTexCoord4sv(target: TGLenum, v: TGLshort) {.importc.} + proc glGetColorTableParameterivSGI(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glFramebufferTexture2DOES(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glClearDepthxOES(depth: TGLfixed) {.importc.} + proc glDisableClientStateiEXT(`array`: TGLenum, index: TGLuint) {.importc.} + proc glWindowPos2dARB(x: TGLdouble, y: TGLdouble) {.importc.} + proc glVertexAttrib1fvNV(index: TGLuint, v: TGLfloat) {.importc.} + proc glDepthRangedNV(zNear: TGLdouble, zFar: TGLdouble) {.importc.} + proc glClear(mask: TGLbitfield) {.importc.} + proc glUnmapTexture2DINTEL(texture: TGLuint, level: TGLint) {.importc.} + proc glSecondaryColor3ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc.} + proc glVertexAttribI4bv(index: TGLuint, v: TGLbyte) {.importc.} + proc glTexRenderbufferNV(target: TGLenum, renderbuffer: TGLuint) {.importc.} + proc glColor4ubVertex3fvSUN(c: TGLubyte, v: TGLfloat) {.importc.} + proc glVertexAttrib2svNV(index: TGLuint, v: TGLshort) {.importc.} + proc glMultiTexCoord1ivARB(target: TGLenum, v: TGLint) {.importc.} + proc glUniformMatrix3x2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glVertexAttribL3dvEXT(index: TGLuint, v: TGLdouble) {.importc.} + proc glMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glGetBufferPointervARB(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} + proc glGetMultiTexLevelParameterfvEXT(texunit: TGLenum, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glMultiTexParameterIuivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glGetShaderSource(shader: TGLuint, bufSize: TGLsizei, length: TGLsizei, source: TGLchar) {.importc.} + proc glStencilFunc(func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} + proc glVertexAttribI4bvEXT(index: TGLuint, v: TGLbyte) {.importc.} + proc glVertexAttrib4NuivARB(index: TGLuint, v: TGLuint) {.importc.} + proc glIsObjectBufferATI(buffer: TGLuint): TGLboolean {.importc.} + proc glRasterPos2xOES(x: TGLfixed, y: TGLfixed) {.importc.} + proc glIsFenceNV(fence: TGLuint): TGLboolean {.importc.} + proc glGetFramebufferParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glClearBufferfv(buffer: TGLenum, drawbuffer: TGLint, value: TGLfloat) {.importc.} + proc glClearColorxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} + proc glVertexWeightfEXT(weight: TGLfloat) {.importc.} + proc glExtIsProgramBinaryQCOM(program: TGLuint): TGLboolean {.importc.} + proc glTextureStorage2DMultisampleEXT(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} + proc glGetHistogramParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glVertexAttrib4dNV(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glGetPerfMonitorCounterStringAMD(group: TGLuint, counter: TGLuint, bufSize: TGLsizei, length: TGLsizei, counterString: TGLchar) {.importc.} + proc glMultiTexCoord2sARB(target: TGLenum, s: TGLshort, t: TGLshort) {.importc.} + proc glSpriteParameterivSGIX(pname: TGLenum, params: TGLint) {.importc.} + proc glCompressedTextureImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glBufferSubData(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} + proc glBlendParameteriNV(pname: TGLenum, value: TGLint) {.importc.} + proc glVertexAttrib2fvNV(index: TGLuint, v: TGLfloat) {.importc.} + proc glGetVariantBooleanvEXT(id: TGLuint, value: TGLenum, data: TGLboolean) {.importc.} + proc glProgramParameteri(program: TGLuint, pname: TGLenum, value: TGLint) {.importc.} + proc glGetLocalConstantIntegervEXT(id: TGLuint, value: TGLenum, data: TGLint) {.importc.} + proc glFragmentMaterialiSGIX(face: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glGetNamedStringivARB(namelen: TGLint, name: TGLchar, pname: TGLenum, params: TGLint) {.importc.} + proc glBinormal3ivEXT(v: TGLint) {.importc.} + proc glCheckFramebufferStatusEXT(target: TGLenum): TGLenum {.importc.} + proc glVertexAttrib1fNV(index: TGLuint, x: TGLfloat) {.importc.} + proc glNamedRenderbufferStorageEXT(renderbuffer: TGLuint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glPresentFrameKeyedNV(video_slot: TGLuint, minPresentTime: TGLuint64EXT, beginPresentTimeId: TGLuint, presentDurationId: TGLuint, `type`: TGLenum, target0: TGLenum, fill0: TGLuint, key0: TGLuint, target1: TGLenum, fill1: TGLuint, key1: TGLuint) {.importc.} + proc glGetObjectParameterfvARB(obj: TGLhandleARB, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertex3sv(v: TGLshort) {.importc.} + proc glColor4s(red: TGLshort, green: TGLshort, blue: TGLshort, alpha: TGLshort) {.importc.} + proc glGetQueryObjecti64vEXT(id: TGLuint, pname: TGLenum, params: TGLint64) {.importc.} + proc glEvalMesh2(mode: TGLenum, i1: TGLint, i2: TGLint, j1: TGLint, j2: TGLint) {.importc.} + proc glBeginTransformFeedbackEXT(primitiveMode: TGLenum) {.importc.} + proc glBufferAddressRangeNV(pname: TGLenum, index: TGLuint, address: TGLuint64EXT, length: TGLsizeiptr) {.importc.} + proc glPointParameterfvARB(pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetActiveVaryingNV(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLsizei, `type`: TGLenum, name: TGLchar) {.importc.} + proc glIndexMask(mask: TGLuint) {.importc.} + proc glVertexAttribBinding(attribindex: TGLuint, bindingindex: TGLuint) {.importc.} + proc glDeleteFencesNV(n: TGLsizei, fences: TGLuint) {.importc.} + proc glVertexAttribI4ubv(index: TGLuint, v: TGLubyte) {.importc.} + proc glPathParameterfvNV(path: TGLuint, pname: TGLenum, value: TGLfloat) {.importc.} + proc glVertexStream3fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glVertexAttribs4svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc.} + proc glVertexAttrib4sNV(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} + proc glAlphaFragmentOp3ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint, arg3: TGLuint, arg3Rep: TGLuint, arg3Mod: TGLuint) {.importc.} + proc glGetHistogramParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexAttribL1ui64NV(index: TGLuint, x: TGLuint64EXT) {.importc.} + proc glVertexAttribs3fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} + proc glMultiTexCoord3ivARB(target: TGLenum, v: TGLint) {.importc.} + proc glClipPlanefOES(plane: TGLenum, equation: TGLfloat) {.importc.} + proc glVertex3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} + proc glVertex3dv(v: TGLdouble) {.importc.} + proc glWeightPointerOES(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glBindBufferBase(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc.} + proc glIndexs(c: TGLshort) {.importc.} + proc glTessellationFactorAMD(factor: TGLfloat) {.importc.} + proc glColor4ubVertex3fSUN(r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glPauseTransformFeedback() {.importc.} + proc glImageTransformParameterivHP(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glColor3dv(v: TGLdouble) {.importc.} + proc glRasterPos4sv(v: TGLshort) {.importc.} + proc glInvalidateTexSubImage(texture: TGLuint, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} + proc glNormalStream3bvATI(stream: TGLenum, coords: TGLbyte) {.importc.} + proc glUniformMatrix2x4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glMinmax(target: TGLenum, internalformat: TGLenum, sink: TGLboolean) {.importc.} + proc glGetProgramStageiv(program: TGLuint, shadertype: TGLenum, pname: TGLenum, values: TGLint) {.importc.} + proc glScalex(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} + proc glTexBufferARB(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} + proc glDrawArraysIndirect(mode: TGLenum, indirect: pointer) {.importc.} + proc glMatrixLoadTransposefEXT(mode: TGLenum, m: TGLfloat) {.importc.} + proc glMultiTexCoord2f(target: TGLenum, s: TGLfloat, t: TGLfloat) {.importc.} + proc glDrawRangeElements(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc.} + proc glVertexAttrib4NubARB(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc.} + proc glMultiTexCoord4xvOES(texture: TGLenum, coords: TGLfixed) {.importc.} + proc glVertexArrayVertexAttribOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glVertexAttribL1i64vNV(index: TGLuint, v: TGLint64EXT) {.importc.} + proc glMapBuffer(target: TGLenum, access: TGLenum) {.importc.} + proc glUniform1ui(location: TGLint, v0: TGLuint) {.importc.} + proc glGetPixelMapfv(map: TGLenum, values: TGLfloat) {.importc.} + proc glTexImage2DMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} + proc glUniform2ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glVertexAttribI3ui(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint) {.importc.} + proc glGetProgramResourceiv(program: TGLuint, programInterface: TGLenum, index: TGLuint, propCount: TGLsizei, props: TGLenum, bufSize: TGLsizei, length: TGLsizei, params: TGLint) {.importc.} + proc glUniform4iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glVertexAttrib3f(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glClientActiveVertexStreamATI(stream: TGLenum) {.importc.} + proc glTexCoord4fColor4fNormal3fVertex4fvSUN(tc: TGLfloat, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} + proc glColor3xvOES(components: TGLfixed) {.importc.} + proc glVertexPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} + proc glProgramEnvParameter4dARB(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glGetLocalConstantFloatvEXT(id: TGLuint, value: TGLenum, data: TGLfloat) {.importc.} + proc glTexCoordPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} + proc glTexCoordPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc.} + proc glSelectPerfMonitorCountersAMD(monitor: TGLuint, enable: TGLboolean, group: TGLuint, numCounters: TGLint, counterList: TGLuint) {.importc.} + proc glVertexStream4svATI(stream: TGLenum, coords: TGLshort) {.importc.} + proc glColor3ui(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc.} + proc glBindTransformFeedbackNV(target: TGLenum, id: TGLuint) {.importc.} + proc glDeformSGIX(mask: TGLbitfield) {.importc.} + proc glDeformationMap3fSGIX(target: TGLenum, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, w1: TGLfloat, w2: TGLfloat, wstride: TGLint, worder: TGLint, points: TGLfloat) {.importc.} + proc glNamedBufferSubDataEXT(buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} + proc glGetNamedProgramStringEXT(program: TGLuint, target: TGLenum, pname: TGLenum, string: pointer) {.importc.} + proc glCopyPathNV(resultPath: TGLuint, srcPath: TGLuint) {.importc.} + proc glMapControlPointsNV(target: TGLenum, index: TGLuint, `type`: TGLenum, ustride: TGLsizei, vstride: TGLsizei, uorder: TGLint, vorder: TGLint, packed: TGLboolean, points: pointer) {.importc.} + proc glGetBufferParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glUnmapObjectBufferATI(buffer: TGLuint) {.importc.} + proc glGetProgramResourceLocation(program: TGLuint, programInterface: TGLenum, name: TGLchar): TGLint {.importc.} + proc glUniform4i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glImageTransformParameterfHP(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glArrayObjectATI(`array`: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc.} + proc glBindBufferRangeEXT(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} + proc glVertexArrayVertexAttribFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, relativeoffset: TGLuint) {.importc.} + proc glBindRenderbufferEXT(target: TGLenum, renderbuffer: TGLuint) {.importc.} + proc glListParameteriSGIX(list: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glProgramUniformMatrix2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glProgramUniform2i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glObjectPtrLabelKHR(`ptr`: pointer, length: TGLsizei, label: TGLchar) {.importc.} + proc glVertexAttribL1i64NV(index: TGLuint, x: TGLint64EXT) {.importc.} + proc glMultiTexBufferEXT(texunit: TGLenum, target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} + proc glCoverFillPathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, coverMode: TGLenum, transformType: TGLenum, transformValues: TGLfloat) {.importc.} + proc glGetVertexAttribIivEXT(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glLightf(light: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glGetMinmaxParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glUniform1d(location: TGLint, x: TGLdouble) {.importc.} + proc glLightiv(light: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexAttrib2dvNV(index: TGLuint, v: TGLdouble) {.importc.} + proc glNormalP3ui(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glFinalCombinerInputNV(variable: TGLenum, input: TGLenum, mapping: TGLenum, componentUsage: TGLenum) {.importc.} + proc glUniform1uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glValidateProgramARB(programObj: TGLhandleARB) {.importc.} + proc glNormalPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glProgramNamedParameter4fvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, v: TGLfloat) {.importc.} + proc glGetBooleanv(pname: TGLenum, params: TGLboolean) {.importc.} + proc glTangent3ivEXT(v: TGLint) {.importc.} + proc glTexImage3DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} + proc glGetUniformIndices(program: TGLuint, uniformCount: TGLsizei, uniformNames: ptr TGLchar, uniformIndices: TGLuint) {.importc.} + proc glVDPAUInitNV(vdpDevice: pointer, getProcAddress: pointer) {.importc.} + proc glGetMinmaxParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glMultiTexCoord2fvARB(target: TGLenum, v: TGLfloat) {.importc.} + proc glProgramEnvParametersI4ivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLint) {.importc.} + proc glClearTexSubImage(texture: TGLuint, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glRectxOES(x1: TGLfixed, y1: TGLfixed, x2: TGLfixed, y2: TGLfixed) {.importc.} + proc glBlendEquationOES(mode: TGLenum) {.importc.} + proc glFramebufferTexture(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glGetInstrumentsSGIX(): TGLint {.importc.} + proc glFramebufferParameteri(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glPathCoverDepthFuncNV(func: TGLenum) {.importc.} + proc glGetTranslatedShaderSourceANGLE(shader: TGLuint, bufsize: TGLsizei, length: TGLsizei, source: TGLchar) {.importc.} + proc glIndexfv(c: TGLfloat) {.importc.} + proc glGetActiveUniformBlockName(program: TGLuint, uniformBlockIndex: TGLuint, bufSize: TGLsizei, length: TGLsizei, uniformBlockName: TGLchar) {.importc.} + proc glNormal3s(nx: TGLshort, ny: TGLshort, nz: TGLshort) {.importc.} + proc glColorFragmentOp3ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint, arg3: TGLuint, arg3Rep: TGLuint, arg3Mod: TGLuint) {.importc.} + proc glGetProgramResourceLocationIndex(program: TGLuint, programInterface: TGLenum, name: TGLchar): TGLint {.importc.} + proc glGetBooleanIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLboolean) {.importc.} + proc glGenPerfMonitorsAMD(n: TGLsizei, monitors: TGLuint) {.importc.} + proc glDrawRangeElementsEXT(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc.} + proc glFramebufferTexture3D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} + proc glGetTexParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glCompileShaderIncludeARB(shader: TGLuint, count: TGLsizei, path: ptr TGLchar, length: TGLint) {.importc.} + proc glGetMultiTexParameterfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glEvalPoint2(i: TGLint, j: TGLint) {.importc.} + proc glGetProgramivNV(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramParameter4fNV(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glMultiTexParameterfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexAttrib3svARB(index: TGLuint, v: TGLshort) {.importc.} + proc glDrawElementArrayAPPLE(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc.} + proc glMultiTexCoord4x(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc.} + proc glUniformMatrix3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glVertexAttribPointerARB(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glProgramUniformMatrix3x4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glGetFloati_vEXT(pname: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} + proc glGetObjectParameterivAPPLE(objectType: TGLenum, name: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glPushGroupMarkerEXT(length: TGLsizei, marker: TGLchar) {.importc.} + proc glProgramUniform4uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glReplacementCodeuiVertex3fSUN(rc: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glTexSubImage1DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glProgramUniform1uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glGetFenceivNV(fence: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetnCompressedTexImageARB(target: TGLenum, lod: TGLint, bufSize: TGLsizei, img: pointer) {.importc.} + proc glTexGenfOES(coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glVertexAttrib4dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glVertexAttribL1ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc.} + proc glVertexAttrib4fvARB(index: TGLuint, v: TGLfloat) {.importc.} + proc glDeleteVertexArraysOES(n: TGLsizei, arrays: TGLuint) {.importc.} + proc glSamplerParameterIiv(sampler: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glMapGrid1d(un: TGLint, u1: TGLdouble, u2: TGLdouble) {.importc.} + proc glTranslatexOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} + proc glCullFace(mode: TGLenum) {.importc.} + proc glPrioritizeTextures(n: TGLsizei, textures: TGLuint, priorities: TGLfloat) {.importc.} + proc glGetSeparableFilterEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer, span: pointer) {.importc.} + proc glVertexAttrib4NubvARB(index: TGLuint, v: TGLubyte) {.importc.} + proc glGetTransformFeedbackVaryingNV(program: TGLuint, index: TGLuint, location: TGLint) {.importc.} + proc glTexCoord4xOES(s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc.} + proc glGetProgramEnvParameterdvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} + proc glWindowPos2ivMESA(v: TGLint) {.importc.} + proc glGlobalAlphaFactorfSUN(factor: TGLfloat) {.importc.} + proc glNormalStream3fvATI(stream: TGLenum, coords: TGLfloat) {.importc.} + proc glRasterPos4i(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glReleaseShaderCompiler() {.importc.} + proc glProgramUniformMatrix4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glCopyMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} + proc glColorTableParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glSecondaryColor3bvEXT(v: TGLbyte) {.importc.} + proc glMap1xOES(target: TGLenum, u1: TGLfixed, u2: TGLfixed, stride: TGLint, order: TGLint, points: TGLfixed) {.importc.} + proc glVertexStream1svATI(stream: TGLenum, coords: TGLshort) {.importc.} + proc glIsRenderbuffer(renderbuffer: TGLuint): TGLboolean {.importc.} + proc glPatchParameterfv(pname: TGLenum, values: TGLfloat) {.importc.} + proc glProgramUniformMatrix4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glVertexAttrib4ubNV(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc.} + proc glVertex2i(x: TGLint, y: TGLint) {.importc.} + proc glPushClientAttrib(mask: TGLbitfield) {.importc.} + proc glDrawArraysEXT(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc.} + proc glCreateProgram(): TGLuint {.importc.} + proc glPolygonStipple(mask: TGLubyte) {.importc.} + proc glGetColorTableEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glSharpenTexFuncSGIS(target: TGLenum, n: TGLsizei, points: TGLfloat) {.importc.} + proc glNamedFramebufferTextureEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glWindowPos3fvMESA(v: TGLfloat) {.importc.} + proc glBinormal3iEXT(bx: TGLint, by: TGLint, bz: TGLint) {.importc.} + proc glEnableClientStateiEXT(`array`: TGLenum, index: TGLuint) {.importc.} + proc glProgramUniform3iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glProgramUniform1dEXT(program: TGLuint, location: TGLint, x: TGLdouble) {.importc.} + proc glPollInstrumentsSGIX(marker_p: TGLint): TGLint {.importc.} + proc glSecondaryColor3f(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc.} + proc glDeleteTransformFeedbacks(n: TGLsizei, ids: TGLuint) {.importc.} + proc glCoverStrokePathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, coverMode: TGLenum, transformType: TGLenum, transformValues: TGLfloat) {.importc.} + proc glIsTextureHandleResidentARB(handle: TGLuint64): TGLboolean {.importc.} + proc glVariantsvEXT(id: TGLuint, `addr`: TGLshort) {.importc.} + proc glTexCoordFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} + proc glTexStorage3DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} + proc glUniform2ui(location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} + proc glReplacementCodePointerSUN(`type`: TGLenum, stride: TGLsizei, `pointer`: ptr pointer) {.importc.} + proc glFramebufferTextureLayerARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} + proc glBinormal3dvEXT(v: TGLdouble) {.importc.} + proc glProgramUniform2ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glGetnConvolutionFilterARB(target: TGLenum, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, image: pointer) {.importc.} + proc glStopInstrumentsSGIX(marker: TGLint) {.importc.} + proc glVertexAttrib1svNV(index: TGLuint, v: TGLshort) {.importc.} + proc glVertexAttribs2fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} + proc glGetInternalformativ(target: TGLenum, internalformat: TGLenum, pname: TGLenum, bufSize: TGLsizei, params: TGLint) {.importc.} + proc glIsProgramPipelineEXT(pipeline: TGLuint): TGLboolean {.importc.} + proc glMatrixIndexubvARB(size: TGLint, indices: TGLubyte) {.importc.} + proc glTexCoord4bOES(s: TGLbyte, t: TGLbyte, r: TGLbyte, q: TGLbyte) {.importc.} + proc glSecondaryColor3us(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc.} + proc glGlobalAlphaFactorubSUN(factor: TGLubyte) {.importc.} + proc glNamedStringARB(`type`: TGLenum, namelen: TGLint, name: TGLchar, stringlen: TGLint, string: TGLchar) {.importc.} + proc glGetAttachedShaders(program: TGLuint, maxCount: TGLsizei, count: TGLsizei, shaders: TGLuint) {.importc.} + proc glMatrixRotatefEXT(mode: TGLenum, angle: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glVertexStream3ivATI(stream: TGLenum, coords: TGLint) {.importc.} + proc glMatrixIndexuivARB(size: TGLint, indices: TGLuint) {.importc.} + proc glMatrixRotatedEXT(mode: TGLenum, angle: TGLdouble, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glPathFogGenNV(genMode: TGLenum) {.importc.} + proc glMultiTexCoord4hvNV(target: TGLenum, v: TGLhalfNV) {.importc.} + proc glVertexAttribIPointer(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glMultiTexCoord3bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte, r: TGLbyte) {.importc.} + proc glResizeBuffersMESA() {.importc.} + proc glPrimitiveRestartIndexNV(index: TGLuint) {.importc.} + proc glProgramUniform4f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} + proc glColor4ubVertex2fSUN(r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat) {.importc.} + proc glGetColorTableParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glDepthRangef(n: TGLfloat, f: TGLfloat) {.importc.} + proc glVertexArrayVertexOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glMatrixLoaddEXT(mode: TGLenum, m: TGLdouble) {.importc.} + proc glVariantfvEXT(id: TGLuint, `addr`: TGLfloat) {.importc.} + proc glReplacementCodeuiTexCoord2fVertex3fvSUN(rc: TGLuint, tc: TGLfloat, v: TGLfloat) {.importc.} + proc glSamplePatternSGIS(pattern: TGLenum) {.importc.} + proc glProgramUniform3i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc.} + proc glUniform3uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glGetImageTransformParameterivHP(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glPopMatrix() {.importc.} + proc glVertexAttrib3sARB(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} + proc glGenQueriesEXT(n: TGLsizei, ids: TGLuint) {.importc.} + proc glGetQueryObjectui64v(id: TGLuint, pname: TGLenum, params: TGLuint64) {.importc.} + proc glWeightusvARB(size: TGLint, weights: TGLushort) {.importc.} + proc glWindowPos2sARB(x: TGLshort, y: TGLshort) {.importc.} + proc glGetTextureLevelParameterivEXT(texture: TGLuint, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc.} + proc glBufferParameteriAPPLE(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glMultiModeDrawArraysIBM(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei, modestride: TGLint) {.importc.} + proc glUniformMatrix2x3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glTangentPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glResetMinmax(target: TGLenum) {.importc.} + proc glVertexAttribP1uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} + proc glPixelMapx(map: TGLenum, size: TGLint, values: TGLfixed) {.importc.} + proc glPixelStoref(pname: TGLenum, param: TGLfloat) {.importc.} + proc glBinormal3dEXT(bx: TGLdouble, by: TGLdouble, bz: TGLdouble) {.importc.} + proc glVertexAttribs1hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc.} + proc glVertexAttrib4usvARB(index: TGLuint, v: TGLushort) {.importc.} + proc glUnmapBuffer(target: TGLenum): TGLboolean {.importc.} + proc glFlushRasterSGIX() {.importc.} + proc glColor3uiv(v: TGLuint) {.importc.} + proc glInvalidateBufferSubData(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr) {.importc.} + proc glPassThroughxOES(token: TGLfixed) {.importc.} + proc glLockArraysEXT(first: TGLint, count: TGLsizei) {.importc.} + proc glStencilFuncSeparateATI(frontfunc: TGLenum, backfunc: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} + proc glProgramUniform3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glGenTransformFeedbacks(n: TGLsizei, ids: TGLuint) {.importc.} + proc glCopyTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glIsNamedBufferResidentNV(buffer: TGLuint): TGLboolean {.importc.} + proc glSampleMaskIndexedNV(index: TGLuint, mask: TGLbitfield) {.importc.} + proc glVDPAUSurfaceAccessNV(surface: TGLvdpauSurfaceNV, access: TGLenum) {.importc.} + proc glProgramUniform3dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glDeleteProgram(program: TGLuint) {.importc.} + proc glConvolutionFilter1D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} + proc glVertex2f(x: TGLfloat, y: TGLfloat) {.importc.} + proc glWindowPos4dvMESA(v: TGLdouble) {.importc.} + proc glColor4us(red: TGLushort, green: TGLushort, blue: TGLushort, alpha: TGLushort) {.importc.} + proc glColorMask(red: TGLboolean, green: TGLboolean, blue: TGLboolean, alpha: TGLboolean) {.importc.} + proc glGetTexEnviv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramUniform3ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glSecondaryColor3i(red: TGLint, green: TGLint, blue: TGLint) {.importc.} + proc glGetSamplerParameteriv(sampler: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glDeleteFramebuffersEXT(n: TGLsizei, framebuffers: TGLuint) {.importc.} + proc glCompressedTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} + proc glVertex2s(x: TGLshort, y: TGLshort) {.importc.} + proc glIsQuery(id: TGLuint): TGLboolean {.importc.} + proc glFogxv(pname: TGLenum, param: TGLfixed) {.importc.} + proc glAreProgramsResidentNV(n: TGLsizei, programs: TGLuint, residences: TGLboolean): TGLboolean {.importc.} + proc glShaderSourceARB(shaderObj: TGLhandleARB, count: TGLsizei, string: ptr TGLcharARB, length: TGLint) {.importc.} + proc glPointSizexOES(size: TGLfixed) {.importc.} + proc glPixelTransferf(pname: TGLenum, param: TGLfloat) {.importc.} + proc glExtractComponentEXT(res: TGLuint, src: TGLuint, num: TGLuint) {.importc.} + proc glUniform1fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glGetNamedStringARB(namelen: TGLint, name: TGLchar, bufSize: TGLsizei, stringlen: TGLint, string: TGLchar) {.importc.} + proc glGetProgramBinaryOES(program: TGLuint, bufSize: TGLsizei, length: TGLsizei, binaryFormat: TGLenum, binary: pointer) {.importc.} + proc glDeleteOcclusionQueriesNV(n: TGLsizei, ids: TGLuint) {.importc.} + proc glEnableClientState(`array`: TGLenum) {.importc.} + proc glProgramBufferParametersIuivNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: TGLuint) {.importc.} + proc glProgramUniform2ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} + proc glReplacementCodeuiSUN(code: TGLuint) {.importc.} + proc glMultMatrixd(m: TGLdouble) {.importc.} + proc glInvalidateSubFramebuffer(target: TGLenum, numAttachments: TGLsizei, attachments: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glGenerateMultiTexMipmapEXT(texunit: TGLenum, target: TGLenum) {.importc.} + proc glDepthRangex(n: TGLfixed, f: TGLfixed) {.importc.} + proc glGetInteger64i_v(target: TGLenum, index: TGLuint, data: TGLint64) {.importc.} + proc glDrawBuffers(n: TGLsizei, bufs: TGLenum) {.importc.} + proc glGetPointervEXT(pname: TGLenum, params: ptr pointer) {.importc.} + proc glFogxvOES(pname: TGLenum, param: TGLfixed) {.importc.} + proc glTexCoordP2uiv(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glVertexFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} + proc glColorPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc.} + proc glGetMultiTexParameterivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glMultiTexCoordP4uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} + proc glResetMinmaxEXT(target: TGLenum) {.importc.} + proc glCopyBufferSubData(readTarget: TGLenum, writeTarget: TGLenum, readOffset: TGLintptr, writeOffset: TGLintptr, size: TGLsizeiptr) {.importc.} + proc glSecondaryColor3sv(v: TGLshort) {.importc.} + proc glPixelStorex(pname: TGLenum, param: TGLfixed) {.importc.} + proc glWaitSync(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64) {.importc.} + proc glVertexAttribI1iv(index: TGLuint, v: TGLint) {.importc.} + proc glColorSubTableEXT(target: TGLenum, start: TGLsizei, count: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glGetDoublev(pname: TGLenum, params: TGLdouble) {.importc.} + proc glMultiTexParameterivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glMultiTexCoord4svARB(target: TGLenum, v: TGLshort) {.importc.} + proc glColorPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} + proc glScissorIndexed(index: TGLuint, left: TGLint, bottom: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glStencilOpSeparateATI(face: TGLenum, sfail: TGLenum, dpfail: TGLenum, dppass: TGLenum) {.importc.} + proc glLoadName(name: TGLuint) {.importc.} + proc glIsTransformFeedbackNV(id: TGLuint): TGLboolean {.importc.} + proc glPopDebugGroup() {.importc.} + proc glClipPlanef(p: TGLenum, eqn: TGLfloat) {.importc.} + proc glDeleteFencesAPPLE(n: TGLsizei, fences: TGLuint) {.importc.} + proc glGetQueryObjecti64v(id: TGLuint, pname: TGLenum, params: TGLint64) {.importc.} + proc glAlphaFunc(func: TGLenum, `ref`: TGLfloat) {.importc.} + proc glIndexPointerEXT(`type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} + proc glVertexAttribI3ivEXT(index: TGLuint, v: TGLint) {.importc.} + proc glIndexub(c: TGLubyte) {.importc.} + proc glVertexP2uiv(`type`: TGLenum, value: TGLuint) {.importc.} + proc glProgramUniform1uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glDebugMessageInsertKHR(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: TGLchar) {.importc.} + proc glColor4b(red: TGLbyte, green: TGLbyte, blue: TGLbyte, alpha: TGLbyte) {.importc.} + proc glRenderbufferStorageMultisampleAPPLE(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glMinSampleShading(value: TGLfloat) {.importc.} + proc glBindProgramNV(target: TGLenum, id: TGLuint) {.importc.} + proc glWindowPos3dMESA(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glEdgeFlagPointer(stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glGetFragDataIndex(program: TGLuint, name: TGLchar): TGLint {.importc.} + proc glTexCoord3hNV(s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV) {.importc.} + proc glMultiDrawArraysIndirectAMD(mode: TGLenum, indirect: pointer, primcount: TGLsizei, stride: TGLsizei) {.importc.} + proc glFragmentColorMaterialSGIX(face: TGLenum, mode: TGLenum) {.importc.} + proc glTexGenf(coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} + proc glVertexAttrib4ubvARB(index: TGLuint, v: TGLubyte) {.importc.} + proc glClearBufferiv(buffer: TGLenum, drawbuffer: TGLint, value: TGLint) {.importc.} + proc glGenQueriesARB(n: TGLsizei, ids: TGLuint) {.importc.} + proc glRectdv(v1: TGLdouble, v2: TGLdouble) {.importc.} + proc glBlendEquationSeparateEXT(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} + proc glTestFenceAPPLE(fence: TGLuint): TGLboolean {.importc.} + proc glTexGeniv(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glPolygonMode(face: TGLenum, mode: TGLenum) {.importc.} + proc glFrameZoomSGIX(factor: TGLint) {.importc.} + proc glReplacementCodeuiTexCoord2fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glUniformSubroutinesuiv(shadertype: TGLenum, count: TGLsizei, indices: TGLuint) {.importc.} + proc glBeginQueryIndexed(target: TGLenum, index: TGLuint, id: TGLuint) {.importc.} + proc glMultiTexGeniEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glRasterPos3fv(v: TGLfloat) {.importc.} + proc glMapObjectBufferATI(buffer: TGLuint) {.importc.} + proc glIndexiv(c: TGLint) {.importc.} + proc glVertexAttribLPointer(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glMultiTexCoord4s(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc.} + proc glSecondaryColorP3uiv(`type`: TGLenum, color: TGLuint) {.importc.} + proc glNormalFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc.} + proc glVertex4i(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glUniform1ui64NV(location: TGLint, x: TGLuint64EXT) {.importc.} + proc glScissorIndexedv(index: TGLuint, v: TGLint) {.importc.} + proc glProgramUniform1i(program: TGLuint, location: TGLint, v0: TGLint) {.importc.} + proc glCompressedMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glFinishTextureSUNX() {.importc.} + proc glFramebufferTexture3DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} + proc glSetInvariantEXT(id: TGLuint, `type`: TGLenum, `addr`: pointer) {.importc.} + proc glGetTexParameterIivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glMultiTexCoordP3ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} + proc glMultiTexCoord3f(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc.} + proc glNormalStream3fATI(stream: TGLenum, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat) {.importc.} + proc glActiveShaderProgram(pipeline: TGLuint, program: TGLuint) {.importc.} + proc glDisableVertexArrayEXT(vaobj: TGLuint, `array`: TGLenum) {.importc.} + proc glVertexAttribI3iv(index: TGLuint, v: TGLint) {.importc.} + proc glProvokingVertex(mode: TGLenum) {.importc.} + proc glTexCoord1fv(v: TGLfloat) {.importc.} + proc glVertexAttrib3fv(index: TGLuint, v: TGLfloat) {.importc.} + proc glWindowPos3iv(v: TGLint) {.importc.} + proc glProgramUniform4ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc.} + proc glProgramUniform2d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble) {.importc.} + proc glDebugMessageInsertARB(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: TGLchar) {.importc.} + proc glMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glMap1d(target: TGLenum, u1: TGLdouble, u2: TGLdouble, stride: TGLint, order: TGLint, points: TGLdouble) {.importc.} + proc glDeleteShader(shader: TGLuint) {.importc.} + proc glTexturePageCommitmentEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, resident: TGLboolean) {.importc.} + proc glFramebufferDrawBufferEXT(framebuffer: TGLuint, mode: TGLenum) {.importc.} + proc glTexCoord2fNormal3fVertex3fSUN(s: TGLfloat, t: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glDeleteProgramsNV(n: TGLsizei, programs: TGLuint) {.importc.} + proc glPointAlongPathNV(path: TGLuint, startSegment: TGLsizei, numSegments: TGLsizei, distance: TGLfloat, x: TGLfloat, y: TGLfloat, tangentX: TGLfloat, tangentY: TGLfloat): TGLboolean {.importc.} + proc glTexCoord1d(s: TGLdouble) {.importc.} + proc glStencilStrokePathNV(path: TGLuint, reference: TGLint, mask: TGLuint) {.importc.} + proc glQueryMatrixxOES(mantissa: TGLfixed, exponent: TGLint): TGLbitfield {.importc.} + proc glGetNamedProgramLocalParameterIuivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glGenerateMipmapOES(target: TGLenum) {.importc.} + proc glRenderbufferStorageMultisampleIMG(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glVertexBlendEnviATI(pname: TGLenum, param: TGLint) {.importc.} + proc glPushAttrib(mask: TGLbitfield) {.importc.} + proc glShaderOp3EXT(op: TGLenum, res: TGLuint, arg1: TGLuint, arg2: TGLuint, arg3: TGLuint) {.importc.} + proc glEnableVertexAttribArray(index: TGLuint) {.importc.} + proc glVertexAttrib4Nbv(index: TGLuint, v: TGLbyte) {.importc.} + proc glExtGetBuffersQCOM(buffers: TGLuint, maxBuffers: TGLint, numBuffers: TGLint) {.importc.} + proc glCopyTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glDeletePerfMonitorsAMD(n: TGLsizei, monitors: TGLuint) {.importc.} + proc glGetTrackMatrixivNV(target: TGLenum, address: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glEndConditionalRender() {.importc.} + proc glVertexAttribL3i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc.} + proc glProgramLocalParametersI4ivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLint) {.importc.} + proc glFlush() {.importc.} + proc glGetNamedBufferParameterui64vNV(buffer: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc.} + proc glGetVertexArrayIntegeri_vEXT(vaobj: TGLuint, index: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glReadnPixelsEXT(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, data: pointer) {.importc.} + proc glMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glGetVaryingLocationNV(program: TGLuint, name: TGLchar): TGLint {.importc.} + proc glMultiTexCoord4fvARB(target: TGLenum, v: TGLfloat) {.importc.} + proc glMultiTexCoord3iv(target: TGLenum, v: TGLint) {.importc.} + proc glVertexAttribL2dvEXT(index: TGLuint, v: TGLdouble) {.importc.} + proc glTexParameterxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glSecondaryColor3uivEXT(v: TGLuint) {.importc.} + proc glReadnPixelsARB(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, data: pointer) {.importc.} + proc glCopyTexSubImage1DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} + proc glGetDoublei_vEXT(pname: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} + proc glVariantPointerEXT(id: TGLuint, `type`: TGLenum, stride: TGLuint, `addr`: pointer) {.importc.} + proc glProgramUniform3ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glTexCoord2fColor3fVertex3fvSUN(tc: TGLfloat, c: TGLfloat, v: TGLfloat) {.importc.} + proc glProgramUniform3fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glBindFragDataLocationIndexed(program: TGLuint, colorNumber: TGLuint, index: TGLuint, name: TGLchar) {.importc.} + proc glGetnSeparableFilterARB(target: TGLenum, format: TGLenum, `type`: TGLenum, rowBufSize: TGLsizei, row: pointer, columnBufSize: TGLsizei, column: pointer, span: pointer) {.importc.} + proc glTextureParameteriEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glGetUniformuivEXT(program: TGLuint, location: TGLint, params: TGLuint) {.importc.} + proc glFragmentMaterialivSGIX(face: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glMultiTexCoord1svARB(target: TGLenum, v: TGLshort) {.importc.} + proc glClientActiveTextureARB(texture: TGLenum) {.importc.} + proc glVertexAttrib1fARB(index: TGLuint, x: TGLfloat) {.importc.} + proc glVertexAttrib4NbvARB(index: TGLuint, v: TGLbyte) {.importc.} + proc glRasterPos2d(x: TGLdouble, y: TGLdouble) {.importc.} + proc glMultiTexCoord4iARB(target: TGLenum, s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc.} + proc glGetPixelTexGenParameterfvSGIS(pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexAttribL2dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glGetProgramStringARB(target: TGLenum, pname: TGLenum, string: pointer) {.importc.} + proc glRasterPos2i(x: TGLint, y: TGLint) {.importc.} + proc glTexCoord2fColor4fNormal3fVertex3fvSUN(tc: TGLfloat, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} + proc glMultiTexCoord3s(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort) {.importc.} + proc glMultTransposeMatrixd(m: TGLdouble) {.importc.} + proc glActiveVaryingNV(program: TGLuint, name: TGLchar) {.importc.} + proc glProgramUniform1f(program: TGLuint, location: TGLint, v0: TGLfloat) {.importc.} + proc glGetActiveSubroutineName(program: TGLuint, shadertype: TGLenum, index: TGLuint, bufsize: TGLsizei, length: TGLsizei, name: TGLchar) {.importc.} + proc glClipPlanex(plane: TGLenum, equation: TGLfixed) {.importc.} + proc glMultiTexCoord4iv(target: TGLenum, v: TGLint) {.importc.} + proc glTransformFeedbackVaryingsEXT(program: TGLuint, count: TGLsizei, varyings: ptr TGLchar, bufferMode: TGLenum) {.importc.} + proc glBlendEquationSeparateiARB(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} + proc glVertex2sv(v: TGLshort) {.importc.} + proc glAccumxOES(op: TGLenum, value: TGLfixed) {.importc.} + proc glProgramLocalParameter4dARB(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glIsRenderbufferEXT(renderbuffer: TGLuint): TGLboolean {.importc.} + proc glMultiDrawElementsIndirectAMD(mode: TGLenum, `type`: TGLenum, indirect: pointer, primcount: TGLsizei, stride: TGLsizei) {.importc.} + proc glVertexAttribI4uiEXT(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} + proc glVertex4fv(v: TGLfloat) {.importc.} + proc glGenerateMipmapEXT(target: TGLenum) {.importc.} + proc glVertexP3ui(`type`: TGLenum, value: TGLuint) {.importc.} + proc glTexCoord2dv(v: TGLdouble) {.importc.} + proc glFlushMappedBufferRange(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr) {.importc.} + proc glTrackMatrixNV(target: TGLenum, address: TGLuint, matrix: TGLenum, transform: TGLenum) {.importc.} + proc glFragmentLightModeliSGIX(pname: TGLenum, param: TGLint) {.importc.} + proc glVertexAttrib4Nusv(index: TGLuint, v: TGLushort) {.importc.} + proc glScalef(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glLightxvOES(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glTextureParameterivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glCompressedMultiTexImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glVertexAttribL1d(index: TGLuint, x: TGLdouble) {.importc.} + proc glVertexAttrib3fARB(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glVertexAttrib3hvNV(index: TGLuint, v: TGLhalfNV) {.importc.} + proc glSpriteParameteriSGIX(pname: TGLenum, param: TGLint) {.importc.} + proc glFrustumxOES(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} + proc glGetnMapdvARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: TGLdouble) {.importc.} + proc glGetMinmaxEXT(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} + proc glProgramUniformHandleui64NV(program: TGLuint, location: TGLint, value: TGLuint64) {.importc.} + proc glWindowPos4fvMESA(v: TGLfloat) {.importc.} + proc glExtGetTexturesQCOM(textures: TGLuint, maxTextures: TGLint, numTextures: TGLint) {.importc.} + proc glProgramSubroutineParametersuivNV(target: TGLenum, count: TGLsizei, params: TGLuint) {.importc.} + proc glSampleCoveragexOES(value: TGLclampx, invert: TGLboolean) {.importc.} + proc glMultiTexEnvivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetFinalCombinerInputParameterfvNV(variable: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glLightModeliv(pname: TGLenum, params: TGLint) {.importc.} + proc glUniform4f(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} + proc glDepthRange(near: TGLdouble, far: TGLdouble) {.importc.} + proc glProgramUniformMatrix4x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glProgramUniform4fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glGetTexParameterIiv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexAttribs4dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} + proc glConvolutionParameteri(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexAttribI4uiv(index: TGLuint, v: TGLuint) {.importc.} + proc glEvalCoord1dv(u: TGLdouble) {.importc.} + proc glIsFramebuffer(framebuffer: TGLuint): TGLboolean {.importc.} + proc glEvalCoord2d(u: TGLdouble, v: TGLdouble) {.importc.} + proc glClearDepthf(d: TGLfloat) {.importc.} + proc glCompressedTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} + proc glProgramUniformMatrix3x2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glGetTexParameterxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glBinormal3fEXT(bx: TGLfloat, by: TGLfloat, bz: TGLfloat) {.importc.} + proc glProgramParameteriARB(program: TGLuint, pname: TGLenum, value: TGLint) {.importc.} + proc glWindowPos3ivMESA(v: TGLint) {.importc.} + proc glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc: TGLuint, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} + proc glPresentFrameDualFillNV(video_slot: TGLuint, minPresentTime: TGLuint64EXT, beginPresentTimeId: TGLuint, presentDurationId: TGLuint, `type`: TGLenum, target0: TGLenum, fill0: TGLuint, target1: TGLenum, fill1: TGLuint, target2: TGLenum, fill2: TGLuint, target3: TGLenum, fill3: TGLuint) {.importc.} + proc glIndexPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} + proc glVertexStream2dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble) {.importc.} + proc glUniformMatrix3x4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glMapNamedBufferRangeEXT(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc.} + proc glColor4sv(v: TGLshort) {.importc.} + proc glStencilFillPathNV(path: TGLuint, fillMode: TGLenum, mask: TGLuint) {.importc.} + proc glGetVertexAttribfvARB(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glWindowPos3dv(v: TGLdouble) {.importc.} + proc glHintPGI(target: TGLenum, mode: TGLint) {.importc.} + proc glVertexAttribs3hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc.} + proc glProgramUniform1i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT) {.importc.} + proc glReplacementCodeuiColor3fVertex3fSUN(rc: TGLuint, r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glUniform2iARB(location: TGLint, v0: TGLint, v1: TGLint) {.importc.} + proc glViewport(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glBlendFuncSeparateIndexedAMD(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} + proc glColor3us(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc.} + proc glVertexAttrib2hvNV(index: TGLuint, v: TGLhalfNV) {.importc.} + proc glGenerateMipmap(target: TGLenum) {.importc.} + proc glGetProgramEnvParameterIuivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glBlendEquationiARB(buf: TGLuint, mode: TGLenum) {.importc.} + proc glReadBufferNV(mode: TGLenum) {.importc.} + proc glProvokingVertexEXT(mode: TGLenum) {.importc.} + proc glPointParameterivNV(pname: TGLenum, params: TGLint) {.importc.} + proc glBlitFramebufferANGLE(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} + proc glGetObjectParameterivARB(obj: TGLhandleARB, pname: TGLenum, params: TGLint) {.importc.} + proc glGetSubroutineIndex(program: TGLuint, shadertype: TGLenum, name: TGLchar): TGLuint {.importc.} + proc glMap2d(target: TGLenum, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, points: TGLdouble) {.importc.} + proc glRectfv(v1: TGLfloat, v2: TGLfloat) {.importc.} + proc glDepthRangeArrayv(first: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} + proc glMultiTexParameteriEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} + proc glTexStorageSparseAMD(target: TGLenum, internalFormat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, layers: TGLsizei, flags: TGLbitfield) {.importc.} + proc glGenerateTextureMipmapEXT(texture: TGLuint, target: TGLenum) {.importc.} + proc glCopyConvolutionFilter1D(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} + proc glVertex4d(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glGetPathParameterfvNV(path: TGLuint, pname: TGLenum, value: TGLfloat) {.importc.} + proc glDetachShader(program: TGLuint, shader: TGLuint) {.importc.} + proc glGetColorTableSGI(target: TGLenum, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} + proc glPixelTransformParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glBufferSubDataARB(target: TGLenum, offset: TGLintptrARB, size: TGLsizeiptrARB, data: pointer) {.importc.} + proc glVertexAttrib4ubvNV(index: TGLuint, v: TGLubyte) {.importc.} + proc glCopyTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} + proc glGetQueryivARB(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glVertexAttribIPointerEXT(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glVertexAttribL3dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glGetQueryObjectui64vEXT(id: TGLuint, pname: TGLenum, params: TGLuint64) {.importc.} + proc glColor4x(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} + proc glProgramUniformMatrix3x2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glVertexAttribI4i(index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glVertexAttrib1f(index: TGLuint, x: TGLfloat) {.importc.} + proc glUnmapBufferOES(target: TGLenum): TGLboolean {.importc.} + proc glVertexStream2ivATI(stream: TGLenum, coords: TGLint) {.importc.} + proc glBeginOcclusionQueryNV(id: TGLuint) {.importc.} + proc glVertex4sv(v: TGLshort) {.importc.} + proc glEnablei(target: TGLenum, index: TGLuint) {.importc.} + proc glUseProgramObjectARB(programObj: TGLhandleARB) {.importc.} + proc glGetVertexAttribLdvEXT(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glUniform2d(location: TGLint, x: TGLdouble, y: TGLdouble) {.importc.} + proc glMinmaxEXT(target: TGLenum, internalformat: TGLenum, sink: TGLboolean) {.importc.} + proc glTexImage3D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glGenSymbolsEXT(datatype: TGLenum, storagetype: TGLenum, range: TGLenum, components: TGLuint): TGLuint {.importc.} + proc glVertexAttribI4svEXT(index: TGLuint, v: TGLshort) {.importc.} + proc glProgramEnvParameter4dvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} + proc glProgramUniformMatrix4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glGetSamplerParameterfv(sampler: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glPopClientAttrib() {.importc.} + proc glHistogram(target: TGLenum, width: TGLsizei, internalformat: TGLenum, sink: TGLboolean) {.importc.} + proc glTexEnvfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glMultiTexCoord1dvARB(target: TGLenum, v: TGLdouble) {.importc.} + proc glGetTexGenivOES(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glUniform1ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glTexCoord3fv(v: TGLfloat) {.importc.} + proc glVertex2xvOES(coords: TGLfixed) {.importc.} + proc glTexCoord4fVertex4fvSUN(tc: TGLfloat, v: TGLfloat) {.importc.} + proc glUniform2uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glMultiTexEnvfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetTextureParameterIivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glMemoryBarrierEXT(barriers: TGLbitfield) {.importc.} + proc glGetTexParameterPointervAPPLE(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} + proc glWindowPos2svARB(v: TGLshort) {.importc.} + proc glEndQuery(target: TGLenum) {.importc.} + proc glBlitFramebufferEXT(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} + proc glProgramEnvParametersI4uivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLuint) {.importc.} + proc glGetActiveUniform(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLchar) {.importc.} + proc glGenAsyncMarkersSGIX(range: TGLsizei): TGLuint {.importc.} + proc glClipControlARB(origin: TGLenum, depth: TGLenum) {.importc.} + proc glDrawElementsInstancedEXT(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} + proc glGetFragmentMaterialivSGIX(face: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glSwizzleEXT(res: TGLuint, `in`: TGLuint, outX: TGLenum, outY: TGLenum, outZ: TGLenum, outW: TGLenum) {.importc.} + proc glMultiTexCoord1bOES(texture: TGLenum, s: TGLbyte) {.importc.} + proc glProgramParameters4dvNV(target: TGLenum, index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} + proc glWindowPos2s(x: TGLshort, y: TGLshort) {.importc.} + proc glBlendFuncSeparatei(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} + proc glMultiModeDrawElementsIBM(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei, modestride: TGLint) {.importc.} + proc glNormal3x(nx: TGLfixed, ny: TGLfixed, nz: TGLfixed) {.importc.} + proc glProgramUniform1fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glTexCoord2hNV(s: TGLhalfNV, t: TGLhalfNV) {.importc.} + proc glViewportIndexedfv(index: TGLuint, v: TGLfloat) {.importc.} + proc glDrawTexxOES(x: TGLfixed, y: TGLfixed, z: TGLfixed, width: TGLfixed, height: TGLfixed) {.importc.} + proc glProgramParameter4dvNV(target: TGLenum, index: TGLuint, v: TGLdouble) {.importc.} + proc glDeleteBuffers(n: TGLsizei, buffers: TGLuint) {.importc.} + proc glGetVertexArrayIntegervEXT(vaobj: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glBindFragDataLocationEXT(program: TGLuint, color: TGLuint, name: TGLchar) {.importc.} + proc glGenProgramsNV(n: TGLsizei, programs: TGLuint) {.importc.} + proc glMultiTexCoord1i(target: TGLenum, s: TGLint) {.importc.} + proc glCompressedTexImage3DOES(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} + proc glGetQueryivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glExtGetBufferPointervQCOM(target: TGLenum, params: ptr pointer) {.importc.} + proc glVertex3iv(v: TGLint) {.importc.} + proc glVertexAttribL1dvEXT(index: TGLuint, v: TGLdouble) {.importc.} + proc glValidateProgramPipeline(pipeline: TGLuint) {.importc.} + proc glBindVertexArray(`array`: TGLuint) {.importc.} + proc glUniform2uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} + proc glUniform3i(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} + proc glGetVertexAttribIuiv(index: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glVertexArrayParameteriAPPLE(pname: TGLenum, param: TGLint) {.importc.} + proc glVertexAttribL2i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT) {.importc.} + proc glTexGenivOES(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glIsFramebufferOES(framebuffer: TGLuint): TGLboolean {.importc.} + proc glColor4ubv(v: TGLubyte) {.importc.} + proc glDeleteNamedStringARB(namelen: TGLint, name: TGLchar) {.importc.} + proc glCopyConvolutionFilter1DEXT(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} + proc glBufferStorage(target: TGLenum, size: TGLsizeiptr, data: pointer, flags: TGLbitfield) {.importc.} + proc glDrawTexiOES(x: TGLint, y: TGLint, z: TGLint, width: TGLint, height: TGLint) {.importc.} + proc glRasterPos3dv(v: TGLdouble) {.importc.} + proc glIndexMaterialEXT(face: TGLenum, mode: TGLenum) {.importc.} + proc glGetClipPlanex(plane: TGLenum, equation: TGLfixed) {.importc.} + proc glIsVertexArrayOES(`array`: TGLuint): TGLboolean {.importc.} + proc glColorTableEXT(target: TGLenum, internalFormat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} + proc glCompressedTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} + proc glLightx(light: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glGetTexParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexAttrib4NsvARB(index: TGLuint, v: TGLshort) {.importc.} + proc glInterleavedArrays(format: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glProgramLocalParameter4fARB(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glPopDebugGroupKHR() {.importc.} + proc glVDPAUUnregisterSurfaceNV(surface: TGLvdpauSurfaceNV) {.importc.} + proc glTexCoord1s(s: TGLshort) {.importc.} + proc glFramebufferTexture2DMultisampleIMG(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, samples: TGLsizei) {.importc.} + proc glShaderBinary(count: TGLsizei, shaders: TGLuint, binaryformat: TGLenum, binary: pointer, length: TGLsizei) {.importc.} + proc glVertexAttrib2dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glUniformMatrix4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glWeightivARB(size: TGLint, weights: TGLint) {.importc.} + proc glGetMultiTexParameterIivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glCopyConvolutionFilter2DEXT(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glSecondaryColor3hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV) {.importc.} + proc glVertexAttrib1sv(index: TGLuint, v: TGLshort) {.importc.} + proc glFrustumfOES(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} + proc glVertexStream2iATI(stream: TGLenum, x: TGLint, y: TGLint) {.importc.} + proc glNormalStream3bATI(stream: TGLenum, nx: TGLbyte, ny: TGLbyte, nz: TGLbyte) {.importc.} + proc glVertexArrayTexCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glGetQueryiv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glTransformFeedbackStreamAttribsNV(count: TGLsizei, attribs: TGLint, nbuffers: TGLsizei, bufstreams: TGLint, bufferMode: TGLenum) {.importc.} + proc glTextureStorage3DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} + proc glWindowPos3dvMESA(v: TGLdouble) {.importc.} + proc glUniform2uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glTextureStorage2DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glVertexArrayMultiTexCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, texunit: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} + proc glVertexStream1dvATI(stream: TGLenum, coords: TGLdouble) {.importc.} + proc glCopyImageSubData(srcName: TGLuint, srcTarget: TGLenum, srcLevel: TGLint, srcX: TGLint, srcY: TGLint, srcZ: TGLint, dstName: TGLuint, dstTarget: TGLenum, dstLevel: TGLint, dstX: TGLint, dstY: TGLint, dstZ: TGLint, srcWidth: TGLsizei, srcHeight: TGLsizei, srcDepth: TGLsizei) {.importc.} + proc glClearNamedBufferSubDataEXT(buffer: TGLuint, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, offset: TGLsizeiptr, size: TGLsizeiptr, data: pointer) {.importc.} + proc glBindBuffersRange(target: TGLenum, first: TGLuint, count: TGLsizei, buffers: TGLuint, offsets: TGLintptr, sizes: TGLsizeiptr) {.importc.} + proc glGetVertexAttribIuivEXT(index: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glLoadMatrixx(m: TGLfixed) {.importc.} + proc glTransformFeedbackVaryingsNV(program: TGLuint, count: TGLsizei, locations: TGLint, bufferMode: TGLenum) {.importc.} + proc glUniform1i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glVertexArrayVertexAttribLFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} + proc glClearBufferuiv(buffer: TGLenum, drawbuffer: TGLint, value: TGLuint) {.importc.} + proc glCombinerOutputNV(stage: TGLenum, portion: TGLenum, abOutput: TGLenum, cdOutput: TGLenum, sumOutput: TGLenum, scale: TGLenum, bias: TGLenum, abDotProduct: TGLboolean, cdDotProduct: TGLboolean, muxSum: TGLboolean) {.importc.} + proc glTexImage3DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glPixelTransformParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glActiveStencilFaceEXT(face: TGLenum) {.importc.} + proc glCreateShaderObjectARB(shaderType: TGLenum): TGLhandleARB {.importc.} + proc glGetTextureParameterivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glCopyTextureLevelsAPPLE(destinationTexture: TGLuint, sourceTexture: TGLuint, sourceBaseLevel: TGLint, sourceLevelCount: TGLsizei) {.importc.} + proc glVertexAttrib4Nuiv(index: TGLuint, v: TGLuint) {.importc.} + proc glDrawPixels(width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glWindowPos3dvARB(v: TGLdouble) {.importc.} + proc glProgramLocalParameterI4ivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc.} + proc glRasterPos4s(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} + proc glTexCoord2fVertex3fvSUN(tc: TGLfloat, v: TGLfloat) {.importc.} + proc glGetPathMetricsNV(metricQueryMask: TGLbitfield, numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, stride: TGLsizei, metrics: TGLfloat) {.importc.} + proc glMultiTexCoord4bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte, r: TGLbyte, q: TGLbyte) {.importc.} + proc glTextureBufferEXT(texture: TGLuint, target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} + proc glSecondaryColor3fv(v: TGLfloat) {.importc.} + proc glMultiTexCoord3fv(target: TGLenum, v: TGLfloat) {.importc.} + proc glGetTexParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glMap2xOES(target: TGLenum, u1: TGLfixed, u2: TGLfixed, ustride: TGLint, uorder: TGLint, v1: TGLfixed, v2: TGLfixed, vstride: TGLint, vorder: TGLint, points: TGLfixed) {.importc.} + proc glFlushVertexArrayRangeAPPLE(length: TGLsizei, `pointer`: pointer) {.importc.} + proc glActiveTextureARB(texture: TGLenum) {.importc.} + proc glGetVertexAttribLi64vNV(index: TGLuint, pname: TGLenum, params: TGLint64EXT) {.importc.} + proc glNormal3bv(v: TGLbyte) {.importc.} + proc glCreateSyncFromCLeventARB(context: TCL_context, event: TCL_context, flags: TGLbitfield): TGLsync {.importc.} + proc glRenderbufferStorageEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} + proc glGetCompressedTextureImageEXT(texture: TGLuint, target: TGLenum, lod: TGLint, img: pointer) {.importc.} + proc glColorFragmentOp2ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint) {.importc.} + proc glPixelMapusv(map: TGLenum, mapsize: TGLsizei, values: TGLushort) {.importc.} + proc glGlobalAlphaFactorsSUN(factor: TGLshort) {.importc.} + proc glTexParameterxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glEvalCoord2xOES(u: TGLfixed, v: TGLfixed) {.importc.} + proc glIsList(list: TGLuint): TGLboolean {.importc.} + proc glVertexAttrib3d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} + proc glSpriteParameterfSGIX(pname: TGLenum, param: TGLfloat) {.importc.} + proc glPathGlyphRangeNV(firstPathName: TGLuint, fontTarget: TGLenum, fontName: pointer, fontStyle: TGLbitfield, firstGlyph: TGLuint, numGlyphs: TGLsizei, handleMissingGlyphs: TGLenum, pathParameterTemplate: TGLuint, emScale: TGLfloat) {.importc.} + proc glUniform3iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glClearBufferfi(buffer: TGLenum, drawbuffer: TGLint, depth: TGLfloat, stencil: TGLint) {.importc.} + proc glWindowPos3sMESA(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} + proc glGetMapParameterfvNV(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glBindFragmentShaderATI(id: TGLuint) {.importc.} + proc glTexCoord4s(s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc.} + proc glGetMultiTexGenfvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glColorMaterial(face: TGLenum, mode: TGLenum) {.importc.} + proc glVertexAttribs1svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc.} + proc glEnableVertexAttribAPPLE(index: TGLuint, pname: TGLenum) {.importc.} + proc glGetDoubleIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLdouble) {.importc.} + proc glOrthof(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} + proc glVertexBlendEnvfATI(pname: TGLenum, param: TGLfloat) {.importc.} + proc glUniformMatrix2x4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glPrioritizeTexturesxOES(n: TGLsizei, textures: TGLuint, priorities: TGLfixed) {.importc.} + proc glGetTextureSamplerHandleNV(texture: TGLuint, sampler: TGLuint): TGLuint64 {.importc.} + proc glDeleteVertexArrays(n: TGLsizei, arrays: TGLuint) {.importc.} + proc glMultiTexCoord1xOES(texture: TGLenum, s: TGLfixed) {.importc.} + proc glGlobalAlphaFactorusSUN(factor: TGLushort) {.importc.} + proc glGetConvolutionParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glProgramUniform4fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} + proc glProgramUniformMatrix3x4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glBindVertexBuffer(bindingindex: TGLuint, buffer: TGLuint, offset: TGLintptr, stride: TGLsizei) {.importc.} + proc glGetHistogramParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetShaderPrecisionFormat(shadertype: TGLenum, precisiontype: TGLenum, range: TGLint, precision: TGLint) {.importc.} + proc glTextureMaterialEXT(face: TGLenum, mode: TGLenum) {.importc.} + proc glEvalCoord2xvOES(coords: TGLfixed) {.importc.} + proc glWeightuivARB(size: TGLint, weights: TGLuint) {.importc.} + proc glGetTextureLevelParameterfvEXT(texture: TGLuint, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexAttribP3uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} + proc glProgramEnvParameterI4ivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc.} + proc glFogi(pname: TGLenum, param: TGLint) {.importc.} + proc glTexCoord1iv(v: TGLint) {.importc.} + proc glReplacementCodeuiColor4ubVertex3fvSUN(rc: TGLuint, c: TGLubyte, v: TGLfloat) {.importc.} + proc glProgramUniform1ui(program: TGLuint, location: TGLint, v0: TGLuint) {.importc.} + proc glMultiTexCoord3d(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc.} + proc glBeginVideoCaptureNV(video_capture_slot: TGLuint) {.importc.} + proc glEvalCoord1f(u: TGLfloat) {.importc.} + proc glMultiTexCoord1hvNV(target: TGLenum, v: TGLhalfNV) {.importc.} + proc glSecondaryColor3sEXT(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc.} + proc glTextureImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glCopyTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} + proc glFinishFenceAPPLE(fence: TGLuint) {.importc.} + proc glVertexArrayRangeNV(length: TGLsizei, `pointer`: pointer) {.importc.} + proc glLightModelf(pname: TGLenum, param: TGLfloat) {.importc.} + proc glVertexAttribL1ui64ARB(index: TGLuint, x: TGLuint64EXT) {.importc.} + proc glPolygonOffset(factor: TGLfloat, units: TGLfloat) {.importc.} + proc glRasterPos4xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed, w: TGLfixed) {.importc.} + proc glVertexAttrib3dvNV(index: TGLuint, v: TGLdouble) {.importc.} + proc glBeginQuery(target: TGLenum, id: TGLuint) {.importc.} + proc glWeightfvARB(size: TGLint, weights: TGLfloat) {.importc.} + proc glGetUniformuiv(program: TGLuint, location: TGLint, params: TGLuint) {.importc.} + proc glIsTextureEXT(texture: TGLuint): TGLboolean {.importc.} + proc glGetClipPlanef(plane: TGLenum, equation: TGLfloat) {.importc.} + proc glTexGenxOES(coord: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glFramebufferTextureFaceEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc.} + proc glDisableClientState(`array`: TGLenum) {.importc.} + proc glTexPageCommitmentARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, resident: TGLboolean) {.importc.} + proc glRasterPos4dv(v: TGLdouble) {.importc.} + proc glGetLightx(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glVertexAttrib1hvNV(index: TGLuint, v: TGLhalfNV) {.importc.} + proc glMultiTexCoord2s(target: TGLenum, s: TGLshort, t: TGLshort) {.importc.} + proc glProgramUniform2iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glGetListParameterivSGIX(list: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glColorFragmentOp1ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint) {.importc.} + proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glSampleMapATI(dst: TGLuint, interp: TGLuint, swizzle: TGLenum) {.importc.} + proc glProgramUniform1d(program: TGLuint, location: TGLint, v0: TGLdouble) {.importc.} + proc glBindAttribLocation(program: TGLuint, index: TGLuint, name: TGLchar) {.importc.} + proc glGetCombinerStageParameterfvNV(stage: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTexSubImage4DSGIS(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, woffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, size4d: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} + proc glGetMapAttribParameterfvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glNewObjectBufferATI(size: TGLsizei, `pointer`: pointer, usage: TGLenum): TGLuint {.importc.} + proc glWindowPos4iMESA(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glNewList(list: TGLuint, mode: TGLenum) {.importc.} + proc glUniform1i64NV(location: TGLint, x: TGLint64EXT) {.importc.} + proc glTexCoordP3ui(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glEndQueryEXT(target: TGLenum) {.importc.} + proc glGetVertexAttribLdv(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glStencilMask(mask: TGLuint) {.importc.} + proc glVertexAttrib4sv(index: TGLuint, v: TGLshort) {.importc.} + proc glRectsv(v1: TGLshort, v2: TGLshort) {.importc.} + proc glGetVariantArrayObjectfvATI(id: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTexCoord3hvNV(v: TGLhalfNV) {.importc.} + proc glGetUniformdv(program: TGLuint, location: TGLint, params: TGLdouble) {.importc.} + proc glSecondaryColor3fvEXT(v: TGLfloat) {.importc.} + proc glAlphaFuncx(func: TGLenum, `ref`: TGLfixed) {.importc.} + proc glVertexAttribPointerNV(index: TGLuint, fsize: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glColorTable(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} + proc glProgramUniformMatrix2x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} {.pop.} # stdcall. const From 0706e88020857ee9c833abae0c31459f3a325bbb Mon Sep 17 00:00:00 2001 From: EXetoC Date: Tue, 15 Apr 2014 20:21:12 +0200 Subject: [PATCH 06/18] Change case for conditional symbol. --- lib/opengl.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/opengl.nim b/lib/opengl.nim index 6be77fd..693134a 100644 --- a/lib/opengl.nim +++ b/lib/opengl.nim @@ -207,7 +207,7 @@ proc checkGlError = raise exc -const NoGlAutoErrorCheck = defined(noglautoerrorcheck) +const NoGlAutoErrorCheck = defined(noGlAutoErrorCheck) var glAutoErrorCheck = true From 28cc673b7e22ba45ad4fcb3ef2ddea99ee639b16 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Tue, 15 Apr 2014 21:32:06 +0200 Subject: [PATCH 07/18] Export error code field. --- lib/opengl.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/opengl.nim b/lib/opengl.nim index 693134a..2494abd 100644 --- a/lib/opengl.nim +++ b/lib/opengl.nim @@ -188,7 +188,7 @@ proc getGlError*: TGlError = glGetError().TGlError type E_GL* = object of E_Base - code: TGlError + code*: TGlError proc checkGlError = let error = getGlError() From dfe2b612feac808efb33fb84863e0eae869cfefe Mon Sep 17 00:00:00 2001 From: EXetoC Date: Tue, 15 Apr 2014 21:45:24 +0200 Subject: [PATCH 08/18] Fix inline mistake; Disable unused hint. --- lib/opengl.nim | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/lib/opengl.nim b/lib/opengl.nim index 2494abd..5db5de5 100644 --- a/lib/opengl.nim +++ b/lib/opengl.nim @@ -225,9 +225,7 @@ macro wrapErrorChecking(f: stmt): stmt = glProc.pragma = newNimNode(nnkPragma).add( newNimNode(nnkExprColonExpr).add( ident"importc" , newLit($child.name)) - ).add( - ident"inline").add( - ident"ogl") + ).add(ident"ogl") glProc.name = ident($glProc.name & "Impl") var @@ -251,11 +249,12 @@ macro wrapErrorChecking(f: stmt): stmt = body.add getAst(errCheck()) var procc = newProc(child.name, params, body) + procc.pragma = newNimNode(nnkPragma).add(ident"inline") procc.name = postfix(procc.name, "*") result.add procc {.deadCodeElim: on.} -{.push stdcall.} +{.push stdcall, hint[XDeclaredButNotUsed]: off.} wrapErrorChecking: proc glMultiTexCoord2d(target: TGLenum, s: TGLdouble, t: TGLdouble) {.importc.} proc glDrawElementsIndirect(mode: TGLenum, `type`: TGLenum, indirect: pointer) {.importc.} @@ -3075,7 +3074,7 @@ wrapErrorChecking: proc glVertexAttribPointerNV(index: TGLuint, fsize: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glColorTable(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} proc glProgramUniformMatrix2x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} -{.pop.} # stdcall. +{.pop.} # stdcall, hint[XDeclaredButNotUsed]: off. const GL_2X_BIT_ATI* = 0x00000001 From 3f57135369d082f6fa96c7075cf65df23df27486 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Tue, 15 Apr 2014 23:53:53 +0200 Subject: [PATCH 09/18] Fix incorrect amount of pointer indirections. --- lib/opengl.nim | 2592 ++++++++++++++++++++++++------------------------ 1 file changed, 1296 insertions(+), 1296 deletions(-) diff --git a/lib/opengl.nim b/lib/opengl.nim index 5db5de5..be64930 100644 --- a/lib/opengl.nim +++ b/lib/opengl.nim @@ -259,53 +259,53 @@ wrapErrorChecking: proc glMultiTexCoord2d(target: TGLenum, s: TGLdouble, t: TGLdouble) {.importc.} proc glDrawElementsIndirect(mode: TGLenum, `type`: TGLenum, indirect: pointer) {.importc.} proc glEnableVertexArrayEXT(vaobj: TGLuint, `array`: TGLenum) {.importc.} - proc glDeleteFramebuffers(n: TGLsizei, framebuffers: TGLuint) {.importc.} - proc glMultiTexCoord3dv(target: TGLenum, v: TGLdouble) {.importc.} + proc glDeleteFramebuffers(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} + proc glMultiTexCoord3dv(target: TGLenum, v: ptr TGLdouble) {.importc.} proc glVertexAttrib4d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glLoadPaletteFromModelViewMatrixOES() {.importc.} - proc glVertex3xvOES(coords: TGLfixed) {.importc.} + proc glVertex3xvOES(coords: ptr TGLfixed) {.importc.} proc glNormalStream3sATI(stream: TGLenum, nx: TGLshort, ny: TGLshort, nz: TGLshort) {.importc.} proc glMatrixFrustumEXT(mode: TGLenum, left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} - proc glUniformMatrix2fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glColor4dv(v: TGLdouble) {.importc.} - proc glColor3fv(v: TGLfloat) {.importc.} + proc glUniformMatrix2fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glColor4dv(v: ptr TGLdouble) {.importc.} + proc glColor3fv(v: ptr TGLfloat) {.importc.} proc glVertexAttribI1uiEXT(index: TGLuint, x: TGLuint) {.importc.} - proc glGetDebugMessageLogKHR(count: TGLuint, bufsize: TGLsizei, sources: TGLenum, types: TGLenum, ids: TGLuint, severities: TGLenum, lengths: TGLsizei, messageLog: TGLchar): TGLuint {.importc.} - proc glVertexAttribI2iv(index: TGLuint, v: TGLint) {.importc.} - proc glTexCoord1xvOES(coords: TGLfixed) {.importc.} + proc glGetDebugMessageLogKHR(count: TGLuint, bufsize: TGLsizei, sources: ptr TGLenum, types: ptr TGLenum, ids: ptr TGLuint, severities: ptr TGLenum, lengths: ptr TGLsizei, messageLog: ptr TGLchar): TGLuint {.importc.} + proc glVertexAttribI2iv(index: TGLuint, v: ptr TGLint) {.importc.} + proc glTexCoord1xvOES(coords: ptr TGLfixed) {.importc.} proc glVertex3hNV(x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV) {.importc.} proc glIsShader(shader: TGLuint): TGLboolean {.importc.} - proc glDeleteRenderbuffersEXT(n: TGLsizei, renderbuffers: TGLuint) {.importc.} - proc glVertex3hvNV(v: TGLhalfNV) {.importc.} + proc glDeleteRenderbuffersEXT(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} + proc glVertex3hvNV(v: ptr TGLhalfNV) {.importc.} proc glGetPointervKHR(pname: TGLenum, params: ptr pointer) {.importc.} - proc glProgramUniform3i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glProgramUniform3i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} proc glNamedFramebufferTexture1DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glGetNamedProgramLocalParameterfvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} - proc glGenRenderbuffersOES(n: TGLsizei, renderbuffers: TGLuint) {.importc.} - proc glVertex4dv(v: TGLdouble) {.importc.} - proc glTexCoord2fColor4ubVertex3fvSUN(tc: TGLfloat, c: TGLubyte, v: TGLfloat) {.importc.} + proc glGetNamedProgramLocalParameterfvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} + proc glGenRenderbuffersOES(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} + proc glVertex4dv(v: ptr TGLdouble) {.importc.} + proc glTexCoord2fColor4ubVertex3fvSUN(tc: ptr TGLfloat, c: ptr TGLubyte, v: ptr TGLfloat) {.importc.} proc glTexStorage2DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glVertexAttrib2d(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} - proc glVertexAttrib1dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glVertexAttrib1dv(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glBindProgramARB(target: TGLenum, program: TGLuint) {.importc.} - proc glRasterPos2dv(v: TGLdouble) {.importc.} + proc glRasterPos2dv(v: ptr TGLdouble) {.importc.} proc glCompressedTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} proc glNormalPointervINTEL(`type`: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glGetInteger64vAPPLE(pname: TGLenum, params: TGLint64) {.importc.} + proc glGetInteger64vAPPLE(pname: TGLenum, params: ptr TGLint64) {.importc.} proc glPushMatrix() {.importc.} proc glGetCompressedTexImageARB(target: TGLenum, level: TGLint, img: pointer) {.importc.} proc glBindMaterialParameterEXT(face: TGLenum, value: TGLenum): TGLuint {.importc.} proc glBlendEquationIndexedAMD(buf: TGLuint, mode: TGLenum) {.importc.} - proc glGetObjectBufferfvATI(buffer: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetObjectBufferfvATI(buffer: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glMakeNamedBufferNonResidentNV(buffer: TGLuint) {.importc.} proc glUniform2ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc.} - proc glRasterPos4fv(v: TGLfloat) {.importc.} - proc glDeleteTextures(n: TGLsizei, textures: TGLuint) {.importc.} + proc glRasterPos4fv(v: ptr TGLfloat) {.importc.} + proc glDeleteTextures(n: TGLsizei, textures: ptr TGLuint) {.importc.} proc glSecondaryColorPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glEndTilingQCOM(preserveMask: TGLbitfield) {.importc.} proc glBindBuffer(target: TGLenum, buffer: TGLuint) {.importc.} - proc glUniformMatrix3fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glUniformMatrix3fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glSamplerParameterf(sampler: TGLuint, pname: TGLenum, param: TGLfloat) {.importc.} proc glSecondaryColor3d(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc.} proc glVertexAttrib4sARB(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} @@ -314,194 +314,194 @@ wrapErrorChecking: proc glPopAttrib() {.importc.} proc glGetnColorTableARB(target: TGLenum, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, table: pointer) {.importc.} proc glMatrixLoadIdentityEXT(mode: TGLenum) {.importc.} - proc glGetNamedProgramivEXT(program: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetNamedProgramivEXT(program: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glCopyTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} proc glUniform4i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc.} - proc glDeleteTexturesEXT(n: TGLsizei, textures: TGLuint) {.importc.} - proc glMultiTexCoord1dv(target: TGLenum, v: TGLdouble) {.importc.} + proc glDeleteTexturesEXT(n: TGLsizei, textures: ptr TGLuint) {.importc.} + proc glMultiTexCoord1dv(target: TGLenum, v: ptr TGLdouble) {.importc.} proc glMultiTexRenderbufferEXT(texunit: TGLenum, target: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glMultiDrawArraysIndirect(mode: TGLenum, indirect: pointer, drawcount: TGLsizei, stride: TGLsizei) {.importc.} - proc glGetUniformfvARB(programObj: TGLhandleARB, location: TGLint, params: TGLfloat) {.importc.} + proc glMultiDrawArraysIndirect(mode: TGLenum, indirect: ptr pointer, drawcount: TGLsizei, stride: TGLsizei) {.importc.} + proc glGetUniformfvARB(programObj: TGLhandleARB, location: TGLint, params: ptr TGLfloat) {.importc.} proc glBufferDataARB(target: TGLenum, size: TGLsizeiptrARB, data: pointer, usage: TGLenum) {.importc.} proc glTexCoord2d(s: TGLdouble, t: TGLdouble) {.importc.} - proc glGetArrayObjectfvATI(`array`: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetArrayObjectfvATI(`array`: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glShaderOp1EXT(op: TGLenum, res: TGLuint, arg1: TGLuint) {.importc.} proc glColor3s(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc.} proc glStencilFuncSeparate(face: TGLenum, func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} proc glTextureImage2DMultisampleCoverageNV(texture: TGLuint, target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} - proc glMultiTexCoord2xvOES(texture: TGLenum, coords: TGLfixed) {.importc.} - proc glGetVertexAttribLui64vNV(index: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc.} + proc glMultiTexCoord2xvOES(texture: TGLenum, coords: ptr TGLfixed) {.importc.} + proc glGetVertexAttribLui64vNV(index: TGLuint, pname: TGLenum, params: ptr TGLuint64EXT) {.importc.} proc glNormal3xOES(nx: TGLfixed, ny: TGLfixed, nz: TGLfixed) {.importc.} proc glMapBufferRangeEXT(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc.} proc glCreateShader(`type`: TGLenum): TGLuint {.importc.} proc glDrawRangeElementArrayAPPLE(mode: TGLenum, start: TGLuint, `end`: TGLuint, first: TGLint, count: TGLsizei) {.importc.} proc glVertex2bOES(x: TGLbyte) {.importc.} - proc glGetMapxvOES(target: TGLenum, query: TGLenum, v: TGLfixed) {.importc.} - proc glRasterPos3sv(v: TGLshort) {.importc.} - proc glDeleteQueriesARB(n: TGLsizei, ids: TGLuint) {.importc.} - proc glProgramUniform1iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} - proc glVertexStream2dvATI(stream: TGLenum, coords: TGLdouble) {.importc.} + proc glGetMapxvOES(target: TGLenum, query: TGLenum, v: ptr TGLfixed) {.importc.} + proc glRasterPos3sv(v: ptr TGLshort) {.importc.} + proc glDeleteQueriesARB(n: TGLsizei, ids: ptr TGLuint) {.importc.} + proc glProgramUniform1iv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} + proc glVertexStream2dvATI(stream: TGLenum, coords: ptr TGLdouble) {.importc.} proc glBindVertexArrayOES(`array`: TGLuint) {.importc.} - proc glLightModelfv(pname: TGLenum, params: TGLfloat) {.importc.} - proc glEvalCoord2dv(u: TGLdouble) {.importc.} + proc glLightModelfv(pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glEvalCoord2dv(u: ptr TGLdouble) {.importc.} proc glColor3hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV) {.importc.} proc glSecondaryColor3iEXT(red: TGLint, green: TGLint, blue: TGLint) {.importc.} proc glBindTexture(target: TGLenum, texture: TGLuint) {.importc.} proc glUniformBufferEXT(program: TGLuint, location: TGLint, buffer: TGLuint) {.importc.} - proc glGetCombinerInputParameterfvNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glUniform2ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} - proc glMatrixMultTransposefEXT(mode: TGLenum, m: TGLfloat) {.importc.} + proc glGetCombinerInputParameterfvNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glUniform2ui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} + proc glMatrixMultTransposefEXT(mode: TGLenum, m: ptr TGLfloat) {.importc.} proc glLineWidth(width: TGLfloat) {.importc.} proc glRotatef(angle: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glNormalStream3svATI(stream: TGLenum, coords: TGLshort) {.importc.} + proc glNormalStream3svATI(stream: TGLenum, coords: ptr TGLshort) {.importc.} proc glTexCoordP4ui(`type`: TGLenum, coords: TGLuint) {.importc.} - proc glImageTransformParameterfvHP(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glImageTransformParameterfvHP(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glUniform3uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} - proc glGetInvariantIntegervEXT(id: TGLuint, value: TGLenum, data: TGLint) {.importc.} - proc glGetTransformFeedbackVaryingEXT(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLsizei, `type`: TGLenum, name: TGLchar) {.importc.} - proc glSamplerParameterIuiv(sampler: TGLuint, pname: TGLenum, param: TGLuint) {.importc.} + proc glGetInvariantIntegervEXT(id: TGLuint, value: TGLenum, data: ptr TGLint) {.importc.} + proc glGetTransformFeedbackVaryingEXT(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, size: ptr TGLsizei, `type`: ptr TGLenum, name: ptr TGLchar) {.importc.} + proc glSamplerParameterIuiv(sampler: TGLuint, pname: TGLenum, param: ptr TGLuint) {.importc.} proc glProgramUniform2fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} - proc glMultiTexCoord2hvNV(target: TGLenum, v: TGLhalfNV) {.importc.} - proc glDeleteRenderbuffersOES(n: TGLsizei, renderbuffers: TGLuint) {.importc.} + proc glMultiTexCoord2hvNV(target: TGLenum, v: ptr TGLhalfNV) {.importc.} + proc glDeleteRenderbuffersOES(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} proc glRenderbufferStorageMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glStencilClearTagEXT(stencilTagBits: TGLsizei, stencilClearTag: TGLuint) {.importc.} - proc glConvolutionParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glConvolutionParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glFenceSyncAPPLE(condition: TGLenum, flags: TGLbitfield): TGLsync {.importc.} - proc glGetVariantArrayObjectivATI(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glProgramUniform4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} - proc glPushDebugGroupKHR(source: TGLenum, id: TGLuint, length: TGLsizei, message: TGLchar) {.importc.} - proc glFragmentLightivSGIX(light: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetVariantArrayObjectivATI(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glProgramUniform4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} + proc glPushDebugGroupKHR(source: TGLenum, id: TGLuint, length: TGLsizei, message: ptr TGLchar) {.importc.} + proc glFragmentLightivSGIX(light: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glFramebufferTexture2DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glGetActiveSubroutineUniformiv(program: TGLuint, shadertype: TGLenum, index: TGLuint, pname: TGLenum, values: TGLint) {.importc.} + proc glGetActiveSubroutineUniformiv(program: TGLuint, shadertype: TGLenum, index: TGLuint, pname: TGLenum, values: ptr TGLint) {.importc.} proc glFrustumf(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} proc glEndQueryIndexed(target: TGLenum, index: TGLuint) {.importc.} proc glCompressedTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glGetProgramPipelineInfoLogEXT(pipeline: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc.} - proc glGetVertexAttribfvNV(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetProgramPipelineInfoLogEXT(pipeline: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, infoLog: ptr TGLchar) {.importc.} + proc glGetVertexAttribfvNV(index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glVertexArrayIndexOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glDrawTexsvOES(coords: TGLshort) {.importc.} + proc glDrawTexsvOES(coords: ptr TGLshort) {.importc.} proc glMultiTexCoord1hNV(target: TGLenum, s: TGLhalfNV) {.importc.} - proc glWindowPos2iv(v: TGLint) {.importc.} + proc glWindowPos2iv(v: ptr TGLint) {.importc.} proc glMultiTexCoordP1ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} proc glTexCoord1i(s: TGLint) {.importc.} - proc glVertex4hvNV(v: TGLhalfNV) {.importc.} + proc glVertex4hvNV(v: ptr TGLhalfNV) {.importc.} proc glCallLists(n: TGLsizei, `type`: TGLenum, lists: pointer) {.importc.} proc glIndexFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc.} proc glPointParameterfARB(pname: TGLenum, param: TGLfloat) {.importc.} - proc glProgramUniform1dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} - proc glGetVertexAttribArrayObjectfvATI(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glVDPAUUnmapSurfacesNV(numSurface: TGLsizei, surfaces: TGLvdpauSurfaceNV) {.importc.} + proc glProgramUniform1dv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} + proc glGetVertexAttribArrayObjectfvATI(index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glVDPAUUnmapSurfacesNV(numSurface: TGLsizei, surfaces: ptr TGLvdpauSurfaceNV) {.importc.} proc glVertexAttribIFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} proc glClearColorx(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} - proc glColor3bv(v: TGLbyte) {.importc.} + proc glColor3bv(v: ptr TGLbyte) {.importc.} proc glNamedProgramLocalParameter4dEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glVertexPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glGetObjectLabelKHR(identifier: TGLenum, name: TGLuint, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc.} - proc glCombinerStageParameterfvNV(stage: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glNormal3hvNV(v: TGLhalfNV) {.importc.} + proc glGetObjectLabelKHR(identifier: TGLenum, name: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, label: ptr TGLchar) {.importc.} + proc glCombinerStageParameterfvNV(stage: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glNormal3hvNV(v: ptr TGLhalfNV) {.importc.} proc glUniform2i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT) {.importc.} - proc glMultiTexCoord2iv(target: TGLenum, v: TGLint) {.importc.} + proc glMultiTexCoord2iv(target: TGLenum, v: ptr TGLint) {.importc.} proc glProgramUniform3i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} proc glDeleteAsyncMarkersSGIX(marker: TGLuint, range: TGLsizei) {.importc.} proc glStencilOp(fail: TGLenum, zfail: TGLenum, zpass: TGLenum) {.importc.} proc glColorP4ui(`type`: TGLenum, color: TGLuint) {.importc.} - proc glFinishAsyncSGIX(markerp: TGLuint): TGLint {.importc.} + proc glFinishAsyncSGIX(markerp: ptr TGLuint): TGLint {.importc.} proc glDrawTexsOES(x: TGLshort, y: TGLshort, z: TGLshort, width: TGLshort, height: TGLshort) {.importc.} proc glLineStipple(factor: TGLint, pattern: TGLushort) {.importc.} proc glAlphaFragmentOp1ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint) {.importc.} - proc glMapTexture2DINTEL(texture: TGLuint, level: TGLint, access: TGLbitfield, stride: TGLint, layout: TGLenum) {.importc.} + proc glMapTexture2DINTEL(texture: TGLuint, level: TGLint, access: TGLbitfield, stride: ptr TGLint, layout: ptr TGLenum) {.importc.} proc glVertex4f(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} proc glFramebufferTextureARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} proc glProgramUniform3ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc.} - proc glMultTransposeMatrixxOES(m: TGLfixed) {.importc.} - proc glNormal3fv(v: TGLfloat) {.importc.} + proc glMultTransposeMatrixxOES(m: ptr TGLfixed) {.importc.} + proc glNormal3fv(v: ptr TGLfloat) {.importc.} proc glUniform4fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} proc glBinormal3bEXT(bx: TGLbyte, by: TGLbyte, bz: TGLbyte) {.importc.} - proc glGenProgramPipelinesEXT(n: TGLsizei, pipelines: TGLuint) {.importc.} + proc glGenProgramPipelinesEXT(n: TGLsizei, pipelines: ptr TGLuint) {.importc.} proc glDispatchComputeIndirect(indirect: TGLintptr) {.importc.} - proc glGetPerfMonitorCounterDataAMD(monitor: TGLuint, pname: TGLenum, dataSize: TGLsizei, data: TGLuint, bytesWritten: TGLint) {.importc.} + proc glGetPerfMonitorCounterDataAMD(monitor: TGLuint, pname: TGLenum, dataSize: TGLsizei, data: ptr TGLuint, bytesWritten: ptr TGLint) {.importc.} proc glStencilOpValueAMD(face: TGLenum, value: TGLuint) {.importc.} - proc glTangent3fvEXT(v: TGLfloat) {.importc.} + proc glTangent3fvEXT(v: ptr TGLfloat) {.importc.} proc glUniform3iARB(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} proc glMatrixScalefEXT(mode: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glVertexAttrib2dARB(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} proc glIsVertexArray(`array`: TGLuint): TGLboolean {.importc.} proc glGetMaterialx(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} proc glMultiTexCoord1dARB(target: TGLenum, s: TGLdouble) {.importc.} - proc glColor3usv(v: TGLushort) {.importc.} - proc glVertexStream3svATI(stream: TGLenum, coords: TGLshort) {.importc.} + proc glColor3usv(v: ptr TGLushort) {.importc.} + proc glVertexStream3svATI(stream: TGLenum, coords: ptr TGLshort) {.importc.} proc glRasterPos3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} proc glMultiTexCoord2bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte) {.importc.} - proc glGetClipPlanefOES(plane: TGLenum, equation: TGLfloat) {.importc.} + proc glGetClipPlanefOES(plane: TGLenum, equation: ptr TGLfloat) {.importc.} proc glFramebufferTextureEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} proc glVertexAttrib1dNV(index: TGLuint, x: TGLdouble) {.importc.} proc glSampleCoverageOES(value: TGLfixed, invert: TGLboolean) {.importc.} proc glCompressedTexSubImage2DARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} - proc glUniform1iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} - proc glExtGetProgramsQCOM(programs: TGLuint, maxPrograms: TGLint, numPrograms: TGLint) {.importc.} + proc glUniform1iv(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} + proc glExtGetProgramsQCOM(programs: ptr TGLuint, maxPrograms: TGLint, numPrograms: ptr TGLint) {.importc.} proc glFogx(pname: TGLenum, param: TGLfixed) {.importc.} proc glMultiTexCoord3hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV) {.importc.} - proc glClipPlane(plane: TGLenum, equation: TGLdouble) {.importc.} - proc glConvolutionParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glClipPlane(plane: TGLenum, equation: ptr TGLdouble) {.importc.} + proc glConvolutionParameterxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glInvalidateBufferData(buffer: TGLuint) {.importc.} proc glCheckNamedFramebufferStatusEXT(framebuffer: TGLuint, target: TGLenum): TGLenum {.importc.} proc glLinkProgram(program: TGLuint) {.importc.} proc glCheckFramebufferStatus(target: TGLenum): TGLenum {.importc.} proc glBlendFunci(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc.} - proc glProgramUniform4uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glProgramUniform4uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} proc glConvolutionFilter2D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} - proc glVertex4bvOES(coords: TGLbyte) {.importc.} + proc glVertex4bvOES(coords: ptr TGLbyte) {.importc.} proc glCopyTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glColor4uiv(v: TGLuint) {.importc.} - proc glGetBufferParameteri64v(target: TGLenum, pname: TGLenum, params: TGLint64) {.importc.} - proc glGetLocalConstantBooleanvEXT(id: TGLuint, value: TGLenum, data: TGLboolean) {.importc.} + proc glColor4uiv(v: ptr TGLuint) {.importc.} + proc glGetBufferParameteri64v(target: TGLenum, pname: TGLenum, params: ptr TGLint64) {.importc.} + proc glGetLocalConstantBooleanvEXT(id: TGLuint, value: TGLenum, data: ptr TGLboolean) {.importc.} proc glCoverStrokePathNV(path: TGLuint, coverMode: TGLenum) {.importc.} proc glScaled(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glLightfv(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glTexParameterIiv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glLightfv(light: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glTexParameterIiv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glMakeImageHandleResidentNV(handle: TGLuint64, access: TGLenum) {.importc.} proc glWindowPos3iARB(x: TGLint, y: TGLint, z: TGLint) {.importc.} proc glListBase(base: TGLuint) {.importc.} proc glFlushMappedBufferRangeEXT(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr) {.importc.} - proc glNormal3dv(v: TGLdouble) {.importc.} + proc glNormal3dv(v: ptr TGLdouble) {.importc.} proc glProgramUniform4d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble, v2: TGLdouble, v3: TGLdouble) {.importc.} - proc glCreateShaderProgramEXT(`type`: TGLenum, string: TGLchar): TGLuint {.importc.} - proc glGetLightxvOES(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glGetObjectPtrLabelKHR(`ptr`: pointer, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc.} - proc glTransformPathNV(resultPath: TGLuint, srcPath: TGLuint, transformType: TGLenum, transformValues: TGLfloat) {.importc.} - proc glMultTransposeMatrixf(m: TGLfloat) {.importc.} - proc glMapVertexAttrib2dAPPLE(index: TGLuint, size: TGLuint, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, points: TGLdouble) {.importc.} + proc glCreateShaderProgramEXT(`type`: TGLenum, string: ptr TGLchar): TGLuint {.importc.} + proc glGetLightxvOES(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glGetObjectPtrLabelKHR(`ptr`: ptr pointer, bufSize: TGLsizei, length: ptr TGLsizei, label: ptr TGLchar) {.importc.} + proc glTransformPathNV(resultPath: TGLuint, srcPath: TGLuint, transformType: TGLenum, transformValues: ptr TGLfloat) {.importc.} + proc glMultTransposeMatrixf(m: ptr TGLfloat) {.importc.} + proc glMapVertexAttrib2dAPPLE(index: TGLuint, size: TGLuint, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, points: ptr TGLdouble) {.importc.} proc glIsSync(sync: TGLsync): TGLboolean {.importc.} - proc glMultMatrixx(m: TGLfixed) {.importc.} + proc glMultMatrixx(m: ptr TGLfixed) {.importc.} proc glInterpolatePathsNV(resultPath: TGLuint, pathA: TGLuint, pathB: TGLuint, weight: TGLfloat) {.importc.} proc glEnableClientStateIndexedEXT(`array`: TGLenum, index: TGLuint) {.importc.} proc glProgramEnvParameter4fARB(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glVertexAttrib2svARB(index: TGLuint, v: TGLshort) {.importc.} + proc glVertexAttrib2svARB(index: TGLuint, v: ptr TGLshort) {.importc.} proc glLighti(light: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glSelectBuffer(size: TGLsizei, buffer: TGLuint) {.importc.} - proc glReplacementCodeusvSUN(code: TGLushort) {.importc.} - proc glMapVertexAttrib1fAPPLE(index: TGLuint, size: TGLuint, u1: TGLfloat, u2: TGLfloat, stride: TGLint, order: TGLint, points: TGLfloat) {.importc.} + proc glSelectBuffer(size: TGLsizei, buffer: ptr TGLuint) {.importc.} + proc glReplacementCodeusvSUN(code: ptr TGLushort) {.importc.} + proc glMapVertexAttrib1fAPPLE(index: TGLuint, size: TGLuint, u1: TGLfloat, u2: TGLfloat, stride: TGLint, order: TGLint, points: ptr TGLfloat) {.importc.} proc glMaterialx(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} proc glDrawTransformFeedback(mode: TGLenum, id: TGLuint) {.importc.} proc glWindowPos2i(x: TGLint, y: TGLint) {.importc.} proc glMultiTexEnviEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glProgramUniform1fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glDrawBuffersARB(n: TGLsizei, bufs: TGLenum) {.importc.} - proc glGetUniformLocationARB(programObj: TGLhandleARB, name: TGLcharARB): TGLint {.importc.} + proc glProgramUniform1fv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glDrawBuffersARB(n: TGLsizei, bufs: ptr TGLenum) {.importc.} + proc glGetUniformLocationARB(programObj: TGLhandleARB, name: ptr TGLcharARB): TGLint {.importc.} proc glResumeTransformFeedback() {.importc.} - proc glMap1f(target: TGLenum, u1: TGLfloat, u2: TGLfloat, stride: TGLint, order: TGLint, points: TGLfloat) {.importc.} + proc glMap1f(target: TGLenum, u1: TGLfloat, u2: TGLfloat, stride: TGLint, order: TGLint, points: ptr TGLfloat) {.importc.} proc glVertex3xOES(x: TGLfixed, y: TGLfixed) {.importc.} proc glPathCoordsNV(path: TGLuint, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} proc glListParameterfSGIX(list: TGLuint, pname: TGLenum, param: TGLfloat) {.importc.} - proc glGetUniformivARB(programObj: TGLhandleARB, location: TGLint, params: TGLint) {.importc.} - proc glBinormal3bvEXT(v: TGLbyte) {.importc.} + proc glGetUniformivARB(programObj: TGLhandleARB, location: TGLint, params: ptr TGLint) {.importc.} + proc glBinormal3bvEXT(v: ptr TGLbyte) {.importc.} proc glVertexAttribP3ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} proc glGetVertexArrayPointeri_vEXT(vaobj: TGLuint, index: TGLuint, pname: TGLenum, param: ptr pointer) {.importc.} - proc glProgramParameter4fvNV(target: TGLenum, index: TGLuint, v: TGLfloat) {.importc.} - proc glDiscardFramebufferEXT(target: TGLenum, numAttachments: TGLsizei, attachments: TGLenum) {.importc.} - proc glGetDebugMessageLogARB(count: TGLuint, bufsize: TGLsizei, sources: TGLenum, types: TGLenum, ids: TGLuint, severities: TGLenum, lengths: TGLsizei, messageLog: TGLchar): TGLuint {.importc.} + proc glProgramParameter4fvNV(target: TGLenum, index: TGLuint, v: ptr TGLfloat) {.importc.} + proc glDiscardFramebufferEXT(target: TGLenum, numAttachments: TGLsizei, attachments: ptr TGLenum) {.importc.} + proc glGetDebugMessageLogARB(count: TGLuint, bufsize: TGLsizei, sources: ptr TGLenum, types: ptr TGLenum, ids: ptr TGLuint, severities: ptr TGLenum, lengths: ptr TGLsizei, messageLog: ptr TGLchar): TGLuint {.importc.} proc glResolveMultisampleFramebufferAPPLE() {.importc.} - proc glGetIntegeri_vEXT(target: TGLenum, index: TGLuint, data: TGLint) {.importc.} + proc glGetIntegeri_vEXT(target: TGLenum, index: TGLuint, data: ptr TGLint) {.importc.} proc glDepthBoundsdNV(zmin: TGLdouble, zmax: TGLdouble) {.importc.} proc glEnd() {.importc.} proc glBindBufferBaseEXT(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc.} @@ -509,396 +509,396 @@ wrapErrorChecking: proc glFogCoorddEXT(coord: TGLdouble) {.importc.} proc glFrontFace(mode: TGLenum) {.importc.} proc glVertexAttrib1hNV(index: TGLuint, x: TGLhalfNV) {.importc.} - proc glNamedProgramLocalParametersI4uivEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLuint) {.importc.} - proc glTexCoord1dv(v: TGLdouble) {.importc.} + proc glNamedProgramLocalParametersI4uivEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLuint) {.importc.} + proc glTexCoord1dv(v: ptr TGLdouble) {.importc.} proc glBindVideoCaptureStreamTextureNV(video_capture_slot: TGLuint, stream: TGLuint, frame_region: TGLenum, target: TGLenum, texture: TGLuint) {.importc.} proc glWindowPos2iARB(x: TGLint, y: TGLint) {.importc.} proc glVertexAttribFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei) {.importc.} - proc glUniform1uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} - proc glGetVideoivNV(video_slot: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glVertexAttrib3fvARB(index: TGLuint, v: TGLfloat) {.importc.} + proc glUniform1uivEXT(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} + proc glGetVideoivNV(video_slot: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glVertexAttrib3fvARB(index: TGLuint, v: ptr TGLfloat) {.importc.} proc glVertexArraySecondaryColorOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glSecondaryColor3bv(v: TGLbyte) {.importc.} + proc glSecondaryColor3bv(v: ptr TGLbyte) {.importc.} proc glDispatchComputeGroupSizeARB(num_groups_x: TGLuint, num_groups_y: TGLuint, num_groups_z: TGLuint, group_size_x: TGLuint, group_size_y: TGLuint, group_size_z: TGLuint) {.importc.} proc glNamedCopyBufferSubDataEXT(readBuffer: TGLuint, writeBuffer: TGLuint, readOffset: TGLintptr, writeOffset: TGLintptr, size: TGLsizeiptr) {.importc.} proc glSampleCoverage(value: TGLfloat, invert: TGLboolean) {.importc.} - proc glGetnMapfvARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: TGLfloat) {.importc.} - proc glVertexStream2svATI(stream: TGLenum, coords: TGLshort) {.importc.} - proc glProgramParameters4fvNV(target: TGLenum, index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} + proc glGetnMapfvARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: ptr TGLfloat) {.importc.} + proc glVertexStream2svATI(stream: TGLenum, coords: ptr TGLshort) {.importc.} + proc glProgramParameters4fvNV(target: TGLenum, index: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} proc glVertexAttrib4fARB(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} proc glIndexd(c: TGLdouble) {.importc.} - proc glGetInteger64v(pname: TGLenum, params: TGLint64) {.importc.} + proc glGetInteger64v(pname: TGLenum, params: ptr TGLint64) {.importc.} proc glGetMultiTexImageEXT(texunit: TGLenum, target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glLightModelx(pname: TGLenum, param: TGLfixed) {.importc.} - proc glMap2f(target: TGLenum, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, points: TGLfloat) {.importc.} + proc glMap2f(target: TGLenum, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, points: ptr TGLfloat) {.importc.} proc glSecondaryColorPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} proc glVertexArrayVertexAttribIOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glProgramUniformHandleui64vARB(program: TGLuint, location: TGLint, count: TGLsizei, values: TGLuint64) {.importc.} + proc glProgramUniformHandleui64vARB(program: TGLuint, location: TGLint, count: TGLsizei, values: ptr TGLuint64) {.importc.} proc glActiveProgramEXT(program: TGLuint) {.importc.} - proc glProgramUniformMatrix4x3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glProgramUniformMatrix4x3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glCompressedTexSubImage3DARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} proc glBindProgramPipelineEXT(pipeline: TGLuint) {.importc.} - proc glDetailTexFuncSGIS(target: TGLenum, n: TGLsizei, points: TGLfloat) {.importc.} + proc glDetailTexFuncSGIS(target: TGLenum, n: TGLsizei, points: ptr TGLfloat) {.importc.} proc glSecondaryColor3ubEXT(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc.} proc glDrawArraysInstanced(mode: TGLenum, first: TGLint, count: TGLsizei, instancecount: TGLsizei) {.importc.} proc glWindowPos3fARB(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glNamedProgramLocalParameter4fEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glTextureParameterfvEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTextureParameterfvEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glProgramUniformHandleui64ARB(program: TGLuint, location: TGLint, value: TGLuint64) {.importc.} proc glHistogramEXT(target: TGLenum, width: TGLsizei, internalformat: TGLenum, sink: TGLboolean) {.importc.} proc glResumeTransformFeedbackNV() {.importc.} - proc glGetMaterialxv(face: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glMultiTexCoord1sv(target: TGLenum, v: TGLshort) {.importc.} + proc glGetMaterialxv(face: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glMultiTexCoord1sv(target: TGLenum, v: ptr TGLshort) {.importc.} proc glReadInstrumentsSGIX(marker: TGLint) {.importc.} proc glTexCoord4hNV(s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV, q: TGLhalfNV) {.importc.} - proc glVertexAttribL4i64vNV(index: TGLuint, v: TGLint64EXT) {.importc.} + proc glVertexAttribL4i64vNV(index: TGLuint, v: ptr TGLint64EXT) {.importc.} proc glEnableVariantClientStateEXT(id: TGLuint) {.importc.} proc glSyncTextureINTEL(texture: TGLuint) {.importc.} - proc glGetObjectPtrLabel(`ptr`: pointer, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc.} + proc glGetObjectPtrLabel(`ptr`: ptr pointer, bufSize: TGLsizei, length: ptr TGLsizei, label: ptr TGLchar) {.importc.} proc glCopyTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} proc glOrthofOES(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} proc glWindowPos3sARB(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} proc glIsBufferARB(buffer: TGLuint): TGLboolean {.importc.} - proc glColor3sv(v: TGLshort) {.importc.} + proc glColor3sv(v: ptr TGLshort) {.importc.} proc glEvalMesh1(mode: TGLenum, i1: TGLint, i2: TGLint) {.importc.} - proc glMultiDrawArrays(mode: TGLenum, first: TGLint, count: TGLsizei, drawcount: TGLsizei) {.importc.} - proc glGetMultiTexEnvfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glMultiDrawArrays(mode: TGLenum, first: ptr TGLint, count: ptr TGLsizei, drawcount: TGLsizei) {.importc.} + proc glGetMultiTexEnvfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glWindowPos3fMESA(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glExtGetFramebuffersQCOM(framebuffers: TGLuint, maxFramebuffers: TGLint, numFramebuffers: TGLint) {.importc.} + proc glExtGetFramebuffersQCOM(framebuffers: ptr TGLuint, maxFramebuffers: TGLint, numFramebuffers: ptr TGLint) {.importc.} proc glTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glVertexAttrib4uiv(index: TGLuint, v: TGLuint) {.importc.} + proc glVertexAttrib4uiv(index: TGLuint, v: ptr TGLuint) {.importc.} proc glProgramUniformui64NV(program: TGLuint, location: TGLint, value: TGLuint64EXT) {.importc.} - proc glMultiTexCoord2ivARB(target: TGLenum, v: TGLint) {.importc.} + proc glMultiTexCoord2ivARB(target: TGLenum, v: ptr TGLint) {.importc.} proc glProgramUniform4i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc.} - proc glWindowPos2svMESA(v: TGLshort) {.importc.} - proc glVertexAttrib3dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glWindowPos2svMESA(v: ptr TGLshort) {.importc.} + proc glVertexAttrib3dv(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glColor4i(red: TGLint, green: TGLint, blue: TGLint, alpha: TGLint) {.importc.} proc glClampColor(target: TGLenum, clamp: TGLenum) {.importc.} proc glVertexP2ui(`type`: TGLenum, value: TGLuint) {.importc.} - proc glGenQueries(n: TGLsizei, ids: TGLuint) {.importc.} + proc glGenQueries(n: TGLsizei, ids: ptr TGLuint) {.importc.} proc glBindBufferOffsetNV(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr) {.importc.} - proc glGetFragDataLocation(program: TGLuint, name: TGLchar): TGLint {.importc.} - proc glVertexAttribs2svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc.} + proc glGetFragDataLocation(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} + proc glVertexAttribs2svNV(index: TGLuint, count: TGLsizei, v: ptr TGLshort) {.importc.} proc glGetPathLengthNV(path: TGLuint, startSegment: TGLsizei, numSegments: TGLsizei): TGLfloat {.importc.} proc glVertexAttrib3dARB(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glMultiTexGenfvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glMultiTexGenfvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glFlushPixelDataRangeNV(target: TGLenum) {.importc.} proc glReplacementCodeuiNormal3fVertex3fSUN(rc: TGLuint, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glPathParameteriNV(path: TGLuint, pname: TGLenum, value: TGLint) {.importc.} proc glVertexAttribI2iEXT(index: TGLuint, x: TGLint, y: TGLint) {.importc.} proc glPixelStorei(pname: TGLenum, param: TGLint) {.importc.} - proc glGetNamedFramebufferParameterivEXT(framebuffer: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glGetTexEnvxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glGetNamedFramebufferParameterivEXT(framebuffer: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetTexEnvxv(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glPathStringNV(path: TGLuint, format: TGLenum, length: TGLsizei, pathString: pointer) {.importc.} proc glDepthMask(flag: TGLboolean) {.importc.} proc glCopyTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} proc glDepthRangexOES(n: TGLfixed, f: TGLfixed) {.importc.} - proc glUniform2i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} - proc glSetFragmentShaderConstantATI(dst: TGLuint, value: TGLfloat) {.importc.} + proc glUniform2i64vNV(location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} + proc glSetFragmentShaderConstantATI(dst: TGLuint, value: ptr TGLfloat) {.importc.} proc glAttachShader(program: TGLuint, shader: TGLuint) {.importc.} - proc glGetFramebufferParameterivEXT(framebuffer: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetFramebufferParameterivEXT(framebuffer: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glPointParameteriNV(pname: TGLenum, param: TGLint) {.importc.} proc glWindowPos2dMESA(x: TGLdouble, y: TGLdouble) {.importc.} - proc glGetTextureParameterfvEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glTexBumpParameterfvATI(pname: TGLenum, param: TGLfloat) {.importc.} + proc glGetTextureParameterfvEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glTexBumpParameterfvATI(pname: TGLenum, param: ptr TGLfloat) {.importc.} proc glCompressedTexImage1DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glGetTexGendv(coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc.} - proc glGetFragmentMaterialfvSGIX(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetTexGendv(coord: TGLenum, pname: TGLenum, params: ptr TGLdouble) {.importc.} + proc glGetFragmentMaterialfvSGIX(face: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glBeginConditionalRenderNVX(id: TGLuint) {.importc.} proc glLightModelxOES(pname: TGLenum, param: TGLfixed) {.importc.} proc glTexCoord2xOES(s: TGLfixed, t: TGLfixed) {.importc.} - proc glProgramUniformMatrix2x4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glRasterPos2xvOES(coords: TGLfixed) {.importc.} - proc glGetMapiv(target: TGLenum, query: TGLenum, v: TGLint) {.importc.} + proc glProgramUniformMatrix2x4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glRasterPos2xvOES(coords: ptr TGLfixed) {.importc.} + proc glGetMapiv(target: TGLenum, query: TGLenum, v: ptr TGLint) {.importc.} proc glGetImageHandleARB(texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, format: TGLenum): TGLuint64 {.importc.} - proc glVDPAURegisterVideoSurfaceNV(vdpSurface: pointer, target: TGLenum, numTextureNames: TGLsizei, textureNames: TGLuint): TGLvdpauSurfaceNV {.importc.} + proc glVDPAURegisterVideoSurfaceNV(vdpSurface: pointer, target: TGLenum, numTextureNames: TGLsizei, textureNames: ptr TGLuint): TGLvdpauSurfaceNV {.importc.} proc glVertexAttribL2dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} - proc glVertexAttrib1dvNV(index: TGLuint, v: TGLdouble) {.importc.} - proc glPollAsyncSGIX(markerp: TGLuint): TGLint {.importc.} - proc glCullParameterfvEXT(pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexAttrib1dvNV(index: TGLuint, v: ptr TGLdouble) {.importc.} + proc glPollAsyncSGIX(markerp: ptr TGLuint): TGLint {.importc.} + proc glCullParameterfvEXT(pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glMakeNamedBufferResidentNV(buffer: TGLuint, access: TGLenum) {.importc.} proc glPointParameterfSGIS(pname: TGLenum, param: TGLfloat) {.importc.} proc glGenLists(range: TGLsizei): TGLuint {.importc.} - proc glGetTexBumpParameterfvATI(pname: TGLenum, param: TGLfloat) {.importc.} + proc glGetTexBumpParameterfvATI(pname: TGLenum, param: ptr TGLfloat) {.importc.} proc glCompressedMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} proc glFinishFenceNV(fence: TGLuint) {.importc.} proc glPointSize(size: TGLfloat) {.importc.} proc glCompressedTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glGetUniformui64vNV(program: TGLuint, location: TGLint, params: TGLuint64EXT) {.importc.} + proc glGetUniformui64vNV(program: TGLuint, location: TGLint, params: ptr TGLuint64EXT) {.importc.} proc glGetMapControlPointsNV(target: TGLenum, index: TGLuint, `type`: TGLenum, ustride: TGLsizei, vstride: TGLsizei, packed: TGLboolean, points: pointer) {.importc.} - proc glGetPathColorGenfvNV(color: TGLenum, pname: TGLenum, value: TGLfloat) {.importc.} + proc glGetPathColorGenfvNV(color: TGLenum, pname: TGLenum, value: ptr TGLfloat) {.importc.} proc glTexCoord2f(s: TGLfloat, t: TGLfloat) {.importc.} proc glSampleMaski(index: TGLuint, mask: TGLbitfield) {.importc.} proc glReadBufferIndexedEXT(src: TGLenum, index: TGLint) {.importc.} proc glCoverFillPathNV(path: TGLuint, coverMode: TGLenum) {.importc.} - proc glColorTableParameterfvSGI(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glDeleteVertexArraysAPPLE(n: TGLsizei, arrays: TGLuint) {.importc.} - proc glGetVertexAttribIiv(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glWeightbvARB(size: TGLint, weights: TGLbyte) {.importc.} + proc glColorTableParameterfvSGI(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glDeleteVertexArraysAPPLE(n: TGLsizei, arrays: ptr TGLuint) {.importc.} + proc glGetVertexAttribIiv(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glWeightbvARB(size: TGLint, weights: ptr TGLbyte) {.importc.} proc glGetNamedBufferPointervEXT(buffer: TGLuint, pname: TGLenum, params: ptr pointer) {.importc.} proc glTexCoordPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glColor4fv(v: TGLfloat) {.importc.} - proc glGetnUniformfvARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLfloat) {.importc.} + proc glColor4fv(v: ptr TGLfloat) {.importc.} + proc glGetnUniformfvARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLfloat) {.importc.} proc glMaterialxOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glGetFixedv(pname: TGLenum, params: TGLfixed) {.importc.} + proc glGetFixedv(pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glMaterialf(face: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glVideoCaptureStreamParameterfvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glGetDebugMessageLogAMD(count: TGLuint, bufsize: TGLsizei, categories: TGLenum, severities: TGLuint, ids: TGLuint, lengths: TGLsizei, message: TGLchar): TGLuint {.importc.} - proc glProgramUniform2uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} - proc glMatrixMultTransposedEXT(mode: TGLenum, m: TGLdouble) {.importc.} + proc glVideoCaptureStreamParameterfvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glGetDebugMessageLogAMD(count: TGLuint, bufsize: TGLsizei, categories: ptr TGLenum, severities: ptr TGLuint, ids: ptr TGLuint, lengths: ptr TGLsizei, message: ptr TGLchar): TGLuint {.importc.} + proc glProgramUniform2uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} + proc glMatrixMultTransposedEXT(mode: TGLenum, m: ptr TGLdouble) {.importc.} proc glIsPointInStrokePathNV(path: TGLuint, x: TGLfloat, y: TGLfloat): TGLboolean {.importc.} proc glDisable(cap: TGLenum) {.importc.} proc glCompileShader(shader: TGLuint) {.importc.} - proc glLoadTransposeMatrixd(m: TGLdouble) {.importc.} - proc glGetMultiTexParameterIuivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glLoadTransposeMatrixd(m: ptr TGLdouble) {.importc.} + proc glGetMultiTexParameterIuivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} proc glGetHistogram(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} - proc glMultiTexCoord3fvARB(target: TGLenum, v: TGLfloat) {.importc.} - proc glColor4xvOES(components: TGLfixed) {.importc.} + proc glMultiTexCoord3fvARB(target: TGLenum, v: ptr TGLfloat) {.importc.} + proc glColor4xvOES(components: ptr TGLfixed) {.importc.} proc glIsBuffer(buffer: TGLuint): TGLboolean {.importc.} - proc glVertex2dv(v: TGLdouble) {.importc.} - proc glNamedProgramLocalParameterI4uivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glVertex2dv(v: ptr TGLdouble) {.importc.} + proc glNamedProgramLocalParameterI4uivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} proc glPixelTexGenParameteriSGIS(pname: TGLenum, param: TGLint) {.importc.} - proc glBindVertexBuffers(first: TGLuint, count: TGLsizei, buffers: TGLuint, offsets: TGLintptr, strides: TGLsizei) {.importc.} - proc glUniform1ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glBindVertexBuffers(first: TGLuint, count: TGLsizei, buffers: ptr TGLuint, offsets: ptr TGLintptr, strides: ptr TGLsizei) {.importc.} + proc glUniform1ui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} proc glColor4ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte, alpha: TGLubyte) {.importc.} - proc glConvolutionParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glConvolutionParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc: TGLuint, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glVertexAttribI2ui(index: TGLuint, x: TGLuint, y: TGLuint) {.importc.} - proc glDeleteNamesAMD(identifier: TGLenum, num: TGLuint, names: TGLuint) {.importc.} + proc glDeleteNamesAMD(identifier: TGLenum, num: TGLuint, names: ptr TGLuint) {.importc.} proc glPixelTransferxOES(pname: TGLenum, param: TGLfixed) {.importc.} - proc glVertexAttrib4ivARB(index: TGLuint, v: TGLint) {.importc.} + proc glVertexAttrib4ivARB(index: TGLuint, v: ptr TGLint) {.importc.} proc glLightModeli(pname: TGLenum, param: TGLint) {.importc.} proc glGetHistogramEXT(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} - proc glWindowPos3svMESA(v: TGLshort) {.importc.} - proc glRasterPos3iv(v: TGLint) {.importc.} + proc glWindowPos3svMESA(v: ptr TGLshort) {.importc.} + proc glRasterPos3iv(v: ptr TGLint) {.importc.} proc glCopyTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} proc glTextureStorage3DMultisampleEXT(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} proc glIsNameAMD(identifier: TGLenum, name: TGLuint): TGLboolean {.importc.} - proc glProgramUniformMatrix3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glGetProgramParameterfvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glProgramUniformMatrix3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glGetProgramParameterfvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glTexStorage3D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} proc glMultiTexCoord2xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed) {.importc.} proc glWindowPos2fARB(x: TGLfloat, y: TGLfloat) {.importc.} - proc glGetProgramResourceIndex(program: TGLuint, programInterface: TGLenum, name: TGLchar): TGLuint {.importc.} - proc glProgramUniform2uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glGetProgramResourceIndex(program: TGLuint, programInterface: TGLenum, name: ptr TGLchar): TGLuint {.importc.} + proc glProgramUniform2uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} proc glMakeImageHandleNonResidentNV(handle: TGLuint64) {.importc.} - proc glNamedProgramLocalParameter4fvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} - proc glInvalidateFramebuffer(target: TGLenum, numAttachments: TGLsizei, attachments: TGLenum) {.importc.} + proc glNamedProgramLocalParameter4fvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} + proc glInvalidateFramebuffer(target: TGLenum, numAttachments: TGLsizei, attachments: ptr TGLenum) {.importc.} proc glTexStorage3DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} - proc glMapVertexAttrib2fAPPLE(index: TGLuint, size: TGLuint, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, points: TGLfloat) {.importc.} + proc glMapVertexAttrib2fAPPLE(index: TGLuint, size: TGLuint, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, points: ptr TGLfloat) {.importc.} proc glCombinerParameterfNV(pname: TGLenum, param: TGLfloat) {.importc.} proc glCopyMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} proc glBindVertexShaderEXT(id: TGLuint) {.importc.} proc glPathGlyphsNV(firstPathName: TGLuint, fontTarget: TGLenum, fontName: pointer, fontStyle: TGLbitfield, numGlyphs: TGLsizei, `type`: TGLenum, charcodes: pointer, handleMissingGlyphs: TGLenum, pathParameterTemplate: TGLuint, emScale: TGLfloat) {.importc.} - proc glProgramLocalParametersI4uivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLuint) {.importc.} - proc glMultiTexCoord3hvNV(target: TGLenum, v: TGLhalfNV) {.importc.} - proc glMultiTexCoordP2uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} + proc glProgramLocalParametersI4uivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLuint) {.importc.} + proc glMultiTexCoord3hvNV(target: TGLenum, v: ptr TGLhalfNV) {.importc.} + proc glMultiTexCoordP2uiv(texture: TGLenum, `type`: TGLenum, coords: ptr TGLuint) {.importc.} proc glDisableVariantClientStateEXT(id: TGLuint) {.importc.} - proc glGetTexLevelParameterxvOES(target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfixed) {.importc.} - proc glRasterPos2sv(v: TGLshort) {.importc.} - proc glWeightPathsNV(resultPath: TGLuint, numPaths: TGLsizei, paths: TGLuint, weights: TGLfloat) {.importc.} - proc glDrawBuffersNV(n: TGLsizei, bufs: TGLenum) {.importc.} + proc glGetTexLevelParameterxvOES(target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glRasterPos2sv(v: ptr TGLshort) {.importc.} + proc glWeightPathsNV(resultPath: TGLuint, numPaths: TGLsizei, paths: ptr TGLuint, weights: ptr TGLfloat) {.importc.} + proc glDrawBuffersNV(n: TGLsizei, bufs: ptr TGLenum) {.importc.} proc glBindBufferARB(target: TGLenum, buffer: TGLuint) {.importc.} - proc glVariantbvEXT(id: TGLuint, `addr`: TGLbyte) {.importc.} - proc glColorP3uiv(`type`: TGLenum, color: TGLuint) {.importc.} + proc glVariantbvEXT(id: TGLuint, `addr`: ptr TGLbyte) {.importc.} + proc glColorP3uiv(`type`: TGLenum, color: ptr TGLuint) {.importc.} proc glBlendEquationEXT(mode: TGLenum) {.importc.} - proc glProgramLocalParameterI4uivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glProgramLocalParameterI4uivNV(target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} proc glRenderMode(mode: TGLenum): TGLint {.importc.} proc glVertexStream4fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glGetObjectLabelEXT(`type`: TGLenum, `object`: TGLuint, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc.} + proc glGetObjectLabelEXT(`type`: TGLenum, `object`: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, label: ptr TGLchar) {.importc.} proc glNamedFramebufferTexture3DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} - proc glLoadMatrixf(m: TGLfloat) {.importc.} - proc glGetQueryObjectuivEXT(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glLoadMatrixf(m: ptr TGLfloat) {.importc.} + proc glGetQueryObjectuivEXT(id: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} proc glBindVideoCaptureStreamBufferNV(video_capture_slot: TGLuint, stream: TGLuint, frame_region: TGLenum, offset: TGLintptrARB) {.importc.} proc glMatrixOrthoEXT(mode: TGLenum, left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} proc glBlendFunc(sfactor: TGLenum, dfactor: TGLenum) {.importc.} - proc glTexGenxvOES(coord: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glTexGenxvOES(coord: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glMatrixMode(mode: TGLenum) {.importc.} - proc glColorTableParameterivSGI(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGetProgramInfoLog(program: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc.} + proc glColorTableParameterivSGI(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetProgramInfoLog(program: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, infoLog: ptr TGLchar) {.importc.} proc glGetSeparableFilter(target: TGLenum, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer, span: pointer) {.importc.} - proc glFogfv(pname: TGLenum, params: TGLfloat) {.importc.} - proc glDrawTexfvOES(coords: TGLfloat) {.importc.} - proc glClipPlanexIMG(p: TGLenum, eqn: TGLfixed) {.importc.} + proc glFogfv(pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glDrawTexfvOES(coords: ptr TGLfloat) {.importc.} + proc glClipPlanexIMG(p: TGLenum, eqn: ptr TGLfixed) {.importc.} proc glResetHistogramEXT(target: TGLenum) {.importc.} proc glMemoryBarrier(barriers: TGLbitfield) {.importc.} - proc glGetPixelMapusv(map: TGLenum, values: TGLushort) {.importc.} + proc glGetPixelMapusv(map: TGLenum, values: ptr TGLushort) {.importc.} proc glEvalCoord2f(u: TGLfloat, v: TGLfloat) {.importc.} - proc glUniform4uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glUniform4uiv(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} proc glIsProgramARB(program: TGLuint): TGLboolean {.importc.} - proc glPointParameterfv(pname: TGLenum, params: TGLfloat) {.importc.} + proc glPointParameterfv(pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glTexBuffer(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} proc glVertexAttrib1s(index: TGLuint, x: TGLshort) {.importc.} proc glRenderbufferStorageMultisampleEXT(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glMapNamedBufferEXT(buffer: TGLuint, access: TGLenum) {.importc.} - proc glDebugMessageCallbackAMD(callback: TGLDEBUGPROCAMD, userParam: pointer) {.importc.} - proc glGetTexEnvfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glVertexAttribI3uivEXT(index: TGLuint, v: TGLuint) {.importc.} + proc glDebugMessageCallbackAMD(callback: TGLDEBUGPROCAMD, userParam: ptr pointer) {.importc.} + proc glGetTexEnvfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glVertexAttribI3uivEXT(index: TGLuint, v: ptr TGLuint) {.importc.} proc glMultiTexEnvfEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glGetUniformiv(program: TGLuint, location: TGLint, params: TGLint) {.importc.} - proc glProgramLocalParameters4fvEXT(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLfloat) {.importc.} - proc glStencilStrokePathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, reference: TGLint, mask: TGLuint, transformType: TGLenum, transformValues: TGLfloat) {.importc.} + proc glGetUniformiv(program: TGLuint, location: TGLint, params: ptr TGLint) {.importc.} + proc glProgramLocalParameters4fvEXT(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLfloat) {.importc.} + proc glStencilStrokePathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, reference: TGLint, mask: TGLuint, transformType: TGLenum, transformValues: ptr TGLfloat) {.importc.} proc glBeginConditionalRender(id: TGLuint, mode: TGLenum) {.importc.} proc glVertexAttribI3uiEXT(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint) {.importc.} - proc glVDPAUMapSurfacesNV(numSurfaces: TGLsizei, surfaces: TGLvdpauSurfaceNV) {.importc.} - proc glGetProgramResourceName(program: TGLuint, programInterface: TGLenum, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, name: TGLchar) {.importc.} + proc glVDPAUMapSurfacesNV(numSurfaces: TGLsizei, surfaces: ptr TGLvdpauSurfaceNV) {.importc.} + proc glGetProgramResourceName(program: TGLuint, programInterface: TGLenum, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, name: ptr TGLchar) {.importc.} proc glMultiTexCoord4f(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc.} proc glVertexAttrib2hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV) {.importc.} proc glDrawArraysInstancedNV(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} proc glClearAccum(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} - proc glVertexAttribI4usv(index: TGLuint, v: TGLushort) {.importc.} - proc glGetProgramNamedParameterfvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, params: TGLfloat) {.importc.} + proc glVertexAttribI4usv(index: TGLuint, v: ptr TGLushort) {.importc.} + proc glGetProgramNamedParameterfvNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, params: ptr TGLfloat) {.importc.} proc glTextureLightEXT(pname: TGLenum) {.importc.} proc glPathSubCoordsNV(path: TGLuint, coordStart: TGLsizei, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} proc glBindImageTexture(unit: TGLuint, texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, access: TGLenum, format: TGLenum) {.importc.} - proc glGenVertexArraysAPPLE(n: TGLsizei, arrays: TGLuint) {.importc.} + proc glGenVertexArraysAPPLE(n: TGLsizei, arrays: ptr TGLuint) {.importc.} proc glFogCoordf(coord: TGLfloat) {.importc.} proc glFrameTerminatorGREMEDY() {.importc.} proc glValidateProgramPipelineEXT(pipeline: TGLuint) {.importc.} proc glScalexOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glReplacementCodeuiColor3fVertex3fvSUN(rc: TGLuint, c: TGLfloat, v: TGLfloat) {.importc.} - proc glProgramNamedParameter4dNV(id: TGLuint, len: TGLsizei, name: TGLubyte, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glReplacementCodeuiColor3fVertex3fvSUN(rc: ptr TGLuint, c: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glProgramNamedParameter4dNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glMultiDrawElementsIndirectCountARB(mode: TGLenum, `type`: TGLenum, indirect: TGLintptr, drawcount: TGLintptr, maxdrawcount: TGLsizei, stride: TGLsizei) {.importc.} - proc glReferencePlaneSGIX(equation: TGLdouble) {.importc.} + proc glReferencePlaneSGIX(equation: ptr TGLdouble) {.importc.} proc glNormalStream3iATI(stream: TGLenum, nx: TGLint, ny: TGLint, nz: TGLint) {.importc.} - proc glGetColorTableParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glGetAttribLocation(program: TGLuint, name: TGLchar): TGLint {.importc.} + proc glGetColorTableParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glGetAttribLocation(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} proc glMultiTexParameterfEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glGenFencesNV(n: TGLsizei, fences: TGLuint) {.importc.} - proc glUniform4dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} - proc glGetTexLevelParameterfv(target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glProgramUniform1ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} - proc glProgramUniform1dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} - proc glLoadTransposeMatrixdARB(m: TGLdouble) {.importc.} - proc glVertexAttrib2fvARB(index: TGLuint, v: TGLfloat) {.importc.} + proc glGenFencesNV(n: TGLsizei, fences: ptr TGLuint) {.importc.} + proc glUniform4dv(location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} + proc glGetTexLevelParameterfv(target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glProgramUniform1ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} + proc glProgramUniform1dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} + proc glLoadTransposeMatrixdARB(m: ptr TGLdouble) {.importc.} + proc glVertexAttrib2fvARB(index: TGLuint, v: ptr TGLfloat) {.importc.} proc glMultiTexGendEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLdouble) {.importc.} - proc glProgramUniformMatrix4x3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glProgramUniformMatrix4x3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glUniform4ui(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} proc glTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glVertexAttrib3hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV) {.importc.} proc glRotatexOES(angle: TGLfixed, x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glGenTextures(n: TGLsizei, textures: TGLuint) {.importc.} + proc glGenTextures(n: TGLsizei, textures: ptr TGLuint) {.importc.} proc glCheckFramebufferStatusOES(target: TGLenum): TGLenum {.importc.} - proc glGetVideoCaptureStreamdvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glGetVideoCaptureStreamdvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} proc glCompressedTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} proc glCurrentPaletteMatrixOES(matrixpaletteindex: TGLuint) {.importc.} proc glCompressedMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} proc glNormal3d(nx: TGLdouble, ny: TGLdouble, nz: TGLdouble) {.importc.} - proc glMultiTexCoord1fv(target: TGLenum, v: TGLfloat) {.importc.} + proc glMultiTexCoord1fv(target: TGLenum, v: ptr TGLfloat) {.importc.} proc glProgramUniform2uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} proc glMultiTexCoord3fARB(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc.} proc glRasterPos3xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} proc glEGLImageTargetRenderbufferStorageOES(target: TGLenum, image: TGLeglImageOES) {.importc.} - proc glGetAttribLocationARB(programObj: TGLhandleARB, name: TGLcharARB): TGLint {.importc.} - proc glProgramNamedParameter4dvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, v: TGLdouble) {.importc.} + proc glGetAttribLocationARB(programObj: TGLhandleARB, name: ptr TGLcharARB): TGLint {.importc.} + proc glProgramNamedParameter4dvNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, v: ptr TGLdouble) {.importc.} proc glProgramLocalParameterI4uiNV(target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} proc glNamedFramebufferTextureFaceEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc.} proc glIndexf(c: TGLfloat) {.importc.} proc glExtTexObjectStateOverrideiQCOM(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} proc glCoverageOperationNV(operation: TGLenum) {.importc.} - proc glColorP4uiv(`type`: TGLenum, color: TGLuint) {.importc.} + proc glColorP4uiv(`type`: TGLenum, color: ptr TGLuint) {.importc.} proc glDeleteSync(sync: TGLsync) {.importc.} - proc glGetHistogramParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetHistogramParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glTexCoord4fColor4fNormal3fVertex4fSUN(s: TGLfloat, t: TGLfloat, p: TGLfloat, q: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} proc glEndPerfMonitorAMD(monitor: TGLuint) {.importc.} - proc glGetInternalformati64v(target: TGLenum, internalformat: TGLenum, pname: TGLenum, bufSize: TGLsizei, params: TGLint64) {.importc.} - proc glGenNamesAMD(identifier: TGLenum, num: TGLuint, names: TGLuint) {.importc.} - proc glDrawElementsInstancedBaseVertexBaseInstance(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei, basevertex: TGLint, baseinstance: TGLuint) {.importc.} + proc glGetInternalformati64v(target: TGLenum, internalformat: TGLenum, pname: TGLenum, bufSize: TGLsizei, params: ptr TGLint64) {.importc.} + proc glGenNamesAMD(identifier: TGLenum, num: TGLuint, names: ptr TGLuint) {.importc.} + proc glDrawElementsInstancedBaseVertexBaseInstance(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, instancecount: TGLsizei, basevertex: TGLint, baseinstance: TGLuint) {.importc.} proc glMultiTexCoord4i(target: TGLenum, s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc.} - proc glVertexAttribL1dv(index: TGLuint, v: TGLdouble) {.importc.} - proc glGetProgramNamedParameterdvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, params: TGLdouble) {.importc.} + proc glVertexAttribL1dv(index: TGLuint, v: ptr TGLdouble) {.importc.} + proc glGetProgramNamedParameterdvNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, params: ptr TGLdouble) {.importc.} proc glSetLocalConstantEXT(id: TGLuint, `type`: TGLenum, `addr`: pointer) {.importc.} proc glProgramBinary(program: TGLuint, binaryFormat: TGLenum, binary: pointer, length: TGLsizei) {.importc.} - proc glVideoCaptureNV(video_capture_slot: TGLuint, sequence_num: TGLuint, capture_time: TGLuint64EXT): TGLenum {.importc.} - proc glDebugMessageEnableAMD(category: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc.} + proc glVideoCaptureNV(video_capture_slot: TGLuint, sequence_num: ptr TGLuint, capture_time: ptr TGLuint64EXT): TGLenum {.importc.} + proc glDebugMessageEnableAMD(category: TGLenum, severity: TGLenum, count: TGLsizei, ids: ptr TGLuint, enabled: TGLboolean) {.importc.} proc glVertexAttribI1i(index: TGLuint, x: TGLint) {.importc.} proc glVertexWeighthNV(weight: TGLhalfNV) {.importc.} - proc glTextureParameterIivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glClipPlanefIMG(p: TGLenum, eqn: TGLfloat) {.importc.} - proc glGetLightxv(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glGetAttachedObjectsARB(containerObj: TGLhandleARB, maxCount: TGLsizei, count: TGLsizei, obj: TGLhandleARB) {.importc.} - proc glVertexAttrib4fv(index: TGLuint, v: TGLfloat) {.importc.} + proc glTextureParameterIivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glClipPlanefIMG(p: TGLenum, eqn: ptr TGLfloat) {.importc.} + proc glGetLightxv(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glGetAttachedObjectsARB(containerObj: TGLhandleARB, maxCount: TGLsizei, count: ptr TGLsizei, obj: ptr TGLhandleARB) {.importc.} + proc glVertexAttrib4fv(index: TGLuint, v: ptr TGLfloat) {.importc.} proc glDisableVertexAttribArrayARB(index: TGLuint) {.importc.} - proc glWindowPos3fvARB(v: TGLfloat) {.importc.} + proc glWindowPos3fvARB(v: ptr TGLfloat) {.importc.} proc glClearDepthdNV(depth: TGLdouble) {.importc.} - proc glMapParameterivNV(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glMapParameterivNV(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glEndConditionalRenderNVX() {.importc.} - proc glGetFragmentLightivSGIX(light: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glProgramUniformMatrix4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glGetFragmentLightivSGIX(light: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glProgramUniformMatrix4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glVertexStream1iATI(stream: TGLenum, x: TGLint) {.importc.} proc glColorP3ui(`type`: TGLenum, color: TGLuint) {.importc.} - proc glGetLightxOES(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glGetLightiv(light: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetLightxOES(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glGetLightiv(light: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glVertexStream3dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} proc glProgramUniform1iEXT(program: TGLuint, location: TGLint, v0: TGLint) {.importc.} proc glSecondaryColorFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} proc glDrawElementsBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, basevertex: TGLint) {.importc.} - proc glGenFencesAPPLE(n: TGLsizei, fences: TGLuint) {.importc.} - proc glBinormal3svEXT(v: TGLshort) {.importc.} + proc glGenFencesAPPLE(n: TGLsizei, fences: ptr TGLuint) {.importc.} + proc glBinormal3svEXT(v: ptr TGLshort) {.importc.} proc glUseProgramStagesEXT(pipeline: TGLuint, stages: TGLbitfield, program: TGLuint) {.importc.} - proc glDebugMessageCallbackKHR(callback: TGLDEBUGPROCKHR, userParam: pointer) {.importc.} + proc glDebugMessageCallbackKHR(callback: TGLDEBUGPROCKHR, userParam: ptr pointer) {.importc.} proc glCopyMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glColor4hvNV(v: TGLhalfNV) {.importc.} + proc glColor4hvNV(v: ptr TGLhalfNV) {.importc.} proc glFenceSync(condition: TGLenum, flags: TGLbitfield): TGLsync {.importc.} proc glTexCoordPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} proc glPopName() {.importc.} - proc glColor3fVertex3fvSUN(c: TGLfloat, v: TGLfloat) {.importc.} - proc glGetUniformfv(program: TGLuint, location: TGLint, params: TGLfloat) {.importc.} + proc glColor3fVertex3fvSUN(c: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glGetUniformfv(program: TGLuint, location: TGLint, params: ptr TGLfloat) {.importc.} proc glMultiTexCoord2hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV) {.importc.} - proc glLightxv(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glVideoCaptureStreamParameterivNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glEvalCoord1xvOES(coords: TGLfixed) {.importc.} - proc glGetProgramEnvParameterIivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc.} + proc glLightxv(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glVideoCaptureStreamParameterivNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glEvalCoord1xvOES(coords: ptr TGLfixed) {.importc.} + proc glGetProgramEnvParameterIivNV(target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} proc glObjectPurgeableAPPLE(objectType: TGLenum, name: TGLuint, option: TGLenum): TGLenum {.importc.} - proc glRequestResidentProgramsNV(n: TGLsizei, programs: TGLuint) {.importc.} + proc glRequestResidentProgramsNV(n: TGLsizei, programs: ptr TGLuint) {.importc.} proc glIsImageHandleResidentNV(handle: TGLuint64): TGLboolean {.importc.} - proc glColor3hvNV(v: TGLhalfNV) {.importc.} + proc glColor3hvNV(v: ptr TGLhalfNV) {.importc.} proc glMultiTexCoord2dARB(target: TGLenum, s: TGLdouble, t: TGLdouble) {.importc.} proc glDeletePathsNV(path: TGLuint, range: TGLsizei) {.importc.} - proc glVertexAttrib4Nsv(index: TGLuint, v: TGLshort) {.importc.} + proc glVertexAttrib4Nsv(index: TGLuint, v: ptr TGLshort) {.importc.} proc glTexEnvf(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} proc glGlobalAlphaFactoriSUN(factor: TGLint) {.importc.} proc glBlendColorEXT(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} - proc glSecondaryColor3usvEXT(v: TGLushort) {.importc.} + proc glSecondaryColor3usvEXT(v: ptr TGLushort) {.importc.} proc glProgramEnvParameterI4uiNV(target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} proc glTexImage4DSGIS(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, size4d: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glMatrixPushEXT(mode: TGLenum) {.importc.} - proc glGetPixelTexGenParameterivSGIS(pname: TGLenum, params: TGLint) {.importc.} - proc glVariantuivEXT(id: TGLuint, `addr`: TGLuint) {.importc.} - proc glTexParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glGetSubroutineUniformLocation(program: TGLuint, shadertype: TGLenum, name: TGLchar): TGLint {.importc.} - proc glProgramUniformMatrix3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glDrawBuffersATI(n: TGLsizei, bufs: TGLenum) {.importc.} - proc glGetVertexAttribivNV(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glMultiTexCoord4bvOES(texture: TGLenum, coords: TGLbyte) {.importc.} + proc glGetPixelTexGenParameterivSGIS(pname: TGLenum, params: ptr TGLint) {.importc.} + proc glVariantuivEXT(id: TGLuint, `addr`: ptr TGLuint) {.importc.} + proc glTexParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glGetSubroutineUniformLocation(program: TGLuint, shadertype: TGLenum, name: ptr TGLchar): TGLint {.importc.} + proc glProgramUniformMatrix3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glDrawBuffersATI(n: TGLsizei, bufs: ptr TGLenum) {.importc.} + proc glGetVertexAttribivNV(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glMultiTexCoord4bvOES(texture: TGLenum, coords: ptr TGLbyte) {.importc.} proc glCompressedTexSubImage1DARB(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} proc glClientActiveTexture(texture: TGLenum) {.importc.} proc glVertexAttrib2fARB(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc.} - proc glProgramUniform2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glGetBufferParameterui64vNV(target: TGLenum, pname: TGLenum, params: TGLuint64EXT) {.importc.} - proc glVertexStream3dvATI(stream: TGLenum, coords: TGLdouble) {.importc.} - proc glReplacementCodeuiNormal3fVertex3fvSUN(rc: TGLuint, n: TGLfloat, v: TGLfloat) {.importc.} - proc glVertexAttrib4svNV(index: TGLuint, v: TGLshort) {.importc.} - proc glClearBufferSubData(target: TGLenum, internalformat: TGLenum, offset: TGLintptr, size: TGLsizeiptr, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glProgramUniform2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glGetBufferParameterui64vNV(target: TGLenum, pname: TGLenum, params: ptr TGLuint64EXT) {.importc.} + proc glVertexStream3dvATI(stream: TGLenum, coords: ptr TGLdouble) {.importc.} + proc glReplacementCodeuiNormal3fVertex3fvSUN(rc: ptr TGLuint, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glVertexAttrib4svNV(index: TGLuint, v: ptr TGLshort) {.importc.} + proc glClearBufferSubData(target: TGLenum, internalformat: TGLenum, offset: TGLintptr, size: TGLsizeiptr, format: TGLenum, `type`: TGLenum, data: ptr pointer) {.importc.} proc glVertexStream2sATI(stream: TGLenum, x: TGLshort, y: TGLshort) {.importc.} proc glTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetListParameterfvSGIX(list: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glUniform3uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glGetListParameterfvSGIX(list: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glUniform3uiv(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} proc glIsTexture(texture: TGLuint): TGLboolean {.importc.} proc glObjectUnpurgeableAPPLE(objectType: TGLenum, name: TGLuint, option: TGLenum): TGLenum {.importc.} - proc glGetVertexAttribdv(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glGetVertexAttribdv(index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} proc glGetPointeri_vEXT(pname: TGLenum, index: TGLuint, params: ptr pointer) {.importc.} proc glSampleCoveragex(value: TGLclampx, invert: TGLboolean) {.importc.} proc glColor3f(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc.} - proc glGetnMapivARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: TGLint) {.importc.} + proc glGetnMapivARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: ptr TGLint) {.importc.} proc glMakeTextureHandleResidentARB(handle: TGLuint64) {.importc.} proc glSecondaryColorP3ui(`type`: TGLenum, color: TGLuint) {.importc.} proc glMultiTexCoord4sARB(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc.} proc glUniform3i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc.} - proc glVDPAUGetSurfaceivNV(surface: TGLvdpauSurfaceNV, pname: TGLenum, bufSize: TGLsizei, length: TGLsizei, values: TGLint) {.importc.} + proc glVDPAUGetSurfaceivNV(surface: TGLvdpauSurfaceNV, pname: TGLenum, bufSize: TGLsizei, length: ptr TGLsizei, values: ptr TGLint) {.importc.} proc glTexBufferEXT(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} - proc glVertexAttribI4ubvEXT(index: TGLuint, v: TGLubyte) {.importc.} - proc glDeleteFramebuffersOES(n: TGLsizei, framebuffers: TGLuint) {.importc.} + proc glVertexAttribI4ubvEXT(index: TGLuint, v: ptr TGLubyte) {.importc.} + proc glDeleteFramebuffersOES(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} proc glColor3fVertex3fSUN(r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glCombinerInputNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, input: TGLenum, mapping: TGLenum, componentUsage: TGLenum) {.importc.} proc glPolygonOffsetEXT(factor: TGLfloat, bias: TGLfloat) {.importc.} @@ -907,61 +907,61 @@ wrapErrorChecking: proc glTexCoord3f(s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc.} proc glMultiTexCoord1fARB(target: TGLenum, s: TGLfloat) {.importc.} proc glVertexAttrib4f(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glGetFragDataLocationEXT(program: TGLuint, name: TGLchar): TGLint {.importc.} + proc glGetFragDataLocationEXT(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} proc glFlushMappedNamedBufferRangeEXT(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr) {.importc.} proc glVertexAttrib1sARB(index: TGLuint, x: TGLshort) {.importc.} - proc glBitmapxOES(width: TGLsizei, height: TGLsizei, xorig: TGLfixed, yorig: TGLfixed, xmove: TGLfixed, ymove: TGLfixed, bitmap: TGLubyte) {.importc.} + proc glBitmapxOES(width: TGLsizei, height: TGLsizei, xorig: TGLfixed, yorig: TGLfixed, xmove: TGLfixed, ymove: TGLfixed, bitmap: ptr TGLubyte) {.importc.} proc glEnableVertexArrayAttribEXT(vaobj: TGLuint, index: TGLuint) {.importc.} - proc glDeleteRenderbuffers(n: TGLsizei, renderbuffers: TGLuint) {.importc.} + proc glDeleteRenderbuffers(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} proc glFramebufferRenderbuffer(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} proc glInvalidateTexImage(texture: TGLuint, level: TGLint) {.importc.} proc glProgramUniform2i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT) {.importc.} proc glTextureImage3DMultisampleNV(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} proc glValidateProgram(program: TGLuint) {.importc.} - proc glUniform1dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} - proc glNormalStream3dvATI(stream: TGLenum, coords: TGLdouble) {.importc.} - proc glMultiDrawElementsIndirect(mode: TGLenum, `type`: TGLenum, indirect: pointer, drawcount: TGLsizei, stride: TGLsizei) {.importc.} + proc glUniform1dv(location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} + proc glNormalStream3dvATI(stream: TGLenum, coords: ptr TGLdouble) {.importc.} + proc glMultiDrawElementsIndirect(mode: TGLenum, `type`: TGLenum, indirect: ptr pointer, drawcount: TGLsizei, stride: TGLsizei) {.importc.} proc glVertexBlendARB(count: TGLint) {.importc.} proc glIsSampler(sampler: TGLuint): TGLboolean {.importc.} - proc glVariantdvEXT(id: TGLuint, `addr`: TGLdouble) {.importc.} - proc glProgramUniformMatrix3x2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glVertexStream4fvATI(stream: TGLenum, coords: TGLfloat) {.importc.} + proc glVariantdvEXT(id: TGLuint, `addr`: ptr TGLdouble) {.importc.} + proc glProgramUniformMatrix3x2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glVertexStream4fvATI(stream: TGLenum, coords: ptr TGLfloat) {.importc.} proc glOrthoxOES(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} proc glColorFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} proc glFogCoordPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glVertexAttrib3dvARB(index: TGLuint, v: TGLdouble) {.importc.} + proc glVertexAttrib3dvARB(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glVertex3bOES(x: TGLbyte, y: TGLbyte) {.importc.} proc glVertexAttribFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, relativeoffset: TGLuint) {.importc.} proc glTexCoord4fVertex4fSUN(s: TGLfloat, t: TGLfloat, p: TGLfloat, q: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} proc glEnableDriverControlQCOM(driverControl: TGLuint) {.importc.} proc glPointParameteri(pname: TGLenum, param: TGLint) {.importc.} proc glVertexAttribI2i(index: TGLuint, x: TGLint, y: TGLint) {.importc.} - proc glGetDriverControlStringQCOM(driverControl: TGLuint, bufSize: TGLsizei, length: TGLsizei, driverControlString: TGLchar) {.importc.} - proc glGetTexLevelParameteriv(target: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetDriverControlStringQCOM(driverControl: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, driverControlString: ptr TGLchar) {.importc.} + proc glGetTexLevelParameteriv(target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glGetHandleARB(pname: TGLenum): TGLhandleARB {.importc.} - proc glIndexubv(c: TGLubyte) {.importc.} + proc glIndexubv(c: ptr TGLubyte) {.importc.} proc glBlendFunciARB(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc.} - proc glColor4usv(v: TGLushort) {.importc.} + proc glColor4usv(v: ptr TGLushort) {.importc.} proc glBlendEquationSeparateOES(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} proc glVertexAttribI4ui(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} proc glProgramUniform3f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} - proc glVertexAttribL3i64vNV(index: TGLuint, v: TGLint64EXT) {.importc.} - proc glWeightdvARB(size: TGLint, weights: TGLdouble) {.importc.} + proc glVertexAttribL3i64vNV(index: TGLuint, v: ptr TGLint64EXT) {.importc.} + proc glWeightdvARB(size: TGLint, weights: ptr TGLdouble) {.importc.} proc glVertexArrayRangeAPPLE(length: TGLsizei, `pointer`: pointer) {.importc.} proc glMapGrid2d(un: TGLint, u1: TGLdouble, u2: TGLdouble, vn: TGLint, v1: TGLdouble, v2: TGLdouble) {.importc.} - proc glFogiv(pname: TGLenum, params: TGLint) {.importc.} + proc glFogiv(pname: TGLenum, params: ptr TGLint) {.importc.} proc glUniform2f(location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} - proc glGetDoublei_v(target: TGLenum, index: TGLuint, data: TGLdouble) {.importc.} - proc glGetVertexAttribfv(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glVertexAttribI2ivEXT(index: TGLuint, v: TGLint) {.importc.} + proc glGetDoublei_v(target: TGLenum, index: TGLuint, data: ptr TGLdouble) {.importc.} + proc glGetVertexAttribfv(index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glVertexAttribI2ivEXT(index: TGLuint, v: ptr TGLint) {.importc.} proc glIsProgramNV(id: TGLuint): TGLboolean {.importc.} proc glTexCoord1hNV(s: TGLhalfNV) {.importc.} proc glMinSampleShadingARB(value: TGLfloat) {.importc.} - proc glMultiDrawElements(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, drawcount: TGLsizei) {.importc.} - proc glGetQueryObjectuiv(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glMultiDrawElements(mode: TGLenum, count: ptr TGLsizei, `type`: TGLenum, indices: ptr pointer, drawcount: TGLsizei) {.importc.} + proc glGetQueryObjectuiv(id: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} proc glReadBuffer(mode: TGLenum) {.importc.} - proc glMultiTexCoordP3uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} - proc glUniformMatrix3x2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glMultiTexCoordP3uiv(texture: TGLenum, `type`: TGLenum, coords: ptr TGLuint) {.importc.} + proc glUniformMatrix3x2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glBindRenderbuffer(target: TGLenum, renderbuffer: TGLuint) {.importc.} proc glBinormal3sEXT(bx: TGLshort, by: TGLshort, bz: TGLshort) {.importc.} proc glUniform4iARB(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} @@ -969,392 +969,392 @@ wrapErrorChecking: proc glDeleteLists(list: TGLuint, range: TGLsizei) {.importc.} proc glVertexAttribI1iEXT(index: TGLuint, x: TGLint) {.importc.} proc glFramebufferTexture1D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glVertexAttribI2uiv(index: TGLuint, v: TGLuint) {.importc.} - proc glBindFragDataLocation(program: TGLuint, color: TGLuint, name: TGLchar) {.importc.} + proc glVertexAttribI2uiv(index: TGLuint, v: ptr TGLuint) {.importc.} + proc glBindFragDataLocation(program: TGLuint, color: TGLuint, name: ptr TGLchar) {.importc.} proc glClearStencil(s: TGLint) {.importc.} - proc glVertexAttrib4Nubv(index: TGLuint, v: TGLubyte) {.importc.} + proc glVertexAttrib4Nubv(index: TGLuint, v: ptr TGLubyte) {.importc.} proc glConvolutionFilter2DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} - proc glGenFramebuffersEXT(n: TGLsizei, framebuffers: TGLuint) {.importc.} - proc glFogCoordfvEXT(coord: TGLfloat) {.importc.} - proc glGetRenderbufferParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glVertexAttribs1fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} + proc glGenFramebuffersEXT(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} + proc glFogCoordfvEXT(coord: ptr TGLfloat) {.importc.} + proc glGetRenderbufferParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glVertexAttribs1fvNV(index: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} proc glTexCoord2fColor3fVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glRasterPos3i(x: TGLint, y: TGLint, z: TGLint) {.importc.} proc glMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glConvolutionParameteriEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} proc glVertexAttribI4iEXT(index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} - proc glVertexAttribL2i64vNV(index: TGLuint, v: TGLint64EXT) {.importc.} + proc glVertexAttribL2i64vNV(index: TGLuint, v: ptr TGLint64EXT) {.importc.} proc glBlendColor(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} - proc glGetPathColorGenivNV(color: TGLenum, pname: TGLenum, value: TGLint) {.importc.} + proc glGetPathColorGenivNV(color: TGLenum, pname: TGLenum, value: ptr TGLint) {.importc.} proc glCompressedTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} proc glDrawElementsInstanced(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei) {.importc.} proc glFogCoordd(coord: TGLdouble) {.importc.} - proc glTexParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glWindowPos3svARB(v: TGLshort) {.importc.} + proc glTexParameterxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glWindowPos3svARB(v: ptr TGLshort) {.importc.} proc glGetVertexArrayPointervEXT(vaobj: TGLuint, pname: TGLenum, param: ptr pointer) {.importc.} proc glDrawTextureNV(texture: TGLuint, sampler: TGLuint, x0: TGLfloat, y0: TGLfloat, x1: TGLfloat, y1: TGLfloat, z: TGLfloat, s0: TGLfloat, t0: TGLfloat, s1: TGLfloat, t1: TGLfloat) {.importc.} - proc glUniformMatrix2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glUniformMatrix2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glTexImage3DOES(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glClampColorARB(target: TGLenum, clamp: TGLenum) {.importc.} proc glTexParameteri(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glWindowPos4svMESA(v: TGLshort) {.importc.} + proc glWindowPos4svMESA(v: ptr TGLshort) {.importc.} proc glMultiTexCoordP4ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} - proc glVertexP4uiv(`type`: TGLenum, value: TGLuint) {.importc.} + proc glVertexP4uiv(`type`: TGLenum, value: ptr TGLuint) {.importc.} proc glProgramUniform4iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} - proc glTexCoord3xvOES(coords: TGLfixed) {.importc.} + proc glTexCoord3xvOES(coords: ptr TGLfixed) {.importc.} proc glCopyTexImage2DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} - proc glGenSamplers(count: TGLsizei, samplers: TGLuint) {.importc.} - proc glRasterPos4iv(v: TGLint) {.importc.} + proc glGenSamplers(count: TGLsizei, samplers: ptr TGLuint) {.importc.} + proc glRasterPos4iv(v: ptr TGLint) {.importc.} proc glWindowPos4sMESA(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glProgramUniform2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} - proc glPrioritizeTexturesEXT(n: TGLsizei, textures: TGLuint, priorities: TGLclampf) {.importc.} + proc glProgramUniform2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} + proc glPrioritizeTexturesEXT(n: TGLsizei, textures: ptr TGLuint, priorities: ptr TGLclampf) {.importc.} proc glRects(x1: TGLshort, y1: TGLshort, x2: TGLshort, y2: TGLshort) {.importc.} - proc glMultiDrawElementsBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, drawcount: TGLsizei, basevertex: TGLint) {.importc.} + proc glMultiDrawElementsBaseVertex(mode: TGLenum, count: ptr TGLsizei, `type`: TGLenum, indices: ptr pointer, drawcount: TGLsizei, basevertex: ptr TGLint) {.importc.} proc glProgramBinaryOES(program: TGLuint, binaryFormat: TGLenum, binary: pointer, length: TGLint) {.importc.} - proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc: TGLuint, tc: TGLfloat, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} - proc glGetMinmaxParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc: ptr TGLuint, tc: ptr TGLfloat, c: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glGetMinmaxParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glColor4fNormal3fVertex3fSUN(r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glWindowPos2d(x: TGLdouble, y: TGLdouble) {.importc.} - proc glGetPerfMonitorGroupStringAMD(group: TGLuint, bufSize: TGLsizei, length: TGLsizei, groupString: TGLchar) {.importc.} - proc glUniformHandleui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64) {.importc.} + proc glGetPerfMonitorGroupStringAMD(group: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, groupString: ptr TGLchar) {.importc.} + proc glUniformHandleui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64) {.importc.} proc glBlendEquation(mode: TGLenum) {.importc.} proc glMapBufferARB(target: TGLenum, access: TGLenum) {.importc.} - proc glGetMaterialxvOES(face: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glVertexAttribI1ivEXT(index: TGLuint, v: TGLint) {.importc.} - proc glTexCoord4hvNV(v: TGLhalfNV) {.importc.} + proc glGetMaterialxvOES(face: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glVertexAttribI1ivEXT(index: TGLuint, v: ptr TGLint) {.importc.} + proc glTexCoord4hvNV(v: ptr TGLhalfNV) {.importc.} proc glVertexArrayVertexAttribLOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glExtGetShadersQCOM(shaders: TGLuint, maxShaders: TGLint, numShaders: TGLint) {.importc.} - proc glWindowPos4ivMESA(v: TGLint) {.importc.} + proc glExtGetShadersQCOM(shaders: ptr TGLuint, maxShaders: TGLint, numShaders: ptr TGLint) {.importc.} + proc glWindowPos4ivMESA(v: ptr TGLint) {.importc.} proc glVertexAttrib1sNV(index: TGLuint, x: TGLshort) {.importc.} - proc glNormalStream3ivATI(stream: TGLenum, coords: TGLint) {.importc.} + proc glNormalStream3ivATI(stream: TGLenum, coords: ptr TGLint) {.importc.} proc glSecondaryColor3fEXT(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc.} proc glVertexArrayFogCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} proc glGetTextureImageEXT(texture: TGLuint, target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glVertexAttrib4hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV, w: TGLhalfNV) {.importc.} proc glReplacementCodeusSUN(code: TGLushort) {.importc.} proc glPixelTexGenSGIX(mode: TGLenum) {.importc.} - proc glMultiDrawRangeElementArrayAPPLE(mode: TGLenum, start: TGLuint, `end`: TGLuint, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glMultiDrawRangeElementArrayAPPLE(mode: TGLenum, start: TGLuint, `end`: TGLuint, first: ptr TGLint, count: ptr TGLsizei, primcount: TGLsizei) {.importc.} proc glDrawElements(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc.} - proc glTexCoord1hvNV(v: TGLhalfNV) {.importc.} - proc glGetPixelMapuiv(map: TGLenum, values: TGLuint) {.importc.} + proc glTexCoord1hvNV(v: ptr TGLhalfNV) {.importc.} + proc glGetPixelMapuiv(map: TGLenum, values: ptr TGLuint) {.importc.} proc glRasterPos4d(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glConvolutionParameterxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} proc glSecondaryColor3dEXT(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc.} - proc glGetCombinerOutputParameterivNV(stage: TGLenum, portion: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetCombinerOutputParameterivNV(stage: TGLenum, portion: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glQueryCounter(id: TGLuint, target: TGLenum) {.importc.} - proc glGetUniformi64vNV(program: TGLuint, location: TGLint, params: TGLint64EXT) {.importc.} - proc glTexCoord2fv(v: TGLfloat) {.importc.} + proc glGetUniformi64vNV(program: TGLuint, location: TGLint, params: ptr TGLint64EXT) {.importc.} + proc glTexCoord2fv(v: ptr TGLfloat) {.importc.} proc glWindowPos3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} proc glBlendFuncSeparateINGR(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc.} proc glTextureNormalEXT(mode: TGLenum) {.importc.} proc glVertexStream2fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat) {.importc.} proc glViewportIndexedf(index: TGLuint, x: TGLfloat, y: TGLfloat, w: TGLfloat, h: TGLfloat) {.importc.} - proc glMultiTexCoord4ivARB(target: TGLenum, v: TGLint) {.importc.} + proc glMultiTexCoord4ivARB(target: TGLenum, v: ptr TGLint) {.importc.} proc glBindBufferOffsetEXT(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr) {.importc.} - proc glTexCoord3sv(v: TGLshort) {.importc.} + proc glTexCoord3sv(v: ptr TGLshort) {.importc.} proc glVertexArrayVertexAttribBindingEXT(vaobj: TGLuint, attribindex: TGLuint, bindingindex: TGLuint) {.importc.} proc glVertexAttrib2f(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc.} - proc glMultiTexGenivEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glUniformui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} - proc glGetInfoLogARB(obj: TGLhandleARB, maxLength: TGLsizei, length: TGLsizei, infoLog: TGLcharARB) {.importc.} - proc glGetNamedProgramLocalParameterIivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLint) {.importc.} + proc glMultiTexGenivEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glUniformui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} + proc glGetInfoLogARB(obj: TGLhandleARB, maxLength: TGLsizei, length: ptr TGLsizei, infoLog: ptr TGLcharARB) {.importc.} + proc glGetNamedProgramLocalParameterIivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} proc glVertexAttrib4s(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glUniformMatrix4x2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glVertexAttribs3dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} - proc glSecondaryColor3dvEXT(v: TGLdouble) {.importc.} + proc glUniformMatrix4x2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glVertexAttribs3dvNV(index: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} + proc glSecondaryColor3dvEXT(v: ptr TGLdouble) {.importc.} proc glTextureRenderbufferEXT(texture: TGLuint, target: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glVertexAttribL2ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc.} + proc glVertexAttribL2ui64vNV(index: TGLuint, v: ptr TGLuint64EXT) {.importc.} proc glBlendFuncSeparateOES(srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} proc glVertexAttribDivisorARB(index: TGLuint, divisor: TGLuint) {.importc.} - proc glWindowPos2sv(v: TGLshort) {.importc.} - proc glMultiTexCoord3svARB(target: TGLenum, v: TGLshort) {.importc.} - proc glCombinerParameterfvNV(pname: TGLenum, params: TGLfloat) {.importc.} - proc glGetImageTransformParameterfvHP(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glTexParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGetArrayObjectivATI(`array`: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGetTexParameterIuiv(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} - proc glGetProgramPipelineInfoLog(pipeline: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc.} - proc glGetOcclusionQueryuivNV(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} - proc glVertexAttrib4bvARB(index: TGLuint, v: TGLbyte) {.importc.} - proc glListParameterfvSGIX(list: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glDeleteSamplers(count: TGLsizei, samplers: TGLuint) {.importc.} + proc glWindowPos2sv(v: ptr TGLshort) {.importc.} + proc glMultiTexCoord3svARB(target: TGLenum, v: ptr TGLshort) {.importc.} + proc glCombinerParameterfvNV(pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glGetImageTransformParameterfvHP(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glTexParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetArrayObjectivATI(`array`: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetTexParameterIuiv(target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} + proc glGetProgramPipelineInfoLog(pipeline: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, infoLog: ptr TGLchar) {.importc.} + proc glGetOcclusionQueryuivNV(id: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} + proc glVertexAttrib4bvARB(index: TGLuint, v: ptr TGLbyte) {.importc.} + proc glListParameterfvSGIX(list: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glDeleteSamplers(count: TGLsizei, samplers: ptr TGLuint) {.importc.} proc glNormalStream3dATI(stream: TGLenum, nx: TGLdouble, ny: TGLdouble, nz: TGLdouble) {.importc.} - proc glProgramUniform4i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glProgramUniform4i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} proc glBlendFuncSeparateiARB(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} proc glEndTransformFeedbackEXT() {.importc.} proc glMultiTexCoord3i(target: TGLenum, s: TGLint, t: TGLint, r: TGLint) {.importc.} proc glMakeBufferResidentNV(target: TGLenum, access: TGLenum) {.importc.} - proc glTangent3dvEXT(v: TGLdouble) {.importc.} + proc glTangent3dvEXT(v: ptr TGLdouble) {.importc.} proc glMatrixPopEXT(mode: TGLenum) {.importc.} - proc glVertexAttrib4NivARB(index: TGLuint, v: TGLint) {.importc.} + proc glVertexAttrib4NivARB(index: TGLuint, v: ptr TGLint) {.importc.} proc glProgramUniform2ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc.} proc glWeightPointerARB(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glCullParameterdvEXT(pname: TGLenum, params: TGLdouble) {.importc.} + proc glCullParameterdvEXT(pname: TGLenum, params: ptr TGLdouble) {.importc.} proc glFramebufferTexture2D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glGenVertexArrays(n: TGLsizei, arrays: TGLuint) {.importc.} + proc glGenVertexArrays(n: TGLsizei, arrays: ptr TGLuint) {.importc.} proc glUniformHandleui64NV(location: TGLint, value: TGLuint64) {.importc.} proc glIndexPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glGetProgramSubroutineParameteruivNV(target: TGLenum, index: TGLuint, param: TGLuint) {.importc.} - proc glVertexAttrib1svARB(index: TGLuint, v: TGLshort) {.importc.} + proc glGetProgramSubroutineParameteruivNV(target: TGLenum, index: TGLuint, param: ptr TGLuint) {.importc.} + proc glVertexAttrib1svARB(index: TGLuint, v: ptr TGLshort) {.importc.} proc glDetachObjectARB(containerObj: TGLhandleARB, attachedObj: TGLhandleARB) {.importc.} proc glCompressedTexImage3D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} proc glBlendFuncSeparate(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc.} - proc glExecuteProgramNV(target: TGLenum, id: TGLuint, params: TGLfloat) {.importc.} + proc glExecuteProgramNV(target: TGLenum, id: TGLuint, params: ptr TGLfloat) {.importc.} proc glAttachObjectARB(containerObj: TGLhandleARB, obj: TGLhandleARB) {.importc.} proc glCompressedTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} - proc glProgramUniform4iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} - proc glVertexAttrib3sv(index: TGLuint, v: TGLshort) {.importc.} - proc glTexCoord3bvOES(coords: TGLbyte) {.importc.} - proc glGenTexturesEXT(n: TGLsizei, textures: TGLuint) {.importc.} + proc glProgramUniform4iv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} + proc glVertexAttrib3sv(index: TGLuint, v: ptr TGLshort) {.importc.} + proc glTexCoord3bvOES(coords: ptr TGLbyte) {.importc.} + proc glGenTexturesEXT(n: TGLsizei, textures: ptr TGLuint) {.importc.} proc glColor4f(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} - proc glGetFramebufferAttachmentParameterivOES(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetFramebufferAttachmentParameterivOES(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glClearColor(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} - proc glNamedProgramLocalParametersI4ivEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLint) {.importc.} + proc glNamedProgramLocalParametersI4ivEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLint) {.importc.} proc glMakeImageHandleNonResidentARB(handle: TGLuint64) {.importc.} - proc glGenRenderbuffers(n: TGLsizei, renderbuffers: TGLuint) {.importc.} - proc glVertexAttribL1ui64vARB(index: TGLuint, v: TGLuint64EXT) {.importc.} + proc glGenRenderbuffers(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} + proc glVertexAttribL1ui64vARB(index: TGLuint, v: ptr TGLuint64EXT) {.importc.} proc glBindFramebufferEXT(target: TGLenum, framebuffer: TGLuint) {.importc.} proc glProgramUniform2dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble) {.importc.} proc glCompressedMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} proc glDeleteSyncAPPLE(sync: TGLsync) {.importc.} - proc glDebugMessageInsertAMD(category: TGLenum, severity: TGLenum, id: TGLuint, length: TGLsizei, buf: TGLchar) {.importc.} + proc glDebugMessageInsertAMD(category: TGLenum, severity: TGLenum, id: TGLuint, length: TGLsizei, buf: ptr TGLchar) {.importc.} proc glSecondaryColorPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glTextureImage2DMultisampleNV(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} proc glBeginFragmentShaderATI() {.importc.} proc glClearDepth(depth: TGLdouble) {.importc.} - proc glBindTextures(first: TGLuint, count: TGLsizei, textures: TGLuint) {.importc.} + proc glBindTextures(first: TGLuint, count: TGLsizei, textures: ptr TGLuint) {.importc.} proc glEvalCoord1d(u: TGLdouble) {.importc.} proc glSecondaryColor3b(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc.} proc glExtGetTexSubImageQCOM(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, texels: pointer) {.importc.} proc glClearColorIiEXT(red: TGLint, green: TGLint, blue: TGLint, alpha: TGLint) {.importc.} proc glVertex2xOES(x: TGLfixed) {.importc.} proc glVertexAttrib2s(index: TGLuint, x: TGLshort, y: TGLshort) {.importc.} - proc glUniformHandleui64vARB(location: TGLint, count: TGLsizei, value: TGLuint64) {.importc.} - proc glAreTexturesResidentEXT(n: TGLsizei, textures: TGLuint, residences: TGLboolean): TGLboolean {.importc.} - proc glDrawElementsInstancedBaseInstance(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei, baseinstance: TGLuint) {.importc.} + proc glUniformHandleui64vARB(location: TGLint, count: TGLsizei, value: ptr TGLuint64) {.importc.} + proc glAreTexturesResidentEXT(n: TGLsizei, textures: ptr TGLuint, residences: ptr TGLboolean): TGLboolean {.importc.} + proc glDrawElementsInstancedBaseInstance(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, instancecount: TGLsizei, baseinstance: TGLuint) {.importc.} proc glGetString(name: TGLenum): TGLubyte {.importc.} proc glDrawTransformFeedbackStream(mode: TGLenum, id: TGLuint, stream: TGLuint) {.importc.} - proc glSecondaryColor3uiv(v: TGLuint) {.importc.} + proc glSecondaryColor3uiv(v: ptr TGLuint) {.importc.} proc glNamedFramebufferParameteriEXT(framebuffer: TGLuint, pname: TGLenum, param: TGLint) {.importc.} - proc glVertexAttrib4hvNV(index: TGLuint, v: TGLhalfNV) {.importc.} - proc glGetnUniformuivARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLuint) {.importc.} + proc glVertexAttrib4hvNV(index: TGLuint, v: ptr TGLhalfNV) {.importc.} + proc glGetnUniformuivARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLuint) {.importc.} proc glProgramUniform4ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} - proc glPointParameterxvOES(pname: TGLenum, params: TGLfixed) {.importc.} + proc glPointParameterxvOES(pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glIsEnabledi(target: TGLenum, index: TGLuint): TGLboolean {.importc.} proc glColorPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} - proc glFragmentLightModelfvSGIX(pname: TGLenum, params: TGLfloat) {.importc.} + proc glFragmentLightModelfvSGIX(pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glRasterPos3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glDeleteObjectARB(obj: TGLhandleARB) {.importc.} proc glSetFenceNV(fence: TGLuint, condition: TGLenum) {.importc.} - proc glTransformFeedbackAttribsNV(count: TGLuint, attribs: TGLint, bufferMode: TGLenum) {.importc.} - proc glProgramUniformMatrix2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glTransformFeedbackAttribsNV(count: TGLuint, attribs: ptr TGLint, bufferMode: TGLenum) {.importc.} + proc glProgramUniformMatrix2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glGetPointerv(pname: TGLenum, params: ptr pointer) {.importc.} - proc glWindowPos2dvMESA(v: TGLdouble) {.importc.} + proc glWindowPos2dvMESA(v: ptr TGLdouble) {.importc.} proc glTexImage2DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLint, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} proc glGenFragmentShadersATI(range: TGLuint): TGLuint {.importc.} - proc glTexCoord4fv(v: TGLfloat) {.importc.} + proc glTexCoord4fv(v: ptr TGLfloat) {.importc.} proc glCompressedTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} proc glGetNamedBufferSubDataEXT(buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} proc glFinish() {.importc.} proc glDeleteVertexShaderEXT(id: TGLuint) {.importc.} proc glFinishObjectAPPLE(`object`: TGLenum, name: TGLint) {.importc.} - proc glGetActiveAttribARB(programObj: TGLhandleARB, index: TGLuint, maxLength: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLcharARB) {.importc.} + proc glGetActiveAttribARB(programObj: TGLhandleARB, index: TGLuint, maxLength: TGLsizei, length: ptr TGLsizei, size: ptr TGLint, `type`: ptr TGLenum, name: ptr TGLcharARB) {.importc.} proc glPointParameterx(pname: TGLenum, param: TGLfixed) {.importc.} - proc glProgramUniformui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} - proc glSecondaryColor3ubv(v: TGLubyte) {.importc.} - proc glGetProgramLocalParameterIivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc.} - proc glDeleteProgramPipelinesEXT(n: TGLsizei, pipelines: TGLuint) {.importc.} + proc glProgramUniformui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} + proc glSecondaryColor3ubv(v: ptr TGLubyte) {.importc.} + proc glGetProgramLocalParameterIivNV(target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} + proc glDeleteProgramPipelinesEXT(n: TGLsizei, pipelines: ptr TGLuint) {.importc.} proc glVertexAttrib4fNV(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glGetColorTableParameterfvSGI(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glGetFloati_v(target: TGLenum, index: TGLuint, data: TGLfloat) {.importc.} - proc glGenBuffers(n: TGLsizei, buffers: TGLuint) {.importc.} + proc glGetColorTableParameterfvSGI(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glGetFloati_v(target: TGLenum, index: TGLuint, data: ptr TGLfloat) {.importc.} + proc glGenBuffers(n: TGLsizei, buffers: ptr TGLuint) {.importc.} proc glNormal3b(nx: TGLbyte, ny: TGLbyte, nz: TGLbyte) {.importc.} proc glDrawArraysInstancedARB(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} proc glTexStorage2DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} - proc glGetVariantIntegervEXT(id: TGLuint, value: TGLenum, data: TGLint) {.importc.} - proc glColor3ubv(v: TGLubyte) {.importc.} - proc glVertexAttribP4uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} - proc glProgramUniform2ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glGetVariantIntegervEXT(id: TGLuint, value: TGLenum, data: ptr TGLint) {.importc.} + proc glColor3ubv(v: ptr TGLubyte) {.importc.} + proc glVertexAttribP4uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: ptr TGLuint) {.importc.} + proc glProgramUniform2ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} proc glVertexStream4dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glVertexAttribL2ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc.} proc glSecondaryColor3bEXT(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc.} proc glGetBufferPointervOES(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} - proc glGetMaterialfv(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetMaterialfv(face: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glVertexStream3sATI(stream: TGLenum, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} proc glUniform1i(location: TGLint, v0: TGLint) {.importc.} proc glVertexAttribL2d(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} proc glTestObjectAPPLE(`object`: TGLenum, name: TGLuint): TGLboolean {.importc.} - proc glGetTransformFeedbackVarying(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLsizei, `type`: TGLenum, name: TGLchar) {.importc.} + proc glGetTransformFeedbackVarying(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, size: ptr TGLsizei, `type`: ptr TGLenum, name: ptr TGLchar) {.importc.} proc glFramebufferRenderbufferOES(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} proc glVertexStream3iATI(stream: TGLenum, x: TGLint, y: TGLint, z: TGLint) {.importc.} proc glMakeTextureHandleNonResidentNV(handle: TGLuint64) {.importc.} - proc glVertexAttrib4fvNV(index: TGLuint, v: TGLfloat) {.importc.} + proc glVertexAttrib4fvNV(index: TGLuint, v: ptr TGLfloat) {.importc.} proc glArrayElement(i: TGLint) {.importc.} - proc glClearBufferData(target: TGLenum, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glClearBufferData(target: TGLenum, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, data: ptr pointer) {.importc.} proc glSecondaryColor3usEXT(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc.} proc glRenderbufferStorageMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glTexCoord2xvOES(coords: TGLfixed) {.importc.} + proc glTexCoord2xvOES(coords: ptr TGLfixed) {.importc.} proc glWindowPos3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glTangent3svEXT(v: TGLshort) {.importc.} + proc glTangent3svEXT(v: ptr TGLshort) {.importc.} proc glPointParameterf(pname: TGLenum, param: TGLfloat) {.importc.} - proc glVertexAttribI4uivEXT(index: TGLuint, v: TGLuint) {.importc.} - proc glColorTableParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glMatrixMultdEXT(mode: TGLenum, m: TGLdouble) {.importc.} + proc glVertexAttribI4uivEXT(index: TGLuint, v: ptr TGLuint) {.importc.} + proc glColorTableParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glMatrixMultdEXT(mode: TGLenum, m: ptr TGLdouble) {.importc.} proc glUseProgramStages(pipeline: TGLuint, stages: TGLbitfield, program: TGLuint) {.importc.} proc glVertexStream4sATI(stream: TGLenum, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} proc glDrawElementsInstancedNV(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} proc glUniform3d(location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glDebugMessageControlARB(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc.} - proc glVertexAttribs3svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc.} + proc glDebugMessageControlARB(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: ptr TGLuint, enabled: TGLboolean) {.importc.} + proc glVertexAttribs3svNV(index: TGLuint, count: TGLsizei, v: ptr TGLshort) {.importc.} proc glElementPointerATI(`type`: TGLenum, `pointer`: pointer) {.importc.} - proc glColor4fNormal3fVertex3fvSUN(c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} - proc glGetPerfMonitorCountersAMD(group: TGLuint, numCounters: TGLint, maxActiveCounters: TGLint, counterSize: TGLsizei, counters: TGLuint) {.importc.} + proc glColor4fNormal3fVertex3fvSUN(c: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glGetPerfMonitorCountersAMD(group: TGLuint, numCounters: ptr TGLint, maxActiveCounters: ptr TGLint, counterSize: TGLsizei, counters: ptr TGLuint) {.importc.} proc glDispatchCompute(num_groups_x: TGLuint, num_groups_y: TGLuint, num_groups_z: TGLuint) {.importc.} proc glVertexAttribDivisorNV(index: TGLuint, divisor: TGLuint) {.importc.} proc glProgramUniform3uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} proc glRenderbufferStorageMultisampleNV(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glBinormalPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glRectxvOES(v1: TGLfixed, v2: TGLfixed) {.importc.} - proc glGenVertexArraysOES(n: TGLsizei, arrays: TGLuint) {.importc.} - proc glDebugMessageControlKHR(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc.} + proc glRectxvOES(v1: ptr TGLfixed, v2: ptr TGLfixed) {.importc.} + proc glGenVertexArraysOES(n: TGLsizei, arrays: ptr TGLuint) {.importc.} + proc glDebugMessageControlKHR(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: ptr TGLuint, enabled: TGLboolean) {.importc.} proc glProgramUniform1uiEXT(program: TGLuint, location: TGLint, v0: TGLuint) {.importc.} proc glPixelTransferi(pname: TGLenum, param: TGLint) {.importc.} proc glIsPointInFillPathNV(path: TGLuint, mask: TGLuint, x: TGLfloat, y: TGLfloat): TGLboolean {.importc.} proc glVertexBindingDivisor(bindingindex: TGLuint, divisor: TGLuint) {.importc.} - proc glGetVertexAttribLui64vARB(index: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc.} - proc glProgramUniformMatrix3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glGetVertexAttribLui64vARB(index: TGLuint, pname: TGLenum, params: ptr TGLuint64EXT) {.importc.} + proc glProgramUniformMatrix3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glDrawBuffer(mode: TGLenum) {.importc.} proc glMultiTexCoord1sARB(target: TGLenum, s: TGLshort) {.importc.} proc glSeparableFilter2DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer) {.importc.} - proc glTangent3bvEXT(v: TGLbyte) {.importc.} - proc glTexParameterIuiv(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glTangent3bvEXT(v: ptr TGLbyte) {.importc.} + proc glTexParameterIuiv(target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} proc glVertexAttribL4i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc.} - proc glDebugMessageCallbackARB(callback: TGLDEBUGPROCARB, userParam: pointer) {.importc.} - proc glMultiTexCoordP1uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} - proc glLabelObjectEXT(`type`: TGLenum, `object`: TGLuint, length: TGLsizei, label: TGLchar) {.importc.} - proc glGetnPolygonStippleARB(bufSize: TGLsizei, pattern: TGLubyte) {.importc.} + proc glDebugMessageCallbackARB(callback: TGLDEBUGPROCARB, userParam: ptr pointer) {.importc.} + proc glMultiTexCoordP1uiv(texture: TGLenum, `type`: TGLenum, coords: ptr TGLuint) {.importc.} + proc glLabelObjectEXT(`type`: TGLenum, `object`: TGLuint, length: TGLsizei, label: ptr TGLchar) {.importc.} + proc glGetnPolygonStippleARB(bufSize: TGLsizei, pattern: ptr TGLubyte) {.importc.} proc glTexCoord3xOES(s: TGLfixed, t: TGLfixed, r: TGLfixed) {.importc.} proc glCopyPixels(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, `type`: TGLenum) {.importc.} - proc glGetnUniformfvEXT(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLfloat) {.importc.} + proc glGetnUniformfvEXT(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLfloat) {.importc.} proc glColorMaski(index: TGLuint, r: TGLboolean, g: TGLboolean, b: TGLboolean, a: TGLboolean) {.importc.} - proc glRasterPos2fv(v: TGLfloat) {.importc.} - proc glBindBuffersBase(target: TGLenum, first: TGLuint, count: TGLsizei, buffers: TGLuint) {.importc.} - proc glSpriteParameterfvSGIX(pname: TGLenum, params: TGLfloat) {.importc.} - proc glGetSyncivAPPLE(sync: TGLsync, pname: TGLenum, bufSize: TGLsizei, length: TGLsizei, values: TGLint) {.importc.} + proc glRasterPos2fv(v: ptr TGLfloat) {.importc.} + proc glBindBuffersBase(target: TGLenum, first: TGLuint, count: TGLsizei, buffers: ptr TGLuint) {.importc.} + proc glSpriteParameterfvSGIX(pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glGetSyncivAPPLE(sync: TGLsync, pname: TGLenum, bufSize: TGLsizei, length: ptr TGLsizei, values: ptr TGLint) {.importc.} proc glVertexAttribI3i(index: TGLuint, x: TGLint, y: TGLint, z: TGLint) {.importc.} proc glPixelTransformParameteriEXT(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glMultiDrawArraysEXT(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glMultiDrawArraysEXT(mode: TGLenum, first: ptr TGLint, count: ptr TGLsizei, primcount: TGLsizei) {.importc.} proc glGetTextureHandleNV(texture: TGLuint): TGLuint64 {.importc.} proc glTexCoordP2ui(`type`: TGLenum, coords: TGLuint) {.importc.} - proc glDeleteQueries(n: TGLsizei, ids: TGLuint) {.importc.} - proc glGetVertexAttribArrayObjectivATI(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glDeleteQueries(n: TGLsizei, ids: ptr TGLuint) {.importc.} + proc glGetVertexAttribArrayObjectivATI(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glVertexArrayVertexBindingDivisorEXT(vaobj: TGLuint, bindingindex: TGLuint, divisor: TGLuint) {.importc.} proc glVertex3i(x: TGLint, y: TGLint, z: TGLint) {.importc.} proc glBlendEquationSeparatei(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} - proc glGetMapAttribParameterivNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glGetVideoCaptureivNV(video_capture_slot: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glFragmentMaterialfvSGIX(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetMapAttribParameterivNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetVideoCaptureivNV(video_capture_slot: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glFragmentMaterialfvSGIX(face: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glEGLImageTargetTexture2DOES(target: TGLenum, image: TGLeglImageOES) {.importc.} proc glCopyImageSubDataNV(srcName: TGLuint, srcTarget: TGLenum, srcLevel: TGLint, srcX: TGLint, srcY: TGLint, srcZ: TGLint, dstName: TGLuint, dstTarget: TGLenum, dstLevel: TGLint, dstX: TGLint, dstY: TGLint, dstZ: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} proc glUniform2i(location: TGLint, v0: TGLint, v1: TGLint) {.importc.} - proc glVertexAttrib3fvNV(index: TGLuint, v: TGLfloat) {.importc.} - proc glNamedBufferStorageEXT(buffer: TGLuint, size: TGLsizeiptr, data: pointer, flags: TGLbitfield) {.importc.} - proc glProgramEnvParameterI4uivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} - proc glGetVertexAttribdvARB(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} - proc glVertexAttribL3ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc.} - proc glUniform4fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glWeightsvARB(size: TGLint, weights: TGLshort) {.importc.} + proc glVertexAttrib3fvNV(index: TGLuint, v: ptr TGLfloat) {.importc.} + proc glNamedBufferStorageEXT(buffer: TGLuint, size: TGLsizeiptr, data: ptr pointer, flags: TGLbitfield) {.importc.} + proc glProgramEnvParameterI4uivNV(target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} + proc glGetVertexAttribdvARB(index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} + proc glVertexAttribL3ui64vNV(index: TGLuint, v: ptr TGLuint64EXT) {.importc.} + proc glUniform4fvARB(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glWeightsvARB(size: TGLint, weights: ptr TGLshort) {.importc.} proc glMakeTextureHandleNonResidentARB(handle: TGLuint64) {.importc.} proc glEvalCoord1xOES(u: TGLfixed) {.importc.} - proc glVertexAttrib2sv(index: TGLuint, v: TGLshort) {.importc.} - proc glVertexAttrib4dvNV(index: TGLuint, v: TGLdouble) {.importc.} - proc glProgramNamedParameter4fNV(id: TGLuint, len: TGLsizei, name: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glVertexAttrib2sv(index: TGLuint, v: ptr TGLshort) {.importc.} + proc glVertexAttrib4dvNV(index: TGLuint, v: ptr TGLdouble) {.importc.} + proc glProgramNamedParameter4fNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} proc glCompileShaderARB(shaderObj: TGLhandleARB) {.importc.} - proc glProgramEnvParameter4fvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} - proc glGetVertexAttribiv(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramEnvParameter4fvARB(target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} + proc glGetVertexAttribiv(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glEvalPoint1(i: TGLint) {.importc.} proc glEvalMapsNV(target: TGLenum, mode: TGLenum) {.importc.} - proc glGetTexGenxvOES(coord: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glGetTexGenxvOES(coord: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glBlendEquationSeparate(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} - proc glGetColorTableParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetColorTableParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glQueryCounterEXT(id: TGLuint, target: TGLenum) {.importc.} - proc glExtGetProgramBinarySourceQCOM(program: TGLuint, shadertype: TGLenum, source: TGLchar, length: TGLint) {.importc.} - proc glGetConvolutionParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glExtGetProgramBinarySourceQCOM(program: TGLuint, shadertype: TGLenum, source: ptr TGLchar, length: ptr TGLint) {.importc.} + proc glGetConvolutionParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glIsProgramPipeline(pipeline: TGLuint): TGLboolean {.importc.} - proc glVertexWeightfvEXT(weight: TGLfloat) {.importc.} + proc glVertexWeightfvEXT(weight: ptr TGLfloat) {.importc.} proc glDisableDriverControlQCOM(driverControl: TGLuint) {.importc.} - proc glVertexStream1fvATI(stream: TGLenum, coords: TGLfloat) {.importc.} + proc glVertexStream1fvATI(stream: TGLenum, coords: ptr TGLfloat) {.importc.} proc glMakeTextureHandleResidentNV(handle: TGLuint64) {.importc.} - proc glSamplerParameteriv(sampler: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glSamplerParameteriv(sampler: TGLuint, pname: TGLenum, param: ptr TGLint) {.importc.} proc glTexEnvxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} proc glEndOcclusionQueryNV() {.importc.} proc glFlushMappedBufferRangeAPPLE(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glVertex4iv(v: TGLint) {.importc.} + proc glVertex4iv(v: ptr TGLint) {.importc.} proc glVertexArrayVertexAttribIFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} proc glDisableIndexedEXT(target: TGLenum, index: TGLuint) {.importc.} proc glVertexAttribL1dEXT(index: TGLuint, x: TGLdouble) {.importc.} proc glBeginPerfMonitorAMD(monitor: TGLuint) {.importc.} proc glConvolutionFilter1DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} proc glPrimitiveRestartIndex(index: TGLuint) {.importc.} - proc glWindowPos2dv(v: TGLdouble) {.importc.} + proc glWindowPos2dv(v: ptr TGLdouble) {.importc.} proc glBindFramebufferOES(target: TGLenum, framebuffer: TGLuint) {.importc.} proc glTessellationModeAMD(mode: TGLenum) {.importc.} proc glIsVariantEnabledEXT(id: TGLuint, cap: TGLenum): TGLboolean {.importc.} - proc glColor3iv(v: TGLint) {.importc.} + proc glColor3iv(v: ptr TGLint) {.importc.} proc glFogCoordFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc.} - proc glClearNamedBufferDataEXT(buffer: TGLuint, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glClearNamedBufferDataEXT(buffer: TGLuint, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, data: ptr pointer) {.importc.} proc glTextureRangeAPPLE(target: TGLenum, length: TGLsizei, `pointer`: pointer) {.importc.} - proc glTexCoord4bvOES(coords: TGLbyte) {.importc.} + proc glTexCoord4bvOES(coords: ptr TGLbyte) {.importc.} proc glRotated(angle: TGLdouble, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} proc glAccum(op: TGLenum, value: TGLfloat) {.importc.} proc glVertex3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glGetPathMetricRangeNV(metricQueryMask: TGLbitfield, firstPathName: TGLuint, numPaths: TGLsizei, stride: TGLsizei, metrics: TGLfloat) {.importc.} + proc glGetPathMetricRangeNV(metricQueryMask: TGLbitfield, firstPathName: TGLuint, numPaths: TGLsizei, stride: TGLsizei, metrics: ptr TGLfloat) {.importc.} proc glUniform4d(location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glMultiTexCoord1iv(target: TGLenum, v: TGLint) {.importc.} - proc glFogFuncSGIS(n: TGLsizei, points: TGLfloat) {.importc.} + proc glMultiTexCoord1iv(target: TGLenum, v: ptr TGLint) {.importc.} + proc glFogFuncSGIS(n: TGLsizei, points: ptr TGLfloat) {.importc.} proc glGetMaterialxOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} proc glGlobalAlphaFactorbSUN(factor: TGLbyte) {.importc.} - proc glGetProgramLocalParameterdvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} - proc glDeleteProgramsARB(n: TGLsizei, programs: TGLuint) {.importc.} + proc glGetProgramLocalParameterdvARB(target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} + proc glDeleteProgramsARB(n: TGLsizei, programs: ptr TGLuint) {.importc.} proc glVertexStream1sATI(stream: TGLenum, x: TGLshort) {.importc.} proc glMatrixTranslatedEXT(mode: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} proc glTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glGetBufferSubData(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} proc glUniform4uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} - proc glGetShaderiv(shader: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glGetQueryIndexediv(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glDebugMessageInsert(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: TGLchar) {.importc.} - proc glVertexAttribs2dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} - proc glGetFixedvOES(pname: TGLenum, params: TGLfixed) {.importc.} - proc glUniform2iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glGetShaderiv(shader: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetQueryIndexediv(target: TGLenum, index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glDebugMessageInsert(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: ptr TGLchar) {.importc.} + proc glVertexAttribs2dvNV(index: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} + proc glGetFixedvOES(pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glUniform2iv(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} proc glTextureView(texture: TGLuint, target: TGLenum, origtexture: TGLuint, internalformat: TGLenum, minlevel: TGLuint, numlevels: TGLuint, minlayer: TGLuint, numlayers: TGLuint) {.importc.} - proc glMultiTexCoord1xvOES(texture: TGLenum, coords: TGLfixed) {.importc.} + proc glMultiTexCoord1xvOES(texture: TGLenum, coords: ptr TGLfixed) {.importc.} proc glTexBufferRange(target: TGLenum, internalformat: TGLenum, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} proc glMultiTexCoordPointerEXT(texunit: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glBlendColorxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} proc glReadPixels(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glWindowPos3dARB(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glPixelTexGenParameterivSGIS(pname: TGLenum, params: TGLint) {.importc.} - proc glSecondaryColor3svEXT(v: TGLshort) {.importc.} + proc glPixelTexGenParameterivSGIS(pname: TGLenum, params: ptr TGLint) {.importc.} + proc glSecondaryColor3svEXT(v: ptr TGLshort) {.importc.} proc glPopGroupMarkerEXT() {.importc.} proc glImportSyncEXT(external_sync_type: TGLenum, external_sync: TGLintptr, flags: TGLbitfield): TGLsync {.importc.} proc glVertexAttribLFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} proc glVertexAttrib2sNV(index: TGLuint, x: TGLshort, y: TGLshort) {.importc.} - proc glGetIntegeri_v(target: TGLenum, index: TGLuint, data: TGLint) {.importc.} - proc glProgramUniform3uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} - proc glGetActiveUniformBlockiv(program: TGLuint, uniformBlockIndex: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glCreateShaderProgramv(`type`: TGLenum, count: TGLsizei, strings: ptr TGLchar): TGLuint {.importc.} + proc glGetIntegeri_v(target: TGLenum, index: TGLuint, data: ptr TGLint) {.importc.} + proc glProgramUniform3uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} + proc glGetActiveUniformBlockiv(program: TGLuint, uniformBlockIndex: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glCreateShaderProgramv(`type`: TGLenum, count: TGLsizei, strings: ptr ptr TGLchar): TGLuint {.importc.} proc glUniform2fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} - proc glVertexStream4ivATI(stream: TGLenum, coords: TGLint) {.importc.} - proc glNormalP3uiv(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glVertexStream4ivATI(stream: TGLenum, coords: ptr TGLint) {.importc.} + proc glNormalP3uiv(`type`: TGLenum, coords: ptr TGLuint) {.importc.} proc glVertexAttribLFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} - proc glTexCoord2bvOES(coords: TGLbyte) {.importc.} - proc glGetActiveUniformName(program: TGLuint, uniformIndex: TGLuint, bufSize: TGLsizei, length: TGLsizei, uniformName: TGLchar) {.importc.} - proc glTexCoord2sv(v: TGLshort) {.importc.} + proc glTexCoord2bvOES(coords: ptr TGLbyte) {.importc.} + proc glGetActiveUniformName(program: TGLuint, uniformIndex: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, uniformName: ptr TGLchar) {.importc.} + proc glTexCoord2sv(v: ptr TGLshort) {.importc.} proc glVertexAttrib2dNV(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} - proc glGetFogFuncSGIS(points: TGLfloat) {.importc.} + proc glGetFogFuncSGIS(points: ptr TGLfloat) {.importc.} proc glSetFenceAPPLE(fence: TGLuint) {.importc.} proc glRasterPos2f(x: TGLfloat, y: TGLfloat) {.importc.} proc glVertexWeightPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} @@ -1362,135 +1362,135 @@ wrapErrorChecking: proc glVDPAUFiniNV() {.importc.} proc glTbufferMask3DFX(mask: TGLuint) {.importc.} proc glVertexP4ui(`type`: TGLenum, value: TGLuint) {.importc.} - proc glTexEnviv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glTexEnviv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glColor4xOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} proc glBlendEquationi(buf: TGLuint, mode: TGLenum) {.importc.} - proc glLoadMatrixxOES(m: TGLfixed) {.importc.} + proc glLoadMatrixxOES(m: ptr TGLfixed) {.importc.} proc glFogxOES(pname: TGLenum, param: TGLfixed) {.importc.} - proc glTexCoord4dv(v: TGLdouble) {.importc.} + proc glTexCoord4dv(v: ptr TGLdouble) {.importc.} proc glFogCoordPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} - proc glGetPerfMonitorGroupsAMD(numGroups: TGLint, groupsSize: TGLsizei, groups: TGLuint) {.importc.} + proc glGetPerfMonitorGroupsAMD(numGroups: ptr TGLint, groupsSize: TGLsizei, groups: ptr TGLuint) {.importc.} proc glVertex2hNV(x: TGLhalfNV, y: TGLhalfNV) {.importc.} proc glDeleteFragmentShaderATI(id: TGLuint) {.importc.} - proc glGetSamplerParameterIiv(sampler: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glUniform2fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glGetSamplerParameterIiv(sampler: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glUniform2fvARB(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} proc glFogf(pname: TGLenum, param: TGLfloat) {.importc.} proc glMultiTexCoord1iARB(target: TGLenum, s: TGLint) {.importc.} - proc glGetActiveUniformARB(programObj: TGLhandleARB, index: TGLuint, maxLength: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLcharARB) {.importc.} + proc glGetActiveUniformARB(programObj: TGLhandleARB, index: TGLuint, maxLength: TGLsizei, length: ptr TGLsizei, size: ptr TGLint, `type`: ptr TGLenum, name: ptr TGLcharARB) {.importc.} proc glMapGrid1xOES(n: TGLint, u1: TGLfixed, u2: TGLfixed) {.importc.} - proc glIndexsv(c: TGLshort) {.importc.} + proc glIndexsv(c: ptr TGLshort) {.importc.} proc glFragmentMaterialfSGIX(face: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} proc glBindTextureEXT(target: TGLenum, texture: TGLuint) {.importc.} - proc glRectiv(v1: TGLint, v2: TGLint) {.importc.} + proc glRectiv(v1: ptr TGLint, v2: ptr TGLint) {.importc.} proc glTangent3dEXT(tx: TGLdouble, ty: TGLdouble, tz: TGLdouble) {.importc.} - proc glProgramUniformMatrix3x4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glProgramUniformMatrix3x4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glNormal3hNV(nx: TGLhalfNV, ny: TGLhalfNV, nz: TGLhalfNV) {.importc.} proc glPushClientAttribDefaultEXT(mask: TGLbitfield) {.importc.} proc glUnmapBufferARB(target: TGLenum): TGLboolean {.importc.} - proc glVertexAttribs1dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} - proc glUniformMatrix2x3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glVertexAttribs1dvNV(index: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} + proc glUniformMatrix2x3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glUniform3f(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} - proc glTexEnvxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glTexEnvxv(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glMapBufferOES(target: TGLenum, access: TGLenum) {.importc.} proc glBufferData(target: TGLenum, size: TGLsizeiptr, data: pointer, usage: TGLenum) {.importc.} - proc glDrawElementsInstancedANGLE(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} + proc glDrawElementsInstancedANGLE(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei) {.importc.} proc glGetTextureHandleARB(texture: TGLuint): TGLuint64 {.importc.} proc glNormal3f(nx: TGLfloat, ny: TGLfloat, nz: TGLfloat) {.importc.} - proc glTexCoordP3uiv(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glTexCoordP3uiv(`type`: TGLenum, coords: ptr TGLuint) {.importc.} proc glTexParameterx(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} proc glMapBufferRange(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc.} proc glTexCoord2fVertex3fSUN(s: TGLfloat, t: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glVariantArrayObjectATI(id: TGLuint, `type`: TGLenum, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc.} proc glGetnHistogramARB(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, values: pointer) {.importc.} - proc glWindowPos3sv(v: TGLshort) {.importc.} + proc glWindowPos3sv(v: ptr TGLshort) {.importc.} proc glGetVariantPointervEXT(id: TGLuint, value: TGLenum, data: ptr pointer) {.importc.} - proc glGetLightfv(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetLightfv(light: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glGetnTexImageARB(target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, img: pointer) {.importc.} - proc glGenRenderbuffersEXT(n: TGLsizei, renderbuffers: TGLuint) {.importc.} + proc glGenRenderbuffersEXT(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} proc glMultiDrawArraysIndirectBindlessNV(mode: TGLenum, indirect: pointer, drawCount: TGLsizei, stride: TGLsizei, vertexBufferCount: TGLint) {.importc.} proc glDisableClientStateIndexedEXT(`array`: TGLenum, index: TGLuint) {.importc.} proc glMapGrid1f(un: TGLint, u1: TGLfloat, u2: TGLfloat) {.importc.} proc glTexStorage2D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glShaderStorageBlockBinding(program: TGLuint, storageBlockIndex: TGLuint, storageBlockBinding: TGLuint) {.importc.} proc glBlendBarrierNV() {.importc.} - proc glGetVideoui64vNV(video_slot: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc.} + proc glGetVideoui64vNV(video_slot: TGLuint, pname: TGLenum, params: ptr TGLuint64EXT) {.importc.} proc glUniform3ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc.} - proc glUniform4ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} - proc glGetQueryObjectivARB(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glUniform4ivARB(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} + proc glGetQueryObjectivARB(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glCompressedTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} proc glEnableIndexedEXT(target: TGLenum, index: TGLuint) {.importc.} proc glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: TGLuint, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glVertexAttribI3iEXT(index: TGLuint, x: TGLint, y: TGLint, z: TGLint) {.importc.} - proc glUniform4uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} - proc glGetUniformLocation(program: TGLuint, name: TGLchar): TGLint {.importc.} + proc glUniform4uivEXT(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} + proc glGetUniformLocation(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} proc glCurrentPaletteMatrixARB(index: TGLint) {.importc.} proc glVertexAttribLPointerEXT(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glFogCoorddvEXT(coord: TGLdouble) {.importc.} + proc glFogCoorddvEXT(coord: ptr TGLdouble) {.importc.} proc glInitNames() {.importc.} - proc glGetPathSpacingNV(pathListMode: TGLenum, numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, advanceScale: TGLfloat, kerningScale: TGLfloat, transformType: TGLenum, returnedSpacing: TGLfloat) {.importc.} - proc glNormal3fVertex3fvSUN(n: TGLfloat, v: TGLfloat) {.importc.} - proc glTexCoord2iv(v: TGLint) {.importc.} + proc glGetPathSpacingNV(pathListMode: TGLenum, numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, advanceScale: TGLfloat, kerningScale: TGLfloat, transformType: TGLenum, returnedSpacing: ptr TGLfloat) {.importc.} + proc glNormal3fVertex3fvSUN(n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glTexCoord2iv(v: ptr TGLint) {.importc.} proc glWindowPos3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glProgramUniformMatrix3x4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glProgramUniformMatrix3x4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glVertexAttribP4ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} - proc glVertexAttribs4ubvNV(index: TGLuint, count: TGLsizei, v: TGLubyte) {.importc.} + proc glVertexAttribs4ubvNV(index: TGLuint, count: TGLsizei, v: ptr TGLubyte) {.importc.} proc glProgramLocalParameterI4iNV(target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} proc glStencilMaskSeparate(face: TGLenum, mask: TGLuint) {.importc.} proc glClientWaitSync(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64): TGLenum {.importc.} proc glPolygonOffsetx(factor: TGLfixed, units: TGLfixed) {.importc.} proc glCreateProgramObjectARB(): TGLhandleARB {.importc.} proc glClearColorIuiEXT(red: TGLuint, green: TGLuint, blue: TGLuint, alpha: TGLuint) {.importc.} - proc glDeleteTransformFeedbacksNV(n: TGLsizei, ids: TGLuint) {.importc.} - proc glFramebufferDrawBuffersEXT(framebuffer: TGLuint, n: TGLsizei, bufs: TGLenum) {.importc.} - proc glAreTexturesResident(n: TGLsizei, textures: TGLuint, residences: TGLboolean): TGLboolean {.importc.} + proc glDeleteTransformFeedbacksNV(n: TGLsizei, ids: ptr TGLuint) {.importc.} + proc glFramebufferDrawBuffersEXT(framebuffer: TGLuint, n: TGLsizei, bufs: ptr TGLenum) {.importc.} + proc glAreTexturesResident(n: TGLsizei, textures: ptr TGLuint, residences: ptr TGLboolean): TGLboolean {.importc.} proc glNamedBufferDataEXT(buffer: TGLuint, size: TGLsizeiptr, data: pointer, usage: TGLenum) {.importc.} - proc glGetInvariantFloatvEXT(id: TGLuint, value: TGLenum, data: TGLfloat) {.importc.} + proc glGetInvariantFloatvEXT(id: TGLuint, value: TGLenum, data: ptr TGLfloat) {.importc.} proc glMultiTexCoord4d(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc.} - proc glGetPixelTransformParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetPixelTransformParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glGetStringi(name: TGLenum, index: TGLuint): TGLubyte {.importc.} proc glMakeBufferNonResidentNV(target: TGLenum) {.importc.} proc glVertex4bOES(x: TGLbyte, y: TGLbyte, z: TGLbyte) {.importc.} - proc glGetObjectLabel(identifier: TGLenum, name: TGLuint, bufSize: TGLsizei, length: TGLsizei, label: TGLchar) {.importc.} - proc glClipPlanexOES(plane: TGLenum, equation: TGLfixed) {.importc.} + proc glGetObjectLabel(identifier: TGLenum, name: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, label: ptr TGLchar) {.importc.} + proc glClipPlanexOES(plane: TGLenum, equation: ptr TGLfixed) {.importc.} proc glElementPointerAPPLE(`type`: TGLenum, `pointer`: pointer) {.importc.} proc glIsAsyncMarkerSGIX(marker: TGLuint): TGLboolean {.importc.} proc glUseShaderProgramEXT(`type`: TGLenum, program: TGLuint) {.importc.} proc glReplacementCodeuiColor4ubVertex3fSUN(rc: TGLuint, r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glIsTransformFeedback(id: TGLuint): TGLboolean {.importc.} proc glEdgeFlag(flag: TGLboolean) {.importc.} - proc glGetTexGeniv(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetTexGeniv(coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glBeginQueryEXT(target: TGLenum, id: TGLuint) {.importc.} proc glUniform1uiEXT(location: TGLint, v0: TGLuint) {.importc.} - proc glProgramUniform3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glGetVideoi64vNV(video_slot: TGLuint, pname: TGLenum, params: TGLint64EXT) {.importc.} + proc glProgramUniform3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glGetVideoi64vNV(video_slot: TGLuint, pname: TGLenum, params: ptr TGLint64EXT) {.importc.} proc glProgramUniform3ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} proc glSecondaryColor3uiEXT(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc.} proc glPathStencilFuncNV(func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} proc glVertexAttribP1ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} - proc glStencilFillPathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, fillMode: TGLenum, mask: TGLuint, transformType: TGLenum, transformValues: TGLfloat) {.importc.} + proc glStencilFillPathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, fillMode: TGLenum, mask: TGLuint, transformType: TGLenum, transformValues: ptr TGLfloat) {.importc.} proc glFogCoordfEXT(coord: TGLfloat) {.importc.} - proc glTextureParameterIuivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glTextureParameterIuivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} proc glProgramUniform4dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glFramebufferTextureFaceARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc.} proc glTexCoord3s(s: TGLshort, t: TGLshort, r: TGLshort) {.importc.} - proc glGetFramebufferAttachmentParameteriv(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetFramebufferAttachmentParameteriv(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glEndVideoCaptureNV(video_capture_slot: TGLuint) {.importc.} - proc glProgramUniformMatrix2x4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glGetFloatIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLfloat) {.importc.} + proc glProgramUniformMatrix2x4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glGetFloatIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr TGLfloat) {.importc.} proc glTexCoord1xOES(s: TGLfixed) {.importc.} proc glTexCoord4f(s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc.} - proc glShaderSource(shader: TGLuint, count: TGLsizei, string: ptr TGLchar, length: TGLint) {.importc.} - proc glGetDetailTexFuncSGIS(target: TGLenum, points: TGLfloat) {.importc.} + proc glShaderSource(shader: TGLuint, count: TGLsizei, string: ptr ptr TGLchar, length: ptr TGLint) {.importc.} + proc glGetDetailTexFuncSGIS(target: TGLenum, points: ptr TGLfloat) {.importc.} proc glResetHistogram(target: TGLenum) {.importc.} proc glVertexAttribP2ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} proc glDrawTransformFeedbackNV(mode: TGLenum, id: TGLuint) {.importc.} proc glWindowPos2fMESA(x: TGLfloat, y: TGLfloat) {.importc.} - proc glObjectLabelKHR(identifier: TGLenum, name: TGLuint, length: TGLsizei, label: TGLchar) {.importc.} + proc glObjectLabelKHR(identifier: TGLenum, name: TGLuint, length: TGLsizei, label: ptr TGLchar) {.importc.} proc glMultiTexCoord2iARB(target: TGLenum, s: TGLint, t: TGLint) {.importc.} - proc glVertexAttrib4usv(index: TGLuint, v: TGLushort) {.importc.} + proc glVertexAttrib4usv(index: TGLuint, v: ptr TGLushort) {.importc.} proc glGetGraphicsResetStatusARB(): TGLenum {.importc.} proc glProgramUniform3dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glPathSubCommandsNV(path: TGLuint, commandStart: TGLsizei, commandsToDelete: TGLsizei, numCommands: TGLsizei, commands: TGLubyte, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} + proc glPathSubCommandsNV(path: TGLuint, commandStart: TGLsizei, commandsToDelete: TGLsizei, numCommands: TGLsizei, commands: ptr TGLubyte, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} proc glEndTransformFeedbackNV() {.importc.} proc glWindowPos2sMESA(x: TGLshort, y: TGLshort) {.importc.} proc glTangent3sEXT(tx: TGLshort, ty: TGLshort, tz: TGLshort) {.importc.} @@ -1500,31 +1500,31 @@ wrapErrorChecking: proc glWindowPos3iMESA(x: TGLint, y: TGLint, z: TGLint) {.importc.} proc glTexGend(coord: TGLenum, pname: TGLenum, param: TGLdouble) {.importc.} proc glRenderbufferStorageMultisampleANGLE(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glGetProgramiv(program: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetProgramiv(program: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glDrawTransformFeedbackStreamInstanced(mode: TGLenum, id: TGLuint, stream: TGLuint, instancecount: TGLsizei) {.importc.} proc glMatrixTranslatefEXT(mode: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glColor4iv(v: TGLint) {.importc.} - proc glSecondaryColor3ivEXT(v: TGLint) {.importc.} - proc glIsNamedStringARB(namelen: TGLint, name: TGLchar): TGLboolean {.importc.} - proc glVertexAttribL4dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glColor4iv(v: ptr TGLint) {.importc.} + proc glSecondaryColor3ivEXT(v: ptr TGLint) {.importc.} + proc glIsNamedStringARB(namelen: TGLint, name: ptr TGLchar): TGLboolean {.importc.} + proc glVertexAttribL4dv(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glEndTransformFeedback() {.importc.} - proc glVertexStream3fvATI(stream: TGLenum, coords: TGLfloat) {.importc.} - proc glProgramUniformMatrix4x2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glVertexStream3fvATI(stream: TGLenum, coords: ptr TGLfloat) {.importc.} + proc glProgramUniformMatrix4x2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glTextureBufferRangeEXT(texture: TGLuint, target: TGLenum, internalformat: TGLenum, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glTexCoord2fNormal3fVertex3fvSUN(tc: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} + proc glTexCoord2fNormal3fVertex3fvSUN(tc: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} proc glProgramUniform2f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} - proc glMultiTexCoord2sv(target: TGLenum, v: TGLshort) {.importc.} + proc glMultiTexCoord2sv(target: TGLenum, v: ptr TGLshort) {.importc.} proc glTexCoord3bOES(s: TGLbyte, t: TGLbyte, r: TGLbyte) {.importc.} - proc glGenFramebuffersOES(n: TGLsizei, framebuffers: TGLuint) {.importc.} - proc glMultiTexCoord3sv(target: TGLenum, v: TGLshort) {.importc.} + proc glGenFramebuffersOES(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} + proc glMultiTexCoord3sv(target: TGLenum, v: ptr TGLshort) {.importc.} proc glVertexAttrib4Nub(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc.} proc glColor3d(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc.} - proc glGetActiveAttrib(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLchar) {.importc.} + proc glGetActiveAttrib(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, size: ptr TGLint, `type`: ptr TGLenum, name: ptr TGLchar) {.importc.} proc glConvolutionParameterfEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} proc glTexSubImage2DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glBinormal3fvEXT(v: TGLfloat) {.importc.} - proc glDebugMessageControl(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: TGLuint, enabled: TGLboolean) {.importc.} - proc glProgramUniform3uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glBinormal3fvEXT(v: ptr TGLfloat) {.importc.} + proc glDebugMessageControl(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: ptr TGLuint, enabled: TGLboolean) {.importc.} + proc glProgramUniform3uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} proc glPNTrianglesiATI(pname: TGLenum, param: TGLint) {.importc.} proc glGetPerfMonitorCounterInfoAMD(group: TGLuint, counter: TGLuint, pname: TGLenum, data: pointer) {.importc.} proc glVertexAttribL3ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc.} @@ -1532,103 +1532,103 @@ wrapErrorChecking: proc glColorSubTable(target: TGLenum, start: TGLsizei, count: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} proc glCompressedMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} proc glBindSampler(unit: TGLuint, sampler: TGLuint) {.importc.} - proc glVariantubvEXT(id: TGLuint, `addr`: TGLubyte) {.importc.} + proc glVariantubvEXT(id: TGLuint, `addr`: ptr TGLubyte) {.importc.} proc glDisablei(target: TGLenum, index: TGLuint) {.importc.} proc glVertexAttribI2uiEXT(index: TGLuint, x: TGLuint, y: TGLuint) {.importc.} proc glDrawElementArrayATI(mode: TGLenum, count: TGLsizei) {.importc.} proc glTagSampleBufferSGIX() {.importc.} proc glVertexPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} proc glFragmentLightiSGIX(light: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glLoadTransposeMatrixxOES(m: TGLfixed) {.importc.} - proc glProgramLocalParameter4fvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} - proc glGetVariantFloatvEXT(id: TGLuint, value: TGLenum, data: TGLfloat) {.importc.} - proc glProgramUniform4ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glLoadTransposeMatrixxOES(m: ptr TGLfixed) {.importc.} + proc glProgramLocalParameter4fvARB(target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} + proc glGetVariantFloatvEXT(id: TGLuint, value: TGLenum, data: ptr TGLfloat) {.importc.} + proc glProgramUniform4ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} proc glFragmentLightfSGIX(light: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} proc glIsVertexArrayAPPLE(`array`: TGLuint): TGLboolean {.importc.} - proc glTexCoord1bvOES(coords: TGLbyte) {.importc.} - proc glUniform4fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glTexCoord1bvOES(coords: ptr TGLbyte) {.importc.} + proc glUniform4fv(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} proc glPixelDataRangeNV(target: TGLenum, length: TGLsizei, `pointer`: pointer) {.importc.} - proc glUniformMatrix4x2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glUniformMatrix4x2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glRectf(x1: TGLfloat, y1: TGLfloat, x2: TGLfloat, y2: TGLfloat) {.importc.} proc glCoverageMaskNV(mask: TGLboolean) {.importc.} - proc glPointParameterfvSGIS(pname: TGLenum, params: TGLfloat) {.importc.} - proc glProgramUniformMatrix4x2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glPointParameterfvSGIS(pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glProgramUniformMatrix4x2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glFragmentLightModelfSGIX(pname: TGLenum, param: TGLfloat) {.importc.} proc glDisableVertexAttribAPPLE(index: TGLuint, pname: TGLenum) {.importc.} - proc glMultiTexCoord3dvARB(target: TGLenum, v: TGLdouble) {.importc.} - proc glTexCoord4iv(v: TGLint) {.importc.} + proc glMultiTexCoord3dvARB(target: TGLenum, v: ptr TGLdouble) {.importc.} + proc glTexCoord4iv(v: ptr TGLint) {.importc.} proc glUniform1f(location: TGLint, v0: TGLfloat) {.importc.} proc glVertexAttribParameteriAMD(index: TGLuint, pname: TGLenum, param: TGLint) {.importc.} - proc glGetConvolutionParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetConvolutionParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glRecti(x1: TGLint, y1: TGLint, x2: TGLint, y2: TGLint) {.importc.} - proc glTexEnvxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glGetRenderbufferParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glTexEnvxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glGetRenderbufferParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glBlendFuncIndexedAMD(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc.} - proc glProgramUniformMatrix3x2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glProgramUniformMatrix3x2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glDrawArraysInstancedANGLE(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} proc glTextureBarrierNV() {.importc.} - proc glDrawBuffersIndexedEXT(n: TGLint, location: TGLenum, indices: TGLint) {.importc.} - proc glUniformMatrix4fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glInstrumentsBufferSGIX(size: TGLsizei, buffer: TGLint) {.importc.} + proc glDrawBuffersIndexedEXT(n: TGLint, location: ptr TGLenum, indices: ptr TGLint) {.importc.} + proc glUniformMatrix4fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glInstrumentsBufferSGIX(size: TGLsizei, buffer: ptr TGLint) {.importc.} proc glAlphaFuncQCOM(func: TGLenum, `ref`: TGLclampf) {.importc.} - proc glUniformMatrix4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glGetMinmaxParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGetInvariantBooleanvEXT(id: TGLuint, value: TGLenum, data: TGLboolean) {.importc.} + proc glUniformMatrix4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glGetMinmaxParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetInvariantBooleanvEXT(id: TGLuint, value: TGLenum, data: ptr TGLboolean) {.importc.} proc glVDPAUIsSurfaceNV(surface: TGLvdpauSurfaceNV) {.importc.} - proc glGenProgramsARB(n: TGLsizei, programs: TGLuint) {.importc.} + proc glGenProgramsARB(n: TGLsizei, programs: ptr TGLuint) {.importc.} proc glDrawRangeElementArrayATI(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei) {.importc.} proc glFramebufferRenderbufferEXT(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} proc glClearIndex(c: TGLfloat) {.importc.} proc glDepthRangeIndexed(index: TGLuint, n: TGLdouble, f: TGLdouble) {.importc.} - proc glDrawTexivOES(coords: TGLint) {.importc.} + proc glDrawTexivOES(coords: ptr TGLint) {.importc.} proc glTangent3iEXT(tx: TGLint, ty: TGLint, tz: TGLint) {.importc.} proc glStringMarkerGREMEDY(len: TGLsizei, string: pointer) {.importc.} proc glTexCoordP1ui(`type`: TGLenum, coords: TGLuint) {.importc.} proc glOrthox(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} - proc glReplacementCodeuiVertex3fvSUN(rc: TGLuint, v: TGLfloat) {.importc.} - proc glMultiTexCoord1bvOES(texture: TGLenum, coords: TGLbyte) {.importc.} + proc glReplacementCodeuiVertex3fvSUN(rc: ptr TGLuint, v: ptr TGLfloat) {.importc.} + proc glMultiTexCoord1bvOES(texture: TGLenum, coords: ptr TGLbyte) {.importc.} proc glDrawArraysInstancedBaseInstance(mode: TGLenum, first: TGLint, count: TGLsizei, instancecount: TGLsizei, baseinstance: TGLuint) {.importc.} - proc glMultMatrixf(m: TGLfloat) {.importc.} + proc glMultMatrixf(m: ptr TGLfloat) {.importc.} proc glProgramUniform4i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} - proc glScissorArrayv(first: TGLuint, count: TGLsizei, v: TGLint) {.importc.} - proc glGetnUniformivEXT(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLint) {.importc.} - proc glGetTexEnvxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glWindowPos3ivARB(v: TGLint) {.importc.} + proc glScissorArrayv(first: TGLuint, count: TGLsizei, v: ptr TGLint) {.importc.} + proc glGetnUniformivEXT(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLint) {.importc.} + proc glGetTexEnvxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glWindowPos3ivARB(v: ptr TGLint) {.importc.} proc glProgramStringARB(target: TGLenum, format: TGLenum, len: TGLsizei, string: pointer) {.importc.} proc glTextureColorMaskSGIS(red: TGLboolean, green: TGLboolean, blue: TGLboolean, alpha: TGLboolean) {.importc.} - proc glMultiTexCoord4fv(target: TGLenum, v: TGLfloat) {.importc.} - proc glUniformMatrix4x3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glMultiTexCoord4fv(target: TGLenum, v: ptr TGLfloat) {.importc.} + proc glUniformMatrix4x3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glIsPathNV(path: TGLuint): TGLboolean {.importc.} proc glStartTilingQCOM(x: TGLuint, y: TGLuint, width: TGLuint, height: TGLuint, preserveMask: TGLbitfield) {.importc.} - proc glVariantivEXT(id: TGLuint, `addr`: TGLint) {.importc.} + proc glVariantivEXT(id: TGLuint, `addr`: ptr TGLint) {.importc.} proc glGetnMinmaxARB(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, values: pointer) {.importc.} - proc glTransformFeedbackVaryings(program: TGLuint, count: TGLsizei, varyings: ptr TGLchar, bufferMode: TGLenum) {.importc.} + proc glTransformFeedbackVaryings(program: TGLuint, count: TGLsizei, varyings: ptr ptr TGLchar, bufferMode: TGLenum) {.importc.} proc glShaderOp2EXT(op: TGLenum, res: TGLuint, arg1: TGLuint, arg2: TGLuint) {.importc.} proc glVertexAttribPointer(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glMultiTexCoord4dvARB(target: TGLenum, v: TGLdouble) {.importc.} + proc glMultiTexCoord4dvARB(target: TGLenum, v: ptr TGLdouble) {.importc.} proc glProgramUniform1ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT) {.importc.} - proc glGetShaderSourceARB(obj: TGLhandleARB, maxLength: TGLsizei, length: TGLsizei, source: TGLcharARB) {.importc.} + proc glGetShaderSourceARB(obj: TGLhandleARB, maxLength: TGLsizei, length: ptr TGLsizei, source: ptr TGLcharARB) {.importc.} proc glGetBufferSubDataARB(target: TGLenum, offset: TGLintptrARB, size: TGLsizeiptrARB, data: pointer) {.importc.} proc glCopyTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} proc glProgramEnvParameterI4iNV(target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} - proc glGetVertexAttribivARB(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glGetFinalCombinerInputParameterivNV(variable: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetVertexAttribivARB(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetFinalCombinerInputParameterivNV(variable: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glIndexFuncEXT(func: TGLenum, `ref`: TGLclampf) {.importc.} - proc glProgramUniformMatrix3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glProgramUniformMatrix3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glTexStorage1DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc.} - proc glUniformMatrix2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glUniformMatrix2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glConvolutionParameterf(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} proc glGlobalAlphaFactordSUN(factor: TGLdouble) {.importc.} proc glCopyTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} proc glVertex4xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} proc glClearDepthx(depth: TGLfixed) {.importc.} - proc glGetColorTableParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGenProgramPipelines(n: TGLsizei, pipelines: TGLuint) {.importc.} - proc glVertexAttribL4ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc.} + proc glGetColorTableParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGenProgramPipelines(n: TGLsizei, pipelines: ptr TGLuint) {.importc.} + proc glVertexAttribL4ui64vNV(index: TGLuint, v: ptr TGLuint64EXT) {.importc.} proc glUniform1fARB(location: TGLint, v0: TGLfloat) {.importc.} - proc glUniformMatrix3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glUniform3dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} - proc glVertexAttribI4iv(index: TGLuint, v: TGLint) {.importc.} + proc glUniformMatrix3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glUniform3dv(location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} + proc glVertexAttribI4iv(index: TGLuint, v: ptr TGLint) {.importc.} proc glPixelZoom(xfactor: TGLfloat, yfactor: TGLfloat) {.importc.} proc glShadeModel(mode: TGLenum) {.importc.} proc glFramebufferTexture3DOES(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} @@ -1637,542 +1637,542 @@ wrapErrorChecking: proc glIsEnabled(cap: TGLenum): TGLboolean {.importc.} proc glTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glPolygonOffsetxOES(factor: TGLfixed, units: TGLfixed) {.importc.} - proc glDrawBuffersEXT(n: TGLsizei, bufs: TGLenum) {.importc.} + proc glDrawBuffersEXT(n: TGLsizei, bufs: ptr TGLenum) {.importc.} proc glPixelTexGenParameterfSGIS(pname: TGLenum, param: TGLfloat) {.importc.} - proc glExtGetRenderbuffersQCOM(renderbuffers: TGLuint, maxRenderbuffers: TGLint, numRenderbuffers: TGLint) {.importc.} - proc glBindImageTextures(first: TGLuint, count: TGLsizei, textures: TGLuint) {.importc.} - proc glVertexAttribP2uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} + proc glExtGetRenderbuffersQCOM(renderbuffers: ptr TGLuint, maxRenderbuffers: TGLint, numRenderbuffers: ptr TGLint) {.importc.} + proc glBindImageTextures(first: TGLuint, count: TGLsizei, textures: ptr TGLuint) {.importc.} + proc glVertexAttribP2uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: ptr TGLuint) {.importc.} proc glTextureImage3DMultisampleCoverageNV(texture: TGLuint, target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} proc glRasterPos2s(x: TGLshort, y: TGLshort) {.importc.} - proc glVertexAttrib4dvARB(index: TGLuint, v: TGLdouble) {.importc.} - proc glProgramUniformMatrix2x3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glProgramUniformMatrix2x4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glVertexAttrib4dvARB(index: TGLuint, v: ptr TGLdouble) {.importc.} + proc glProgramUniformMatrix2x3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glProgramUniformMatrix2x4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glMultiTexCoord1d(target: TGLenum, s: TGLdouble) {.importc.} - proc glGetProgramParameterdvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glGetProgramParameterdvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} proc glPNTrianglesfATI(pname: TGLenum, param: TGLfloat) {.importc.} - proc glUniformMatrix3x4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glUniformMatrix3x4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glVertexAttrib3sNV(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glGetVideoCaptureStreamfvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glCombinerParameterivNV(pname: TGLenum, params: TGLint) {.importc.} - proc glGetTexGenfvOES(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetVideoCaptureStreamfvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glCombinerParameterivNV(pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetTexGenfvOES(coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glCopyTexSubImage2DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glGetProgramLocalParameterfvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} - proc glTexCoord3iv(v: TGLint) {.importc.} - proc glVertexAttribs2hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc.} - proc glNormal3sv(v: TGLshort) {.importc.} - proc glUniform2dv(location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} - proc glSecondaryColor3hvNV(v: TGLhalfNV) {.importc.} + proc glGetProgramLocalParameterfvARB(target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} + proc glTexCoord3iv(v: ptr TGLint) {.importc.} + proc glVertexAttribs2hvNV(index: TGLuint, n: TGLsizei, v: ptr TGLhalfNV) {.importc.} + proc glNormal3sv(v: ptr TGLshort) {.importc.} + proc glUniform2dv(location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} + proc glSecondaryColor3hvNV(v: ptr TGLhalfNV) {.importc.} proc glDrawArraysInstancedEXT(mode: TGLenum, start: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} proc glBeginTransformFeedback(primitiveMode: TGLenum) {.importc.} - proc glTexParameterIuivEXT(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} - proc glProgramBufferParametersfvNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: TGLfloat) {.importc.} + proc glTexParameterIuivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} + proc glProgramBufferParametersfvNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: ptr TGLfloat) {.importc.} proc glVertexArrayBindVertexBufferEXT(vaobj: TGLuint, bindingindex: TGLuint, buffer: TGLuint, offset: TGLintptr, stride: TGLsizei) {.importc.} proc glPathParameterfNV(path: TGLuint, pname: TGLenum, value: TGLfloat) {.importc.} - proc glGetClipPlanexOES(plane: TGLenum, equation: TGLfixed) {.importc.} - proc glSecondaryColor3ubvEXT(v: TGLubyte) {.importc.} - proc glGetPixelMapxv(map: TGLenum, size: TGLint, values: TGLfixed) {.importc.} - proc glVertexAttribI1uivEXT(index: TGLuint, v: TGLuint) {.importc.} + proc glGetClipPlanexOES(plane: TGLenum, equation: ptr TGLfixed) {.importc.} + proc glSecondaryColor3ubvEXT(v: ptr TGLubyte) {.importc.} + proc glGetPixelMapxv(map: TGLenum, size: TGLint, values: ptr TGLfixed) {.importc.} + proc glVertexAttribI1uivEXT(index: TGLuint, v: ptr TGLuint) {.importc.} proc glMultiTexImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glAlphaFuncxOES(func: TGLenum, `ref`: TGLfixed) {.importc.} - proc glMultiTexCoord2dv(target: TGLenum, v: TGLdouble) {.importc.} + proc glMultiTexCoord2dv(target: TGLenum, v: ptr TGLdouble) {.importc.} proc glBindRenderbufferOES(target: TGLenum, renderbuffer: TGLuint) {.importc.} proc glPathStencilDepthOffsetNV(factor: TGLfloat, units: TGLfloat) {.importc.} - proc glPointParameterfvEXT(pname: TGLenum, params: TGLfloat) {.importc.} + proc glPointParameterfvEXT(pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glSampleCoverageARB(value: TGLfloat, invert: TGLboolean) {.importc.} proc glVertexAttrib3dNV(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glNamedProgramLocalParameter4dvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} - proc glGenFramebuffers(n: TGLsizei, framebuffers: TGLuint) {.importc.} - proc glMultiDrawElementsEXT(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei) {.importc.} + proc glNamedProgramLocalParameter4dvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} + proc glGenFramebuffers(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} + proc glMultiDrawElementsEXT(mode: TGLenum, count: ptr TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei) {.importc.} proc glVertexAttrib2fNV(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc.} - proc glProgramUniform4ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glProgramUniform4ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} proc glTexGeniOES(coord: TGLenum, pname: TGLenum, param: TGLint) {.importc.} proc glBindProgramPipeline(pipeline: TGLuint) {.importc.} - proc glBindSamplers(first: TGLuint, count: TGLsizei, samplers: TGLuint) {.importc.} + proc glBindSamplers(first: TGLuint, count: TGLsizei, samplers: ptr TGLuint) {.importc.} proc glColorTableSGI(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} proc glMultiTexCoord3xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed) {.importc.} proc glIsQueryEXT(id: TGLuint): TGLboolean {.importc.} - proc glGenBuffersARB(n: TGLsizei, buffers: TGLuint) {.importc.} - proc glVertex4xvOES(coords: TGLfixed) {.importc.} - proc glPixelMapuiv(map: TGLenum, mapsize: TGLsizei, values: TGLuint) {.importc.} + proc glGenBuffersARB(n: TGLsizei, buffers: ptr TGLuint) {.importc.} + proc glVertex4xvOES(coords: ptr TGLfixed) {.importc.} + proc glPixelMapuiv(map: TGLenum, mapsize: TGLsizei, values: ptr TGLuint) {.importc.} proc glDrawTexfOES(x: TGLfloat, y: TGLfloat, z: TGLfloat, width: TGLfloat, height: TGLfloat) {.importc.} proc glPointParameterfEXT(pname: TGLenum, param: TGLfloat) {.importc.} - proc glPathDashArrayNV(path: TGLuint, dashCount: TGLsizei, dashArray: TGLfloat) {.importc.} - proc glClearTexImage(texture: TGLuint, level: TGLint, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} - proc glIndexdv(c: TGLdouble) {.importc.} - proc glMultTransposeMatrixfARB(m: TGLfloat) {.importc.} + proc glPathDashArrayNV(path: TGLuint, dashCount: TGLsizei, dashArray: ptr TGLfloat) {.importc.} + proc glClearTexImage(texture: TGLuint, level: TGLint, format: TGLenum, `type`: TGLenum, data: ptr pointer) {.importc.} + proc glIndexdv(c: ptr TGLdouble) {.importc.} + proc glMultTransposeMatrixfARB(m: ptr TGLfloat) {.importc.} proc glVertexAttribL3d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glUniform3fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glGetProgramInterfaceiv(program: TGLuint, programInterface: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glFogCoordfv(coord: TGLfloat) {.importc.} + proc glUniform3fv(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glGetProgramInterfaceiv(program: TGLuint, programInterface: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glFogCoordfv(coord: ptr TGLfloat) {.importc.} proc glTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetPolygonStipple(mask: TGLubyte) {.importc.} - proc glGetQueryObjectivEXT(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetPolygonStipple(mask: ptr TGLubyte) {.importc.} + proc glGetQueryObjectivEXT(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glColor3xOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed) {.importc.} - proc glMultiTexParameterIivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGetMaterialiv(face: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glVertex2fv(v: TGLfloat) {.importc.} - proc glConvolutionParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGenOcclusionQueriesNV(n: TGLsizei, ids: TGLuint) {.importc.} - proc glGetVertexAttribdvNV(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} - proc glVertexAttribs4fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} - proc glVertexAttribL3dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glMultiTexParameterIivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetMaterialiv(face: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glVertex2fv(v: ptr TGLfloat) {.importc.} + proc glConvolutionParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGenOcclusionQueriesNV(n: TGLsizei, ids: ptr TGLuint) {.importc.} + proc glGetVertexAttribdvNV(index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} + proc glVertexAttribs4fvNV(index: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} + proc glVertexAttribL3dv(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glTexEnvi(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glObjectPtrLabel(`ptr`: pointer, length: TGLsizei, label: TGLchar) {.importc.} - proc glGetTexGenfv(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glMapVertexAttrib1dAPPLE(index: TGLuint, size: TGLuint, u1: TGLdouble, u2: TGLdouble, stride: TGLint, order: TGLint, points: TGLdouble) {.importc.} - proc glTexCoord3dv(v: TGLdouble) {.importc.} + proc glObjectPtrLabel(`ptr`: ptr pointer, length: TGLsizei, label: ptr TGLchar) {.importc.} + proc glGetTexGenfv(coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glMapVertexAttrib1dAPPLE(index: TGLuint, size: TGLuint, u1: TGLdouble, u2: TGLdouble, stride: TGLint, order: TGLint, points: ptr TGLdouble) {.importc.} + proc glTexCoord3dv(v: ptr TGLdouble) {.importc.} proc glIsEnabledIndexedEXT(target: TGLenum, index: TGLuint): TGLboolean {.importc.} proc glGlobalAlphaFactoruiSUN(factor: TGLuint) {.importc.} proc glMatrixIndexPointerARB(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glUniformHandleui64ARB(location: TGLint, value: TGLuint64) {.importc.} - proc glUniform1fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glGetActiveSubroutineUniformName(program: TGLuint, shadertype: TGLenum, index: TGLuint, bufsize: TGLsizei, length: TGLsizei, name: TGLchar) {.importc.} - proc glProgramUniformMatrix4x2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glUniform1fvARB(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glGetActiveSubroutineUniformName(program: TGLuint, shadertype: TGLenum, index: TGLuint, bufsize: TGLsizei, length: ptr TGLsizei, name: ptr TGLchar) {.importc.} + proc glProgramUniformMatrix4x2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glMultiTexCoord4fARB(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc.} - proc glGetDriverControlsQCOM(num: TGLint, size: TGLsizei, driverControls: TGLuint) {.importc.} + proc glGetDriverControlsQCOM(num: ptr TGLint, size: TGLsizei, driverControls: ptr TGLuint) {.importc.} proc glBindBufferRange(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} proc glMapGrid2f(un: TGLint, u1: TGLfloat, u2: TGLfloat, vn: TGLint, v1: TGLfloat, v2: TGLfloat) {.importc.} - proc glUniform2fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glUniform2fv(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} proc glOrtho(left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} proc glGetImageHandleNV(texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, format: TGLenum): TGLuint64 {.importc.} proc glIsImageHandleResidentARB(handle: TGLuint64): TGLboolean {.importc.} - proc glGetConvolutionParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetConvolutionParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glLineWidthxOES(width: TGLfixed) {.importc.} - proc glPathCommandsNV(path: TGLuint, numCommands: TGLsizei, commands: TGLubyte, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} - proc glMaterialxvOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glPathCommandsNV(path: TGLuint, numCommands: TGLsizei, commands: ptr TGLubyte, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} + proc glMaterialxvOES(face: TGLenum, pname: TGLenum, param: ptr TGLfixed) {.importc.} proc glPauseTransformFeedbackNV() {.importc.} proc glTexCoord4d(s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc.} - proc glUniform3ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glUniform3ui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} proc glMultiTexCoord3dARB(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc.} proc glProgramUniform3fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} proc glTexImage3DMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} proc glNormalPointerEXT(`type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} - proc glPathColorGenNV(color: TGLenum, genMode: TGLenum, colorFormat: TGLenum, coeffs: TGLfloat) {.importc.} - proc glGetMultiTexGendvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc.} + proc glPathColorGenNV(color: TGLenum, genMode: TGLenum, colorFormat: TGLenum, coeffs: ptr TGLfloat) {.importc.} + proc glGetMultiTexGendvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLdouble) {.importc.} proc glColor3i(red: TGLint, green: TGLint, blue: TGLint) {.importc.} proc glPointSizex(size: TGLfixed) {.importc.} proc glGetConvolutionFilterEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} proc glBindBufferBaseNV(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc.} proc glInsertComponentEXT(res: TGLuint, src: TGLuint, num: TGLuint) {.importc.} proc glVertex2d(x: TGLdouble, y: TGLdouble) {.importc.} - proc glGetPathDashArrayNV(path: TGLuint, dashArray: TGLfloat) {.importc.} + proc glGetPathDashArrayNV(path: TGLuint, dashArray: ptr TGLfloat) {.importc.} proc glVertexAttrib2sARB(index: TGLuint, x: TGLshort, y: TGLshort) {.importc.} proc glScissor(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glLoadMatrixd(m: TGLdouble) {.importc.} - proc glVertex2bvOES(coords: TGLbyte) {.importc.} + proc glLoadMatrixd(m: ptr TGLdouble) {.importc.} + proc glVertex2bvOES(coords: ptr TGLbyte) {.importc.} proc glTexCoord2i(s: TGLint, t: TGLint) {.importc.} proc glWriteMaskEXT(res: TGLuint, `in`: TGLuint, outX: TGLenum, outY: TGLenum, outZ: TGLenum, outW: TGLenum) {.importc.} proc glClientWaitSyncAPPLE(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64): TGLenum {.importc.} - proc glGetObjectBufferivATI(buffer: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glGetNamedBufferParameterivEXT(buffer: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetObjectBufferivATI(buffer: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetNamedBufferParameterivEXT(buffer: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glTexCoord1bOES(s: TGLbyte) {.importc.} proc glVertexAttrib4dARB(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glUniform3fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} - proc glWindowPos2ivARB(v: TGLint) {.importc.} - proc glCreateShaderProgramvEXT(`type`: TGLenum, count: TGLsizei, strings: ptr TGLchar): TGLuint {.importc.} - proc glListParameterivSGIX(list: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glWindowPos2ivARB(v: ptr TGLint) {.importc.} + proc glCreateShaderProgramvEXT(`type`: TGLenum, count: TGLsizei, strings: ptr ptr TGLchar): TGLuint {.importc.} + proc glListParameterivSGIX(list: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glGetGraphicsResetStatusEXT(): TGLenum {.importc.} proc glActiveShaderProgramEXT(pipeline: TGLuint, program: TGLuint) {.importc.} - proc glTexCoordP1uiv(`type`: TGLenum, coords: TGLuint) {.importc.} - proc glVideoCaptureStreamParameterdvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glTexCoordP1uiv(`type`: TGLenum, coords: ptr TGLuint) {.importc.} + proc glVideoCaptureStreamParameterdvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} proc glGetVertexAttribPointerv(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc.} proc glGetCompressedMultiTexImageEXT(texunit: TGLenum, target: TGLenum, lod: TGLint, img: pointer) {.importc.} proc glWindowPos4fMESA(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} proc glDrawElementsInstancedARB(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} proc glVertexStream1dATI(stream: TGLenum, x: TGLdouble) {.importc.} - proc glMatrixMultfEXT(mode: TGLenum, m: TGLfloat) {.importc.} - proc glGetPathParameterivNV(path: TGLuint, pname: TGLenum, value: TGLint) {.importc.} + proc glMatrixMultfEXT(mode: TGLenum, m: ptr TGLfloat) {.importc.} + proc glGetPathParameterivNV(path: TGLuint, pname: TGLenum, value: ptr TGLint) {.importc.} proc glCombinerParameteriNV(pname: TGLenum, param: TGLint) {.importc.} proc glUpdateObjectBufferATI(buffer: TGLuint, offset: TGLuint, size: TGLsizei, `pointer`: pointer, preserve: TGLenum) {.importc.} - proc glVertexAttrib4uivARB(index: TGLuint, v: TGLuint) {.importc.} - proc glVertexAttrib4iv(index: TGLuint, v: TGLint) {.importc.} + proc glVertexAttrib4uivARB(index: TGLuint, v: ptr TGLuint) {.importc.} + proc glVertexAttrib4iv(index: TGLuint, v: ptr TGLint) {.importc.} proc glFrustum(left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} - proc glDrawTexxvOES(coords: TGLfixed) {.importc.} + proc glDrawTexxvOES(coords: ptr TGLfixed) {.importc.} proc glTexCoord2fColor4ubVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glMultiTexCoord2fARB(target: TGLenum, s: TGLfloat, t: TGLfloat) {.importc.} - proc glGenTransformFeedbacksNV(n: TGLsizei, ids: TGLuint) {.importc.} + proc glGenTransformFeedbacksNV(n: TGLsizei, ids: ptr TGLuint) {.importc.} proc glMultiTexGenfEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} proc glGetMinmax(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} proc glBindTransformFeedback(target: TGLenum, id: TGLuint) {.importc.} proc glEnableVertexAttribArrayARB(index: TGLuint) {.importc.} proc glIsFenceAPPLE(fence: TGLuint): TGLboolean {.importc.} - proc glMultiTexGendvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc.} + proc glMultiTexGendvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLdouble) {.importc.} proc glRotatex(angle: TGLfixed, x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glGetFragmentLightfvSGIX(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glMultiTexCoord4dv(target: TGLenum, v: TGLdouble) {.importc.} + proc glGetFragmentLightfvSGIX(light: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glMultiTexCoord4dv(target: TGLenum, v: ptr TGLdouble) {.importc.} proc glBlendFuncSeparateEXT(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc.} proc glMultiTexCoord1f(target: TGLenum, s: TGLfloat) {.importc.} proc glWindowPos2f(x: TGLfloat, y: TGLfloat) {.importc.} - proc glGetPathTexGenivNV(texCoordSet: TGLenum, pname: TGLenum, value: TGLint) {.importc.} - proc glIndexxvOES(component: TGLfixed) {.importc.} + proc glGetPathTexGenivNV(texCoordSet: TGLenum, pname: TGLenum, value: ptr TGLint) {.importc.} + proc glIndexxvOES(component: ptr TGLfixed) {.importc.} proc glDisableVertexArrayAttribEXT(vaobj: TGLuint, index: TGLuint) {.importc.} - proc glGetProgramivARB(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetProgramivARB(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glPatchParameteri(pname: TGLenum, value: TGLint) {.importc.} - proc glMultiTexCoord2fv(target: TGLenum, v: TGLfloat) {.importc.} + proc glMultiTexCoord2fv(target: TGLenum, v: ptr TGLfloat) {.importc.} proc glTexSubImage3DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glFramebufferTexture1DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} proc glTangent3fEXT(tx: TGLfloat, ty: TGLfloat, tz: TGLfloat) {.importc.} proc glIsVertexAttribEnabledAPPLE(index: TGLuint, pname: TGLenum): TGLboolean {.importc.} - proc glGetShaderInfoLog(shader: TGLuint, bufSize: TGLsizei, length: TGLsizei, infoLog: TGLchar) {.importc.} + proc glGetShaderInfoLog(shader: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, infoLog: ptr TGLchar) {.importc.} proc glFrustumx(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} - proc glTexGenfv(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glTexGenfv(coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glCompressedTexImage2DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glMultiTexCoord2bvOES(texture: TGLenum, coords: TGLbyte) {.importc.} - proc glGetTexBumpParameterivATI(pname: TGLenum, param: TGLint) {.importc.} - proc glMultiTexCoord2svARB(target: TGLenum, v: TGLshort) {.importc.} - proc glProgramBufferParametersIivNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: TGLint) {.importc.} + proc glMultiTexCoord2bvOES(texture: TGLenum, coords: ptr TGLbyte) {.importc.} + proc glGetTexBumpParameterivATI(pname: TGLenum, param: ptr TGLint) {.importc.} + proc glMultiTexCoord2svARB(target: TGLenum, v: ptr TGLshort) {.importc.} + proc glProgramBufferParametersIivNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: ptr TGLint) {.importc.} proc glIsQueryARB(id: TGLuint): TGLboolean {.importc.} proc glFramebufferTextureLayer(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} proc glUniform4i(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} proc glDrawArrays(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc.} - proc glWeightubvARB(size: TGLint, weights: TGLubyte) {.importc.} - proc glGetUniformSubroutineuiv(shadertype: TGLenum, location: TGLint, params: TGLuint) {.importc.} - proc glMultTransposeMatrixdARB(m: TGLdouble) {.importc.} - proc glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc: TGLuint, tc: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} - proc glGetMapdv(target: TGLenum, query: TGLenum, v: TGLdouble) {.importc.} - proc glGetMultisamplefvNV(pname: TGLenum, index: TGLuint, val: TGLfloat) {.importc.} - proc glVertex2hvNV(v: TGLhalfNV) {.importc.} - proc glProgramUniformMatrix2x3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glWeightubvARB(size: TGLint, weights: ptr TGLubyte) {.importc.} + proc glGetUniformSubroutineuiv(shadertype: TGLenum, location: TGLint, params: ptr TGLuint) {.importc.} + proc glMultTransposeMatrixdARB(m: ptr TGLdouble) {.importc.} + proc glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc: ptr TGLuint, tc: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glGetMapdv(target: TGLenum, query: TGLenum, v: ptr TGLdouble) {.importc.} + proc glGetMultisamplefvNV(pname: TGLenum, index: TGLuint, val: ptr TGLfloat) {.importc.} + proc glVertex2hvNV(v: ptr TGLhalfNV) {.importc.} + proc glProgramUniformMatrix2x3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glProgramUniform3iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} - proc glGetnPixelMapusvARB(map: TGLenum, bufSize: TGLsizei, values: TGLushort) {.importc.} - proc glVertexWeighthvNV(weight: TGLhalfNV) {.importc.} + proc glGetnPixelMapusvARB(map: TGLenum, bufSize: TGLsizei, values: ptr TGLushort) {.importc.} + proc glVertexWeighthvNV(weight: ptr TGLhalfNV) {.importc.} proc glDrawTransformFeedbackInstanced(mode: TGLenum, id: TGLuint, instancecount: TGLsizei) {.importc.} proc glFlushStaticDataIBM(target: TGLenum) {.importc.} - proc glWindowPos2fvARB(v: TGLfloat) {.importc.} + proc glWindowPos2fvARB(v: ptr TGLfloat) {.importc.} proc glMultiTexCoord3sARB(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort) {.importc.} - proc glWindowPos3fv(v: TGLfloat) {.importc.} + proc glWindowPos3fv(v: ptr TGLfloat) {.importc.} proc glFlushVertexArrayRangeNV() {.importc.} proc glTangent3bEXT(tx: TGLbyte, ty: TGLbyte, tz: TGLbyte) {.importc.} proc glIglooInterfaceSGIX(pname: TGLenum, params: pointer) {.importc.} - proc glProgramUniformMatrix4x2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glProgramUniformMatrix4x2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glVertexAttribIFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} proc glNamedRenderbufferStorageMultisampleEXT(renderbuffer: TGLuint, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glCopyTexImage1DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} proc glBindTexGenParameterEXT(unit: TGLenum, coord: TGLenum, value: TGLenum): TGLuint {.importc.} proc glVertex4hNV(x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV, w: TGLhalfNV) {.importc.} - proc glGetMapfv(target: TGLenum, query: TGLenum, v: TGLfloat) {.importc.} + proc glGetMapfv(target: TGLenum, query: TGLenum, v: ptr TGLfloat) {.importc.} proc glSamplePatternEXT(pattern: TGLenum) {.importc.} proc glIndexxOES(component: TGLfixed) {.importc.} - proc glVertexAttrib4ubv(index: TGLuint, v: TGLubyte) {.importc.} + proc glVertexAttrib4ubv(index: TGLuint, v: ptr TGLubyte) {.importc.} proc glGetColorTable(target: TGLenum, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} - proc glFragmentLightModelivSGIX(pname: TGLenum, params: TGLint) {.importc.} + proc glFragmentLightModelivSGIX(pname: TGLenum, params: ptr TGLint) {.importc.} proc glPixelTransformParameterfEXT(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glSamplerParameterfv(sampler: TGLuint, pname: TGLenum, param: TGLfloat) {.importc.} + proc glSamplerParameterfv(sampler: TGLuint, pname: TGLenum, param: ptr TGLfloat) {.importc.} proc glBindTextureUnitParameterEXT(unit: TGLenum, value: TGLenum): TGLuint {.importc.} proc glColor3ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc.} - proc glGetMultiTexGenivEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glVariantusvEXT(id: TGLuint, `addr`: TGLushort) {.importc.} - proc glMaterialiv(face: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetMultiTexGenivEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glVariantusvEXT(id: TGLuint, `addr`: ptr TGLushort) {.importc.} + proc glMaterialiv(face: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glPassTexCoordATI(dst: TGLuint, coord: TGLuint, swizzle: TGLenum) {.importc.} - proc glGetIntegerui64vNV(value: TGLenum, result: TGLuint64EXT) {.importc.} + proc glGetIntegerui64vNV(value: TGLenum, result: ptr TGLuint64EXT) {.importc.} proc glProgramParameteriEXT(program: TGLuint, pname: TGLenum, value: TGLint) {.importc.} proc glVertexArrayEdgeFlagOffsetEXT(vaobj: TGLuint, buffer: TGLuint, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glGetCombinerInputParameterivNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetCombinerInputParameterivNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glLogicOp(opcode: TGLenum) {.importc.} - proc glConvolutionParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glConvolutionParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glIsBufferResidentNV(target: TGLenum): TGLboolean {.importc.} proc glIsProgram(program: TGLuint): TGLboolean {.importc.} proc glEndQueryARB(target: TGLenum) {.importc.} proc glRenderbufferStorage(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glMaterialfv(face: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glMaterialfv(face: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glTranslatex(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glPathParameterivNV(path: TGLuint, pname: TGLenum, value: TGLint) {.importc.} + proc glPathParameterivNV(path: TGLuint, pname: TGLenum, value: ptr TGLint) {.importc.} proc glLightxOES(light: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} proc glSampleMaskEXT(value: TGLclampf, invert: TGLboolean) {.importc.} - proc glReplacementCodeubvSUN(code: TGLubyte) {.importc.} + proc glReplacementCodeubvSUN(code: ptr TGLubyte) {.importc.} proc glVertexAttribArrayObjectATI(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc.} proc glBeginTransformFeedbackNV(primitiveMode: TGLenum) {.importc.} - proc glEvalCoord1fv(u: TGLfloat) {.importc.} - proc glProgramUniformMatrix2x3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glMaterialxv(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glGetIntegerui64i_vNV(value: TGLenum, index: TGLuint, result: TGLuint64EXT) {.importc.} + proc glEvalCoord1fv(u: ptr TGLfloat) {.importc.} + proc glProgramUniformMatrix2x3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glMaterialxv(face: TGLenum, pname: TGLenum, param: ptr TGLfixed) {.importc.} + proc glGetIntegerui64i_vNV(value: TGLenum, index: TGLuint, result: ptr TGLuint64EXT) {.importc.} proc glUniformBlockBinding(program: TGLuint, uniformBlockIndex: TGLuint, uniformBlockBinding: TGLuint) {.importc.} proc glColor4ui(red: TGLuint, green: TGLuint, blue: TGLuint, alpha: TGLuint) {.importc.} - proc glColor4ubVertex2fvSUN(c: TGLubyte, v: TGLfloat) {.importc.} + proc glColor4ubVertex2fvSUN(c: ptr TGLubyte, v: ptr TGLfloat) {.importc.} proc glRectd(x1: TGLdouble, y1: TGLdouble, x2: TGLdouble, y2: TGLdouble) {.importc.} proc glGenVertexShadersEXT(range: TGLuint): TGLuint {.importc.} proc glLinkProgramARB(programObj: TGLhandleARB) {.importc.} proc glVertexAttribL4dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glBlitFramebuffer(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} proc glUseProgram(program: TGLuint) {.importc.} - proc glNamedProgramLocalParameterI4ivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLint) {.importc.} - proc glMatrixLoadTransposedEXT(mode: TGLenum, m: TGLdouble) {.importc.} + proc glNamedProgramLocalParameterI4ivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} + proc glMatrixLoadTransposedEXT(mode: TGLenum, m: ptr TGLdouble) {.importc.} proc glTranslatef(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glGetBooleani_v(target: TGLenum, index: TGLuint, data: TGLboolean) {.importc.} + proc glGetBooleani_v(target: TGLenum, index: TGLuint, data: ptr TGLboolean) {.importc.} proc glEndFragmentShaderATI() {.importc.} - proc glVertexAttribI4ivEXT(index: TGLuint, v: TGLint) {.importc.} + proc glVertexAttribI4ivEXT(index: TGLuint, v: ptr TGLint) {.importc.} proc glMultiDrawElementsIndirectBindlessNV(mode: TGLenum, `type`: TGLenum, indirect: pointer, drawCount: TGLsizei, stride: TGLsizei, vertexBufferCount: TGLint) {.importc.} proc glTexCoord2s(s: TGLshort, t: TGLshort) {.importc.} - proc glProgramUniform1i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} - proc glPointSizePointerOES(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glGetTexFilterFuncSGIS(target: TGLenum, filter: TGLenum, weights: TGLfloat) {.importc.} + proc glProgramUniform1i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} + proc glPointSizePointerOES(`type`: TGLenum, stride: TGLsizei, `pointer`: ptr pointer) {.importc.} + proc glGetTexFilterFuncSGIS(target: TGLenum, filter: TGLenum, weights: ptr TGLfloat) {.importc.} proc glMapGrid2xOES(n: TGLint, u1: TGLfixed, u2: TGLfixed, v1: TGLfixed, v2: TGLfixed) {.importc.} - proc glRasterPos4xvOES(coords: TGLfixed) {.importc.} - proc glGetProgramBinary(program: TGLuint, bufSize: TGLsizei, length: TGLsizei, binaryFormat: TGLenum, binary: pointer) {.importc.} + proc glRasterPos4xvOES(coords: ptr TGLfixed) {.importc.} + proc glGetProgramBinary(program: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, binaryFormat: ptr TGLenum, binary: pointer) {.importc.} proc glNamedProgramLocalParameterI4uiEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} proc glGetTexImage(target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glColor4d(red: TGLdouble, green: TGLdouble, blue: TGLdouble, alpha: TGLdouble) {.importc.} proc glTexCoord2fColor4fNormal3fVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glIndexi(c: TGLint) {.importc.} - proc glGetSamplerParameterIuiv(sampler: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} - proc glGetnUniformivARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLint) {.importc.} + proc glGetSamplerParameterIuiv(sampler: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} + proc glGetnUniformivARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLint) {.importc.} proc glCopyTexSubImage3DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glVertexAttribI2uivEXT(index: TGLuint, v: TGLuint) {.importc.} - proc glVertexStream2fvATI(stream: TGLenum, coords: TGLfloat) {.importc.} + proc glVertexAttribI2uivEXT(index: TGLuint, v: ptr TGLuint) {.importc.} + proc glVertexStream2fvATI(stream: TGLenum, coords: ptr TGLfloat) {.importc.} proc glArrayElementEXT(i: TGLint) {.importc.} - proc glVertexAttrib2fv(index: TGLuint, v: TGLfloat) {.importc.} + proc glVertexAttrib2fv(index: TGLuint, v: ptr TGLfloat) {.importc.} proc glCopyMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glTexCoord4sv(v: TGLshort) {.importc.} - proc glTexGenfvOES(coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glPointParameteriv(pname: TGLenum, params: TGLint) {.importc.} - proc glGetNamedRenderbufferParameterivEXT(renderbuffer: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glTexCoord4sv(v: ptr TGLshort) {.importc.} + proc glTexGenfvOES(coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glPointParameteriv(pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetNamedRenderbufferParameterivEXT(renderbuffer: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glProgramVertexLimitNV(target: TGLenum, limit: TGLint) {.importc.} - proc glSetMultisamplefvAMD(pname: TGLenum, index: TGLuint, val: TGLfloat) {.importc.} + proc glSetMultisamplefvAMD(pname: TGLenum, index: TGLuint, val: ptr TGLfloat) {.importc.} proc glLoadIdentityDeformationMapSGIX(mask: TGLbitfield) {.importc.} proc glIsSyncAPPLE(sync: TGLsync): TGLboolean {.importc.} - proc glProgramUniform1ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} - proc glEdgeFlagPointerListIBM(stride: TGLint, `pointer`: ptr TGLboolean, ptrstride: TGLint) {.importc.} + proc glProgramUniform1ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} + proc glEdgeFlagPointerListIBM(stride: TGLint, `pointer`: ptr ptr TGLboolean, ptrstride: TGLint) {.importc.} proc glBeginVertexShaderEXT() {.importc.} - proc glGetIntegerv(pname: TGLenum, params: TGLint) {.importc.} - proc glVertexAttrib2dvARB(index: TGLuint, v: TGLdouble) {.importc.} + proc glGetIntegerv(pname: TGLenum, params: ptr TGLint) {.importc.} + proc glVertexAttrib2dvARB(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glBeginConditionalRenderNV(id: TGLuint, mode: TGLenum) {.importc.} - proc glEdgeFlagv(flag: TGLboolean) {.importc.} + proc glEdgeFlagv(flag: ptr TGLboolean) {.importc.} proc glReplacementCodeubSUN(code: TGLubyte) {.importc.} - proc glObjectLabel(identifier: TGLenum, name: TGLuint, length: TGLsizei, label: TGLchar) {.importc.} - proc glMultiTexCoord3xvOES(texture: TGLenum, coords: TGLfixed) {.importc.} - proc glNormal3iv(v: TGLint) {.importc.} + proc glObjectLabel(identifier: TGLenum, name: TGLuint, length: TGLsizei, label: ptr TGLchar) {.importc.} + proc glMultiTexCoord3xvOES(texture: TGLenum, coords: ptr TGLfixed) {.importc.} + proc glNormal3iv(v: ptr TGLint) {.importc.} proc glSamplerParameteri(sampler: TGLuint, pname: TGLenum, param: TGLint) {.importc.} proc glTextureStorage1DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc.} - proc glVertexStream4dvATI(stream: TGLenum, coords: TGLdouble) {.importc.} - proc glWindowPos2fv(v: TGLfloat) {.importc.} + proc glVertexStream4dvATI(stream: TGLenum, coords: ptr TGLdouble) {.importc.} + proc glWindowPos2fv(v: ptr TGLfloat) {.importc.} proc glTexCoord4i(s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc.} - proc glVertexAttrib4NusvARB(index: TGLuint, v: TGLushort) {.importc.} + proc glVertexAttrib4NusvARB(index: TGLuint, v: ptr TGLushort) {.importc.} proc glVertexAttribL4d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glVertexAttribDivisorANGLE(index: TGLuint, divisor: TGLuint) {.importc.} proc glMatrixIndexPointerOES(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glMultMatrixxOES(m: TGLfixed) {.importc.} + proc glMultMatrixxOES(m: ptr TGLfixed) {.importc.} proc glMultiTexCoordP2ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} - proc glDeformationMap3dSGIX(target: TGLenum, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, w1: TGLdouble, w2: TGLdouble, wstride: TGLint, worder: TGLint, points: TGLdouble) {.importc.} + proc glDeformationMap3dSGIX(target: TGLenum, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, w1: TGLdouble, w2: TGLdouble, wstride: TGLint, worder: TGLint, points: ptr TGLdouble) {.importc.} proc glClearDepthfOES(depth: TGLclampf) {.importc.} - proc glVertexStream1ivATI(stream: TGLenum, coords: TGLint) {.importc.} + proc glVertexStream1ivATI(stream: TGLenum, coords: ptr TGLint) {.importc.} proc glHint(target: TGLenum, mode: TGLenum) {.importc.} - proc glVertex3fv(v: TGLfloat) {.importc.} + proc glVertex3fv(v: ptr TGLfloat) {.importc.} proc glWaitSyncAPPLE(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64) {.importc.} proc glWindowPos3i(x: TGLint, y: TGLint, z: TGLint) {.importc.} proc glCompressedTexImage3DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glVertexAttrib1fvARB(index: TGLuint, v: TGLfloat) {.importc.} + proc glVertexAttrib1fvARB(index: TGLuint, v: ptr TGLfloat) {.importc.} proc glMultiTexCoord4xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc.} proc glUniform4ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc.} proc glProgramUniform4uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} proc glUnmapNamedBufferEXT(buffer: TGLuint): TGLboolean {.importc.} - proc glBitmap(width: TGLsizei, height: TGLsizei, xorig: TGLfloat, yorig: TGLfloat, xmove: TGLfloat, ymove: TGLfloat, bitmap: TGLubyte) {.importc.} - proc glNamedProgramLocalParameters4fvEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLfloat) {.importc.} - proc glGetPathCommandsNV(path: TGLuint, commands: TGLubyte) {.importc.} + proc glBitmap(width: TGLsizei, height: TGLsizei, xorig: TGLfloat, yorig: TGLfloat, xmove: TGLfloat, ymove: TGLfloat, bitmap: ptr TGLubyte) {.importc.} + proc glNamedProgramLocalParameters4fvEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLfloat) {.importc.} + proc glGetPathCommandsNV(path: TGLuint, commands: ptr TGLubyte) {.importc.} proc glVertexAttrib3fNV(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glNamedProgramStringEXT(program: TGLuint, target: TGLenum, format: TGLenum, len: TGLsizei, string: pointer) {.importc.} - proc glMatrixIndexusvARB(size: TGLint, indices: TGLushort) {.importc.} + proc glMatrixIndexusvARB(size: TGLint, indices: ptr TGLushort) {.importc.} proc glBlitFramebufferNV(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} - proc glVertexAttribI1uiv(index: TGLuint, v: TGLuint) {.importc.} + proc glVertexAttribI1uiv(index: TGLuint, v: ptr TGLuint) {.importc.} proc glEndConditionalRenderNV() {.importc.} - proc glFeedbackBuffer(size: TGLsizei, `type`: TGLenum, buffer: TGLfloat) {.importc.} - proc glMultiTexCoord3bvOES(texture: TGLenum, coords: TGLbyte) {.importc.} + proc glFeedbackBuffer(size: TGLsizei, `type`: TGLenum, buffer: ptr TGLfloat) {.importc.} + proc glMultiTexCoord3bvOES(texture: TGLenum, coords: ptr TGLbyte) {.importc.} proc glCopyColorTableSGI(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} proc glActiveTexture(texture: TGLenum) {.importc.} proc glFogCoordhNV(fog: TGLhalfNV) {.importc.} proc glColorMaskIndexedEXT(index: TGLuint, r: TGLboolean, g: TGLboolean, b: TGLboolean, a: TGLboolean) {.importc.} proc glGetCompressedTexImage(target: TGLenum, level: TGLint, img: pointer) {.importc.} - proc glRasterPos2iv(v: TGLint) {.importc.} - proc glGetBufferParameterivARB(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glRasterPos2iv(v: ptr TGLint) {.importc.} + proc glGetBufferParameterivARB(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glProgramUniform3d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble, v2: TGLdouble) {.importc.} - proc glRasterPos3xvOES(coords: TGLfixed) {.importc.} - proc glGetTextureParameterIuivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} + proc glRasterPos3xvOES(coords: ptr TGLfixed) {.importc.} + proc glGetTextureParameterIuivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} proc glBindImageTextureEXT(index: TGLuint, texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, access: TGLenum, format: TGLint) {.importc.} proc glWindowPos2iMESA(x: TGLint, y: TGLint) {.importc.} proc glVertexPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glPixelTexGenParameterfvSGIS(pname: TGLenum, params: TGLfloat) {.importc.} + proc glPixelTexGenParameterfvSGIS(pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glUniform1iARB(location: TGLint, v0: TGLint) {.importc.} proc glTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glStencilOpSeparate(face: TGLenum, sfail: TGLenum, dpfail: TGLenum, dppass: TGLenum) {.importc.} proc glVertexAttrib1dARB(index: TGLuint, x: TGLdouble) {.importc.} - proc glGetVideoCaptureStreamivNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetVideoCaptureStreamivNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glIsFramebufferEXT(framebuffer: TGLuint): TGLboolean {.importc.} - proc glPointParameterxv(pname: TGLenum, params: TGLfixed) {.importc.} - proc glProgramUniform4dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glPointParameterxv(pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glProgramUniform4dv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} proc glPassThrough(token: TGLfloat) {.importc.} - proc glGetProgramPipelineiv(pipeline: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetProgramPipelineiv(pipeline: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glApplyTextureEXT(mode: TGLenum) {.importc.} proc glVertexArrayNormalOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glTexFilterFuncSGIS(target: TGLenum, filter: TGLenum, n: TGLsizei, weights: TGLfloat) {.importc.} + proc glTexFilterFuncSGIS(target: TGLenum, filter: TGLenum, n: TGLsizei, weights: ptr TGLfloat) {.importc.} proc glRenderbufferStorageOES(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glBindParameterEXT(value: TGLenum): TGLuint {.importc.} proc glVertex4s(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glLoadTransposeMatrixf(m: TGLfloat) {.importc.} + proc glLoadTransposeMatrixf(m: ptr TGLfloat) {.importc.} proc glDepthFunc(func: TGLenum) {.importc.} - proc glGetFramebufferAttachmentParameterivEXT(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetFramebufferAttachmentParameterivEXT(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glSampleMaskSGIS(value: TGLclampf, invert: TGLboolean) {.importc.} proc glGetPointerIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr pointer) {.importc.} proc glVertexStream4iATI(stream: TGLenum, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} proc glUnlockArraysEXT() {.importc.} - proc glReplacementCodeuivSUN(code: TGLuint) {.importc.} + proc glReplacementCodeuivSUN(code: ptr TGLuint) {.importc.} proc glMatrixScaledEXT(mode: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} proc glMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glFeedbackBufferxOES(n: TGLsizei, `type`: TGLenum, buffer: TGLfixed) {.importc.} + proc glFeedbackBufferxOES(n: TGLsizei, `type`: TGLenum, buffer: ptr TGLfixed) {.importc.} proc glLightEnviSGIX(pname: TGLenum, param: TGLint) {.importc.} proc glMultiTexCoord4dARB(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc.} - proc glExtGetTexLevelParameterivQCOM(texture: TGLuint, face: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc.} - proc glVertexAttribI4usvEXT(index: TGLuint, v: TGLushort) {.importc.} - proc glWindowPos2dvARB(v: TGLdouble) {.importc.} + proc glExtGetTexLevelParameterivQCOM(texture: TGLuint, face: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glVertexAttribI4usvEXT(index: TGLuint, v: ptr TGLushort) {.importc.} + proc glWindowPos2dvARB(v: ptr TGLdouble) {.importc.} proc glBindFramebuffer(target: TGLenum, framebuffer: TGLuint) {.importc.} - proc glGetProgramPipelineivEXT(pipeline: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glProgramUniformHandleui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, values: TGLuint64) {.importc.} - proc glFogCoordhvNV(fog: TGLhalfNV) {.importc.} + proc glGetProgramPipelineivEXT(pipeline: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glProgramUniformHandleui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, values: ptr TGLuint64) {.importc.} + proc glFogCoordhvNV(fog: ptr TGLhalfNV) {.importc.} proc glTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetActiveAtomicCounterBufferiv(program: TGLuint, bufferIndex: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetActiveAtomicCounterBufferiv(program: TGLuint, bufferIndex: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glBeginQueryARB(target: TGLenum, id: TGLuint) {.importc.} - proc glGetTexParameterIuivEXT(target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} - proc glUniform4ui64vNV(location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glGetTexParameterIuivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} + proc glUniform4ui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} proc glClearAccumxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} proc glFreeObjectBufferATI(buffer: TGLuint) {.importc.} - proc glGetVideouivNV(video_slot: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glGetVideouivNV(video_slot: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} proc glVertexAttribL4ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc.} - proc glGetUniformBlockIndex(program: TGLuint, uniformBlockName: TGLchar): TGLuint {.importc.} + proc glGetUniformBlockIndex(program: TGLuint, uniformBlockName: ptr TGLchar): TGLuint {.importc.} proc glCopyMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glVertex3bvOES(coords: TGLbyte) {.importc.} - proc glMultiDrawElementArrayAPPLE(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glVertex3bvOES(coords: ptr TGLbyte) {.importc.} + proc glMultiDrawElementArrayAPPLE(mode: TGLenum, first: ptr TGLint, count: ptr TGLsizei, primcount: TGLsizei) {.importc.} proc glPrimitiveRestartNV() {.importc.} proc glMateriali(face: TGLenum, pname: TGLenum, param: TGLint) {.importc.} proc glBegin(mode: TGLenum) {.importc.} proc glFogCoordPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glTexCoord1sv(v: TGLshort) {.importc.} - proc glVertexAttribI4sv(index: TGLuint, v: TGLshort) {.importc.} + proc glTexCoord1sv(v: ptr TGLshort) {.importc.} + proc glVertexAttribI4sv(index: TGLuint, v: ptr TGLshort) {.importc.} proc glTexEnvx(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glTexParameterIivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glLoadTransposeMatrixfARB(m: TGLfloat) {.importc.} + proc glTexParameterIivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glLoadTransposeMatrixfARB(m: ptr TGLfloat) {.importc.} proc glGetTextureSamplerHandleARB(texture: TGLuint, sampler: TGLuint): TGLuint64 {.importc.} - proc glVertexP3uiv(`type`: TGLenum, value: TGLuint) {.importc.} - proc glProgramUniform2dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} - proc glTexCoord4xvOES(coords: TGLfixed) {.importc.} + proc glVertexP3uiv(`type`: TGLenum, value: ptr TGLuint) {.importc.} + proc glProgramUniform2dv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} + proc glTexCoord4xvOES(coords: ptr TGLfixed) {.importc.} proc glTexStorage1D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc.} proc glTextureParameterfEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} proc glVertexAttrib1d(index: TGLuint, x: TGLdouble) {.importc.} - proc glGetnPixelMapfvARB(map: TGLenum, bufSize: TGLsizei, values: TGLfloat) {.importc.} + proc glGetnPixelMapfvARB(map: TGLenum, bufSize: TGLsizei, values: ptr TGLfloat) {.importc.} proc glDisableVertexAttribArray(index: TGLuint) {.importc.} - proc glUniformMatrix4x3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glUniformMatrix4x3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glRasterPos4f(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} proc glProgramUniform1fEXT(program: TGLuint, location: TGLint, v0: TGLfloat) {.importc.} - proc glPathTexGenNV(texCoordSet: TGLenum, genMode: TGLenum, components: TGLint, coeffs: TGLfloat) {.importc.} + proc glPathTexGenNV(texCoordSet: TGLenum, genMode: TGLenum, components: TGLint, coeffs: ptr TGLfloat) {.importc.} proc glUniform3ui(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} - proc glVDPAURegisterOutputSurfaceNV(vdpSurface: pointer, target: TGLenum, numTextureNames: TGLsizei, textureNames: TGLuint): TGLvdpauSurfaceNV {.importc.} - proc glGetProgramLocalParameterIuivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glVDPAURegisterOutputSurfaceNV(vdpSurface: pointer, target: TGLenum, numTextureNames: TGLsizei, textureNames: ptr TGLuint): TGLvdpauSurfaceNV {.importc.} + proc glGetProgramLocalParameterIuivNV(target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} proc glIsTextureHandleResidentNV(handle: TGLuint64): TGLboolean {.importc.} - proc glProgramEnvParameters4fvEXT(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLfloat) {.importc.} + proc glProgramEnvParameters4fvEXT(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLfloat) {.importc.} proc glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glGetMultiTexEnvivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGetFloatv(pname: TGLenum, params: TGLfloat) {.importc.} - proc glInsertEventMarkerEXT(length: TGLsizei, marker: TGLchar) {.importc.} + proc glGetMultiTexEnvivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetFloatv(pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glInsertEventMarkerEXT(length: TGLsizei, marker: ptr TGLchar) {.importc.} proc glRasterPos3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} proc glNamedFramebufferRenderbufferEXT(framebuffer: TGLuint, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} proc glGetConvolutionFilter(target: TGLenum, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} proc glIsOcclusionQueryNV(id: TGLuint): TGLboolean {.importc.} - proc glGetnPixelMapuivARB(map: TGLenum, bufSize: TGLsizei, values: TGLuint) {.importc.} - proc glMapParameterfvNV(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glPushDebugGroup(source: TGLenum, id: TGLuint, length: TGLsizei, message: TGLchar) {.importc.} + proc glGetnPixelMapuivARB(map: TGLenum, bufSize: TGLsizei, values: ptr TGLuint) {.importc.} + proc glMapParameterfvNV(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glPushDebugGroup(source: TGLenum, id: TGLuint, length: TGLsizei, message: ptr TGLchar) {.importc.} proc glMakeImageHandleResidentARB(handle: TGLuint64, access: TGLenum) {.importc.} - proc glProgramUniformMatrix2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glUniform3i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glProgramUniformMatrix2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glUniform3i64vNV(location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} proc glImageTransformParameteriHP(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} proc glMultiTexCoord1s(target: TGLenum, s: TGLshort) {.importc.} - proc glVertexAttribL4dvEXT(index: TGLuint, v: TGLdouble) {.importc.} - proc glGetProgramEnvParameterfvARB(target: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} + proc glVertexAttribL4dvEXT(index: TGLuint, v: ptr TGLdouble) {.importc.} + proc glGetProgramEnvParameterfvARB(target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} proc glVertexArrayColorOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glGetHistogramParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGetRenderbufferParameterivOES(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetHistogramParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetRenderbufferParameterivOES(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glGetBufferPointerv(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} proc glSecondaryColor3ui(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc.} - proc glGetDebugMessageLog(count: TGLuint, bufsize: TGLsizei, sources: TGLenum, types: TGLenum, ids: TGLuint, severities: TGLenum, lengths: TGLsizei, messageLog: TGLchar): TGLuint {.importc.} + proc glGetDebugMessageLog(count: TGLuint, bufsize: TGLsizei, sources: ptr TGLenum, types: ptr TGLenum, ids: ptr TGLuint, severities: ptr TGLenum, lengths: ptr TGLsizei, messageLog: ptr TGLchar): TGLuint {.importc.} proc glNormal3i(nx: TGLint, ny: TGLint, nz: TGLint) {.importc.} proc glTestFenceNV(fence: TGLuint): TGLboolean {.importc.} - proc glSecondaryColor3usv(v: TGLushort) {.importc.} + proc glSecondaryColor3usv(v: ptr TGLushort) {.importc.} proc glGenPathsNV(range: TGLsizei): TGLuint {.importc.} - proc glDeleteBuffersARB(n: TGLsizei, buffers: TGLuint) {.importc.} - proc glProgramUniform4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glGetSharpenTexFuncSGIS(target: TGLenum, points: TGLfloat) {.importc.} + proc glDeleteBuffersARB(n: TGLsizei, buffers: ptr TGLuint) {.importc.} + proc glProgramUniform4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glGetSharpenTexFuncSGIS(target: TGLenum, points: ptr TGLfloat) {.importc.} proc glDrawMeshArraysSUN(mode: TGLenum, first: TGLint, count: TGLsizei, width: TGLsizei) {.importc.} - proc glVertexAttribs4hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc.} - proc glGetClipPlane(plane: TGLenum, equation: TGLdouble) {.importc.} - proc glEvalCoord2fv(u: TGLfloat) {.importc.} + proc glVertexAttribs4hvNV(index: TGLuint, n: TGLsizei, v: ptr TGLhalfNV) {.importc.} + proc glGetClipPlane(plane: TGLenum, equation: ptr TGLdouble) {.importc.} + proc glEvalCoord2fv(u: ptr TGLfloat) {.importc.} proc glAsyncMarkerSGIX(marker: TGLuint) {.importc.} - proc glGetSynciv(sync: TGLsync, pname: TGLenum, bufSize: TGLsizei, length: TGLsizei, values: TGLint) {.importc.} - proc glGetPathTexGenfvNV(texCoordSet: TGLenum, pname: TGLenum, value: TGLfloat) {.importc.} + proc glGetSynciv(sync: TGLsync, pname: TGLenum, bufSize: TGLsizei, length: ptr TGLsizei, values: ptr TGLint) {.importc.} + proc glGetPathTexGenfvNV(texCoordSet: TGLenum, pname: TGLenum, value: ptr TGLfloat) {.importc.} proc glTexParameterf(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glMultiTexCoord1fvARB(target: TGLenum, v: TGLfloat) {.importc.} + proc glMultiTexCoord1fvARB(target: TGLenum, v: ptr TGLfloat) {.importc.} proc glNormalPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} - proc glFragmentLightfvSGIX(light: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glViewportArrayv(first: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} + proc glFragmentLightfvSGIX(light: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glViewportArrayv(first: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} proc glNormal3fVertex3fSUN(nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glMultiTexCoord2dvARB(target: TGLenum, v: TGLdouble) {.importc.} + proc glMultiTexCoord2dvARB(target: TGLenum, v: ptr TGLdouble) {.importc.} proc glCopyColorSubTable(target: TGLenum, start: TGLsizei, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glTexCoord2hvNV(v: TGLhalfNV) {.importc.} - proc glGetQueryObjectiv(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glTexCoord2hvNV(v: ptr TGLhalfNV) {.importc.} + proc glGetQueryObjectiv(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glColor4hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV, alpha: TGLhalfNV) {.importc.} - proc glProgramUniform2fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glProgramUniform2fv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} proc glMultiTexCoord4hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV, q: TGLhalfNV) {.importc.} - proc glWindowPos2fvMESA(v: TGLfloat) {.importc.} + proc glWindowPos2fvMESA(v: ptr TGLfloat) {.importc.} proc glVertexAttrib3s(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glGetIntegerIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLint) {.importc.} - proc glVertexAttrib4Niv(index: TGLuint, v: TGLint) {.importc.} - proc glProgramLocalParameter4dvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} + proc glGetIntegerIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr TGLint) {.importc.} + proc glVertexAttrib4Niv(index: TGLuint, v: ptr TGLint) {.importc.} + proc glProgramLocalParameter4dvARB(target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} proc glFramebufferTextureLayerEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} proc glVertexAttribI1ui(index: TGLuint, x: TGLuint) {.importc.} - proc glFogCoorddv(coord: TGLdouble) {.importc.} - proc glLightModelxv(pname: TGLenum, param: TGLfixed) {.importc.} - proc glGetCombinerOutputParameterfvNV(stage: TGLenum, portion: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glFogCoorddv(coord: ptr TGLdouble) {.importc.} + proc glLightModelxv(pname: TGLenum, param: ptr TGLfixed) {.importc.} + proc glGetCombinerOutputParameterfvNV(stage: TGLenum, portion: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glFramebufferReadBufferEXT(framebuffer: TGLuint, mode: TGLenum) {.importc.} - proc glGetActiveUniformsiv(program: TGLuint, uniformCount: TGLsizei, uniformIndices: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glGetProgramStringNV(id: TGLuint, pname: TGLenum, program: TGLubyte) {.importc.} + proc glGetActiveUniformsiv(program: TGLuint, uniformCount: TGLsizei, uniformIndices: ptr TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetProgramStringNV(id: TGLuint, pname: TGLenum, program: ptr TGLubyte) {.importc.} proc glCopyConvolutionFilter2D(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} proc glMultiTexCoord3iARB(target: TGLenum, s: TGLint, t: TGLint, r: TGLint) {.importc.} proc glPushName(name: TGLuint) {.importc.} proc glProgramParameter4dNV(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glVertexAttrib4svARB(index: TGLuint, v: TGLshort) {.importc.} - proc glSecondaryColor3iv(v: TGLint) {.importc.} + proc glVertexAttrib4svARB(index: TGLuint, v: ptr TGLshort) {.importc.} + proc glSecondaryColor3iv(v: ptr TGLint) {.importc.} proc glCopyColorSubTableEXT(target: TGLenum, start: TGLsizei, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} proc glCallList(list: TGLuint) {.importc.} - proc glGetMultiTexLevelParameterivEXT(texunit: TGLenum, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc.} - proc glProgramUniformMatrix2x4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} - proc glTexBumpParameterivATI(pname: TGLenum, param: TGLint) {.importc.} + proc glGetMultiTexLevelParameterivEXT(texunit: TGLenum, target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glProgramUniformMatrix2x4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} + proc glTexBumpParameterivATI(pname: TGLenum, param: ptr TGLint) {.importc.} proc glTexGeni(coord: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glSecondaryColor3dv(v: TGLdouble) {.importc.} - proc glGetnUniformdvARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: TGLdouble) {.importc.} - proc glGetNamedProgramLocalParameterdvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} + proc glSecondaryColor3dv(v: ptr TGLdouble) {.importc.} + proc glGetnUniformdvARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLdouble) {.importc.} + proc glGetNamedProgramLocalParameterdvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} proc glGetVertexAttribPointervARB(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc.} proc glCopyColorTable(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} proc glNamedFramebufferTextureLayerEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} - proc glLoadProgramNV(target: TGLenum, id: TGLuint, len: TGLsizei, program: TGLubyte) {.importc.} + proc glLoadProgramNV(target: TGLenum, id: TGLuint, len: TGLsizei, program: ptr TGLubyte) {.importc.} proc glAlphaFragmentOp2ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint) {.importc.} proc glBindLightParameterEXT(light: TGLenum, value: TGLenum): TGLuint {.importc.} - proc glVertexAttrib1fv(index: TGLuint, v: TGLfloat) {.importc.} + proc glVertexAttrib1fv(index: TGLuint, v: ptr TGLfloat) {.importc.} proc glLoadIdentity() {.importc.} proc glFramebufferTexture2DMultisampleEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, samples: TGLsizei) {.importc.} - proc glVertexAttrib1dvARB(index: TGLuint, v: TGLdouble) {.importc.} + proc glVertexAttrib1dvARB(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glDrawRangeElementsBaseVertex(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer, basevertex: TGLint) {.importc.} - proc glPixelMapfv(map: TGLenum, mapsize: TGLsizei, values: TGLfloat) {.importc.} + proc glPixelMapfv(map: TGLenum, mapsize: TGLsizei, values: ptr TGLfloat) {.importc.} proc glPointParameterxOES(pname: TGLenum, param: TGLfixed) {.importc.} proc glBindBufferRangeNV(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} proc glDepthBoundsEXT(zmin: TGLclampd, zmax: TGLclampd) {.importc.} - proc glProgramUniformMatrix2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glProgramUniformMatrix2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glSecondaryColor3s(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc.} - proc glEdgeFlagPointerEXT(stride: TGLsizei, count: TGLsizei, `pointer`: TGLboolean) {.importc.} + proc glEdgeFlagPointerEXT(stride: TGLsizei, count: TGLsizei, `pointer`: ptr TGLboolean) {.importc.} proc glVertexStream1fATI(stream: TGLenum, x: TGLfloat) {.importc.} proc glUniformui64NV(location: TGLint, value: TGLuint64EXT) {.importc.} - proc glTexCoordP4uiv(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glTexCoordP4uiv(`type`: TGLenum, coords: ptr TGLuint) {.importc.} proc glTexCoord3d(s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc.} - proc glDeleteProgramPipelines(n: TGLsizei, pipelines: TGLuint) {.importc.} - proc glVertex2iv(v: TGLint) {.importc.} - proc glGetMultisamplefv(pname: TGLenum, index: TGLuint, val: TGLfloat) {.importc.} + proc glDeleteProgramPipelines(n: TGLsizei, pipelines: ptr TGLuint) {.importc.} + proc glVertex2iv(v: ptr TGLint) {.importc.} + proc glGetMultisamplefv(pname: TGLenum, index: TGLuint, val: ptr TGLfloat) {.importc.} proc glStartInstrumentsSGIX() {.importc.} - proc glGetOcclusionQueryivNV(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glDebugMessageCallback(callback: TGLDEBUGPROC, userParam: pointer) {.importc.} + proc glGetOcclusionQueryivNV(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glDebugMessageCallback(callback: TGLDEBUGPROC, userParam: ptr pointer) {.importc.} proc glPixelZoomxOES(xfactor: TGLfixed, yfactor: TGLfixed) {.importc.} proc glTexCoord3i(s: TGLint, t: TGLint, r: TGLint) {.importc.} proc glEdgeFlagFormatNV(stride: TGLsizei) {.importc.} @@ -2181,848 +2181,848 @@ wrapErrorChecking: proc glDepthRangefOES(n: TGLclampf, f: TGLclampf) {.importc.} proc glEndVertexShaderEXT() {.importc.} proc glBindVertexArrayAPPLE(`array`: TGLuint) {.importc.} - proc glColor4bv(v: TGLbyte) {.importc.} + proc glColor4bv(v: ptr TGLbyte) {.importc.} proc glNamedFramebufferTexture2DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} proc glTexCoord1f(s: TGLfloat) {.importc.} - proc glUniform3fvARB(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glGetQueryObjectuivARB(id: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} - proc glVertexAttrib4bv(index: TGLuint, v: TGLbyte) {.importc.} - proc glGetPixelTransformParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glVertexAttrib3svNV(index: TGLuint, v: TGLshort) {.importc.} - proc glDeleteQueriesEXT(n: TGLsizei, ids: TGLuint) {.importc.} - proc glUniform3ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} - proc glNormal3xvOES(coords: TGLfixed) {.importc.} - proc glMatrixLoadfEXT(mode: TGLenum, m: TGLfloat) {.importc.} - proc glGetNamedFramebufferAttachmentParameterivEXT(framebuffer: TGLuint, attachment: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glUniform3fvARB(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glGetQueryObjectuivARB(id: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} + proc glVertexAttrib4bv(index: TGLuint, v: ptr TGLbyte) {.importc.} + proc glGetPixelTransformParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glVertexAttrib3svNV(index: TGLuint, v: ptr TGLshort) {.importc.} + proc glDeleteQueriesEXT(n: TGLsizei, ids: ptr TGLuint) {.importc.} + proc glUniform3ivARB(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} + proc glNormal3xvOES(coords: ptr TGLfixed) {.importc.} + proc glMatrixLoadfEXT(mode: TGLenum, m: ptr TGLfloat) {.importc.} + proc glGetNamedFramebufferAttachmentParameterivEXT(framebuffer: TGLuint, attachment: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glSeparableFilter2D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer) {.importc.} - proc glVertexAttribI3uiv(index: TGLuint, v: TGLuint) {.importc.} + proc glVertexAttribI3uiv(index: TGLuint, v: ptr TGLuint) {.importc.} proc glTextureStorageSparseAMD(texture: TGLuint, target: TGLenum, internalFormat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, layers: TGLsizei, flags: TGLbitfield) {.importc.} proc glMultiDrawArraysIndirectCountARB(mode: TGLenum, indirect: TGLintptr, drawcount: TGLintptr, maxdrawcount: TGLsizei, stride: TGLsizei) {.importc.} proc glTranslated(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} proc glColorPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glDrawElementsInstancedBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei, basevertex: TGLint) {.importc.} - proc glBindAttribLocationARB(programObj: TGLhandleARB, index: TGLuint, name: TGLcharARB) {.importc.} - proc glTexGendv(coord: TGLenum, pname: TGLenum, params: TGLdouble) {.importc.} - proc glGetPathCoordsNV(path: TGLuint, coords: TGLfloat) {.importc.} - proc glGetMapParameterivNV(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glBindAttribLocationARB(programObj: TGLhandleARB, index: TGLuint, name: ptr TGLcharARB) {.importc.} + proc glTexGendv(coord: TGLenum, pname: TGLenum, params: ptr TGLdouble) {.importc.} + proc glGetPathCoordsNV(path: TGLuint, coords: ptr TGLfloat) {.importc.} + proc glGetMapParameterivNV(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glClientAttribDefaultEXT(mask: TGLbitfield) {.importc.} - proc glProgramUniformMatrix4x3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glProgramUniformMatrix4x3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glEnable(cap: TGLenum) {.importc.} proc glGetVertexAttribPointervNV(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc.} proc glBindMultiTextureEXT(texunit: TGLenum, target: TGLenum, texture: TGLuint) {.importc.} - proc glGetConvolutionParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glLightModelxvOES(pname: TGLenum, param: TGLfixed) {.importc.} - proc glMultiTexCoord4sv(target: TGLenum, v: TGLshort) {.importc.} - proc glGetColorTableParameterivSGI(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetConvolutionParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glLightModelxvOES(pname: TGLenum, param: ptr TGLfixed) {.importc.} + proc glMultiTexCoord4sv(target: TGLenum, v: ptr TGLshort) {.importc.} + proc glGetColorTableParameterivSGI(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glFramebufferTexture2DOES(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} proc glClearDepthxOES(depth: TGLfixed) {.importc.} proc glDisableClientStateiEXT(`array`: TGLenum, index: TGLuint) {.importc.} proc glWindowPos2dARB(x: TGLdouble, y: TGLdouble) {.importc.} - proc glVertexAttrib1fvNV(index: TGLuint, v: TGLfloat) {.importc.} + proc glVertexAttrib1fvNV(index: TGLuint, v: ptr TGLfloat) {.importc.} proc glDepthRangedNV(zNear: TGLdouble, zFar: TGLdouble) {.importc.} proc glClear(mask: TGLbitfield) {.importc.} proc glUnmapTexture2DINTEL(texture: TGLuint, level: TGLint) {.importc.} proc glSecondaryColor3ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc.} - proc glVertexAttribI4bv(index: TGLuint, v: TGLbyte) {.importc.} + proc glVertexAttribI4bv(index: TGLuint, v: ptr TGLbyte) {.importc.} proc glTexRenderbufferNV(target: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glColor4ubVertex3fvSUN(c: TGLubyte, v: TGLfloat) {.importc.} - proc glVertexAttrib2svNV(index: TGLuint, v: TGLshort) {.importc.} - proc glMultiTexCoord1ivARB(target: TGLenum, v: TGLint) {.importc.} - proc glUniformMatrix3x2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glVertexAttribL3dvEXT(index: TGLuint, v: TGLdouble) {.importc.} + proc glColor4ubVertex3fvSUN(c: ptr TGLubyte, v: ptr TGLfloat) {.importc.} + proc glVertexAttrib2svNV(index: TGLuint, v: ptr TGLshort) {.importc.} + proc glMultiTexCoord1ivARB(target: TGLenum, v: ptr TGLint) {.importc.} + proc glUniformMatrix3x2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glVertexAttribL3dvEXT(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glGetBufferPointervARB(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} - proc glGetMultiTexLevelParameterfvEXT(texunit: TGLenum, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glMultiTexParameterIuivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLuint) {.importc.} - proc glGetShaderSource(shader: TGLuint, bufSize: TGLsizei, length: TGLsizei, source: TGLchar) {.importc.} + proc glGetMultiTexLevelParameterfvEXT(texunit: TGLenum, target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glMultiTexParameterIuivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} + proc glGetShaderSource(shader: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, source: ptr TGLchar) {.importc.} proc glStencilFunc(func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} - proc glVertexAttribI4bvEXT(index: TGLuint, v: TGLbyte) {.importc.} - proc glVertexAttrib4NuivARB(index: TGLuint, v: TGLuint) {.importc.} + proc glVertexAttribI4bvEXT(index: TGLuint, v: ptr TGLbyte) {.importc.} + proc glVertexAttrib4NuivARB(index: TGLuint, v: ptr TGLuint) {.importc.} proc glIsObjectBufferATI(buffer: TGLuint): TGLboolean {.importc.} proc glRasterPos2xOES(x: TGLfixed, y: TGLfixed) {.importc.} proc glIsFenceNV(fence: TGLuint): TGLboolean {.importc.} - proc glGetFramebufferParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glClearBufferfv(buffer: TGLenum, drawbuffer: TGLint, value: TGLfloat) {.importc.} + proc glGetFramebufferParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glClearBufferfv(buffer: TGLenum, drawbuffer: TGLint, value: ptr TGLfloat) {.importc.} proc glClearColorxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} proc glVertexWeightfEXT(weight: TGLfloat) {.importc.} proc glExtIsProgramBinaryQCOM(program: TGLuint): TGLboolean {.importc.} proc glTextureStorage2DMultisampleEXT(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} - proc glGetHistogramParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glGetHistogramParameterxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glVertexAttrib4dNV(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glGetPerfMonitorCounterStringAMD(group: TGLuint, counter: TGLuint, bufSize: TGLsizei, length: TGLsizei, counterString: TGLchar) {.importc.} + proc glGetPerfMonitorCounterStringAMD(group: TGLuint, counter: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, counterString: ptr TGLchar) {.importc.} proc glMultiTexCoord2sARB(target: TGLenum, s: TGLshort, t: TGLshort) {.importc.} - proc glSpriteParameterivSGIX(pname: TGLenum, params: TGLint) {.importc.} + proc glSpriteParameterivSGIX(pname: TGLenum, params: ptr TGLint) {.importc.} proc glCompressedTextureImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} proc glBufferSubData(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} proc glBlendParameteriNV(pname: TGLenum, value: TGLint) {.importc.} - proc glVertexAttrib2fvNV(index: TGLuint, v: TGLfloat) {.importc.} - proc glGetVariantBooleanvEXT(id: TGLuint, value: TGLenum, data: TGLboolean) {.importc.} + proc glVertexAttrib2fvNV(index: TGLuint, v: ptr TGLfloat) {.importc.} + proc glGetVariantBooleanvEXT(id: TGLuint, value: TGLenum, data: ptr TGLboolean) {.importc.} proc glProgramParameteri(program: TGLuint, pname: TGLenum, value: TGLint) {.importc.} - proc glGetLocalConstantIntegervEXT(id: TGLuint, value: TGLenum, data: TGLint) {.importc.} + proc glGetLocalConstantIntegervEXT(id: TGLuint, value: TGLenum, data: ptr TGLint) {.importc.} proc glFragmentMaterialiSGIX(face: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glGetNamedStringivARB(namelen: TGLint, name: TGLchar, pname: TGLenum, params: TGLint) {.importc.} - proc glBinormal3ivEXT(v: TGLint) {.importc.} + proc glGetNamedStringivARB(namelen: TGLint, name: ptr TGLchar, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glBinormal3ivEXT(v: ptr TGLint) {.importc.} proc glCheckFramebufferStatusEXT(target: TGLenum): TGLenum {.importc.} proc glVertexAttrib1fNV(index: TGLuint, x: TGLfloat) {.importc.} proc glNamedRenderbufferStorageEXT(renderbuffer: TGLuint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glPresentFrameKeyedNV(video_slot: TGLuint, minPresentTime: TGLuint64EXT, beginPresentTimeId: TGLuint, presentDurationId: TGLuint, `type`: TGLenum, target0: TGLenum, fill0: TGLuint, key0: TGLuint, target1: TGLenum, fill1: TGLuint, key1: TGLuint) {.importc.} - proc glGetObjectParameterfvARB(obj: TGLhandleARB, pname: TGLenum, params: TGLfloat) {.importc.} - proc glVertex3sv(v: TGLshort) {.importc.} + proc glGetObjectParameterfvARB(obj: TGLhandleARB, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glVertex3sv(v: ptr TGLshort) {.importc.} proc glColor4s(red: TGLshort, green: TGLshort, blue: TGLshort, alpha: TGLshort) {.importc.} - proc glGetQueryObjecti64vEXT(id: TGLuint, pname: TGLenum, params: TGLint64) {.importc.} + proc glGetQueryObjecti64vEXT(id: TGLuint, pname: TGLenum, params: ptr TGLint64) {.importc.} proc glEvalMesh2(mode: TGLenum, i1: TGLint, i2: TGLint, j1: TGLint, j2: TGLint) {.importc.} proc glBeginTransformFeedbackEXT(primitiveMode: TGLenum) {.importc.} proc glBufferAddressRangeNV(pname: TGLenum, index: TGLuint, address: TGLuint64EXT, length: TGLsizeiptr) {.importc.} - proc glPointParameterfvARB(pname: TGLenum, params: TGLfloat) {.importc.} - proc glGetActiveVaryingNV(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLsizei, `type`: TGLenum, name: TGLchar) {.importc.} + proc glPointParameterfvARB(pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glGetActiveVaryingNV(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, size: ptr TGLsizei, `type`: ptr TGLenum, name: ptr TGLchar) {.importc.} proc glIndexMask(mask: TGLuint) {.importc.} proc glVertexAttribBinding(attribindex: TGLuint, bindingindex: TGLuint) {.importc.} - proc glDeleteFencesNV(n: TGLsizei, fences: TGLuint) {.importc.} - proc glVertexAttribI4ubv(index: TGLuint, v: TGLubyte) {.importc.} - proc glPathParameterfvNV(path: TGLuint, pname: TGLenum, value: TGLfloat) {.importc.} + proc glDeleteFencesNV(n: TGLsizei, fences: ptr TGLuint) {.importc.} + proc glVertexAttribI4ubv(index: TGLuint, v: ptr TGLubyte) {.importc.} + proc glPathParameterfvNV(path: TGLuint, pname: TGLenum, value: ptr TGLfloat) {.importc.} proc glVertexStream3fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glVertexAttribs4svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc.} + proc glVertexAttribs4svNV(index: TGLuint, count: TGLsizei, v: ptr TGLshort) {.importc.} proc glVertexAttrib4sNV(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} proc glAlphaFragmentOp3ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint, arg3: TGLuint, arg3Rep: TGLuint, arg3Mod: TGLuint) {.importc.} - proc glGetHistogramParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetHistogramParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glVertexAttribL1ui64NV(index: TGLuint, x: TGLuint64EXT) {.importc.} - proc glVertexAttribs3fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} - proc glMultiTexCoord3ivARB(target: TGLenum, v: TGLint) {.importc.} - proc glClipPlanefOES(plane: TGLenum, equation: TGLfloat) {.importc.} + proc glVertexAttribs3fvNV(index: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} + proc glMultiTexCoord3ivARB(target: TGLenum, v: ptr TGLint) {.importc.} + proc glClipPlanefOES(plane: TGLenum, equation: ptr TGLfloat) {.importc.} proc glVertex3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glVertex3dv(v: TGLdouble) {.importc.} + proc glVertex3dv(v: ptr TGLdouble) {.importc.} proc glWeightPointerOES(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glBindBufferBase(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc.} proc glIndexs(c: TGLshort) {.importc.} proc glTessellationFactorAMD(factor: TGLfloat) {.importc.} proc glColor4ubVertex3fSUN(r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glPauseTransformFeedback() {.importc.} - proc glImageTransformParameterivHP(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glColor3dv(v: TGLdouble) {.importc.} - proc glRasterPos4sv(v: TGLshort) {.importc.} + proc glImageTransformParameterivHP(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glColor3dv(v: ptr TGLdouble) {.importc.} + proc glRasterPos4sv(v: ptr TGLshort) {.importc.} proc glInvalidateTexSubImage(texture: TGLuint, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} - proc glNormalStream3bvATI(stream: TGLenum, coords: TGLbyte) {.importc.} - proc glUniformMatrix2x4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glNormalStream3bvATI(stream: TGLenum, coords: ptr TGLbyte) {.importc.} + proc glUniformMatrix2x4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glMinmax(target: TGLenum, internalformat: TGLenum, sink: TGLboolean) {.importc.} - proc glGetProgramStageiv(program: TGLuint, shadertype: TGLenum, pname: TGLenum, values: TGLint) {.importc.} + proc glGetProgramStageiv(program: TGLuint, shadertype: TGLenum, pname: TGLenum, values: ptr TGLint) {.importc.} proc glScalex(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} proc glTexBufferARB(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} proc glDrawArraysIndirect(mode: TGLenum, indirect: pointer) {.importc.} - proc glMatrixLoadTransposefEXT(mode: TGLenum, m: TGLfloat) {.importc.} + proc glMatrixLoadTransposefEXT(mode: TGLenum, m: ptr TGLfloat) {.importc.} proc glMultiTexCoord2f(target: TGLenum, s: TGLfloat, t: TGLfloat) {.importc.} proc glDrawRangeElements(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc.} proc glVertexAttrib4NubARB(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc.} - proc glMultiTexCoord4xvOES(texture: TGLenum, coords: TGLfixed) {.importc.} + proc glMultiTexCoord4xvOES(texture: TGLenum, coords: ptr TGLfixed) {.importc.} proc glVertexArrayVertexAttribOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glVertexAttribL1i64vNV(index: TGLuint, v: TGLint64EXT) {.importc.} + proc glVertexAttribL1i64vNV(index: TGLuint, v: ptr TGLint64EXT) {.importc.} proc glMapBuffer(target: TGLenum, access: TGLenum) {.importc.} proc glUniform1ui(location: TGLint, v0: TGLuint) {.importc.} - proc glGetPixelMapfv(map: TGLenum, values: TGLfloat) {.importc.} + proc glGetPixelMapfv(map: TGLenum, values: ptr TGLfloat) {.importc.} proc glTexImage2DMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} - proc glUniform2ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glUniform2ivARB(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} proc glVertexAttribI3ui(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint) {.importc.} - proc glGetProgramResourceiv(program: TGLuint, programInterface: TGLenum, index: TGLuint, propCount: TGLsizei, props: TGLenum, bufSize: TGLsizei, length: TGLsizei, params: TGLint) {.importc.} - proc glUniform4iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glGetProgramResourceiv(program: TGLuint, programInterface: TGLenum, index: TGLuint, propCount: TGLsizei, props: ptr TGLenum, bufSize: TGLsizei, length: ptr TGLsizei, params: ptr TGLint) {.importc.} + proc glUniform4iv(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} proc glVertexAttrib3f(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glClientActiveVertexStreamATI(stream: TGLenum) {.importc.} - proc glTexCoord4fColor4fNormal3fVertex4fvSUN(tc: TGLfloat, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} - proc glColor3xvOES(components: TGLfixed) {.importc.} + proc glTexCoord4fColor4fNormal3fVertex4fvSUN(tc: ptr TGLfloat, c: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glColor3xvOES(components: ptr TGLfixed) {.importc.} proc glVertexPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} proc glProgramEnvParameter4dARB(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glGetLocalConstantFloatvEXT(id: TGLuint, value: TGLenum, data: TGLfloat) {.importc.} + proc glGetLocalConstantFloatvEXT(id: TGLuint, value: TGLenum, data: ptr TGLfloat) {.importc.} proc glTexCoordPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} proc glTexCoordPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glSelectPerfMonitorCountersAMD(monitor: TGLuint, enable: TGLboolean, group: TGLuint, numCounters: TGLint, counterList: TGLuint) {.importc.} - proc glVertexStream4svATI(stream: TGLenum, coords: TGLshort) {.importc.} + proc glSelectPerfMonitorCountersAMD(monitor: TGLuint, enable: TGLboolean, group: TGLuint, numCounters: TGLint, counterList: ptr TGLuint) {.importc.} + proc glVertexStream4svATI(stream: TGLenum, coords: ptr TGLshort) {.importc.} proc glColor3ui(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc.} proc glBindTransformFeedbackNV(target: TGLenum, id: TGLuint) {.importc.} proc glDeformSGIX(mask: TGLbitfield) {.importc.} - proc glDeformationMap3fSGIX(target: TGLenum, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, w1: TGLfloat, w2: TGLfloat, wstride: TGLint, worder: TGLint, points: TGLfloat) {.importc.} + proc glDeformationMap3fSGIX(target: TGLenum, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, w1: TGLfloat, w2: TGLfloat, wstride: TGLint, worder: TGLint, points: ptr TGLfloat) {.importc.} proc glNamedBufferSubDataEXT(buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} proc glGetNamedProgramStringEXT(program: TGLuint, target: TGLenum, pname: TGLenum, string: pointer) {.importc.} proc glCopyPathNV(resultPath: TGLuint, srcPath: TGLuint) {.importc.} proc glMapControlPointsNV(target: TGLenum, index: TGLuint, `type`: TGLenum, ustride: TGLsizei, vstride: TGLsizei, uorder: TGLint, vorder: TGLint, packed: TGLboolean, points: pointer) {.importc.} - proc glGetBufferParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetBufferParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glUnmapObjectBufferATI(buffer: TGLuint) {.importc.} - proc glGetProgramResourceLocation(program: TGLuint, programInterface: TGLenum, name: TGLchar): TGLint {.importc.} - proc glUniform4i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glGetProgramResourceLocation(program: TGLuint, programInterface: TGLenum, name: ptr TGLchar): TGLint {.importc.} + proc glUniform4i64vNV(location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} proc glImageTransformParameterfHP(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} proc glArrayObjectATI(`array`: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc.} proc glBindBufferRangeEXT(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} proc glVertexArrayVertexAttribFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, relativeoffset: TGLuint) {.importc.} proc glBindRenderbufferEXT(target: TGLenum, renderbuffer: TGLuint) {.importc.} proc glListParameteriSGIX(list: TGLuint, pname: TGLenum, param: TGLint) {.importc.} - proc glProgramUniformMatrix2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glProgramUniform2i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} - proc glObjectPtrLabelKHR(`ptr`: pointer, length: TGLsizei, label: TGLchar) {.importc.} + proc glProgramUniformMatrix2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glProgramUniform2i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} + proc glObjectPtrLabelKHR(`ptr`: ptr pointer, length: TGLsizei, label: ptr TGLchar) {.importc.} proc glVertexAttribL1i64NV(index: TGLuint, x: TGLint64EXT) {.importc.} proc glMultiTexBufferEXT(texunit: TGLenum, target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} - proc glCoverFillPathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, coverMode: TGLenum, transformType: TGLenum, transformValues: TGLfloat) {.importc.} - proc glGetVertexAttribIivEXT(index: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glCoverFillPathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, coverMode: TGLenum, transformType: TGLenum, transformValues: ptr TGLfloat) {.importc.} + proc glGetVertexAttribIivEXT(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glLightf(light: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glGetMinmaxParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetMinmaxParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glUniform1d(location: TGLint, x: TGLdouble) {.importc.} - proc glLightiv(light: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glVertexAttrib2dvNV(index: TGLuint, v: TGLdouble) {.importc.} + proc glLightiv(light: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glVertexAttrib2dvNV(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glNormalP3ui(`type`: TGLenum, coords: TGLuint) {.importc.} proc glFinalCombinerInputNV(variable: TGLenum, input: TGLenum, mapping: TGLenum, componentUsage: TGLenum) {.importc.} - proc glUniform1uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glUniform1uiv(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} proc glValidateProgramARB(programObj: TGLhandleARB) {.importc.} proc glNormalPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glProgramNamedParameter4fvNV(id: TGLuint, len: TGLsizei, name: TGLubyte, v: TGLfloat) {.importc.} - proc glGetBooleanv(pname: TGLenum, params: TGLboolean) {.importc.} - proc glTangent3ivEXT(v: TGLint) {.importc.} + proc glProgramNamedParameter4fvNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, v: ptr TGLfloat) {.importc.} + proc glGetBooleanv(pname: TGLenum, params: ptr TGLboolean) {.importc.} + proc glTangent3ivEXT(v: ptr TGLint) {.importc.} proc glTexImage3DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} - proc glGetUniformIndices(program: TGLuint, uniformCount: TGLsizei, uniformNames: ptr TGLchar, uniformIndices: TGLuint) {.importc.} + proc glGetUniformIndices(program: TGLuint, uniformCount: TGLsizei, uniformNames: ptr ptr TGLchar, uniformIndices: ptr TGLuint) {.importc.} proc glVDPAUInitNV(vdpDevice: pointer, getProcAddress: pointer) {.importc.} - proc glGetMinmaxParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glMultiTexCoord2fvARB(target: TGLenum, v: TGLfloat) {.importc.} - proc glProgramEnvParametersI4ivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLint) {.importc.} - proc glClearTexSubImage(texture: TGLuint, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} + proc glGetMinmaxParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glMultiTexCoord2fvARB(target: TGLenum, v: ptr TGLfloat) {.importc.} + proc glProgramEnvParametersI4ivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLint) {.importc.} + proc glClearTexSubImage(texture: TGLuint, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, data: ptr pointer) {.importc.} proc glRectxOES(x1: TGLfixed, y1: TGLfixed, x2: TGLfixed, y2: TGLfixed) {.importc.} proc glBlendEquationOES(mode: TGLenum) {.importc.} proc glFramebufferTexture(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} proc glGetInstrumentsSGIX(): TGLint {.importc.} proc glFramebufferParameteri(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} proc glPathCoverDepthFuncNV(func: TGLenum) {.importc.} - proc glGetTranslatedShaderSourceANGLE(shader: TGLuint, bufsize: TGLsizei, length: TGLsizei, source: TGLchar) {.importc.} - proc glIndexfv(c: TGLfloat) {.importc.} - proc glGetActiveUniformBlockName(program: TGLuint, uniformBlockIndex: TGLuint, bufSize: TGLsizei, length: TGLsizei, uniformBlockName: TGLchar) {.importc.} + proc glGetTranslatedShaderSourceANGLE(shader: TGLuint, bufsize: TGLsizei, length: ptr TGLsizei, source: ptr TGLchar) {.importc.} + proc glIndexfv(c: ptr TGLfloat) {.importc.} + proc glGetActiveUniformBlockName(program: TGLuint, uniformBlockIndex: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, uniformBlockName: ptr TGLchar) {.importc.} proc glNormal3s(nx: TGLshort, ny: TGLshort, nz: TGLshort) {.importc.} proc glColorFragmentOp3ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint, arg3: TGLuint, arg3Rep: TGLuint, arg3Mod: TGLuint) {.importc.} - proc glGetProgramResourceLocationIndex(program: TGLuint, programInterface: TGLenum, name: TGLchar): TGLint {.importc.} - proc glGetBooleanIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLboolean) {.importc.} - proc glGenPerfMonitorsAMD(n: TGLsizei, monitors: TGLuint) {.importc.} + proc glGetProgramResourceLocationIndex(program: TGLuint, programInterface: TGLenum, name: ptr TGLchar): TGLint {.importc.} + proc glGetBooleanIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr TGLboolean) {.importc.} + proc glGenPerfMonitorsAMD(n: TGLsizei, monitors: ptr TGLuint) {.importc.} proc glDrawRangeElementsEXT(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc.} proc glFramebufferTexture3D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} - proc glGetTexParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glCompileShaderIncludeARB(shader: TGLuint, count: TGLsizei, path: ptr TGLchar, length: TGLint) {.importc.} - proc glGetMultiTexParameterfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetTexParameterxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glCompileShaderIncludeARB(shader: TGLuint, count: TGLsizei, path: ptr ptr TGLchar, length: ptr TGLint) {.importc.} + proc glGetMultiTexParameterfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glEvalPoint2(i: TGLint, j: TGLint) {.importc.} - proc glGetProgramivNV(id: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetProgramivNV(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glProgramParameter4fNV(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glMultiTexParameterfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glVertexAttrib3svARB(index: TGLuint, v: TGLshort) {.importc.} + proc glMultiTexParameterfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glVertexAttrib3svARB(index: TGLuint, v: ptr TGLshort) {.importc.} proc glDrawElementArrayAPPLE(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc.} proc glMultiTexCoord4x(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc.} - proc glUniformMatrix3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glUniformMatrix3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glVertexAttribPointerARB(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glProgramUniformMatrix3x4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glGetFloati_vEXT(pname: TGLenum, index: TGLuint, params: TGLfloat) {.importc.} - proc glGetObjectParameterivAPPLE(objectType: TGLenum, name: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glPushGroupMarkerEXT(length: TGLsizei, marker: TGLchar) {.importc.} - proc glProgramUniform4uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glProgramUniformMatrix3x4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glGetFloati_vEXT(pname: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} + proc glGetObjectParameterivAPPLE(objectType: TGLenum, name: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glPushGroupMarkerEXT(length: TGLsizei, marker: ptr TGLchar) {.importc.} + proc glProgramUniform4uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} proc glReplacementCodeuiVertex3fSUN(rc: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glTexSubImage1DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glProgramUniform1uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} - proc glGetFenceivNV(fence: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramUniform1uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} + proc glGetFenceivNV(fence: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glGetnCompressedTexImageARB(target: TGLenum, lod: TGLint, bufSize: TGLsizei, img: pointer) {.importc.} proc glTexGenfOES(coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glVertexAttrib4dv(index: TGLuint, v: TGLdouble) {.importc.} - proc glVertexAttribL1ui64vNV(index: TGLuint, v: TGLuint64EXT) {.importc.} - proc glVertexAttrib4fvARB(index: TGLuint, v: TGLfloat) {.importc.} - proc glDeleteVertexArraysOES(n: TGLsizei, arrays: TGLuint) {.importc.} - proc glSamplerParameterIiv(sampler: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glVertexAttrib4dv(index: TGLuint, v: ptr TGLdouble) {.importc.} + proc glVertexAttribL1ui64vNV(index: TGLuint, v: ptr TGLuint64EXT) {.importc.} + proc glVertexAttrib4fvARB(index: TGLuint, v: ptr TGLfloat) {.importc.} + proc glDeleteVertexArraysOES(n: TGLsizei, arrays: ptr TGLuint) {.importc.} + proc glSamplerParameterIiv(sampler: TGLuint, pname: TGLenum, param: ptr TGLint) {.importc.} proc glMapGrid1d(un: TGLint, u1: TGLdouble, u2: TGLdouble) {.importc.} proc glTranslatexOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} proc glCullFace(mode: TGLenum) {.importc.} - proc glPrioritizeTextures(n: TGLsizei, textures: TGLuint, priorities: TGLfloat) {.importc.} + proc glPrioritizeTextures(n: TGLsizei, textures: ptr TGLuint, priorities: ptr TGLfloat) {.importc.} proc glGetSeparableFilterEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer, span: pointer) {.importc.} - proc glVertexAttrib4NubvARB(index: TGLuint, v: TGLubyte) {.importc.} - proc glGetTransformFeedbackVaryingNV(program: TGLuint, index: TGLuint, location: TGLint) {.importc.} + proc glVertexAttrib4NubvARB(index: TGLuint, v: ptr TGLubyte) {.importc.} + proc glGetTransformFeedbackVaryingNV(program: TGLuint, index: TGLuint, location: ptr TGLint) {.importc.} proc glTexCoord4xOES(s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc.} - proc glGetProgramEnvParameterdvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} - proc glWindowPos2ivMESA(v: TGLint) {.importc.} + proc glGetProgramEnvParameterdvARB(target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} + proc glWindowPos2ivMESA(v: ptr TGLint) {.importc.} proc glGlobalAlphaFactorfSUN(factor: TGLfloat) {.importc.} - proc glNormalStream3fvATI(stream: TGLenum, coords: TGLfloat) {.importc.} + proc glNormalStream3fvATI(stream: TGLenum, coords: ptr TGLfloat) {.importc.} proc glRasterPos4i(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} proc glReleaseShaderCompiler() {.importc.} - proc glProgramUniformMatrix4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glProgramUniformMatrix4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glCopyMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} - proc glColorTableParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glSecondaryColor3bvEXT(v: TGLbyte) {.importc.} + proc glColorTableParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glSecondaryColor3bvEXT(v: ptr TGLbyte) {.importc.} proc glMap1xOES(target: TGLenum, u1: TGLfixed, u2: TGLfixed, stride: TGLint, order: TGLint, points: TGLfixed) {.importc.} - proc glVertexStream1svATI(stream: TGLenum, coords: TGLshort) {.importc.} + proc glVertexStream1svATI(stream: TGLenum, coords: ptr TGLshort) {.importc.} proc glIsRenderbuffer(renderbuffer: TGLuint): TGLboolean {.importc.} - proc glPatchParameterfv(pname: TGLenum, values: TGLfloat) {.importc.} - proc glProgramUniformMatrix4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glPatchParameterfv(pname: TGLenum, values: ptr TGLfloat) {.importc.} + proc glProgramUniformMatrix4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glVertexAttrib4ubNV(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc.} proc glVertex2i(x: TGLint, y: TGLint) {.importc.} proc glPushClientAttrib(mask: TGLbitfield) {.importc.} proc glDrawArraysEXT(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc.} proc glCreateProgram(): TGLuint {.importc.} - proc glPolygonStipple(mask: TGLubyte) {.importc.} + proc glPolygonStipple(mask: ptr TGLubyte) {.importc.} proc glGetColorTableEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} - proc glSharpenTexFuncSGIS(target: TGLenum, n: TGLsizei, points: TGLfloat) {.importc.} + proc glSharpenTexFuncSGIS(target: TGLenum, n: TGLsizei, points: ptr TGLfloat) {.importc.} proc glNamedFramebufferTextureEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glWindowPos3fvMESA(v: TGLfloat) {.importc.} + proc glWindowPos3fvMESA(v: ptr TGLfloat) {.importc.} proc glBinormal3iEXT(bx: TGLint, by: TGLint, bz: TGLint) {.importc.} proc glEnableClientStateiEXT(`array`: TGLenum, index: TGLuint) {.importc.} - proc glProgramUniform3iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glProgramUniform3iv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} proc glProgramUniform1dEXT(program: TGLuint, location: TGLint, x: TGLdouble) {.importc.} - proc glPollInstrumentsSGIX(marker_p: TGLint): TGLint {.importc.} + proc glPollInstrumentsSGIX(marker_p: ptr TGLint): TGLint {.importc.} proc glSecondaryColor3f(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc.} - proc glDeleteTransformFeedbacks(n: TGLsizei, ids: TGLuint) {.importc.} - proc glCoverStrokePathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, coverMode: TGLenum, transformType: TGLenum, transformValues: TGLfloat) {.importc.} + proc glDeleteTransformFeedbacks(n: TGLsizei, ids: ptr TGLuint) {.importc.} + proc glCoverStrokePathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, coverMode: TGLenum, transformType: TGLenum, transformValues: ptr TGLfloat) {.importc.} proc glIsTextureHandleResidentARB(handle: TGLuint64): TGLboolean {.importc.} - proc glVariantsvEXT(id: TGLuint, `addr`: TGLshort) {.importc.} + proc glVariantsvEXT(id: TGLuint, `addr`: ptr TGLshort) {.importc.} proc glTexCoordFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} proc glTexStorage3DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} proc glUniform2ui(location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} proc glReplacementCodePointerSUN(`type`: TGLenum, stride: TGLsizei, `pointer`: ptr pointer) {.importc.} proc glFramebufferTextureLayerARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} - proc glBinormal3dvEXT(v: TGLdouble) {.importc.} - proc glProgramUniform2ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} + proc glBinormal3dvEXT(v: ptr TGLdouble) {.importc.} + proc glProgramUniform2ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} proc glGetnConvolutionFilterARB(target: TGLenum, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, image: pointer) {.importc.} proc glStopInstrumentsSGIX(marker: TGLint) {.importc.} - proc glVertexAttrib1svNV(index: TGLuint, v: TGLshort) {.importc.} - proc glVertexAttribs2fvNV(index: TGLuint, count: TGLsizei, v: TGLfloat) {.importc.} - proc glGetInternalformativ(target: TGLenum, internalformat: TGLenum, pname: TGLenum, bufSize: TGLsizei, params: TGLint) {.importc.} + proc glVertexAttrib1svNV(index: TGLuint, v: ptr TGLshort) {.importc.} + proc glVertexAttribs2fvNV(index: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} + proc glGetInternalformativ(target: TGLenum, internalformat: TGLenum, pname: TGLenum, bufSize: TGLsizei, params: ptr TGLint) {.importc.} proc glIsProgramPipelineEXT(pipeline: TGLuint): TGLboolean {.importc.} - proc glMatrixIndexubvARB(size: TGLint, indices: TGLubyte) {.importc.} + proc glMatrixIndexubvARB(size: TGLint, indices: ptr TGLubyte) {.importc.} proc glTexCoord4bOES(s: TGLbyte, t: TGLbyte, r: TGLbyte, q: TGLbyte) {.importc.} proc glSecondaryColor3us(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc.} proc glGlobalAlphaFactorubSUN(factor: TGLubyte) {.importc.} - proc glNamedStringARB(`type`: TGLenum, namelen: TGLint, name: TGLchar, stringlen: TGLint, string: TGLchar) {.importc.} - proc glGetAttachedShaders(program: TGLuint, maxCount: TGLsizei, count: TGLsizei, shaders: TGLuint) {.importc.} + proc glNamedStringARB(`type`: TGLenum, namelen: TGLint, name: ptr TGLchar, stringlen: TGLint, string: ptr TGLchar) {.importc.} + proc glGetAttachedShaders(program: TGLuint, maxCount: TGLsizei, count: ptr TGLsizei, shaders: ptr TGLuint) {.importc.} proc glMatrixRotatefEXT(mode: TGLenum, angle: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glVertexStream3ivATI(stream: TGLenum, coords: TGLint) {.importc.} - proc glMatrixIndexuivARB(size: TGLint, indices: TGLuint) {.importc.} + proc glVertexStream3ivATI(stream: TGLenum, coords: ptr TGLint) {.importc.} + proc glMatrixIndexuivARB(size: TGLint, indices: ptr TGLuint) {.importc.} proc glMatrixRotatedEXT(mode: TGLenum, angle: TGLdouble, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} proc glPathFogGenNV(genMode: TGLenum) {.importc.} - proc glMultiTexCoord4hvNV(target: TGLenum, v: TGLhalfNV) {.importc.} + proc glMultiTexCoord4hvNV(target: TGLenum, v: ptr TGLhalfNV) {.importc.} proc glVertexAttribIPointer(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glMultiTexCoord3bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte, r: TGLbyte) {.importc.} proc glResizeBuffersMESA() {.importc.} proc glPrimitiveRestartIndexNV(index: TGLuint) {.importc.} proc glProgramUniform4f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} proc glColor4ubVertex2fSUN(r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat) {.importc.} - proc glGetColorTableParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetColorTableParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glDepthRangef(n: TGLfloat, f: TGLfloat) {.importc.} proc glVertexArrayVertexOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glMatrixLoaddEXT(mode: TGLenum, m: TGLdouble) {.importc.} - proc glVariantfvEXT(id: TGLuint, `addr`: TGLfloat) {.importc.} - proc glReplacementCodeuiTexCoord2fVertex3fvSUN(rc: TGLuint, tc: TGLfloat, v: TGLfloat) {.importc.} + proc glMatrixLoaddEXT(mode: TGLenum, m: ptr TGLdouble) {.importc.} + proc glVariantfvEXT(id: TGLuint, `addr`: ptr TGLfloat) {.importc.} + proc glReplacementCodeuiTexCoord2fVertex3fvSUN(rc: ptr TGLuint, tc: ptr TGLfloat, v: ptr TGLfloat) {.importc.} proc glSamplePatternSGIS(pattern: TGLenum) {.importc.} proc glProgramUniform3i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc.} - proc glUniform3uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} - proc glGetImageTransformParameterivHP(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glUniform3uivEXT(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} + proc glGetImageTransformParameterivHP(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glPopMatrix() {.importc.} proc glVertexAttrib3sARB(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glGenQueriesEXT(n: TGLsizei, ids: TGLuint) {.importc.} - proc glGetQueryObjectui64v(id: TGLuint, pname: TGLenum, params: TGLuint64) {.importc.} - proc glWeightusvARB(size: TGLint, weights: TGLushort) {.importc.} + proc glGenQueriesEXT(n: TGLsizei, ids: ptr TGLuint) {.importc.} + proc glGetQueryObjectui64v(id: TGLuint, pname: TGLenum, params: ptr TGLuint64) {.importc.} + proc glWeightusvARB(size: TGLint, weights: ptr TGLushort) {.importc.} proc glWindowPos2sARB(x: TGLshort, y: TGLshort) {.importc.} - proc glGetTextureLevelParameterivEXT(texture: TGLuint, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLint) {.importc.} + proc glGetTextureLevelParameterivEXT(texture: TGLuint, target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glBufferParameteriAPPLE(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glMultiModeDrawArraysIBM(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei, modestride: TGLint) {.importc.} - proc glUniformMatrix2x3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLfloat) {.importc.} + proc glMultiModeDrawArraysIBM(mode: ptr TGLenum, first: ptr TGLint, count: ptr TGLsizei, primcount: TGLsizei, modestride: TGLint) {.importc.} + proc glUniformMatrix2x3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} proc glTangentPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glResetMinmax(target: TGLenum) {.importc.} - proc glVertexAttribP1uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} - proc glPixelMapx(map: TGLenum, size: TGLint, values: TGLfixed) {.importc.} + proc glVertexAttribP1uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: ptr TGLuint) {.importc.} + proc glPixelMapx(map: TGLenum, size: TGLint, values: ptr TGLfixed) {.importc.} proc glPixelStoref(pname: TGLenum, param: TGLfloat) {.importc.} proc glBinormal3dEXT(bx: TGLdouble, by: TGLdouble, bz: TGLdouble) {.importc.} - proc glVertexAttribs1hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc.} - proc glVertexAttrib4usvARB(index: TGLuint, v: TGLushort) {.importc.} + proc glVertexAttribs1hvNV(index: TGLuint, n: TGLsizei, v: ptr TGLhalfNV) {.importc.} + proc glVertexAttrib4usvARB(index: TGLuint, v: ptr TGLushort) {.importc.} proc glUnmapBuffer(target: TGLenum): TGLboolean {.importc.} proc glFlushRasterSGIX() {.importc.} - proc glColor3uiv(v: TGLuint) {.importc.} + proc glColor3uiv(v: ptr TGLuint) {.importc.} proc glInvalidateBufferSubData(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr) {.importc.} proc glPassThroughxOES(token: TGLfixed) {.importc.} proc glLockArraysEXT(first: TGLint, count: TGLsizei) {.importc.} proc glStencilFuncSeparateATI(frontfunc: TGLenum, backfunc: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} - proc glProgramUniform3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} - proc glGenTransformFeedbacks(n: TGLsizei, ids: TGLuint) {.importc.} + proc glProgramUniform3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} + proc glGenTransformFeedbacks(n: TGLsizei, ids: ptr TGLuint) {.importc.} proc glCopyTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} proc glIsNamedBufferResidentNV(buffer: TGLuint): TGLboolean {.importc.} proc glSampleMaskIndexedNV(index: TGLuint, mask: TGLbitfield) {.importc.} proc glVDPAUSurfaceAccessNV(surface: TGLvdpauSurfaceNV, access: TGLenum) {.importc.} - proc glProgramUniform3dv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLdouble) {.importc.} + proc glProgramUniform3dv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} proc glDeleteProgram(program: TGLuint) {.importc.} proc glConvolutionFilter1D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} proc glVertex2f(x: TGLfloat, y: TGLfloat) {.importc.} - proc glWindowPos4dvMESA(v: TGLdouble) {.importc.} + proc glWindowPos4dvMESA(v: ptr TGLdouble) {.importc.} proc glColor4us(red: TGLushort, green: TGLushort, blue: TGLushort, alpha: TGLushort) {.importc.} proc glColorMask(red: TGLboolean, green: TGLboolean, blue: TGLboolean, alpha: TGLboolean) {.importc.} - proc glGetTexEnviv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glProgramUniform3ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glGetTexEnviv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glProgramUniform3ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} proc glSecondaryColor3i(red: TGLint, green: TGLint, blue: TGLint) {.importc.} - proc glGetSamplerParameteriv(sampler: TGLuint, pname: TGLenum, params: TGLint) {.importc.} - proc glDeleteFramebuffersEXT(n: TGLsizei, framebuffers: TGLuint) {.importc.} + proc glGetSamplerParameteriv(sampler: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glDeleteFramebuffersEXT(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} proc glCompressedTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} proc glVertex2s(x: TGLshort, y: TGLshort) {.importc.} proc glIsQuery(id: TGLuint): TGLboolean {.importc.} - proc glFogxv(pname: TGLenum, param: TGLfixed) {.importc.} - proc glAreProgramsResidentNV(n: TGLsizei, programs: TGLuint, residences: TGLboolean): TGLboolean {.importc.} - proc glShaderSourceARB(shaderObj: TGLhandleARB, count: TGLsizei, string: ptr TGLcharARB, length: TGLint) {.importc.} + proc glFogxv(pname: TGLenum, param: ptr TGLfixed) {.importc.} + proc glAreProgramsResidentNV(n: TGLsizei, programs: ptr TGLuint, residences: ptr TGLboolean): TGLboolean {.importc.} + proc glShaderSourceARB(shaderObj: TGLhandleARB, count: TGLsizei, string: ptr ptr TGLcharARB, length: ptr TGLint) {.importc.} proc glPointSizexOES(size: TGLfixed) {.importc.} proc glPixelTransferf(pname: TGLenum, param: TGLfloat) {.importc.} proc glExtractComponentEXT(res: TGLuint, src: TGLuint, num: TGLuint) {.importc.} - proc glUniform1fv(location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glGetNamedStringARB(namelen: TGLint, name: TGLchar, bufSize: TGLsizei, stringlen: TGLint, string: TGLchar) {.importc.} - proc glGetProgramBinaryOES(program: TGLuint, bufSize: TGLsizei, length: TGLsizei, binaryFormat: TGLenum, binary: pointer) {.importc.} - proc glDeleteOcclusionQueriesNV(n: TGLsizei, ids: TGLuint) {.importc.} + proc glUniform1fv(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glGetNamedStringARB(namelen: TGLint, name: ptr TGLchar, bufSize: TGLsizei, stringlen: ptr TGLint, string: ptr TGLchar) {.importc.} + proc glGetProgramBinaryOES(program: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, binaryFormat: ptr TGLenum, binary: pointer) {.importc.} + proc glDeleteOcclusionQueriesNV(n: TGLsizei, ids: ptr TGLuint) {.importc.} proc glEnableClientState(`array`: TGLenum) {.importc.} - proc glProgramBufferParametersIuivNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: TGLuint) {.importc.} + proc glProgramBufferParametersIuivNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: ptr TGLuint) {.importc.} proc glProgramUniform2ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} proc glReplacementCodeuiSUN(code: TGLuint) {.importc.} - proc glMultMatrixd(m: TGLdouble) {.importc.} - proc glInvalidateSubFramebuffer(target: TGLenum, numAttachments: TGLsizei, attachments: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} + proc glMultMatrixd(m: ptr TGLdouble) {.importc.} + proc glInvalidateSubFramebuffer(target: TGLenum, numAttachments: TGLsizei, attachments: ptr TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} proc glGenerateMultiTexMipmapEXT(texunit: TGLenum, target: TGLenum) {.importc.} proc glDepthRangex(n: TGLfixed, f: TGLfixed) {.importc.} - proc glGetInteger64i_v(target: TGLenum, index: TGLuint, data: TGLint64) {.importc.} - proc glDrawBuffers(n: TGLsizei, bufs: TGLenum) {.importc.} + proc glGetInteger64i_v(target: TGLenum, index: TGLuint, data: ptr TGLint64) {.importc.} + proc glDrawBuffers(n: TGLsizei, bufs: ptr TGLenum) {.importc.} proc glGetPointervEXT(pname: TGLenum, params: ptr pointer) {.importc.} - proc glFogxvOES(pname: TGLenum, param: TGLfixed) {.importc.} - proc glTexCoordP2uiv(`type`: TGLenum, coords: TGLuint) {.importc.} + proc glFogxvOES(pname: TGLenum, param: ptr TGLfixed) {.importc.} + proc glTexCoordP2uiv(`type`: TGLenum, coords: ptr TGLuint) {.importc.} proc glVertexFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} proc glColorPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glGetMultiTexParameterivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glMultiTexCoordP4uiv(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} + proc glGetMultiTexParameterivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glMultiTexCoordP4uiv(texture: TGLenum, `type`: TGLenum, coords: ptr TGLuint) {.importc.} proc glResetMinmaxEXT(target: TGLenum) {.importc.} proc glCopyBufferSubData(readTarget: TGLenum, writeTarget: TGLenum, readOffset: TGLintptr, writeOffset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glSecondaryColor3sv(v: TGLshort) {.importc.} + proc glSecondaryColor3sv(v: ptr TGLshort) {.importc.} proc glPixelStorex(pname: TGLenum, param: TGLfixed) {.importc.} proc glWaitSync(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64) {.importc.} - proc glVertexAttribI1iv(index: TGLuint, v: TGLint) {.importc.} + proc glVertexAttribI1iv(index: TGLuint, v: ptr TGLint) {.importc.} proc glColorSubTableEXT(target: TGLenum, start: TGLsizei, count: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} - proc glGetDoublev(pname: TGLenum, params: TGLdouble) {.importc.} - proc glMultiTexParameterivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glMultiTexCoord4svARB(target: TGLenum, v: TGLshort) {.importc.} + proc glGetDoublev(pname: TGLenum, params: ptr TGLdouble) {.importc.} + proc glMultiTexParameterivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glMultiTexCoord4svARB(target: TGLenum, v: ptr TGLshort) {.importc.} proc glColorPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} proc glScissorIndexed(index: TGLuint, left: TGLint, bottom: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} proc glStencilOpSeparateATI(face: TGLenum, sfail: TGLenum, dpfail: TGLenum, dppass: TGLenum) {.importc.} proc glLoadName(name: TGLuint) {.importc.} proc glIsTransformFeedbackNV(id: TGLuint): TGLboolean {.importc.} proc glPopDebugGroup() {.importc.} - proc glClipPlanef(p: TGLenum, eqn: TGLfloat) {.importc.} - proc glDeleteFencesAPPLE(n: TGLsizei, fences: TGLuint) {.importc.} - proc glGetQueryObjecti64v(id: TGLuint, pname: TGLenum, params: TGLint64) {.importc.} + proc glClipPlanef(p: TGLenum, eqn: ptr TGLfloat) {.importc.} + proc glDeleteFencesAPPLE(n: TGLsizei, fences: ptr TGLuint) {.importc.} + proc glGetQueryObjecti64v(id: TGLuint, pname: TGLenum, params: ptr TGLint64) {.importc.} proc glAlphaFunc(func: TGLenum, `ref`: TGLfloat) {.importc.} proc glIndexPointerEXT(`type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} - proc glVertexAttribI3ivEXT(index: TGLuint, v: TGLint) {.importc.} + proc glVertexAttribI3ivEXT(index: TGLuint, v: ptr TGLint) {.importc.} proc glIndexub(c: TGLubyte) {.importc.} - proc glVertexP2uiv(`type`: TGLenum, value: TGLuint) {.importc.} - proc glProgramUniform1uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} - proc glDebugMessageInsertKHR(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: TGLchar) {.importc.} + proc glVertexP2uiv(`type`: TGLenum, value: ptr TGLuint) {.importc.} + proc glProgramUniform1uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} + proc glDebugMessageInsertKHR(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: ptr TGLchar) {.importc.} proc glColor4b(red: TGLbyte, green: TGLbyte, blue: TGLbyte, alpha: TGLbyte) {.importc.} proc glRenderbufferStorageMultisampleAPPLE(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glMinSampleShading(value: TGLfloat) {.importc.} proc glBindProgramNV(target: TGLenum, id: TGLuint) {.importc.} proc glWindowPos3dMESA(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} proc glEdgeFlagPointer(stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glGetFragDataIndex(program: TGLuint, name: TGLchar): TGLint {.importc.} + proc glGetFragDataIndex(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} proc glTexCoord3hNV(s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV) {.importc.} proc glMultiDrawArraysIndirectAMD(mode: TGLenum, indirect: pointer, primcount: TGLsizei, stride: TGLsizei) {.importc.} proc glFragmentColorMaterialSGIX(face: TGLenum, mode: TGLenum) {.importc.} proc glTexGenf(coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glVertexAttrib4ubvARB(index: TGLuint, v: TGLubyte) {.importc.} - proc glClearBufferiv(buffer: TGLenum, drawbuffer: TGLint, value: TGLint) {.importc.} - proc glGenQueriesARB(n: TGLsizei, ids: TGLuint) {.importc.} - proc glRectdv(v1: TGLdouble, v2: TGLdouble) {.importc.} + proc glVertexAttrib4ubvARB(index: TGLuint, v: ptr TGLubyte) {.importc.} + proc glClearBufferiv(buffer: TGLenum, drawbuffer: TGLint, value: ptr TGLint) {.importc.} + proc glGenQueriesARB(n: TGLsizei, ids: ptr TGLuint) {.importc.} + proc glRectdv(v1: ptr TGLdouble, v2: ptr TGLdouble) {.importc.} proc glBlendEquationSeparateEXT(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} proc glTestFenceAPPLE(fence: TGLuint): TGLboolean {.importc.} - proc glTexGeniv(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glTexGeniv(coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glPolygonMode(face: TGLenum, mode: TGLenum) {.importc.} proc glFrameZoomSGIX(factor: TGLint) {.importc.} proc glReplacementCodeuiTexCoord2fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glUniformSubroutinesuiv(shadertype: TGLenum, count: TGLsizei, indices: TGLuint) {.importc.} + proc glUniformSubroutinesuiv(shadertype: TGLenum, count: TGLsizei, indices: ptr TGLuint) {.importc.} proc glBeginQueryIndexed(target: TGLenum, index: TGLuint, id: TGLuint) {.importc.} proc glMultiTexGeniEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glRasterPos3fv(v: TGLfloat) {.importc.} + proc glRasterPos3fv(v: ptr TGLfloat) {.importc.} proc glMapObjectBufferATI(buffer: TGLuint) {.importc.} - proc glIndexiv(c: TGLint) {.importc.} + proc glIndexiv(c: ptr TGLint) {.importc.} proc glVertexAttribLPointer(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glMultiTexCoord4s(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc.} - proc glSecondaryColorP3uiv(`type`: TGLenum, color: TGLuint) {.importc.} + proc glSecondaryColorP3uiv(`type`: TGLenum, color: ptr TGLuint) {.importc.} proc glNormalFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc.} proc glVertex4i(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} proc glUniform1ui64NV(location: TGLint, x: TGLuint64EXT) {.importc.} - proc glScissorIndexedv(index: TGLuint, v: TGLint) {.importc.} + proc glScissorIndexedv(index: TGLuint, v: ptr TGLint) {.importc.} proc glProgramUniform1i(program: TGLuint, location: TGLint, v0: TGLint) {.importc.} proc glCompressedMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} proc glFinishTextureSUNX() {.importc.} proc glFramebufferTexture3DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} proc glSetInvariantEXT(id: TGLuint, `type`: TGLenum, `addr`: pointer) {.importc.} - proc glGetTexParameterIivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetTexParameterIivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glMultiTexCoordP3ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} proc glMultiTexCoord3f(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc.} proc glNormalStream3fATI(stream: TGLenum, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat) {.importc.} proc glActiveShaderProgram(pipeline: TGLuint, program: TGLuint) {.importc.} proc glDisableVertexArrayEXT(vaobj: TGLuint, `array`: TGLenum) {.importc.} - proc glVertexAttribI3iv(index: TGLuint, v: TGLint) {.importc.} + proc glVertexAttribI3iv(index: TGLuint, v: ptr TGLint) {.importc.} proc glProvokingVertex(mode: TGLenum) {.importc.} - proc glTexCoord1fv(v: TGLfloat) {.importc.} - proc glVertexAttrib3fv(index: TGLuint, v: TGLfloat) {.importc.} - proc glWindowPos3iv(v: TGLint) {.importc.} + proc glTexCoord1fv(v: ptr TGLfloat) {.importc.} + proc glVertexAttrib3fv(index: TGLuint, v: ptr TGLfloat) {.importc.} + proc glWindowPos3iv(v: ptr TGLint) {.importc.} proc glProgramUniform4ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc.} proc glProgramUniform2d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble) {.importc.} - proc glDebugMessageInsertARB(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: TGLchar) {.importc.} + proc glDebugMessageInsertARB(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: ptr TGLchar) {.importc.} proc glMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glMap1d(target: TGLenum, u1: TGLdouble, u2: TGLdouble, stride: TGLint, order: TGLint, points: TGLdouble) {.importc.} + proc glMap1d(target: TGLenum, u1: TGLdouble, u2: TGLdouble, stride: TGLint, order: TGLint, points: ptr TGLdouble) {.importc.} proc glDeleteShader(shader: TGLuint) {.importc.} proc glTexturePageCommitmentEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, resident: TGLboolean) {.importc.} proc glFramebufferDrawBufferEXT(framebuffer: TGLuint, mode: TGLenum) {.importc.} proc glTexCoord2fNormal3fVertex3fSUN(s: TGLfloat, t: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glDeleteProgramsNV(n: TGLsizei, programs: TGLuint) {.importc.} - proc glPointAlongPathNV(path: TGLuint, startSegment: TGLsizei, numSegments: TGLsizei, distance: TGLfloat, x: TGLfloat, y: TGLfloat, tangentX: TGLfloat, tangentY: TGLfloat): TGLboolean {.importc.} + proc glDeleteProgramsNV(n: TGLsizei, programs: ptr TGLuint) {.importc.} + proc glPointAlongPathNV(path: TGLuint, startSegment: TGLsizei, numSegments: TGLsizei, distance: TGLfloat, x: ptr TGLfloat, y: ptr TGLfloat, tangentX: ptr TGLfloat, tangentY: ptr TGLfloat): TGLboolean {.importc.} proc glTexCoord1d(s: TGLdouble) {.importc.} proc glStencilStrokePathNV(path: TGLuint, reference: TGLint, mask: TGLuint) {.importc.} - proc glQueryMatrixxOES(mantissa: TGLfixed, exponent: TGLint): TGLbitfield {.importc.} - proc glGetNamedProgramLocalParameterIuivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glQueryMatrixxOES(mantissa: ptr TGLfixed, exponent: ptr TGLint): TGLbitfield {.importc.} + proc glGetNamedProgramLocalParameterIuivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} proc glGenerateMipmapOES(target: TGLenum) {.importc.} proc glRenderbufferStorageMultisampleIMG(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glVertexBlendEnviATI(pname: TGLenum, param: TGLint) {.importc.} proc glPushAttrib(mask: TGLbitfield) {.importc.} proc glShaderOp3EXT(op: TGLenum, res: TGLuint, arg1: TGLuint, arg2: TGLuint, arg3: TGLuint) {.importc.} proc glEnableVertexAttribArray(index: TGLuint) {.importc.} - proc glVertexAttrib4Nbv(index: TGLuint, v: TGLbyte) {.importc.} - proc glExtGetBuffersQCOM(buffers: TGLuint, maxBuffers: TGLint, numBuffers: TGLint) {.importc.} + proc glVertexAttrib4Nbv(index: TGLuint, v: ptr TGLbyte) {.importc.} + proc glExtGetBuffersQCOM(buffers: ptr TGLuint, maxBuffers: TGLint, numBuffers: ptr TGLint) {.importc.} proc glCopyTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glDeletePerfMonitorsAMD(n: TGLsizei, monitors: TGLuint) {.importc.} - proc glGetTrackMatrixivNV(target: TGLenum, address: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glDeletePerfMonitorsAMD(n: TGLsizei, monitors: ptr TGLuint) {.importc.} + proc glGetTrackMatrixivNV(target: TGLenum, address: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glEndConditionalRender() {.importc.} proc glVertexAttribL3i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc.} - proc glProgramLocalParametersI4ivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLint) {.importc.} + proc glProgramLocalParametersI4ivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLint) {.importc.} proc glFlush() {.importc.} - proc glGetNamedBufferParameterui64vNV(buffer: TGLuint, pname: TGLenum, params: TGLuint64EXT) {.importc.} - proc glGetVertexArrayIntegeri_vEXT(vaobj: TGLuint, index: TGLuint, pname: TGLenum, param: TGLint) {.importc.} + proc glGetNamedBufferParameterui64vNV(buffer: TGLuint, pname: TGLenum, params: ptr TGLuint64EXT) {.importc.} + proc glGetVertexArrayIntegeri_vEXT(vaobj: TGLuint, index: TGLuint, pname: TGLenum, param: ptr TGLint) {.importc.} proc glReadnPixelsEXT(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, data: pointer) {.importc.} proc glMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetVaryingLocationNV(program: TGLuint, name: TGLchar): TGLint {.importc.} - proc glMultiTexCoord4fvARB(target: TGLenum, v: TGLfloat) {.importc.} - proc glMultiTexCoord3iv(target: TGLenum, v: TGLint) {.importc.} - proc glVertexAttribL2dvEXT(index: TGLuint, v: TGLdouble) {.importc.} + proc glGetVaryingLocationNV(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} + proc glMultiTexCoord4fvARB(target: TGLenum, v: ptr TGLfloat) {.importc.} + proc glMultiTexCoord3iv(target: TGLenum, v: ptr TGLint) {.importc.} + proc glVertexAttribL2dvEXT(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glTexParameterxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glSecondaryColor3uivEXT(v: TGLuint) {.importc.} + proc glSecondaryColor3uivEXT(v: ptr TGLuint) {.importc.} proc glReadnPixelsARB(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, data: pointer) {.importc.} proc glCopyTexSubImage1DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glGetDoublei_vEXT(pname: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} + proc glGetDoublei_vEXT(pname: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} proc glVariantPointerEXT(id: TGLuint, `type`: TGLenum, stride: TGLuint, `addr`: pointer) {.importc.} - proc glProgramUniform3ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLuint64EXT) {.importc.} - proc glTexCoord2fColor3fVertex3fvSUN(tc: TGLfloat, c: TGLfloat, v: TGLfloat) {.importc.} - proc glProgramUniform3fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glBindFragDataLocationIndexed(program: TGLuint, colorNumber: TGLuint, index: TGLuint, name: TGLchar) {.importc.} + proc glProgramUniform3ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} + proc glTexCoord2fColor3fVertex3fvSUN(tc: ptr TGLfloat, c: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glProgramUniform3fv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glBindFragDataLocationIndexed(program: TGLuint, colorNumber: TGLuint, index: TGLuint, name: ptr TGLchar) {.importc.} proc glGetnSeparableFilterARB(target: TGLenum, format: TGLenum, `type`: TGLenum, rowBufSize: TGLsizei, row: pointer, columnBufSize: TGLsizei, column: pointer, span: pointer) {.importc.} proc glTextureParameteriEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glGetUniformuivEXT(program: TGLuint, location: TGLint, params: TGLuint) {.importc.} - proc glFragmentMaterialivSGIX(face: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glMultiTexCoord1svARB(target: TGLenum, v: TGLshort) {.importc.} + proc glGetUniformuivEXT(program: TGLuint, location: TGLint, params: ptr TGLuint) {.importc.} + proc glFragmentMaterialivSGIX(face: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glMultiTexCoord1svARB(target: TGLenum, v: ptr TGLshort) {.importc.} proc glClientActiveTextureARB(texture: TGLenum) {.importc.} proc glVertexAttrib1fARB(index: TGLuint, x: TGLfloat) {.importc.} - proc glVertexAttrib4NbvARB(index: TGLuint, v: TGLbyte) {.importc.} + proc glVertexAttrib4NbvARB(index: TGLuint, v: ptr TGLbyte) {.importc.} proc glRasterPos2d(x: TGLdouble, y: TGLdouble) {.importc.} proc glMultiTexCoord4iARB(target: TGLenum, s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc.} - proc glGetPixelTexGenParameterfvSGIS(pname: TGLenum, params: TGLfloat) {.importc.} - proc glVertexAttribL2dv(index: TGLuint, v: TGLdouble) {.importc.} + proc glGetPixelTexGenParameterfvSGIS(pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glVertexAttribL2dv(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glGetProgramStringARB(target: TGLenum, pname: TGLenum, string: pointer) {.importc.} proc glRasterPos2i(x: TGLint, y: TGLint) {.importc.} - proc glTexCoord2fColor4fNormal3fVertex3fvSUN(tc: TGLfloat, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} + proc glTexCoord2fColor4fNormal3fVertex3fvSUN(tc: ptr TGLfloat, c: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} proc glMultiTexCoord3s(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort) {.importc.} - proc glMultTransposeMatrixd(m: TGLdouble) {.importc.} - proc glActiveVaryingNV(program: TGLuint, name: TGLchar) {.importc.} + proc glMultTransposeMatrixd(m: ptr TGLdouble) {.importc.} + proc glActiveVaryingNV(program: TGLuint, name: ptr TGLchar) {.importc.} proc glProgramUniform1f(program: TGLuint, location: TGLint, v0: TGLfloat) {.importc.} - proc glGetActiveSubroutineName(program: TGLuint, shadertype: TGLenum, index: TGLuint, bufsize: TGLsizei, length: TGLsizei, name: TGLchar) {.importc.} - proc glClipPlanex(plane: TGLenum, equation: TGLfixed) {.importc.} - proc glMultiTexCoord4iv(target: TGLenum, v: TGLint) {.importc.} - proc glTransformFeedbackVaryingsEXT(program: TGLuint, count: TGLsizei, varyings: ptr TGLchar, bufferMode: TGLenum) {.importc.} + proc glGetActiveSubroutineName(program: TGLuint, shadertype: TGLenum, index: TGLuint, bufsize: TGLsizei, length: ptr TGLsizei, name: ptr TGLchar) {.importc.} + proc glClipPlanex(plane: TGLenum, equation: ptr TGLfixed) {.importc.} + proc glMultiTexCoord4iv(target: TGLenum, v: ptr TGLint) {.importc.} + proc glTransformFeedbackVaryingsEXT(program: TGLuint, count: TGLsizei, varyings: ptr ptr TGLchar, bufferMode: TGLenum) {.importc.} proc glBlendEquationSeparateiARB(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} - proc glVertex2sv(v: TGLshort) {.importc.} + proc glVertex2sv(v: ptr TGLshort) {.importc.} proc glAccumxOES(op: TGLenum, value: TGLfixed) {.importc.} proc glProgramLocalParameter4dARB(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} proc glIsRenderbufferEXT(renderbuffer: TGLuint): TGLboolean {.importc.} proc glMultiDrawElementsIndirectAMD(mode: TGLenum, `type`: TGLenum, indirect: pointer, primcount: TGLsizei, stride: TGLsizei) {.importc.} proc glVertexAttribI4uiEXT(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} - proc glVertex4fv(v: TGLfloat) {.importc.} + proc glVertex4fv(v: ptr TGLfloat) {.importc.} proc glGenerateMipmapEXT(target: TGLenum) {.importc.} proc glVertexP3ui(`type`: TGLenum, value: TGLuint) {.importc.} - proc glTexCoord2dv(v: TGLdouble) {.importc.} + proc glTexCoord2dv(v: ptr TGLdouble) {.importc.} proc glFlushMappedBufferRange(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr) {.importc.} proc glTrackMatrixNV(target: TGLenum, address: TGLuint, matrix: TGLenum, transform: TGLenum) {.importc.} proc glFragmentLightModeliSGIX(pname: TGLenum, param: TGLint) {.importc.} - proc glVertexAttrib4Nusv(index: TGLuint, v: TGLushort) {.importc.} + proc glVertexAttrib4Nusv(index: TGLuint, v: ptr TGLushort) {.importc.} proc glScalef(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glLightxvOES(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glTextureParameterivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glLightxvOES(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glTextureParameterivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glCompressedMultiTexImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} proc glVertexAttribL1d(index: TGLuint, x: TGLdouble) {.importc.} proc glVertexAttrib3fARB(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glVertexAttrib3hvNV(index: TGLuint, v: TGLhalfNV) {.importc.} + proc glVertexAttrib3hvNV(index: TGLuint, v: ptr TGLhalfNV) {.importc.} proc glSpriteParameteriSGIX(pname: TGLenum, param: TGLint) {.importc.} proc glFrustumxOES(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} - proc glGetnMapdvARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: TGLdouble) {.importc.} + proc glGetnMapdvARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: ptr TGLdouble) {.importc.} proc glGetMinmaxEXT(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} proc glProgramUniformHandleui64NV(program: TGLuint, location: TGLint, value: TGLuint64) {.importc.} - proc glWindowPos4fvMESA(v: TGLfloat) {.importc.} - proc glExtGetTexturesQCOM(textures: TGLuint, maxTextures: TGLint, numTextures: TGLint) {.importc.} - proc glProgramSubroutineParametersuivNV(target: TGLenum, count: TGLsizei, params: TGLuint) {.importc.} + proc glWindowPos4fvMESA(v: ptr TGLfloat) {.importc.} + proc glExtGetTexturesQCOM(textures: ptr TGLuint, maxTextures: TGLint, numTextures: ptr TGLint) {.importc.} + proc glProgramSubroutineParametersuivNV(target: TGLenum, count: TGLsizei, params: ptr TGLuint) {.importc.} proc glSampleCoveragexOES(value: TGLclampx, invert: TGLboolean) {.importc.} - proc glMultiTexEnvivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGetFinalCombinerInputParameterfvNV(variable: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glLightModeliv(pname: TGLenum, params: TGLint) {.importc.} + proc glMultiTexEnvivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetFinalCombinerInputParameterfvNV(variable: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glLightModeliv(pname: TGLenum, params: ptr TGLint) {.importc.} proc glUniform4f(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} proc glDepthRange(near: TGLdouble, far: TGLdouble) {.importc.} - proc glProgramUniformMatrix4x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glProgramUniform4fv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} - proc glGetTexParameterIiv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glVertexAttribs4dvNV(index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} + proc glProgramUniformMatrix4x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glProgramUniform4fv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} + proc glGetTexParameterIiv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glVertexAttribs4dvNV(index: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} proc glConvolutionParameteri(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glVertexAttribI4uiv(index: TGLuint, v: TGLuint) {.importc.} - proc glEvalCoord1dv(u: TGLdouble) {.importc.} + proc glVertexAttribI4uiv(index: TGLuint, v: ptr TGLuint) {.importc.} + proc glEvalCoord1dv(u: ptr TGLdouble) {.importc.} proc glIsFramebuffer(framebuffer: TGLuint): TGLboolean {.importc.} proc glEvalCoord2d(u: TGLdouble, v: TGLdouble) {.importc.} proc glClearDepthf(d: TGLfloat) {.importc.} proc glCompressedTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} - proc glProgramUniformMatrix3x2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glGetTexParameterxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glProgramUniformMatrix3x2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glGetTexParameterxv(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glBinormal3fEXT(bx: TGLfloat, by: TGLfloat, bz: TGLfloat) {.importc.} proc glProgramParameteriARB(program: TGLuint, pname: TGLenum, value: TGLint) {.importc.} - proc glWindowPos3ivMESA(v: TGLint) {.importc.} - proc glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc: TGLuint, c: TGLfloat, n: TGLfloat, v: TGLfloat) {.importc.} + proc glWindowPos3ivMESA(v: ptr TGLint) {.importc.} + proc glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc: ptr TGLuint, c: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} proc glPresentFrameDualFillNV(video_slot: TGLuint, minPresentTime: TGLuint64EXT, beginPresentTimeId: TGLuint, presentDurationId: TGLuint, `type`: TGLenum, target0: TGLenum, fill0: TGLuint, target1: TGLenum, fill1: TGLuint, target2: TGLenum, fill2: TGLuint, target3: TGLenum, fill3: TGLuint) {.importc.} proc glIndexPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} proc glVertexStream2dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble) {.importc.} - proc glUniformMatrix3x4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glUniformMatrix3x4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glMapNamedBufferRangeEXT(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc.} - proc glColor4sv(v: TGLshort) {.importc.} + proc glColor4sv(v: ptr TGLshort) {.importc.} proc glStencilFillPathNV(path: TGLuint, fillMode: TGLenum, mask: TGLuint) {.importc.} - proc glGetVertexAttribfvARB(index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glWindowPos3dv(v: TGLdouble) {.importc.} + proc glGetVertexAttribfvARB(index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glWindowPos3dv(v: ptr TGLdouble) {.importc.} proc glHintPGI(target: TGLenum, mode: TGLint) {.importc.} - proc glVertexAttribs3hvNV(index: TGLuint, n: TGLsizei, v: TGLhalfNV) {.importc.} + proc glVertexAttribs3hvNV(index: TGLuint, n: TGLsizei, v: ptr TGLhalfNV) {.importc.} proc glProgramUniform1i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT) {.importc.} proc glReplacementCodeuiColor3fVertex3fSUN(rc: TGLuint, r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glUniform2iARB(location: TGLint, v0: TGLint, v1: TGLint) {.importc.} proc glViewport(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} proc glBlendFuncSeparateIndexedAMD(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} proc glColor3us(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc.} - proc glVertexAttrib2hvNV(index: TGLuint, v: TGLhalfNV) {.importc.} + proc glVertexAttrib2hvNV(index: TGLuint, v: ptr TGLhalfNV) {.importc.} proc glGenerateMipmap(target: TGLenum) {.importc.} - proc glGetProgramEnvParameterIuivNV(target: TGLenum, index: TGLuint, params: TGLuint) {.importc.} + proc glGetProgramEnvParameterIuivNV(target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} proc glBlendEquationiARB(buf: TGLuint, mode: TGLenum) {.importc.} proc glReadBufferNV(mode: TGLenum) {.importc.} proc glProvokingVertexEXT(mode: TGLenum) {.importc.} - proc glPointParameterivNV(pname: TGLenum, params: TGLint) {.importc.} + proc glPointParameterivNV(pname: TGLenum, params: ptr TGLint) {.importc.} proc glBlitFramebufferANGLE(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} - proc glGetObjectParameterivARB(obj: TGLhandleARB, pname: TGLenum, params: TGLint) {.importc.} - proc glGetSubroutineIndex(program: TGLuint, shadertype: TGLenum, name: TGLchar): TGLuint {.importc.} - proc glMap2d(target: TGLenum, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, points: TGLdouble) {.importc.} - proc glRectfv(v1: TGLfloat, v2: TGLfloat) {.importc.} - proc glDepthRangeArrayv(first: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} + proc glGetObjectParameterivARB(obj: TGLhandleARB, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetSubroutineIndex(program: TGLuint, shadertype: TGLenum, name: ptr TGLchar): TGLuint {.importc.} + proc glMap2d(target: TGLenum, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, points: ptr TGLdouble) {.importc.} + proc glRectfv(v1: ptr TGLfloat, v2: ptr TGLfloat) {.importc.} + proc glDepthRangeArrayv(first: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} proc glMultiTexParameteriEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} proc glTexStorageSparseAMD(target: TGLenum, internalFormat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, layers: TGLsizei, flags: TGLbitfield) {.importc.} proc glGenerateTextureMipmapEXT(texture: TGLuint, target: TGLenum) {.importc.} proc glCopyConvolutionFilter1D(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} proc glVertex4d(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glGetPathParameterfvNV(path: TGLuint, pname: TGLenum, value: TGLfloat) {.importc.} + proc glGetPathParameterfvNV(path: TGLuint, pname: TGLenum, value: ptr TGLfloat) {.importc.} proc glDetachShader(program: TGLuint, shader: TGLuint) {.importc.} proc glGetColorTableSGI(target: TGLenum, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} - proc glPixelTransformParameterfvEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glPixelTransformParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glBufferSubDataARB(target: TGLenum, offset: TGLintptrARB, size: TGLsizeiptrARB, data: pointer) {.importc.} - proc glVertexAttrib4ubvNV(index: TGLuint, v: TGLubyte) {.importc.} + proc glVertexAttrib4ubvNV(index: TGLuint, v: ptr TGLubyte) {.importc.} proc glCopyTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} - proc glGetQueryivARB(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetQueryivARB(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glVertexAttribIPointerEXT(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glVertexAttribL3dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glGetQueryObjectui64vEXT(id: TGLuint, pname: TGLenum, params: TGLuint64) {.importc.} + proc glGetQueryObjectui64vEXT(id: TGLuint, pname: TGLenum, params: ptr TGLuint64) {.importc.} proc glColor4x(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} - proc glProgramUniformMatrix3x2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glProgramUniformMatrix3x2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glVertexAttribI4i(index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} proc glVertexAttrib1f(index: TGLuint, x: TGLfloat) {.importc.} proc glUnmapBufferOES(target: TGLenum): TGLboolean {.importc.} - proc glVertexStream2ivATI(stream: TGLenum, coords: TGLint) {.importc.} + proc glVertexStream2ivATI(stream: TGLenum, coords: ptr TGLint) {.importc.} proc glBeginOcclusionQueryNV(id: TGLuint) {.importc.} - proc glVertex4sv(v: TGLshort) {.importc.} + proc glVertex4sv(v: ptr TGLshort) {.importc.} proc glEnablei(target: TGLenum, index: TGLuint) {.importc.} proc glUseProgramObjectARB(programObj: TGLhandleARB) {.importc.} - proc glGetVertexAttribLdvEXT(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glGetVertexAttribLdvEXT(index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} proc glUniform2d(location: TGLint, x: TGLdouble, y: TGLdouble) {.importc.} proc glMinmaxEXT(target: TGLenum, internalformat: TGLenum, sink: TGLboolean) {.importc.} proc glTexImage3D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glGenSymbolsEXT(datatype: TGLenum, storagetype: TGLenum, range: TGLenum, components: TGLuint): TGLuint {.importc.} - proc glVertexAttribI4svEXT(index: TGLuint, v: TGLshort) {.importc.} - proc glProgramEnvParameter4dvARB(target: TGLenum, index: TGLuint, params: TGLdouble) {.importc.} - proc glProgramUniformMatrix4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glGetSamplerParameterfv(sampler: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glVertexAttribI4svEXT(index: TGLuint, v: ptr TGLshort) {.importc.} + proc glProgramEnvParameter4dvARB(target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} + proc glProgramUniformMatrix4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glGetSamplerParameterfv(sampler: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glPopClientAttrib() {.importc.} proc glHistogram(target: TGLenum, width: TGLsizei, internalformat: TGLenum, sink: TGLboolean) {.importc.} - proc glTexEnvfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glMultiTexCoord1dvARB(target: TGLenum, v: TGLdouble) {.importc.} - proc glGetTexGenivOES(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glUniform1ivARB(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} - proc glTexCoord3fv(v: TGLfloat) {.importc.} - proc glVertex2xvOES(coords: TGLfixed) {.importc.} - proc glTexCoord4fVertex4fvSUN(tc: TGLfloat, v: TGLfloat) {.importc.} - proc glUniform2uiv(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} - proc glMultiTexEnvfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glGetTextureParameterIivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glTexEnvfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glMultiTexCoord1dvARB(target: TGLenum, v: ptr TGLdouble) {.importc.} + proc glGetTexGenivOES(coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glUniform1ivARB(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} + proc glTexCoord3fv(v: ptr TGLfloat) {.importc.} + proc glVertex2xvOES(coords: ptr TGLfixed) {.importc.} + proc glTexCoord4fVertex4fvSUN(tc: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glUniform2uiv(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} + proc glMultiTexEnvfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glGetTextureParameterIivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glMemoryBarrierEXT(barriers: TGLbitfield) {.importc.} proc glGetTexParameterPointervAPPLE(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} - proc glWindowPos2svARB(v: TGLshort) {.importc.} + proc glWindowPos2svARB(v: ptr TGLshort) {.importc.} proc glEndQuery(target: TGLenum) {.importc.} proc glBlitFramebufferEXT(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} - proc glProgramEnvParametersI4uivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: TGLuint) {.importc.} - proc glGetActiveUniform(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: TGLsizei, size: TGLint, `type`: TGLenum, name: TGLchar) {.importc.} + proc glProgramEnvParametersI4uivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLuint) {.importc.} + proc glGetActiveUniform(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, size: ptr TGLint, `type`: ptr TGLenum, name: ptr TGLchar) {.importc.} proc glGenAsyncMarkersSGIX(range: TGLsizei): TGLuint {.importc.} proc glClipControlARB(origin: TGLenum, depth: TGLenum) {.importc.} proc glDrawElementsInstancedEXT(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} - proc glGetFragmentMaterialivSGIX(face: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetFragmentMaterialivSGIX(face: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glSwizzleEXT(res: TGLuint, `in`: TGLuint, outX: TGLenum, outY: TGLenum, outZ: TGLenum, outW: TGLenum) {.importc.} proc glMultiTexCoord1bOES(texture: TGLenum, s: TGLbyte) {.importc.} - proc glProgramParameters4dvNV(target: TGLenum, index: TGLuint, count: TGLsizei, v: TGLdouble) {.importc.} + proc glProgramParameters4dvNV(target: TGLenum, index: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} proc glWindowPos2s(x: TGLshort, y: TGLshort) {.importc.} proc glBlendFuncSeparatei(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} - proc glMultiModeDrawElementsIBM(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei, modestride: TGLint) {.importc.} + proc glMultiModeDrawElementsIBM(mode: ptr TGLenum, count: ptr TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei, modestride: TGLint) {.importc.} proc glNormal3x(nx: TGLfixed, ny: TGLfixed, nz: TGLfixed) {.importc.} - proc glProgramUniform1fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLfloat) {.importc.} + proc glProgramUniform1fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} proc glTexCoord2hNV(s: TGLhalfNV, t: TGLhalfNV) {.importc.} - proc glViewportIndexedfv(index: TGLuint, v: TGLfloat) {.importc.} + proc glViewportIndexedfv(index: TGLuint, v: ptr TGLfloat) {.importc.} proc glDrawTexxOES(x: TGLfixed, y: TGLfixed, z: TGLfixed, width: TGLfixed, height: TGLfixed) {.importc.} - proc glProgramParameter4dvNV(target: TGLenum, index: TGLuint, v: TGLdouble) {.importc.} - proc glDeleteBuffers(n: TGLsizei, buffers: TGLuint) {.importc.} - proc glGetVertexArrayIntegervEXT(vaobj: TGLuint, pname: TGLenum, param: TGLint) {.importc.} - proc glBindFragDataLocationEXT(program: TGLuint, color: TGLuint, name: TGLchar) {.importc.} - proc glGenProgramsNV(n: TGLsizei, programs: TGLuint) {.importc.} + proc glProgramParameter4dvNV(target: TGLenum, index: TGLuint, v: ptr TGLdouble) {.importc.} + proc glDeleteBuffers(n: TGLsizei, buffers: ptr TGLuint) {.importc.} + proc glGetVertexArrayIntegervEXT(vaobj: TGLuint, pname: TGLenum, param: ptr TGLint) {.importc.} + proc glBindFragDataLocationEXT(program: TGLuint, color: TGLuint, name: ptr TGLchar) {.importc.} + proc glGenProgramsNV(n: TGLsizei, programs: ptr TGLuint) {.importc.} proc glMultiTexCoord1i(target: TGLenum, s: TGLint) {.importc.} proc glCompressedTexImage3DOES(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glGetQueryivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetQueryivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glExtGetBufferPointervQCOM(target: TGLenum, params: ptr pointer) {.importc.} - proc glVertex3iv(v: TGLint) {.importc.} - proc glVertexAttribL1dvEXT(index: TGLuint, v: TGLdouble) {.importc.} + proc glVertex3iv(v: ptr TGLint) {.importc.} + proc glVertexAttribL1dvEXT(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glValidateProgramPipeline(pipeline: TGLuint) {.importc.} proc glBindVertexArray(`array`: TGLuint) {.importc.} proc glUniform2uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} proc glUniform3i(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} - proc glGetVertexAttribIuiv(index: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} + proc glGetVertexAttribIuiv(index: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} proc glVertexArrayParameteriAPPLE(pname: TGLenum, param: TGLint) {.importc.} proc glVertexAttribL2i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT) {.importc.} - proc glTexGenivOES(coord: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glTexGenivOES(coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glIsFramebufferOES(framebuffer: TGLuint): TGLboolean {.importc.} - proc glColor4ubv(v: TGLubyte) {.importc.} - proc glDeleteNamedStringARB(namelen: TGLint, name: TGLchar) {.importc.} + proc glColor4ubv(v: ptr TGLubyte) {.importc.} + proc glDeleteNamedStringARB(namelen: TGLint, name: ptr TGLchar) {.importc.} proc glCopyConvolutionFilter1DEXT(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glBufferStorage(target: TGLenum, size: TGLsizeiptr, data: pointer, flags: TGLbitfield) {.importc.} + proc glBufferStorage(target: TGLenum, size: TGLsizeiptr, data: ptr pointer, flags: TGLbitfield) {.importc.} proc glDrawTexiOES(x: TGLint, y: TGLint, z: TGLint, width: TGLint, height: TGLint) {.importc.} - proc glRasterPos3dv(v: TGLdouble) {.importc.} + proc glRasterPos3dv(v: ptr TGLdouble) {.importc.} proc glIndexMaterialEXT(face: TGLenum, mode: TGLenum) {.importc.} - proc glGetClipPlanex(plane: TGLenum, equation: TGLfixed) {.importc.} + proc glGetClipPlanex(plane: TGLenum, equation: ptr TGLfixed) {.importc.} proc glIsVertexArrayOES(`array`: TGLuint): TGLboolean {.importc.} proc glColorTableEXT(target: TGLenum, internalFormat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} proc glCompressedTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} proc glLightx(light: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glGetTexParameterfv(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glVertexAttrib4NsvARB(index: TGLuint, v: TGLshort) {.importc.} + proc glGetTexParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glVertexAttrib4NsvARB(index: TGLuint, v: ptr TGLshort) {.importc.} proc glInterleavedArrays(format: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glProgramLocalParameter4fARB(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} proc glPopDebugGroupKHR() {.importc.} proc glVDPAUUnregisterSurfaceNV(surface: TGLvdpauSurfaceNV) {.importc.} proc glTexCoord1s(s: TGLshort) {.importc.} proc glFramebufferTexture2DMultisampleIMG(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, samples: TGLsizei) {.importc.} - proc glShaderBinary(count: TGLsizei, shaders: TGLuint, binaryformat: TGLenum, binary: pointer, length: TGLsizei) {.importc.} - proc glVertexAttrib2dv(index: TGLuint, v: TGLdouble) {.importc.} - proc glUniformMatrix4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glWeightivARB(size: TGLint, weights: TGLint) {.importc.} - proc glGetMultiTexParameterIivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glShaderBinary(count: TGLsizei, shaders: ptr TGLuint, binaryformat: TGLenum, binary: pointer, length: TGLsizei) {.importc.} + proc glVertexAttrib2dv(index: TGLuint, v: ptr TGLdouble) {.importc.} + proc glUniformMatrix4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glWeightivARB(size: TGLint, weights: ptr TGLint) {.importc.} + proc glGetMultiTexParameterIivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glCopyConvolutionFilter2DEXT(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} proc glSecondaryColor3hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV) {.importc.} - proc glVertexAttrib1sv(index: TGLuint, v: TGLshort) {.importc.} + proc glVertexAttrib1sv(index: TGLuint, v: ptr TGLshort) {.importc.} proc glFrustumfOES(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} proc glVertexStream2iATI(stream: TGLenum, x: TGLint, y: TGLint) {.importc.} proc glNormalStream3bATI(stream: TGLenum, nx: TGLbyte, ny: TGLbyte, nz: TGLbyte) {.importc.} proc glVertexArrayTexCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glGetQueryiv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glTransformFeedbackStreamAttribsNV(count: TGLsizei, attribs: TGLint, nbuffers: TGLsizei, bufstreams: TGLint, bufferMode: TGLenum) {.importc.} + proc glGetQueryiv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glTransformFeedbackStreamAttribsNV(count: TGLsizei, attribs: ptr TGLint, nbuffers: TGLsizei, bufstreams: ptr TGLint, bufferMode: TGLenum) {.importc.} proc glTextureStorage3DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} - proc glWindowPos3dvMESA(v: TGLdouble) {.importc.} - proc glUniform2uivEXT(location: TGLint, count: TGLsizei, value: TGLuint) {.importc.} + proc glWindowPos3dvMESA(v: ptr TGLdouble) {.importc.} + proc glUniform2uivEXT(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} proc glTextureStorage2DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glVertexArrayMultiTexCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, texunit: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glVertexStream1dvATI(stream: TGLenum, coords: TGLdouble) {.importc.} + proc glVertexStream1dvATI(stream: TGLenum, coords: ptr TGLdouble) {.importc.} proc glCopyImageSubData(srcName: TGLuint, srcTarget: TGLenum, srcLevel: TGLint, srcX: TGLint, srcY: TGLint, srcZ: TGLint, dstName: TGLuint, dstTarget: TGLenum, dstLevel: TGLint, dstX: TGLint, dstY: TGLint, dstZ: TGLint, srcWidth: TGLsizei, srcHeight: TGLsizei, srcDepth: TGLsizei) {.importc.} - proc glClearNamedBufferSubDataEXT(buffer: TGLuint, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, offset: TGLsizeiptr, size: TGLsizeiptr, data: pointer) {.importc.} - proc glBindBuffersRange(target: TGLenum, first: TGLuint, count: TGLsizei, buffers: TGLuint, offsets: TGLintptr, sizes: TGLsizeiptr) {.importc.} - proc glGetVertexAttribIuivEXT(index: TGLuint, pname: TGLenum, params: TGLuint) {.importc.} - proc glLoadMatrixx(m: TGLfixed) {.importc.} - proc glTransformFeedbackVaryingsNV(program: TGLuint, count: TGLsizei, locations: TGLint, bufferMode: TGLenum) {.importc.} - proc glUniform1i64vNV(location: TGLint, count: TGLsizei, value: TGLint64EXT) {.importc.} + proc glClearNamedBufferSubDataEXT(buffer: TGLuint, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, offset: TGLsizeiptr, size: TGLsizeiptr, data: ptr pointer) {.importc.} + proc glBindBuffersRange(target: TGLenum, first: TGLuint, count: TGLsizei, buffers: ptr TGLuint, offsets: ptr TGLintptr, sizes: ptr TGLsizeiptr) {.importc.} + proc glGetVertexAttribIuivEXT(index: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} + proc glLoadMatrixx(m: ptr TGLfixed) {.importc.} + proc glTransformFeedbackVaryingsNV(program: TGLuint, count: TGLsizei, locations: ptr TGLint, bufferMode: TGLenum) {.importc.} + proc glUniform1i64vNV(location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} proc glVertexArrayVertexAttribLFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} - proc glClearBufferuiv(buffer: TGLenum, drawbuffer: TGLint, value: TGLuint) {.importc.} + proc glClearBufferuiv(buffer: TGLenum, drawbuffer: TGLint, value: ptr TGLuint) {.importc.} proc glCombinerOutputNV(stage: TGLenum, portion: TGLenum, abOutput: TGLenum, cdOutput: TGLenum, sumOutput: TGLenum, scale: TGLenum, bias: TGLenum, abDotProduct: TGLboolean, cdDotProduct: TGLboolean, muxSum: TGLboolean) {.importc.} proc glTexImage3DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glPixelTransformParameterivEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glPixelTransformParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glActiveStencilFaceEXT(face: TGLenum) {.importc.} proc glCreateShaderObjectARB(shaderType: TGLenum): TGLhandleARB {.importc.} - proc glGetTextureParameterivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glGetTextureParameterivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glCopyTextureLevelsAPPLE(destinationTexture: TGLuint, sourceTexture: TGLuint, sourceBaseLevel: TGLint, sourceLevelCount: TGLsizei) {.importc.} - proc glVertexAttrib4Nuiv(index: TGLuint, v: TGLuint) {.importc.} + proc glVertexAttrib4Nuiv(index: TGLuint, v: ptr TGLuint) {.importc.} proc glDrawPixels(width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glWindowPos3dvARB(v: TGLdouble) {.importc.} - proc glProgramLocalParameterI4ivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc.} + proc glWindowPos3dvARB(v: ptr TGLdouble) {.importc.} + proc glProgramLocalParameterI4ivNV(target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} proc glRasterPos4s(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glTexCoord2fVertex3fvSUN(tc: TGLfloat, v: TGLfloat) {.importc.} - proc glGetPathMetricsNV(metricQueryMask: TGLbitfield, numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, stride: TGLsizei, metrics: TGLfloat) {.importc.} + proc glTexCoord2fVertex3fvSUN(tc: ptr TGLfloat, v: ptr TGLfloat) {.importc.} + proc glGetPathMetricsNV(metricQueryMask: TGLbitfield, numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, stride: TGLsizei, metrics: ptr TGLfloat) {.importc.} proc glMultiTexCoord4bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte, r: TGLbyte, q: TGLbyte) {.importc.} proc glTextureBufferEXT(texture: TGLuint, target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} - proc glSecondaryColor3fv(v: TGLfloat) {.importc.} - proc glMultiTexCoord3fv(target: TGLenum, v: TGLfloat) {.importc.} - proc glGetTexParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} + proc glSecondaryColor3fv(v: ptr TGLfloat) {.importc.} + proc glMultiTexCoord3fv(target: TGLenum, v: ptr TGLfloat) {.importc.} + proc glGetTexParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} proc glMap2xOES(target: TGLenum, u1: TGLfixed, u2: TGLfixed, ustride: TGLint, uorder: TGLint, v1: TGLfixed, v2: TGLfixed, vstride: TGLint, vorder: TGLint, points: TGLfixed) {.importc.} proc glFlushVertexArrayRangeAPPLE(length: TGLsizei, `pointer`: pointer) {.importc.} proc glActiveTextureARB(texture: TGLenum) {.importc.} - proc glGetVertexAttribLi64vNV(index: TGLuint, pname: TGLenum, params: TGLint64EXT) {.importc.} - proc glNormal3bv(v: TGLbyte) {.importc.} - proc glCreateSyncFromCLeventARB(context: TCL_context, event: TCL_context, flags: TGLbitfield): TGLsync {.importc.} + proc glGetVertexAttribLi64vNV(index: TGLuint, pname: TGLenum, params: ptr TGLint64EXT) {.importc.} + proc glNormal3bv(v: ptr TGLbyte) {.importc.} + proc glCreateSyncFromCLeventARB(context: ptr TCL_context, event: ptr TCL_context, flags: TGLbitfield): TGLsync {.importc.} proc glRenderbufferStorageEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} proc glGetCompressedTextureImageEXT(texture: TGLuint, target: TGLenum, lod: TGLint, img: pointer) {.importc.} proc glColorFragmentOp2ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint) {.importc.} - proc glPixelMapusv(map: TGLenum, mapsize: TGLsizei, values: TGLushort) {.importc.} + proc glPixelMapusv(map: TGLenum, mapsize: TGLsizei, values: ptr TGLushort) {.importc.} proc glGlobalAlphaFactorsSUN(factor: TGLshort) {.importc.} - proc glTexParameterxv(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glTexParameterxv(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glEvalCoord2xOES(u: TGLfixed, v: TGLfixed) {.importc.} proc glIsList(list: TGLuint): TGLboolean {.importc.} proc glVertexAttrib3d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} proc glSpriteParameterfSGIX(pname: TGLenum, param: TGLfloat) {.importc.} proc glPathGlyphRangeNV(firstPathName: TGLuint, fontTarget: TGLenum, fontName: pointer, fontStyle: TGLbitfield, firstGlyph: TGLuint, numGlyphs: TGLsizei, handleMissingGlyphs: TGLenum, pathParameterTemplate: TGLuint, emScale: TGLfloat) {.importc.} - proc glUniform3iv(location: TGLint, count: TGLsizei, value: TGLint) {.importc.} + proc glUniform3iv(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} proc glClearBufferfi(buffer: TGLenum, drawbuffer: TGLint, depth: TGLfloat, stencil: TGLint) {.importc.} proc glWindowPos3sMESA(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glGetMapParameterfvNV(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetMapParameterfvNV(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glBindFragmentShaderATI(id: TGLuint) {.importc.} proc glTexCoord4s(s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc.} - proc glGetMultiTexGenfvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetMultiTexGenfvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glColorMaterial(face: TGLenum, mode: TGLenum) {.importc.} - proc glVertexAttribs1svNV(index: TGLuint, count: TGLsizei, v: TGLshort) {.importc.} + proc glVertexAttribs1svNV(index: TGLuint, count: TGLsizei, v: ptr TGLshort) {.importc.} proc glEnableVertexAttribAPPLE(index: TGLuint, pname: TGLenum) {.importc.} - proc glGetDoubleIndexedvEXT(target: TGLenum, index: TGLuint, data: TGLdouble) {.importc.} + proc glGetDoubleIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr TGLdouble) {.importc.} proc glOrthof(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} proc glVertexBlendEnvfATI(pname: TGLenum, param: TGLfloat) {.importc.} - proc glUniformMatrix2x4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} - proc glPrioritizeTexturesxOES(n: TGLsizei, textures: TGLuint, priorities: TGLfixed) {.importc.} + proc glUniformMatrix2x4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glPrioritizeTexturesxOES(n: TGLsizei, textures: ptr TGLuint, priorities: ptr TGLfixed) {.importc.} proc glGetTextureSamplerHandleNV(texture: TGLuint, sampler: TGLuint): TGLuint64 {.importc.} - proc glDeleteVertexArrays(n: TGLsizei, arrays: TGLuint) {.importc.} + proc glDeleteVertexArrays(n: TGLsizei, arrays: ptr TGLuint) {.importc.} proc glMultiTexCoord1xOES(texture: TGLenum, s: TGLfixed) {.importc.} proc glGlobalAlphaFactorusSUN(factor: TGLushort) {.importc.} - proc glGetConvolutionParameterxvOES(target: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} + proc glGetConvolutionParameterxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} proc glProgramUniform4fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} - proc glProgramUniformMatrix3x4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glProgramUniformMatrix3x4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} proc glBindVertexBuffer(bindingindex: TGLuint, buffer: TGLuint, offset: TGLintptr, stride: TGLsizei) {.importc.} - proc glGetHistogramParameteriv(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glGetShaderPrecisionFormat(shadertype: TGLenum, precisiontype: TGLenum, range: TGLint, precision: TGLint) {.importc.} + proc glGetHistogramParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glGetShaderPrecisionFormat(shadertype: TGLenum, precisiontype: TGLenum, range: ptr TGLint, precision: ptr TGLint) {.importc.} proc glTextureMaterialEXT(face: TGLenum, mode: TGLenum) {.importc.} - proc glEvalCoord2xvOES(coords: TGLfixed) {.importc.} - proc glWeightuivARB(size: TGLint, weights: TGLuint) {.importc.} - proc glGetTextureLevelParameterfvEXT(texture: TGLuint, target: TGLenum, level: TGLint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glVertexAttribP3uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} - proc glProgramEnvParameterI4ivNV(target: TGLenum, index: TGLuint, params: TGLint) {.importc.} + proc glEvalCoord2xvOES(coords: ptr TGLfixed) {.importc.} + proc glWeightuivARB(size: TGLint, weights: ptr TGLuint) {.importc.} + proc glGetTextureLevelParameterfvEXT(texture: TGLuint, target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glVertexAttribP3uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: ptr TGLuint) {.importc.} + proc glProgramEnvParameterI4ivNV(target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} proc glFogi(pname: TGLenum, param: TGLint) {.importc.} - proc glTexCoord1iv(v: TGLint) {.importc.} - proc glReplacementCodeuiColor4ubVertex3fvSUN(rc: TGLuint, c: TGLubyte, v: TGLfloat) {.importc.} + proc glTexCoord1iv(v: ptr TGLint) {.importc.} + proc glReplacementCodeuiColor4ubVertex3fvSUN(rc: ptr TGLuint, c: ptr TGLubyte, v: ptr TGLfloat) {.importc.} proc glProgramUniform1ui(program: TGLuint, location: TGLint, v0: TGLuint) {.importc.} proc glMultiTexCoord3d(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc.} proc glBeginVideoCaptureNV(video_capture_slot: TGLuint) {.importc.} proc glEvalCoord1f(u: TGLfloat) {.importc.} - proc glMultiTexCoord1hvNV(target: TGLenum, v: TGLhalfNV) {.importc.} + proc glMultiTexCoord1hvNV(target: TGLenum, v: ptr TGLhalfNV) {.importc.} proc glSecondaryColor3sEXT(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc.} proc glTextureImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} proc glCopyTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} @@ -3032,48 +3032,48 @@ wrapErrorChecking: proc glVertexAttribL1ui64ARB(index: TGLuint, x: TGLuint64EXT) {.importc.} proc glPolygonOffset(factor: TGLfloat, units: TGLfloat) {.importc.} proc glRasterPos4xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed, w: TGLfixed) {.importc.} - proc glVertexAttrib3dvNV(index: TGLuint, v: TGLdouble) {.importc.} + proc glVertexAttrib3dvNV(index: TGLuint, v: ptr TGLdouble) {.importc.} proc glBeginQuery(target: TGLenum, id: TGLuint) {.importc.} - proc glWeightfvARB(size: TGLint, weights: TGLfloat) {.importc.} - proc glGetUniformuiv(program: TGLuint, location: TGLint, params: TGLuint) {.importc.} + proc glWeightfvARB(size: TGLint, weights: ptr TGLfloat) {.importc.} + proc glGetUniformuiv(program: TGLuint, location: TGLint, params: ptr TGLuint) {.importc.} proc glIsTextureEXT(texture: TGLuint): TGLboolean {.importc.} - proc glGetClipPlanef(plane: TGLenum, equation: TGLfloat) {.importc.} + proc glGetClipPlanef(plane: TGLenum, equation: ptr TGLfloat) {.importc.} proc glTexGenxOES(coord: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} proc glFramebufferTextureFaceEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc.} proc glDisableClientState(`array`: TGLenum) {.importc.} proc glTexPageCommitmentARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, resident: TGLboolean) {.importc.} - proc glRasterPos4dv(v: TGLdouble) {.importc.} - proc glGetLightx(light: TGLenum, pname: TGLenum, params: TGLfixed) {.importc.} - proc glVertexAttrib1hvNV(index: TGLuint, v: TGLhalfNV) {.importc.} + proc glRasterPos4dv(v: ptr TGLdouble) {.importc.} + proc glGetLightx(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} + proc glVertexAttrib1hvNV(index: TGLuint, v: ptr TGLhalfNV) {.importc.} proc glMultiTexCoord2s(target: TGLenum, s: TGLshort, t: TGLshort) {.importc.} - proc glProgramUniform2iv(program: TGLuint, location: TGLint, count: TGLsizei, value: TGLint) {.importc.} - proc glGetListParameterivSGIX(list: TGLuint, pname: TGLenum, params: TGLint) {.importc.} + proc glProgramUniform2iv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} + proc glGetListParameterivSGIX(list: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} proc glColorFragmentOp1ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint) {.importc.} proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} proc glSampleMapATI(dst: TGLuint, interp: TGLuint, swizzle: TGLenum) {.importc.} proc glProgramUniform1d(program: TGLuint, location: TGLint, v0: TGLdouble) {.importc.} - proc glBindAttribLocation(program: TGLuint, index: TGLuint, name: TGLchar) {.importc.} - proc glGetCombinerStageParameterfvNV(stage: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} + proc glBindAttribLocation(program: TGLuint, index: TGLuint, name: ptr TGLchar) {.importc.} + proc glGetCombinerStageParameterfvNV(stage: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glTexSubImage4DSGIS(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, woffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, size4d: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetMapAttribParameterfvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} + proc glGetMapAttribParameterfvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} proc glNewObjectBufferATI(size: TGLsizei, `pointer`: pointer, usage: TGLenum): TGLuint {.importc.} proc glWindowPos4iMESA(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} proc glNewList(list: TGLuint, mode: TGLenum) {.importc.} proc glUniform1i64NV(location: TGLint, x: TGLint64EXT) {.importc.} proc glTexCoordP3ui(`type`: TGLenum, coords: TGLuint) {.importc.} proc glEndQueryEXT(target: TGLenum) {.importc.} - proc glGetVertexAttribLdv(index: TGLuint, pname: TGLenum, params: TGLdouble) {.importc.} + proc glGetVertexAttribLdv(index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} proc glStencilMask(mask: TGLuint) {.importc.} - proc glVertexAttrib4sv(index: TGLuint, v: TGLshort) {.importc.} - proc glRectsv(v1: TGLshort, v2: TGLshort) {.importc.} - proc glGetVariantArrayObjectfvATI(id: TGLuint, pname: TGLenum, params: TGLfloat) {.importc.} - proc glTexCoord3hvNV(v: TGLhalfNV) {.importc.} - proc glGetUniformdv(program: TGLuint, location: TGLint, params: TGLdouble) {.importc.} - proc glSecondaryColor3fvEXT(v: TGLfloat) {.importc.} + proc glVertexAttrib4sv(index: TGLuint, v: ptr TGLshort) {.importc.} + proc glRectsv(v1: ptr TGLshort, v2: ptr TGLshort) {.importc.} + proc glGetVariantArrayObjectfvATI(id: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glTexCoord3hvNV(v: ptr TGLhalfNV) {.importc.} + proc glGetUniformdv(program: TGLuint, location: TGLint, params: ptr TGLdouble) {.importc.} + proc glSecondaryColor3fvEXT(v: ptr TGLfloat) {.importc.} proc glAlphaFuncx(func: TGLenum, `ref`: TGLfixed) {.importc.} proc glVertexAttribPointerNV(index: TGLuint, fsize: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} proc glColorTable(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} - proc glProgramUniformMatrix2x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: TGLdouble) {.importc.} + proc glProgramUniformMatrix2x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} {.pop.} # stdcall, hint[XDeclaredButNotUsed]: off. const From 138b94293bbda99a2f0598c3fe6481e1d29b31c1 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Wed, 16 Apr 2014 00:20:01 +0200 Subject: [PATCH 10/18] Revert to old names; re-add most of the missing aliases. --- lib/opengl.nim | 5635 ++++++++++++++++++++++++------------------------ 1 file changed, 2861 insertions(+), 2774 deletions(-) diff --git a/lib/opengl.nim b/lib/opengl.nim index be64930..ead7c64 100644 --- a/lib/opengl.nim +++ b/lib/opengl.nim @@ -99,6 +99,38 @@ else: nimLoadProcs0() type + GLenum* = uint32 + GLboolean* = bool + GLbitfield* = uint32 + GLvoid* = void + GLbyte* = int8 + GLshort* = int64 + GLint* = int32 + GLclampx* = int32 + GLubyte* = uint8 + GLushort* = uint16 + GLuint* = uint32 + GLsizei* = int32 + GLfloat* = float32 + GLclampf* = float32 + GLdouble* = float64 + GLclampd* = float64 + GLeglImageOES* = pointer + GLchar* = char + GLcharARB* = cchar + GLfixed* = int32 + GLhalfNV* = uint16 + GLvdpauSurfaceNV* = uint + GLintptr* = int32 + GLintptrARB* = int32 + GLint64EXT* = int64 + GLuint64EXT* = uint64 + GLint64* = int64 + GLsizeiptrARB* = int32 + GLsizeiptr* = int32 + GLsync* = pointer + GLuint64* = uint64 + TGLenum* = uint32 TGLboolean* = bool TGLbitfield* = uint32 @@ -130,8 +162,10 @@ type TGLsizeiptr* = int32 TGLsync* = pointer TGLuint64* = uint64 + TCL_context* = distinct pointer TCL_event* = distinct pointer + TGLDebugProc* = proc ( source: TGLenum, typ: TGLenum, @@ -140,6 +174,8 @@ type length: TGLsizei, message: ptr TGLchar, userParam: pointer) {.stdcall.} + GLDebugProc* = TGLDebugProc + TGlDebugProcARB* = proc ( source: TGLenum, typ: TGLenum, @@ -148,6 +184,8 @@ type len: TGLsizei, message: ptr TGLchar, userParam: pointer) {.stdcall.} + GlDebugProcARB* = TGlDebugProcARB + TGlDebugProcAMD* = proc ( id: TGLuint, category: TGLenum, @@ -155,6 +193,8 @@ type len: TGLsizei, message: ptr TGLchar, userParam: pointer) {.stdcall.} + GlDebugProcAMD* = TGlDebugProcAMD + TGlDebugProcKHR* = proc ( source, typ: TGLenum, id: TGLuint, @@ -162,13 +202,60 @@ type length: TGLsizei, message: ptr TGLchar, userParam: pointer) {.stdcall.} + GlDebugProcKHR* = TGlDebugProcKHR + + TGLVectorub2* = array[0..1, GLubyte] + TGLVectori2* = array[0..1, GLint] + TGLVectorf2* = array[0..1, GLfloat] + TGLVectord2* = array[0..1, GLdouble] + TGLVectorp2* = array[0..1, Pointer] + TGLVectorb3* = array[0..2, GLbyte] + TGLVectorub3* = array[0..2, GLubyte] + TGLVectori3* = array[0..2, GLint] + TGLVectorui3* = array[0..2, GLuint] + TGLVectorf3* = array[0..2, GLfloat] + TGLVectord3* = array[0..2, GLdouble] + TGLVectorp3* = array[0..2, Pointer] + TGLVectors3* = array[0..2, GLshort] + TGLVectorus3* = array[0..2, GLushort] + TGLVectorb4* = array[0..3, GLbyte] + TGLVectorub4* = array[0..3, GLubyte] + TGLVectori4* = array[0..3, GLint] + TGLVectorui4* = array[0..3, GLuint] + TGLVectorf4* = array[0..3, GLfloat] + TGLVectord4* = array[0..3, GLdouble] + TGLVectorp4* = array[0..3, Pointer] + TGLVectors4* = array[0..3, GLshort] + TGLVectorus4* = array[0..3, GLshort] + TGLArrayf4* = TGLVectorf4 + TGLArrayf3* = TGLVectorf3 + TGLArrayd3* = TGLVectord3 + TGLArrayi4* = TGLVectori4 + TGLArrayp4* = TGLVectorp4 + TGlMatrixub3* = array[0..2, array[0..2, GLubyte]] + TGlMatrixi3* = array[0..2, array[0..2, GLint]] + TGLMatrixf3* = array[0..2, array[0..2, GLfloat]] + TGLMatrixd3* = array[0..2, array[0..2, GLdouble]] + TGlMatrixub4* = array[0..3, array[0..3, GLubyte]] + TGlMatrixi4* = array[0..3, array[0..3, GLint]] + TGLMatrixf4* = array[0..3, array[0..3, GLfloat]] + TGLMatrixd4* = array[0..3, array[0..3, GLdouble]] + TGLVector3f* = TGLVectorf3 # Datatypes corresponding to OpenGL12.pas for easy porting + TVector3d* = TGLVectord3 + TVector4i* = TGLVectori4 + TVector4f* = TGLVectorf4 + TVector4p* = TGLVectorp4 + TMatrix4f* = TGLMatrixf4 + TMatrix4d* = TGLMatrixd4 when defined(macosx): type TGLhandleARB = pointer + GLhandleARB = pointer else: type TGLhandleARB = uint32 + GLhandleARB = uint32 type TGlError* {.size: TGLenum.sizeof.} = enum @@ -256,2824 +343,2824 @@ macro wrapErrorChecking(f: stmt): stmt = {.deadCodeElim: on.} {.push stdcall, hint[XDeclaredButNotUsed]: off.} wrapErrorChecking: - proc glMultiTexCoord2d(target: TGLenum, s: TGLdouble, t: TGLdouble) {.importc.} - proc glDrawElementsIndirect(mode: TGLenum, `type`: TGLenum, indirect: pointer) {.importc.} - proc glEnableVertexArrayEXT(vaobj: TGLuint, `array`: TGLenum) {.importc.} - proc glDeleteFramebuffers(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} - proc glMultiTexCoord3dv(target: TGLenum, v: ptr TGLdouble) {.importc.} - proc glVertexAttrib4d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} + proc glMultiTexCoord2d(target: GLenum, s: GLdouble, t: GLdouble) {.importc.} + proc glDrawElementsIndirect(mode: GLenum, `type`: GLenum, indirect: pointer) {.importc.} + proc glEnableVertexArrayEXT(vaobj: GLuint, `array`: GLenum) {.importc.} + proc glDeleteFramebuffers(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glMultiTexCoord3dv(target: GLenum, v: ptr GLdouble) {.importc.} + proc glVertexAttrib4d(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} proc glLoadPaletteFromModelViewMatrixOES() {.importc.} - proc glVertex3xvOES(coords: ptr TGLfixed) {.importc.} - proc glNormalStream3sATI(stream: TGLenum, nx: TGLshort, ny: TGLshort, nz: TGLshort) {.importc.} - proc glMatrixFrustumEXT(mode: TGLenum, left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} - proc glUniformMatrix2fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glColor4dv(v: ptr TGLdouble) {.importc.} - proc glColor3fv(v: ptr TGLfloat) {.importc.} - proc glVertexAttribI1uiEXT(index: TGLuint, x: TGLuint) {.importc.} - proc glGetDebugMessageLogKHR(count: TGLuint, bufsize: TGLsizei, sources: ptr TGLenum, types: ptr TGLenum, ids: ptr TGLuint, severities: ptr TGLenum, lengths: ptr TGLsizei, messageLog: ptr TGLchar): TGLuint {.importc.} - proc glVertexAttribI2iv(index: TGLuint, v: ptr TGLint) {.importc.} - proc glTexCoord1xvOES(coords: ptr TGLfixed) {.importc.} - proc glVertex3hNV(x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV) {.importc.} - proc glIsShader(shader: TGLuint): TGLboolean {.importc.} - proc glDeleteRenderbuffersEXT(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} - proc glVertex3hvNV(v: ptr TGLhalfNV) {.importc.} - proc glGetPointervKHR(pname: TGLenum, params: ptr pointer) {.importc.} - proc glProgramUniform3i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} - proc glNamedFramebufferTexture1DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glGetNamedProgramLocalParameterfvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} - proc glGenRenderbuffersOES(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} - proc glVertex4dv(v: ptr TGLdouble) {.importc.} - proc glTexCoord2fColor4ubVertex3fvSUN(tc: ptr TGLfloat, c: ptr TGLubyte, v: ptr TGLfloat) {.importc.} - proc glTexStorage2DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glVertexAttrib2d(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} - proc glVertexAttrib1dv(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glBindProgramARB(target: TGLenum, program: TGLuint) {.importc.} - proc glRasterPos2dv(v: ptr TGLdouble) {.importc.} - proc glCompressedTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glNormalPointervINTEL(`type`: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glGetInteger64vAPPLE(pname: TGLenum, params: ptr TGLint64) {.importc.} + proc glVertex3xvOES(coords: ptr GLfixed) {.importc.} + proc glNormalStream3sATI(stream: GLenum, nx: GLshort, ny: GLshort, nz: GLshort) {.importc.} + proc glMatrixFrustumEXT(mode: GLenum, left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, zNear: GLdouble, zFar: GLdouble) {.importc.} + proc glUniformMatrix2fvARB(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glColor4dv(v: ptr GLdouble) {.importc.} + proc glColor3fv(v: ptr GLfloat) {.importc.} + proc glVertexAttribI1uiEXT(index: GLuint, x: GLuint) {.importc.} + proc glGetDebugMessageLogKHR(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} + proc glVertexAttribI2iv(index: GLuint, v: ptr GLint) {.importc.} + proc glTexCoord1xvOES(coords: ptr GLfixed) {.importc.} + proc glVertex3hNV(x: GLhalfNV, y: GLhalfNV, z: GLhalfNV) {.importc.} + proc glIsShader(shader: GLuint): TGLboolean {.importc.} + proc glDeleteRenderbuffersEXT(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glVertex3hvNV(v: ptr GLhalfNV) {.importc.} + proc glGetPointervKHR(pname: GLenum, params: ptr pointer) {.importc.} + proc glProgramUniform3i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} + proc glNamedFramebufferTexture1DEXT(framebuffer: GLuint, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glGetNamedProgramLocalParameterfvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glGenRenderbuffersOES(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glVertex4dv(v: ptr GLdouble) {.importc.} + proc glTexCoord2fColor4ubVertex3fvSUN(tc: ptr GLfloat, c: ptr GLubyte, v: ptr GLfloat) {.importc.} + proc glTexStorage2DEXT(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glVertexAttrib2d(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} + proc glVertexAttrib1dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glBindProgramARB(target: GLenum, program: GLuint) {.importc.} + proc glRasterPos2dv(v: ptr GLdouble) {.importc.} + proc glCompressedTextureSubImage2DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glNormalPointervINTEL(`type`: GLenum, `pointer`: ptr pointer) {.importc.} + proc glGetInteger64vAPPLE(pname: GLenum, params: ptr GLint64) {.importc.} proc glPushMatrix() {.importc.} - proc glGetCompressedTexImageARB(target: TGLenum, level: TGLint, img: pointer) {.importc.} - proc glBindMaterialParameterEXT(face: TGLenum, value: TGLenum): TGLuint {.importc.} - proc glBlendEquationIndexedAMD(buf: TGLuint, mode: TGLenum) {.importc.} - proc glGetObjectBufferfvATI(buffer: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glMakeNamedBufferNonResidentNV(buffer: TGLuint) {.importc.} - proc glUniform2ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc.} - proc glRasterPos4fv(v: ptr TGLfloat) {.importc.} - proc glDeleteTextures(n: TGLsizei, textures: ptr TGLuint) {.importc.} - proc glSecondaryColorPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glEndTilingQCOM(preserveMask: TGLbitfield) {.importc.} - proc glBindBuffer(target: TGLenum, buffer: TGLuint) {.importc.} - proc glUniformMatrix3fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glSamplerParameterf(sampler: TGLuint, pname: TGLenum, param: TGLfloat) {.importc.} - proc glSecondaryColor3d(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc.} - proc glVertexAttrib4sARB(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glNamedProgramLocalParameterI4iEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} - proc glProgramUniform2iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint) {.importc.} + proc glGetCompressedTexImageARB(target: GLenum, level: GLint, img: pointer) {.importc.} + proc glBindMaterialParameterEXT(face: GLenum, value: GLenum): TGLuint {.importc.} + proc glBlendEquationIndexedAMD(buf: GLuint, mode: GLenum) {.importc.} + proc glGetObjectBufferfvATI(buffer: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMakeNamedBufferNonResidentNV(buffer: GLuint) {.importc.} + proc glUniform2ui64NV(location: GLint, x: GLuint64EXT, y: GLuint64EXT) {.importc.} + proc glRasterPos4fv(v: ptr GLfloat) {.importc.} + proc glDeleteTextures(n: GLsizei, textures: ptr GLuint) {.importc.} + proc glSecondaryColorPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glTextureSubImage1DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glEndTilingQCOM(preserveMask: GLbitfield) {.importc.} + proc glBindBuffer(target: GLenum, buffer: GLuint) {.importc.} + proc glUniformMatrix3fvARB(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glSamplerParameterf(sampler: GLuint, pname: GLenum, param: GLfloat) {.importc.} + proc glSecondaryColor3d(red: GLdouble, green: GLdouble, blue: GLdouble) {.importc.} + proc glVertexAttrib4sARB(index: GLuint, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glNamedProgramLocalParameterI4iEXT(program: GLuint, target: GLenum, index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glProgramUniform2iEXT(program: GLuint, location: GLint, v0: GLint, v1: GLint) {.importc.} proc glPopAttrib() {.importc.} - proc glGetnColorTableARB(target: TGLenum, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, table: pointer) {.importc.} - proc glMatrixLoadIdentityEXT(mode: TGLenum) {.importc.} - proc glGetNamedProgramivEXT(program: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glCopyTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glUniform4i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc.} - proc glDeleteTexturesEXT(n: TGLsizei, textures: ptr TGLuint) {.importc.} - proc glMultiTexCoord1dv(target: TGLenum, v: ptr TGLdouble) {.importc.} - proc glMultiTexRenderbufferEXT(texunit: TGLenum, target: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glMultiDrawArraysIndirect(mode: TGLenum, indirect: ptr pointer, drawcount: TGLsizei, stride: TGLsizei) {.importc.} - proc glGetUniformfvARB(programObj: TGLhandleARB, location: TGLint, params: ptr TGLfloat) {.importc.} - proc glBufferDataARB(target: TGLenum, size: TGLsizeiptrARB, data: pointer, usage: TGLenum) {.importc.} - proc glTexCoord2d(s: TGLdouble, t: TGLdouble) {.importc.} - proc glGetArrayObjectfvATI(`array`: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glShaderOp1EXT(op: TGLenum, res: TGLuint, arg1: TGLuint) {.importc.} - proc glColor3s(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc.} - proc glStencilFuncSeparate(face: TGLenum, func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} - proc glTextureImage2DMultisampleCoverageNV(texture: TGLuint, target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} - proc glMultiTexCoord2xvOES(texture: TGLenum, coords: ptr TGLfixed) {.importc.} - proc glGetVertexAttribLui64vNV(index: TGLuint, pname: TGLenum, params: ptr TGLuint64EXT) {.importc.} - proc glNormal3xOES(nx: TGLfixed, ny: TGLfixed, nz: TGLfixed) {.importc.} - proc glMapBufferRangeEXT(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc.} - proc glCreateShader(`type`: TGLenum): TGLuint {.importc.} - proc glDrawRangeElementArrayAPPLE(mode: TGLenum, start: TGLuint, `end`: TGLuint, first: TGLint, count: TGLsizei) {.importc.} - proc glVertex2bOES(x: TGLbyte) {.importc.} - proc glGetMapxvOES(target: TGLenum, query: TGLenum, v: ptr TGLfixed) {.importc.} - proc glRasterPos3sv(v: ptr TGLshort) {.importc.} - proc glDeleteQueriesARB(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glProgramUniform1iv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glVertexStream2dvATI(stream: TGLenum, coords: ptr TGLdouble) {.importc.} - proc glBindVertexArrayOES(`array`: TGLuint) {.importc.} - proc glLightModelfv(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glEvalCoord2dv(u: ptr TGLdouble) {.importc.} - proc glColor3hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV) {.importc.} - proc glSecondaryColor3iEXT(red: TGLint, green: TGLint, blue: TGLint) {.importc.} - proc glBindTexture(target: TGLenum, texture: TGLuint) {.importc.} - proc glUniformBufferEXT(program: TGLuint, location: TGLint, buffer: TGLuint) {.importc.} - proc glGetCombinerInputParameterfvNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glUniform2ui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} - proc glMatrixMultTransposefEXT(mode: TGLenum, m: ptr TGLfloat) {.importc.} - proc glLineWidth(width: TGLfloat) {.importc.} - proc glRotatef(angle: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glNormalStream3svATI(stream: TGLenum, coords: ptr TGLshort) {.importc.} - proc glTexCoordP4ui(`type`: TGLenum, coords: TGLuint) {.importc.} - proc glImageTransformParameterfvHP(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glUniform3uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} - proc glGetInvariantIntegervEXT(id: TGLuint, value: TGLenum, data: ptr TGLint) {.importc.} - proc glGetTransformFeedbackVaryingEXT(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, size: ptr TGLsizei, `type`: ptr TGLenum, name: ptr TGLchar) {.importc.} - proc glSamplerParameterIuiv(sampler: TGLuint, pname: TGLenum, param: ptr TGLuint) {.importc.} - proc glProgramUniform2fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} - proc glMultiTexCoord2hvNV(target: TGLenum, v: ptr TGLhalfNV) {.importc.} - proc glDeleteRenderbuffersOES(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} - proc glRenderbufferStorageMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glStencilClearTagEXT(stencilTagBits: TGLsizei, stencilClearTag: TGLuint) {.importc.} - proc glConvolutionParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glFenceSyncAPPLE(condition: TGLenum, flags: TGLbitfield): TGLsync {.importc.} - proc glGetVariantArrayObjectivATI(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glProgramUniform4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glPushDebugGroupKHR(source: TGLenum, id: TGLuint, length: TGLsizei, message: ptr TGLchar) {.importc.} - proc glFragmentLightivSGIX(light: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glFramebufferTexture2DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glGetActiveSubroutineUniformiv(program: TGLuint, shadertype: TGLenum, index: TGLuint, pname: TGLenum, values: ptr TGLint) {.importc.} - proc glFrustumf(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} - proc glEndQueryIndexed(target: TGLenum, index: TGLuint) {.importc.} - proc glCompressedTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glGetProgramPipelineInfoLogEXT(pipeline: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, infoLog: ptr TGLchar) {.importc.} - proc glGetVertexAttribfvNV(index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVertexArrayIndexOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glDrawTexsvOES(coords: ptr TGLshort) {.importc.} - proc glMultiTexCoord1hNV(target: TGLenum, s: TGLhalfNV) {.importc.} - proc glWindowPos2iv(v: ptr TGLint) {.importc.} - proc glMultiTexCoordP1ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} - proc glTexCoord1i(s: TGLint) {.importc.} - proc glVertex4hvNV(v: ptr TGLhalfNV) {.importc.} - proc glCallLists(n: TGLsizei, `type`: TGLenum, lists: pointer) {.importc.} - proc glIndexFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc.} - proc glPointParameterfARB(pname: TGLenum, param: TGLfloat) {.importc.} - proc glProgramUniform1dv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glGetVertexAttribArrayObjectfvATI(index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVDPAUUnmapSurfacesNV(numSurface: TGLsizei, surfaces: ptr TGLvdpauSurfaceNV) {.importc.} - proc glVertexAttribIFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} - proc glClearColorx(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} - proc glColor3bv(v: ptr TGLbyte) {.importc.} - proc glNamedProgramLocalParameter4dEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glVertexPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glGetObjectLabelKHR(identifier: TGLenum, name: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, label: ptr TGLchar) {.importc.} - proc glCombinerStageParameterfvNV(stage: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glNormal3hvNV(v: ptr TGLhalfNV) {.importc.} - proc glUniform2i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT) {.importc.} - proc glMultiTexCoord2iv(target: TGLenum, v: ptr TGLint) {.importc.} - proc glProgramUniform3i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} - proc glDeleteAsyncMarkersSGIX(marker: TGLuint, range: TGLsizei) {.importc.} - proc glStencilOp(fail: TGLenum, zfail: TGLenum, zpass: TGLenum) {.importc.} - proc glColorP4ui(`type`: TGLenum, color: TGLuint) {.importc.} - proc glFinishAsyncSGIX(markerp: ptr TGLuint): TGLint {.importc.} - proc glDrawTexsOES(x: TGLshort, y: TGLshort, z: TGLshort, width: TGLshort, height: TGLshort) {.importc.} - proc glLineStipple(factor: TGLint, pattern: TGLushort) {.importc.} - proc glAlphaFragmentOp1ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint) {.importc.} - proc glMapTexture2DINTEL(texture: TGLuint, level: TGLint, access: TGLbitfield, stride: ptr TGLint, layout: ptr TGLenum) {.importc.} - proc glVertex4f(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glFramebufferTextureARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glProgramUniform3ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc.} - proc glMultTransposeMatrixxOES(m: ptr TGLfixed) {.importc.} - proc glNormal3fv(v: ptr TGLfloat) {.importc.} - proc glUniform4fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} - proc glBinormal3bEXT(bx: TGLbyte, by: TGLbyte, bz: TGLbyte) {.importc.} - proc glGenProgramPipelinesEXT(n: TGLsizei, pipelines: ptr TGLuint) {.importc.} - proc glDispatchComputeIndirect(indirect: TGLintptr) {.importc.} - proc glGetPerfMonitorCounterDataAMD(monitor: TGLuint, pname: TGLenum, dataSize: TGLsizei, data: ptr TGLuint, bytesWritten: ptr TGLint) {.importc.} - proc glStencilOpValueAMD(face: TGLenum, value: TGLuint) {.importc.} - proc glTangent3fvEXT(v: ptr TGLfloat) {.importc.} - proc glUniform3iARB(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} - proc glMatrixScalefEXT(mode: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glVertexAttrib2dARB(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} - proc glIsVertexArray(`array`: TGLuint): TGLboolean {.importc.} - proc glGetMaterialx(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glMultiTexCoord1dARB(target: TGLenum, s: TGLdouble) {.importc.} - proc glColor3usv(v: ptr TGLushort) {.importc.} - proc glVertexStream3svATI(stream: TGLenum, coords: ptr TGLshort) {.importc.} - proc glRasterPos3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glMultiTexCoord2bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte) {.importc.} - proc glGetClipPlanefOES(plane: TGLenum, equation: ptr TGLfloat) {.importc.} - proc glFramebufferTextureEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glVertexAttrib1dNV(index: TGLuint, x: TGLdouble) {.importc.} - proc glSampleCoverageOES(value: TGLfixed, invert: TGLboolean) {.importc.} - proc glCompressedTexSubImage2DARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} - proc glUniform1iv(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glExtGetProgramsQCOM(programs: ptr TGLuint, maxPrograms: TGLint, numPrograms: ptr TGLint) {.importc.} - proc glFogx(pname: TGLenum, param: TGLfixed) {.importc.} - proc glMultiTexCoord3hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV) {.importc.} - proc glClipPlane(plane: TGLenum, equation: ptr TGLdouble) {.importc.} - proc glConvolutionParameterxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glInvalidateBufferData(buffer: TGLuint) {.importc.} - proc glCheckNamedFramebufferStatusEXT(framebuffer: TGLuint, target: TGLenum): TGLenum {.importc.} - proc glLinkProgram(program: TGLuint) {.importc.} - proc glCheckFramebufferStatus(target: TGLenum): TGLenum {.importc.} - proc glBlendFunci(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc.} - proc glProgramUniform4uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glConvolutionFilter2D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} - proc glVertex4bvOES(coords: ptr TGLbyte) {.importc.} - proc glCopyTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glColor4uiv(v: ptr TGLuint) {.importc.} - proc glGetBufferParameteri64v(target: TGLenum, pname: TGLenum, params: ptr TGLint64) {.importc.} - proc glGetLocalConstantBooleanvEXT(id: TGLuint, value: TGLenum, data: ptr TGLboolean) {.importc.} - proc glCoverStrokePathNV(path: TGLuint, coverMode: TGLenum) {.importc.} - proc glScaled(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glLightfv(light: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glTexParameterIiv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glMakeImageHandleResidentNV(handle: TGLuint64, access: TGLenum) {.importc.} - proc glWindowPos3iARB(x: TGLint, y: TGLint, z: TGLint) {.importc.} - proc glListBase(base: TGLuint) {.importc.} - proc glFlushMappedBufferRangeEXT(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr) {.importc.} - proc glNormal3dv(v: ptr TGLdouble) {.importc.} - proc glProgramUniform4d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble, v2: TGLdouble, v3: TGLdouble) {.importc.} - proc glCreateShaderProgramEXT(`type`: TGLenum, string: ptr TGLchar): TGLuint {.importc.} - proc glGetLightxvOES(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glGetObjectPtrLabelKHR(`ptr`: ptr pointer, bufSize: TGLsizei, length: ptr TGLsizei, label: ptr TGLchar) {.importc.} - proc glTransformPathNV(resultPath: TGLuint, srcPath: TGLuint, transformType: TGLenum, transformValues: ptr TGLfloat) {.importc.} - proc glMultTransposeMatrixf(m: ptr TGLfloat) {.importc.} - proc glMapVertexAttrib2dAPPLE(index: TGLuint, size: TGLuint, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, points: ptr TGLdouble) {.importc.} - proc glIsSync(sync: TGLsync): TGLboolean {.importc.} - proc glMultMatrixx(m: ptr TGLfixed) {.importc.} - proc glInterpolatePathsNV(resultPath: TGLuint, pathA: TGLuint, pathB: TGLuint, weight: TGLfloat) {.importc.} - proc glEnableClientStateIndexedEXT(`array`: TGLenum, index: TGLuint) {.importc.} - proc glProgramEnvParameter4fARB(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glVertexAttrib2svARB(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glLighti(light: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glSelectBuffer(size: TGLsizei, buffer: ptr TGLuint) {.importc.} - proc glReplacementCodeusvSUN(code: ptr TGLushort) {.importc.} - proc glMapVertexAttrib1fAPPLE(index: TGLuint, size: TGLuint, u1: TGLfloat, u2: TGLfloat, stride: TGLint, order: TGLint, points: ptr TGLfloat) {.importc.} - proc glMaterialx(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glDrawTransformFeedback(mode: TGLenum, id: TGLuint) {.importc.} - proc glWindowPos2i(x: TGLint, y: TGLint) {.importc.} - proc glMultiTexEnviEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glProgramUniform1fv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glDrawBuffersARB(n: TGLsizei, bufs: ptr TGLenum) {.importc.} - proc glGetUniformLocationARB(programObj: TGLhandleARB, name: ptr TGLcharARB): TGLint {.importc.} + proc glGetnColorTableARB(target: GLenum, format: GLenum, `type`: GLenum, bufSize: GLsizei, table: pointer) {.importc.} + proc glMatrixLoadIdentityEXT(mode: GLenum) {.importc.} + proc glGetNamedProgramivEXT(program: GLuint, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glCopyTextureSubImage2DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glUniform4i64NV(location: GLint, x: GLint64EXT, y: GLint64EXT, z: GLint64EXT, w: GLint64EXT) {.importc.} + proc glDeleteTexturesEXT(n: GLsizei, textures: ptr GLuint) {.importc.} + proc glMultiTexCoord1dv(target: GLenum, v: ptr GLdouble) {.importc.} + proc glMultiTexRenderbufferEXT(texunit: GLenum, target: GLenum, renderbuffer: GLuint) {.importc.} + proc glMultiDrawArraysIndirect(mode: GLenum, indirect: ptr pointer, drawcount: GLsizei, stride: GLsizei) {.importc.} + proc glGetUniformfvARB(programObj: GLhandleARB, location: GLint, params: ptr GLfloat) {.importc.} + proc glBufferDataARB(target: GLenum, size: GLsizeiptrARB, data: pointer, usage: GLenum) {.importc.} + proc glTexCoord2d(s: GLdouble, t: GLdouble) {.importc.} + proc glGetArrayObjectfvATI(`array`: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glShaderOp1EXT(op: GLenum, res: GLuint, arg1: GLuint) {.importc.} + proc glColor3s(red: GLshort, green: GLshort, blue: GLshort) {.importc.} + proc glStencilFuncSeparate(face: GLenum, func: GLenum, `ref`: GLint, mask: GLuint) {.importc.} + proc glTextureImage2DMultisampleCoverageNV(texture: GLuint, target: GLenum, coverageSamples: GLsizei, colorSamples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glMultiTexCoord2xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} + proc glGetVertexAttribLui64vNV(index: GLuint, pname: GLenum, params: ptr GLuint64EXT) {.importc.} + proc glNormal3xOES(nx: GLfixed, ny: GLfixed, nz: GLfixed) {.importc.} + proc glMapBufferRangeEXT(target: GLenum, offset: GLintptr, length: GLsizeiptr, access: GLbitfield) {.importc.} + proc glCreateShader(`type`: GLenum): TGLuint {.importc.} + proc glDrawRangeElementArrayAPPLE(mode: GLenum, start: GLuint, `end`: GLuint, first: GLint, count: GLsizei) {.importc.} + proc glVertex2bOES(x: GLbyte) {.importc.} + proc glGetMapxvOES(target: GLenum, query: GLenum, v: ptr GLfixed) {.importc.} + proc glRasterPos3sv(v: ptr GLshort) {.importc.} + proc glDeleteQueriesARB(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glProgramUniform1iv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glVertexStream2dvATI(stream: GLenum, coords: ptr GLdouble) {.importc.} + proc glBindVertexArrayOES(`array`: GLuint) {.importc.} + proc glLightModelfv(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glEvalCoord2dv(u: ptr GLdouble) {.importc.} + proc glColor3hNV(red: GLhalfNV, green: GLhalfNV, blue: GLhalfNV) {.importc.} + proc glSecondaryColor3iEXT(red: GLint, green: GLint, blue: GLint) {.importc.} + proc glBindTexture(target: GLenum, texture: GLuint) {.importc.} + proc glUniformBufferEXT(program: GLuint, location: GLint, buffer: GLuint) {.importc.} + proc glGetCombinerInputParameterfvNV(stage: GLenum, portion: GLenum, variable: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glUniform2ui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} + proc glMatrixMultTransposefEXT(mode: GLenum, m: ptr GLfloat) {.importc.} + proc glLineWidth(width: GLfloat) {.importc.} + proc glRotatef(angle: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glNormalStream3svATI(stream: GLenum, coords: ptr GLshort) {.importc.} + proc glTexCoordP4ui(`type`: GLenum, coords: GLuint) {.importc.} + proc glImageTransformParameterfvHP(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glUniform3uiEXT(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} + proc glGetInvariantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} + proc glGetTransformFeedbackVaryingEXT(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glSamplerParameterIuiv(sampler: GLuint, pname: GLenum, param: ptr GLuint) {.importc.} + proc glProgramUniform2fEXT(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} + proc glMultiTexCoord2hvNV(target: GLenum, v: ptr GLhalfNV) {.importc.} + proc glDeleteRenderbuffersOES(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glRenderbufferStorageMultisampleCoverageNV(target: GLenum, coverageSamples: GLsizei, colorSamples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glStencilClearTagEXT(stencilTagBits: GLsizei, stencilClearTag: GLuint) {.importc.} + proc glConvolutionParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glFenceSyncAPPLE(condition: GLenum, flags: GLbitfield): TGLsync {.importc.} + proc glGetVariantArrayObjectivATI(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniform4dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glPushDebugGroupKHR(source: GLenum, id: GLuint, length: GLsizei, message: ptr GLchar) {.importc.} + proc glFragmentLightivSGIX(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glFramebufferTexture2DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glGetActiveSubroutineUniformiv(program: GLuint, shadertype: GLenum, index: GLuint, pname: GLenum, values: ptr GLint) {.importc.} + proc glFrustumf(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} + proc glEndQueryIndexed(target: GLenum, index: GLuint) {.importc.} + proc glCompressedTextureSubImage3DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glGetProgramPipelineInfoLogEXT(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetVertexAttribfvNV(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexArrayIndexOffsetEXT(vaobj: GLuint, buffer: GLuint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glDrawTexsvOES(coords: ptr GLshort) {.importc.} + proc glMultiTexCoord1hNV(target: GLenum, s: GLhalfNV) {.importc.} + proc glWindowPos2iv(v: ptr GLint) {.importc.} + proc glMultiTexCoordP1ui(texture: GLenum, `type`: GLenum, coords: GLuint) {.importc.} + proc glTexCoord1i(s: GLint) {.importc.} + proc glVertex4hvNV(v: ptr GLhalfNV) {.importc.} + proc glCallLists(n: GLsizei, `type`: GLenum, lists: pointer) {.importc.} + proc glIndexFormatNV(`type`: GLenum, stride: GLsizei) {.importc.} + proc glPointParameterfARB(pname: GLenum, param: GLfloat) {.importc.} + proc glProgramUniform1dv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glGetVertexAttribArrayObjectfvATI(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVDPAUUnmapSurfacesNV(numSurface: GLsizei, surfaces: ptr GLvdpauSurfaceNV) {.importc.} + proc glVertexAttribIFormat(attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} + proc glClearColorx(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glColor3bv(v: ptr GLbyte) {.importc.} + proc glNamedProgramLocalParameter4dEXT(program: GLuint, target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glVertexPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glGetObjectLabelKHR(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glCombinerStageParameterfvNV(stage: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glNormal3hvNV(v: ptr GLhalfNV) {.importc.} + proc glUniform2i64NV(location: GLint, x: GLint64EXT, y: GLint64EXT) {.importc.} + proc glMultiTexCoord2iv(target: GLenum, v: ptr GLint) {.importc.} + proc glProgramUniform3i(program: GLuint, location: GLint, v0: GLint, v1: GLint, v2: GLint) {.importc.} + proc glDeleteAsyncMarkersSGIX(marker: GLuint, range: GLsizei) {.importc.} + proc glStencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum) {.importc.} + proc glColorP4ui(`type`: GLenum, color: GLuint) {.importc.} + proc glFinishAsyncSGIX(markerp: ptr GLuint): TGLint {.importc.} + proc glDrawTexsOES(x: GLshort, y: GLshort, z: GLshort, width: GLshort, height: GLshort) {.importc.} + proc glLineStipple(factor: GLint, pattern: GLushort) {.importc.} + proc glAlphaFragmentOp1ATI(op: GLenum, dst: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint) {.importc.} + proc glMapTexture2DINTEL(texture: GLuint, level: GLint, access: GLbitfield, stride: ptr GLint, layout: ptr GLenum) {.importc.} + proc glVertex4f(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glFramebufferTextureARB(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glProgramUniform3ui64NV(program: GLuint, location: GLint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT) {.importc.} + proc glMultTransposeMatrixxOES(m: ptr GLfixed) {.importc.} + proc glNormal3fv(v: ptr GLfloat) {.importc.} + proc glUniform4fARB(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat, v3: GLfloat) {.importc.} + proc glBinormal3bEXT(bx: GLbyte, by: GLbyte, bz: GLbyte) {.importc.} + proc glGenProgramPipelinesEXT(n: GLsizei, pipelines: ptr GLuint) {.importc.} + proc glDispatchComputeIndirect(indirect: GLintptr) {.importc.} + proc glGetPerfMonitorCounterDataAMD(monitor: GLuint, pname: GLenum, dataSize: GLsizei, data: ptr GLuint, bytesWritten: ptr GLint) {.importc.} + proc glStencilOpValueAMD(face: GLenum, value: GLuint) {.importc.} + proc glTangent3fvEXT(v: ptr GLfloat) {.importc.} + proc glUniform3iARB(location: GLint, v0: GLint, v1: GLint, v2: GLint) {.importc.} + proc glMatrixScalefEXT(mode: GLenum, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVertexAttrib2dARB(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} + proc glIsVertexArray(`array`: GLuint): TGLboolean {.importc.} + proc glGetMaterialx(face: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glMultiTexCoord1dARB(target: GLenum, s: GLdouble) {.importc.} + proc glColor3usv(v: ptr GLushort) {.importc.} + proc glVertexStream3svATI(stream: GLenum, coords: ptr GLshort) {.importc.} + proc glRasterPos3s(x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glMultiTexCoord2bOES(texture: GLenum, s: GLbyte, t: GLbyte) {.importc.} + proc glGetClipPlanefOES(plane: GLenum, equation: ptr GLfloat) {.importc.} + proc glFramebufferTextureEXT(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glVertexAttrib1dNV(index: GLuint, x: GLdouble) {.importc.} + proc glSampleCoverageOES(value: GLfixed, invert: GLboolean) {.importc.} + proc glCompressedTexSubImage2DARB(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glUniform1iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glExtGetProgramsQCOM(programs: ptr GLuint, maxPrograms: GLint, numPrograms: ptr GLint) {.importc.} + proc glFogx(pname: GLenum, param: GLfixed) {.importc.} + proc glMultiTexCoord3hNV(target: GLenum, s: GLhalfNV, t: GLhalfNV, r: GLhalfNV) {.importc.} + proc glClipPlane(plane: GLenum, equation: ptr GLdouble) {.importc.} + proc glConvolutionParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glInvalidateBufferData(buffer: GLuint) {.importc.} + proc glCheckNamedFramebufferStatusEXT(framebuffer: GLuint, target: GLenum): TGLenum {.importc.} + proc glLinkProgram(program: GLuint) {.importc.} + proc glCheckFramebufferStatus(target: GLenum): TGLenum {.importc.} + proc glBlendFunci(buf: GLuint, src: GLenum, dst: GLenum) {.importc.} + proc glProgramUniform4uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glConvolutionFilter2D(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glVertex4bvOES(coords: ptr GLbyte) {.importc.} + proc glCopyTextureSubImage1DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glColor4uiv(v: ptr GLuint) {.importc.} + proc glGetBufferParameteri64v(target: GLenum, pname: GLenum, params: ptr GLint64) {.importc.} + proc glGetLocalConstantBooleanvEXT(id: GLuint, value: GLenum, data: ptr GLboolean) {.importc.} + proc glCoverStrokePathNV(path: GLuint, coverMode: GLenum) {.importc.} + proc glScaled(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glLightfv(light: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexParameterIiv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMakeImageHandleResidentNV(handle: GLuint64, access: GLenum) {.importc.} + proc glWindowPos3iARB(x: GLint, y: GLint, z: GLint) {.importc.} + proc glListBase(base: GLuint) {.importc.} + proc glFlushMappedBufferRangeEXT(target: GLenum, offset: GLintptr, length: GLsizeiptr) {.importc.} + proc glNormal3dv(v: ptr GLdouble) {.importc.} + proc glProgramUniform4d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble, v2: GLdouble, v3: GLdouble) {.importc.} + proc glCreateShaderProgramEXT(`type`: GLenum, string: ptr GLchar): TGLuint {.importc.} + proc glGetLightxvOES(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glGetObjectPtrLabelKHR(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glTransformPathNV(resultPath: GLuint, srcPath: GLuint, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} + proc glMultTransposeMatrixf(m: ptr GLfloat) {.importc.} + proc glMapVertexAttrib2dAPPLE(index: GLuint, size: GLuint, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: ptr GLdouble) {.importc.} + proc glIsSync(sync: GLsync): TGLboolean {.importc.} + proc glMultMatrixx(m: ptr GLfixed) {.importc.} + proc glInterpolatePathsNV(resultPath: GLuint, pathA: GLuint, pathB: GLuint, weight: GLfloat) {.importc.} + proc glEnableClientStateIndexedEXT(`array`: GLenum, index: GLuint) {.importc.} + proc glProgramEnvParameter4fARB(target: GLenum, index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glVertexAttrib2svARB(index: GLuint, v: ptr GLshort) {.importc.} + proc glLighti(light: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glSelectBuffer(size: GLsizei, buffer: ptr GLuint) {.importc.} + proc glReplacementCodeusvSUN(code: ptr GLushort) {.importc.} + proc glMapVertexAttrib1fAPPLE(index: GLuint, size: GLuint, u1: GLfloat, u2: GLfloat, stride: GLint, order: GLint, points: ptr GLfloat) {.importc.} + proc glMaterialx(face: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glDrawTransformFeedback(mode: GLenum, id: GLuint) {.importc.} + proc glWindowPos2i(x: GLint, y: GLint) {.importc.} + proc glMultiTexEnviEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glProgramUniform1fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glDrawBuffersARB(n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glGetUniformLocationARB(programObj: GLhandleARB, name: ptr GLcharARB): TGLint {.importc.} proc glResumeTransformFeedback() {.importc.} - proc glMap1f(target: TGLenum, u1: TGLfloat, u2: TGLfloat, stride: TGLint, order: TGLint, points: ptr TGLfloat) {.importc.} - proc glVertex3xOES(x: TGLfixed, y: TGLfixed) {.importc.} - proc glPathCoordsNV(path: TGLuint, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} - proc glListParameterfSGIX(list: TGLuint, pname: TGLenum, param: TGLfloat) {.importc.} - proc glGetUniformivARB(programObj: TGLhandleARB, location: TGLint, params: ptr TGLint) {.importc.} - proc glBinormal3bvEXT(v: ptr TGLbyte) {.importc.} - proc glVertexAttribP3ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} - proc glGetVertexArrayPointeri_vEXT(vaobj: TGLuint, index: TGLuint, pname: TGLenum, param: ptr pointer) {.importc.} - proc glProgramParameter4fvNV(target: TGLenum, index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glDiscardFramebufferEXT(target: TGLenum, numAttachments: TGLsizei, attachments: ptr TGLenum) {.importc.} - proc glGetDebugMessageLogARB(count: TGLuint, bufsize: TGLsizei, sources: ptr TGLenum, types: ptr TGLenum, ids: ptr TGLuint, severities: ptr TGLenum, lengths: ptr TGLsizei, messageLog: ptr TGLchar): TGLuint {.importc.} + proc glMap1f(target: GLenum, u1: GLfloat, u2: GLfloat, stride: GLint, order: GLint, points: ptr GLfloat) {.importc.} + proc glVertex3xOES(x: GLfixed, y: GLfixed) {.importc.} + proc glPathCoordsNV(path: GLuint, numCoords: GLsizei, coordType: GLenum, coords: pointer) {.importc.} + proc glListParameterfSGIX(list: GLuint, pname: GLenum, param: GLfloat) {.importc.} + proc glGetUniformivARB(programObj: GLhandleARB, location: GLint, params: ptr GLint) {.importc.} + proc glBinormal3bvEXT(v: ptr GLbyte) {.importc.} + proc glVertexAttribP3ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} + proc glGetVertexArrayPointeri_vEXT(vaobj: GLuint, index: GLuint, pname: GLenum, param: ptr pointer) {.importc.} + proc glProgramParameter4fvNV(target: GLenum, index: GLuint, v: ptr GLfloat) {.importc.} + proc glDiscardFramebufferEXT(target: GLenum, numAttachments: GLsizei, attachments: ptr GLenum) {.importc.} + proc glGetDebugMessageLogARB(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} proc glResolveMultisampleFramebufferAPPLE() {.importc.} - proc glGetIntegeri_vEXT(target: TGLenum, index: TGLuint, data: ptr TGLint) {.importc.} - proc glDepthBoundsdNV(zmin: TGLdouble, zmax: TGLdouble) {.importc.} + proc glGetIntegeri_vEXT(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} + proc glDepthBoundsdNV(zmin: GLdouble, zmax: GLdouble) {.importc.} proc glEnd() {.importc.} - proc glBindBufferBaseEXT(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc.} - proc glVertexAttribDivisor(index: TGLuint, divisor: TGLuint) {.importc.} - proc glFogCoorddEXT(coord: TGLdouble) {.importc.} - proc glFrontFace(mode: TGLenum) {.importc.} - proc glVertexAttrib1hNV(index: TGLuint, x: TGLhalfNV) {.importc.} - proc glNamedProgramLocalParametersI4uivEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLuint) {.importc.} - proc glTexCoord1dv(v: ptr TGLdouble) {.importc.} - proc glBindVideoCaptureStreamTextureNV(video_capture_slot: TGLuint, stream: TGLuint, frame_region: TGLenum, target: TGLenum, texture: TGLuint) {.importc.} - proc glWindowPos2iARB(x: TGLint, y: TGLint) {.importc.} - proc glVertexAttribFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei) {.importc.} - proc glUniform1uivEXT(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glGetVideoivNV(video_slot: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertexAttrib3fvARB(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glVertexArraySecondaryColorOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glSecondaryColor3bv(v: ptr TGLbyte) {.importc.} - proc glDispatchComputeGroupSizeARB(num_groups_x: TGLuint, num_groups_y: TGLuint, num_groups_z: TGLuint, group_size_x: TGLuint, group_size_y: TGLuint, group_size_z: TGLuint) {.importc.} - proc glNamedCopyBufferSubDataEXT(readBuffer: TGLuint, writeBuffer: TGLuint, readOffset: TGLintptr, writeOffset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glSampleCoverage(value: TGLfloat, invert: TGLboolean) {.importc.} - proc glGetnMapfvARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: ptr TGLfloat) {.importc.} - proc glVertexStream2svATI(stream: TGLenum, coords: ptr TGLshort) {.importc.} - proc glProgramParameters4fvNV(target: TGLenum, index: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} - proc glVertexAttrib4fARB(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glIndexd(c: TGLdouble) {.importc.} - proc glGetInteger64v(pname: TGLenum, params: ptr TGLint64) {.importc.} - proc glGetMultiTexImageEXT(texunit: TGLenum, target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glLightModelx(pname: TGLenum, param: TGLfixed) {.importc.} - proc glMap2f(target: TGLenum, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, points: ptr TGLfloat) {.importc.} - proc glSecondaryColorPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} - proc glVertexArrayVertexAttribIOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glProgramUniformHandleui64vARB(program: TGLuint, location: TGLint, count: TGLsizei, values: ptr TGLuint64) {.importc.} - proc glActiveProgramEXT(program: TGLuint) {.importc.} - proc glProgramUniformMatrix4x3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glCompressedTexSubImage3DARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} - proc glBindProgramPipelineEXT(pipeline: TGLuint) {.importc.} - proc glDetailTexFuncSGIS(target: TGLenum, n: TGLsizei, points: ptr TGLfloat) {.importc.} - proc glSecondaryColor3ubEXT(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc.} - proc glDrawArraysInstanced(mode: TGLenum, first: TGLint, count: TGLsizei, instancecount: TGLsizei) {.importc.} - proc glWindowPos3fARB(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glNamedProgramLocalParameter4fEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glTextureParameterfvEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glProgramUniformHandleui64ARB(program: TGLuint, location: TGLint, value: TGLuint64) {.importc.} - proc glHistogramEXT(target: TGLenum, width: TGLsizei, internalformat: TGLenum, sink: TGLboolean) {.importc.} + proc glBindBufferBaseEXT(target: GLenum, index: GLuint, buffer: GLuint) {.importc.} + proc glVertexAttribDivisor(index: GLuint, divisor: GLuint) {.importc.} + proc glFogCoorddEXT(coord: GLdouble) {.importc.} + proc glFrontFace(mode: GLenum) {.importc.} + proc glVertexAttrib1hNV(index: GLuint, x: GLhalfNV) {.importc.} + proc glNamedProgramLocalParametersI4uivEXT(program: GLuint, target: GLenum, index: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} + proc glTexCoord1dv(v: ptr GLdouble) {.importc.} + proc glBindVideoCaptureStreamTextureNV(video_capture_slot: GLuint, stream: GLuint, frame_region: GLenum, target: GLenum, texture: GLuint) {.importc.} + proc glWindowPos2iARB(x: GLint, y: GLint) {.importc.} + proc glVertexAttribFormatNV(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei) {.importc.} + proc glUniform1uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glGetVideoivNV(video_slot: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttrib3fvARB(index: GLuint, v: ptr GLfloat) {.importc.} + proc glVertexArraySecondaryColorOffsetEXT(vaobj: GLuint, buffer: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glSecondaryColor3bv(v: ptr GLbyte) {.importc.} + proc glDispatchComputeGroupSizeARB(num_groups_x: GLuint, num_groups_y: GLuint, num_groups_z: GLuint, group_size_x: GLuint, group_size_y: GLuint, group_size_z: GLuint) {.importc.} + proc glNamedCopyBufferSubDataEXT(readBuffer: GLuint, writeBuffer: GLuint, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr) {.importc.} + proc glSampleCoverage(value: GLfloat, invert: GLboolean) {.importc.} + proc glGetnMapfvARB(target: GLenum, query: GLenum, bufSize: GLsizei, v: ptr GLfloat) {.importc.} + proc glVertexStream2svATI(stream: GLenum, coords: ptr GLshort) {.importc.} + proc glProgramParameters4fvNV(target: GLenum, index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glVertexAttrib4fARB(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glIndexd(c: GLdouble) {.importc.} + proc glGetInteger64v(pname: GLenum, params: ptr GLint64) {.importc.} + proc glGetMultiTexImageEXT(texunit: GLenum, target: GLenum, level: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glLightModelx(pname: GLenum, param: GLfixed) {.importc.} + proc glMap2f(target: GLenum, u1: GLfloat, u2: GLfloat, ustride: GLint, uorder: GLint, v1: GLfloat, v2: GLfloat, vstride: GLint, vorder: GLint, points: ptr GLfloat) {.importc.} + proc glSecondaryColorPointerListIBM(size: GLint, `type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glVertexArrayVertexAttribIOffsetEXT(vaobj: GLuint, buffer: GLuint, index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glProgramUniformHandleui64vARB(program: GLuint, location: GLint, count: GLsizei, values: ptr GLuint64) {.importc.} + proc glActiveProgramEXT(program: GLuint) {.importc.} + proc glProgramUniformMatrix4x3fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glCompressedTexSubImage3DARB(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glBindProgramPipelineEXT(pipeline: GLuint) {.importc.} + proc glDetailTexFuncSGIS(target: GLenum, n: GLsizei, points: ptr GLfloat) {.importc.} + proc glSecondaryColor3ubEXT(red: GLubyte, green: GLubyte, blue: GLubyte) {.importc.} + proc glDrawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instancecount: GLsizei) {.importc.} + proc glWindowPos3fARB(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glNamedProgramLocalParameter4fEXT(program: GLuint, target: GLenum, index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glTextureParameterfvEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glProgramUniformHandleui64ARB(program: GLuint, location: GLint, value: GLuint64) {.importc.} + proc glHistogramEXT(target: GLenum, width: GLsizei, internalformat: GLenum, sink: GLboolean) {.importc.} proc glResumeTransformFeedbackNV() {.importc.} - proc glGetMaterialxv(face: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glMultiTexCoord1sv(target: TGLenum, v: ptr TGLshort) {.importc.} - proc glReadInstrumentsSGIX(marker: TGLint) {.importc.} - proc glTexCoord4hNV(s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV, q: TGLhalfNV) {.importc.} - proc glVertexAttribL4i64vNV(index: TGLuint, v: ptr TGLint64EXT) {.importc.} - proc glEnableVariantClientStateEXT(id: TGLuint) {.importc.} - proc glSyncTextureINTEL(texture: TGLuint) {.importc.} - proc glGetObjectPtrLabel(`ptr`: ptr pointer, bufSize: TGLsizei, length: ptr TGLsizei, label: ptr TGLchar) {.importc.} - proc glCopyTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glOrthofOES(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} - proc glWindowPos3sARB(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glIsBufferARB(buffer: TGLuint): TGLboolean {.importc.} - proc glColor3sv(v: ptr TGLshort) {.importc.} - proc glEvalMesh1(mode: TGLenum, i1: TGLint, i2: TGLint) {.importc.} - proc glMultiDrawArrays(mode: TGLenum, first: ptr TGLint, count: ptr TGLsizei, drawcount: TGLsizei) {.importc.} - proc glGetMultiTexEnvfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glWindowPos3fMESA(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glExtGetFramebuffersQCOM(framebuffers: ptr TGLuint, maxFramebuffers: TGLint, numFramebuffers: ptr TGLint) {.importc.} - proc glTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glVertexAttrib4uiv(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glProgramUniformui64NV(program: TGLuint, location: TGLint, value: TGLuint64EXT) {.importc.} - proc glMultiTexCoord2ivARB(target: TGLenum, v: ptr TGLint) {.importc.} - proc glProgramUniform4i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc.} - proc glWindowPos2svMESA(v: ptr TGLshort) {.importc.} - proc glVertexAttrib3dv(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glColor4i(red: TGLint, green: TGLint, blue: TGLint, alpha: TGLint) {.importc.} - proc glClampColor(target: TGLenum, clamp: TGLenum) {.importc.} - proc glVertexP2ui(`type`: TGLenum, value: TGLuint) {.importc.} - proc glGenQueries(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glBindBufferOffsetNV(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr) {.importc.} - proc glGetFragDataLocation(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} - proc glVertexAttribs2svNV(index: TGLuint, count: TGLsizei, v: ptr TGLshort) {.importc.} - proc glGetPathLengthNV(path: TGLuint, startSegment: TGLsizei, numSegments: TGLsizei): TGLfloat {.importc.} - proc glVertexAttrib3dARB(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glMultiTexGenfvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glFlushPixelDataRangeNV(target: TGLenum) {.importc.} - proc glReplacementCodeuiNormal3fVertex3fSUN(rc: TGLuint, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glPathParameteriNV(path: TGLuint, pname: TGLenum, value: TGLint) {.importc.} - proc glVertexAttribI2iEXT(index: TGLuint, x: TGLint, y: TGLint) {.importc.} - proc glPixelStorei(pname: TGLenum, param: TGLint) {.importc.} - proc glGetNamedFramebufferParameterivEXT(framebuffer: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetTexEnvxv(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glPathStringNV(path: TGLuint, format: TGLenum, length: TGLsizei, pathString: pointer) {.importc.} - proc glDepthMask(flag: TGLboolean) {.importc.} - proc glCopyTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} - proc glDepthRangexOES(n: TGLfixed, f: TGLfixed) {.importc.} - proc glUniform2i64vNV(location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} - proc glSetFragmentShaderConstantATI(dst: TGLuint, value: ptr TGLfloat) {.importc.} - proc glAttachShader(program: TGLuint, shader: TGLuint) {.importc.} - proc glGetFramebufferParameterivEXT(framebuffer: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glPointParameteriNV(pname: TGLenum, param: TGLint) {.importc.} - proc glWindowPos2dMESA(x: TGLdouble, y: TGLdouble) {.importc.} - proc glGetTextureParameterfvEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glTexBumpParameterfvATI(pname: TGLenum, param: ptr TGLfloat) {.importc.} - proc glCompressedTexImage1DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glGetTexGendv(coord: TGLenum, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glGetFragmentMaterialfvSGIX(face: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glBeginConditionalRenderNVX(id: TGLuint) {.importc.} - proc glLightModelxOES(pname: TGLenum, param: TGLfixed) {.importc.} - proc glTexCoord2xOES(s: TGLfixed, t: TGLfixed) {.importc.} - proc glProgramUniformMatrix2x4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glRasterPos2xvOES(coords: ptr TGLfixed) {.importc.} - proc glGetMapiv(target: TGLenum, query: TGLenum, v: ptr TGLint) {.importc.} - proc glGetImageHandleARB(texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, format: TGLenum): TGLuint64 {.importc.} - proc glVDPAURegisterVideoSurfaceNV(vdpSurface: pointer, target: TGLenum, numTextureNames: TGLsizei, textureNames: ptr TGLuint): TGLvdpauSurfaceNV {.importc.} - proc glVertexAttribL2dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} - proc glVertexAttrib1dvNV(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glPollAsyncSGIX(markerp: ptr TGLuint): TGLint {.importc.} - proc glCullParameterfvEXT(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glMakeNamedBufferResidentNV(buffer: TGLuint, access: TGLenum) {.importc.} - proc glPointParameterfSGIS(pname: TGLenum, param: TGLfloat) {.importc.} - proc glGenLists(range: TGLsizei): TGLuint {.importc.} - proc glGetTexBumpParameterfvATI(pname: TGLenum, param: ptr TGLfloat) {.importc.} - proc glCompressedMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glFinishFenceNV(fence: TGLuint) {.importc.} - proc glPointSize(size: TGLfloat) {.importc.} - proc glCompressedTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glGetUniformui64vNV(program: TGLuint, location: TGLint, params: ptr TGLuint64EXT) {.importc.} - proc glGetMapControlPointsNV(target: TGLenum, index: TGLuint, `type`: TGLenum, ustride: TGLsizei, vstride: TGLsizei, packed: TGLboolean, points: pointer) {.importc.} - proc glGetPathColorGenfvNV(color: TGLenum, pname: TGLenum, value: ptr TGLfloat) {.importc.} - proc glTexCoord2f(s: TGLfloat, t: TGLfloat) {.importc.} - proc glSampleMaski(index: TGLuint, mask: TGLbitfield) {.importc.} - proc glReadBufferIndexedEXT(src: TGLenum, index: TGLint) {.importc.} - proc glCoverFillPathNV(path: TGLuint, coverMode: TGLenum) {.importc.} - proc glColorTableParameterfvSGI(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glDeleteVertexArraysAPPLE(n: TGLsizei, arrays: ptr TGLuint) {.importc.} - proc glGetVertexAttribIiv(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glWeightbvARB(size: TGLint, weights: ptr TGLbyte) {.importc.} - proc glGetNamedBufferPointervEXT(buffer: TGLuint, pname: TGLenum, params: ptr pointer) {.importc.} - proc glTexCoordPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glColor4fv(v: ptr TGLfloat) {.importc.} - proc glGetnUniformfvARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLfloat) {.importc.} - proc glMaterialxOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glGetFixedv(pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glMaterialf(face: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glVideoCaptureStreamParameterfvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glGetDebugMessageLogAMD(count: TGLuint, bufsize: TGLsizei, categories: ptr TGLenum, severities: ptr TGLuint, ids: ptr TGLuint, lengths: ptr TGLsizei, message: ptr TGLchar): TGLuint {.importc.} - proc glProgramUniform2uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glMatrixMultTransposedEXT(mode: TGLenum, m: ptr TGLdouble) {.importc.} - proc glIsPointInStrokePathNV(path: TGLuint, x: TGLfloat, y: TGLfloat): TGLboolean {.importc.} - proc glDisable(cap: TGLenum) {.importc.} - proc glCompileShader(shader: TGLuint) {.importc.} - proc glLoadTransposeMatrixd(m: ptr TGLdouble) {.importc.} - proc glGetMultiTexParameterIuivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glGetHistogram(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} - proc glMultiTexCoord3fvARB(target: TGLenum, v: ptr TGLfloat) {.importc.} - proc glColor4xvOES(components: ptr TGLfixed) {.importc.} - proc glIsBuffer(buffer: TGLuint): TGLboolean {.importc.} - proc glVertex2dv(v: ptr TGLdouble) {.importc.} - proc glNamedProgramLocalParameterI4uivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} - proc glPixelTexGenParameteriSGIS(pname: TGLenum, param: TGLint) {.importc.} - proc glBindVertexBuffers(first: TGLuint, count: TGLsizei, buffers: ptr TGLuint, offsets: ptr TGLintptr, strides: ptr TGLsizei) {.importc.} - proc glUniform1ui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} - proc glColor4ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte, alpha: TGLubyte) {.importc.} - proc glConvolutionParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc: TGLuint, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glVertexAttribI2ui(index: TGLuint, x: TGLuint, y: TGLuint) {.importc.} - proc glDeleteNamesAMD(identifier: TGLenum, num: TGLuint, names: ptr TGLuint) {.importc.} - proc glPixelTransferxOES(pname: TGLenum, param: TGLfixed) {.importc.} - proc glVertexAttrib4ivARB(index: TGLuint, v: ptr TGLint) {.importc.} - proc glLightModeli(pname: TGLenum, param: TGLint) {.importc.} - proc glGetHistogramEXT(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} - proc glWindowPos3svMESA(v: ptr TGLshort) {.importc.} - proc glRasterPos3iv(v: ptr TGLint) {.importc.} - proc glCopyTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glTextureStorage3DMultisampleEXT(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} - proc glIsNameAMD(identifier: TGLenum, name: TGLuint): TGLboolean {.importc.} - proc glProgramUniformMatrix3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glGetProgramParameterfvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glTexStorage3D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} - proc glMultiTexCoord2xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed) {.importc.} - proc glWindowPos2fARB(x: TGLfloat, y: TGLfloat) {.importc.} - proc glGetProgramResourceIndex(program: TGLuint, programInterface: TGLenum, name: ptr TGLchar): TGLuint {.importc.} - proc glProgramUniform2uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glMakeImageHandleNonResidentNV(handle: TGLuint64) {.importc.} - proc glNamedProgramLocalParameter4fvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} - proc glInvalidateFramebuffer(target: TGLenum, numAttachments: TGLsizei, attachments: ptr TGLenum) {.importc.} - proc glTexStorage3DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} - proc glMapVertexAttrib2fAPPLE(index: TGLuint, size: TGLuint, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, points: ptr TGLfloat) {.importc.} - proc glCombinerParameterfNV(pname: TGLenum, param: TGLfloat) {.importc.} - proc glCopyMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} - proc glBindVertexShaderEXT(id: TGLuint) {.importc.} - proc glPathGlyphsNV(firstPathName: TGLuint, fontTarget: TGLenum, fontName: pointer, fontStyle: TGLbitfield, numGlyphs: TGLsizei, `type`: TGLenum, charcodes: pointer, handleMissingGlyphs: TGLenum, pathParameterTemplate: TGLuint, emScale: TGLfloat) {.importc.} - proc glProgramLocalParametersI4uivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLuint) {.importc.} - proc glMultiTexCoord3hvNV(target: TGLenum, v: ptr TGLhalfNV) {.importc.} - proc glMultiTexCoordP2uiv(texture: TGLenum, `type`: TGLenum, coords: ptr TGLuint) {.importc.} - proc glDisableVariantClientStateEXT(id: TGLuint) {.importc.} - proc glGetTexLevelParameterxvOES(target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glRasterPos2sv(v: ptr TGLshort) {.importc.} - proc glWeightPathsNV(resultPath: TGLuint, numPaths: TGLsizei, paths: ptr TGLuint, weights: ptr TGLfloat) {.importc.} - proc glDrawBuffersNV(n: TGLsizei, bufs: ptr TGLenum) {.importc.} - proc glBindBufferARB(target: TGLenum, buffer: TGLuint) {.importc.} - proc glVariantbvEXT(id: TGLuint, `addr`: ptr TGLbyte) {.importc.} - proc glColorP3uiv(`type`: TGLenum, color: ptr TGLuint) {.importc.} - proc glBlendEquationEXT(mode: TGLenum) {.importc.} - proc glProgramLocalParameterI4uivNV(target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} - proc glRenderMode(mode: TGLenum): TGLint {.importc.} - proc glVertexStream4fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glGetObjectLabelEXT(`type`: TGLenum, `object`: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, label: ptr TGLchar) {.importc.} - proc glNamedFramebufferTexture3DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} - proc glLoadMatrixf(m: ptr TGLfloat) {.importc.} - proc glGetQueryObjectuivEXT(id: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glBindVideoCaptureStreamBufferNV(video_capture_slot: TGLuint, stream: TGLuint, frame_region: TGLenum, offset: TGLintptrARB) {.importc.} - proc glMatrixOrthoEXT(mode: TGLenum, left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} - proc glBlendFunc(sfactor: TGLenum, dfactor: TGLenum) {.importc.} - proc glTexGenxvOES(coord: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glMatrixMode(mode: TGLenum) {.importc.} - proc glColorTableParameterivSGI(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetProgramInfoLog(program: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, infoLog: ptr TGLchar) {.importc.} - proc glGetSeparableFilter(target: TGLenum, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer, span: pointer) {.importc.} - proc glFogfv(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glDrawTexfvOES(coords: ptr TGLfloat) {.importc.} - proc glClipPlanexIMG(p: TGLenum, eqn: ptr TGLfixed) {.importc.} - proc glResetHistogramEXT(target: TGLenum) {.importc.} - proc glMemoryBarrier(barriers: TGLbitfield) {.importc.} - proc glGetPixelMapusv(map: TGLenum, values: ptr TGLushort) {.importc.} - proc glEvalCoord2f(u: TGLfloat, v: TGLfloat) {.importc.} - proc glUniform4uiv(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glIsProgramARB(program: TGLuint): TGLboolean {.importc.} - proc glPointParameterfv(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glTexBuffer(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} - proc glVertexAttrib1s(index: TGLuint, x: TGLshort) {.importc.} - proc glRenderbufferStorageMultisampleEXT(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glMapNamedBufferEXT(buffer: TGLuint, access: TGLenum) {.importc.} - proc glDebugMessageCallbackAMD(callback: TGLDEBUGPROCAMD, userParam: ptr pointer) {.importc.} - proc glGetTexEnvfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVertexAttribI3uivEXT(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glMultiTexEnvfEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glGetUniformiv(program: TGLuint, location: TGLint, params: ptr TGLint) {.importc.} - proc glProgramLocalParameters4fvEXT(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLfloat) {.importc.} - proc glStencilStrokePathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, reference: TGLint, mask: TGLuint, transformType: TGLenum, transformValues: ptr TGLfloat) {.importc.} - proc glBeginConditionalRender(id: TGLuint, mode: TGLenum) {.importc.} - proc glVertexAttribI3uiEXT(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint) {.importc.} - proc glVDPAUMapSurfacesNV(numSurfaces: TGLsizei, surfaces: ptr TGLvdpauSurfaceNV) {.importc.} - proc glGetProgramResourceName(program: TGLuint, programInterface: TGLenum, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, name: ptr TGLchar) {.importc.} - proc glMultiTexCoord4f(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc.} - proc glVertexAttrib2hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV) {.importc.} - proc glDrawArraysInstancedNV(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} - proc glClearAccum(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} - proc glVertexAttribI4usv(index: TGLuint, v: ptr TGLushort) {.importc.} - proc glGetProgramNamedParameterfvNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, params: ptr TGLfloat) {.importc.} - proc glTextureLightEXT(pname: TGLenum) {.importc.} - proc glPathSubCoordsNV(path: TGLuint, coordStart: TGLsizei, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} - proc glBindImageTexture(unit: TGLuint, texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, access: TGLenum, format: TGLenum) {.importc.} - proc glGenVertexArraysAPPLE(n: TGLsizei, arrays: ptr TGLuint) {.importc.} - proc glFogCoordf(coord: TGLfloat) {.importc.} + proc glGetMaterialxv(face: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glMultiTexCoord1sv(target: GLenum, v: ptr GLshort) {.importc.} + proc glReadInstrumentsSGIX(marker: GLint) {.importc.} + proc glTexCoord4hNV(s: GLhalfNV, t: GLhalfNV, r: GLhalfNV, q: GLhalfNV) {.importc.} + proc glVertexAttribL4i64vNV(index: GLuint, v: ptr GLint64EXT) {.importc.} + proc glEnableVariantClientStateEXT(id: GLuint) {.importc.} + proc glSyncTextureINTEL(texture: GLuint) {.importc.} + proc glGetObjectPtrLabel(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glCopyTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glOrthofOES(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} + proc glWindowPos3sARB(x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glIsBufferARB(buffer: GLuint): TGLboolean {.importc.} + proc glColor3sv(v: ptr GLshort) {.importc.} + proc glEvalMesh1(mode: GLenum, i1: GLint, i2: GLint) {.importc.} + proc glMultiDrawArrays(mode: GLenum, first: ptr GLint, count: ptr GLsizei, drawcount: GLsizei) {.importc.} + proc glGetMultiTexEnvfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glWindowPos3fMESA(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glExtGetFramebuffersQCOM(framebuffers: ptr GLuint, maxFramebuffers: GLint, numFramebuffers: ptr GLint) {.importc.} + proc glTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glVertexAttrib4uiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glProgramUniformui64NV(program: GLuint, location: GLint, value: GLuint64EXT) {.importc.} + proc glMultiTexCoord2ivARB(target: GLenum, v: ptr GLint) {.importc.} + proc glProgramUniform4i64NV(program: GLuint, location: GLint, x: GLint64EXT, y: GLint64EXT, z: GLint64EXT, w: GLint64EXT) {.importc.} + proc glWindowPos2svMESA(v: ptr GLshort) {.importc.} + proc glVertexAttrib3dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glColor4i(red: GLint, green: GLint, blue: GLint, alpha: GLint) {.importc.} + proc glClampColor(target: GLenum, clamp: GLenum) {.importc.} + proc glVertexP2ui(`type`: GLenum, value: GLuint) {.importc.} + proc glGenQueries(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glBindBufferOffsetNV(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr) {.importc.} + proc glGetFragDataLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glVertexAttribs2svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} + proc glGetPathLengthNV(path: GLuint, startSegment: GLsizei, numSegments: GLsizei): TGLfloat {.importc.} + proc glVertexAttrib3dARB(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glMultiTexGenfvEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glFlushPixelDataRangeNV(target: GLenum) {.importc.} + proc glReplacementCodeuiNormal3fVertex3fSUN(rc: GLuint, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glPathParameteriNV(path: GLuint, pname: GLenum, value: GLint) {.importc.} + proc glVertexAttribI2iEXT(index: GLuint, x: GLint, y: GLint) {.importc.} + proc glPixelStorei(pname: GLenum, param: GLint) {.importc.} + proc glGetNamedFramebufferParameterivEXT(framebuffer: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetTexEnvxv(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glPathStringNV(path: GLuint, format: GLenum, length: GLsizei, pathString: pointer) {.importc.} + proc glDepthMask(flag: GLboolean) {.importc.} + proc glCopyTexImage1D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, border: GLint) {.importc.} + proc glDepthRangexOES(n: GLfixed, f: GLfixed) {.importc.} + proc glUniform2i64vNV(location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} + proc glSetFragmentShaderConstantATI(dst: GLuint, value: ptr GLfloat) {.importc.} + proc glAttachShader(program: GLuint, shader: GLuint) {.importc.} + proc glGetFramebufferParameterivEXT(framebuffer: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glPointParameteriNV(pname: GLenum, param: GLint) {.importc.} + proc glWindowPos2dMESA(x: GLdouble, y: GLdouble) {.importc.} + proc glGetTextureParameterfvEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexBumpParameterfvATI(pname: GLenum, param: ptr GLfloat) {.importc.} + proc glCompressedTexImage1DARB(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glGetTexGendv(coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glGetFragmentMaterialfvSGIX(face: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glBeginConditionalRenderNVX(id: GLuint) {.importc.} + proc glLightModelxOES(pname: GLenum, param: GLfixed) {.importc.} + proc glTexCoord2xOES(s: GLfixed, t: GLfixed) {.importc.} + proc glProgramUniformMatrix2x4fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glRasterPos2xvOES(coords: ptr GLfixed) {.importc.} + proc glGetMapiv(target: GLenum, query: GLenum, v: ptr GLint) {.importc.} + proc glGetImageHandleARB(texture: GLuint, level: GLint, layered: GLboolean, layer: GLint, format: GLenum): TGLuint64 {.importc.} + proc glVDPAURegisterVideoSurfaceNV(vdpSurface: pointer, target: GLenum, numTextureNames: GLsizei, textureNames: ptr GLuint): TGLvdpauSurfaceNV {.importc.} + proc glVertexAttribL2dEXT(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} + proc glVertexAttrib1dvNV(index: GLuint, v: ptr GLdouble) {.importc.} + proc glPollAsyncSGIX(markerp: ptr GLuint): TGLint {.importc.} + proc glCullParameterfvEXT(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMakeNamedBufferResidentNV(buffer: GLuint, access: GLenum) {.importc.} + proc glPointParameterfSGIS(pname: GLenum, param: GLfloat) {.importc.} + proc glGenLists(range: GLsizei): TGLuint {.importc.} + proc glGetTexBumpParameterfvATI(pname: GLenum, param: ptr GLfloat) {.importc.} + proc glCompressedMultiTexSubImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glFinishFenceNV(fence: GLuint) {.importc.} + proc glPointSize(size: GLfloat) {.importc.} + proc glCompressedTextureImage2DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glGetUniformui64vNV(program: GLuint, location: GLint, params: ptr GLuint64EXT) {.importc.} + proc glGetMapControlPointsNV(target: GLenum, index: GLuint, `type`: GLenum, ustride: GLsizei, vstride: GLsizei, packed: GLboolean, points: pointer) {.importc.} + proc glGetPathColorGenfvNV(color: GLenum, pname: GLenum, value: ptr GLfloat) {.importc.} + proc glTexCoord2f(s: GLfloat, t: GLfloat) {.importc.} + proc glSampleMaski(index: GLuint, mask: GLbitfield) {.importc.} + proc glReadBufferIndexedEXT(src: GLenum, index: GLint) {.importc.} + proc glCoverFillPathNV(path: GLuint, coverMode: GLenum) {.importc.} + proc glColorTableParameterfvSGI(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glDeleteVertexArraysAPPLE(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glGetVertexAttribIiv(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glWeightbvARB(size: GLint, weights: ptr GLbyte) {.importc.} + proc glGetNamedBufferPointervEXT(buffer: GLuint, pname: GLenum, params: ptr pointer) {.importc.} + proc glTexCoordPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glColor4fv(v: ptr GLfloat) {.importc.} + proc glGetnUniformfvARB(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLfloat) {.importc.} + proc glMaterialxOES(face: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glGetFixedv(pname: GLenum, params: ptr GLfixed) {.importc.} + proc glMaterialf(face: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glVideoCaptureStreamParameterfvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetDebugMessageLogAMD(count: GLuint, bufsize: GLsizei, categories: ptr GLenum, severities: ptr GLuint, ids: ptr GLuint, lengths: ptr GLsizei, message: ptr GLchar): TGLuint {.importc.} + proc glProgramUniform2uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glMatrixMultTransposedEXT(mode: GLenum, m: ptr GLdouble) {.importc.} + proc glIsPointInStrokePathNV(path: GLuint, x: GLfloat, y: GLfloat): TGLboolean {.importc.} + proc glDisable(cap: GLenum) {.importc.} + proc glCompileShader(shader: GLuint) {.importc.} + proc glLoadTransposeMatrixd(m: ptr GLdouble) {.importc.} + proc glGetMultiTexParameterIuivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glGetHistogram(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, values: pointer) {.importc.} + proc glMultiTexCoord3fvARB(target: GLenum, v: ptr GLfloat) {.importc.} + proc glColor4xvOES(components: ptr GLfixed) {.importc.} + proc glIsBuffer(buffer: GLuint): TGLboolean {.importc.} + proc glVertex2dv(v: ptr GLdouble) {.importc.} + proc glNamedProgramLocalParameterI4uivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glPixelTexGenParameteriSGIS(pname: GLenum, param: GLint) {.importc.} + proc glBindVertexBuffers(first: GLuint, count: GLsizei, buffers: ptr GLuint, offsets: ptr GLintptr, strides: ptr GLsizei) {.importc.} + proc glUniform1ui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} + proc glColor4ub(red: GLubyte, green: GLubyte, blue: GLubyte, alpha: GLubyte) {.importc.} + proc glConvolutionParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc: GLuint, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVertexAttribI2ui(index: GLuint, x: GLuint, y: GLuint) {.importc.} + proc glDeleteNamesAMD(identifier: GLenum, num: GLuint, names: ptr GLuint) {.importc.} + proc glPixelTransferxOES(pname: GLenum, param: GLfixed) {.importc.} + proc glVertexAttrib4ivARB(index: GLuint, v: ptr GLint) {.importc.} + proc glLightModeli(pname: GLenum, param: GLint) {.importc.} + proc glGetHistogramEXT(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, values: pointer) {.importc.} + proc glWindowPos3svMESA(v: ptr GLshort) {.importc.} + proc glRasterPos3iv(v: ptr GLint) {.importc.} + proc glCopyTextureSubImage3DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glTextureStorage3DMultisampleEXT(texture: GLuint, target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glIsNameAMD(identifier: GLenum, name: GLuint): TGLboolean {.importc.} + proc glProgramUniformMatrix3fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glGetProgramParameterfvNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} + proc glMultiTexCoord2xOES(texture: GLenum, s: GLfixed, t: GLfixed) {.importc.} + proc glWindowPos2fARB(x: GLfloat, y: GLfloat) {.importc.} + proc glGetProgramResourceIndex(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLuint {.importc.} + proc glProgramUniform2uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glMakeImageHandleNonResidentNV(handle: GLuint64) {.importc.} + proc glNamedProgramLocalParameter4fvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glInvalidateFramebuffer(target: GLenum, numAttachments: GLsizei, attachments: ptr GLenum) {.importc.} + proc glTexStorage3DMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glMapVertexAttrib2fAPPLE(index: GLuint, size: GLuint, u1: GLfloat, u2: GLfloat, ustride: GLint, uorder: GLint, v1: GLfloat, v2: GLfloat, vstride: GLint, vorder: GLint, points: ptr GLfloat) {.importc.} + proc glCombinerParameterfNV(pname: GLenum, param: GLfloat) {.importc.} + proc glCopyMultiTexImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) {.importc.} + proc glBindVertexShaderEXT(id: GLuint) {.importc.} + proc glPathGlyphsNV(firstPathName: GLuint, fontTarget: GLenum, fontName: pointer, fontStyle: GLbitfield, numGlyphs: GLsizei, `type`: GLenum, charcodes: pointer, handleMissingGlyphs: GLenum, pathParameterTemplate: GLuint, emScale: GLfloat) {.importc.} + proc glProgramLocalParametersI4uivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} + proc glMultiTexCoord3hvNV(target: GLenum, v: ptr GLhalfNV) {.importc.} + proc glMultiTexCoordP2uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} + proc glDisableVariantClientStateEXT(id: GLuint) {.importc.} + proc glGetTexLevelParameterxvOES(target: GLenum, level: GLint, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glRasterPos2sv(v: ptr GLshort) {.importc.} + proc glWeightPathsNV(resultPath: GLuint, numPaths: GLsizei, paths: ptr GLuint, weights: ptr GLfloat) {.importc.} + proc glDrawBuffersNV(n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glBindBufferARB(target: GLenum, buffer: GLuint) {.importc.} + proc glVariantbvEXT(id: GLuint, `addr`: ptr GLbyte) {.importc.} + proc glColorP3uiv(`type`: GLenum, color: ptr GLuint) {.importc.} + proc glBlendEquationEXT(mode: GLenum) {.importc.} + proc glProgramLocalParameterI4uivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glRenderMode(mode: GLenum): TGLint {.importc.} + proc glVertexStream4fATI(stream: GLenum, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glGetObjectLabelEXT(`type`: GLenum, `object`: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glNamedFramebufferTexture3DEXT(framebuffer: GLuint, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} + proc glLoadMatrixf(m: ptr GLfloat) {.importc.} + proc glGetQueryObjectuivEXT(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glBindVideoCaptureStreamBufferNV(video_capture_slot: GLuint, stream: GLuint, frame_region: GLenum, offset: GLintptrARB) {.importc.} + proc glMatrixOrthoEXT(mode: GLenum, left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, zNear: GLdouble, zFar: GLdouble) {.importc.} + proc glBlendFunc(sfactor: GLenum, dfactor: GLenum) {.importc.} + proc glTexGenxvOES(coord: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glMatrixMode(mode: GLenum) {.importc.} + proc glColorTableParameterivSGI(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetProgramInfoLog(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetSeparableFilter(target: GLenum, format: GLenum, `type`: GLenum, row: pointer, column: pointer, span: pointer) {.importc.} + proc glFogfv(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glDrawTexfvOES(coords: ptr GLfloat) {.importc.} + proc glClipPlanexIMG(p: GLenum, eqn: ptr GLfixed) {.importc.} + proc glResetHistogramEXT(target: GLenum) {.importc.} + proc glMemoryBarrier(barriers: GLbitfield) {.importc.} + proc glGetPixelMapusv(map: GLenum, values: ptr GLushort) {.importc.} + proc glEvalCoord2f(u: GLfloat, v: GLfloat) {.importc.} + proc glUniform4uiv(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glIsProgramARB(program: GLuint): TGLboolean {.importc.} + proc glPointParameterfv(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexBuffer(target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} + proc glVertexAttrib1s(index: GLuint, x: GLshort) {.importc.} + proc glRenderbufferStorageMultisampleEXT(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glMapNamedBufferEXT(buffer: GLuint, access: GLenum) {.importc.} + proc glDebugMessageCallbackAMD(callback: GLDEBUGPROCAMD, userParam: ptr pointer) {.importc.} + proc glGetTexEnvfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttribI3uivEXT(index: GLuint, v: ptr GLuint) {.importc.} + proc glMultiTexEnvfEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glGetUniformiv(program: GLuint, location: GLint, params: ptr GLint) {.importc.} + proc glProgramLocalParameters4fvEXT(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLfloat) {.importc.} + proc glStencilStrokePathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, reference: GLint, mask: GLuint, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} + proc glBeginConditionalRender(id: GLuint, mode: GLenum) {.importc.} + proc glVertexAttribI3uiEXT(index: GLuint, x: GLuint, y: GLuint, z: GLuint) {.importc.} + proc glVDPAUMapSurfacesNV(numSurfaces: GLsizei, surfaces: ptr GLvdpauSurfaceNV) {.importc.} + proc glGetProgramResourceName(program: GLuint, programInterface: GLenum, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} + proc glMultiTexCoord4f(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} + proc glVertexAttrib2hNV(index: GLuint, x: GLhalfNV, y: GLhalfNV) {.importc.} + proc glDrawArraysInstancedNV(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei) {.importc.} + proc glClearAccum(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) {.importc.} + proc glVertexAttribI4usv(index: GLuint, v: ptr GLushort) {.importc.} + proc glGetProgramNamedParameterfvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, params: ptr GLfloat) {.importc.} + proc glTextureLightEXT(pname: GLenum) {.importc.} + proc glPathSubCoordsNV(path: GLuint, coordStart: GLsizei, numCoords: GLsizei, coordType: GLenum, coords: pointer) {.importc.} + proc glBindImageTexture(unit: GLuint, texture: GLuint, level: GLint, layered: GLboolean, layer: GLint, access: GLenum, format: GLenum) {.importc.} + proc glGenVertexArraysAPPLE(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glFogCoordf(coord: GLfloat) {.importc.} proc glFrameTerminatorGREMEDY() {.importc.} - proc glValidateProgramPipelineEXT(pipeline: TGLuint) {.importc.} - proc glScalexOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glReplacementCodeuiColor3fVertex3fvSUN(rc: ptr TGLuint, c: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glProgramNamedParameter4dNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glMultiDrawElementsIndirectCountARB(mode: TGLenum, `type`: TGLenum, indirect: TGLintptr, drawcount: TGLintptr, maxdrawcount: TGLsizei, stride: TGLsizei) {.importc.} - proc glReferencePlaneSGIX(equation: ptr TGLdouble) {.importc.} - proc glNormalStream3iATI(stream: TGLenum, nx: TGLint, ny: TGLint, nz: TGLint) {.importc.} - proc glGetColorTableParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glGetAttribLocation(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} - proc glMultiTexParameterfEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glGenFencesNV(n: TGLsizei, fences: ptr TGLuint) {.importc.} - proc glUniform4dv(location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glGetTexLevelParameterfv(target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glProgramUniform1ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glProgramUniform1dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glLoadTransposeMatrixdARB(m: ptr TGLdouble) {.importc.} - proc glVertexAttrib2fvARB(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glMultiTexGendEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLdouble) {.importc.} - proc glProgramUniformMatrix4x3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glUniform4ui(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} - proc glTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glVertexAttrib3hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV) {.importc.} - proc glRotatexOES(angle: TGLfixed, x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glGenTextures(n: TGLsizei, textures: ptr TGLuint) {.importc.} - proc glCheckFramebufferStatusOES(target: TGLenum): TGLenum {.importc.} - proc glGetVideoCaptureStreamdvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glCompressedTextureSubImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glCurrentPaletteMatrixOES(matrixpaletteindex: TGLuint) {.importc.} - proc glCompressedMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glNormal3d(nx: TGLdouble, ny: TGLdouble, nz: TGLdouble) {.importc.} - proc glMultiTexCoord1fv(target: TGLenum, v: ptr TGLfloat) {.importc.} - proc glProgramUniform2uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} - proc glMultiTexCoord3fARB(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc.} - proc glRasterPos3xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glEGLImageTargetRenderbufferStorageOES(target: TGLenum, image: TGLeglImageOES) {.importc.} - proc glGetAttribLocationARB(programObj: TGLhandleARB, name: ptr TGLcharARB): TGLint {.importc.} - proc glProgramNamedParameter4dvNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, v: ptr TGLdouble) {.importc.} - proc glProgramLocalParameterI4uiNV(target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} - proc glNamedFramebufferTextureFaceEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc.} - proc glIndexf(c: TGLfloat) {.importc.} - proc glExtTexObjectStateOverrideiQCOM(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glCoverageOperationNV(operation: TGLenum) {.importc.} - proc glColorP4uiv(`type`: TGLenum, color: ptr TGLuint) {.importc.} - proc glDeleteSync(sync: TGLsync) {.importc.} - proc glGetHistogramParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glTexCoord4fColor4fNormal3fVertex4fSUN(s: TGLfloat, t: TGLfloat, p: TGLfloat, q: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glEndPerfMonitorAMD(monitor: TGLuint) {.importc.} - proc glGetInternalformati64v(target: TGLenum, internalformat: TGLenum, pname: TGLenum, bufSize: TGLsizei, params: ptr TGLint64) {.importc.} - proc glGenNamesAMD(identifier: TGLenum, num: TGLuint, names: ptr TGLuint) {.importc.} - proc glDrawElementsInstancedBaseVertexBaseInstance(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, instancecount: TGLsizei, basevertex: TGLint, baseinstance: TGLuint) {.importc.} - proc glMultiTexCoord4i(target: TGLenum, s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc.} - proc glVertexAttribL1dv(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glGetProgramNamedParameterdvNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, params: ptr TGLdouble) {.importc.} - proc glSetLocalConstantEXT(id: TGLuint, `type`: TGLenum, `addr`: pointer) {.importc.} - proc glProgramBinary(program: TGLuint, binaryFormat: TGLenum, binary: pointer, length: TGLsizei) {.importc.} - proc glVideoCaptureNV(video_capture_slot: TGLuint, sequence_num: ptr TGLuint, capture_time: ptr TGLuint64EXT): TGLenum {.importc.} - proc glDebugMessageEnableAMD(category: TGLenum, severity: TGLenum, count: TGLsizei, ids: ptr TGLuint, enabled: TGLboolean) {.importc.} - proc glVertexAttribI1i(index: TGLuint, x: TGLint) {.importc.} - proc glVertexWeighthNV(weight: TGLhalfNV) {.importc.} - proc glTextureParameterIivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glClipPlanefIMG(p: TGLenum, eqn: ptr TGLfloat) {.importc.} - proc glGetLightxv(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glGetAttachedObjectsARB(containerObj: TGLhandleARB, maxCount: TGLsizei, count: ptr TGLsizei, obj: ptr TGLhandleARB) {.importc.} - proc glVertexAttrib4fv(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glDisableVertexAttribArrayARB(index: TGLuint) {.importc.} - proc glWindowPos3fvARB(v: ptr TGLfloat) {.importc.} - proc glClearDepthdNV(depth: TGLdouble) {.importc.} - proc glMapParameterivNV(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glValidateProgramPipelineEXT(pipeline: GLuint) {.importc.} + proc glScalexOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glReplacementCodeuiColor3fVertex3fvSUN(rc: ptr GLuint, c: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glProgramNamedParameter4dNV(id: GLuint, len: GLsizei, name: ptr GLubyte, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glMultiDrawElementsIndirectCountARB(mode: GLenum, `type`: GLenum, indirect: GLintptr, drawcount: GLintptr, maxdrawcount: GLsizei, stride: GLsizei) {.importc.} + proc glReferencePlaneSGIX(equation: ptr GLdouble) {.importc.} + proc glNormalStream3iATI(stream: GLenum, nx: GLint, ny: GLint, nz: GLint) {.importc.} + proc glGetColorTableParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetAttribLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glMultiTexParameterfEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glGenFencesNV(n: GLsizei, fences: ptr GLuint) {.importc.} + proc glUniform4dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glGetTexLevelParameterfv(target: GLenum, level: GLint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glProgramUniform1ivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glProgramUniform1dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glLoadTransposeMatrixdARB(m: ptr GLdouble) {.importc.} + proc glVertexAttrib2fvARB(index: GLuint, v: ptr GLfloat) {.importc.} + proc glMultiTexGendEXT(texunit: GLenum, coord: GLenum, pname: GLenum, param: GLdouble) {.importc.} + proc glProgramUniformMatrix4x3dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glUniform4ui(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} + proc glTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glVertexAttrib3hNV(index: GLuint, x: GLhalfNV, y: GLhalfNV, z: GLhalfNV) {.importc.} + proc glRotatexOES(angle: GLfixed, x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glGenTextures(n: GLsizei, textures: ptr GLuint) {.importc.} + proc glCheckFramebufferStatusOES(target: GLenum): TGLenum {.importc.} + proc glGetVideoCaptureStreamdvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glCompressedTextureSubImage1DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glCurrentPaletteMatrixOES(matrixpaletteindex: GLuint) {.importc.} + proc glCompressedMultiTexSubImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} + proc glNormal3d(nx: GLdouble, ny: GLdouble, nz: GLdouble) {.importc.} + proc glMultiTexCoord1fv(target: GLenum, v: ptr GLfloat) {.importc.} + proc glProgramUniform2uiEXT(program: GLuint, location: GLint, v0: GLuint, v1: GLuint) {.importc.} + proc glMultiTexCoord3fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} + proc glRasterPos3xOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glEGLImageTargetRenderbufferStorageOES(target: GLenum, image: GLeglImageOES) {.importc.} + proc glGetAttribLocationARB(programObj: GLhandleARB, name: ptr GLcharARB): TGLint {.importc.} + proc glProgramNamedParameter4dvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, v: ptr GLdouble) {.importc.} + proc glProgramLocalParameterI4uiNV(target: GLenum, index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} + proc glNamedFramebufferTextureFaceEXT(framebuffer: GLuint, attachment: GLenum, texture: GLuint, level: GLint, face: GLenum) {.importc.} + proc glIndexf(c: GLfloat) {.importc.} + proc glExtTexObjectStateOverrideiQCOM(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glCoverageOperationNV(operation: GLenum) {.importc.} + proc glColorP4uiv(`type`: GLenum, color: ptr GLuint) {.importc.} + proc glDeleteSync(sync: GLsync) {.importc.} + proc glGetHistogramParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexCoord4fColor4fNormal3fVertex4fSUN(s: GLfloat, t: GLfloat, p: GLfloat, q: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glEndPerfMonitorAMD(monitor: GLuint) {.importc.} + proc glGetInternalformati64v(target: GLenum, internalformat: GLenum, pname: GLenum, bufSize: GLsizei, params: ptr GLint64) {.importc.} + proc glGenNamesAMD(identifier: GLenum, num: GLuint, names: ptr GLuint) {.importc.} + proc glDrawElementsInstancedBaseVertexBaseInstance(mode: GLenum, count: GLsizei, `type`: GLenum, indices: ptr pointer, instancecount: GLsizei, basevertex: GLint, baseinstance: GLuint) {.importc.} + proc glMultiTexCoord4i(target: GLenum, s: GLint, t: GLint, r: GLint, q: GLint) {.importc.} + proc glVertexAttribL1dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glGetProgramNamedParameterdvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, params: ptr GLdouble) {.importc.} + proc glSetLocalConstantEXT(id: GLuint, `type`: GLenum, `addr`: pointer) {.importc.} + proc glProgramBinary(program: GLuint, binaryFormat: GLenum, binary: pointer, length: GLsizei) {.importc.} + proc glVideoCaptureNV(video_capture_slot: GLuint, sequence_num: ptr GLuint, capture_time: ptr GLuint64EXT): TGLenum {.importc.} + proc glDebugMessageEnableAMD(category: GLenum, severity: GLenum, count: GLsizei, ids: ptr GLuint, enabled: GLboolean) {.importc.} + proc glVertexAttribI1i(index: GLuint, x: GLint) {.importc.} + proc glVertexWeighthNV(weight: GLhalfNV) {.importc.} + proc glTextureParameterIivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glClipPlanefIMG(p: GLenum, eqn: ptr GLfloat) {.importc.} + proc glGetLightxv(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glGetAttachedObjectsARB(containerObj: GLhandleARB, maxCount: GLsizei, count: ptr GLsizei, obj: ptr GLhandleARB) {.importc.} + proc glVertexAttrib4fv(index: GLuint, v: ptr GLfloat) {.importc.} + proc glDisableVertexAttribArrayARB(index: GLuint) {.importc.} + proc glWindowPos3fvARB(v: ptr GLfloat) {.importc.} + proc glClearDepthdNV(depth: GLdouble) {.importc.} + proc glMapParameterivNV(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glEndConditionalRenderNVX() {.importc.} - proc glGetFragmentLightivSGIX(light: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glProgramUniformMatrix4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glVertexStream1iATI(stream: TGLenum, x: TGLint) {.importc.} - proc glColorP3ui(`type`: TGLenum, color: TGLuint) {.importc.} - proc glGetLightxOES(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glGetLightiv(light: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertexStream3dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glProgramUniform1iEXT(program: TGLuint, location: TGLint, v0: TGLint) {.importc.} - proc glSecondaryColorFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} - proc glDrawElementsBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, basevertex: TGLint) {.importc.} - proc glGenFencesAPPLE(n: TGLsizei, fences: ptr TGLuint) {.importc.} - proc glBinormal3svEXT(v: ptr TGLshort) {.importc.} - proc glUseProgramStagesEXT(pipeline: TGLuint, stages: TGLbitfield, program: TGLuint) {.importc.} - proc glDebugMessageCallbackKHR(callback: TGLDEBUGPROCKHR, userParam: ptr pointer) {.importc.} - proc glCopyMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glColor4hvNV(v: ptr TGLhalfNV) {.importc.} - proc glFenceSync(condition: TGLenum, flags: TGLbitfield): TGLsync {.importc.} - proc glTexCoordPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} + proc glGetFragmentLightivSGIX(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniformMatrix4fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glVertexStream1iATI(stream: GLenum, x: GLint) {.importc.} + proc glColorP3ui(`type`: GLenum, color: GLuint) {.importc.} + proc glGetLightxOES(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glGetLightiv(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexStream3dATI(stream: GLenum, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glProgramUniform1iEXT(program: GLuint, location: GLint, v0: GLint) {.importc.} + proc glSecondaryColorFormatNV(size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glDrawElementsBaseVertex(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, basevertex: GLint) {.importc.} + proc glGenFencesAPPLE(n: GLsizei, fences: ptr GLuint) {.importc.} + proc glBinormal3svEXT(v: ptr GLshort) {.importc.} + proc glUseProgramStagesEXT(pipeline: GLuint, stages: GLbitfield, program: GLuint) {.importc.} + proc glDebugMessageCallbackKHR(callback: GLDEBUGPROCKHR, userParam: ptr pointer) {.importc.} + proc glCopyMultiTexSubImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glColor4hvNV(v: ptr GLhalfNV) {.importc.} + proc glFenceSync(condition: GLenum, flags: GLbitfield): TGLsync {.importc.} + proc glTexCoordPointerListIBM(size: GLint, `type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} proc glPopName() {.importc.} - proc glColor3fVertex3fvSUN(c: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glGetUniformfv(program: TGLuint, location: TGLint, params: ptr TGLfloat) {.importc.} - proc glMultiTexCoord2hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV) {.importc.} - proc glLightxv(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glVideoCaptureStreamParameterivNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glEvalCoord1xvOES(coords: ptr TGLfixed) {.importc.} - proc glGetProgramEnvParameterIivNV(target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} - proc glObjectPurgeableAPPLE(objectType: TGLenum, name: TGLuint, option: TGLenum): TGLenum {.importc.} - proc glRequestResidentProgramsNV(n: TGLsizei, programs: ptr TGLuint) {.importc.} - proc glIsImageHandleResidentNV(handle: TGLuint64): TGLboolean {.importc.} - proc glColor3hvNV(v: ptr TGLhalfNV) {.importc.} - proc glMultiTexCoord2dARB(target: TGLenum, s: TGLdouble, t: TGLdouble) {.importc.} - proc glDeletePathsNV(path: TGLuint, range: TGLsizei) {.importc.} - proc glVertexAttrib4Nsv(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glTexEnvf(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glGlobalAlphaFactoriSUN(factor: TGLint) {.importc.} - proc glBlendColorEXT(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} - proc glSecondaryColor3usvEXT(v: ptr TGLushort) {.importc.} - proc glProgramEnvParameterI4uiNV(target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} - proc glTexImage4DSGIS(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, size4d: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glMatrixPushEXT(mode: TGLenum) {.importc.} - proc glGetPixelTexGenParameterivSGIS(pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVariantuivEXT(id: TGLuint, `addr`: ptr TGLuint) {.importc.} - proc glTexParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glGetSubroutineUniformLocation(program: TGLuint, shadertype: TGLenum, name: ptr TGLchar): TGLint {.importc.} - proc glProgramUniformMatrix3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glDrawBuffersATI(n: TGLsizei, bufs: ptr TGLenum) {.importc.} - proc glGetVertexAttribivNV(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glMultiTexCoord4bvOES(texture: TGLenum, coords: ptr TGLbyte) {.importc.} - proc glCompressedTexSubImage1DARB(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} - proc glClientActiveTexture(texture: TGLenum) {.importc.} - proc glVertexAttrib2fARB(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc.} - proc glProgramUniform2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glGetBufferParameterui64vNV(target: TGLenum, pname: TGLenum, params: ptr TGLuint64EXT) {.importc.} - proc glVertexStream3dvATI(stream: TGLenum, coords: ptr TGLdouble) {.importc.} - proc glReplacementCodeuiNormal3fVertex3fvSUN(rc: ptr TGLuint, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glVertexAttrib4svNV(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glClearBufferSubData(target: TGLenum, internalformat: TGLenum, offset: TGLintptr, size: TGLsizeiptr, format: TGLenum, `type`: TGLenum, data: ptr pointer) {.importc.} - proc glVertexStream2sATI(stream: TGLenum, x: TGLshort, y: TGLshort) {.importc.} - proc glTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetListParameterfvSGIX(list: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glUniform3uiv(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glIsTexture(texture: TGLuint): TGLboolean {.importc.} - proc glObjectUnpurgeableAPPLE(objectType: TGLenum, name: TGLuint, option: TGLenum): TGLenum {.importc.} - proc glGetVertexAttribdv(index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glGetPointeri_vEXT(pname: TGLenum, index: TGLuint, params: ptr pointer) {.importc.} - proc glSampleCoveragex(value: TGLclampx, invert: TGLboolean) {.importc.} - proc glColor3f(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc.} - proc glGetnMapivARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: ptr TGLint) {.importc.} - proc glMakeTextureHandleResidentARB(handle: TGLuint64) {.importc.} - proc glSecondaryColorP3ui(`type`: TGLenum, color: TGLuint) {.importc.} - proc glMultiTexCoord4sARB(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc.} - proc glUniform3i64NV(location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc.} - proc glVDPAUGetSurfaceivNV(surface: TGLvdpauSurfaceNV, pname: TGLenum, bufSize: TGLsizei, length: ptr TGLsizei, values: ptr TGLint) {.importc.} - proc glTexBufferEXT(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} - proc glVertexAttribI4ubvEXT(index: TGLuint, v: ptr TGLubyte) {.importc.} - proc glDeleteFramebuffersOES(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} - proc glColor3fVertex3fSUN(r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glCombinerInputNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, input: TGLenum, mapping: TGLenum, componentUsage: TGLenum) {.importc.} - proc glPolygonOffsetEXT(factor: TGLfloat, bias: TGLfloat) {.importc.} - proc glWindowPos4dMESA(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glVertex3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glTexCoord3f(s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc.} - proc glMultiTexCoord1fARB(target: TGLenum, s: TGLfloat) {.importc.} - proc glVertexAttrib4f(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glGetFragDataLocationEXT(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} - proc glFlushMappedNamedBufferRangeEXT(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr) {.importc.} - proc glVertexAttrib1sARB(index: TGLuint, x: TGLshort) {.importc.} - proc glBitmapxOES(width: TGLsizei, height: TGLsizei, xorig: TGLfixed, yorig: TGLfixed, xmove: TGLfixed, ymove: TGLfixed, bitmap: ptr TGLubyte) {.importc.} - proc glEnableVertexArrayAttribEXT(vaobj: TGLuint, index: TGLuint) {.importc.} - proc glDeleteRenderbuffers(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} - proc glFramebufferRenderbuffer(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glInvalidateTexImage(texture: TGLuint, level: TGLint) {.importc.} - proc glProgramUniform2i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT) {.importc.} - proc glTextureImage3DMultisampleNV(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} - proc glValidateProgram(program: TGLuint) {.importc.} - proc glUniform1dv(location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glNormalStream3dvATI(stream: TGLenum, coords: ptr TGLdouble) {.importc.} - proc glMultiDrawElementsIndirect(mode: TGLenum, `type`: TGLenum, indirect: ptr pointer, drawcount: TGLsizei, stride: TGLsizei) {.importc.} - proc glVertexBlendARB(count: TGLint) {.importc.} - proc glIsSampler(sampler: TGLuint): TGLboolean {.importc.} - proc glVariantdvEXT(id: TGLuint, `addr`: ptr TGLdouble) {.importc.} - proc glProgramUniformMatrix3x2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glVertexStream4fvATI(stream: TGLenum, coords: ptr TGLfloat) {.importc.} - proc glOrthoxOES(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} - proc glColorFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} - proc glFogCoordPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glVertexAttrib3dvARB(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glVertex3bOES(x: TGLbyte, y: TGLbyte) {.importc.} - proc glVertexAttribFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, relativeoffset: TGLuint) {.importc.} - proc glTexCoord4fVertex4fSUN(s: TGLfloat, t: TGLfloat, p: TGLfloat, q: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glEnableDriverControlQCOM(driverControl: TGLuint) {.importc.} - proc glPointParameteri(pname: TGLenum, param: TGLint) {.importc.} - proc glVertexAttribI2i(index: TGLuint, x: TGLint, y: TGLint) {.importc.} - proc glGetDriverControlStringQCOM(driverControl: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, driverControlString: ptr TGLchar) {.importc.} - proc glGetTexLevelParameteriv(target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetHandleARB(pname: TGLenum): TGLhandleARB {.importc.} - proc glIndexubv(c: ptr TGLubyte) {.importc.} - proc glBlendFunciARB(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc.} - proc glColor4usv(v: ptr TGLushort) {.importc.} - proc glBlendEquationSeparateOES(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} - proc glVertexAttribI4ui(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} - proc glProgramUniform3f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} - proc glVertexAttribL3i64vNV(index: TGLuint, v: ptr TGLint64EXT) {.importc.} - proc glWeightdvARB(size: TGLint, weights: ptr TGLdouble) {.importc.} - proc glVertexArrayRangeAPPLE(length: TGLsizei, `pointer`: pointer) {.importc.} - proc glMapGrid2d(un: TGLint, u1: TGLdouble, u2: TGLdouble, vn: TGLint, v1: TGLdouble, v2: TGLdouble) {.importc.} - proc glFogiv(pname: TGLenum, params: ptr TGLint) {.importc.} - proc glUniform2f(location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} - proc glGetDoublei_v(target: TGLenum, index: TGLuint, data: ptr TGLdouble) {.importc.} - proc glGetVertexAttribfv(index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVertexAttribI2ivEXT(index: TGLuint, v: ptr TGLint) {.importc.} - proc glIsProgramNV(id: TGLuint): TGLboolean {.importc.} - proc glTexCoord1hNV(s: TGLhalfNV) {.importc.} - proc glMinSampleShadingARB(value: TGLfloat) {.importc.} - proc glMultiDrawElements(mode: TGLenum, count: ptr TGLsizei, `type`: TGLenum, indices: ptr pointer, drawcount: TGLsizei) {.importc.} - proc glGetQueryObjectuiv(id: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glReadBuffer(mode: TGLenum) {.importc.} - proc glMultiTexCoordP3uiv(texture: TGLenum, `type`: TGLenum, coords: ptr TGLuint) {.importc.} - proc glUniformMatrix3x2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glBindRenderbuffer(target: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glBinormal3sEXT(bx: TGLshort, by: TGLshort, bz: TGLshort) {.importc.} - proc glUniform4iARB(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} - proc glGetUniformOffsetEXT(program: TGLuint, location: TGLint): TGLintptr {.importc.} - proc glDeleteLists(list: TGLuint, range: TGLsizei) {.importc.} - proc glVertexAttribI1iEXT(index: TGLuint, x: TGLint) {.importc.} - proc glFramebufferTexture1D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glVertexAttribI2uiv(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glBindFragDataLocation(program: TGLuint, color: TGLuint, name: ptr TGLchar) {.importc.} - proc glClearStencil(s: TGLint) {.importc.} - proc glVertexAttrib4Nubv(index: TGLuint, v: ptr TGLubyte) {.importc.} - proc glConvolutionFilter2DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} - proc glGenFramebuffersEXT(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} - proc glFogCoordfvEXT(coord: ptr TGLfloat) {.importc.} - proc glGetRenderbufferParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertexAttribs1fvNV(index: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} - proc glTexCoord2fColor3fVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glRasterPos3i(x: TGLint, y: TGLint, z: TGLint) {.importc.} - proc glMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glConvolutionParameteriEXT(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glVertexAttribI4iEXT(index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} - proc glVertexAttribL2i64vNV(index: TGLuint, v: ptr TGLint64EXT) {.importc.} - proc glBlendColor(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} - proc glGetPathColorGenivNV(color: TGLenum, pname: TGLenum, value: ptr TGLint) {.importc.} - proc glCompressedTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glDrawElementsInstanced(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei) {.importc.} - proc glFogCoordd(coord: TGLdouble) {.importc.} - proc glTexParameterxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glWindowPos3svARB(v: ptr TGLshort) {.importc.} - proc glGetVertexArrayPointervEXT(vaobj: TGLuint, pname: TGLenum, param: ptr pointer) {.importc.} - proc glDrawTextureNV(texture: TGLuint, sampler: TGLuint, x0: TGLfloat, y0: TGLfloat, x1: TGLfloat, y1: TGLfloat, z: TGLfloat, s0: TGLfloat, t0: TGLfloat, s1: TGLfloat, t1: TGLfloat) {.importc.} - proc glUniformMatrix2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glTexImage3DOES(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glClampColorARB(target: TGLenum, clamp: TGLenum) {.importc.} - proc glTexParameteri(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glWindowPos4svMESA(v: ptr TGLshort) {.importc.} - proc glMultiTexCoordP4ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} - proc glVertexP4uiv(`type`: TGLenum, value: ptr TGLuint) {.importc.} - proc glProgramUniform4iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} - proc glTexCoord3xvOES(coords: ptr TGLfixed) {.importc.} - proc glCopyTexImage2DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} - proc glGenSamplers(count: TGLsizei, samplers: ptr TGLuint) {.importc.} - proc glRasterPos4iv(v: ptr TGLint) {.importc.} - proc glWindowPos4sMESA(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glProgramUniform2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glPrioritizeTexturesEXT(n: TGLsizei, textures: ptr TGLuint, priorities: ptr TGLclampf) {.importc.} - proc glRects(x1: TGLshort, y1: TGLshort, x2: TGLshort, y2: TGLshort) {.importc.} - proc glMultiDrawElementsBaseVertex(mode: TGLenum, count: ptr TGLsizei, `type`: TGLenum, indices: ptr pointer, drawcount: TGLsizei, basevertex: ptr TGLint) {.importc.} - proc glProgramBinaryOES(program: TGLuint, binaryFormat: TGLenum, binary: pointer, length: TGLint) {.importc.} - proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc: ptr TGLuint, tc: ptr TGLfloat, c: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glGetMinmaxParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glColor4fNormal3fVertex3fSUN(r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glWindowPos2d(x: TGLdouble, y: TGLdouble) {.importc.} - proc glGetPerfMonitorGroupStringAMD(group: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, groupString: ptr TGLchar) {.importc.} - proc glUniformHandleui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64) {.importc.} - proc glBlendEquation(mode: TGLenum) {.importc.} - proc glMapBufferARB(target: TGLenum, access: TGLenum) {.importc.} - proc glGetMaterialxvOES(face: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glVertexAttribI1ivEXT(index: TGLuint, v: ptr TGLint) {.importc.} - proc glTexCoord4hvNV(v: ptr TGLhalfNV) {.importc.} - proc glVertexArrayVertexAttribLOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glExtGetShadersQCOM(shaders: ptr TGLuint, maxShaders: TGLint, numShaders: ptr TGLint) {.importc.} - proc glWindowPos4ivMESA(v: ptr TGLint) {.importc.} - proc glVertexAttrib1sNV(index: TGLuint, x: TGLshort) {.importc.} - proc glNormalStream3ivATI(stream: TGLenum, coords: ptr TGLint) {.importc.} - proc glSecondaryColor3fEXT(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc.} - proc glVertexArrayFogCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glGetTextureImageEXT(texture: TGLuint, target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glVertexAttrib4hNV(index: TGLuint, x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV, w: TGLhalfNV) {.importc.} - proc glReplacementCodeusSUN(code: TGLushort) {.importc.} - proc glPixelTexGenSGIX(mode: TGLenum) {.importc.} - proc glMultiDrawRangeElementArrayAPPLE(mode: TGLenum, start: TGLuint, `end`: TGLuint, first: ptr TGLint, count: ptr TGLsizei, primcount: TGLsizei) {.importc.} - proc glDrawElements(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc.} - proc glTexCoord1hvNV(v: ptr TGLhalfNV) {.importc.} - proc glGetPixelMapuiv(map: TGLenum, values: ptr TGLuint) {.importc.} - proc glRasterPos4d(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glConvolutionParameterxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glSecondaryColor3dEXT(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc.} - proc glGetCombinerOutputParameterivNV(stage: TGLenum, portion: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glQueryCounter(id: TGLuint, target: TGLenum) {.importc.} - proc glGetUniformi64vNV(program: TGLuint, location: TGLint, params: ptr TGLint64EXT) {.importc.} - proc glTexCoord2fv(v: ptr TGLfloat) {.importc.} - proc glWindowPos3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glBlendFuncSeparateINGR(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc.} - proc glTextureNormalEXT(mode: TGLenum) {.importc.} - proc glVertexStream2fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat) {.importc.} - proc glViewportIndexedf(index: TGLuint, x: TGLfloat, y: TGLfloat, w: TGLfloat, h: TGLfloat) {.importc.} - proc glMultiTexCoord4ivARB(target: TGLenum, v: ptr TGLint) {.importc.} - proc glBindBufferOffsetEXT(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr) {.importc.} - proc glTexCoord3sv(v: ptr TGLshort) {.importc.} - proc glVertexArrayVertexAttribBindingEXT(vaobj: TGLuint, attribindex: TGLuint, bindingindex: TGLuint) {.importc.} - proc glVertexAttrib2f(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc.} - proc glMultiTexGenivEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glUniformui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} - proc glGetInfoLogARB(obj: TGLhandleARB, maxLength: TGLsizei, length: ptr TGLsizei, infoLog: ptr TGLcharARB) {.importc.} - proc glGetNamedProgramLocalParameterIivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} - proc glVertexAttrib4s(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glUniformMatrix4x2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glVertexAttribs3dvNV(index: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} - proc glSecondaryColor3dvEXT(v: ptr TGLdouble) {.importc.} - proc glTextureRenderbufferEXT(texture: TGLuint, target: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glVertexAttribL2ui64vNV(index: TGLuint, v: ptr TGLuint64EXT) {.importc.} - proc glBlendFuncSeparateOES(srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} - proc glVertexAttribDivisorARB(index: TGLuint, divisor: TGLuint) {.importc.} - proc glWindowPos2sv(v: ptr TGLshort) {.importc.} - proc glMultiTexCoord3svARB(target: TGLenum, v: ptr TGLshort) {.importc.} - proc glCombinerParameterfvNV(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glGetImageTransformParameterfvHP(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glTexParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetArrayObjectivATI(`array`: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetTexParameterIuiv(target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glGetProgramPipelineInfoLog(pipeline: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, infoLog: ptr TGLchar) {.importc.} - proc glGetOcclusionQueryuivNV(id: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glVertexAttrib4bvARB(index: TGLuint, v: ptr TGLbyte) {.importc.} - proc glListParameterfvSGIX(list: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glDeleteSamplers(count: TGLsizei, samplers: ptr TGLuint) {.importc.} - proc glNormalStream3dATI(stream: TGLenum, nx: TGLdouble, ny: TGLdouble, nz: TGLdouble) {.importc.} - proc glProgramUniform4i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} - proc glBlendFuncSeparateiARB(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} + proc glColor3fVertex3fvSUN(c: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glGetUniformfv(program: GLuint, location: GLint, params: ptr GLfloat) {.importc.} + proc glMultiTexCoord2hNV(target: GLenum, s: GLhalfNV, t: GLhalfNV) {.importc.} + proc glLightxv(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glVideoCaptureStreamParameterivNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glEvalCoord1xvOES(coords: ptr GLfixed) {.importc.} + proc glGetProgramEnvParameterIivNV(target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glObjectPurgeableAPPLE(objectType: GLenum, name: GLuint, option: GLenum): TGLenum {.importc.} + proc glRequestResidentProgramsNV(n: GLsizei, programs: ptr GLuint) {.importc.} + proc glIsImageHandleResidentNV(handle: GLuint64): TGLboolean {.importc.} + proc glColor3hvNV(v: ptr GLhalfNV) {.importc.} + proc glMultiTexCoord2dARB(target: GLenum, s: GLdouble, t: GLdouble) {.importc.} + proc glDeletePathsNV(path: GLuint, range: GLsizei) {.importc.} + proc glVertexAttrib4Nsv(index: GLuint, v: ptr GLshort) {.importc.} + proc glTexEnvf(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glGlobalAlphaFactoriSUN(factor: GLint) {.importc.} + proc glBlendColorEXT(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) {.importc.} + proc glSecondaryColor3usvEXT(v: ptr GLushort) {.importc.} + proc glProgramEnvParameterI4uiNV(target: GLenum, index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} + proc glTexImage4DSGIS(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, size4d: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glMatrixPushEXT(mode: GLenum) {.importc.} + proc glGetPixelTexGenParameterivSGIS(pname: GLenum, params: ptr GLint) {.importc.} + proc glVariantuivEXT(id: GLuint, `addr`: ptr GLuint) {.importc.} + proc glTexParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetSubroutineUniformLocation(program: GLuint, shadertype: GLenum, name: ptr GLchar): TGLint {.importc.} + proc glProgramUniformMatrix3fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glDrawBuffersATI(n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glGetVertexAttribivNV(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoord4bvOES(texture: GLenum, coords: ptr GLbyte) {.importc.} + proc glCompressedTexSubImage1DARB(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glClientActiveTexture(texture: GLenum) {.importc.} + proc glVertexAttrib2fARB(index: GLuint, x: GLfloat, y: GLfloat) {.importc.} + proc glProgramUniform2fvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetBufferParameterui64vNV(target: GLenum, pname: GLenum, params: ptr GLuint64EXT) {.importc.} + proc glVertexStream3dvATI(stream: GLenum, coords: ptr GLdouble) {.importc.} + proc glReplacementCodeuiNormal3fVertex3fvSUN(rc: ptr GLuint, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glVertexAttrib4svNV(index: GLuint, v: ptr GLshort) {.importc.} + proc glClearBufferSubData(target: GLenum, internalformat: GLenum, offset: GLintptr, size: GLsizeiptr, format: GLenum, `type`: GLenum, data: ptr pointer) {.importc.} + proc glVertexStream2sATI(stream: GLenum, x: GLshort, y: GLshort) {.importc.} + proc glTextureImage2DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetListParameterfvSGIX(list: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glUniform3uiv(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glIsTexture(texture: GLuint): TGLboolean {.importc.} + proc glObjectUnpurgeableAPPLE(objectType: GLenum, name: GLuint, option: GLenum): TGLenum {.importc.} + proc glGetVertexAttribdv(index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glGetPointeri_vEXT(pname: GLenum, index: GLuint, params: ptr pointer) {.importc.} + proc glSampleCoveragex(value: GLclampx, invert: GLboolean) {.importc.} + proc glColor3f(red: GLfloat, green: GLfloat, blue: GLfloat) {.importc.} + proc glGetnMapivARB(target: GLenum, query: GLenum, bufSize: GLsizei, v: ptr GLint) {.importc.} + proc glMakeTextureHandleResidentARB(handle: GLuint64) {.importc.} + proc glSecondaryColorP3ui(`type`: GLenum, color: GLuint) {.importc.} + proc glMultiTexCoord4sARB(target: GLenum, s: GLshort, t: GLshort, r: GLshort, q: GLshort) {.importc.} + proc glUniform3i64NV(location: GLint, x: GLint64EXT, y: GLint64EXT, z: GLint64EXT) {.importc.} + proc glVDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV, pname: GLenum, bufSize: GLsizei, length: ptr GLsizei, values: ptr GLint) {.importc.} + proc glTexBufferEXT(target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} + proc glVertexAttribI4ubvEXT(index: GLuint, v: ptr GLubyte) {.importc.} + proc glDeleteFramebuffersOES(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glColor3fVertex3fSUN(r: GLfloat, g: GLfloat, b: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glCombinerInputNV(stage: GLenum, portion: GLenum, variable: GLenum, input: GLenum, mapping: GLenum, componentUsage: GLenum) {.importc.} + proc glPolygonOffsetEXT(factor: GLfloat, bias: GLfloat) {.importc.} + proc glWindowPos4dMESA(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glVertex3f(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glTexCoord3f(s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} + proc glMultiTexCoord1fARB(target: GLenum, s: GLfloat) {.importc.} + proc glVertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glGetFragDataLocationEXT(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glFlushMappedNamedBufferRangeEXT(buffer: GLuint, offset: GLintptr, length: GLsizeiptr) {.importc.} + proc glVertexAttrib1sARB(index: GLuint, x: GLshort) {.importc.} + proc glBitmapxOES(width: GLsizei, height: GLsizei, xorig: GLfixed, yorig: GLfixed, xmove: GLfixed, ymove: GLfixed, bitmap: ptr GLubyte) {.importc.} + proc glEnableVertexArrayAttribEXT(vaobj: GLuint, index: GLuint) {.importc.} + proc glDeleteRenderbuffers(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glFramebufferRenderbuffer(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} + proc glInvalidateTexImage(texture: GLuint, level: GLint) {.importc.} + proc glProgramUniform2i64NV(program: GLuint, location: GLint, x: GLint64EXT, y: GLint64EXT) {.importc.} + proc glTextureImage3DMultisampleNV(texture: GLuint, target: GLenum, samples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glValidateProgram(program: GLuint) {.importc.} + proc glUniform1dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glNormalStream3dvATI(stream: GLenum, coords: ptr GLdouble) {.importc.} + proc glMultiDrawElementsIndirect(mode: GLenum, `type`: GLenum, indirect: ptr pointer, drawcount: GLsizei, stride: GLsizei) {.importc.} + proc glVertexBlendARB(count: GLint) {.importc.} + proc glIsSampler(sampler: GLuint): TGLboolean {.importc.} + proc glVariantdvEXT(id: GLuint, `addr`: ptr GLdouble) {.importc.} + proc glProgramUniformMatrix3x2fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glVertexStream4fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} + proc glOrthoxOES(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} + proc glColorFormatNV(size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glFogCoordPointer(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glVertexAttrib3dvARB(index: GLuint, v: ptr GLdouble) {.importc.} + proc glVertex3bOES(x: GLbyte, y: GLbyte) {.importc.} + proc glVertexAttribFormat(attribindex: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, relativeoffset: GLuint) {.importc.} + proc glTexCoord4fVertex4fSUN(s: GLfloat, t: GLfloat, p: GLfloat, q: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glEnableDriverControlQCOM(driverControl: GLuint) {.importc.} + proc glPointParameteri(pname: GLenum, param: GLint) {.importc.} + proc glVertexAttribI2i(index: GLuint, x: GLint, y: GLint) {.importc.} + proc glGetDriverControlStringQCOM(driverControl: GLuint, bufSize: GLsizei, length: ptr GLsizei, driverControlString: ptr GLchar) {.importc.} + proc glGetTexLevelParameteriv(target: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetHandleARB(pname: GLenum): TGLhandleARB {.importc.} + proc glIndexubv(c: ptr GLubyte) {.importc.} + proc glBlendFunciARB(buf: GLuint, src: GLenum, dst: GLenum) {.importc.} + proc glColor4usv(v: ptr GLushort) {.importc.} + proc glBlendEquationSeparateOES(modeRGB: GLenum, modeAlpha: GLenum) {.importc.} + proc glVertexAttribI4ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} + proc glProgramUniform3f(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} + proc glVertexAttribL3i64vNV(index: GLuint, v: ptr GLint64EXT) {.importc.} + proc glWeightdvARB(size: GLint, weights: ptr GLdouble) {.importc.} + proc glVertexArrayRangeAPPLE(length: GLsizei, `pointer`: pointer) {.importc.} + proc glMapGrid2d(un: GLint, u1: GLdouble, u2: GLdouble, vn: GLint, v1: GLdouble, v2: GLdouble) {.importc.} + proc glFogiv(pname: GLenum, params: ptr GLint) {.importc.} + proc glUniform2f(location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} + proc glGetDoublei_v(target: GLenum, index: GLuint, data: ptr GLdouble) {.importc.} + proc glGetVertexAttribfv(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttribI2ivEXT(index: GLuint, v: ptr GLint) {.importc.} + proc glIsProgramNV(id: GLuint): TGLboolean {.importc.} + proc glTexCoord1hNV(s: GLhalfNV) {.importc.} + proc glMinSampleShadingARB(value: GLfloat) {.importc.} + proc glMultiDrawElements(mode: GLenum, count: ptr GLsizei, `type`: GLenum, indices: ptr pointer, drawcount: GLsizei) {.importc.} + proc glGetQueryObjectuiv(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glReadBuffer(mode: GLenum) {.importc.} + proc glMultiTexCoordP3uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} + proc glUniformMatrix3x2fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glBindRenderbuffer(target: GLenum, renderbuffer: GLuint) {.importc.} + proc glBinormal3sEXT(bx: GLshort, by: GLshort, bz: GLshort) {.importc.} + proc glUniform4iARB(location: GLint, v0: GLint, v1: GLint, v2: GLint, v3: GLint) {.importc.} + proc glGetUniformOffsetEXT(program: GLuint, location: GLint): TGLintptr {.importc.} + proc glDeleteLists(list: GLuint, range: GLsizei) {.importc.} + proc glVertexAttribI1iEXT(index: GLuint, x: GLint) {.importc.} + proc glFramebufferTexture1D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glVertexAttribI2uiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glBindFragDataLocation(program: GLuint, color: GLuint, name: ptr GLchar) {.importc.} + proc glClearStencil(s: GLint) {.importc.} + proc glVertexAttrib4Nubv(index: GLuint, v: ptr GLubyte) {.importc.} + proc glConvolutionFilter2DEXT(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glGenFramebuffersEXT(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glFogCoordfvEXT(coord: ptr GLfloat) {.importc.} + proc glGetRenderbufferParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttribs1fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glTexCoord2fColor3fVertex3fSUN(s: GLfloat, t: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glRasterPos3i(x: GLint, y: GLint, z: GLint) {.importc.} + proc glMultiTexSubImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glConvolutionParameteriEXT(target: GLenum, pname: GLenum, params: GLint) {.importc.} + proc glVertexAttribI4iEXT(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glVertexAttribL2i64vNV(index: GLuint, v: ptr GLint64EXT) {.importc.} + proc glBlendColor(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) {.importc.} + proc glGetPathColorGenivNV(color: GLenum, pname: GLenum, value: ptr GLint) {.importc.} + proc glCompressedTextureImage1DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glDrawElementsInstanced(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, instancecount: GLsizei) {.importc.} + proc glFogCoordd(coord: GLdouble) {.importc.} + proc glTexParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glWindowPos3svARB(v: ptr GLshort) {.importc.} + proc glGetVertexArrayPointervEXT(vaobj: GLuint, pname: GLenum, param: ptr pointer) {.importc.} + proc glDrawTextureNV(texture: GLuint, sampler: GLuint, x0: GLfloat, y0: GLfloat, x1: GLfloat, y1: GLfloat, z: GLfloat, s0: GLfloat, t0: GLfloat, s1: GLfloat, t1: GLfloat) {.importc.} + proc glUniformMatrix2dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glTexImage3DOES(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glClampColorARB(target: GLenum, clamp: GLenum) {.importc.} + proc glTexParameteri(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glWindowPos4svMESA(v: ptr GLshort) {.importc.} + proc glMultiTexCoordP4ui(texture: GLenum, `type`: GLenum, coords: GLuint) {.importc.} + proc glVertexP4uiv(`type`: GLenum, value: ptr GLuint) {.importc.} + proc glProgramUniform4iEXT(program: GLuint, location: GLint, v0: GLint, v1: GLint, v2: GLint, v3: GLint) {.importc.} + proc glTexCoord3xvOES(coords: ptr GLfixed) {.importc.} + proc glCopyTexImage2DEXT(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) {.importc.} + proc glGenSamplers(count: GLsizei, samplers: ptr GLuint) {.importc.} + proc glRasterPos4iv(v: ptr GLint) {.importc.} + proc glWindowPos4sMESA(x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glProgramUniform2dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glPrioritizeTexturesEXT(n: GLsizei, textures: ptr GLuint, priorities: ptr GLclampf) {.importc.} + proc glRects(x1: GLshort, y1: GLshort, x2: GLshort, y2: GLshort) {.importc.} + proc glMultiDrawElementsBaseVertex(mode: GLenum, count: ptr GLsizei, `type`: GLenum, indices: ptr pointer, drawcount: GLsizei, basevertex: ptr GLint) {.importc.} + proc glProgramBinaryOES(program: GLuint, binaryFormat: GLenum, binary: pointer, length: GLint) {.importc.} + proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc: ptr GLuint, tc: ptr GLfloat, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glGetMinmaxParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glColor4fNormal3fVertex3fSUN(r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glWindowPos2d(x: GLdouble, y: GLdouble) {.importc.} + proc glGetPerfMonitorGroupStringAMD(group: GLuint, bufSize: GLsizei, length: ptr GLsizei, groupString: ptr GLchar) {.importc.} + proc glUniformHandleui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64) {.importc.} + proc glBlendEquation(mode: GLenum) {.importc.} + proc glMapBufferARB(target: GLenum, access: GLenum) {.importc.} + proc glGetMaterialxvOES(face: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glVertexAttribI1ivEXT(index: GLuint, v: ptr GLint) {.importc.} + proc glTexCoord4hvNV(v: ptr GLhalfNV) {.importc.} + proc glVertexArrayVertexAttribLOffsetEXT(vaobj: GLuint, buffer: GLuint, index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glExtGetShadersQCOM(shaders: ptr GLuint, maxShaders: GLint, numShaders: ptr GLint) {.importc.} + proc glWindowPos4ivMESA(v: ptr GLint) {.importc.} + proc glVertexAttrib1sNV(index: GLuint, x: GLshort) {.importc.} + proc glNormalStream3ivATI(stream: GLenum, coords: ptr GLint) {.importc.} + proc glSecondaryColor3fEXT(red: GLfloat, green: GLfloat, blue: GLfloat) {.importc.} + proc glVertexArrayFogCoordOffsetEXT(vaobj: GLuint, buffer: GLuint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glGetTextureImageEXT(texture: GLuint, target: GLenum, level: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glVertexAttrib4hNV(index: GLuint, x: GLhalfNV, y: GLhalfNV, z: GLhalfNV, w: GLhalfNV) {.importc.} + proc glReplacementCodeusSUN(code: GLushort) {.importc.} + proc glPixelTexGenSGIX(mode: GLenum) {.importc.} + proc glMultiDrawRangeElementArrayAPPLE(mode: GLenum, start: GLuint, `end`: GLuint, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei) {.importc.} + proc glDrawElements(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer) {.importc.} + proc glTexCoord1hvNV(v: ptr GLhalfNV) {.importc.} + proc glGetPixelMapuiv(map: GLenum, values: ptr GLuint) {.importc.} + proc glRasterPos4d(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glTexImage1D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glConvolutionParameterxOES(target: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glSecondaryColor3dEXT(red: GLdouble, green: GLdouble, blue: GLdouble) {.importc.} + proc glGetCombinerOutputParameterivNV(stage: GLenum, portion: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glQueryCounter(id: GLuint, target: GLenum) {.importc.} + proc glGetUniformi64vNV(program: GLuint, location: GLint, params: ptr GLint64EXT) {.importc.} + proc glTexCoord2fv(v: ptr GLfloat) {.importc.} + proc glWindowPos3d(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glBlendFuncSeparateINGR(sfactorRGB: GLenum, dfactorRGB: GLenum, sfactorAlpha: GLenum, dfactorAlpha: GLenum) {.importc.} + proc glTextureNormalEXT(mode: GLenum) {.importc.} + proc glVertexStream2fATI(stream: GLenum, x: GLfloat, y: GLfloat) {.importc.} + proc glViewportIndexedf(index: GLuint, x: GLfloat, y: GLfloat, w: GLfloat, h: GLfloat) {.importc.} + proc glMultiTexCoord4ivARB(target: GLenum, v: ptr GLint) {.importc.} + proc glBindBufferOffsetEXT(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr) {.importc.} + proc glTexCoord3sv(v: ptr GLshort) {.importc.} + proc glVertexArrayVertexAttribBindingEXT(vaobj: GLuint, attribindex: GLuint, bindingindex: GLuint) {.importc.} + proc glVertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat) {.importc.} + proc glMultiTexGenivEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glUniformui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} + proc glGetInfoLogARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, infoLog: ptr GLcharARB) {.importc.} + proc glGetNamedProgramLocalParameterIivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glVertexAttrib4s(index: GLuint, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glUniformMatrix4x2dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glVertexAttribs3dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glSecondaryColor3dvEXT(v: ptr GLdouble) {.importc.} + proc glTextureRenderbufferEXT(texture: GLuint, target: GLenum, renderbuffer: GLuint) {.importc.} + proc glVertexAttribL2ui64vNV(index: GLuint, v: ptr GLuint64EXT) {.importc.} + proc glBlendFuncSeparateOES(srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) {.importc.} + proc glVertexAttribDivisorARB(index: GLuint, divisor: GLuint) {.importc.} + proc glWindowPos2sv(v: ptr GLshort) {.importc.} + proc glMultiTexCoord3svARB(target: GLenum, v: ptr GLshort) {.importc.} + proc glCombinerParameterfvNV(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetImageTransformParameterfvHP(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetArrayObjectivATI(`array`: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetTexParameterIuiv(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glGetProgramPipelineInfoLog(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetOcclusionQueryuivNV(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glVertexAttrib4bvARB(index: GLuint, v: ptr GLbyte) {.importc.} + proc glListParameterfvSGIX(list: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glDeleteSamplers(count: GLsizei, samplers: ptr GLuint) {.importc.} + proc glNormalStream3dATI(stream: GLenum, nx: GLdouble, ny: GLdouble, nz: GLdouble) {.importc.} + proc glProgramUniform4i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} + proc glBlendFuncSeparateiARB(buf: GLuint, srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) {.importc.} proc glEndTransformFeedbackEXT() {.importc.} - proc glMultiTexCoord3i(target: TGLenum, s: TGLint, t: TGLint, r: TGLint) {.importc.} - proc glMakeBufferResidentNV(target: TGLenum, access: TGLenum) {.importc.} - proc glTangent3dvEXT(v: ptr TGLdouble) {.importc.} - proc glMatrixPopEXT(mode: TGLenum) {.importc.} - proc glVertexAttrib4NivARB(index: TGLuint, v: ptr TGLint) {.importc.} - proc glProgramUniform2ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc.} - proc glWeightPointerARB(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glCullParameterdvEXT(pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glFramebufferTexture2D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glGenVertexArrays(n: TGLsizei, arrays: ptr TGLuint) {.importc.} - proc glUniformHandleui64NV(location: TGLint, value: TGLuint64) {.importc.} - proc glIndexPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glGetProgramSubroutineParameteruivNV(target: TGLenum, index: TGLuint, param: ptr TGLuint) {.importc.} - proc glVertexAttrib1svARB(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glDetachObjectARB(containerObj: TGLhandleARB, attachedObj: TGLhandleARB) {.importc.} - proc glCompressedTexImage3D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glBlendFuncSeparate(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc.} - proc glExecuteProgramNV(target: TGLenum, id: TGLuint, params: ptr TGLfloat) {.importc.} - proc glAttachObjectARB(containerObj: TGLhandleARB, obj: TGLhandleARB) {.importc.} - proc glCompressedTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} - proc glProgramUniform4iv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glVertexAttrib3sv(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glTexCoord3bvOES(coords: ptr TGLbyte) {.importc.} - proc glGenTexturesEXT(n: TGLsizei, textures: ptr TGLuint) {.importc.} - proc glColor4f(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} - proc glGetFramebufferAttachmentParameterivOES(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glClearColor(red: TGLfloat, green: TGLfloat, blue: TGLfloat, alpha: TGLfloat) {.importc.} - proc glNamedProgramLocalParametersI4ivEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLint) {.importc.} - proc glMakeImageHandleNonResidentARB(handle: TGLuint64) {.importc.} - proc glGenRenderbuffers(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} - proc glVertexAttribL1ui64vARB(index: TGLuint, v: ptr TGLuint64EXT) {.importc.} - proc glBindFramebufferEXT(target: TGLenum, framebuffer: TGLuint) {.importc.} - proc glProgramUniform2dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble) {.importc.} - proc glCompressedMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glDeleteSyncAPPLE(sync: TGLsync) {.importc.} - proc glDebugMessageInsertAMD(category: TGLenum, severity: TGLenum, id: TGLuint, length: TGLsizei, buf: ptr TGLchar) {.importc.} - proc glSecondaryColorPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glTextureImage2DMultisampleNV(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} + proc glMultiTexCoord3i(target: GLenum, s: GLint, t: GLint, r: GLint) {.importc.} + proc glMakeBufferResidentNV(target: GLenum, access: GLenum) {.importc.} + proc glTangent3dvEXT(v: ptr GLdouble) {.importc.} + proc glMatrixPopEXT(mode: GLenum) {.importc.} + proc glVertexAttrib4NivARB(index: GLuint, v: ptr GLint) {.importc.} + proc glProgramUniform2ui64NV(program: GLuint, location: GLint, x: GLuint64EXT, y: GLuint64EXT) {.importc.} + proc glWeightPointerARB(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glCullParameterdvEXT(pname: GLenum, params: ptr GLdouble) {.importc.} + proc glFramebufferTexture2D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glGenVertexArrays(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glUniformHandleui64NV(location: GLint, value: GLuint64) {.importc.} + proc glIndexPointer(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glGetProgramSubroutineParameteruivNV(target: GLenum, index: GLuint, param: ptr GLuint) {.importc.} + proc glVertexAttrib1svARB(index: GLuint, v: ptr GLshort) {.importc.} + proc glDetachObjectARB(containerObj: GLhandleARB, attachedObj: GLhandleARB) {.importc.} + proc glCompressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glBlendFuncSeparate(sfactorRGB: GLenum, dfactorRGB: GLenum, sfactorAlpha: GLenum, dfactorAlpha: GLenum) {.importc.} + proc glExecuteProgramNV(target: GLenum, id: GLuint, params: ptr GLfloat) {.importc.} + proc glAttachObjectARB(containerObj: GLhandleARB, obj: GLhandleARB) {.importc.} + proc glCompressedTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glProgramUniform4iv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glVertexAttrib3sv(index: GLuint, v: ptr GLshort) {.importc.} + proc glTexCoord3bvOES(coords: ptr GLbyte) {.importc.} + proc glGenTexturesEXT(n: GLsizei, textures: ptr GLuint) {.importc.} + proc glColor4f(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) {.importc.} + proc glGetFramebufferAttachmentParameterivOES(target: GLenum, attachment: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glClearColor(red: GLfloat, green: GLfloat, blue: GLfloat, alpha: GLfloat) {.importc.} + proc glNamedProgramLocalParametersI4ivEXT(program: GLuint, target: GLenum, index: GLuint, count: GLsizei, params: ptr GLint) {.importc.} + proc glMakeImageHandleNonResidentARB(handle: GLuint64) {.importc.} + proc glGenRenderbuffers(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glVertexAttribL1ui64vARB(index: GLuint, v: ptr GLuint64EXT) {.importc.} + proc glBindFramebufferEXT(target: GLenum, framebuffer: GLuint) {.importc.} + proc glProgramUniform2dEXT(program: GLuint, location: GLint, x: GLdouble, y: GLdouble) {.importc.} + proc glCompressedMultiTexImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glDeleteSyncAPPLE(sync: GLsync) {.importc.} + proc glDebugMessageInsertAMD(category: GLenum, severity: GLenum, id: GLuint, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glSecondaryColorPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glTextureImage2DMultisampleNV(texture: GLuint, target: GLenum, samples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, fixedSampleLocations: GLboolean) {.importc.} proc glBeginFragmentShaderATI() {.importc.} - proc glClearDepth(depth: TGLdouble) {.importc.} - proc glBindTextures(first: TGLuint, count: TGLsizei, textures: ptr TGLuint) {.importc.} - proc glEvalCoord1d(u: TGLdouble) {.importc.} - proc glSecondaryColor3b(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc.} - proc glExtGetTexSubImageQCOM(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, texels: pointer) {.importc.} - proc glClearColorIiEXT(red: TGLint, green: TGLint, blue: TGLint, alpha: TGLint) {.importc.} - proc glVertex2xOES(x: TGLfixed) {.importc.} - proc glVertexAttrib2s(index: TGLuint, x: TGLshort, y: TGLshort) {.importc.} - proc glUniformHandleui64vARB(location: TGLint, count: TGLsizei, value: ptr TGLuint64) {.importc.} - proc glAreTexturesResidentEXT(n: TGLsizei, textures: ptr TGLuint, residences: ptr TGLboolean): TGLboolean {.importc.} - proc glDrawElementsInstancedBaseInstance(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, instancecount: TGLsizei, baseinstance: TGLuint) {.importc.} - proc glGetString(name: TGLenum): TGLubyte {.importc.} - proc glDrawTransformFeedbackStream(mode: TGLenum, id: TGLuint, stream: TGLuint) {.importc.} - proc glSecondaryColor3uiv(v: ptr TGLuint) {.importc.} - proc glNamedFramebufferParameteriEXT(framebuffer: TGLuint, pname: TGLenum, param: TGLint) {.importc.} - proc glVertexAttrib4hvNV(index: TGLuint, v: ptr TGLhalfNV) {.importc.} - proc glGetnUniformuivARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLuint) {.importc.} - proc glProgramUniform4ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} - proc glPointParameterxvOES(pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glIsEnabledi(target: TGLenum, index: TGLuint): TGLboolean {.importc.} - proc glColorPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} - proc glFragmentLightModelfvSGIX(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glRasterPos3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glDeleteObjectARB(obj: TGLhandleARB) {.importc.} - proc glSetFenceNV(fence: TGLuint, condition: TGLenum) {.importc.} - proc glTransformFeedbackAttribsNV(count: TGLuint, attribs: ptr TGLint, bufferMode: TGLenum) {.importc.} - proc glProgramUniformMatrix2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glGetPointerv(pname: TGLenum, params: ptr pointer) {.importc.} - proc glWindowPos2dvMESA(v: ptr TGLdouble) {.importc.} - proc glTexImage2DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLint, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} - proc glGenFragmentShadersATI(range: TGLuint): TGLuint {.importc.} - proc glTexCoord4fv(v: ptr TGLfloat) {.importc.} - proc glCompressedTexImage1D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glGetNamedBufferSubDataEXT(buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} + proc glClearDepth(depth: GLdouble) {.importc.} + proc glBindTextures(first: GLuint, count: GLsizei, textures: ptr GLuint) {.importc.} + proc glEvalCoord1d(u: GLdouble) {.importc.} + proc glSecondaryColor3b(red: GLbyte, green: GLbyte, blue: GLbyte) {.importc.} + proc glExtGetTexSubImageQCOM(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, texels: pointer) {.importc.} + proc glClearColorIiEXT(red: GLint, green: GLint, blue: GLint, alpha: GLint) {.importc.} + proc glVertex2xOES(x: GLfixed) {.importc.} + proc glVertexAttrib2s(index: GLuint, x: GLshort, y: GLshort) {.importc.} + proc glUniformHandleui64vARB(location: GLint, count: GLsizei, value: ptr GLuint64) {.importc.} + proc glAreTexturesResidentEXT(n: GLsizei, textures: ptr GLuint, residences: ptr GLboolean): TGLboolean {.importc.} + proc glDrawElementsInstancedBaseInstance(mode: GLenum, count: GLsizei, `type`: GLenum, indices: ptr pointer, instancecount: GLsizei, baseinstance: GLuint) {.importc.} + proc glGetString(name: GLenum): TGLubyte {.importc.} + proc glDrawTransformFeedbackStream(mode: GLenum, id: GLuint, stream: GLuint) {.importc.} + proc glSecondaryColor3uiv(v: ptr GLuint) {.importc.} + proc glNamedFramebufferParameteriEXT(framebuffer: GLuint, pname: GLenum, param: GLint) {.importc.} + proc glVertexAttrib4hvNV(index: GLuint, v: ptr GLhalfNV) {.importc.} + proc glGetnUniformuivARB(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLuint) {.importc.} + proc glProgramUniform4ui(program: GLuint, location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} + proc glPointParameterxvOES(pname: GLenum, params: ptr GLfixed) {.importc.} + proc glIsEnabledi(target: GLenum, index: GLuint): TGLboolean {.importc.} + proc glColorPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, count: GLsizei, `pointer`: pointer) {.importc.} + proc glFragmentLightModelfvSGIX(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glRasterPos3f(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glDeleteObjectARB(obj: GLhandleARB) {.importc.} + proc glSetFenceNV(fence: GLuint, condition: GLenum) {.importc.} + proc glTransformFeedbackAttribsNV(count: GLuint, attribs: ptr GLint, bufferMode: GLenum) {.importc.} + proc glProgramUniformMatrix2fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glGetPointerv(pname: GLenum, params: ptr pointer) {.importc.} + proc glWindowPos2dvMESA(v: ptr GLdouble) {.importc.} + proc glTexImage2DMultisample(target: GLenum, samples: GLsizei, internalformat: GLint, width: GLsizei, height: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glGenFragmentShadersATI(range: GLuint): TGLuint {.importc.} + proc glTexCoord4fv(v: ptr GLfloat) {.importc.} + proc glCompressedTexImage1D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glGetNamedBufferSubDataEXT(buffer: GLuint, offset: GLintptr, size: GLsizeiptr, data: pointer) {.importc.} proc glFinish() {.importc.} - proc glDeleteVertexShaderEXT(id: TGLuint) {.importc.} - proc glFinishObjectAPPLE(`object`: TGLenum, name: TGLint) {.importc.} - proc glGetActiveAttribARB(programObj: TGLhandleARB, index: TGLuint, maxLength: TGLsizei, length: ptr TGLsizei, size: ptr TGLint, `type`: ptr TGLenum, name: ptr TGLcharARB) {.importc.} - proc glPointParameterx(pname: TGLenum, param: TGLfixed) {.importc.} - proc glProgramUniformui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} - proc glSecondaryColor3ubv(v: ptr TGLubyte) {.importc.} - proc glGetProgramLocalParameterIivNV(target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} - proc glDeleteProgramPipelinesEXT(n: TGLsizei, pipelines: ptr TGLuint) {.importc.} - proc glVertexAttrib4fNV(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glGetColorTableParameterfvSGI(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glGetFloati_v(target: TGLenum, index: TGLuint, data: ptr TGLfloat) {.importc.} - proc glGenBuffers(n: TGLsizei, buffers: ptr TGLuint) {.importc.} - proc glNormal3b(nx: TGLbyte, ny: TGLbyte, nz: TGLbyte) {.importc.} - proc glDrawArraysInstancedARB(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} - proc glTexStorage2DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} - proc glGetVariantIntegervEXT(id: TGLuint, value: TGLenum, data: ptr TGLint) {.importc.} - proc glColor3ubv(v: ptr TGLubyte) {.importc.} - proc glVertexAttribP4uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: ptr TGLuint) {.importc.} - proc glProgramUniform2ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glVertexStream4dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glVertexAttribL2ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT) {.importc.} - proc glSecondaryColor3bEXT(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc.} - proc glGetBufferPointervOES(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} - proc glGetMaterialfv(face: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVertexStream3sATI(stream: TGLenum, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glUniform1i(location: TGLint, v0: TGLint) {.importc.} - proc glVertexAttribL2d(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} - proc glTestObjectAPPLE(`object`: TGLenum, name: TGLuint): TGLboolean {.importc.} - proc glGetTransformFeedbackVarying(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, size: ptr TGLsizei, `type`: ptr TGLenum, name: ptr TGLchar) {.importc.} - proc glFramebufferRenderbufferOES(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glVertexStream3iATI(stream: TGLenum, x: TGLint, y: TGLint, z: TGLint) {.importc.} - proc glMakeTextureHandleNonResidentNV(handle: TGLuint64) {.importc.} - proc glVertexAttrib4fvNV(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glArrayElement(i: TGLint) {.importc.} - proc glClearBufferData(target: TGLenum, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, data: ptr pointer) {.importc.} - proc glSecondaryColor3usEXT(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc.} - proc glRenderbufferStorageMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glTexCoord2xvOES(coords: ptr TGLfixed) {.importc.} - proc glWindowPos3f(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glTangent3svEXT(v: ptr TGLshort) {.importc.} - proc glPointParameterf(pname: TGLenum, param: TGLfloat) {.importc.} - proc glVertexAttribI4uivEXT(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glColorTableParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glMatrixMultdEXT(mode: TGLenum, m: ptr TGLdouble) {.importc.} - proc glUseProgramStages(pipeline: TGLuint, stages: TGLbitfield, program: TGLuint) {.importc.} - proc glVertexStream4sATI(stream: TGLenum, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glDrawElementsInstancedNV(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} - proc glUniform3d(location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glDebugMessageControlARB(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: ptr TGLuint, enabled: TGLboolean) {.importc.} - proc glVertexAttribs3svNV(index: TGLuint, count: TGLsizei, v: ptr TGLshort) {.importc.} - proc glElementPointerATI(`type`: TGLenum, `pointer`: pointer) {.importc.} - proc glColor4fNormal3fVertex3fvSUN(c: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glGetPerfMonitorCountersAMD(group: TGLuint, numCounters: ptr TGLint, maxActiveCounters: ptr TGLint, counterSize: TGLsizei, counters: ptr TGLuint) {.importc.} - proc glDispatchCompute(num_groups_x: TGLuint, num_groups_y: TGLuint, num_groups_z: TGLuint) {.importc.} - proc glVertexAttribDivisorNV(index: TGLuint, divisor: TGLuint) {.importc.} - proc glProgramUniform3uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} - proc glRenderbufferStorageMultisampleNV(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glBinormalPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glRectxvOES(v1: ptr TGLfixed, v2: ptr TGLfixed) {.importc.} - proc glGenVertexArraysOES(n: TGLsizei, arrays: ptr TGLuint) {.importc.} - proc glDebugMessageControlKHR(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: ptr TGLuint, enabled: TGLboolean) {.importc.} - proc glProgramUniform1uiEXT(program: TGLuint, location: TGLint, v0: TGLuint) {.importc.} - proc glPixelTransferi(pname: TGLenum, param: TGLint) {.importc.} - proc glIsPointInFillPathNV(path: TGLuint, mask: TGLuint, x: TGLfloat, y: TGLfloat): TGLboolean {.importc.} - proc glVertexBindingDivisor(bindingindex: TGLuint, divisor: TGLuint) {.importc.} - proc glGetVertexAttribLui64vARB(index: TGLuint, pname: TGLenum, params: ptr TGLuint64EXT) {.importc.} - proc glProgramUniformMatrix3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glDrawBuffer(mode: TGLenum) {.importc.} - proc glMultiTexCoord1sARB(target: TGLenum, s: TGLshort) {.importc.} - proc glSeparableFilter2DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer) {.importc.} - proc glTangent3bvEXT(v: ptr TGLbyte) {.importc.} - proc glTexParameterIuiv(target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glVertexAttribL4i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT, w: TGLint64EXT) {.importc.} - proc glDebugMessageCallbackARB(callback: TGLDEBUGPROCARB, userParam: ptr pointer) {.importc.} - proc glMultiTexCoordP1uiv(texture: TGLenum, `type`: TGLenum, coords: ptr TGLuint) {.importc.} - proc glLabelObjectEXT(`type`: TGLenum, `object`: TGLuint, length: TGLsizei, label: ptr TGLchar) {.importc.} - proc glGetnPolygonStippleARB(bufSize: TGLsizei, pattern: ptr TGLubyte) {.importc.} - proc glTexCoord3xOES(s: TGLfixed, t: TGLfixed, r: TGLfixed) {.importc.} - proc glCopyPixels(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, `type`: TGLenum) {.importc.} - proc glGetnUniformfvEXT(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLfloat) {.importc.} - proc glColorMaski(index: TGLuint, r: TGLboolean, g: TGLboolean, b: TGLboolean, a: TGLboolean) {.importc.} - proc glRasterPos2fv(v: ptr TGLfloat) {.importc.} - proc glBindBuffersBase(target: TGLenum, first: TGLuint, count: TGLsizei, buffers: ptr TGLuint) {.importc.} - proc glSpriteParameterfvSGIX(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glGetSyncivAPPLE(sync: TGLsync, pname: TGLenum, bufSize: TGLsizei, length: ptr TGLsizei, values: ptr TGLint) {.importc.} - proc glVertexAttribI3i(index: TGLuint, x: TGLint, y: TGLint, z: TGLint) {.importc.} - proc glPixelTransformParameteriEXT(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glMultiDrawArraysEXT(mode: TGLenum, first: ptr TGLint, count: ptr TGLsizei, primcount: TGLsizei) {.importc.} - proc glGetTextureHandleNV(texture: TGLuint): TGLuint64 {.importc.} - proc glTexCoordP2ui(`type`: TGLenum, coords: TGLuint) {.importc.} - proc glDeleteQueries(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glGetVertexAttribArrayObjectivATI(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertexArrayVertexBindingDivisorEXT(vaobj: TGLuint, bindingindex: TGLuint, divisor: TGLuint) {.importc.} - proc glVertex3i(x: TGLint, y: TGLint, z: TGLint) {.importc.} - proc glBlendEquationSeparatei(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} - proc glGetMapAttribParameterivNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetVideoCaptureivNV(video_capture_slot: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glFragmentMaterialfvSGIX(face: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glEGLImageTargetTexture2DOES(target: TGLenum, image: TGLeglImageOES) {.importc.} - proc glCopyImageSubDataNV(srcName: TGLuint, srcTarget: TGLenum, srcLevel: TGLint, srcX: TGLint, srcY: TGLint, srcZ: TGLint, dstName: TGLuint, dstTarget: TGLenum, dstLevel: TGLint, dstX: TGLint, dstY: TGLint, dstZ: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} - proc glUniform2i(location: TGLint, v0: TGLint, v1: TGLint) {.importc.} - proc glVertexAttrib3fvNV(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glNamedBufferStorageEXT(buffer: TGLuint, size: TGLsizeiptr, data: ptr pointer, flags: TGLbitfield) {.importc.} - proc glProgramEnvParameterI4uivNV(target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} - proc glGetVertexAttribdvARB(index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glVertexAttribL3ui64vNV(index: TGLuint, v: ptr TGLuint64EXT) {.importc.} - proc glUniform4fvARB(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glWeightsvARB(size: TGLint, weights: ptr TGLshort) {.importc.} - proc glMakeTextureHandleNonResidentARB(handle: TGLuint64) {.importc.} - proc glEvalCoord1xOES(u: TGLfixed) {.importc.} - proc glVertexAttrib2sv(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glVertexAttrib4dvNV(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glProgramNamedParameter4fNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glCompileShaderARB(shaderObj: TGLhandleARB) {.importc.} - proc glProgramEnvParameter4fvARB(target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} - proc glGetVertexAttribiv(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glEvalPoint1(i: TGLint) {.importc.} - proc glEvalMapsNV(target: TGLenum, mode: TGLenum) {.importc.} - proc glGetTexGenxvOES(coord: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glBlendEquationSeparate(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} - proc glGetColorTableParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glQueryCounterEXT(id: TGLuint, target: TGLenum) {.importc.} - proc glExtGetProgramBinarySourceQCOM(program: TGLuint, shadertype: TGLenum, source: ptr TGLchar, length: ptr TGLint) {.importc.} - proc glGetConvolutionParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glIsProgramPipeline(pipeline: TGLuint): TGLboolean {.importc.} - proc glVertexWeightfvEXT(weight: ptr TGLfloat) {.importc.} - proc glDisableDriverControlQCOM(driverControl: TGLuint) {.importc.} - proc glVertexStream1fvATI(stream: TGLenum, coords: ptr TGLfloat) {.importc.} - proc glMakeTextureHandleResidentNV(handle: TGLuint64) {.importc.} - proc glSamplerParameteriv(sampler: TGLuint, pname: TGLenum, param: ptr TGLint) {.importc.} - proc glTexEnvxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} + proc glDeleteVertexShaderEXT(id: GLuint) {.importc.} + proc glFinishObjectAPPLE(`object`: GLenum, name: GLint) {.importc.} + proc glGetActiveAttribARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLcharARB) {.importc.} + proc glPointParameterx(pname: GLenum, param: GLfixed) {.importc.} + proc glProgramUniformui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} + proc glSecondaryColor3ubv(v: ptr GLubyte) {.importc.} + proc glGetProgramLocalParameterIivNV(target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glDeleteProgramPipelinesEXT(n: GLsizei, pipelines: ptr GLuint) {.importc.} + proc glVertexAttrib4fNV(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glGetColorTableParameterfvSGI(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetFloati_v(target: GLenum, index: GLuint, data: ptr GLfloat) {.importc.} + proc glGenBuffers(n: GLsizei, buffers: ptr GLuint) {.importc.} + proc glNormal3b(nx: GLbyte, ny: GLbyte, nz: GLbyte) {.importc.} + proc glDrawArraysInstancedARB(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei) {.importc.} + proc glTexStorage2DMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glGetVariantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} + proc glColor3ubv(v: ptr GLubyte) {.importc.} + proc glVertexAttribP4uiv(index: GLuint, `type`: GLenum, normalized: GLboolean, value: ptr GLuint) {.importc.} + proc glProgramUniform2ivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glVertexStream4dATI(stream: GLenum, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glVertexAttribL2ui64NV(index: GLuint, x: GLuint64EXT, y: GLuint64EXT) {.importc.} + proc glSecondaryColor3bEXT(red: GLbyte, green: GLbyte, blue: GLbyte) {.importc.} + proc glGetBufferPointervOES(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} + proc glGetMaterialfv(face: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexStream3sATI(stream: GLenum, x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glUniform1i(location: GLint, v0: GLint) {.importc.} + proc glVertexAttribL2d(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} + proc glTestObjectAPPLE(`object`: GLenum, name: GLuint): TGLboolean {.importc.} + proc glGetTransformFeedbackVarying(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glFramebufferRenderbufferOES(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} + proc glVertexStream3iATI(stream: GLenum, x: GLint, y: GLint, z: GLint) {.importc.} + proc glMakeTextureHandleNonResidentNV(handle: GLuint64) {.importc.} + proc glVertexAttrib4fvNV(index: GLuint, v: ptr GLfloat) {.importc.} + proc glArrayElement(i: GLint) {.importc.} + proc glClearBufferData(target: GLenum, internalformat: GLenum, format: GLenum, `type`: GLenum, data: ptr pointer) {.importc.} + proc glSecondaryColor3usEXT(red: GLushort, green: GLushort, blue: GLushort) {.importc.} + proc glRenderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glTexCoord2xvOES(coords: ptr GLfixed) {.importc.} + proc glWindowPos3f(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glTangent3svEXT(v: ptr GLshort) {.importc.} + proc glPointParameterf(pname: GLenum, param: GLfloat) {.importc.} + proc glVertexAttribI4uivEXT(index: GLuint, v: ptr GLuint) {.importc.} + proc glColorTableParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMatrixMultdEXT(mode: GLenum, m: ptr GLdouble) {.importc.} + proc glUseProgramStages(pipeline: GLuint, stages: GLbitfield, program: GLuint) {.importc.} + proc glVertexStream4sATI(stream: GLenum, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glDrawElementsInstancedNV(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, primcount: GLsizei) {.importc.} + proc glUniform3d(location: GLint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glDebugMessageControlARB(source: GLenum, `type`: GLenum, severity: GLenum, count: GLsizei, ids: ptr GLuint, enabled: GLboolean) {.importc.} + proc glVertexAttribs3svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} + proc glElementPointerATI(`type`: GLenum, `pointer`: pointer) {.importc.} + proc glColor4fNormal3fVertex3fvSUN(c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glGetPerfMonitorCountersAMD(group: GLuint, numCounters: ptr GLint, maxActiveCounters: ptr GLint, counterSize: GLsizei, counters: ptr GLuint) {.importc.} + proc glDispatchCompute(num_groups_x: GLuint, num_groups_y: GLuint, num_groups_z: GLuint) {.importc.} + proc glVertexAttribDivisorNV(index: GLuint, divisor: GLuint) {.importc.} + proc glProgramUniform3uiEXT(program: GLuint, location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} + proc glRenderbufferStorageMultisampleNV(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glBinormalPointerEXT(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glRectxvOES(v1: ptr GLfixed, v2: ptr GLfixed) {.importc.} + proc glGenVertexArraysOES(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glDebugMessageControlKHR(source: GLenum, `type`: GLenum, severity: GLenum, count: GLsizei, ids: ptr GLuint, enabled: GLboolean) {.importc.} + proc glProgramUniform1uiEXT(program: GLuint, location: GLint, v0: GLuint) {.importc.} + proc glPixelTransferi(pname: GLenum, param: GLint) {.importc.} + proc glIsPointInFillPathNV(path: GLuint, mask: GLuint, x: GLfloat, y: GLfloat): TGLboolean {.importc.} + proc glVertexBindingDivisor(bindingindex: GLuint, divisor: GLuint) {.importc.} + proc glGetVertexAttribLui64vARB(index: GLuint, pname: GLenum, params: ptr GLuint64EXT) {.importc.} + proc glProgramUniformMatrix3dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glDrawBuffer(mode: GLenum) {.importc.} + proc glMultiTexCoord1sARB(target: GLenum, s: GLshort) {.importc.} + proc glSeparableFilter2DEXT(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, row: pointer, column: pointer) {.importc.} + proc glTangent3bvEXT(v: ptr GLbyte) {.importc.} + proc glTexParameterIuiv(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glVertexAttribL4i64NV(index: GLuint, x: GLint64EXT, y: GLint64EXT, z: GLint64EXT, w: GLint64EXT) {.importc.} + proc glDebugMessageCallbackARB(callback: GLDEBUGPROCARB, userParam: ptr pointer) {.importc.} + proc glMultiTexCoordP1uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} + proc glLabelObjectEXT(`type`: GLenum, `object`: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} + proc glGetnPolygonStippleARB(bufSize: GLsizei, pattern: ptr GLubyte) {.importc.} + proc glTexCoord3xOES(s: GLfixed, t: GLfixed, r: GLfixed) {.importc.} + proc glCopyPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, `type`: GLenum) {.importc.} + proc glGetnUniformfvEXT(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLfloat) {.importc.} + proc glColorMaski(index: GLuint, r: GLboolean, g: GLboolean, b: GLboolean, a: GLboolean) {.importc.} + proc glRasterPos2fv(v: ptr GLfloat) {.importc.} + proc glBindBuffersBase(target: GLenum, first: GLuint, count: GLsizei, buffers: ptr GLuint) {.importc.} + proc glSpriteParameterfvSGIX(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetSyncivAPPLE(sync: GLsync, pname: GLenum, bufSize: GLsizei, length: ptr GLsizei, values: ptr GLint) {.importc.} + proc glVertexAttribI3i(index: GLuint, x: GLint, y: GLint, z: GLint) {.importc.} + proc glPixelTransformParameteriEXT(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glMultiDrawArraysEXT(mode: GLenum, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei) {.importc.} + proc glGetTextureHandleNV(texture: GLuint): TGLuint64 {.importc.} + proc glTexCoordP2ui(`type`: GLenum, coords: GLuint) {.importc.} + proc glDeleteQueries(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glGetVertexAttribArrayObjectivATI(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexArrayVertexBindingDivisorEXT(vaobj: GLuint, bindingindex: GLuint, divisor: GLuint) {.importc.} + proc glVertex3i(x: GLint, y: GLint, z: GLint) {.importc.} + proc glBlendEquationSeparatei(buf: GLuint, modeRGB: GLenum, modeAlpha: GLenum) {.importc.} + proc glGetMapAttribParameterivNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetVideoCaptureivNV(video_capture_slot: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glFragmentMaterialfvSGIX(face: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glEGLImageTargetTexture2DOES(target: GLenum, image: GLeglImageOES) {.importc.} + proc glCopyImageSubDataNV(srcName: GLuint, srcTarget: GLenum, srcLevel: GLint, srcX: GLint, srcY: GLint, srcZ: GLint, dstName: GLuint, dstTarget: GLenum, dstLevel: GLint, dstX: GLint, dstY: GLint, dstZ: GLint, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} + proc glUniform2i(location: GLint, v0: GLint, v1: GLint) {.importc.} + proc glVertexAttrib3fvNV(index: GLuint, v: ptr GLfloat) {.importc.} + proc glNamedBufferStorageEXT(buffer: GLuint, size: GLsizeiptr, data: ptr pointer, flags: GLbitfield) {.importc.} + proc glProgramEnvParameterI4uivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glGetVertexAttribdvARB(index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glVertexAttribL3ui64vNV(index: GLuint, v: ptr GLuint64EXT) {.importc.} + proc glUniform4fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glWeightsvARB(size: GLint, weights: ptr GLshort) {.importc.} + proc glMakeTextureHandleNonResidentARB(handle: GLuint64) {.importc.} + proc glEvalCoord1xOES(u: GLfixed) {.importc.} + proc glVertexAttrib2sv(index: GLuint, v: ptr GLshort) {.importc.} + proc glVertexAttrib4dvNV(index: GLuint, v: ptr GLdouble) {.importc.} + proc glProgramNamedParameter4fNV(id: GLuint, len: GLsizei, name: ptr GLubyte, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glCompileShaderARB(shaderObj: GLhandleARB) {.importc.} + proc glProgramEnvParameter4fvARB(target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glGetVertexAttribiv(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glEvalPoint1(i: GLint) {.importc.} + proc glEvalMapsNV(target: GLenum, mode: GLenum) {.importc.} + proc glGetTexGenxvOES(coord: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glBlendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum) {.importc.} + proc glGetColorTableParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glQueryCounterEXT(id: GLuint, target: GLenum) {.importc.} + proc glExtGetProgramBinarySourceQCOM(program: GLuint, shadertype: GLenum, source: ptr GLchar, length: ptr GLint) {.importc.} + proc glGetConvolutionParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glIsProgramPipeline(pipeline: GLuint): TGLboolean {.importc.} + proc glVertexWeightfvEXT(weight: ptr GLfloat) {.importc.} + proc glDisableDriverControlQCOM(driverControl: GLuint) {.importc.} + proc glVertexStream1fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} + proc glMakeTextureHandleResidentNV(handle: GLuint64) {.importc.} + proc glSamplerParameteriv(sampler: GLuint, pname: GLenum, param: ptr GLint) {.importc.} + proc glTexEnvxOES(target: GLenum, pname: GLenum, param: GLfixed) {.importc.} proc glEndOcclusionQueryNV() {.importc.} - proc glFlushMappedBufferRangeAPPLE(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glVertex4iv(v: ptr TGLint) {.importc.} - proc glVertexArrayVertexAttribIFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} - proc glDisableIndexedEXT(target: TGLenum, index: TGLuint) {.importc.} - proc glVertexAttribL1dEXT(index: TGLuint, x: TGLdouble) {.importc.} - proc glBeginPerfMonitorAMD(monitor: TGLuint) {.importc.} - proc glConvolutionFilter1DEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} - proc glPrimitiveRestartIndex(index: TGLuint) {.importc.} - proc glWindowPos2dv(v: ptr TGLdouble) {.importc.} - proc glBindFramebufferOES(target: TGLenum, framebuffer: TGLuint) {.importc.} - proc glTessellationModeAMD(mode: TGLenum) {.importc.} - proc glIsVariantEnabledEXT(id: TGLuint, cap: TGLenum): TGLboolean {.importc.} - proc glColor3iv(v: ptr TGLint) {.importc.} - proc glFogCoordFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc.} - proc glClearNamedBufferDataEXT(buffer: TGLuint, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, data: ptr pointer) {.importc.} - proc glTextureRangeAPPLE(target: TGLenum, length: TGLsizei, `pointer`: pointer) {.importc.} - proc glTexCoord4bvOES(coords: ptr TGLbyte) {.importc.} - proc glRotated(angle: TGLdouble, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glAccum(op: TGLenum, value: TGLfloat) {.importc.} - proc glVertex3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glGetPathMetricRangeNV(metricQueryMask: TGLbitfield, firstPathName: TGLuint, numPaths: TGLsizei, stride: TGLsizei, metrics: ptr TGLfloat) {.importc.} - proc glUniform4d(location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glTextureSubImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glMultiTexCoord1iv(target: TGLenum, v: ptr TGLint) {.importc.} - proc glFogFuncSGIS(n: TGLsizei, points: ptr TGLfloat) {.importc.} - proc glGetMaterialxOES(face: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glGlobalAlphaFactorbSUN(factor: TGLbyte) {.importc.} - proc glGetProgramLocalParameterdvARB(target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} - proc glDeleteProgramsARB(n: TGLsizei, programs: ptr TGLuint) {.importc.} - proc glVertexStream1sATI(stream: TGLenum, x: TGLshort) {.importc.} - proc glMatrixTranslatedEXT(mode: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glTexSubImage1D(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetBufferSubData(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} - proc glUniform4uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} - proc glGetShaderiv(shader: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetQueryIndexediv(target: TGLenum, index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glDebugMessageInsert(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: ptr TGLchar) {.importc.} - proc glVertexAttribs2dvNV(index: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} - proc glGetFixedvOES(pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glUniform2iv(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glTextureView(texture: TGLuint, target: TGLenum, origtexture: TGLuint, internalformat: TGLenum, minlevel: TGLuint, numlevels: TGLuint, minlayer: TGLuint, numlayers: TGLuint) {.importc.} - proc glMultiTexCoord1xvOES(texture: TGLenum, coords: ptr TGLfixed) {.importc.} - proc glTexBufferRange(target: TGLenum, internalformat: TGLenum, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glMultiTexCoordPointerEXT(texunit: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glBlendColorxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} - proc glReadPixels(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glWindowPos3dARB(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glPixelTexGenParameterivSGIS(pname: TGLenum, params: ptr TGLint) {.importc.} - proc glSecondaryColor3svEXT(v: ptr TGLshort) {.importc.} + proc glFlushMappedBufferRangeAPPLE(target: GLenum, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glVertex4iv(v: ptr GLint) {.importc.} + proc glVertexArrayVertexAttribIFormatEXT(vaobj: GLuint, attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} + proc glDisableIndexedEXT(target: GLenum, index: GLuint) {.importc.} + proc glVertexAttribL1dEXT(index: GLuint, x: GLdouble) {.importc.} + proc glBeginPerfMonitorAMD(monitor: GLuint) {.importc.} + proc glConvolutionFilter1DEXT(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glPrimitiveRestartIndex(index: GLuint) {.importc.} + proc glWindowPos2dv(v: ptr GLdouble) {.importc.} + proc glBindFramebufferOES(target: GLenum, framebuffer: GLuint) {.importc.} + proc glTessellationModeAMD(mode: GLenum) {.importc.} + proc glIsVariantEnabledEXT(id: GLuint, cap: GLenum): TGLboolean {.importc.} + proc glColor3iv(v: ptr GLint) {.importc.} + proc glFogCoordFormatNV(`type`: GLenum, stride: GLsizei) {.importc.} + proc glClearNamedBufferDataEXT(buffer: GLuint, internalformat: GLenum, format: GLenum, `type`: GLenum, data: ptr pointer) {.importc.} + proc glTextureRangeAPPLE(target: GLenum, length: GLsizei, `pointer`: pointer) {.importc.} + proc glTexCoord4bvOES(coords: ptr GLbyte) {.importc.} + proc glRotated(angle: GLdouble, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glAccum(op: GLenum, value: GLfloat) {.importc.} + proc glVertex3d(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glGetPathMetricRangeNV(metricQueryMask: GLbitfield, firstPathName: GLuint, numPaths: GLsizei, stride: GLsizei, metrics: ptr GLfloat) {.importc.} + proc glUniform4d(location: GLint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glTextureSubImage2DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glMultiTexCoord1iv(target: GLenum, v: ptr GLint) {.importc.} + proc glFogFuncSGIS(n: GLsizei, points: ptr GLfloat) {.importc.} + proc glGetMaterialxOES(face: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glGlobalAlphaFactorbSUN(factor: GLbyte) {.importc.} + proc glGetProgramLocalParameterdvARB(target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glDeleteProgramsARB(n: GLsizei, programs: ptr GLuint) {.importc.} + proc glVertexStream1sATI(stream: GLenum, x: GLshort) {.importc.} + proc glMatrixTranslatedEXT(mode: GLenum, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetBufferSubData(target: GLenum, offset: GLintptr, size: GLsizeiptr, data: pointer) {.importc.} + proc glUniform4uiEXT(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} + proc glGetShaderiv(shader: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetQueryIndexediv(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glDebugMessageInsert(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glVertexAttribs2dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glGetFixedvOES(pname: GLenum, params: ptr GLfixed) {.importc.} + proc glUniform2iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glTextureView(texture: GLuint, target: GLenum, origtexture: GLuint, internalformat: GLenum, minlevel: GLuint, numlevels: GLuint, minlayer: GLuint, numlayers: GLuint) {.importc.} + proc glMultiTexCoord1xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} + proc glTexBufferRange(target: GLenum, internalformat: GLenum, buffer: GLuint, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glMultiTexCoordPointerEXT(texunit: GLenum, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glBlendColorxOES(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glReadPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glWindowPos3dARB(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glPixelTexGenParameterivSGIS(pname: GLenum, params: ptr GLint) {.importc.} + proc glSecondaryColor3svEXT(v: ptr GLshort) {.importc.} proc glPopGroupMarkerEXT() {.importc.} - proc glImportSyncEXT(external_sync_type: TGLenum, external_sync: TGLintptr, flags: TGLbitfield): TGLsync {.importc.} - proc glVertexAttribLFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} - proc glVertexAttrib2sNV(index: TGLuint, x: TGLshort, y: TGLshort) {.importc.} - proc glGetIntegeri_v(target: TGLenum, index: TGLuint, data: ptr TGLint) {.importc.} - proc glProgramUniform3uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glGetActiveUniformBlockiv(program: TGLuint, uniformBlockIndex: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glCreateShaderProgramv(`type`: TGLenum, count: TGLsizei, strings: ptr ptr TGLchar): TGLuint {.importc.} - proc glUniform2fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} - proc glVertexStream4ivATI(stream: TGLenum, coords: ptr TGLint) {.importc.} - proc glNormalP3uiv(`type`: TGLenum, coords: ptr TGLuint) {.importc.} - proc glVertexAttribLFormat(attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} - proc glTexCoord2bvOES(coords: ptr TGLbyte) {.importc.} - proc glGetActiveUniformName(program: TGLuint, uniformIndex: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, uniformName: ptr TGLchar) {.importc.} - proc glTexCoord2sv(v: ptr TGLshort) {.importc.} - proc glVertexAttrib2dNV(index: TGLuint, x: TGLdouble, y: TGLdouble) {.importc.} - proc glGetFogFuncSGIS(points: ptr TGLfloat) {.importc.} - proc glSetFenceAPPLE(fence: TGLuint) {.importc.} - proc glRasterPos2f(x: TGLfloat, y: TGLfloat) {.importc.} - proc glVertexWeightPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} + proc glImportSyncEXT(external_sync_type: GLenum, external_sync: GLintptr, flags: GLbitfield): TGLsync {.importc.} + proc glVertexAttribLFormatNV(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glVertexAttrib2sNV(index: GLuint, x: GLshort, y: GLshort) {.importc.} + proc glGetIntegeri_v(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} + proc glProgramUniform3uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glGetActiveUniformBlockiv(program: GLuint, uniformBlockIndex: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glCreateShaderProgramv(`type`: GLenum, count: GLsizei, strings: ptr ptr GLchar): TGLuint {.importc.} + proc glUniform2fARB(location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} + proc glVertexStream4ivATI(stream: GLenum, coords: ptr GLint) {.importc.} + proc glNormalP3uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} + proc glVertexAttribLFormat(attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} + proc glTexCoord2bvOES(coords: ptr GLbyte) {.importc.} + proc glGetActiveUniformName(program: GLuint, uniformIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformName: ptr GLchar) {.importc.} + proc glTexCoord2sv(v: ptr GLshort) {.importc.} + proc glVertexAttrib2dNV(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} + proc glGetFogFuncSGIS(points: ptr GLfloat) {.importc.} + proc glSetFenceAPPLE(fence: GLuint) {.importc.} + proc glRasterPos2f(x: GLfloat, y: GLfloat) {.importc.} + proc glVertexWeightPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glEndList() {.importc.} proc glVDPAUFiniNV() {.importc.} - proc glTbufferMask3DFX(mask: TGLuint) {.importc.} - proc glVertexP4ui(`type`: TGLenum, value: TGLuint) {.importc.} - proc glTexEnviv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glColor4xOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} - proc glBlendEquationi(buf: TGLuint, mode: TGLenum) {.importc.} - proc glLoadMatrixxOES(m: ptr TGLfixed) {.importc.} - proc glFogxOES(pname: TGLenum, param: TGLfixed) {.importc.} - proc glTexCoord4dv(v: ptr TGLdouble) {.importc.} - proc glFogCoordPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} - proc glGetPerfMonitorGroupsAMD(numGroups: ptr TGLint, groupsSize: TGLsizei, groups: ptr TGLuint) {.importc.} - proc glVertex2hNV(x: TGLhalfNV, y: TGLhalfNV) {.importc.} - proc glDeleteFragmentShaderATI(id: TGLuint) {.importc.} - proc glGetSamplerParameterIiv(sampler: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glUniform2fvARB(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glFogf(pname: TGLenum, param: TGLfloat) {.importc.} - proc glMultiTexCoord1iARB(target: TGLenum, s: TGLint) {.importc.} - proc glGetActiveUniformARB(programObj: TGLhandleARB, index: TGLuint, maxLength: TGLsizei, length: ptr TGLsizei, size: ptr TGLint, `type`: ptr TGLenum, name: ptr TGLcharARB) {.importc.} - proc glMapGrid1xOES(n: TGLint, u1: TGLfixed, u2: TGLfixed) {.importc.} - proc glIndexsv(c: ptr TGLshort) {.importc.} - proc glFragmentMaterialfSGIX(face: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glBindTextureEXT(target: TGLenum, texture: TGLuint) {.importc.} - proc glRectiv(v1: ptr TGLint, v2: ptr TGLint) {.importc.} - proc glTangent3dEXT(tx: TGLdouble, ty: TGLdouble, tz: TGLdouble) {.importc.} - proc glProgramUniformMatrix3x4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glNormal3hNV(nx: TGLhalfNV, ny: TGLhalfNV, nz: TGLhalfNV) {.importc.} - proc glPushClientAttribDefaultEXT(mask: TGLbitfield) {.importc.} - proc glUnmapBufferARB(target: TGLenum): TGLboolean {.importc.} - proc glVertexAttribs1dvNV(index: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} - proc glUniformMatrix2x3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glUniform3f(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} - proc glTexEnvxv(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glMapBufferOES(target: TGLenum, access: TGLenum) {.importc.} - proc glBufferData(target: TGLenum, size: TGLsizeiptr, data: pointer, usage: TGLenum) {.importc.} - proc glDrawElementsInstancedANGLE(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei) {.importc.} - proc glGetTextureHandleARB(texture: TGLuint): TGLuint64 {.importc.} - proc glNormal3f(nx: TGLfloat, ny: TGLfloat, nz: TGLfloat) {.importc.} - proc glTexCoordP3uiv(`type`: TGLenum, coords: ptr TGLuint) {.importc.} - proc glTexParameterx(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glMapBufferRange(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc.} - proc glTexCoord2fVertex3fSUN(s: TGLfloat, t: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glVariantArrayObjectATI(id: TGLuint, `type`: TGLenum, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc.} - proc glGetnHistogramARB(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, values: pointer) {.importc.} - proc glWindowPos3sv(v: ptr TGLshort) {.importc.} - proc glGetVariantPointervEXT(id: TGLuint, value: TGLenum, data: ptr pointer) {.importc.} - proc glGetLightfv(light: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glGetnTexImageARB(target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, img: pointer) {.importc.} - proc glGenRenderbuffersEXT(n: TGLsizei, renderbuffers: ptr TGLuint) {.importc.} - proc glMultiDrawArraysIndirectBindlessNV(mode: TGLenum, indirect: pointer, drawCount: TGLsizei, stride: TGLsizei, vertexBufferCount: TGLint) {.importc.} - proc glDisableClientStateIndexedEXT(`array`: TGLenum, index: TGLuint) {.importc.} - proc glMapGrid1f(un: TGLint, u1: TGLfloat, u2: TGLfloat) {.importc.} - proc glTexStorage2D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glShaderStorageBlockBinding(program: TGLuint, storageBlockIndex: TGLuint, storageBlockBinding: TGLuint) {.importc.} + proc glTbufferMask3DFX(mask: GLuint) {.importc.} + proc glVertexP4ui(`type`: GLenum, value: GLuint) {.importc.} + proc glTexEnviv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glColor4xOES(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glBlendEquationi(buf: GLuint, mode: GLenum) {.importc.} + proc glLoadMatrixxOES(m: ptr GLfixed) {.importc.} + proc glFogxOES(pname: GLenum, param: GLfixed) {.importc.} + proc glTexCoord4dv(v: ptr GLdouble) {.importc.} + proc glFogCoordPointerListIBM(`type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glGetPerfMonitorGroupsAMD(numGroups: ptr GLint, groupsSize: GLsizei, groups: ptr GLuint) {.importc.} + proc glVertex2hNV(x: GLhalfNV, y: GLhalfNV) {.importc.} + proc glDeleteFragmentShaderATI(id: GLuint) {.importc.} + proc glGetSamplerParameterIiv(sampler: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glUniform2fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glFogf(pname: GLenum, param: GLfloat) {.importc.} + proc glMultiTexCoord1iARB(target: GLenum, s: GLint) {.importc.} + proc glGetActiveUniformARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLcharARB) {.importc.} + proc glMapGrid1xOES(n: GLint, u1: GLfixed, u2: GLfixed) {.importc.} + proc glIndexsv(c: ptr GLshort) {.importc.} + proc glFragmentMaterialfSGIX(face: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glBindTextureEXT(target: GLenum, texture: GLuint) {.importc.} + proc glRectiv(v1: ptr GLint, v2: ptr GLint) {.importc.} + proc glTangent3dEXT(tx: GLdouble, ty: GLdouble, tz: GLdouble) {.importc.} + proc glProgramUniformMatrix3x4fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glNormal3hNV(nx: GLhalfNV, ny: GLhalfNV, nz: GLhalfNV) {.importc.} + proc glPushClientAttribDefaultEXT(mask: GLbitfield) {.importc.} + proc glUnmapBufferARB(target: GLenum): TGLboolean {.importc.} + proc glVertexAttribs1dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glUniformMatrix2x3dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glUniform3f(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} + proc glTexEnvxv(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glMapBufferOES(target: GLenum, access: GLenum) {.importc.} + proc glBufferData(target: GLenum, size: GLsizeiptr, data: pointer, usage: GLenum) {.importc.} + proc glDrawElementsInstancedANGLE(mode: GLenum, count: GLsizei, `type`: GLenum, indices: ptr pointer, primcount: GLsizei) {.importc.} + proc glGetTextureHandleARB(texture: GLuint): TGLuint64 {.importc.} + proc glNormal3f(nx: GLfloat, ny: GLfloat, nz: GLfloat) {.importc.} + proc glTexCoordP3uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} + proc glTexParameterx(target: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glMapBufferRange(target: GLenum, offset: GLintptr, length: GLsizeiptr, access: GLbitfield) {.importc.} + proc glTexCoord2fVertex3fSUN(s: GLfloat, t: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVariantArrayObjectATI(id: GLuint, `type`: GLenum, stride: GLsizei, buffer: GLuint, offset: GLuint) {.importc.} + proc glGetnHistogramARB(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, bufSize: GLsizei, values: pointer) {.importc.} + proc glWindowPos3sv(v: ptr GLshort) {.importc.} + proc glGetVariantPointervEXT(id: GLuint, value: GLenum, data: ptr pointer) {.importc.} + proc glGetLightfv(light: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetnTexImageARB(target: GLenum, level: GLint, format: GLenum, `type`: GLenum, bufSize: GLsizei, img: pointer) {.importc.} + proc glGenRenderbuffersEXT(n: GLsizei, renderbuffers: ptr GLuint) {.importc.} + proc glMultiDrawArraysIndirectBindlessNV(mode: GLenum, indirect: pointer, drawCount: GLsizei, stride: GLsizei, vertexBufferCount: GLint) {.importc.} + proc glDisableClientStateIndexedEXT(`array`: GLenum, index: GLuint) {.importc.} + proc glMapGrid1f(un: GLint, u1: GLfloat, u2: GLfloat) {.importc.} + proc glTexStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glShaderStorageBlockBinding(program: GLuint, storageBlockIndex: GLuint, storageBlockBinding: GLuint) {.importc.} proc glBlendBarrierNV() {.importc.} - proc glGetVideoui64vNV(video_slot: TGLuint, pname: TGLenum, params: ptr TGLuint64EXT) {.importc.} - proc glUniform3ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc.} - proc glUniform4ivARB(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glGetQueryObjectivARB(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glCompressedTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} - proc glEnableIndexedEXT(target: TGLenum, index: TGLuint) {.importc.} - proc glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: TGLuint, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glVertexAttribI3iEXT(index: TGLuint, x: TGLint, y: TGLint, z: TGLint) {.importc.} - proc glUniform4uivEXT(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glGetUniformLocation(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} - proc glCurrentPaletteMatrixARB(index: TGLint) {.importc.} - proc glVertexAttribLPointerEXT(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glFogCoorddvEXT(coord: ptr TGLdouble) {.importc.} + proc glGetVideoui64vNV(video_slot: GLuint, pname: GLenum, params: ptr GLuint64EXT) {.importc.} + proc glUniform3ui64NV(location: GLint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT) {.importc.} + proc glUniform4ivARB(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glGetQueryObjectivARB(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glCompressedTexSubImage3DOES(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glEnableIndexedEXT(target: GLenum, index: GLuint) {.importc.} + proc glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: GLuint, coverageSamples: GLsizei, colorSamples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glVertexAttribI3iEXT(index: GLuint, x: GLint, y: GLint, z: GLint) {.importc.} + proc glUniform4uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glGetUniformLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glCurrentPaletteMatrixARB(index: GLint) {.importc.} + proc glVertexAttribLPointerEXT(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glFogCoorddvEXT(coord: ptr GLdouble) {.importc.} proc glInitNames() {.importc.} - proc glGetPathSpacingNV(pathListMode: TGLenum, numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, advanceScale: TGLfloat, kerningScale: TGLfloat, transformType: TGLenum, returnedSpacing: ptr TGLfloat) {.importc.} - proc glNormal3fVertex3fvSUN(n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glTexCoord2iv(v: ptr TGLint) {.importc.} - proc glWindowPos3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glProgramUniformMatrix3x4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glVertexAttribP4ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} - proc glVertexAttribs4ubvNV(index: TGLuint, count: TGLsizei, v: ptr TGLubyte) {.importc.} - proc glProgramLocalParameterI4iNV(target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} - proc glStencilMaskSeparate(face: TGLenum, mask: TGLuint) {.importc.} - proc glClientWaitSync(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64): TGLenum {.importc.} - proc glPolygonOffsetx(factor: TGLfixed, units: TGLfixed) {.importc.} + proc glGetPathSpacingNV(pathListMode: GLenum, numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, advanceScale: GLfloat, kerningScale: GLfloat, transformType: GLenum, returnedSpacing: ptr GLfloat) {.importc.} + proc glNormal3fVertex3fvSUN(n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glTexCoord2iv(v: ptr GLint) {.importc.} + proc glWindowPos3s(x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glProgramUniformMatrix3x4fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glVertexAttribP4ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} + proc glVertexAttribs4ubvNV(index: GLuint, count: GLsizei, v: ptr GLubyte) {.importc.} + proc glProgramLocalParameterI4iNV(target: GLenum, index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glStencilMaskSeparate(face: GLenum, mask: GLuint) {.importc.} + proc glClientWaitSync(sync: GLsync, flags: GLbitfield, timeout: GLuint64): TGLenum {.importc.} + proc glPolygonOffsetx(factor: GLfixed, units: GLfixed) {.importc.} proc glCreateProgramObjectARB(): TGLhandleARB {.importc.} - proc glClearColorIuiEXT(red: TGLuint, green: TGLuint, blue: TGLuint, alpha: TGLuint) {.importc.} - proc glDeleteTransformFeedbacksNV(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glFramebufferDrawBuffersEXT(framebuffer: TGLuint, n: TGLsizei, bufs: ptr TGLenum) {.importc.} - proc glAreTexturesResident(n: TGLsizei, textures: ptr TGLuint, residences: ptr TGLboolean): TGLboolean {.importc.} - proc glNamedBufferDataEXT(buffer: TGLuint, size: TGLsizeiptr, data: pointer, usage: TGLenum) {.importc.} - proc glGetInvariantFloatvEXT(id: TGLuint, value: TGLenum, data: ptr TGLfloat) {.importc.} - proc glMultiTexCoord4d(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc.} - proc glGetPixelTransformParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glGetStringi(name: TGLenum, index: TGLuint): TGLubyte {.importc.} - proc glMakeBufferNonResidentNV(target: TGLenum) {.importc.} - proc glVertex4bOES(x: TGLbyte, y: TGLbyte, z: TGLbyte) {.importc.} - proc glGetObjectLabel(identifier: TGLenum, name: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, label: ptr TGLchar) {.importc.} - proc glClipPlanexOES(plane: TGLenum, equation: ptr TGLfixed) {.importc.} - proc glElementPointerAPPLE(`type`: TGLenum, `pointer`: pointer) {.importc.} - proc glIsAsyncMarkerSGIX(marker: TGLuint): TGLboolean {.importc.} - proc glUseShaderProgramEXT(`type`: TGLenum, program: TGLuint) {.importc.} - proc glReplacementCodeuiColor4ubVertex3fSUN(rc: TGLuint, r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glIsTransformFeedback(id: TGLuint): TGLboolean {.importc.} - proc glEdgeFlag(flag: TGLboolean) {.importc.} - proc glGetTexGeniv(coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glBeginQueryEXT(target: TGLenum, id: TGLuint) {.importc.} - proc glUniform1uiEXT(location: TGLint, v0: TGLuint) {.importc.} - proc glProgramUniform3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glGetVideoi64vNV(video_slot: TGLuint, pname: TGLenum, params: ptr TGLint64EXT) {.importc.} - proc glProgramUniform3ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} - proc glSecondaryColor3uiEXT(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc.} - proc glPathStencilFuncNV(func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} - proc glVertexAttribP1ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} - proc glStencilFillPathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, fillMode: TGLenum, mask: TGLuint, transformType: TGLenum, transformValues: ptr TGLfloat) {.importc.} - proc glFogCoordfEXT(coord: TGLfloat) {.importc.} - proc glTextureParameterIuivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glProgramUniform4dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glFramebufferTextureFaceARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc.} - proc glTexCoord3s(s: TGLshort, t: TGLshort, r: TGLshort) {.importc.} - proc glGetFramebufferAttachmentParameteriv(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glEndVideoCaptureNV(video_capture_slot: TGLuint) {.importc.} - proc glProgramUniformMatrix2x4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glGetFloatIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr TGLfloat) {.importc.} - proc glTexCoord1xOES(s: TGLfixed) {.importc.} - proc glTexCoord4f(s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc.} - proc glShaderSource(shader: TGLuint, count: TGLsizei, string: ptr ptr TGLchar, length: ptr TGLint) {.importc.} - proc glGetDetailTexFuncSGIS(target: TGLenum, points: ptr TGLfloat) {.importc.} - proc glResetHistogram(target: TGLenum) {.importc.} - proc glVertexAttribP2ui(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: TGLuint) {.importc.} - proc glDrawTransformFeedbackNV(mode: TGLenum, id: TGLuint) {.importc.} - proc glWindowPos2fMESA(x: TGLfloat, y: TGLfloat) {.importc.} - proc glObjectLabelKHR(identifier: TGLenum, name: TGLuint, length: TGLsizei, label: ptr TGLchar) {.importc.} - proc glMultiTexCoord2iARB(target: TGLenum, s: TGLint, t: TGLint) {.importc.} - proc glVertexAttrib4usv(index: TGLuint, v: ptr TGLushort) {.importc.} + proc glClearColorIuiEXT(red: GLuint, green: GLuint, blue: GLuint, alpha: GLuint) {.importc.} + proc glDeleteTransformFeedbacksNV(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glFramebufferDrawBuffersEXT(framebuffer: GLuint, n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glAreTexturesResident(n: GLsizei, textures: ptr GLuint, residences: ptr GLboolean): TGLboolean {.importc.} + proc glNamedBufferDataEXT(buffer: GLuint, size: GLsizeiptr, data: pointer, usage: GLenum) {.importc.} + proc glGetInvariantFloatvEXT(id: GLuint, value: GLenum, data: ptr GLfloat) {.importc.} + proc glMultiTexCoord4d(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble, q: GLdouble) {.importc.} + proc glGetPixelTransformParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetStringi(name: GLenum, index: GLuint): TGLubyte {.importc.} + proc glMakeBufferNonResidentNV(target: GLenum) {.importc.} + proc glVertex4bOES(x: GLbyte, y: GLbyte, z: GLbyte) {.importc.} + proc glGetObjectLabel(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glClipPlanexOES(plane: GLenum, equation: ptr GLfixed) {.importc.} + proc glElementPointerAPPLE(`type`: GLenum, `pointer`: pointer) {.importc.} + proc glIsAsyncMarkerSGIX(marker: GLuint): TGLboolean {.importc.} + proc glUseShaderProgramEXT(`type`: GLenum, program: GLuint) {.importc.} + proc glReplacementCodeuiColor4ubVertex3fSUN(rc: GLuint, r: GLubyte, g: GLubyte, b: GLubyte, a: GLubyte, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glIsTransformFeedback(id: GLuint): TGLboolean {.importc.} + proc glEdgeFlag(flag: GLboolean) {.importc.} + proc glGetTexGeniv(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glBeginQueryEXT(target: GLenum, id: GLuint) {.importc.} + proc glUniform1uiEXT(location: GLint, v0: GLuint) {.importc.} + proc glProgramUniform3fvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetVideoi64vNV(video_slot: GLuint, pname: GLenum, params: ptr GLint64EXT) {.importc.} + proc glProgramUniform3ui(program: GLuint, location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} + proc glSecondaryColor3uiEXT(red: GLuint, green: GLuint, blue: GLuint) {.importc.} + proc glPathStencilFuncNV(func: GLenum, `ref`: GLint, mask: GLuint) {.importc.} + proc glVertexAttribP1ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} + proc glStencilFillPathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, fillMode: GLenum, mask: GLuint, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} + proc glFogCoordfEXT(coord: GLfloat) {.importc.} + proc glTextureParameterIuivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glProgramUniform4dEXT(program: GLuint, location: GLint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glFramebufferTextureFaceARB(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint, face: GLenum) {.importc.} + proc glTexCoord3s(s: GLshort, t: GLshort, r: GLshort) {.importc.} + proc glGetFramebufferAttachmentParameteriv(target: GLenum, attachment: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glEndVideoCaptureNV(video_capture_slot: GLuint) {.importc.} + proc glProgramUniformMatrix2x4dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glGetFloatIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLfloat) {.importc.} + proc glTexCoord1xOES(s: GLfixed) {.importc.} + proc glTexCoord4f(s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} + proc glShaderSource(shader: GLuint, count: GLsizei, string: ptr ptr GLchar, length: ptr GLint) {.importc.} + proc glGetDetailTexFuncSGIS(target: GLenum, points: ptr GLfloat) {.importc.} + proc glResetHistogram(target: GLenum) {.importc.} + proc glVertexAttribP2ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} + proc glDrawTransformFeedbackNV(mode: GLenum, id: GLuint) {.importc.} + proc glWindowPos2fMESA(x: GLfloat, y: GLfloat) {.importc.} + proc glObjectLabelKHR(identifier: GLenum, name: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} + proc glMultiTexCoord2iARB(target: GLenum, s: GLint, t: GLint) {.importc.} + proc glVertexAttrib4usv(index: GLuint, v: ptr GLushort) {.importc.} proc glGetGraphicsResetStatusARB(): TGLenum {.importc.} - proc glProgramUniform3dEXT(program: TGLuint, location: TGLint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glPathSubCommandsNV(path: TGLuint, commandStart: TGLsizei, commandsToDelete: TGLsizei, numCommands: TGLsizei, commands: ptr TGLubyte, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} + proc glProgramUniform3dEXT(program: GLuint, location: GLint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glPathSubCommandsNV(path: GLuint, commandStart: GLsizei, commandsToDelete: GLsizei, numCommands: GLsizei, commands: ptr GLubyte, numCoords: GLsizei, coordType: GLenum, coords: pointer) {.importc.} proc glEndTransformFeedbackNV() {.importc.} - proc glWindowPos2sMESA(x: TGLshort, y: TGLshort) {.importc.} - proc glTangent3sEXT(tx: TGLshort, ty: TGLshort, tz: TGLshort) {.importc.} - proc glLineWidthx(width: TGLfixed) {.importc.} - proc glGetUniformBufferSizeEXT(program: TGLuint, location: TGLint): TGLint {.importc.} - proc glTexCoord2bOES(s: TGLbyte, t: TGLbyte) {.importc.} - proc glWindowPos3iMESA(x: TGLint, y: TGLint, z: TGLint) {.importc.} - proc glTexGend(coord: TGLenum, pname: TGLenum, param: TGLdouble) {.importc.} - proc glRenderbufferStorageMultisampleANGLE(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glGetProgramiv(program: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glDrawTransformFeedbackStreamInstanced(mode: TGLenum, id: TGLuint, stream: TGLuint, instancecount: TGLsizei) {.importc.} - proc glMatrixTranslatefEXT(mode: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glColor4iv(v: ptr TGLint) {.importc.} - proc glSecondaryColor3ivEXT(v: ptr TGLint) {.importc.} - proc glIsNamedStringARB(namelen: TGLint, name: ptr TGLchar): TGLboolean {.importc.} - proc glVertexAttribL4dv(index: TGLuint, v: ptr TGLdouble) {.importc.} + proc glWindowPos2sMESA(x: GLshort, y: GLshort) {.importc.} + proc glTangent3sEXT(tx: GLshort, ty: GLshort, tz: GLshort) {.importc.} + proc glLineWidthx(width: GLfixed) {.importc.} + proc glGetUniformBufferSizeEXT(program: GLuint, location: GLint): TGLint {.importc.} + proc glTexCoord2bOES(s: GLbyte, t: GLbyte) {.importc.} + proc glWindowPos3iMESA(x: GLint, y: GLint, z: GLint) {.importc.} + proc glTexGend(coord: GLenum, pname: GLenum, param: GLdouble) {.importc.} + proc glRenderbufferStorageMultisampleANGLE(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glGetProgramiv(program: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glDrawTransformFeedbackStreamInstanced(mode: GLenum, id: GLuint, stream: GLuint, instancecount: GLsizei) {.importc.} + proc glMatrixTranslatefEXT(mode: GLenum, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glColor4iv(v: ptr GLint) {.importc.} + proc glSecondaryColor3ivEXT(v: ptr GLint) {.importc.} + proc glIsNamedStringARB(namelen: GLint, name: ptr GLchar): TGLboolean {.importc.} + proc glVertexAttribL4dv(index: GLuint, v: ptr GLdouble) {.importc.} proc glEndTransformFeedback() {.importc.} - proc glVertexStream3fvATI(stream: TGLenum, coords: ptr TGLfloat) {.importc.} - proc glProgramUniformMatrix4x2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glTextureBufferRangeEXT(texture: TGLuint, target: TGLenum, internalformat: TGLenum, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glTexCoord2fNormal3fVertex3fvSUN(tc: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glProgramUniform2f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat) {.importc.} - proc glMultiTexCoord2sv(target: TGLenum, v: ptr TGLshort) {.importc.} - proc glTexCoord3bOES(s: TGLbyte, t: TGLbyte, r: TGLbyte) {.importc.} - proc glGenFramebuffersOES(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} - proc glMultiTexCoord3sv(target: TGLenum, v: ptr TGLshort) {.importc.} - proc glVertexAttrib4Nub(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc.} - proc glColor3d(red: TGLdouble, green: TGLdouble, blue: TGLdouble) {.importc.} - proc glGetActiveAttrib(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, size: ptr TGLint, `type`: ptr TGLenum, name: ptr TGLchar) {.importc.} - proc glConvolutionParameterfEXT(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glTexSubImage2DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glBinormal3fvEXT(v: ptr TGLfloat) {.importc.} - proc glDebugMessageControl(source: TGLenum, `type`: TGLenum, severity: TGLenum, count: TGLsizei, ids: ptr TGLuint, enabled: TGLboolean) {.importc.} - proc glProgramUniform3uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glPNTrianglesiATI(pname: TGLenum, param: TGLint) {.importc.} - proc glGetPerfMonitorCounterInfoAMD(group: TGLuint, counter: TGLuint, pname: TGLenum, data: pointer) {.importc.} - proc glVertexAttribL3ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT) {.importc.} - proc glIsRenderbufferOES(renderbuffer: TGLuint): TGLboolean {.importc.} - proc glColorSubTable(target: TGLenum, start: TGLsizei, count: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} - proc glCompressedMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glBindSampler(unit: TGLuint, sampler: TGLuint) {.importc.} - proc glVariantubvEXT(id: TGLuint, `addr`: ptr TGLubyte) {.importc.} - proc glDisablei(target: TGLenum, index: TGLuint) {.importc.} - proc glVertexAttribI2uiEXT(index: TGLuint, x: TGLuint, y: TGLuint) {.importc.} - proc glDrawElementArrayATI(mode: TGLenum, count: TGLsizei) {.importc.} + proc glVertexStream3fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} + proc glProgramUniformMatrix4x2dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glTextureBufferRangeEXT(texture: GLuint, target: GLenum, internalformat: GLenum, buffer: GLuint, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glTexCoord2fNormal3fVertex3fvSUN(tc: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glProgramUniform2f(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} + proc glMultiTexCoord2sv(target: GLenum, v: ptr GLshort) {.importc.} + proc glTexCoord3bOES(s: GLbyte, t: GLbyte, r: GLbyte) {.importc.} + proc glGenFramebuffersOES(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glMultiTexCoord3sv(target: GLenum, v: ptr GLshort) {.importc.} + proc glVertexAttrib4Nub(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, w: GLubyte) {.importc.} + proc glColor3d(red: GLdouble, green: GLdouble, blue: GLdouble) {.importc.} + proc glGetActiveAttrib(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glConvolutionParameterfEXT(target: GLenum, pname: GLenum, params: GLfloat) {.importc.} + proc glTexSubImage2DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glBinormal3fvEXT(v: ptr GLfloat) {.importc.} + proc glDebugMessageControl(source: GLenum, `type`: GLenum, severity: GLenum, count: GLsizei, ids: ptr GLuint, enabled: GLboolean) {.importc.} + proc glProgramUniform3uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glPNTrianglesiATI(pname: GLenum, param: GLint) {.importc.} + proc glGetPerfMonitorCounterInfoAMD(group: GLuint, counter: GLuint, pname: GLenum, data: pointer) {.importc.} + proc glVertexAttribL3ui64NV(index: GLuint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT) {.importc.} + proc glIsRenderbufferOES(renderbuffer: GLuint): TGLboolean {.importc.} + proc glColorSubTable(target: GLenum, start: GLsizei, count: GLsizei, format: GLenum, `type`: GLenum, data: pointer) {.importc.} + proc glCompressedMultiTexImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glBindSampler(unit: GLuint, sampler: GLuint) {.importc.} + proc glVariantubvEXT(id: GLuint, `addr`: ptr GLubyte) {.importc.} + proc glDisablei(target: GLenum, index: GLuint) {.importc.} + proc glVertexAttribI2uiEXT(index: GLuint, x: GLuint, y: GLuint) {.importc.} + proc glDrawElementArrayATI(mode: GLenum, count: GLsizei) {.importc.} proc glTagSampleBufferSGIX() {.importc.} - proc glVertexPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} - proc glFragmentLightiSGIX(light: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glLoadTransposeMatrixxOES(m: ptr TGLfixed) {.importc.} - proc glProgramLocalParameter4fvARB(target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} - proc glGetVariantFloatvEXT(id: TGLuint, value: TGLenum, data: ptr TGLfloat) {.importc.} - proc glProgramUniform4ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} - proc glFragmentLightfSGIX(light: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glIsVertexArrayAPPLE(`array`: TGLuint): TGLboolean {.importc.} - proc glTexCoord1bvOES(coords: ptr TGLbyte) {.importc.} - proc glUniform4fv(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glPixelDataRangeNV(target: TGLenum, length: TGLsizei, `pointer`: pointer) {.importc.} - proc glUniformMatrix4x2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glRectf(x1: TGLfloat, y1: TGLfloat, x2: TGLfloat, y2: TGLfloat) {.importc.} - proc glCoverageMaskNV(mask: TGLboolean) {.importc.} - proc glPointParameterfvSGIS(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glProgramUniformMatrix4x2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glFragmentLightModelfSGIX(pname: TGLenum, param: TGLfloat) {.importc.} - proc glDisableVertexAttribAPPLE(index: TGLuint, pname: TGLenum) {.importc.} - proc glMultiTexCoord3dvARB(target: TGLenum, v: ptr TGLdouble) {.importc.} - proc glTexCoord4iv(v: ptr TGLint) {.importc.} - proc glUniform1f(location: TGLint, v0: TGLfloat) {.importc.} - proc glVertexAttribParameteriAMD(index: TGLuint, pname: TGLenum, param: TGLint) {.importc.} - proc glGetConvolutionParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glRecti(x1: TGLint, y1: TGLint, x2: TGLint, y2: TGLint) {.importc.} - proc glTexEnvxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glGetRenderbufferParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glBlendFuncIndexedAMD(buf: TGLuint, src: TGLenum, dst: TGLenum) {.importc.} - proc glProgramUniformMatrix3x2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glDrawArraysInstancedANGLE(mode: TGLenum, first: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} + proc glVertexPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, count: GLsizei, `pointer`: pointer) {.importc.} + proc glFragmentLightiSGIX(light: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glLoadTransposeMatrixxOES(m: ptr GLfixed) {.importc.} + proc glProgramLocalParameter4fvARB(target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glGetVariantFloatvEXT(id: GLuint, value: GLenum, data: ptr GLfloat) {.importc.} + proc glProgramUniform4ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} + proc glFragmentLightfSGIX(light: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glIsVertexArrayAPPLE(`array`: GLuint): TGLboolean {.importc.} + proc glTexCoord1bvOES(coords: ptr GLbyte) {.importc.} + proc glUniform4fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glPixelDataRangeNV(target: GLenum, length: GLsizei, `pointer`: pointer) {.importc.} + proc glUniformMatrix4x2fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glRectf(x1: GLfloat, y1: GLfloat, x2: GLfloat, y2: GLfloat) {.importc.} + proc glCoverageMaskNV(mask: GLboolean) {.importc.} + proc glPointParameterfvSGIS(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glProgramUniformMatrix4x2dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glFragmentLightModelfSGIX(pname: GLenum, param: GLfloat) {.importc.} + proc glDisableVertexAttribAPPLE(index: GLuint, pname: GLenum) {.importc.} + proc glMultiTexCoord3dvARB(target: GLenum, v: ptr GLdouble) {.importc.} + proc glTexCoord4iv(v: ptr GLint) {.importc.} + proc glUniform1f(location: GLint, v0: GLfloat) {.importc.} + proc glVertexAttribParameteriAMD(index: GLuint, pname: GLenum, param: GLint) {.importc.} + proc glGetConvolutionParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glRecti(x1: GLint, y1: GLint, x2: GLint, y2: GLint) {.importc.} + proc glTexEnvxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glGetRenderbufferParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glBlendFuncIndexedAMD(buf: GLuint, src: GLenum, dst: GLenum) {.importc.} + proc glProgramUniformMatrix3x2fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glDrawArraysInstancedANGLE(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei) {.importc.} proc glTextureBarrierNV() {.importc.} - proc glDrawBuffersIndexedEXT(n: TGLint, location: ptr TGLenum, indices: ptr TGLint) {.importc.} - proc glUniformMatrix4fvARB(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glInstrumentsBufferSGIX(size: TGLsizei, buffer: ptr TGLint) {.importc.} - proc glAlphaFuncQCOM(func: TGLenum, `ref`: TGLclampf) {.importc.} - proc glUniformMatrix4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glGetMinmaxParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetInvariantBooleanvEXT(id: TGLuint, value: TGLenum, data: ptr TGLboolean) {.importc.} - proc glVDPAUIsSurfaceNV(surface: TGLvdpauSurfaceNV) {.importc.} - proc glGenProgramsARB(n: TGLsizei, programs: ptr TGLuint) {.importc.} - proc glDrawRangeElementArrayATI(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei) {.importc.} - proc glFramebufferRenderbufferEXT(target: TGLenum, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glClearIndex(c: TGLfloat) {.importc.} - proc glDepthRangeIndexed(index: TGLuint, n: TGLdouble, f: TGLdouble) {.importc.} - proc glDrawTexivOES(coords: ptr TGLint) {.importc.} - proc glTangent3iEXT(tx: TGLint, ty: TGLint, tz: TGLint) {.importc.} - proc glStringMarkerGREMEDY(len: TGLsizei, string: pointer) {.importc.} - proc glTexCoordP1ui(`type`: TGLenum, coords: TGLuint) {.importc.} - proc glOrthox(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} - proc glReplacementCodeuiVertex3fvSUN(rc: ptr TGLuint, v: ptr TGLfloat) {.importc.} - proc glMultiTexCoord1bvOES(texture: TGLenum, coords: ptr TGLbyte) {.importc.} - proc glDrawArraysInstancedBaseInstance(mode: TGLenum, first: TGLint, count: TGLsizei, instancecount: TGLsizei, baseinstance: TGLuint) {.importc.} - proc glMultMatrixf(m: ptr TGLfloat) {.importc.} - proc glProgramUniform4i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} - proc glScissorArrayv(first: TGLuint, count: TGLsizei, v: ptr TGLint) {.importc.} - proc glGetnUniformivEXT(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLint) {.importc.} - proc glGetTexEnvxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glWindowPos3ivARB(v: ptr TGLint) {.importc.} - proc glProgramStringARB(target: TGLenum, format: TGLenum, len: TGLsizei, string: pointer) {.importc.} - proc glTextureColorMaskSGIS(red: TGLboolean, green: TGLboolean, blue: TGLboolean, alpha: TGLboolean) {.importc.} - proc glMultiTexCoord4fv(target: TGLenum, v: ptr TGLfloat) {.importc.} - proc glUniformMatrix4x3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glIsPathNV(path: TGLuint): TGLboolean {.importc.} - proc glStartTilingQCOM(x: TGLuint, y: TGLuint, width: TGLuint, height: TGLuint, preserveMask: TGLbitfield) {.importc.} - proc glVariantivEXT(id: TGLuint, `addr`: ptr TGLint) {.importc.} - proc glGetnMinmaxARB(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, values: pointer) {.importc.} - proc glTransformFeedbackVaryings(program: TGLuint, count: TGLsizei, varyings: ptr ptr TGLchar, bufferMode: TGLenum) {.importc.} - proc glShaderOp2EXT(op: TGLenum, res: TGLuint, arg1: TGLuint, arg2: TGLuint) {.importc.} - proc glVertexAttribPointer(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glMultiTexCoord4dvARB(target: TGLenum, v: ptr TGLdouble) {.importc.} - proc glProgramUniform1ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT) {.importc.} - proc glGetShaderSourceARB(obj: TGLhandleARB, maxLength: TGLsizei, length: ptr TGLsizei, source: ptr TGLcharARB) {.importc.} - proc glGetBufferSubDataARB(target: TGLenum, offset: TGLintptrARB, size: TGLsizeiptrARB, data: pointer) {.importc.} - proc glCopyTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glProgramEnvParameterI4iNV(target: TGLenum, index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} - proc glGetVertexAttribivARB(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetFinalCombinerInputParameterivNV(variable: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glIndexFuncEXT(func: TGLenum, `ref`: TGLclampf) {.importc.} - proc glProgramUniformMatrix3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glTexStorage1DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc.} - proc glUniformMatrix2fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glConvolutionParameterf(target: TGLenum, pname: TGLenum, params: TGLfloat) {.importc.} - proc glGlobalAlphaFactordSUN(factor: TGLdouble) {.importc.} - proc glCopyTextureImage2DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} - proc glVertex4xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glClearDepthx(depth: TGLfixed) {.importc.} - proc glGetColorTableParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGenProgramPipelines(n: TGLsizei, pipelines: ptr TGLuint) {.importc.} - proc glVertexAttribL4ui64vNV(index: TGLuint, v: ptr TGLuint64EXT) {.importc.} - proc glUniform1fARB(location: TGLint, v0: TGLfloat) {.importc.} - proc glUniformMatrix3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glUniform3dv(location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glVertexAttribI4iv(index: TGLuint, v: ptr TGLint) {.importc.} - proc glPixelZoom(xfactor: TGLfloat, yfactor: TGLfloat) {.importc.} - proc glShadeModel(mode: TGLenum) {.importc.} - proc glFramebufferTexture3DOES(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} - proc glMultiTexCoord2i(target: TGLenum, s: TGLint, t: TGLint) {.importc.} - proc glBlendEquationSeparateIndexedAMD(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} - proc glIsEnabled(cap: TGLenum): TGLboolean {.importc.} - proc glTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glPolygonOffsetxOES(factor: TGLfixed, units: TGLfixed) {.importc.} - proc glDrawBuffersEXT(n: TGLsizei, bufs: ptr TGLenum) {.importc.} - proc glPixelTexGenParameterfSGIS(pname: TGLenum, param: TGLfloat) {.importc.} - proc glExtGetRenderbuffersQCOM(renderbuffers: ptr TGLuint, maxRenderbuffers: TGLint, numRenderbuffers: ptr TGLint) {.importc.} - proc glBindImageTextures(first: TGLuint, count: TGLsizei, textures: ptr TGLuint) {.importc.} - proc glVertexAttribP2uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: ptr TGLuint) {.importc.} - proc glTextureImage3DMultisampleCoverageNV(texture: TGLuint, target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} - proc glRasterPos2s(x: TGLshort, y: TGLshort) {.importc.} - proc glVertexAttrib4dvARB(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glProgramUniformMatrix2x3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glProgramUniformMatrix2x4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glMultiTexCoord1d(target: TGLenum, s: TGLdouble) {.importc.} - proc glGetProgramParameterdvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glPNTrianglesfATI(pname: TGLenum, param: TGLfloat) {.importc.} - proc glUniformMatrix3x4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glVertexAttrib3sNV(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glGetVideoCaptureStreamfvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glCombinerParameterivNV(pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetTexGenfvOES(coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glCopyTexSubImage2DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glGetProgramLocalParameterfvARB(target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} - proc glTexCoord3iv(v: ptr TGLint) {.importc.} - proc glVertexAttribs2hvNV(index: TGLuint, n: TGLsizei, v: ptr TGLhalfNV) {.importc.} - proc glNormal3sv(v: ptr TGLshort) {.importc.} - proc glUniform2dv(location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glSecondaryColor3hvNV(v: ptr TGLhalfNV) {.importc.} - proc glDrawArraysInstancedEXT(mode: TGLenum, start: TGLint, count: TGLsizei, primcount: TGLsizei) {.importc.} - proc glBeginTransformFeedback(primitiveMode: TGLenum) {.importc.} - proc glTexParameterIuivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glProgramBufferParametersfvNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: ptr TGLfloat) {.importc.} - proc glVertexArrayBindVertexBufferEXT(vaobj: TGLuint, bindingindex: TGLuint, buffer: TGLuint, offset: TGLintptr, stride: TGLsizei) {.importc.} - proc glPathParameterfNV(path: TGLuint, pname: TGLenum, value: TGLfloat) {.importc.} - proc glGetClipPlanexOES(plane: TGLenum, equation: ptr TGLfixed) {.importc.} - proc glSecondaryColor3ubvEXT(v: ptr TGLubyte) {.importc.} - proc glGetPixelMapxv(map: TGLenum, size: TGLint, values: ptr TGLfixed) {.importc.} - proc glVertexAttribI1uivEXT(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glMultiTexImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glAlphaFuncxOES(func: TGLenum, `ref`: TGLfixed) {.importc.} - proc glMultiTexCoord2dv(target: TGLenum, v: ptr TGLdouble) {.importc.} - proc glBindRenderbufferOES(target: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glPathStencilDepthOffsetNV(factor: TGLfloat, units: TGLfloat) {.importc.} - proc glPointParameterfvEXT(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glSampleCoverageARB(value: TGLfloat, invert: TGLboolean) {.importc.} - proc glVertexAttrib3dNV(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glNamedProgramLocalParameter4dvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} - proc glGenFramebuffers(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} - proc glMultiDrawElementsEXT(mode: TGLenum, count: ptr TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei) {.importc.} - proc glVertexAttrib2fNV(index: TGLuint, x: TGLfloat, y: TGLfloat) {.importc.} - proc glProgramUniform4ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glTexGeniOES(coord: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glBindProgramPipeline(pipeline: TGLuint) {.importc.} - proc glBindSamplers(first: TGLuint, count: TGLsizei, samplers: ptr TGLuint) {.importc.} - proc glColorTableSGI(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} - proc glMultiTexCoord3xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed) {.importc.} - proc glIsQueryEXT(id: TGLuint): TGLboolean {.importc.} - proc glGenBuffersARB(n: TGLsizei, buffers: ptr TGLuint) {.importc.} - proc glVertex4xvOES(coords: ptr TGLfixed) {.importc.} - proc glPixelMapuiv(map: TGLenum, mapsize: TGLsizei, values: ptr TGLuint) {.importc.} - proc glDrawTexfOES(x: TGLfloat, y: TGLfloat, z: TGLfloat, width: TGLfloat, height: TGLfloat) {.importc.} - proc glPointParameterfEXT(pname: TGLenum, param: TGLfloat) {.importc.} - proc glPathDashArrayNV(path: TGLuint, dashCount: TGLsizei, dashArray: ptr TGLfloat) {.importc.} - proc glClearTexImage(texture: TGLuint, level: TGLint, format: TGLenum, `type`: TGLenum, data: ptr pointer) {.importc.} - proc glIndexdv(c: ptr TGLdouble) {.importc.} - proc glMultTransposeMatrixfARB(m: ptr TGLfloat) {.importc.} - proc glVertexAttribL3d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glUniform3fv(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glGetProgramInterfaceiv(program: TGLuint, programInterface: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glFogCoordfv(coord: ptr TGLfloat) {.importc.} - proc glTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetPolygonStipple(mask: ptr TGLubyte) {.importc.} - proc glGetQueryObjectivEXT(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glColor3xOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed) {.importc.} - proc glMultiTexParameterIivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetMaterialiv(face: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertex2fv(v: ptr TGLfloat) {.importc.} - proc glConvolutionParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGenOcclusionQueriesNV(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glGetVertexAttribdvNV(index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glVertexAttribs4fvNV(index: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} - proc glVertexAttribL3dv(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glTexEnvi(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glObjectPtrLabel(`ptr`: ptr pointer, length: TGLsizei, label: ptr TGLchar) {.importc.} - proc glGetTexGenfv(coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glMapVertexAttrib1dAPPLE(index: TGLuint, size: TGLuint, u1: TGLdouble, u2: TGLdouble, stride: TGLint, order: TGLint, points: ptr TGLdouble) {.importc.} - proc glTexCoord3dv(v: ptr TGLdouble) {.importc.} - proc glIsEnabledIndexedEXT(target: TGLenum, index: TGLuint): TGLboolean {.importc.} - proc glGlobalAlphaFactoruiSUN(factor: TGLuint) {.importc.} - proc glMatrixIndexPointerARB(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glUniformHandleui64ARB(location: TGLint, value: TGLuint64) {.importc.} - proc glUniform1fvARB(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glGetActiveSubroutineUniformName(program: TGLuint, shadertype: TGLenum, index: TGLuint, bufsize: TGLsizei, length: ptr TGLsizei, name: ptr TGLchar) {.importc.} - proc glProgramUniformMatrix4x2fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glMultiTexCoord4fARB(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat, q: TGLfloat) {.importc.} - proc glGetDriverControlsQCOM(num: ptr TGLint, size: TGLsizei, driverControls: ptr TGLuint) {.importc.} - proc glBindBufferRange(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glMapGrid2f(un: TGLint, u1: TGLfloat, u2: TGLfloat, vn: TGLint, v1: TGLfloat, v2: TGLfloat) {.importc.} - proc glUniform2fv(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glOrtho(left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} - proc glGetImageHandleNV(texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, format: TGLenum): TGLuint64 {.importc.} - proc glIsImageHandleResidentARB(handle: TGLuint64): TGLboolean {.importc.} - proc glGetConvolutionParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glLineWidthxOES(width: TGLfixed) {.importc.} - proc glPathCommandsNV(path: TGLuint, numCommands: TGLsizei, commands: ptr TGLubyte, numCoords: TGLsizei, coordType: TGLenum, coords: pointer) {.importc.} - proc glMaterialxvOES(face: TGLenum, pname: TGLenum, param: ptr TGLfixed) {.importc.} + proc glDrawBuffersIndexedEXT(n: GLint, location: ptr GLenum, indices: ptr GLint) {.importc.} + proc glUniformMatrix4fvARB(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glInstrumentsBufferSGIX(size: GLsizei, buffer: ptr GLint) {.importc.} + proc glAlphaFuncQCOM(func: GLenum, `ref`: GLclampf) {.importc.} + proc glUniformMatrix4fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glGetMinmaxParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetInvariantBooleanvEXT(id: GLuint, value: GLenum, data: ptr GLboolean) {.importc.} + proc glVDPAUIsSurfaceNV(surface: GLvdpauSurfaceNV) {.importc.} + proc glGenProgramsARB(n: GLsizei, programs: ptr GLuint) {.importc.} + proc glDrawRangeElementArrayATI(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei) {.importc.} + proc glFramebufferRenderbufferEXT(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} + proc glClearIndex(c: GLfloat) {.importc.} + proc glDepthRangeIndexed(index: GLuint, n: GLdouble, f: GLdouble) {.importc.} + proc glDrawTexivOES(coords: ptr GLint) {.importc.} + proc glTangent3iEXT(tx: GLint, ty: GLint, tz: GLint) {.importc.} + proc glStringMarkerGREMEDY(len: GLsizei, string: pointer) {.importc.} + proc glTexCoordP1ui(`type`: GLenum, coords: GLuint) {.importc.} + proc glOrthox(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} + proc glReplacementCodeuiVertex3fvSUN(rc: ptr GLuint, v: ptr GLfloat) {.importc.} + proc glMultiTexCoord1bvOES(texture: GLenum, coords: ptr GLbyte) {.importc.} + proc glDrawArraysInstancedBaseInstance(mode: GLenum, first: GLint, count: GLsizei, instancecount: GLsizei, baseinstance: GLuint) {.importc.} + proc glMultMatrixf(m: ptr GLfloat) {.importc.} + proc glProgramUniform4i(program: GLuint, location: GLint, v0: GLint, v1: GLint, v2: GLint, v3: GLint) {.importc.} + proc glScissorArrayv(first: GLuint, count: GLsizei, v: ptr GLint) {.importc.} + proc glGetnUniformivEXT(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLint) {.importc.} + proc glGetTexEnvxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glWindowPos3ivARB(v: ptr GLint) {.importc.} + proc glProgramStringARB(target: GLenum, format: GLenum, len: GLsizei, string: pointer) {.importc.} + proc glTextureColorMaskSGIS(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean) {.importc.} + proc glMultiTexCoord4fv(target: GLenum, v: ptr GLfloat) {.importc.} + proc glUniformMatrix4x3fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glIsPathNV(path: GLuint): TGLboolean {.importc.} + proc glStartTilingQCOM(x: GLuint, y: GLuint, width: GLuint, height: GLuint, preserveMask: GLbitfield) {.importc.} + proc glVariantivEXT(id: GLuint, `addr`: ptr GLint) {.importc.} + proc glGetnMinmaxARB(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, bufSize: GLsizei, values: pointer) {.importc.} + proc glTransformFeedbackVaryings(program: GLuint, count: GLsizei, varyings: ptr ptr GLchar, bufferMode: GLenum) {.importc.} + proc glShaderOp2EXT(op: GLenum, res: GLuint, arg1: GLuint, arg2: GLuint) {.importc.} + proc glVertexAttribPointer(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glMultiTexCoord4dvARB(target: GLenum, v: ptr GLdouble) {.importc.} + proc glProgramUniform1ui64NV(program: GLuint, location: GLint, x: GLuint64EXT) {.importc.} + proc glGetShaderSourceARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, source: ptr GLcharARB) {.importc.} + proc glGetBufferSubDataARB(target: GLenum, offset: GLintptrARB, size: GLsizeiptrARB, data: pointer) {.importc.} + proc glCopyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glProgramEnvParameterI4iNV(target: GLenum, index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glGetVertexAttribivARB(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetFinalCombinerInputParameterivNV(variable: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glIndexFuncEXT(func: GLenum, `ref`: GLclampf) {.importc.} + proc glProgramUniformMatrix3dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glTexStorage1DEXT(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei) {.importc.} + proc glUniformMatrix2fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glConvolutionParameterf(target: GLenum, pname: GLenum, params: GLfloat) {.importc.} + proc glGlobalAlphaFactordSUN(factor: GLdouble) {.importc.} + proc glCopyTextureImage2DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) {.importc.} + proc glVertex4xOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glClearDepthx(depth: GLfixed) {.importc.} + proc glGetColorTableParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGenProgramPipelines(n: GLsizei, pipelines: ptr GLuint) {.importc.} + proc glVertexAttribL4ui64vNV(index: GLuint, v: ptr GLuint64EXT) {.importc.} + proc glUniform1fARB(location: GLint, v0: GLfloat) {.importc.} + proc glUniformMatrix3fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glUniform3dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glVertexAttribI4iv(index: GLuint, v: ptr GLint) {.importc.} + proc glPixelZoom(xfactor: GLfloat, yfactor: GLfloat) {.importc.} + proc glShadeModel(mode: GLenum) {.importc.} + proc glFramebufferTexture3DOES(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} + proc glMultiTexCoord2i(target: GLenum, s: GLint, t: GLint) {.importc.} + proc glBlendEquationSeparateIndexedAMD(buf: GLuint, modeRGB: GLenum, modeAlpha: GLenum) {.importc.} + proc glIsEnabled(cap: GLenum): TGLboolean {.importc.} + proc glTexImage2D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glPolygonOffsetxOES(factor: GLfixed, units: GLfixed) {.importc.} + proc glDrawBuffersEXT(n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glPixelTexGenParameterfSGIS(pname: GLenum, param: GLfloat) {.importc.} + proc glExtGetRenderbuffersQCOM(renderbuffers: ptr GLuint, maxRenderbuffers: GLint, numRenderbuffers: ptr GLint) {.importc.} + proc glBindImageTextures(first: GLuint, count: GLsizei, textures: ptr GLuint) {.importc.} + proc glVertexAttribP2uiv(index: GLuint, `type`: GLenum, normalized: GLboolean, value: ptr GLuint) {.importc.} + proc glTextureImage3DMultisampleCoverageNV(texture: GLuint, target: GLenum, coverageSamples: GLsizei, colorSamples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glRasterPos2s(x: GLshort, y: GLshort) {.importc.} + proc glVertexAttrib4dvARB(index: GLuint, v: ptr GLdouble) {.importc.} + proc glProgramUniformMatrix2x3fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glProgramUniformMatrix2x4dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glMultiTexCoord1d(target: GLenum, s: GLdouble) {.importc.} + proc glGetProgramParameterdvNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glPNTrianglesfATI(pname: GLenum, param: GLfloat) {.importc.} + proc glUniformMatrix3x4fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glVertexAttrib3sNV(index: GLuint, x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glGetVideoCaptureStreamfvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glCombinerParameterivNV(pname: GLenum, params: ptr GLint) {.importc.} + proc glGetTexGenfvOES(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glCopyTexSubImage2DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glGetProgramLocalParameterfvARB(target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glTexCoord3iv(v: ptr GLint) {.importc.} + proc glVertexAttribs2hvNV(index: GLuint, n: GLsizei, v: ptr GLhalfNV) {.importc.} + proc glNormal3sv(v: ptr GLshort) {.importc.} + proc glUniform2dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glSecondaryColor3hvNV(v: ptr GLhalfNV) {.importc.} + proc glDrawArraysInstancedEXT(mode: GLenum, start: GLint, count: GLsizei, primcount: GLsizei) {.importc.} + proc glBeginTransformFeedback(primitiveMode: GLenum) {.importc.} + proc glTexParameterIuivEXT(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glProgramBufferParametersfvNV(target: GLenum, bindingIndex: GLuint, wordIndex: GLuint, count: GLsizei, params: ptr GLfloat) {.importc.} + proc glVertexArrayBindVertexBufferEXT(vaobj: GLuint, bindingindex: GLuint, buffer: GLuint, offset: GLintptr, stride: GLsizei) {.importc.} + proc glPathParameterfNV(path: GLuint, pname: GLenum, value: GLfloat) {.importc.} + proc glGetClipPlanexOES(plane: GLenum, equation: ptr GLfixed) {.importc.} + proc glSecondaryColor3ubvEXT(v: ptr GLubyte) {.importc.} + proc glGetPixelMapxv(map: GLenum, size: GLint, values: ptr GLfixed) {.importc.} + proc glVertexAttribI1uivEXT(index: GLuint, v: ptr GLuint) {.importc.} + proc glMultiTexImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glAlphaFuncxOES(func: GLenum, `ref`: GLfixed) {.importc.} + proc glMultiTexCoord2dv(target: GLenum, v: ptr GLdouble) {.importc.} + proc glBindRenderbufferOES(target: GLenum, renderbuffer: GLuint) {.importc.} + proc glPathStencilDepthOffsetNV(factor: GLfloat, units: GLfloat) {.importc.} + proc glPointParameterfvEXT(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glSampleCoverageARB(value: GLfloat, invert: GLboolean) {.importc.} + proc glVertexAttrib3dNV(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glNamedProgramLocalParameter4dvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glGenFramebuffers(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glMultiDrawElementsEXT(mode: GLenum, count: ptr GLsizei, `type`: GLenum, indices: ptr pointer, primcount: GLsizei) {.importc.} + proc glVertexAttrib2fNV(index: GLuint, x: GLfloat, y: GLfloat) {.importc.} + proc glProgramUniform4ivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glTexGeniOES(coord: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glBindProgramPipeline(pipeline: GLuint) {.importc.} + proc glBindSamplers(first: GLuint, count: GLsizei, samplers: ptr GLuint) {.importc.} + proc glColorTableSGI(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, table: pointer) {.importc.} + proc glMultiTexCoord3xOES(texture: GLenum, s: GLfixed, t: GLfixed, r: GLfixed) {.importc.} + proc glIsQueryEXT(id: GLuint): TGLboolean {.importc.} + proc glGenBuffersARB(n: GLsizei, buffers: ptr GLuint) {.importc.} + proc glVertex4xvOES(coords: ptr GLfixed) {.importc.} + proc glPixelMapuiv(map: GLenum, mapsize: GLsizei, values: ptr GLuint) {.importc.} + proc glDrawTexfOES(x: GLfloat, y: GLfloat, z: GLfloat, width: GLfloat, height: GLfloat) {.importc.} + proc glPointParameterfEXT(pname: GLenum, param: GLfloat) {.importc.} + proc glPathDashArrayNV(path: GLuint, dashCount: GLsizei, dashArray: ptr GLfloat) {.importc.} + proc glClearTexImage(texture: GLuint, level: GLint, format: GLenum, `type`: GLenum, data: ptr pointer) {.importc.} + proc glIndexdv(c: ptr GLdouble) {.importc.} + proc glMultTransposeMatrixfARB(m: ptr GLfloat) {.importc.} + proc glVertexAttribL3d(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glUniform3fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetProgramInterfaceiv(program: GLuint, programInterface: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glFogCoordfv(coord: ptr GLfloat) {.importc.} + proc glTexSubImage3DOES(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetPolygonStipple(mask: ptr GLubyte) {.importc.} + proc glGetQueryObjectivEXT(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glColor3xOES(red: GLfixed, green: GLfixed, blue: GLfixed) {.importc.} + proc glMultiTexParameterIivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetMaterialiv(face: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertex2fv(v: ptr GLfloat) {.importc.} + proc glConvolutionParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGenOcclusionQueriesNV(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glGetVertexAttribdvNV(index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glVertexAttribs4fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glVertexAttribL3dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glTexEnvi(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glObjectPtrLabel(`ptr`: ptr pointer, length: GLsizei, label: ptr GLchar) {.importc.} + proc glGetTexGenfv(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMapVertexAttrib1dAPPLE(index: GLuint, size: GLuint, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: ptr GLdouble) {.importc.} + proc glTexCoord3dv(v: ptr GLdouble) {.importc.} + proc glIsEnabledIndexedEXT(target: GLenum, index: GLuint): TGLboolean {.importc.} + proc glGlobalAlphaFactoruiSUN(factor: GLuint) {.importc.} + proc glMatrixIndexPointerARB(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glUniformHandleui64ARB(location: GLint, value: GLuint64) {.importc.} + proc glUniform1fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetActiveSubroutineUniformName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} + proc glProgramUniformMatrix4x2fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glMultiTexCoord4fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} + proc glGetDriverControlsQCOM(num: ptr GLint, size: GLsizei, driverControls: ptr GLuint) {.importc.} + proc glBindBufferRange(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glMapGrid2f(un: GLint, u1: GLfloat, u2: GLfloat, vn: GLint, v1: GLfloat, v2: GLfloat) {.importc.} + proc glUniform2fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glOrtho(left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, zNear: GLdouble, zFar: GLdouble) {.importc.} + proc glGetImageHandleNV(texture: GLuint, level: GLint, layered: GLboolean, layer: GLint, format: GLenum): TGLuint64 {.importc.} + proc glIsImageHandleResidentARB(handle: GLuint64): TGLboolean {.importc.} + proc glGetConvolutionParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glLineWidthxOES(width: GLfixed) {.importc.} + proc glPathCommandsNV(path: GLuint, numCommands: GLsizei, commands: ptr GLubyte, numCoords: GLsizei, coordType: GLenum, coords: pointer) {.importc.} + proc glMaterialxvOES(face: GLenum, pname: GLenum, param: ptr GLfixed) {.importc.} proc glPauseTransformFeedbackNV() {.importc.} - proc glTexCoord4d(s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc.} - proc glUniform3ui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} - proc glMultiTexCoord3dARB(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc.} - proc glProgramUniform3fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} - proc glTexImage3DMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} - proc glNormalPointerEXT(`type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} - proc glPathColorGenNV(color: TGLenum, genMode: TGLenum, colorFormat: TGLenum, coeffs: ptr TGLfloat) {.importc.} - proc glGetMultiTexGendvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glColor3i(red: TGLint, green: TGLint, blue: TGLint) {.importc.} - proc glPointSizex(size: TGLfixed) {.importc.} - proc glGetConvolutionFilterEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} - proc glBindBufferBaseNV(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc.} - proc glInsertComponentEXT(res: TGLuint, src: TGLuint, num: TGLuint) {.importc.} - proc glVertex2d(x: TGLdouble, y: TGLdouble) {.importc.} - proc glGetPathDashArrayNV(path: TGLuint, dashArray: ptr TGLfloat) {.importc.} - proc glVertexAttrib2sARB(index: TGLuint, x: TGLshort, y: TGLshort) {.importc.} - proc glScissor(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glLoadMatrixd(m: ptr TGLdouble) {.importc.} - proc glVertex2bvOES(coords: ptr TGLbyte) {.importc.} - proc glTexCoord2i(s: TGLint, t: TGLint) {.importc.} - proc glWriteMaskEXT(res: TGLuint, `in`: TGLuint, outX: TGLenum, outY: TGLenum, outZ: TGLenum, outW: TGLenum) {.importc.} - proc glClientWaitSyncAPPLE(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64): TGLenum {.importc.} - proc glGetObjectBufferivATI(buffer: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetNamedBufferParameterivEXT(buffer: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glTexCoord1bOES(s: TGLbyte) {.importc.} - proc glVertexAttrib4dARB(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glUniform3fARB(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat) {.importc.} - proc glWindowPos2ivARB(v: ptr TGLint) {.importc.} - proc glCreateShaderProgramvEXT(`type`: TGLenum, count: TGLsizei, strings: ptr ptr TGLchar): TGLuint {.importc.} - proc glListParameterivSGIX(list: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glTexCoord4d(s: GLdouble, t: GLdouble, r: GLdouble, q: GLdouble) {.importc.} + proc glUniform3ui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} + proc glMultiTexCoord3dARB(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble) {.importc.} + proc glProgramUniform3fEXT(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} + proc glTexImage3DMultisampleCoverageNV(target: GLenum, coverageSamples: GLsizei, colorSamples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glNormalPointerEXT(`type`: GLenum, stride: GLsizei, count: GLsizei, `pointer`: pointer) {.importc.} + proc glPathColorGenNV(color: GLenum, genMode: GLenum, colorFormat: GLenum, coeffs: ptr GLfloat) {.importc.} + proc glGetMultiTexGendvEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glColor3i(red: GLint, green: GLint, blue: GLint) {.importc.} + proc glPointSizex(size: GLfixed) {.importc.} + proc glGetConvolutionFilterEXT(target: GLenum, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glBindBufferBaseNV(target: GLenum, index: GLuint, buffer: GLuint) {.importc.} + proc glInsertComponentEXT(res: GLuint, src: GLuint, num: GLuint) {.importc.} + proc glVertex2d(x: GLdouble, y: GLdouble) {.importc.} + proc glGetPathDashArrayNV(path: GLuint, dashArray: ptr GLfloat) {.importc.} + proc glVertexAttrib2sARB(index: GLuint, x: GLshort, y: GLshort) {.importc.} + proc glScissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glLoadMatrixd(m: ptr GLdouble) {.importc.} + proc glVertex2bvOES(coords: ptr GLbyte) {.importc.} + proc glTexCoord2i(s: GLint, t: GLint) {.importc.} + proc glWriteMaskEXT(res: GLuint, `in`: GLuint, outX: GLenum, outY: GLenum, outZ: GLenum, outW: GLenum) {.importc.} + proc glClientWaitSyncAPPLE(sync: GLsync, flags: GLbitfield, timeout: GLuint64): TGLenum {.importc.} + proc glGetObjectBufferivATI(buffer: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetNamedBufferParameterivEXT(buffer: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glTexCoord1bOES(s: GLbyte) {.importc.} + proc glVertexAttrib4dARB(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glUniform3fARB(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} + proc glWindowPos2ivARB(v: ptr GLint) {.importc.} + proc glCreateShaderProgramvEXT(`type`: GLenum, count: GLsizei, strings: ptr ptr GLchar): TGLuint {.importc.} + proc glListParameterivSGIX(list: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glGetGraphicsResetStatusEXT(): TGLenum {.importc.} - proc glActiveShaderProgramEXT(pipeline: TGLuint, program: TGLuint) {.importc.} - proc glTexCoordP1uiv(`type`: TGLenum, coords: ptr TGLuint) {.importc.} - proc glVideoCaptureStreamParameterdvNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glGetVertexAttribPointerv(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glGetCompressedMultiTexImageEXT(texunit: TGLenum, target: TGLenum, lod: TGLint, img: pointer) {.importc.} - proc glWindowPos4fMESA(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glDrawElementsInstancedARB(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} - proc glVertexStream1dATI(stream: TGLenum, x: TGLdouble) {.importc.} - proc glMatrixMultfEXT(mode: TGLenum, m: ptr TGLfloat) {.importc.} - proc glGetPathParameterivNV(path: TGLuint, pname: TGLenum, value: ptr TGLint) {.importc.} - proc glCombinerParameteriNV(pname: TGLenum, param: TGLint) {.importc.} - proc glUpdateObjectBufferATI(buffer: TGLuint, offset: TGLuint, size: TGLsizei, `pointer`: pointer, preserve: TGLenum) {.importc.} - proc glVertexAttrib4uivARB(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glVertexAttrib4iv(index: TGLuint, v: ptr TGLint) {.importc.} - proc glFrustum(left: TGLdouble, right: TGLdouble, bottom: TGLdouble, top: TGLdouble, zNear: TGLdouble, zFar: TGLdouble) {.importc.} - proc glDrawTexxvOES(coords: ptr TGLfixed) {.importc.} - proc glTexCoord2fColor4ubVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glMultiTexCoord2fARB(target: TGLenum, s: TGLfloat, t: TGLfloat) {.importc.} - proc glGenTransformFeedbacksNV(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glMultiTexGenfEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glGetMinmax(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} - proc glBindTransformFeedback(target: TGLenum, id: TGLuint) {.importc.} - proc glEnableVertexAttribArrayARB(index: TGLuint) {.importc.} - proc glIsFenceAPPLE(fence: TGLuint): TGLboolean {.importc.} - proc glMultiTexGendvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glRotatex(angle: TGLfixed, x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glGetFragmentLightfvSGIX(light: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glMultiTexCoord4dv(target: TGLenum, v: ptr TGLdouble) {.importc.} - proc glBlendFuncSeparateEXT(sfactorRGB: TGLenum, dfactorRGB: TGLenum, sfactorAlpha: TGLenum, dfactorAlpha: TGLenum) {.importc.} - proc glMultiTexCoord1f(target: TGLenum, s: TGLfloat) {.importc.} - proc glWindowPos2f(x: TGLfloat, y: TGLfloat) {.importc.} - proc glGetPathTexGenivNV(texCoordSet: TGLenum, pname: TGLenum, value: ptr TGLint) {.importc.} - proc glIndexxvOES(component: ptr TGLfixed) {.importc.} - proc glDisableVertexArrayAttribEXT(vaobj: TGLuint, index: TGLuint) {.importc.} - proc glGetProgramivARB(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glPatchParameteri(pname: TGLenum, value: TGLint) {.importc.} - proc glMultiTexCoord2fv(target: TGLenum, v: ptr TGLfloat) {.importc.} - proc glTexSubImage3DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glFramebufferTexture1DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glTangent3fEXT(tx: TGLfloat, ty: TGLfloat, tz: TGLfloat) {.importc.} - proc glIsVertexAttribEnabledAPPLE(index: TGLuint, pname: TGLenum): TGLboolean {.importc.} - proc glGetShaderInfoLog(shader: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, infoLog: ptr TGLchar) {.importc.} - proc glFrustumx(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} - proc glTexGenfv(coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glCompressedTexImage2DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glMultiTexCoord2bvOES(texture: TGLenum, coords: ptr TGLbyte) {.importc.} - proc glGetTexBumpParameterivATI(pname: TGLenum, param: ptr TGLint) {.importc.} - proc glMultiTexCoord2svARB(target: TGLenum, v: ptr TGLshort) {.importc.} - proc glProgramBufferParametersIivNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: ptr TGLint) {.importc.} - proc glIsQueryARB(id: TGLuint): TGLboolean {.importc.} - proc glFramebufferTextureLayer(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} - proc glUniform4i(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint, v3: TGLint) {.importc.} - proc glDrawArrays(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc.} - proc glWeightubvARB(size: TGLint, weights: ptr TGLubyte) {.importc.} - proc glGetUniformSubroutineuiv(shadertype: TGLenum, location: TGLint, params: ptr TGLuint) {.importc.} - proc glMultTransposeMatrixdARB(m: ptr TGLdouble) {.importc.} - proc glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc: ptr TGLuint, tc: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glGetMapdv(target: TGLenum, query: TGLenum, v: ptr TGLdouble) {.importc.} - proc glGetMultisamplefvNV(pname: TGLenum, index: TGLuint, val: ptr TGLfloat) {.importc.} - proc glVertex2hvNV(v: ptr TGLhalfNV) {.importc.} - proc glProgramUniformMatrix2x3fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glProgramUniform3iEXT(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} - proc glGetnPixelMapusvARB(map: TGLenum, bufSize: TGLsizei, values: ptr TGLushort) {.importc.} - proc glVertexWeighthvNV(weight: ptr TGLhalfNV) {.importc.} - proc glDrawTransformFeedbackInstanced(mode: TGLenum, id: TGLuint, instancecount: TGLsizei) {.importc.} - proc glFlushStaticDataIBM(target: TGLenum) {.importc.} - proc glWindowPos2fvARB(v: ptr TGLfloat) {.importc.} - proc glMultiTexCoord3sARB(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort) {.importc.} - proc glWindowPos3fv(v: ptr TGLfloat) {.importc.} + proc glActiveShaderProgramEXT(pipeline: GLuint, program: GLuint) {.importc.} + proc glTexCoordP1uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} + proc glVideoCaptureStreamParameterdvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glGetVertexAttribPointerv(index: GLuint, pname: GLenum, `pointer`: ptr pointer) {.importc.} + proc glGetCompressedMultiTexImageEXT(texunit: GLenum, target: GLenum, lod: GLint, img: pointer) {.importc.} + proc glWindowPos4fMESA(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glDrawElementsInstancedARB(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, primcount: GLsizei) {.importc.} + proc glVertexStream1dATI(stream: GLenum, x: GLdouble) {.importc.} + proc glMatrixMultfEXT(mode: GLenum, m: ptr GLfloat) {.importc.} + proc glGetPathParameterivNV(path: GLuint, pname: GLenum, value: ptr GLint) {.importc.} + proc glCombinerParameteriNV(pname: GLenum, param: GLint) {.importc.} + proc glUpdateObjectBufferATI(buffer: GLuint, offset: GLuint, size: GLsizei, `pointer`: pointer, preserve: GLenum) {.importc.} + proc glVertexAttrib4uivARB(index: GLuint, v: ptr GLuint) {.importc.} + proc glVertexAttrib4iv(index: GLuint, v: ptr GLint) {.importc.} + proc glFrustum(left: GLdouble, right: GLdouble, bottom: GLdouble, top: GLdouble, zNear: GLdouble, zFar: GLdouble) {.importc.} + proc glDrawTexxvOES(coords: ptr GLfixed) {.importc.} + proc glTexCoord2fColor4ubVertex3fSUN(s: GLfloat, t: GLfloat, r: GLubyte, g: GLubyte, b: GLubyte, a: GLubyte, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glMultiTexCoord2fARB(target: GLenum, s: GLfloat, t: GLfloat) {.importc.} + proc glGenTransformFeedbacksNV(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glMultiTexGenfEXT(texunit: GLenum, coord: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glGetMinmax(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, values: pointer) {.importc.} + proc glBindTransformFeedback(target: GLenum, id: GLuint) {.importc.} + proc glEnableVertexAttribArrayARB(index: GLuint) {.importc.} + proc glIsFenceAPPLE(fence: GLuint): TGLboolean {.importc.} + proc glMultiTexGendvEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glRotatex(angle: GLfixed, x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glGetFragmentLightfvSGIX(light: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMultiTexCoord4dv(target: GLenum, v: ptr GLdouble) {.importc.} + proc glBlendFuncSeparateEXT(sfactorRGB: GLenum, dfactorRGB: GLenum, sfactorAlpha: GLenum, dfactorAlpha: GLenum) {.importc.} + proc glMultiTexCoord1f(target: GLenum, s: GLfloat) {.importc.} + proc glWindowPos2f(x: GLfloat, y: GLfloat) {.importc.} + proc glGetPathTexGenivNV(texCoordSet: GLenum, pname: GLenum, value: ptr GLint) {.importc.} + proc glIndexxvOES(component: ptr GLfixed) {.importc.} + proc glDisableVertexArrayAttribEXT(vaobj: GLuint, index: GLuint) {.importc.} + proc glGetProgramivARB(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glPatchParameteri(pname: GLenum, value: GLint) {.importc.} + proc glMultiTexCoord2fv(target: GLenum, v: ptr GLfloat) {.importc.} + proc glTexSubImage3DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glFramebufferTexture1DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glTangent3fEXT(tx: GLfloat, ty: GLfloat, tz: GLfloat) {.importc.} + proc glIsVertexAttribEnabledAPPLE(index: GLuint, pname: GLenum): TGLboolean {.importc.} + proc glGetShaderInfoLog(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glFrustumx(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} + proc glTexGenfv(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glCompressedTexImage2DARB(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glMultiTexCoord2bvOES(texture: GLenum, coords: ptr GLbyte) {.importc.} + proc glGetTexBumpParameterivATI(pname: GLenum, param: ptr GLint) {.importc.} + proc glMultiTexCoord2svARB(target: GLenum, v: ptr GLshort) {.importc.} + proc glProgramBufferParametersIivNV(target: GLenum, bindingIndex: GLuint, wordIndex: GLuint, count: GLsizei, params: ptr GLint) {.importc.} + proc glIsQueryARB(id: GLuint): TGLboolean {.importc.} + proc glFramebufferTextureLayer(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint, layer: GLint) {.importc.} + proc glUniform4i(location: GLint, v0: GLint, v1: GLint, v2: GLint, v3: GLint) {.importc.} + proc glDrawArrays(mode: GLenum, first: GLint, count: GLsizei) {.importc.} + proc glWeightubvARB(size: GLint, weights: ptr GLubyte) {.importc.} + proc glGetUniformSubroutineuiv(shadertype: GLenum, location: GLint, params: ptr GLuint) {.importc.} + proc glMultTransposeMatrixdARB(m: ptr GLdouble) {.importc.} + proc glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc: ptr GLuint, tc: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glGetMapdv(target: GLenum, query: GLenum, v: ptr GLdouble) {.importc.} + proc glGetMultisamplefvNV(pname: GLenum, index: GLuint, val: ptr GLfloat) {.importc.} + proc glVertex2hvNV(v: ptr GLhalfNV) {.importc.} + proc glProgramUniformMatrix2x3fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glProgramUniform3iEXT(program: GLuint, location: GLint, v0: GLint, v1: GLint, v2: GLint) {.importc.} + proc glGetnPixelMapusvARB(map: GLenum, bufSize: GLsizei, values: ptr GLushort) {.importc.} + proc glVertexWeighthvNV(weight: ptr GLhalfNV) {.importc.} + proc glDrawTransformFeedbackInstanced(mode: GLenum, id: GLuint, instancecount: GLsizei) {.importc.} + proc glFlushStaticDataIBM(target: GLenum) {.importc.} + proc glWindowPos2fvARB(v: ptr GLfloat) {.importc.} + proc glMultiTexCoord3sARB(target: GLenum, s: GLshort, t: GLshort, r: GLshort) {.importc.} + proc glWindowPos3fv(v: ptr GLfloat) {.importc.} proc glFlushVertexArrayRangeNV() {.importc.} - proc glTangent3bEXT(tx: TGLbyte, ty: TGLbyte, tz: TGLbyte) {.importc.} - proc glIglooInterfaceSGIX(pname: TGLenum, params: pointer) {.importc.} - proc glProgramUniformMatrix4x2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glVertexAttribIFormatNV(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} - proc glNamedRenderbufferStorageMultisampleEXT(renderbuffer: TGLuint, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glCopyTexImage1DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} - proc glBindTexGenParameterEXT(unit: TGLenum, coord: TGLenum, value: TGLenum): TGLuint {.importc.} - proc glVertex4hNV(x: TGLhalfNV, y: TGLhalfNV, z: TGLhalfNV, w: TGLhalfNV) {.importc.} - proc glGetMapfv(target: TGLenum, query: TGLenum, v: ptr TGLfloat) {.importc.} - proc glSamplePatternEXT(pattern: TGLenum) {.importc.} - proc glIndexxOES(component: TGLfixed) {.importc.} - proc glVertexAttrib4ubv(index: TGLuint, v: ptr TGLubyte) {.importc.} - proc glGetColorTable(target: TGLenum, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} - proc glFragmentLightModelivSGIX(pname: TGLenum, params: ptr TGLint) {.importc.} - proc glPixelTransformParameterfEXT(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glSamplerParameterfv(sampler: TGLuint, pname: TGLenum, param: ptr TGLfloat) {.importc.} - proc glBindTextureUnitParameterEXT(unit: TGLenum, value: TGLenum): TGLuint {.importc.} - proc glColor3ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc.} - proc glGetMultiTexGenivEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVariantusvEXT(id: TGLuint, `addr`: ptr TGLushort) {.importc.} - proc glMaterialiv(face: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glPassTexCoordATI(dst: TGLuint, coord: TGLuint, swizzle: TGLenum) {.importc.} - proc glGetIntegerui64vNV(value: TGLenum, result: ptr TGLuint64EXT) {.importc.} - proc glProgramParameteriEXT(program: TGLuint, pname: TGLenum, value: TGLint) {.importc.} - proc glVertexArrayEdgeFlagOffsetEXT(vaobj: TGLuint, buffer: TGLuint, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glGetCombinerInputParameterivNV(stage: TGLenum, portion: TGLenum, variable: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glLogicOp(opcode: TGLenum) {.importc.} - proc glConvolutionParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glIsBufferResidentNV(target: TGLenum): TGLboolean {.importc.} - proc glIsProgram(program: TGLuint): TGLboolean {.importc.} - proc glEndQueryARB(target: TGLenum) {.importc.} - proc glRenderbufferStorage(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glMaterialfv(face: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glTranslatex(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glPathParameterivNV(path: TGLuint, pname: TGLenum, value: ptr TGLint) {.importc.} - proc glLightxOES(light: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glSampleMaskEXT(value: TGLclampf, invert: TGLboolean) {.importc.} - proc glReplacementCodeubvSUN(code: ptr TGLubyte) {.importc.} - proc glVertexAttribArrayObjectATI(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc.} - proc glBeginTransformFeedbackNV(primitiveMode: TGLenum) {.importc.} - proc glEvalCoord1fv(u: ptr TGLfloat) {.importc.} - proc glProgramUniformMatrix2x3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glMaterialxv(face: TGLenum, pname: TGLenum, param: ptr TGLfixed) {.importc.} - proc glGetIntegerui64i_vNV(value: TGLenum, index: TGLuint, result: ptr TGLuint64EXT) {.importc.} - proc glUniformBlockBinding(program: TGLuint, uniformBlockIndex: TGLuint, uniformBlockBinding: TGLuint) {.importc.} - proc glColor4ui(red: TGLuint, green: TGLuint, blue: TGLuint, alpha: TGLuint) {.importc.} - proc glColor4ubVertex2fvSUN(c: ptr TGLubyte, v: ptr TGLfloat) {.importc.} - proc glRectd(x1: TGLdouble, y1: TGLdouble, x2: TGLdouble, y2: TGLdouble) {.importc.} - proc glGenVertexShadersEXT(range: TGLuint): TGLuint {.importc.} - proc glLinkProgramARB(programObj: TGLhandleARB) {.importc.} - proc glVertexAttribL4dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glBlitFramebuffer(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} - proc glUseProgram(program: TGLuint) {.importc.} - proc glNamedProgramLocalParameterI4ivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} - proc glMatrixLoadTransposedEXT(mode: TGLenum, m: ptr TGLdouble) {.importc.} - proc glTranslatef(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glGetBooleani_v(target: TGLenum, index: TGLuint, data: ptr TGLboolean) {.importc.} + proc glTangent3bEXT(tx: GLbyte, ty: GLbyte, tz: GLbyte) {.importc.} + proc glIglooInterfaceSGIX(pname: GLenum, params: pointer) {.importc.} + proc glProgramUniformMatrix4x2fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glVertexAttribIFormatNV(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glNamedRenderbufferStorageMultisampleEXT(renderbuffer: GLuint, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glCopyTexImage1DEXT(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, border: GLint) {.importc.} + proc glBindTexGenParameterEXT(unit: GLenum, coord: GLenum, value: GLenum): TGLuint {.importc.} + proc glVertex4hNV(x: GLhalfNV, y: GLhalfNV, z: GLhalfNV, w: GLhalfNV) {.importc.} + proc glGetMapfv(target: GLenum, query: GLenum, v: ptr GLfloat) {.importc.} + proc glSamplePatternEXT(pattern: GLenum) {.importc.} + proc glIndexxOES(component: GLfixed) {.importc.} + proc glVertexAttrib4ubv(index: GLuint, v: ptr GLubyte) {.importc.} + proc glGetColorTable(target: GLenum, format: GLenum, `type`: GLenum, table: pointer) {.importc.} + proc glFragmentLightModelivSGIX(pname: GLenum, params: ptr GLint) {.importc.} + proc glPixelTransformParameterfEXT(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glSamplerParameterfv(sampler: GLuint, pname: GLenum, param: ptr GLfloat) {.importc.} + proc glBindTextureUnitParameterEXT(unit: GLenum, value: GLenum): TGLuint {.importc.} + proc glColor3ub(red: GLubyte, green: GLubyte, blue: GLubyte) {.importc.} + proc glGetMultiTexGenivEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVariantusvEXT(id: GLuint, `addr`: ptr GLushort) {.importc.} + proc glMaterialiv(face: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glPassTexCoordATI(dst: GLuint, coord: GLuint, swizzle: GLenum) {.importc.} + proc glGetIntegerui64vNV(value: GLenum, result: ptr GLuint64EXT) {.importc.} + proc glProgramParameteriEXT(program: GLuint, pname: GLenum, value: GLint) {.importc.} + proc glVertexArrayEdgeFlagOffsetEXT(vaobj: GLuint, buffer: GLuint, stride: GLsizei, offset: GLintptr) {.importc.} + proc glGetCombinerInputParameterivNV(stage: GLenum, portion: GLenum, variable: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glLogicOp(opcode: GLenum) {.importc.} + proc glConvolutionParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glIsBufferResidentNV(target: GLenum): TGLboolean {.importc.} + proc glIsProgram(program: GLuint): TGLboolean {.importc.} + proc glEndQueryARB(target: GLenum) {.importc.} + proc glRenderbufferStorage(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glMaterialfv(face: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTranslatex(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glPathParameterivNV(path: GLuint, pname: GLenum, value: ptr GLint) {.importc.} + proc glLightxOES(light: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glSampleMaskEXT(value: GLclampf, invert: GLboolean) {.importc.} + proc glReplacementCodeubvSUN(code: ptr GLubyte) {.importc.} + proc glVertexAttribArrayObjectATI(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, buffer: GLuint, offset: GLuint) {.importc.} + proc glBeginTransformFeedbackNV(primitiveMode: GLenum) {.importc.} + proc glEvalCoord1fv(u: ptr GLfloat) {.importc.} + proc glProgramUniformMatrix2x3dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glMaterialxv(face: GLenum, pname: GLenum, param: ptr GLfixed) {.importc.} + proc glGetIntegerui64i_vNV(value: GLenum, index: GLuint, result: ptr GLuint64EXT) {.importc.} + proc glUniformBlockBinding(program: GLuint, uniformBlockIndex: GLuint, uniformBlockBinding: GLuint) {.importc.} + proc glColor4ui(red: GLuint, green: GLuint, blue: GLuint, alpha: GLuint) {.importc.} + proc glColor4ubVertex2fvSUN(c: ptr GLubyte, v: ptr GLfloat) {.importc.} + proc glRectd(x1: GLdouble, y1: GLdouble, x2: GLdouble, y2: GLdouble) {.importc.} + proc glGenVertexShadersEXT(range: GLuint): TGLuint {.importc.} + proc glLinkProgramARB(programObj: GLhandleARB) {.importc.} + proc glVertexAttribL4dEXT(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glBlitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} + proc glUseProgram(program: GLuint) {.importc.} + proc glNamedProgramLocalParameterI4ivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glMatrixLoadTransposedEXT(mode: GLenum, m: ptr GLdouble) {.importc.} + proc glTranslatef(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glGetBooleani_v(target: GLenum, index: GLuint, data: ptr GLboolean) {.importc.} proc glEndFragmentShaderATI() {.importc.} - proc glVertexAttribI4ivEXT(index: TGLuint, v: ptr TGLint) {.importc.} - proc glMultiDrawElementsIndirectBindlessNV(mode: TGLenum, `type`: TGLenum, indirect: pointer, drawCount: TGLsizei, stride: TGLsizei, vertexBufferCount: TGLint) {.importc.} - proc glTexCoord2s(s: TGLshort, t: TGLshort) {.importc.} - proc glProgramUniform1i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} - proc glPointSizePointerOES(`type`: TGLenum, stride: TGLsizei, `pointer`: ptr pointer) {.importc.} - proc glGetTexFilterFuncSGIS(target: TGLenum, filter: TGLenum, weights: ptr TGLfloat) {.importc.} - proc glMapGrid2xOES(n: TGLint, u1: TGLfixed, u2: TGLfixed, v1: TGLfixed, v2: TGLfixed) {.importc.} - proc glRasterPos4xvOES(coords: ptr TGLfixed) {.importc.} - proc glGetProgramBinary(program: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, binaryFormat: ptr TGLenum, binary: pointer) {.importc.} - proc glNamedProgramLocalParameterI4uiEXT(program: TGLuint, target: TGLenum, index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} - proc glGetTexImage(target: TGLenum, level: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glColor4d(red: TGLdouble, green: TGLdouble, blue: TGLdouble, alpha: TGLdouble) {.importc.} - proc glTexCoord2fColor4fNormal3fVertex3fSUN(s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glIndexi(c: TGLint) {.importc.} - proc glGetSamplerParameterIuiv(sampler: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glGetnUniformivARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLint) {.importc.} - proc glCopyTexSubImage3DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glVertexAttribI2uivEXT(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glVertexStream2fvATI(stream: TGLenum, coords: ptr TGLfloat) {.importc.} - proc glArrayElementEXT(i: TGLint) {.importc.} - proc glVertexAttrib2fv(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glCopyMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glTexCoord4sv(v: ptr TGLshort) {.importc.} - proc glTexGenfvOES(coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glPointParameteriv(pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetNamedRenderbufferParameterivEXT(renderbuffer: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glProgramVertexLimitNV(target: TGLenum, limit: TGLint) {.importc.} - proc glSetMultisamplefvAMD(pname: TGLenum, index: TGLuint, val: ptr TGLfloat) {.importc.} - proc glLoadIdentityDeformationMapSGIX(mask: TGLbitfield) {.importc.} - proc glIsSyncAPPLE(sync: TGLsync): TGLboolean {.importc.} - proc glProgramUniform1ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} - proc glEdgeFlagPointerListIBM(stride: TGLint, `pointer`: ptr ptr TGLboolean, ptrstride: TGLint) {.importc.} + proc glVertexAttribI4ivEXT(index: GLuint, v: ptr GLint) {.importc.} + proc glMultiDrawElementsIndirectBindlessNV(mode: GLenum, `type`: GLenum, indirect: pointer, drawCount: GLsizei, stride: GLsizei, vertexBufferCount: GLint) {.importc.} + proc glTexCoord2s(s: GLshort, t: GLshort) {.importc.} + proc glProgramUniform1i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} + proc glPointSizePointerOES(`type`: GLenum, stride: GLsizei, `pointer`: ptr pointer) {.importc.} + proc glGetTexFilterFuncSGIS(target: GLenum, filter: GLenum, weights: ptr GLfloat) {.importc.} + proc glMapGrid2xOES(n: GLint, u1: GLfixed, u2: GLfixed, v1: GLfixed, v2: GLfixed) {.importc.} + proc glRasterPos4xvOES(coords: ptr GLfixed) {.importc.} + proc glGetProgramBinary(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, binaryFormat: ptr GLenum, binary: pointer) {.importc.} + proc glNamedProgramLocalParameterI4uiEXT(program: GLuint, target: GLenum, index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} + proc glGetTexImage(target: GLenum, level: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glColor4d(red: GLdouble, green: GLdouble, blue: GLdouble, alpha: GLdouble) {.importc.} + proc glTexCoord2fColor4fNormal3fVertex3fSUN(s: GLfloat, t: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glIndexi(c: GLint) {.importc.} + proc glGetSamplerParameterIuiv(sampler: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glGetnUniformivARB(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLint) {.importc.} + proc glCopyTexSubImage3DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glVertexAttribI2uivEXT(index: GLuint, v: ptr GLuint) {.importc.} + proc glVertexStream2fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} + proc glArrayElementEXT(i: GLint) {.importc.} + proc glVertexAttrib2fv(index: GLuint, v: ptr GLfloat) {.importc.} + proc glCopyMultiTexSubImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glTexCoord4sv(v: ptr GLshort) {.importc.} + proc glTexGenfvOES(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glPointParameteriv(pname: GLenum, params: ptr GLint) {.importc.} + proc glGetNamedRenderbufferParameterivEXT(renderbuffer: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramVertexLimitNV(target: GLenum, limit: GLint) {.importc.} + proc glSetMultisamplefvAMD(pname: GLenum, index: GLuint, val: ptr GLfloat) {.importc.} + proc glLoadIdentityDeformationMapSGIX(mask: GLbitfield) {.importc.} + proc glIsSyncAPPLE(sync: GLsync): TGLboolean {.importc.} + proc glProgramUniform1ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} + proc glEdgeFlagPointerListIBM(stride: GLint, `pointer`: ptr ptr GLboolean, ptrstride: GLint) {.importc.} proc glBeginVertexShaderEXT() {.importc.} - proc glGetIntegerv(pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertexAttrib2dvARB(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glBeginConditionalRenderNV(id: TGLuint, mode: TGLenum) {.importc.} - proc glEdgeFlagv(flag: ptr TGLboolean) {.importc.} - proc glReplacementCodeubSUN(code: TGLubyte) {.importc.} - proc glObjectLabel(identifier: TGLenum, name: TGLuint, length: TGLsizei, label: ptr TGLchar) {.importc.} - proc glMultiTexCoord3xvOES(texture: TGLenum, coords: ptr TGLfixed) {.importc.} - proc glNormal3iv(v: ptr TGLint) {.importc.} - proc glSamplerParameteri(sampler: TGLuint, pname: TGLenum, param: TGLint) {.importc.} - proc glTextureStorage1DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc.} - proc glVertexStream4dvATI(stream: TGLenum, coords: ptr TGLdouble) {.importc.} - proc glWindowPos2fv(v: ptr TGLfloat) {.importc.} - proc glTexCoord4i(s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc.} - proc glVertexAttrib4NusvARB(index: TGLuint, v: ptr TGLushort) {.importc.} - proc glVertexAttribL4d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glVertexAttribDivisorANGLE(index: TGLuint, divisor: TGLuint) {.importc.} - proc glMatrixIndexPointerOES(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glMultMatrixxOES(m: ptr TGLfixed) {.importc.} - proc glMultiTexCoordP2ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} - proc glDeformationMap3dSGIX(target: TGLenum, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, w1: TGLdouble, w2: TGLdouble, wstride: TGLint, worder: TGLint, points: ptr TGLdouble) {.importc.} - proc glClearDepthfOES(depth: TGLclampf) {.importc.} - proc glVertexStream1ivATI(stream: TGLenum, coords: ptr TGLint) {.importc.} - proc glHint(target: TGLenum, mode: TGLenum) {.importc.} - proc glVertex3fv(v: ptr TGLfloat) {.importc.} - proc glWaitSyncAPPLE(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64) {.importc.} - proc glWindowPos3i(x: TGLint, y: TGLint, z: TGLint) {.importc.} - proc glCompressedTexImage3DARB(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glVertexAttrib1fvARB(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glMultiTexCoord4xOES(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc.} - proc glUniform4ui64NV(location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc.} - proc glProgramUniform4uiEXT(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint, v3: TGLuint) {.importc.} - proc glUnmapNamedBufferEXT(buffer: TGLuint): TGLboolean {.importc.} - proc glBitmap(width: TGLsizei, height: TGLsizei, xorig: TGLfloat, yorig: TGLfloat, xmove: TGLfloat, ymove: TGLfloat, bitmap: ptr TGLubyte) {.importc.} - proc glNamedProgramLocalParameters4fvEXT(program: TGLuint, target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLfloat) {.importc.} - proc glGetPathCommandsNV(path: TGLuint, commands: ptr TGLubyte) {.importc.} - proc glVertexAttrib3fNV(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glNamedProgramStringEXT(program: TGLuint, target: TGLenum, format: TGLenum, len: TGLsizei, string: pointer) {.importc.} - proc glMatrixIndexusvARB(size: TGLint, indices: ptr TGLushort) {.importc.} - proc glBlitFramebufferNV(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} - proc glVertexAttribI1uiv(index: TGLuint, v: ptr TGLuint) {.importc.} + proc glGetIntegerv(pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttrib2dvARB(index: GLuint, v: ptr GLdouble) {.importc.} + proc glBeginConditionalRenderNV(id: GLuint, mode: GLenum) {.importc.} + proc glEdgeFlagv(flag: ptr GLboolean) {.importc.} + proc glReplacementCodeubSUN(code: GLubyte) {.importc.} + proc glObjectLabel(identifier: GLenum, name: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} + proc glMultiTexCoord3xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} + proc glNormal3iv(v: ptr GLint) {.importc.} + proc glSamplerParameteri(sampler: GLuint, pname: GLenum, param: GLint) {.importc.} + proc glTextureStorage1DEXT(texture: GLuint, target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei) {.importc.} + proc glVertexStream4dvATI(stream: GLenum, coords: ptr GLdouble) {.importc.} + proc glWindowPos2fv(v: ptr GLfloat) {.importc.} + proc glTexCoord4i(s: GLint, t: GLint, r: GLint, q: GLint) {.importc.} + proc glVertexAttrib4NusvARB(index: GLuint, v: ptr GLushort) {.importc.} + proc glVertexAttribL4d(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glVertexAttribDivisorANGLE(index: GLuint, divisor: GLuint) {.importc.} + proc glMatrixIndexPointerOES(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glMultMatrixxOES(m: ptr GLfixed) {.importc.} + proc glMultiTexCoordP2ui(texture: GLenum, `type`: GLenum, coords: GLuint) {.importc.} + proc glDeformationMap3dSGIX(target: GLenum, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, w1: GLdouble, w2: GLdouble, wstride: GLint, worder: GLint, points: ptr GLdouble) {.importc.} + proc glClearDepthfOES(depth: GLclampf) {.importc.} + proc glVertexStream1ivATI(stream: GLenum, coords: ptr GLint) {.importc.} + proc glHint(target: GLenum, mode: GLenum) {.importc.} + proc glVertex3fv(v: ptr GLfloat) {.importc.} + proc glWaitSyncAPPLE(sync: GLsync, flags: GLbitfield, timeout: GLuint64) {.importc.} + proc glWindowPos3i(x: GLint, y: GLint, z: GLint) {.importc.} + proc glCompressedTexImage3DARB(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glVertexAttrib1fvARB(index: GLuint, v: ptr GLfloat) {.importc.} + proc glMultiTexCoord4xOES(texture: GLenum, s: GLfixed, t: GLfixed, r: GLfixed, q: GLfixed) {.importc.} + proc glUniform4ui64NV(location: GLint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT, w: GLuint64EXT) {.importc.} + proc glProgramUniform4uiEXT(program: GLuint, location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} + proc glUnmapNamedBufferEXT(buffer: GLuint): TGLboolean {.importc.} + proc glBitmap(width: GLsizei, height: GLsizei, xorig: GLfloat, yorig: GLfloat, xmove: GLfloat, ymove: GLfloat, bitmap: ptr GLubyte) {.importc.} + proc glNamedProgramLocalParameters4fvEXT(program: GLuint, target: GLenum, index: GLuint, count: GLsizei, params: ptr GLfloat) {.importc.} + proc glGetPathCommandsNV(path: GLuint, commands: ptr GLubyte) {.importc.} + proc glVertexAttrib3fNV(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glNamedProgramStringEXT(program: GLuint, target: GLenum, format: GLenum, len: GLsizei, string: pointer) {.importc.} + proc glMatrixIndexusvARB(size: GLint, indices: ptr GLushort) {.importc.} + proc glBlitFramebufferNV(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} + proc glVertexAttribI1uiv(index: GLuint, v: ptr GLuint) {.importc.} proc glEndConditionalRenderNV() {.importc.} - proc glFeedbackBuffer(size: TGLsizei, `type`: TGLenum, buffer: ptr TGLfloat) {.importc.} - proc glMultiTexCoord3bvOES(texture: TGLenum, coords: ptr TGLbyte) {.importc.} - proc glCopyColorTableSGI(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glActiveTexture(texture: TGLenum) {.importc.} - proc glFogCoordhNV(fog: TGLhalfNV) {.importc.} - proc glColorMaskIndexedEXT(index: TGLuint, r: TGLboolean, g: TGLboolean, b: TGLboolean, a: TGLboolean) {.importc.} - proc glGetCompressedTexImage(target: TGLenum, level: TGLint, img: pointer) {.importc.} - proc glRasterPos2iv(v: ptr TGLint) {.importc.} - proc glGetBufferParameterivARB(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glProgramUniform3d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble, v2: TGLdouble) {.importc.} - proc glRasterPos3xvOES(coords: ptr TGLfixed) {.importc.} - proc glGetTextureParameterIuivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glBindImageTextureEXT(index: TGLuint, texture: TGLuint, level: TGLint, layered: TGLboolean, layer: TGLint, access: TGLenum, format: TGLint) {.importc.} - proc glWindowPos2iMESA(x: TGLint, y: TGLint) {.importc.} - proc glVertexPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glPixelTexGenParameterfvSGIS(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glUniform1iARB(location: TGLint, v0: TGLint) {.importc.} - proc glTextureSubImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glStencilOpSeparate(face: TGLenum, sfail: TGLenum, dpfail: TGLenum, dppass: TGLenum) {.importc.} - proc glVertexAttrib1dARB(index: TGLuint, x: TGLdouble) {.importc.} - proc glGetVideoCaptureStreamivNV(video_capture_slot: TGLuint, stream: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glIsFramebufferEXT(framebuffer: TGLuint): TGLboolean {.importc.} - proc glPointParameterxv(pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glProgramUniform4dv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glPassThrough(token: TGLfloat) {.importc.} - proc glGetProgramPipelineiv(pipeline: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glApplyTextureEXT(mode: TGLenum) {.importc.} - proc glVertexArrayNormalOffsetEXT(vaobj: TGLuint, buffer: TGLuint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glTexFilterFuncSGIS(target: TGLenum, filter: TGLenum, n: TGLsizei, weights: ptr TGLfloat) {.importc.} - proc glRenderbufferStorageOES(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glBindParameterEXT(value: TGLenum): TGLuint {.importc.} - proc glVertex4s(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glLoadTransposeMatrixf(m: ptr TGLfloat) {.importc.} - proc glDepthFunc(func: TGLenum) {.importc.} - proc glGetFramebufferAttachmentParameterivEXT(target: TGLenum, attachment: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glSampleMaskSGIS(value: TGLclampf, invert: TGLboolean) {.importc.} - proc glGetPointerIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr pointer) {.importc.} - proc glVertexStream4iATI(stream: TGLenum, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glFeedbackBuffer(size: GLsizei, `type`: GLenum, buffer: ptr GLfloat) {.importc.} + proc glMultiTexCoord3bvOES(texture: GLenum, coords: ptr GLbyte) {.importc.} + proc glCopyColorTableSGI(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glActiveTexture(texture: GLenum) {.importc.} + proc glFogCoordhNV(fog: GLhalfNV) {.importc.} + proc glColorMaskIndexedEXT(index: GLuint, r: GLboolean, g: GLboolean, b: GLboolean, a: GLboolean) {.importc.} + proc glGetCompressedTexImage(target: GLenum, level: GLint, img: pointer) {.importc.} + proc glRasterPos2iv(v: ptr GLint) {.importc.} + proc glGetBufferParameterivARB(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniform3d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble, v2: GLdouble) {.importc.} + proc glRasterPos3xvOES(coords: ptr GLfixed) {.importc.} + proc glGetTextureParameterIuivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glBindImageTextureEXT(index: GLuint, texture: GLuint, level: GLint, layered: GLboolean, layer: GLint, access: GLenum, format: GLint) {.importc.} + proc glWindowPos2iMESA(x: GLint, y: GLint) {.importc.} + proc glVertexPointervINTEL(size: GLint, `type`: GLenum, `pointer`: ptr pointer) {.importc.} + proc glPixelTexGenParameterfvSGIS(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glUniform1iARB(location: GLint, v0: GLint) {.importc.} + proc glTextureSubImage3DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glStencilOpSeparate(face: GLenum, sfail: GLenum, dpfail: GLenum, dppass: GLenum) {.importc.} + proc glVertexAttrib1dARB(index: GLuint, x: GLdouble) {.importc.} + proc glGetVideoCaptureStreamivNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glIsFramebufferEXT(framebuffer: GLuint): TGLboolean {.importc.} + proc glPointParameterxv(pname: GLenum, params: ptr GLfixed) {.importc.} + proc glProgramUniform4dv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glPassThrough(token: GLfloat) {.importc.} + proc glGetProgramPipelineiv(pipeline: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glApplyTextureEXT(mode: GLenum) {.importc.} + proc glVertexArrayNormalOffsetEXT(vaobj: GLuint, buffer: GLuint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glTexFilterFuncSGIS(target: GLenum, filter: GLenum, n: GLsizei, weights: ptr GLfloat) {.importc.} + proc glRenderbufferStorageOES(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glBindParameterEXT(value: GLenum): TGLuint {.importc.} + proc glVertex4s(x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glLoadTransposeMatrixf(m: ptr GLfloat) {.importc.} + proc glDepthFunc(func: GLenum) {.importc.} + proc glGetFramebufferAttachmentParameterivEXT(target: GLenum, attachment: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glSampleMaskSGIS(value: GLclampf, invert: GLboolean) {.importc.} + proc glGetPointerIndexedvEXT(target: GLenum, index: GLuint, data: ptr pointer) {.importc.} + proc glVertexStream4iATI(stream: GLenum, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} proc glUnlockArraysEXT() {.importc.} - proc glReplacementCodeuivSUN(code: ptr TGLuint) {.importc.} - proc glMatrixScaledEXT(mode: TGLenum, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glMultiTexImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glFeedbackBufferxOES(n: TGLsizei, `type`: TGLenum, buffer: ptr TGLfixed) {.importc.} - proc glLightEnviSGIX(pname: TGLenum, param: TGLint) {.importc.} - proc glMultiTexCoord4dARB(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble, q: TGLdouble) {.importc.} - proc glExtGetTexLevelParameterivQCOM(texture: TGLuint, face: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertexAttribI4usvEXT(index: TGLuint, v: ptr TGLushort) {.importc.} - proc glWindowPos2dvARB(v: ptr TGLdouble) {.importc.} - proc glBindFramebuffer(target: TGLenum, framebuffer: TGLuint) {.importc.} - proc glGetProgramPipelineivEXT(pipeline: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glProgramUniformHandleui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, values: ptr TGLuint64) {.importc.} - proc glFogCoordhvNV(fog: ptr TGLhalfNV) {.importc.} - proc glTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetActiveAtomicCounterBufferiv(program: TGLuint, bufferIndex: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glBeginQueryARB(target: TGLenum, id: TGLuint) {.importc.} - proc glGetTexParameterIuivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glUniform4ui64vNV(location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} - proc glClearAccumxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} - proc glFreeObjectBufferATI(buffer: TGLuint) {.importc.} - proc glGetVideouivNV(video_slot: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glVertexAttribL4ui64NV(index: TGLuint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc.} - proc glGetUniformBlockIndex(program: TGLuint, uniformBlockName: ptr TGLchar): TGLuint {.importc.} - proc glCopyMultiTexSubImage2DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glVertex3bvOES(coords: ptr TGLbyte) {.importc.} - proc glMultiDrawElementArrayAPPLE(mode: TGLenum, first: ptr TGLint, count: ptr TGLsizei, primcount: TGLsizei) {.importc.} + proc glReplacementCodeuivSUN(code: ptr GLuint) {.importc.} + proc glMatrixScaledEXT(mode: GLenum, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glMultiTexImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glFeedbackBufferxOES(n: GLsizei, `type`: GLenum, buffer: ptr GLfixed) {.importc.} + proc glLightEnviSGIX(pname: GLenum, param: GLint) {.importc.} + proc glMultiTexCoord4dARB(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble, q: GLdouble) {.importc.} + proc glExtGetTexLevelParameterivQCOM(texture: GLuint, face: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttribI4usvEXT(index: GLuint, v: ptr GLushort) {.importc.} + proc glWindowPos2dvARB(v: ptr GLdouble) {.importc.} + proc glBindFramebuffer(target: GLenum, framebuffer: GLuint) {.importc.} + proc glGetProgramPipelineivEXT(pipeline: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniformHandleui64vNV(program: GLuint, location: GLint, count: GLsizei, values: ptr GLuint64) {.importc.} + proc glFogCoordhvNV(fog: ptr GLhalfNV) {.importc.} + proc glTextureImage1DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetActiveAtomicCounterBufferiv(program: GLuint, bufferIndex: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glBeginQueryARB(target: GLenum, id: GLuint) {.importc.} + proc glGetTexParameterIuivEXT(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glUniform4ui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} + proc glClearAccumxOES(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glFreeObjectBufferATI(buffer: GLuint) {.importc.} + proc glGetVideouivNV(video_slot: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glVertexAttribL4ui64NV(index: GLuint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT, w: GLuint64EXT) {.importc.} + proc glGetUniformBlockIndex(program: GLuint, uniformBlockName: ptr GLchar): TGLuint {.importc.} + proc glCopyMultiTexSubImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glVertex3bvOES(coords: ptr GLbyte) {.importc.} + proc glMultiDrawElementArrayAPPLE(mode: GLenum, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei) {.importc.} proc glPrimitiveRestartNV() {.importc.} - proc glMateriali(face: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glBegin(mode: TGLenum) {.importc.} - proc glFogCoordPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glTexCoord1sv(v: ptr TGLshort) {.importc.} - proc glVertexAttribI4sv(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glTexEnvx(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glTexParameterIivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glLoadTransposeMatrixfARB(m: ptr TGLfloat) {.importc.} - proc glGetTextureSamplerHandleARB(texture: TGLuint, sampler: TGLuint): TGLuint64 {.importc.} - proc glVertexP3uiv(`type`: TGLenum, value: ptr TGLuint) {.importc.} - proc glProgramUniform2dv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glTexCoord4xvOES(coords: ptr TGLfixed) {.importc.} - proc glTexStorage1D(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei) {.importc.} - proc glTextureParameterfEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glVertexAttrib1d(index: TGLuint, x: TGLdouble) {.importc.} - proc glGetnPixelMapfvARB(map: TGLenum, bufSize: TGLsizei, values: ptr TGLfloat) {.importc.} - proc glDisableVertexAttribArray(index: TGLuint) {.importc.} - proc glUniformMatrix4x3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glRasterPos4f(x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glProgramUniform1fEXT(program: TGLuint, location: TGLint, v0: TGLfloat) {.importc.} - proc glPathTexGenNV(texCoordSet: TGLenum, genMode: TGLenum, components: TGLint, coeffs: ptr TGLfloat) {.importc.} - proc glUniform3ui(location: TGLint, v0: TGLuint, v1: TGLuint, v2: TGLuint) {.importc.} - proc glVDPAURegisterOutputSurfaceNV(vdpSurface: pointer, target: TGLenum, numTextureNames: TGLsizei, textureNames: ptr TGLuint): TGLvdpauSurfaceNV {.importc.} - proc glGetProgramLocalParameterIuivNV(target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} - proc glIsTextureHandleResidentNV(handle: TGLuint64): TGLboolean {.importc.} - proc glProgramEnvParameters4fvEXT(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLfloat) {.importc.} - proc glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glGetMultiTexEnvivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetFloatv(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glInsertEventMarkerEXT(length: TGLsizei, marker: ptr TGLchar) {.importc.} - proc glRasterPos3d(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glNamedFramebufferRenderbufferEXT(framebuffer: TGLuint, attachment: TGLenum, renderbuffertarget: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glGetConvolutionFilter(target: TGLenum, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} - proc glIsOcclusionQueryNV(id: TGLuint): TGLboolean {.importc.} - proc glGetnPixelMapuivARB(map: TGLenum, bufSize: TGLsizei, values: ptr TGLuint) {.importc.} - proc glMapParameterfvNV(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glPushDebugGroup(source: TGLenum, id: TGLuint, length: TGLsizei, message: ptr TGLchar) {.importc.} - proc glMakeImageHandleResidentARB(handle: TGLuint64, access: TGLenum) {.importc.} - proc glProgramUniformMatrix2fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glUniform3i64vNV(location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} - proc glImageTransformParameteriHP(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glMultiTexCoord1s(target: TGLenum, s: TGLshort) {.importc.} - proc glVertexAttribL4dvEXT(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glGetProgramEnvParameterfvARB(target: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} - proc glVertexArrayColorOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glGetHistogramParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetRenderbufferParameterivOES(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetBufferPointerv(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} - proc glSecondaryColor3ui(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc.} - proc glGetDebugMessageLog(count: TGLuint, bufsize: TGLsizei, sources: ptr TGLenum, types: ptr TGLenum, ids: ptr TGLuint, severities: ptr TGLenum, lengths: ptr TGLsizei, messageLog: ptr TGLchar): TGLuint {.importc.} - proc glNormal3i(nx: TGLint, ny: TGLint, nz: TGLint) {.importc.} - proc glTestFenceNV(fence: TGLuint): TGLboolean {.importc.} - proc glSecondaryColor3usv(v: ptr TGLushort) {.importc.} - proc glGenPathsNV(range: TGLsizei): TGLuint {.importc.} - proc glDeleteBuffersARB(n: TGLsizei, buffers: ptr TGLuint) {.importc.} - proc glProgramUniform4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glGetSharpenTexFuncSGIS(target: TGLenum, points: ptr TGLfloat) {.importc.} - proc glDrawMeshArraysSUN(mode: TGLenum, first: TGLint, count: TGLsizei, width: TGLsizei) {.importc.} - proc glVertexAttribs4hvNV(index: TGLuint, n: TGLsizei, v: ptr TGLhalfNV) {.importc.} - proc glGetClipPlane(plane: TGLenum, equation: ptr TGLdouble) {.importc.} - proc glEvalCoord2fv(u: ptr TGLfloat) {.importc.} - proc glAsyncMarkerSGIX(marker: TGLuint) {.importc.} - proc glGetSynciv(sync: TGLsync, pname: TGLenum, bufSize: TGLsizei, length: ptr TGLsizei, values: ptr TGLint) {.importc.} - proc glGetPathTexGenfvNV(texCoordSet: TGLenum, pname: TGLenum, value: ptr TGLfloat) {.importc.} - proc glTexParameterf(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glMultiTexCoord1fvARB(target: TGLenum, v: ptr TGLfloat) {.importc.} - proc glNormalPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} - proc glFragmentLightfvSGIX(light: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glViewportArrayv(first: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} - proc glNormal3fVertex3fSUN(nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glMultiTexCoord2dvARB(target: TGLenum, v: ptr TGLdouble) {.importc.} - proc glCopyColorSubTable(target: TGLenum, start: TGLsizei, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glTexCoord2hvNV(v: ptr TGLhalfNV) {.importc.} - proc glGetQueryObjectiv(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glColor4hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV, alpha: TGLhalfNV) {.importc.} - proc glProgramUniform2fv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glMultiTexCoord4hNV(target: TGLenum, s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV, q: TGLhalfNV) {.importc.} - proc glWindowPos2fvMESA(v: ptr TGLfloat) {.importc.} - proc glVertexAttrib3s(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glGetIntegerIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr TGLint) {.importc.} - proc glVertexAttrib4Niv(index: TGLuint, v: ptr TGLint) {.importc.} - proc glProgramLocalParameter4dvARB(target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} - proc glFramebufferTextureLayerEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} - proc glVertexAttribI1ui(index: TGLuint, x: TGLuint) {.importc.} - proc glFogCoorddv(coord: ptr TGLdouble) {.importc.} - proc glLightModelxv(pname: TGLenum, param: ptr TGLfixed) {.importc.} - proc glGetCombinerOutputParameterfvNV(stage: TGLenum, portion: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glFramebufferReadBufferEXT(framebuffer: TGLuint, mode: TGLenum) {.importc.} - proc glGetActiveUniformsiv(program: TGLuint, uniformCount: TGLsizei, uniformIndices: ptr TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetProgramStringNV(id: TGLuint, pname: TGLenum, program: ptr TGLubyte) {.importc.} - proc glCopyConvolutionFilter2D(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glMultiTexCoord3iARB(target: TGLenum, s: TGLint, t: TGLint, r: TGLint) {.importc.} - proc glPushName(name: TGLuint) {.importc.} - proc glProgramParameter4dNV(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glVertexAttrib4svARB(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glSecondaryColor3iv(v: ptr TGLint) {.importc.} - proc glCopyColorSubTableEXT(target: TGLenum, start: TGLsizei, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glCallList(list: TGLuint) {.importc.} - proc glGetMultiTexLevelParameterivEXT(texunit: TGLenum, target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glProgramUniformMatrix2x4fv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glTexBumpParameterivATI(pname: TGLenum, param: ptr TGLint) {.importc.} - proc glTexGeni(coord: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glSecondaryColor3dv(v: ptr TGLdouble) {.importc.} - proc glGetnUniformdvARB(program: TGLuint, location: TGLint, bufSize: TGLsizei, params: ptr TGLdouble) {.importc.} - proc glGetNamedProgramLocalParameterdvEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} - proc glGetVertexAttribPointervARB(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glCopyColorTable(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glNamedFramebufferTextureLayerEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} - proc glLoadProgramNV(target: TGLenum, id: TGLuint, len: TGLsizei, program: ptr TGLubyte) {.importc.} - proc glAlphaFragmentOp2ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint) {.importc.} - proc glBindLightParameterEXT(light: TGLenum, value: TGLenum): TGLuint {.importc.} - proc glVertexAttrib1fv(index: TGLuint, v: ptr TGLfloat) {.importc.} + proc glMateriali(face: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glBegin(mode: GLenum) {.importc.} + proc glFogCoordPointerEXT(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glTexCoord1sv(v: ptr GLshort) {.importc.} + proc glVertexAttribI4sv(index: GLuint, v: ptr GLshort) {.importc.} + proc glTexEnvx(target: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glTexParameterIivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glLoadTransposeMatrixfARB(m: ptr GLfloat) {.importc.} + proc glGetTextureSamplerHandleARB(texture: GLuint, sampler: GLuint): TGLuint64 {.importc.} + proc glVertexP3uiv(`type`: GLenum, value: ptr GLuint) {.importc.} + proc glProgramUniform2dv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glTexCoord4xvOES(coords: ptr GLfixed) {.importc.} + proc glTexStorage1D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei) {.importc.} + proc glTextureParameterfEXT(texture: GLuint, target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glVertexAttrib1d(index: GLuint, x: GLdouble) {.importc.} + proc glGetnPixelMapfvARB(map: GLenum, bufSize: GLsizei, values: ptr GLfloat) {.importc.} + proc glDisableVertexAttribArray(index: GLuint) {.importc.} + proc glUniformMatrix4x3dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glRasterPos4f(x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glProgramUniform1fEXT(program: GLuint, location: GLint, v0: GLfloat) {.importc.} + proc glPathTexGenNV(texCoordSet: GLenum, genMode: GLenum, components: GLint, coeffs: ptr GLfloat) {.importc.} + proc glUniform3ui(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} + proc glVDPAURegisterOutputSurfaceNV(vdpSurface: pointer, target: GLenum, numTextureNames: GLsizei, textureNames: ptr GLuint): TGLvdpauSurfaceNV {.importc.} + proc glGetProgramLocalParameterIuivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glIsTextureHandleResidentNV(handle: GLuint64): TGLboolean {.importc.} + proc glProgramEnvParameters4fvEXT(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLfloat) {.importc.} + proc glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glGetMultiTexEnvivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetFloatv(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glInsertEventMarkerEXT(length: GLsizei, marker: ptr GLchar) {.importc.} + proc glRasterPos3d(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glNamedFramebufferRenderbufferEXT(framebuffer: GLuint, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} + proc glGetConvolutionFilter(target: GLenum, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glIsOcclusionQueryNV(id: GLuint): TGLboolean {.importc.} + proc glGetnPixelMapuivARB(map: GLenum, bufSize: GLsizei, values: ptr GLuint) {.importc.} + proc glMapParameterfvNV(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glPushDebugGroup(source: GLenum, id: GLuint, length: GLsizei, message: ptr GLchar) {.importc.} + proc glMakeImageHandleResidentARB(handle: GLuint64, access: GLenum) {.importc.} + proc glProgramUniformMatrix2fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glUniform3i64vNV(location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} + proc glImageTransformParameteriHP(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glMultiTexCoord1s(target: GLenum, s: GLshort) {.importc.} + proc glVertexAttribL4dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} + proc glGetProgramEnvParameterfvARB(target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glVertexArrayColorOffsetEXT(vaobj: GLuint, buffer: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glGetHistogramParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetRenderbufferParameterivOES(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetBufferPointerv(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} + proc glSecondaryColor3ui(red: GLuint, green: GLuint, blue: GLuint) {.importc.} + proc glGetDebugMessageLog(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} + proc glNormal3i(nx: GLint, ny: GLint, nz: GLint) {.importc.} + proc glTestFenceNV(fence: GLuint): TGLboolean {.importc.} + proc glSecondaryColor3usv(v: ptr GLushort) {.importc.} + proc glGenPathsNV(range: GLsizei): TGLuint {.importc.} + proc glDeleteBuffersARB(n: GLsizei, buffers: ptr GLuint) {.importc.} + proc glProgramUniform4fvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetSharpenTexFuncSGIS(target: GLenum, points: ptr GLfloat) {.importc.} + proc glDrawMeshArraysSUN(mode: GLenum, first: GLint, count: GLsizei, width: GLsizei) {.importc.} + proc glVertexAttribs4hvNV(index: GLuint, n: GLsizei, v: ptr GLhalfNV) {.importc.} + proc glGetClipPlane(plane: GLenum, equation: ptr GLdouble) {.importc.} + proc glEvalCoord2fv(u: ptr GLfloat) {.importc.} + proc glAsyncMarkerSGIX(marker: GLuint) {.importc.} + proc glGetSynciv(sync: GLsync, pname: GLenum, bufSize: GLsizei, length: ptr GLsizei, values: ptr GLint) {.importc.} + proc glGetPathTexGenfvNV(texCoordSet: GLenum, pname: GLenum, value: ptr GLfloat) {.importc.} + proc glTexParameterf(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glMultiTexCoord1fvARB(target: GLenum, v: ptr GLfloat) {.importc.} + proc glNormalPointerListIBM(`type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glFragmentLightfvSGIX(light: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glViewportArrayv(first: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glNormal3fVertex3fSUN(nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glMultiTexCoord2dvARB(target: GLenum, v: ptr GLdouble) {.importc.} + proc glCopyColorSubTable(target: GLenum, start: GLsizei, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glTexCoord2hvNV(v: ptr GLhalfNV) {.importc.} + proc glGetQueryObjectiv(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glColor4hNV(red: GLhalfNV, green: GLhalfNV, blue: GLhalfNV, alpha: GLhalfNV) {.importc.} + proc glProgramUniform2fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glMultiTexCoord4hNV(target: GLenum, s: GLhalfNV, t: GLhalfNV, r: GLhalfNV, q: GLhalfNV) {.importc.} + proc glWindowPos2fvMESA(v: ptr GLfloat) {.importc.} + proc glVertexAttrib3s(index: GLuint, x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glGetIntegerIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} + proc glVertexAttrib4Niv(index: GLuint, v: ptr GLint) {.importc.} + proc glProgramLocalParameter4dvARB(target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glFramebufferTextureLayerEXT(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint, layer: GLint) {.importc.} + proc glVertexAttribI1ui(index: GLuint, x: GLuint) {.importc.} + proc glFogCoorddv(coord: ptr GLdouble) {.importc.} + proc glLightModelxv(pname: GLenum, param: ptr GLfixed) {.importc.} + proc glGetCombinerOutputParameterfvNV(stage: GLenum, portion: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glFramebufferReadBufferEXT(framebuffer: GLuint, mode: GLenum) {.importc.} + proc glGetActiveUniformsiv(program: GLuint, uniformCount: GLsizei, uniformIndices: ptr GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetProgramStringNV(id: GLuint, pname: GLenum, program: ptr GLubyte) {.importc.} + proc glCopyConvolutionFilter2D(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glMultiTexCoord3iARB(target: GLenum, s: GLint, t: GLint, r: GLint) {.importc.} + proc glPushName(name: GLuint) {.importc.} + proc glProgramParameter4dNV(target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glVertexAttrib4svARB(index: GLuint, v: ptr GLshort) {.importc.} + proc glSecondaryColor3iv(v: ptr GLint) {.importc.} + proc glCopyColorSubTableEXT(target: GLenum, start: GLsizei, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glCallList(list: GLuint) {.importc.} + proc glGetMultiTexLevelParameterivEXT(texunit: GLenum, target: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniformMatrix2x4fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glTexBumpParameterivATI(pname: GLenum, param: ptr GLint) {.importc.} + proc glTexGeni(coord: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glSecondaryColor3dv(v: ptr GLdouble) {.importc.} + proc glGetnUniformdvARB(program: GLuint, location: GLint, bufSize: GLsizei, params: ptr GLdouble) {.importc.} + proc glGetNamedProgramLocalParameterdvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glGetVertexAttribPointervARB(index: GLuint, pname: GLenum, `pointer`: ptr pointer) {.importc.} + proc glCopyColorTable(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glNamedFramebufferTextureLayerEXT(framebuffer: GLuint, attachment: GLenum, texture: GLuint, level: GLint, layer: GLint) {.importc.} + proc glLoadProgramNV(target: GLenum, id: GLuint, len: GLsizei, program: ptr GLubyte) {.importc.} + proc glAlphaFragmentOp2ATI(op: GLenum, dst: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint) {.importc.} + proc glBindLightParameterEXT(light: GLenum, value: GLenum): TGLuint {.importc.} + proc glVertexAttrib1fv(index: GLuint, v: ptr GLfloat) {.importc.} proc glLoadIdentity() {.importc.} - proc glFramebufferTexture2DMultisampleEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, samples: TGLsizei) {.importc.} - proc glVertexAttrib1dvARB(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glDrawRangeElementsBaseVertex(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer, basevertex: TGLint) {.importc.} - proc glPixelMapfv(map: TGLenum, mapsize: TGLsizei, values: ptr TGLfloat) {.importc.} - proc glPointParameterxOES(pname: TGLenum, param: TGLfixed) {.importc.} - proc glBindBufferRangeNV(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glDepthBoundsEXT(zmin: TGLclampd, zmax: TGLclampd) {.importc.} - proc glProgramUniformMatrix2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glSecondaryColor3s(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc.} - proc glEdgeFlagPointerEXT(stride: TGLsizei, count: TGLsizei, `pointer`: ptr TGLboolean) {.importc.} - proc glVertexStream1fATI(stream: TGLenum, x: TGLfloat) {.importc.} - proc glUniformui64NV(location: TGLint, value: TGLuint64EXT) {.importc.} - proc glTexCoordP4uiv(`type`: TGLenum, coords: ptr TGLuint) {.importc.} - proc glTexCoord3d(s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc.} - proc glDeleteProgramPipelines(n: TGLsizei, pipelines: ptr TGLuint) {.importc.} - proc glVertex2iv(v: ptr TGLint) {.importc.} - proc glGetMultisamplefv(pname: TGLenum, index: TGLuint, val: ptr TGLfloat) {.importc.} + proc glFramebufferTexture2DMultisampleEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, samples: GLsizei) {.importc.} + proc glVertexAttrib1dvARB(index: GLuint, v: ptr GLdouble) {.importc.} + proc glDrawRangeElementsBaseVertex(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei, `type`: GLenum, indices: pointer, basevertex: GLint) {.importc.} + proc glPixelMapfv(map: GLenum, mapsize: GLsizei, values: ptr GLfloat) {.importc.} + proc glPointParameterxOES(pname: GLenum, param: GLfixed) {.importc.} + proc glBindBufferRangeNV(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glDepthBoundsEXT(zmin: GLclampd, zmax: GLclampd) {.importc.} + proc glProgramUniformMatrix2dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glSecondaryColor3s(red: GLshort, green: GLshort, blue: GLshort) {.importc.} + proc glEdgeFlagPointerEXT(stride: GLsizei, count: GLsizei, `pointer`: ptr GLboolean) {.importc.} + proc glVertexStream1fATI(stream: GLenum, x: GLfloat) {.importc.} + proc glUniformui64NV(location: GLint, value: GLuint64EXT) {.importc.} + proc glTexCoordP4uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} + proc glTexCoord3d(s: GLdouble, t: GLdouble, r: GLdouble) {.importc.} + proc glDeleteProgramPipelines(n: GLsizei, pipelines: ptr GLuint) {.importc.} + proc glVertex2iv(v: ptr GLint) {.importc.} + proc glGetMultisamplefv(pname: GLenum, index: GLuint, val: ptr GLfloat) {.importc.} proc glStartInstrumentsSGIX() {.importc.} - proc glGetOcclusionQueryivNV(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glDebugMessageCallback(callback: TGLDEBUGPROC, userParam: ptr pointer) {.importc.} - proc glPixelZoomxOES(xfactor: TGLfixed, yfactor: TGLfixed) {.importc.} - proc glTexCoord3i(s: TGLint, t: TGLint, r: TGLint) {.importc.} - proc glEdgeFlagFormatNV(stride: TGLsizei) {.importc.} - proc glProgramUniform2i(program: TGLuint, location: TGLint, v0: TGLint, v1: TGLint) {.importc.} - proc glColor3b(red: TGLbyte, green: TGLbyte, blue: TGLbyte) {.importc.} - proc glDepthRangefOES(n: TGLclampf, f: TGLclampf) {.importc.} + proc glGetOcclusionQueryivNV(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glDebugMessageCallback(callback: GLDEBUGPROC, userParam: ptr pointer) {.importc.} + proc glPixelZoomxOES(xfactor: GLfixed, yfactor: GLfixed) {.importc.} + proc glTexCoord3i(s: GLint, t: GLint, r: GLint) {.importc.} + proc glEdgeFlagFormatNV(stride: GLsizei) {.importc.} + proc glProgramUniform2i(program: GLuint, location: GLint, v0: GLint, v1: GLint) {.importc.} + proc glColor3b(red: GLbyte, green: GLbyte, blue: GLbyte) {.importc.} + proc glDepthRangefOES(n: GLclampf, f: GLclampf) {.importc.} proc glEndVertexShaderEXT() {.importc.} - proc glBindVertexArrayAPPLE(`array`: TGLuint) {.importc.} - proc glColor4bv(v: ptr TGLbyte) {.importc.} - proc glNamedFramebufferTexture2DEXT(framebuffer: TGLuint, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glTexCoord1f(s: TGLfloat) {.importc.} - proc glUniform3fvARB(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glGetQueryObjectuivARB(id: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glVertexAttrib4bv(index: TGLuint, v: ptr TGLbyte) {.importc.} - proc glGetPixelTransformParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertexAttrib3svNV(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glDeleteQueriesEXT(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glUniform3ivARB(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glNormal3xvOES(coords: ptr TGLfixed) {.importc.} - proc glMatrixLoadfEXT(mode: TGLenum, m: ptr TGLfloat) {.importc.} - proc glGetNamedFramebufferAttachmentParameterivEXT(framebuffer: TGLuint, attachment: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glSeparableFilter2D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer) {.importc.} - proc glVertexAttribI3uiv(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glTextureStorageSparseAMD(texture: TGLuint, target: TGLenum, internalFormat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, layers: TGLsizei, flags: TGLbitfield) {.importc.} - proc glMultiDrawArraysIndirectCountARB(mode: TGLenum, indirect: TGLintptr, drawcount: TGLintptr, maxdrawcount: TGLsizei, stride: TGLsizei) {.importc.} - proc glTranslated(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glColorPointer(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glDrawElementsInstancedBaseVertex(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, instancecount: TGLsizei, basevertex: TGLint) {.importc.} - proc glBindAttribLocationARB(programObj: TGLhandleARB, index: TGLuint, name: ptr TGLcharARB) {.importc.} - proc glTexGendv(coord: TGLenum, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glGetPathCoordsNV(path: TGLuint, coords: ptr TGLfloat) {.importc.} - proc glGetMapParameterivNV(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glClientAttribDefaultEXT(mask: TGLbitfield) {.importc.} - proc glProgramUniformMatrix4x3fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glEnable(cap: TGLenum) {.importc.} - proc glGetVertexAttribPointervNV(index: TGLuint, pname: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glBindMultiTextureEXT(texunit: TGLenum, target: TGLenum, texture: TGLuint) {.importc.} - proc glGetConvolutionParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glLightModelxvOES(pname: TGLenum, param: ptr TGLfixed) {.importc.} - proc glMultiTexCoord4sv(target: TGLenum, v: ptr TGLshort) {.importc.} - proc glGetColorTableParameterivSGI(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glFramebufferTexture2DOES(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glClearDepthxOES(depth: TGLfixed) {.importc.} - proc glDisableClientStateiEXT(`array`: TGLenum, index: TGLuint) {.importc.} - proc glWindowPos2dARB(x: TGLdouble, y: TGLdouble) {.importc.} - proc glVertexAttrib1fvNV(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glDepthRangedNV(zNear: TGLdouble, zFar: TGLdouble) {.importc.} - proc glClear(mask: TGLbitfield) {.importc.} - proc glUnmapTexture2DINTEL(texture: TGLuint, level: TGLint) {.importc.} - proc glSecondaryColor3ub(red: TGLubyte, green: TGLubyte, blue: TGLubyte) {.importc.} - proc glVertexAttribI4bv(index: TGLuint, v: ptr TGLbyte) {.importc.} - proc glTexRenderbufferNV(target: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glColor4ubVertex3fvSUN(c: ptr TGLubyte, v: ptr TGLfloat) {.importc.} - proc glVertexAttrib2svNV(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glMultiTexCoord1ivARB(target: TGLenum, v: ptr TGLint) {.importc.} - proc glUniformMatrix3x2dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glVertexAttribL3dvEXT(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glMultiTexSubImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetBufferPointervARB(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} - proc glGetMultiTexLevelParameterfvEXT(texunit: TGLenum, target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glMultiTexParameterIuivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glGetShaderSource(shader: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, source: ptr TGLchar) {.importc.} - proc glStencilFunc(func: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} - proc glVertexAttribI4bvEXT(index: TGLuint, v: ptr TGLbyte) {.importc.} - proc glVertexAttrib4NuivARB(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glIsObjectBufferATI(buffer: TGLuint): TGLboolean {.importc.} - proc glRasterPos2xOES(x: TGLfixed, y: TGLfixed) {.importc.} - proc glIsFenceNV(fence: TGLuint): TGLboolean {.importc.} - proc glGetFramebufferParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glClearBufferfv(buffer: TGLenum, drawbuffer: TGLint, value: ptr TGLfloat) {.importc.} - proc glClearColorxOES(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} - proc glVertexWeightfEXT(weight: TGLfloat) {.importc.} - proc glExtIsProgramBinaryQCOM(program: TGLuint): TGLboolean {.importc.} - proc glTextureStorage2DMultisampleEXT(texture: TGLuint, target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} - proc glGetHistogramParameterxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glVertexAttrib4dNV(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glGetPerfMonitorCounterStringAMD(group: TGLuint, counter: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, counterString: ptr TGLchar) {.importc.} - proc glMultiTexCoord2sARB(target: TGLenum, s: TGLshort, t: TGLshort) {.importc.} - proc glSpriteParameterivSGIX(pname: TGLenum, params: ptr TGLint) {.importc.} - proc glCompressedTextureImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glBufferSubData(target: TGLenum, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} - proc glBlendParameteriNV(pname: TGLenum, value: TGLint) {.importc.} - proc glVertexAttrib2fvNV(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glGetVariantBooleanvEXT(id: TGLuint, value: TGLenum, data: ptr TGLboolean) {.importc.} - proc glProgramParameteri(program: TGLuint, pname: TGLenum, value: TGLint) {.importc.} - proc glGetLocalConstantIntegervEXT(id: TGLuint, value: TGLenum, data: ptr TGLint) {.importc.} - proc glFragmentMaterialiSGIX(face: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glGetNamedStringivARB(namelen: TGLint, name: ptr TGLchar, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glBinormal3ivEXT(v: ptr TGLint) {.importc.} - proc glCheckFramebufferStatusEXT(target: TGLenum): TGLenum {.importc.} - proc glVertexAttrib1fNV(index: TGLuint, x: TGLfloat) {.importc.} - proc glNamedRenderbufferStorageEXT(renderbuffer: TGLuint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glPresentFrameKeyedNV(video_slot: TGLuint, minPresentTime: TGLuint64EXT, beginPresentTimeId: TGLuint, presentDurationId: TGLuint, `type`: TGLenum, target0: TGLenum, fill0: TGLuint, key0: TGLuint, target1: TGLenum, fill1: TGLuint, key1: TGLuint) {.importc.} - proc glGetObjectParameterfvARB(obj: TGLhandleARB, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVertex3sv(v: ptr TGLshort) {.importc.} - proc glColor4s(red: TGLshort, green: TGLshort, blue: TGLshort, alpha: TGLshort) {.importc.} - proc glGetQueryObjecti64vEXT(id: TGLuint, pname: TGLenum, params: ptr TGLint64) {.importc.} - proc glEvalMesh2(mode: TGLenum, i1: TGLint, i2: TGLint, j1: TGLint, j2: TGLint) {.importc.} - proc glBeginTransformFeedbackEXT(primitiveMode: TGLenum) {.importc.} - proc glBufferAddressRangeNV(pname: TGLenum, index: TGLuint, address: TGLuint64EXT, length: TGLsizeiptr) {.importc.} - proc glPointParameterfvARB(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glGetActiveVaryingNV(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, size: ptr TGLsizei, `type`: ptr TGLenum, name: ptr TGLchar) {.importc.} - proc glIndexMask(mask: TGLuint) {.importc.} - proc glVertexAttribBinding(attribindex: TGLuint, bindingindex: TGLuint) {.importc.} - proc glDeleteFencesNV(n: TGLsizei, fences: ptr TGLuint) {.importc.} - proc glVertexAttribI4ubv(index: TGLuint, v: ptr TGLubyte) {.importc.} - proc glPathParameterfvNV(path: TGLuint, pname: TGLenum, value: ptr TGLfloat) {.importc.} - proc glVertexStream3fATI(stream: TGLenum, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glVertexAttribs4svNV(index: TGLuint, count: TGLsizei, v: ptr TGLshort) {.importc.} - proc glVertexAttrib4sNV(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glAlphaFragmentOp3ATI(op: TGLenum, dst: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint, arg3: TGLuint, arg3Rep: TGLuint, arg3Mod: TGLuint) {.importc.} - proc glGetHistogramParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVertexAttribL1ui64NV(index: TGLuint, x: TGLuint64EXT) {.importc.} - proc glVertexAttribs3fvNV(index: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} - proc glMultiTexCoord3ivARB(target: TGLenum, v: ptr TGLint) {.importc.} - proc glClipPlanefOES(plane: TGLenum, equation: ptr TGLfloat) {.importc.} - proc glVertex3s(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glVertex3dv(v: ptr TGLdouble) {.importc.} - proc glWeightPointerOES(size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glBindBufferBase(target: TGLenum, index: TGLuint, buffer: TGLuint) {.importc.} - proc glIndexs(c: TGLshort) {.importc.} - proc glTessellationFactorAMD(factor: TGLfloat) {.importc.} - proc glColor4ubVertex3fSUN(r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} + proc glBindVertexArrayAPPLE(`array`: GLuint) {.importc.} + proc glColor4bv(v: ptr GLbyte) {.importc.} + proc glNamedFramebufferTexture2DEXT(framebuffer: GLuint, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glTexCoord1f(s: GLfloat) {.importc.} + proc glUniform3fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetQueryObjectuivARB(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glVertexAttrib4bv(index: GLuint, v: ptr GLbyte) {.importc.} + proc glGetPixelTransformParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttrib3svNV(index: GLuint, v: ptr GLshort) {.importc.} + proc glDeleteQueriesEXT(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glUniform3ivARB(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glNormal3xvOES(coords: ptr GLfixed) {.importc.} + proc glMatrixLoadfEXT(mode: GLenum, m: ptr GLfloat) {.importc.} + proc glGetNamedFramebufferAttachmentParameterivEXT(framebuffer: GLuint, attachment: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glSeparableFilter2D(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, row: pointer, column: pointer) {.importc.} + proc glVertexAttribI3uiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glTextureStorageSparseAMD(texture: GLuint, target: GLenum, internalFormat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, layers: GLsizei, flags: GLbitfield) {.importc.} + proc glMultiDrawArraysIndirectCountARB(mode: GLenum, indirect: GLintptr, drawcount: GLintptr, maxdrawcount: GLsizei, stride: GLsizei) {.importc.} + proc glTranslated(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glColorPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glDrawElementsInstancedBaseVertex(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, instancecount: GLsizei, basevertex: GLint) {.importc.} + proc glBindAttribLocationARB(programObj: GLhandleARB, index: GLuint, name: ptr GLcharARB) {.importc.} + proc glTexGendv(coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glGetPathCoordsNV(path: GLuint, coords: ptr GLfloat) {.importc.} + proc glGetMapParameterivNV(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glClientAttribDefaultEXT(mask: GLbitfield) {.importc.} + proc glProgramUniformMatrix4x3fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glEnable(cap: GLenum) {.importc.} + proc glGetVertexAttribPointervNV(index: GLuint, pname: GLenum, `pointer`: ptr pointer) {.importc.} + proc glBindMultiTextureEXT(texunit: GLenum, target: GLenum, texture: GLuint) {.importc.} + proc glGetConvolutionParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glLightModelxvOES(pname: GLenum, param: ptr GLfixed) {.importc.} + proc glMultiTexCoord4sv(target: GLenum, v: ptr GLshort) {.importc.} + proc glGetColorTableParameterivSGI(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glFramebufferTexture2DOES(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glClearDepthxOES(depth: GLfixed) {.importc.} + proc glDisableClientStateiEXT(`array`: GLenum, index: GLuint) {.importc.} + proc glWindowPos2dARB(x: GLdouble, y: GLdouble) {.importc.} + proc glVertexAttrib1fvNV(index: GLuint, v: ptr GLfloat) {.importc.} + proc glDepthRangedNV(zNear: GLdouble, zFar: GLdouble) {.importc.} + proc glClear(mask: GLbitfield) {.importc.} + proc glUnmapTexture2DINTEL(texture: GLuint, level: GLint) {.importc.} + proc glSecondaryColor3ub(red: GLubyte, green: GLubyte, blue: GLubyte) {.importc.} + proc glVertexAttribI4bv(index: GLuint, v: ptr GLbyte) {.importc.} + proc glTexRenderbufferNV(target: GLenum, renderbuffer: GLuint) {.importc.} + proc glColor4ubVertex3fvSUN(c: ptr GLubyte, v: ptr GLfloat) {.importc.} + proc glVertexAttrib2svNV(index: GLuint, v: ptr GLshort) {.importc.} + proc glMultiTexCoord1ivARB(target: GLenum, v: ptr GLint) {.importc.} + proc glUniformMatrix3x2dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glVertexAttribL3dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} + proc glMultiTexSubImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetBufferPointervARB(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} + proc glGetMultiTexLevelParameterfvEXT(texunit: GLenum, target: GLenum, level: GLint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMultiTexParameterIuivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} + proc glGetShaderSource(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, source: ptr GLchar) {.importc.} + proc glStencilFunc(func: GLenum, `ref`: GLint, mask: GLuint) {.importc.} + proc glVertexAttribI4bvEXT(index: GLuint, v: ptr GLbyte) {.importc.} + proc glVertexAttrib4NuivARB(index: GLuint, v: ptr GLuint) {.importc.} + proc glIsObjectBufferATI(buffer: GLuint): TGLboolean {.importc.} + proc glRasterPos2xOES(x: GLfixed, y: GLfixed) {.importc.} + proc glIsFenceNV(fence: GLuint): TGLboolean {.importc.} + proc glGetFramebufferParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glClearBufferfv(buffer: GLenum, drawbuffer: GLint, value: ptr GLfloat) {.importc.} + proc glClearColorxOES(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glVertexWeightfEXT(weight: GLfloat) {.importc.} + proc glExtIsProgramBinaryQCOM(program: GLuint): TGLboolean {.importc.} + proc glTextureStorage2DMultisampleEXT(texture: GLuint, target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glGetHistogramParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glVertexAttrib4dNV(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glGetPerfMonitorCounterStringAMD(group: GLuint, counter: GLuint, bufSize: GLsizei, length: ptr GLsizei, counterString: ptr GLchar) {.importc.} + proc glMultiTexCoord2sARB(target: GLenum, s: GLshort, t: GLshort) {.importc.} + proc glSpriteParameterivSGIX(pname: GLenum, params: ptr GLint) {.importc.} + proc glCompressedTextureImage3DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glBufferSubData(target: GLenum, offset: GLintptr, size: GLsizeiptr, data: pointer) {.importc.} + proc glBlendParameteriNV(pname: GLenum, value: GLint) {.importc.} + proc glVertexAttrib2fvNV(index: GLuint, v: ptr GLfloat) {.importc.} + proc glGetVariantBooleanvEXT(id: GLuint, value: GLenum, data: ptr GLboolean) {.importc.} + proc glProgramParameteri(program: GLuint, pname: GLenum, value: GLint) {.importc.} + proc glGetLocalConstantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} + proc glFragmentMaterialiSGIX(face: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glGetNamedStringivARB(namelen: GLint, name: ptr GLchar, pname: GLenum, params: ptr GLint) {.importc.} + proc glBinormal3ivEXT(v: ptr GLint) {.importc.} + proc glCheckFramebufferStatusEXT(target: GLenum): TGLenum {.importc.} + proc glVertexAttrib1fNV(index: GLuint, x: GLfloat) {.importc.} + proc glNamedRenderbufferStorageEXT(renderbuffer: GLuint, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glPresentFrameKeyedNV(video_slot: GLuint, minPresentTime: GLuint64EXT, beginPresentTimeId: GLuint, presentDurationId: GLuint, `type`: GLenum, target0: GLenum, fill0: GLuint, key0: GLuint, target1: GLenum, fill1: GLuint, key1: GLuint) {.importc.} + proc glGetObjectParameterfvARB(obj: GLhandleARB, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertex3sv(v: ptr GLshort) {.importc.} + proc glColor4s(red: GLshort, green: GLshort, blue: GLshort, alpha: GLshort) {.importc.} + proc glGetQueryObjecti64vEXT(id: GLuint, pname: GLenum, params: ptr GLint64) {.importc.} + proc glEvalMesh2(mode: GLenum, i1: GLint, i2: GLint, j1: GLint, j2: GLint) {.importc.} + proc glBeginTransformFeedbackEXT(primitiveMode: GLenum) {.importc.} + proc glBufferAddressRangeNV(pname: GLenum, index: GLuint, address: GLuint64EXT, length: GLsizeiptr) {.importc.} + proc glPointParameterfvARB(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetActiveVaryingNV(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glIndexMask(mask: GLuint) {.importc.} + proc glVertexAttribBinding(attribindex: GLuint, bindingindex: GLuint) {.importc.} + proc glDeleteFencesNV(n: GLsizei, fences: ptr GLuint) {.importc.} + proc glVertexAttribI4ubv(index: GLuint, v: ptr GLubyte) {.importc.} + proc glPathParameterfvNV(path: GLuint, pname: GLenum, value: ptr GLfloat) {.importc.} + proc glVertexStream3fATI(stream: GLenum, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVertexAttribs4svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} + proc glVertexAttrib4sNV(index: GLuint, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glAlphaFragmentOp3ATI(op: GLenum, dst: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint, arg3: GLuint, arg3Rep: GLuint, arg3Mod: GLuint) {.importc.} + proc glGetHistogramParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttribL1ui64NV(index: GLuint, x: GLuint64EXT) {.importc.} + proc glVertexAttribs3fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glMultiTexCoord3ivARB(target: GLenum, v: ptr GLint) {.importc.} + proc glClipPlanefOES(plane: GLenum, equation: ptr GLfloat) {.importc.} + proc glVertex3s(x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glVertex3dv(v: ptr GLdouble) {.importc.} + proc glWeightPointerOES(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glBindBufferBase(target: GLenum, index: GLuint, buffer: GLuint) {.importc.} + proc glIndexs(c: GLshort) {.importc.} + proc glTessellationFactorAMD(factor: GLfloat) {.importc.} + proc glColor4ubVertex3fSUN(r: GLubyte, g: GLubyte, b: GLubyte, a: GLubyte, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glPauseTransformFeedback() {.importc.} - proc glImageTransformParameterivHP(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glColor3dv(v: ptr TGLdouble) {.importc.} - proc glRasterPos4sv(v: ptr TGLshort) {.importc.} - proc glInvalidateTexSubImage(texture: TGLuint, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} - proc glNormalStream3bvATI(stream: TGLenum, coords: ptr TGLbyte) {.importc.} - proc glUniformMatrix2x4fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glMinmax(target: TGLenum, internalformat: TGLenum, sink: TGLboolean) {.importc.} - proc glGetProgramStageiv(program: TGLuint, shadertype: TGLenum, pname: TGLenum, values: ptr TGLint) {.importc.} - proc glScalex(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glTexBufferARB(target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} - proc glDrawArraysIndirect(mode: TGLenum, indirect: pointer) {.importc.} - proc glMatrixLoadTransposefEXT(mode: TGLenum, m: ptr TGLfloat) {.importc.} - proc glMultiTexCoord2f(target: TGLenum, s: TGLfloat, t: TGLfloat) {.importc.} - proc glDrawRangeElements(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc.} - proc glVertexAttrib4NubARB(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc.} - proc glMultiTexCoord4xvOES(texture: TGLenum, coords: ptr TGLfixed) {.importc.} - proc glVertexArrayVertexAttribOffsetEXT(vaobj: TGLuint, buffer: TGLuint, index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glVertexAttribL1i64vNV(index: TGLuint, v: ptr TGLint64EXT) {.importc.} - proc glMapBuffer(target: TGLenum, access: TGLenum) {.importc.} - proc glUniform1ui(location: TGLint, v0: TGLuint) {.importc.} - proc glGetPixelMapfv(map: TGLenum, values: ptr TGLfloat) {.importc.} - proc glTexImage2DMultisampleCoverageNV(target: TGLenum, coverageSamples: TGLsizei, colorSamples: TGLsizei, internalFormat: TGLint, width: TGLsizei, height: TGLsizei, fixedSampleLocations: TGLboolean) {.importc.} - proc glUniform2ivARB(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glVertexAttribI3ui(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint) {.importc.} - proc glGetProgramResourceiv(program: TGLuint, programInterface: TGLenum, index: TGLuint, propCount: TGLsizei, props: ptr TGLenum, bufSize: TGLsizei, length: ptr TGLsizei, params: ptr TGLint) {.importc.} - proc glUniform4iv(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glVertexAttrib3f(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glClientActiveVertexStreamATI(stream: TGLenum) {.importc.} - proc glTexCoord4fColor4fNormal3fVertex4fvSUN(tc: ptr TGLfloat, c: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glColor3xvOES(components: ptr TGLfixed) {.importc.} - proc glVertexPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} - proc glProgramEnvParameter4dARB(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glGetLocalConstantFloatvEXT(id: TGLuint, value: TGLenum, data: ptr TGLfloat) {.importc.} - proc glTexCoordPointerEXT(size: TGLint, `type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} - proc glTexCoordPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glSelectPerfMonitorCountersAMD(monitor: TGLuint, enable: TGLboolean, group: TGLuint, numCounters: TGLint, counterList: ptr TGLuint) {.importc.} - proc glVertexStream4svATI(stream: TGLenum, coords: ptr TGLshort) {.importc.} - proc glColor3ui(red: TGLuint, green: TGLuint, blue: TGLuint) {.importc.} - proc glBindTransformFeedbackNV(target: TGLenum, id: TGLuint) {.importc.} - proc glDeformSGIX(mask: TGLbitfield) {.importc.} - proc glDeformationMap3fSGIX(target: TGLenum, u1: TGLfloat, u2: TGLfloat, ustride: TGLint, uorder: TGLint, v1: TGLfloat, v2: TGLfloat, vstride: TGLint, vorder: TGLint, w1: TGLfloat, w2: TGLfloat, wstride: TGLint, worder: TGLint, points: ptr TGLfloat) {.importc.} - proc glNamedBufferSubDataEXT(buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr, data: pointer) {.importc.} - proc glGetNamedProgramStringEXT(program: TGLuint, target: TGLenum, pname: TGLenum, string: pointer) {.importc.} - proc glCopyPathNV(resultPath: TGLuint, srcPath: TGLuint) {.importc.} - proc glMapControlPointsNV(target: TGLenum, index: TGLuint, `type`: TGLenum, ustride: TGLsizei, vstride: TGLsizei, uorder: TGLint, vorder: TGLint, packed: TGLboolean, points: pointer) {.importc.} - proc glGetBufferParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glUnmapObjectBufferATI(buffer: TGLuint) {.importc.} - proc glGetProgramResourceLocation(program: TGLuint, programInterface: TGLenum, name: ptr TGLchar): TGLint {.importc.} - proc glUniform4i64vNV(location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} - proc glImageTransformParameterfHP(target: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glArrayObjectATI(`array`: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, buffer: TGLuint, offset: TGLuint) {.importc.} - proc glBindBufferRangeEXT(target: TGLenum, index: TGLuint, buffer: TGLuint, offset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glVertexArrayVertexAttribFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, relativeoffset: TGLuint) {.importc.} - proc glBindRenderbufferEXT(target: TGLenum, renderbuffer: TGLuint) {.importc.} - proc glListParameteriSGIX(list: TGLuint, pname: TGLenum, param: TGLint) {.importc.} - proc glProgramUniformMatrix2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glProgramUniform2i64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} - proc glObjectPtrLabelKHR(`ptr`: ptr pointer, length: TGLsizei, label: ptr TGLchar) {.importc.} - proc glVertexAttribL1i64NV(index: TGLuint, x: TGLint64EXT) {.importc.} - proc glMultiTexBufferEXT(texunit: TGLenum, target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} - proc glCoverFillPathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, coverMode: TGLenum, transformType: TGLenum, transformValues: ptr TGLfloat) {.importc.} - proc glGetVertexAttribIivEXT(index: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glLightf(light: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glGetMinmaxParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glUniform1d(location: TGLint, x: TGLdouble) {.importc.} - proc glLightiv(light: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertexAttrib2dvNV(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glNormalP3ui(`type`: TGLenum, coords: TGLuint) {.importc.} - proc glFinalCombinerInputNV(variable: TGLenum, input: TGLenum, mapping: TGLenum, componentUsage: TGLenum) {.importc.} - proc glUniform1uiv(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glValidateProgramARB(programObj: TGLhandleARB) {.importc.} - proc glNormalPointer(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glProgramNamedParameter4fvNV(id: TGLuint, len: TGLsizei, name: ptr TGLubyte, v: ptr TGLfloat) {.importc.} - proc glGetBooleanv(pname: TGLenum, params: ptr TGLboolean) {.importc.} - proc glTangent3ivEXT(v: ptr TGLint) {.importc.} - proc glTexImage3DMultisample(target: TGLenum, samples: TGLsizei, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, fixedsamplelocations: TGLboolean) {.importc.} - proc glGetUniformIndices(program: TGLuint, uniformCount: TGLsizei, uniformNames: ptr ptr TGLchar, uniformIndices: ptr TGLuint) {.importc.} + proc glImageTransformParameterivHP(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glColor3dv(v: ptr GLdouble) {.importc.} + proc glRasterPos4sv(v: ptr GLshort) {.importc.} + proc glInvalidateTexSubImage(texture: GLuint, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} + proc glNormalStream3bvATI(stream: GLenum, coords: ptr GLbyte) {.importc.} + proc glUniformMatrix2x4fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glMinmax(target: GLenum, internalformat: GLenum, sink: GLboolean) {.importc.} + proc glGetProgramStageiv(program: GLuint, shadertype: GLenum, pname: GLenum, values: ptr GLint) {.importc.} + proc glScalex(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glTexBufferARB(target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} + proc glDrawArraysIndirect(mode: GLenum, indirect: pointer) {.importc.} + proc glMatrixLoadTransposefEXT(mode: GLenum, m: ptr GLfloat) {.importc.} + proc glMultiTexCoord2f(target: GLenum, s: GLfloat, t: GLfloat) {.importc.} + proc glDrawRangeElements(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei, `type`: GLenum, indices: pointer) {.importc.} + proc glVertexAttrib4NubARB(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, w: GLubyte) {.importc.} + proc glMultiTexCoord4xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} + proc glVertexArrayVertexAttribOffsetEXT(vaobj: GLuint, buffer: GLuint, index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr) {.importc.} + proc glVertexAttribL1i64vNV(index: GLuint, v: ptr GLint64EXT) {.importc.} + proc glMapBuffer(target: GLenum, access: GLenum) {.importc.} + proc glUniform1ui(location: GLint, v0: GLuint) {.importc.} + proc glGetPixelMapfv(map: GLenum, values: ptr GLfloat) {.importc.} + proc glTexImage2DMultisampleCoverageNV(target: GLenum, coverageSamples: GLsizei, colorSamples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, fixedSampleLocations: GLboolean) {.importc.} + proc glUniform2ivARB(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glVertexAttribI3ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint) {.importc.} + proc glGetProgramResourceiv(program: GLuint, programInterface: GLenum, index: GLuint, propCount: GLsizei, props: ptr GLenum, bufSize: GLsizei, length: ptr GLsizei, params: ptr GLint) {.importc.} + proc glUniform4iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glVertexAttrib3f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glClientActiveVertexStreamATI(stream: GLenum) {.importc.} + proc glTexCoord4fColor4fNormal3fVertex4fvSUN(tc: ptr GLfloat, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glColor3xvOES(components: ptr GLfixed) {.importc.} + proc glVertexPointerListIBM(size: GLint, `type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glProgramEnvParameter4dARB(target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glGetLocalConstantFloatvEXT(id: GLuint, value: GLenum, data: ptr GLfloat) {.importc.} + proc glTexCoordPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, count: GLsizei, `pointer`: pointer) {.importc.} + proc glTexCoordPointervINTEL(size: GLint, `type`: GLenum, `pointer`: ptr pointer) {.importc.} + proc glSelectPerfMonitorCountersAMD(monitor: GLuint, enable: GLboolean, group: GLuint, numCounters: GLint, counterList: ptr GLuint) {.importc.} + proc glVertexStream4svATI(stream: GLenum, coords: ptr GLshort) {.importc.} + proc glColor3ui(red: GLuint, green: GLuint, blue: GLuint) {.importc.} + proc glBindTransformFeedbackNV(target: GLenum, id: GLuint) {.importc.} + proc glDeformSGIX(mask: GLbitfield) {.importc.} + proc glDeformationMap3fSGIX(target: GLenum, u1: GLfloat, u2: GLfloat, ustride: GLint, uorder: GLint, v1: GLfloat, v2: GLfloat, vstride: GLint, vorder: GLint, w1: GLfloat, w2: GLfloat, wstride: GLint, worder: GLint, points: ptr GLfloat) {.importc.} + proc glNamedBufferSubDataEXT(buffer: GLuint, offset: GLintptr, size: GLsizeiptr, data: pointer) {.importc.} + proc glGetNamedProgramStringEXT(program: GLuint, target: GLenum, pname: GLenum, string: pointer) {.importc.} + proc glCopyPathNV(resultPath: GLuint, srcPath: GLuint) {.importc.} + proc glMapControlPointsNV(target: GLenum, index: GLuint, `type`: GLenum, ustride: GLsizei, vstride: GLsizei, uorder: GLint, vorder: GLint, packed: GLboolean, points: pointer) {.importc.} + proc glGetBufferParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glUnmapObjectBufferATI(buffer: GLuint) {.importc.} + proc glGetProgramResourceLocation(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLint {.importc.} + proc glUniform4i64vNV(location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} + proc glImageTransformParameterfHP(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glArrayObjectATI(`array`: GLenum, size: GLint, `type`: GLenum, stride: GLsizei, buffer: GLuint, offset: GLuint) {.importc.} + proc glBindBufferRangeEXT(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr, size: GLsizeiptr) {.importc.} + proc glVertexArrayVertexAttribFormatEXT(vaobj: GLuint, attribindex: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, relativeoffset: GLuint) {.importc.} + proc glBindRenderbufferEXT(target: GLenum, renderbuffer: GLuint) {.importc.} + proc glListParameteriSGIX(list: GLuint, pname: GLenum, param: GLint) {.importc.} + proc glProgramUniformMatrix2dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glProgramUniform2i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} + proc glObjectPtrLabelKHR(`ptr`: ptr pointer, length: GLsizei, label: ptr GLchar) {.importc.} + proc glVertexAttribL1i64NV(index: GLuint, x: GLint64EXT) {.importc.} + proc glMultiTexBufferEXT(texunit: GLenum, target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} + proc glCoverFillPathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, coverMode: GLenum, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} + proc glGetVertexAttribIivEXT(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glLightf(light: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glGetMinmaxParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glUniform1d(location: GLint, x: GLdouble) {.importc.} + proc glLightiv(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttrib2dvNV(index: GLuint, v: ptr GLdouble) {.importc.} + proc glNormalP3ui(`type`: GLenum, coords: GLuint) {.importc.} + proc glFinalCombinerInputNV(variable: GLenum, input: GLenum, mapping: GLenum, componentUsage: GLenum) {.importc.} + proc glUniform1uiv(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glValidateProgramARB(programObj: GLhandleARB) {.importc.} + proc glNormalPointer(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glProgramNamedParameter4fvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, v: ptr GLfloat) {.importc.} + proc glGetBooleanv(pname: GLenum, params: ptr GLboolean) {.importc.} + proc glTangent3ivEXT(v: ptr GLint) {.importc.} + proc glTexImage3DMultisample(target: GLenum, samples: GLsizei, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedsamplelocations: GLboolean) {.importc.} + proc glGetUniformIndices(program: GLuint, uniformCount: GLsizei, uniformNames: ptr ptr GLchar, uniformIndices: ptr GLuint) {.importc.} proc glVDPAUInitNV(vdpDevice: pointer, getProcAddress: pointer) {.importc.} - proc glGetMinmaxParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glMultiTexCoord2fvARB(target: TGLenum, v: ptr TGLfloat) {.importc.} - proc glProgramEnvParametersI4ivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLint) {.importc.} - proc glClearTexSubImage(texture: TGLuint, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, data: ptr pointer) {.importc.} - proc glRectxOES(x1: TGLfixed, y1: TGLfixed, x2: TGLfixed, y2: TGLfixed) {.importc.} - proc glBlendEquationOES(mode: TGLenum) {.importc.} - proc glFramebufferTexture(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} + proc glGetMinmaxParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoord2fvARB(target: GLenum, v: ptr GLfloat) {.importc.} + proc glProgramEnvParametersI4ivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLint) {.importc.} + proc glClearTexSubImage(texture: GLuint, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, data: ptr pointer) {.importc.} + proc glRectxOES(x1: GLfixed, y1: GLfixed, x2: GLfixed, y2: GLfixed) {.importc.} + proc glBlendEquationOES(mode: GLenum) {.importc.} + proc glFramebufferTexture(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint) {.importc.} proc glGetInstrumentsSGIX(): TGLint {.importc.} - proc glFramebufferParameteri(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glPathCoverDepthFuncNV(func: TGLenum) {.importc.} - proc glGetTranslatedShaderSourceANGLE(shader: TGLuint, bufsize: TGLsizei, length: ptr TGLsizei, source: ptr TGLchar) {.importc.} - proc glIndexfv(c: ptr TGLfloat) {.importc.} - proc glGetActiveUniformBlockName(program: TGLuint, uniformBlockIndex: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, uniformBlockName: ptr TGLchar) {.importc.} - proc glNormal3s(nx: TGLshort, ny: TGLshort, nz: TGLshort) {.importc.} - proc glColorFragmentOp3ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint, arg3: TGLuint, arg3Rep: TGLuint, arg3Mod: TGLuint) {.importc.} - proc glGetProgramResourceLocationIndex(program: TGLuint, programInterface: TGLenum, name: ptr TGLchar): TGLint {.importc.} - proc glGetBooleanIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr TGLboolean) {.importc.} - proc glGenPerfMonitorsAMD(n: TGLsizei, monitors: ptr TGLuint) {.importc.} - proc glDrawRangeElementsEXT(mode: TGLenum, start: TGLuint, `end`: TGLuint, count: TGLsizei, `type`: TGLenum, indices: pointer) {.importc.} - proc glFramebufferTexture3D(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} - proc glGetTexParameterxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glCompileShaderIncludeARB(shader: TGLuint, count: TGLsizei, path: ptr ptr TGLchar, length: ptr TGLint) {.importc.} - proc glGetMultiTexParameterfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glEvalPoint2(i: TGLint, j: TGLint) {.importc.} - proc glGetProgramivNV(id: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glProgramParameter4fNV(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} - proc glMultiTexParameterfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVertexAttrib3svARB(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glDrawElementArrayAPPLE(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc.} - proc glMultiTexCoord4x(texture: TGLenum, s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc.} - proc glUniformMatrix3dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glVertexAttribPointerARB(index: TGLuint, size: TGLint, `type`: TGLenum, normalized: TGLboolean, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glProgramUniformMatrix3x4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glGetFloati_vEXT(pname: TGLenum, index: TGLuint, params: ptr TGLfloat) {.importc.} - proc glGetObjectParameterivAPPLE(objectType: TGLenum, name: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glPushGroupMarkerEXT(length: TGLsizei, marker: ptr TGLchar) {.importc.} - proc glProgramUniform4uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glReplacementCodeuiVertex3fSUN(rc: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glTexSubImage1DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, width: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glProgramUniform1uivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glGetFenceivNV(fence: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetnCompressedTexImageARB(target: TGLenum, lod: TGLint, bufSize: TGLsizei, img: pointer) {.importc.} - proc glTexGenfOES(coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glVertexAttrib4dv(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glVertexAttribL1ui64vNV(index: TGLuint, v: ptr TGLuint64EXT) {.importc.} - proc glVertexAttrib4fvARB(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glDeleteVertexArraysOES(n: TGLsizei, arrays: ptr TGLuint) {.importc.} - proc glSamplerParameterIiv(sampler: TGLuint, pname: TGLenum, param: ptr TGLint) {.importc.} - proc glMapGrid1d(un: TGLint, u1: TGLdouble, u2: TGLdouble) {.importc.} - proc glTranslatexOES(x: TGLfixed, y: TGLfixed, z: TGLfixed) {.importc.} - proc glCullFace(mode: TGLenum) {.importc.} - proc glPrioritizeTextures(n: TGLsizei, textures: ptr TGLuint, priorities: ptr TGLfloat) {.importc.} - proc glGetSeparableFilterEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, row: pointer, column: pointer, span: pointer) {.importc.} - proc glVertexAttrib4NubvARB(index: TGLuint, v: ptr TGLubyte) {.importc.} - proc glGetTransformFeedbackVaryingNV(program: TGLuint, index: TGLuint, location: ptr TGLint) {.importc.} - proc glTexCoord4xOES(s: TGLfixed, t: TGLfixed, r: TGLfixed, q: TGLfixed) {.importc.} - proc glGetProgramEnvParameterdvARB(target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} - proc glWindowPos2ivMESA(v: ptr TGLint) {.importc.} - proc glGlobalAlphaFactorfSUN(factor: TGLfloat) {.importc.} - proc glNormalStream3fvATI(stream: TGLenum, coords: ptr TGLfloat) {.importc.} - proc glRasterPos4i(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} + proc glFramebufferParameteri(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glPathCoverDepthFuncNV(func: GLenum) {.importc.} + proc glGetTranslatedShaderSourceANGLE(shader: GLuint, bufsize: GLsizei, length: ptr GLsizei, source: ptr GLchar) {.importc.} + proc glIndexfv(c: ptr GLfloat) {.importc.} + proc glGetActiveUniformBlockName(program: GLuint, uniformBlockIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformBlockName: ptr GLchar) {.importc.} + proc glNormal3s(nx: GLshort, ny: GLshort, nz: GLshort) {.importc.} + proc glColorFragmentOp3ATI(op: GLenum, dst: GLuint, dstMask: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint, arg3: GLuint, arg3Rep: GLuint, arg3Mod: GLuint) {.importc.} + proc glGetProgramResourceLocationIndex(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLint {.importc.} + proc glGetBooleanIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLboolean) {.importc.} + proc glGenPerfMonitorsAMD(n: GLsizei, monitors: ptr GLuint) {.importc.} + proc glDrawRangeElementsEXT(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei, `type`: GLenum, indices: pointer) {.importc.} + proc glFramebufferTexture3D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} + proc glGetTexParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glCompileShaderIncludeARB(shader: GLuint, count: GLsizei, path: ptr ptr GLchar, length: ptr GLint) {.importc.} + proc glGetMultiTexParameterfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glEvalPoint2(i: GLint, j: GLint) {.importc.} + proc glGetProgramivNV(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramParameter4fNV(target: GLenum, index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} + proc glMultiTexParameterfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttrib3svARB(index: GLuint, v: ptr GLshort) {.importc.} + proc glDrawElementArrayAPPLE(mode: GLenum, first: GLint, count: GLsizei) {.importc.} + proc glMultiTexCoord4x(texture: GLenum, s: GLfixed, t: GLfixed, r: GLfixed, q: GLfixed) {.importc.} + proc glUniformMatrix3dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glVertexAttribPointerARB(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glProgramUniformMatrix3x4dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glGetFloati_vEXT(pname: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} + proc glGetObjectParameterivAPPLE(objectType: GLenum, name: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glPushGroupMarkerEXT(length: GLsizei, marker: ptr GLchar) {.importc.} + proc glProgramUniform4uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glReplacementCodeuiVertex3fSUN(rc: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glTexSubImage1DEXT(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glProgramUniform1uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glGetFenceivNV(fence: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetnCompressedTexImageARB(target: GLenum, lod: GLint, bufSize: GLsizei, img: pointer) {.importc.} + proc glTexGenfOES(coord: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glVertexAttrib4dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glVertexAttribL1ui64vNV(index: GLuint, v: ptr GLuint64EXT) {.importc.} + proc glVertexAttrib4fvARB(index: GLuint, v: ptr GLfloat) {.importc.} + proc glDeleteVertexArraysOES(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glSamplerParameterIiv(sampler: GLuint, pname: GLenum, param: ptr GLint) {.importc.} + proc glMapGrid1d(un: GLint, u1: GLdouble, u2: GLdouble) {.importc.} + proc glTranslatexOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} + proc glCullFace(mode: GLenum) {.importc.} + proc glPrioritizeTextures(n: GLsizei, textures: ptr GLuint, priorities: ptr GLfloat) {.importc.} + proc glGetSeparableFilterEXT(target: GLenum, format: GLenum, `type`: GLenum, row: pointer, column: pointer, span: pointer) {.importc.} + proc glVertexAttrib4NubvARB(index: GLuint, v: ptr GLubyte) {.importc.} + proc glGetTransformFeedbackVaryingNV(program: GLuint, index: GLuint, location: ptr GLint) {.importc.} + proc glTexCoord4xOES(s: GLfixed, t: GLfixed, r: GLfixed, q: GLfixed) {.importc.} + proc glGetProgramEnvParameterdvARB(target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glWindowPos2ivMESA(v: ptr GLint) {.importc.} + proc glGlobalAlphaFactorfSUN(factor: GLfloat) {.importc.} + proc glNormalStream3fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} + proc glRasterPos4i(x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} proc glReleaseShaderCompiler() {.importc.} - proc glProgramUniformMatrix4fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glCopyMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} - proc glColorTableParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glSecondaryColor3bvEXT(v: ptr TGLbyte) {.importc.} - proc glMap1xOES(target: TGLenum, u1: TGLfixed, u2: TGLfixed, stride: TGLint, order: TGLint, points: TGLfixed) {.importc.} - proc glVertexStream1svATI(stream: TGLenum, coords: ptr TGLshort) {.importc.} - proc glIsRenderbuffer(renderbuffer: TGLuint): TGLboolean {.importc.} - proc glPatchParameterfv(pname: TGLenum, values: ptr TGLfloat) {.importc.} - proc glProgramUniformMatrix4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glVertexAttrib4ubNV(index: TGLuint, x: TGLubyte, y: TGLubyte, z: TGLubyte, w: TGLubyte) {.importc.} - proc glVertex2i(x: TGLint, y: TGLint) {.importc.} - proc glPushClientAttrib(mask: TGLbitfield) {.importc.} - proc glDrawArraysEXT(mode: TGLenum, first: TGLint, count: TGLsizei) {.importc.} + proc glProgramUniformMatrix4fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glCopyMultiTexImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, border: GLint) {.importc.} + proc glColorTableParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glSecondaryColor3bvEXT(v: ptr GLbyte) {.importc.} + proc glMap1xOES(target: GLenum, u1: GLfixed, u2: GLfixed, stride: GLint, order: GLint, points: GLfixed) {.importc.} + proc glVertexStream1svATI(stream: GLenum, coords: ptr GLshort) {.importc.} + proc glIsRenderbuffer(renderbuffer: GLuint): TGLboolean {.importc.} + proc glPatchParameterfv(pname: GLenum, values: ptr GLfloat) {.importc.} + proc glProgramUniformMatrix4dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glVertexAttrib4ubNV(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, w: GLubyte) {.importc.} + proc glVertex2i(x: GLint, y: GLint) {.importc.} + proc glPushClientAttrib(mask: GLbitfield) {.importc.} + proc glDrawArraysEXT(mode: GLenum, first: GLint, count: GLsizei) {.importc.} proc glCreateProgram(): TGLuint {.importc.} - proc glPolygonStipple(mask: ptr TGLubyte) {.importc.} - proc glGetColorTableEXT(target: TGLenum, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} - proc glSharpenTexFuncSGIS(target: TGLenum, n: TGLsizei, points: ptr TGLfloat) {.importc.} - proc glNamedFramebufferTextureEXT(framebuffer: TGLuint, attachment: TGLenum, texture: TGLuint, level: TGLint) {.importc.} - proc glWindowPos3fvMESA(v: ptr TGLfloat) {.importc.} - proc glBinormal3iEXT(bx: TGLint, by: TGLint, bz: TGLint) {.importc.} - proc glEnableClientStateiEXT(`array`: TGLenum, index: TGLuint) {.importc.} - proc glProgramUniform3iv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glProgramUniform1dEXT(program: TGLuint, location: TGLint, x: TGLdouble) {.importc.} - proc glPollInstrumentsSGIX(marker_p: ptr TGLint): TGLint {.importc.} - proc glSecondaryColor3f(red: TGLfloat, green: TGLfloat, blue: TGLfloat) {.importc.} - proc glDeleteTransformFeedbacks(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glCoverStrokePathInstancedNV(numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, coverMode: TGLenum, transformType: TGLenum, transformValues: ptr TGLfloat) {.importc.} - proc glIsTextureHandleResidentARB(handle: TGLuint64): TGLboolean {.importc.} - proc glVariantsvEXT(id: TGLuint, `addr`: ptr TGLshort) {.importc.} - proc glTexCoordFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} - proc glTexStorage3DEXT(target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} - proc glUniform2ui(location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} - proc glReplacementCodePointerSUN(`type`: TGLenum, stride: TGLsizei, `pointer`: ptr pointer) {.importc.} - proc glFramebufferTextureLayerARB(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, layer: TGLint) {.importc.} - proc glBinormal3dvEXT(v: ptr TGLdouble) {.importc.} - proc glProgramUniform2ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} - proc glGetnConvolutionFilterARB(target: TGLenum, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, image: pointer) {.importc.} - proc glStopInstrumentsSGIX(marker: TGLint) {.importc.} - proc glVertexAttrib1svNV(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glVertexAttribs2fvNV(index: TGLuint, count: TGLsizei, v: ptr TGLfloat) {.importc.} - proc glGetInternalformativ(target: TGLenum, internalformat: TGLenum, pname: TGLenum, bufSize: TGLsizei, params: ptr TGLint) {.importc.} - proc glIsProgramPipelineEXT(pipeline: TGLuint): TGLboolean {.importc.} - proc glMatrixIndexubvARB(size: TGLint, indices: ptr TGLubyte) {.importc.} - proc glTexCoord4bOES(s: TGLbyte, t: TGLbyte, r: TGLbyte, q: TGLbyte) {.importc.} - proc glSecondaryColor3us(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc.} - proc glGlobalAlphaFactorubSUN(factor: TGLubyte) {.importc.} - proc glNamedStringARB(`type`: TGLenum, namelen: TGLint, name: ptr TGLchar, stringlen: TGLint, string: ptr TGLchar) {.importc.} - proc glGetAttachedShaders(program: TGLuint, maxCount: TGLsizei, count: ptr TGLsizei, shaders: ptr TGLuint) {.importc.} - proc glMatrixRotatefEXT(mode: TGLenum, angle: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glVertexStream3ivATI(stream: TGLenum, coords: ptr TGLint) {.importc.} - proc glMatrixIndexuivARB(size: TGLint, indices: ptr TGLuint) {.importc.} - proc glMatrixRotatedEXT(mode: TGLenum, angle: TGLdouble, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glPathFogGenNV(genMode: TGLenum) {.importc.} - proc glMultiTexCoord4hvNV(target: TGLenum, v: ptr TGLhalfNV) {.importc.} - proc glVertexAttribIPointer(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glMultiTexCoord3bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte, r: TGLbyte) {.importc.} + proc glPolygonStipple(mask: ptr GLubyte) {.importc.} + proc glGetColorTableEXT(target: GLenum, format: GLenum, `type`: GLenum, data: pointer) {.importc.} + proc glSharpenTexFuncSGIS(target: GLenum, n: GLsizei, points: ptr GLfloat) {.importc.} + proc glNamedFramebufferTextureEXT(framebuffer: GLuint, attachment: GLenum, texture: GLuint, level: GLint) {.importc.} + proc glWindowPos3fvMESA(v: ptr GLfloat) {.importc.} + proc glBinormal3iEXT(bx: GLint, by: GLint, bz: GLint) {.importc.} + proc glEnableClientStateiEXT(`array`: GLenum, index: GLuint) {.importc.} + proc glProgramUniform3iv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glProgramUniform1dEXT(program: GLuint, location: GLint, x: GLdouble) {.importc.} + proc glPollInstrumentsSGIX(marker_p: ptr GLint): TGLint {.importc.} + proc glSecondaryColor3f(red: GLfloat, green: GLfloat, blue: GLfloat) {.importc.} + proc glDeleteTransformFeedbacks(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glCoverStrokePathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, coverMode: GLenum, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} + proc glIsTextureHandleResidentARB(handle: GLuint64): TGLboolean {.importc.} + proc glVariantsvEXT(id: GLuint, `addr`: ptr GLshort) {.importc.} + proc glTexCoordFormatNV(size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glTexStorage3DEXT(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} + proc glUniform2ui(location: GLint, v0: GLuint, v1: GLuint) {.importc.} + proc glReplacementCodePointerSUN(`type`: GLenum, stride: GLsizei, `pointer`: ptr pointer) {.importc.} + proc glFramebufferTextureLayerARB(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint, layer: GLint) {.importc.} + proc glBinormal3dvEXT(v: ptr GLdouble) {.importc.} + proc glProgramUniform2ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} + proc glGetnConvolutionFilterARB(target: GLenum, format: GLenum, `type`: GLenum, bufSize: GLsizei, image: pointer) {.importc.} + proc glStopInstrumentsSGIX(marker: GLint) {.importc.} + proc glVertexAttrib1svNV(index: GLuint, v: ptr GLshort) {.importc.} + proc glVertexAttribs2fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} + proc glGetInternalformativ(target: GLenum, internalformat: GLenum, pname: GLenum, bufSize: GLsizei, params: ptr GLint) {.importc.} + proc glIsProgramPipelineEXT(pipeline: GLuint): TGLboolean {.importc.} + proc glMatrixIndexubvARB(size: GLint, indices: ptr GLubyte) {.importc.} + proc glTexCoord4bOES(s: GLbyte, t: GLbyte, r: GLbyte, q: GLbyte) {.importc.} + proc glSecondaryColor3us(red: GLushort, green: GLushort, blue: GLushort) {.importc.} + proc glGlobalAlphaFactorubSUN(factor: GLubyte) {.importc.} + proc glNamedStringARB(`type`: GLenum, namelen: GLint, name: ptr GLchar, stringlen: GLint, string: ptr GLchar) {.importc.} + proc glGetAttachedShaders(program: GLuint, maxCount: GLsizei, count: ptr GLsizei, shaders: ptr GLuint) {.importc.} + proc glMatrixRotatefEXT(mode: GLenum, angle: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVertexStream3ivATI(stream: GLenum, coords: ptr GLint) {.importc.} + proc glMatrixIndexuivARB(size: GLint, indices: ptr GLuint) {.importc.} + proc glMatrixRotatedEXT(mode: GLenum, angle: GLdouble, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glPathFogGenNV(genMode: GLenum) {.importc.} + proc glMultiTexCoord4hvNV(target: GLenum, v: ptr GLhalfNV) {.importc.} + proc glVertexAttribIPointer(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glMultiTexCoord3bOES(texture: GLenum, s: GLbyte, t: GLbyte, r: GLbyte) {.importc.} proc glResizeBuffersMESA() {.importc.} - proc glPrimitiveRestartIndexNV(index: TGLuint) {.importc.} - proc glProgramUniform4f(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} - proc glColor4ubVertex2fSUN(r: TGLubyte, g: TGLubyte, b: TGLubyte, a: TGLubyte, x: TGLfloat, y: TGLfloat) {.importc.} - proc glGetColorTableParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glDepthRangef(n: TGLfloat, f: TGLfloat) {.importc.} - proc glVertexArrayVertexOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glMatrixLoaddEXT(mode: TGLenum, m: ptr TGLdouble) {.importc.} - proc glVariantfvEXT(id: TGLuint, `addr`: ptr TGLfloat) {.importc.} - proc glReplacementCodeuiTexCoord2fVertex3fvSUN(rc: ptr TGLuint, tc: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glSamplePatternSGIS(pattern: TGLenum) {.importc.} - proc glProgramUniform3i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc.} - proc glUniform3uivEXT(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glGetImageTransformParameterivHP(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glPrimitiveRestartIndexNV(index: GLuint) {.importc.} + proc glProgramUniform4f(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat, v3: GLfloat) {.importc.} + proc glColor4ubVertex2fSUN(r: GLubyte, g: GLubyte, b: GLubyte, a: GLubyte, x: GLfloat, y: GLfloat) {.importc.} + proc glGetColorTableParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glDepthRangef(n: GLfloat, f: GLfloat) {.importc.} + proc glVertexArrayVertexOffsetEXT(vaobj: GLuint, buffer: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glMatrixLoaddEXT(mode: GLenum, m: ptr GLdouble) {.importc.} + proc glVariantfvEXT(id: GLuint, `addr`: ptr GLfloat) {.importc.} + proc glReplacementCodeuiTexCoord2fVertex3fvSUN(rc: ptr GLuint, tc: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glSamplePatternSGIS(pattern: GLenum) {.importc.} + proc glProgramUniform3i64NV(program: GLuint, location: GLint, x: GLint64EXT, y: GLint64EXT, z: GLint64EXT) {.importc.} + proc glUniform3uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glGetImageTransformParameterivHP(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glPopMatrix() {.importc.} - proc glVertexAttrib3sARB(index: TGLuint, x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glGenQueriesEXT(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glGetQueryObjectui64v(id: TGLuint, pname: TGLenum, params: ptr TGLuint64) {.importc.} - proc glWeightusvARB(size: TGLint, weights: ptr TGLushort) {.importc.} - proc glWindowPos2sARB(x: TGLshort, y: TGLshort) {.importc.} - proc glGetTextureLevelParameterivEXT(texture: TGLuint, target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glBufferParameteriAPPLE(target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glMultiModeDrawArraysIBM(mode: ptr TGLenum, first: ptr TGLint, count: ptr TGLsizei, primcount: TGLsizei, modestride: TGLint) {.importc.} - proc glUniformMatrix2x3fv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLfloat) {.importc.} - proc glTangentPointerEXT(`type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glResetMinmax(target: TGLenum) {.importc.} - proc glVertexAttribP1uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: ptr TGLuint) {.importc.} - proc glPixelMapx(map: TGLenum, size: TGLint, values: ptr TGLfixed) {.importc.} - proc glPixelStoref(pname: TGLenum, param: TGLfloat) {.importc.} - proc glBinormal3dEXT(bx: TGLdouble, by: TGLdouble, bz: TGLdouble) {.importc.} - proc glVertexAttribs1hvNV(index: TGLuint, n: TGLsizei, v: ptr TGLhalfNV) {.importc.} - proc glVertexAttrib4usvARB(index: TGLuint, v: ptr TGLushort) {.importc.} - proc glUnmapBuffer(target: TGLenum): TGLboolean {.importc.} + proc glVertexAttrib3sARB(index: GLuint, x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glGenQueriesEXT(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glGetQueryObjectui64v(id: GLuint, pname: GLenum, params: ptr GLuint64) {.importc.} + proc glWeightusvARB(size: GLint, weights: ptr GLushort) {.importc.} + proc glWindowPos2sARB(x: GLshort, y: GLshort) {.importc.} + proc glGetTextureLevelParameterivEXT(texture: GLuint, target: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} + proc glBufferParameteriAPPLE(target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glMultiModeDrawArraysIBM(mode: ptr GLenum, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei, modestride: GLint) {.importc.} + proc glUniformMatrix2x3fv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} + proc glTangentPointerEXT(`type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glResetMinmax(target: GLenum) {.importc.} + proc glVertexAttribP1uiv(index: GLuint, `type`: GLenum, normalized: GLboolean, value: ptr GLuint) {.importc.} + proc glPixelMapx(map: GLenum, size: GLint, values: ptr GLfixed) {.importc.} + proc glPixelStoref(pname: GLenum, param: GLfloat) {.importc.} + proc glBinormal3dEXT(bx: GLdouble, by: GLdouble, bz: GLdouble) {.importc.} + proc glVertexAttribs1hvNV(index: GLuint, n: GLsizei, v: ptr GLhalfNV) {.importc.} + proc glVertexAttrib4usvARB(index: GLuint, v: ptr GLushort) {.importc.} + proc glUnmapBuffer(target: GLenum): TGLboolean {.importc.} proc glFlushRasterSGIX() {.importc.} - proc glColor3uiv(v: ptr TGLuint) {.importc.} - proc glInvalidateBufferSubData(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr) {.importc.} - proc glPassThroughxOES(token: TGLfixed) {.importc.} - proc glLockArraysEXT(first: TGLint, count: TGLsizei) {.importc.} - proc glStencilFuncSeparateATI(frontfunc: TGLenum, backfunc: TGLenum, `ref`: TGLint, mask: TGLuint) {.importc.} - proc glProgramUniform3dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glGenTransformFeedbacks(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glCopyTexSubImage3DOES(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glIsNamedBufferResidentNV(buffer: TGLuint): TGLboolean {.importc.} - proc glSampleMaskIndexedNV(index: TGLuint, mask: TGLbitfield) {.importc.} - proc glVDPAUSurfaceAccessNV(surface: TGLvdpauSurfaceNV, access: TGLenum) {.importc.} - proc glProgramUniform3dv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLdouble) {.importc.} - proc glDeleteProgram(program: TGLuint) {.importc.} - proc glConvolutionFilter1D(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, image: pointer) {.importc.} - proc glVertex2f(x: TGLfloat, y: TGLfloat) {.importc.} - proc glWindowPos4dvMESA(v: ptr TGLdouble) {.importc.} - proc glColor4us(red: TGLushort, green: TGLushort, blue: TGLushort, alpha: TGLushort) {.importc.} - proc glColorMask(red: TGLboolean, green: TGLboolean, blue: TGLboolean, alpha: TGLboolean) {.importc.} - proc glGetTexEnviv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glProgramUniform3ivEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glSecondaryColor3i(red: TGLint, green: TGLint, blue: TGLint) {.importc.} - proc glGetSamplerParameteriv(sampler: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glDeleteFramebuffersEXT(n: TGLsizei, framebuffers: ptr TGLuint) {.importc.} - proc glCompressedTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} - proc glVertex2s(x: TGLshort, y: TGLshort) {.importc.} - proc glIsQuery(id: TGLuint): TGLboolean {.importc.} - proc glFogxv(pname: TGLenum, param: ptr TGLfixed) {.importc.} - proc glAreProgramsResidentNV(n: TGLsizei, programs: ptr TGLuint, residences: ptr TGLboolean): TGLboolean {.importc.} - proc glShaderSourceARB(shaderObj: TGLhandleARB, count: TGLsizei, string: ptr ptr TGLcharARB, length: ptr TGLint) {.importc.} - proc glPointSizexOES(size: TGLfixed) {.importc.} - proc glPixelTransferf(pname: TGLenum, param: TGLfloat) {.importc.} - proc glExtractComponentEXT(res: TGLuint, src: TGLuint, num: TGLuint) {.importc.} - proc glUniform1fv(location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glGetNamedStringARB(namelen: TGLint, name: ptr TGLchar, bufSize: TGLsizei, stringlen: ptr TGLint, string: ptr TGLchar) {.importc.} - proc glGetProgramBinaryOES(program: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, binaryFormat: ptr TGLenum, binary: pointer) {.importc.} - proc glDeleteOcclusionQueriesNV(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glEnableClientState(`array`: TGLenum) {.importc.} - proc glProgramBufferParametersIuivNV(target: TGLenum, bindingIndex: TGLuint, wordIndex: TGLuint, count: TGLsizei, params: ptr TGLuint) {.importc.} - proc glProgramUniform2ui(program: TGLuint, location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} - proc glReplacementCodeuiSUN(code: TGLuint) {.importc.} - proc glMultMatrixd(m: ptr TGLdouble) {.importc.} - proc glInvalidateSubFramebuffer(target: TGLenum, numAttachments: TGLsizei, attachments: ptr TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glGenerateMultiTexMipmapEXT(texunit: TGLenum, target: TGLenum) {.importc.} - proc glDepthRangex(n: TGLfixed, f: TGLfixed) {.importc.} - proc glGetInteger64i_v(target: TGLenum, index: TGLuint, data: ptr TGLint64) {.importc.} - proc glDrawBuffers(n: TGLsizei, bufs: ptr TGLenum) {.importc.} - proc glGetPointervEXT(pname: TGLenum, params: ptr pointer) {.importc.} - proc glFogxvOES(pname: TGLenum, param: ptr TGLfixed) {.importc.} - proc glTexCoordP2uiv(`type`: TGLenum, coords: ptr TGLuint) {.importc.} - proc glVertexFormatNV(size: TGLint, `type`: TGLenum, stride: TGLsizei) {.importc.} - proc glColorPointervINTEL(size: TGLint, `type`: TGLenum, `pointer`: ptr pointer) {.importc.} - proc glGetMultiTexParameterivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glMultiTexCoordP4uiv(texture: TGLenum, `type`: TGLenum, coords: ptr TGLuint) {.importc.} - proc glResetMinmaxEXT(target: TGLenum) {.importc.} - proc glCopyBufferSubData(readTarget: TGLenum, writeTarget: TGLenum, readOffset: TGLintptr, writeOffset: TGLintptr, size: TGLsizeiptr) {.importc.} - proc glSecondaryColor3sv(v: ptr TGLshort) {.importc.} - proc glPixelStorex(pname: TGLenum, param: TGLfixed) {.importc.} - proc glWaitSync(sync: TGLsync, flags: TGLbitfield, timeout: TGLuint64) {.importc.} - proc glVertexAttribI1iv(index: TGLuint, v: ptr TGLint) {.importc.} - proc glColorSubTableEXT(target: TGLenum, start: TGLsizei, count: TGLsizei, format: TGLenum, `type`: TGLenum, data: pointer) {.importc.} - proc glGetDoublev(pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glMultiTexParameterivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glMultiTexCoord4svARB(target: TGLenum, v: ptr TGLshort) {.importc.} - proc glColorPointerListIBM(size: TGLint, `type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} - proc glScissorIndexed(index: TGLuint, left: TGLint, bottom: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glStencilOpSeparateATI(face: TGLenum, sfail: TGLenum, dpfail: TGLenum, dppass: TGLenum) {.importc.} - proc glLoadName(name: TGLuint) {.importc.} - proc glIsTransformFeedbackNV(id: TGLuint): TGLboolean {.importc.} + proc glColor3uiv(v: ptr GLuint) {.importc.} + proc glInvalidateBufferSubData(buffer: GLuint, offset: GLintptr, length: GLsizeiptr) {.importc.} + proc glPassThroughxOES(token: GLfixed) {.importc.} + proc glLockArraysEXT(first: GLint, count: GLsizei) {.importc.} + proc glStencilFuncSeparateATI(frontfunc: GLenum, backfunc: GLenum, `ref`: GLint, mask: GLuint) {.importc.} + proc glProgramUniform3dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glGenTransformFeedbacks(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glCopyTexSubImage3DOES(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glIsNamedBufferResidentNV(buffer: GLuint): TGLboolean {.importc.} + proc glSampleMaskIndexedNV(index: GLuint, mask: GLbitfield) {.importc.} + proc glVDPAUSurfaceAccessNV(surface: GLvdpauSurfaceNV, access: GLenum) {.importc.} + proc glProgramUniform3dv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} + proc glDeleteProgram(program: GLuint) {.importc.} + proc glConvolutionFilter1D(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} + proc glVertex2f(x: GLfloat, y: GLfloat) {.importc.} + proc glWindowPos4dvMESA(v: ptr GLdouble) {.importc.} + proc glColor4us(red: GLushort, green: GLushort, blue: GLushort, alpha: GLushort) {.importc.} + proc glColorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean) {.importc.} + proc glGetTexEnviv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glProgramUniform3ivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glSecondaryColor3i(red: GLint, green: GLint, blue: GLint) {.importc.} + proc glGetSamplerParameteriv(sampler: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glDeleteFramebuffersEXT(n: GLsizei, framebuffers: ptr GLuint) {.importc.} + proc glCompressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glVertex2s(x: GLshort, y: GLshort) {.importc.} + proc glIsQuery(id: GLuint): TGLboolean {.importc.} + proc glFogxv(pname: GLenum, param: ptr GLfixed) {.importc.} + proc glAreProgramsResidentNV(n: GLsizei, programs: ptr GLuint, residences: ptr GLboolean): TGLboolean {.importc.} + proc glShaderSourceARB(shaderObj: GLhandleARB, count: GLsizei, string: ptr ptr GLcharARB, length: ptr GLint) {.importc.} + proc glPointSizexOES(size: GLfixed) {.importc.} + proc glPixelTransferf(pname: GLenum, param: GLfloat) {.importc.} + proc glExtractComponentEXT(res: GLuint, src: GLuint, num: GLuint) {.importc.} + proc glUniform1fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetNamedStringARB(namelen: GLint, name: ptr GLchar, bufSize: GLsizei, stringlen: ptr GLint, string: ptr GLchar) {.importc.} + proc glGetProgramBinaryOES(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, binaryFormat: ptr GLenum, binary: pointer) {.importc.} + proc glDeleteOcclusionQueriesNV(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glEnableClientState(`array`: GLenum) {.importc.} + proc glProgramBufferParametersIuivNV(target: GLenum, bindingIndex: GLuint, wordIndex: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} + proc glProgramUniform2ui(program: GLuint, location: GLint, v0: GLuint, v1: GLuint) {.importc.} + proc glReplacementCodeuiSUN(code: GLuint) {.importc.} + proc glMultMatrixd(m: ptr GLdouble) {.importc.} + proc glInvalidateSubFramebuffer(target: GLenum, numAttachments: GLsizei, attachments: ptr GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glGenerateMultiTexMipmapEXT(texunit: GLenum, target: GLenum) {.importc.} + proc glDepthRangex(n: GLfixed, f: GLfixed) {.importc.} + proc glGetInteger64i_v(target: GLenum, index: GLuint, data: ptr GLint64) {.importc.} + proc glDrawBuffers(n: GLsizei, bufs: ptr GLenum) {.importc.} + proc glGetPointervEXT(pname: GLenum, params: ptr pointer) {.importc.} + proc glFogxvOES(pname: GLenum, param: ptr GLfixed) {.importc.} + proc glTexCoordP2uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} + proc glVertexFormatNV(size: GLint, `type`: GLenum, stride: GLsizei) {.importc.} + proc glColorPointervINTEL(size: GLint, `type`: GLenum, `pointer`: ptr pointer) {.importc.} + proc glGetMultiTexParameterivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoordP4uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} + proc glResetMinmaxEXT(target: GLenum) {.importc.} + proc glCopyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr) {.importc.} + proc glSecondaryColor3sv(v: ptr GLshort) {.importc.} + proc glPixelStorex(pname: GLenum, param: GLfixed) {.importc.} + proc glWaitSync(sync: GLsync, flags: GLbitfield, timeout: GLuint64) {.importc.} + proc glVertexAttribI1iv(index: GLuint, v: ptr GLint) {.importc.} + proc glColorSubTableEXT(target: GLenum, start: GLsizei, count: GLsizei, format: GLenum, `type`: GLenum, data: pointer) {.importc.} + proc glGetDoublev(pname: GLenum, params: ptr GLdouble) {.importc.} + proc glMultiTexParameterivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoord4svARB(target: GLenum, v: ptr GLshort) {.importc.} + proc glColorPointerListIBM(size: GLint, `type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glScissorIndexed(index: GLuint, left: GLint, bottom: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glStencilOpSeparateATI(face: GLenum, sfail: GLenum, dpfail: GLenum, dppass: GLenum) {.importc.} + proc glLoadName(name: GLuint) {.importc.} + proc glIsTransformFeedbackNV(id: GLuint): TGLboolean {.importc.} proc glPopDebugGroup() {.importc.} - proc glClipPlanef(p: TGLenum, eqn: ptr TGLfloat) {.importc.} - proc glDeleteFencesAPPLE(n: TGLsizei, fences: ptr TGLuint) {.importc.} - proc glGetQueryObjecti64v(id: TGLuint, pname: TGLenum, params: ptr TGLint64) {.importc.} - proc glAlphaFunc(func: TGLenum, `ref`: TGLfloat) {.importc.} - proc glIndexPointerEXT(`type`: TGLenum, stride: TGLsizei, count: TGLsizei, `pointer`: pointer) {.importc.} - proc glVertexAttribI3ivEXT(index: TGLuint, v: ptr TGLint) {.importc.} - proc glIndexub(c: TGLubyte) {.importc.} - proc glVertexP2uiv(`type`: TGLenum, value: ptr TGLuint) {.importc.} - proc glProgramUniform1uiv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glDebugMessageInsertKHR(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: ptr TGLchar) {.importc.} - proc glColor4b(red: TGLbyte, green: TGLbyte, blue: TGLbyte, alpha: TGLbyte) {.importc.} - proc glRenderbufferStorageMultisampleAPPLE(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glMinSampleShading(value: TGLfloat) {.importc.} - proc glBindProgramNV(target: TGLenum, id: TGLuint) {.importc.} - proc glWindowPos3dMESA(x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glEdgeFlagPointer(stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glGetFragDataIndex(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} - proc glTexCoord3hNV(s: TGLhalfNV, t: TGLhalfNV, r: TGLhalfNV) {.importc.} - proc glMultiDrawArraysIndirectAMD(mode: TGLenum, indirect: pointer, primcount: TGLsizei, stride: TGLsizei) {.importc.} - proc glFragmentColorMaterialSGIX(face: TGLenum, mode: TGLenum) {.importc.} - proc glTexGenf(coord: TGLenum, pname: TGLenum, param: TGLfloat) {.importc.} - proc glVertexAttrib4ubvARB(index: TGLuint, v: ptr TGLubyte) {.importc.} - proc glClearBufferiv(buffer: TGLenum, drawbuffer: TGLint, value: ptr TGLint) {.importc.} - proc glGenQueriesARB(n: TGLsizei, ids: ptr TGLuint) {.importc.} - proc glRectdv(v1: ptr TGLdouble, v2: ptr TGLdouble) {.importc.} - proc glBlendEquationSeparateEXT(modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} - proc glTestFenceAPPLE(fence: TGLuint): TGLboolean {.importc.} - proc glTexGeniv(coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glPolygonMode(face: TGLenum, mode: TGLenum) {.importc.} - proc glFrameZoomSGIX(factor: TGLint) {.importc.} - proc glReplacementCodeuiTexCoord2fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glUniformSubroutinesuiv(shadertype: TGLenum, count: TGLsizei, indices: ptr TGLuint) {.importc.} - proc glBeginQueryIndexed(target: TGLenum, index: TGLuint, id: TGLuint) {.importc.} - proc glMultiTexGeniEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glRasterPos3fv(v: ptr TGLfloat) {.importc.} - proc glMapObjectBufferATI(buffer: TGLuint) {.importc.} - proc glIndexiv(c: ptr TGLint) {.importc.} - proc glVertexAttribLPointer(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glMultiTexCoord4s(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc.} - proc glSecondaryColorP3uiv(`type`: TGLenum, color: ptr TGLuint) {.importc.} - proc glNormalFormatNV(`type`: TGLenum, stride: TGLsizei) {.importc.} - proc glVertex4i(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} - proc glUniform1ui64NV(location: TGLint, x: TGLuint64EXT) {.importc.} - proc glScissorIndexedv(index: TGLuint, v: ptr TGLint) {.importc.} - proc glProgramUniform1i(program: TGLuint, location: TGLint, v0: TGLint) {.importc.} - proc glCompressedMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, imageSize: TGLsizei, bits: pointer) {.importc.} + proc glClipPlanef(p: GLenum, eqn: ptr GLfloat) {.importc.} + proc glDeleteFencesAPPLE(n: GLsizei, fences: ptr GLuint) {.importc.} + proc glGetQueryObjecti64v(id: GLuint, pname: GLenum, params: ptr GLint64) {.importc.} + proc glAlphaFunc(func: GLenum, `ref`: GLfloat) {.importc.} + proc glIndexPointerEXT(`type`: GLenum, stride: GLsizei, count: GLsizei, `pointer`: pointer) {.importc.} + proc glVertexAttribI3ivEXT(index: GLuint, v: ptr GLint) {.importc.} + proc glIndexub(c: GLubyte) {.importc.} + proc glVertexP2uiv(`type`: GLenum, value: ptr GLuint) {.importc.} + proc glProgramUniform1uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glDebugMessageInsertKHR(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glColor4b(red: GLbyte, green: GLbyte, blue: GLbyte, alpha: GLbyte) {.importc.} + proc glRenderbufferStorageMultisampleAPPLE(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glMinSampleShading(value: GLfloat) {.importc.} + proc glBindProgramNV(target: GLenum, id: GLuint) {.importc.} + proc glWindowPos3dMESA(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glEdgeFlagPointer(stride: GLsizei, `pointer`: pointer) {.importc.} + proc glGetFragDataIndex(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glTexCoord3hNV(s: GLhalfNV, t: GLhalfNV, r: GLhalfNV) {.importc.} + proc glMultiDrawArraysIndirectAMD(mode: GLenum, indirect: pointer, primcount: GLsizei, stride: GLsizei) {.importc.} + proc glFragmentColorMaterialSGIX(face: GLenum, mode: GLenum) {.importc.} + proc glTexGenf(coord: GLenum, pname: GLenum, param: GLfloat) {.importc.} + proc glVertexAttrib4ubvARB(index: GLuint, v: ptr GLubyte) {.importc.} + proc glClearBufferiv(buffer: GLenum, drawbuffer: GLint, value: ptr GLint) {.importc.} + proc glGenQueriesARB(n: GLsizei, ids: ptr GLuint) {.importc.} + proc glRectdv(v1: ptr GLdouble, v2: ptr GLdouble) {.importc.} + proc glBlendEquationSeparateEXT(modeRGB: GLenum, modeAlpha: GLenum) {.importc.} + proc glTestFenceAPPLE(fence: GLuint): TGLboolean {.importc.} + proc glTexGeniv(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glPolygonMode(face: GLenum, mode: GLenum) {.importc.} + proc glFrameZoomSGIX(factor: GLint) {.importc.} + proc glReplacementCodeuiTexCoord2fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glUniformSubroutinesuiv(shadertype: GLenum, count: GLsizei, indices: ptr GLuint) {.importc.} + proc glBeginQueryIndexed(target: GLenum, index: GLuint, id: GLuint) {.importc.} + proc glMultiTexGeniEXT(texunit: GLenum, coord: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glRasterPos3fv(v: ptr GLfloat) {.importc.} + proc glMapObjectBufferATI(buffer: GLuint) {.importc.} + proc glIndexiv(c: ptr GLint) {.importc.} + proc glVertexAttribLPointer(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glMultiTexCoord4s(target: GLenum, s: GLshort, t: GLshort, r: GLshort, q: GLshort) {.importc.} + proc glSecondaryColorP3uiv(`type`: GLenum, color: ptr GLuint) {.importc.} + proc glNormalFormatNV(`type`: GLenum, stride: GLsizei) {.importc.} + proc glVertex4i(x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glUniform1ui64NV(location: GLint, x: GLuint64EXT) {.importc.} + proc glScissorIndexedv(index: GLuint, v: ptr GLint) {.importc.} + proc glProgramUniform1i(program: GLuint, location: GLint, v0: GLint) {.importc.} + proc glCompressedMultiTexSubImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} proc glFinishTextureSUNX() {.importc.} - proc glFramebufferTexture3DEXT(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, zoffset: TGLint) {.importc.} - proc glSetInvariantEXT(id: TGLuint, `type`: TGLenum, `addr`: pointer) {.importc.} - proc glGetTexParameterIivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glMultiTexCoordP3ui(texture: TGLenum, `type`: TGLenum, coords: TGLuint) {.importc.} - proc glMultiTexCoord3f(target: TGLenum, s: TGLfloat, t: TGLfloat, r: TGLfloat) {.importc.} - proc glNormalStream3fATI(stream: TGLenum, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat) {.importc.} - proc glActiveShaderProgram(pipeline: TGLuint, program: TGLuint) {.importc.} - proc glDisableVertexArrayEXT(vaobj: TGLuint, `array`: TGLenum) {.importc.} - proc glVertexAttribI3iv(index: TGLuint, v: ptr TGLint) {.importc.} - proc glProvokingVertex(mode: TGLenum) {.importc.} - proc glTexCoord1fv(v: ptr TGLfloat) {.importc.} - proc glVertexAttrib3fv(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glWindowPos3iv(v: ptr TGLint) {.importc.} - proc glProgramUniform4ui64NV(program: TGLuint, location: TGLint, x: TGLuint64EXT, y: TGLuint64EXT, z: TGLuint64EXT, w: TGLuint64EXT) {.importc.} - proc glProgramUniform2d(program: TGLuint, location: TGLint, v0: TGLdouble, v1: TGLdouble) {.importc.} - proc glDebugMessageInsertARB(source: TGLenum, `type`: TGLenum, id: TGLuint, severity: TGLenum, length: TGLsizei, buf: ptr TGLchar) {.importc.} - proc glMultiTexSubImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glMap1d(target: TGLenum, u1: TGLdouble, u2: TGLdouble, stride: TGLint, order: TGLint, points: ptr TGLdouble) {.importc.} - proc glDeleteShader(shader: TGLuint) {.importc.} - proc glTexturePageCommitmentEXT(texture: TGLuint, target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, resident: TGLboolean) {.importc.} - proc glFramebufferDrawBufferEXT(framebuffer: TGLuint, mode: TGLenum) {.importc.} - proc glTexCoord2fNormal3fVertex3fSUN(s: TGLfloat, t: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glDeleteProgramsNV(n: TGLsizei, programs: ptr TGLuint) {.importc.} - proc glPointAlongPathNV(path: TGLuint, startSegment: TGLsizei, numSegments: TGLsizei, distance: TGLfloat, x: ptr TGLfloat, y: ptr TGLfloat, tangentX: ptr TGLfloat, tangentY: ptr TGLfloat): TGLboolean {.importc.} - proc glTexCoord1d(s: TGLdouble) {.importc.} - proc glStencilStrokePathNV(path: TGLuint, reference: TGLint, mask: TGLuint) {.importc.} - proc glQueryMatrixxOES(mantissa: ptr TGLfixed, exponent: ptr TGLint): TGLbitfield {.importc.} - proc glGetNamedProgramLocalParameterIuivEXT(program: TGLuint, target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} - proc glGenerateMipmapOES(target: TGLenum) {.importc.} - proc glRenderbufferStorageMultisampleIMG(target: TGLenum, samples: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glVertexBlendEnviATI(pname: TGLenum, param: TGLint) {.importc.} - proc glPushAttrib(mask: TGLbitfield) {.importc.} - proc glShaderOp3EXT(op: TGLenum, res: TGLuint, arg1: TGLuint, arg2: TGLuint, arg3: TGLuint) {.importc.} - proc glEnableVertexAttribArray(index: TGLuint) {.importc.} - proc glVertexAttrib4Nbv(index: TGLuint, v: ptr TGLbyte) {.importc.} - proc glExtGetBuffersQCOM(buffers: ptr TGLuint, maxBuffers: TGLint, numBuffers: ptr TGLint) {.importc.} - proc glCopyTexSubImage3D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glDeletePerfMonitorsAMD(n: TGLsizei, monitors: ptr TGLuint) {.importc.} - proc glGetTrackMatrixivNV(target: TGLenum, address: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} + proc glFramebufferTexture3DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} + proc glSetInvariantEXT(id: GLuint, `type`: GLenum, `addr`: pointer) {.importc.} + proc glGetTexParameterIivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoordP3ui(texture: GLenum, `type`: GLenum, coords: GLuint) {.importc.} + proc glMultiTexCoord3f(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} + proc glNormalStream3fATI(stream: GLenum, nx: GLfloat, ny: GLfloat, nz: GLfloat) {.importc.} + proc glActiveShaderProgram(pipeline: GLuint, program: GLuint) {.importc.} + proc glDisableVertexArrayEXT(vaobj: GLuint, `array`: GLenum) {.importc.} + proc glVertexAttribI3iv(index: GLuint, v: ptr GLint) {.importc.} + proc glProvokingVertex(mode: GLenum) {.importc.} + proc glTexCoord1fv(v: ptr GLfloat) {.importc.} + proc glVertexAttrib3fv(index: GLuint, v: ptr GLfloat) {.importc.} + proc glWindowPos3iv(v: ptr GLint) {.importc.} + proc glProgramUniform4ui64NV(program: GLuint, location: GLint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT, w: GLuint64EXT) {.importc.} + proc glProgramUniform2d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble) {.importc.} + proc glDebugMessageInsertARB(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glMultiTexSubImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glMap1d(target: GLenum, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: ptr GLdouble) {.importc.} + proc glDeleteShader(shader: GLuint) {.importc.} + proc glTexturePageCommitmentEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, resident: GLboolean) {.importc.} + proc glFramebufferDrawBufferEXT(framebuffer: GLuint, mode: GLenum) {.importc.} + proc glTexCoord2fNormal3fVertex3fSUN(s: GLfloat, t: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glDeleteProgramsNV(n: GLsizei, programs: ptr GLuint) {.importc.} + proc glPointAlongPathNV(path: GLuint, startSegment: GLsizei, numSegments: GLsizei, distance: GLfloat, x: ptr GLfloat, y: ptr GLfloat, tangentX: ptr GLfloat, tangentY: ptr GLfloat): TGLboolean {.importc.} + proc glTexCoord1d(s: GLdouble) {.importc.} + proc glStencilStrokePathNV(path: GLuint, reference: GLint, mask: GLuint) {.importc.} + proc glQueryMatrixxOES(mantissa: ptr GLfixed, exponent: ptr GLint): TGLbitfield {.importc.} + proc glGetNamedProgramLocalParameterIuivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glGenerateMipmapOES(target: GLenum) {.importc.} + proc glRenderbufferStorageMultisampleIMG(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glVertexBlendEnviATI(pname: GLenum, param: GLint) {.importc.} + proc glPushAttrib(mask: GLbitfield) {.importc.} + proc glShaderOp3EXT(op: GLenum, res: GLuint, arg1: GLuint, arg2: GLuint, arg3: GLuint) {.importc.} + proc glEnableVertexAttribArray(index: GLuint) {.importc.} + proc glVertexAttrib4Nbv(index: GLuint, v: ptr GLbyte) {.importc.} + proc glExtGetBuffersQCOM(buffers: ptr GLuint, maxBuffers: GLint, numBuffers: ptr GLint) {.importc.} + proc glCopyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glDeletePerfMonitorsAMD(n: GLsizei, monitors: ptr GLuint) {.importc.} + proc glGetTrackMatrixivNV(target: GLenum, address: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glEndConditionalRender() {.importc.} - proc glVertexAttribL3i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT, z: TGLint64EXT) {.importc.} - proc glProgramLocalParametersI4ivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLint) {.importc.} + proc glVertexAttribL3i64NV(index: GLuint, x: GLint64EXT, y: GLint64EXT, z: GLint64EXT) {.importc.} + proc glProgramLocalParametersI4ivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLint) {.importc.} proc glFlush() {.importc.} - proc glGetNamedBufferParameterui64vNV(buffer: TGLuint, pname: TGLenum, params: ptr TGLuint64EXT) {.importc.} - proc glGetVertexArrayIntegeri_vEXT(vaobj: TGLuint, index: TGLuint, pname: TGLenum, param: ptr TGLint) {.importc.} - proc glReadnPixelsEXT(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, data: pointer) {.importc.} - proc glMultiTexImage1DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetVaryingLocationNV(program: TGLuint, name: ptr TGLchar): TGLint {.importc.} - proc glMultiTexCoord4fvARB(target: TGLenum, v: ptr TGLfloat) {.importc.} - proc glMultiTexCoord3iv(target: TGLenum, v: ptr TGLint) {.importc.} - proc glVertexAttribL2dvEXT(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glTexParameterxOES(target: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glSecondaryColor3uivEXT(v: ptr TGLuint) {.importc.} - proc glReadnPixelsARB(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, bufSize: TGLsizei, data: pointer) {.importc.} - proc glCopyTexSubImage1DEXT(target: TGLenum, level: TGLint, xoffset: TGLint, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glGetDoublei_vEXT(pname: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} - proc glVariantPointerEXT(id: TGLuint, `type`: TGLenum, stride: TGLuint, `addr`: pointer) {.importc.} - proc glProgramUniform3ui64vNV(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLuint64EXT) {.importc.} - proc glTexCoord2fColor3fVertex3fvSUN(tc: ptr TGLfloat, c: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glProgramUniform3fv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glBindFragDataLocationIndexed(program: TGLuint, colorNumber: TGLuint, index: TGLuint, name: ptr TGLchar) {.importc.} - proc glGetnSeparableFilterARB(target: TGLenum, format: TGLenum, `type`: TGLenum, rowBufSize: TGLsizei, row: pointer, columnBufSize: TGLsizei, column: pointer, span: pointer) {.importc.} - proc glTextureParameteriEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glGetUniformuivEXT(program: TGLuint, location: TGLint, params: ptr TGLuint) {.importc.} - proc glFragmentMaterialivSGIX(face: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glMultiTexCoord1svARB(target: TGLenum, v: ptr TGLshort) {.importc.} - proc glClientActiveTextureARB(texture: TGLenum) {.importc.} - proc glVertexAttrib1fARB(index: TGLuint, x: TGLfloat) {.importc.} - proc glVertexAttrib4NbvARB(index: TGLuint, v: ptr TGLbyte) {.importc.} - proc glRasterPos2d(x: TGLdouble, y: TGLdouble) {.importc.} - proc glMultiTexCoord4iARB(target: TGLenum, s: TGLint, t: TGLint, r: TGLint, q: TGLint) {.importc.} - proc glGetPixelTexGenParameterfvSGIS(pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVertexAttribL2dv(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glGetProgramStringARB(target: TGLenum, pname: TGLenum, string: pointer) {.importc.} - proc glRasterPos2i(x: TGLint, y: TGLint) {.importc.} - proc glTexCoord2fColor4fNormal3fVertex3fvSUN(tc: ptr TGLfloat, c: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glMultiTexCoord3s(target: TGLenum, s: TGLshort, t: TGLshort, r: TGLshort) {.importc.} - proc glMultTransposeMatrixd(m: ptr TGLdouble) {.importc.} - proc glActiveVaryingNV(program: TGLuint, name: ptr TGLchar) {.importc.} - proc glProgramUniform1f(program: TGLuint, location: TGLint, v0: TGLfloat) {.importc.} - proc glGetActiveSubroutineName(program: TGLuint, shadertype: TGLenum, index: TGLuint, bufsize: TGLsizei, length: ptr TGLsizei, name: ptr TGLchar) {.importc.} - proc glClipPlanex(plane: TGLenum, equation: ptr TGLfixed) {.importc.} - proc glMultiTexCoord4iv(target: TGLenum, v: ptr TGLint) {.importc.} - proc glTransformFeedbackVaryingsEXT(program: TGLuint, count: TGLsizei, varyings: ptr ptr TGLchar, bufferMode: TGLenum) {.importc.} - proc glBlendEquationSeparateiARB(buf: TGLuint, modeRGB: TGLenum, modeAlpha: TGLenum) {.importc.} - proc glVertex2sv(v: ptr TGLshort) {.importc.} - proc glAccumxOES(op: TGLenum, value: TGLfixed) {.importc.} - proc glProgramLocalParameter4dARB(target: TGLenum, index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glIsRenderbufferEXT(renderbuffer: TGLuint): TGLboolean {.importc.} - proc glMultiDrawElementsIndirectAMD(mode: TGLenum, `type`: TGLenum, indirect: pointer, primcount: TGLsizei, stride: TGLsizei) {.importc.} - proc glVertexAttribI4uiEXT(index: TGLuint, x: TGLuint, y: TGLuint, z: TGLuint, w: TGLuint) {.importc.} - proc glVertex4fv(v: ptr TGLfloat) {.importc.} - proc glGenerateMipmapEXT(target: TGLenum) {.importc.} - proc glVertexP3ui(`type`: TGLenum, value: TGLuint) {.importc.} - proc glTexCoord2dv(v: ptr TGLdouble) {.importc.} - proc glFlushMappedBufferRange(target: TGLenum, offset: TGLintptr, length: TGLsizeiptr) {.importc.} - proc glTrackMatrixNV(target: TGLenum, address: TGLuint, matrix: TGLenum, transform: TGLenum) {.importc.} - proc glFragmentLightModeliSGIX(pname: TGLenum, param: TGLint) {.importc.} - proc glVertexAttrib4Nusv(index: TGLuint, v: ptr TGLushort) {.importc.} - proc glScalef(x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glLightxvOES(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glTextureParameterivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glCompressedMultiTexImage3DEXT(texunit: TGLenum, target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, bits: pointer) {.importc.} - proc glVertexAttribL1d(index: TGLuint, x: TGLdouble) {.importc.} - proc glVertexAttrib3fARB(index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glVertexAttrib3hvNV(index: TGLuint, v: ptr TGLhalfNV) {.importc.} - proc glSpriteParameteriSGIX(pname: TGLenum, param: TGLint) {.importc.} - proc glFrustumxOES(l: TGLfixed, r: TGLfixed, b: TGLfixed, t: TGLfixed, n: TGLfixed, f: TGLfixed) {.importc.} - proc glGetnMapdvARB(target: TGLenum, query: TGLenum, bufSize: TGLsizei, v: ptr TGLdouble) {.importc.} - proc glGetMinmaxEXT(target: TGLenum, reset: TGLboolean, format: TGLenum, `type`: TGLenum, values: pointer) {.importc.} - proc glProgramUniformHandleui64NV(program: TGLuint, location: TGLint, value: TGLuint64) {.importc.} - proc glWindowPos4fvMESA(v: ptr TGLfloat) {.importc.} - proc glExtGetTexturesQCOM(textures: ptr TGLuint, maxTextures: TGLint, numTextures: ptr TGLint) {.importc.} - proc glProgramSubroutineParametersuivNV(target: TGLenum, count: TGLsizei, params: ptr TGLuint) {.importc.} - proc glSampleCoveragexOES(value: TGLclampx, invert: TGLboolean) {.importc.} - proc glMultiTexEnvivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetFinalCombinerInputParameterfvNV(variable: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glLightModeliv(pname: TGLenum, params: ptr TGLint) {.importc.} - proc glUniform4f(location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} - proc glDepthRange(near: TGLdouble, far: TGLdouble) {.importc.} - proc glProgramUniformMatrix4x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glProgramUniform4fv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glGetTexParameterIiv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertexAttribs4dvNV(index: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} - proc glConvolutionParameteri(target: TGLenum, pname: TGLenum, params: TGLint) {.importc.} - proc glVertexAttribI4uiv(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glEvalCoord1dv(u: ptr TGLdouble) {.importc.} - proc glIsFramebuffer(framebuffer: TGLuint): TGLboolean {.importc.} - proc glEvalCoord2d(u: TGLdouble, v: TGLdouble) {.importc.} - proc glClearDepthf(d: TGLfloat) {.importc.} - proc glCompressedTexSubImage2D(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, width: TGLsizei, height: TGLsizei, format: TGLenum, imageSize: TGLsizei, data: pointer) {.importc.} - proc glProgramUniformMatrix3x2dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glGetTexParameterxv(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glBinormal3fEXT(bx: TGLfloat, by: TGLfloat, bz: TGLfloat) {.importc.} - proc glProgramParameteriARB(program: TGLuint, pname: TGLenum, value: TGLint) {.importc.} - proc glWindowPos3ivMESA(v: ptr TGLint) {.importc.} - proc glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc: ptr TGLuint, c: ptr TGLfloat, n: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glPresentFrameDualFillNV(video_slot: TGLuint, minPresentTime: TGLuint64EXT, beginPresentTimeId: TGLuint, presentDurationId: TGLuint, `type`: TGLenum, target0: TGLenum, fill0: TGLuint, target1: TGLenum, fill1: TGLuint, target2: TGLenum, fill2: TGLuint, target3: TGLenum, fill3: TGLuint) {.importc.} - proc glIndexPointerListIBM(`type`: TGLenum, stride: TGLint, `pointer`: ptr pointer, ptrstride: TGLint) {.importc.} - proc glVertexStream2dATI(stream: TGLenum, x: TGLdouble, y: TGLdouble) {.importc.} - proc glUniformMatrix3x4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glMapNamedBufferRangeEXT(buffer: TGLuint, offset: TGLintptr, length: TGLsizeiptr, access: TGLbitfield) {.importc.} - proc glColor4sv(v: ptr TGLshort) {.importc.} - proc glStencilFillPathNV(path: TGLuint, fillMode: TGLenum, mask: TGLuint) {.importc.} - proc glGetVertexAttribfvARB(index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glWindowPos3dv(v: ptr TGLdouble) {.importc.} - proc glHintPGI(target: TGLenum, mode: TGLint) {.importc.} - proc glVertexAttribs3hvNV(index: TGLuint, n: TGLsizei, v: ptr TGLhalfNV) {.importc.} - proc glProgramUniform1i64NV(program: TGLuint, location: TGLint, x: TGLint64EXT) {.importc.} - proc glReplacementCodeuiColor3fVertex3fSUN(rc: TGLuint, r: TGLfloat, g: TGLfloat, b: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glUniform2iARB(location: TGLint, v0: TGLint, v1: TGLint) {.importc.} - proc glViewport(x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glBlendFuncSeparateIndexedAMD(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} - proc glColor3us(red: TGLushort, green: TGLushort, blue: TGLushort) {.importc.} - proc glVertexAttrib2hvNV(index: TGLuint, v: ptr TGLhalfNV) {.importc.} - proc glGenerateMipmap(target: TGLenum) {.importc.} - proc glGetProgramEnvParameterIuivNV(target: TGLenum, index: TGLuint, params: ptr TGLuint) {.importc.} - proc glBlendEquationiARB(buf: TGLuint, mode: TGLenum) {.importc.} - proc glReadBufferNV(mode: TGLenum) {.importc.} - proc glProvokingVertexEXT(mode: TGLenum) {.importc.} - proc glPointParameterivNV(pname: TGLenum, params: ptr TGLint) {.importc.} - proc glBlitFramebufferANGLE(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} - proc glGetObjectParameterivARB(obj: TGLhandleARB, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetSubroutineIndex(program: TGLuint, shadertype: TGLenum, name: ptr TGLchar): TGLuint {.importc.} - proc glMap2d(target: TGLenum, u1: TGLdouble, u2: TGLdouble, ustride: TGLint, uorder: TGLint, v1: TGLdouble, v2: TGLdouble, vstride: TGLint, vorder: TGLint, points: ptr TGLdouble) {.importc.} - proc glRectfv(v1: ptr TGLfloat, v2: ptr TGLfloat) {.importc.} - proc glDepthRangeArrayv(first: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} - proc glMultiTexParameteriEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, param: TGLint) {.importc.} - proc glTexStorageSparseAMD(target: TGLenum, internalFormat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, layers: TGLsizei, flags: TGLbitfield) {.importc.} - proc glGenerateTextureMipmapEXT(texture: TGLuint, target: TGLenum) {.importc.} - proc glCopyConvolutionFilter1D(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glVertex4d(x: TGLdouble, y: TGLdouble, z: TGLdouble, w: TGLdouble) {.importc.} - proc glGetPathParameterfvNV(path: TGLuint, pname: TGLenum, value: ptr TGLfloat) {.importc.} - proc glDetachShader(program: TGLuint, shader: TGLuint) {.importc.} - proc glGetColorTableSGI(target: TGLenum, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} - proc glPixelTransformParameterfvEXT(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glBufferSubDataARB(target: TGLenum, offset: TGLintptrARB, size: TGLsizeiptrARB, data: pointer) {.importc.} - proc glVertexAttrib4ubvNV(index: TGLuint, v: ptr TGLubyte) {.importc.} - proc glCopyTextureImage1DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, border: TGLint) {.importc.} - proc glGetQueryivARB(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glVertexAttribIPointerEXT(index: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glVertexAttribL3dEXT(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glGetQueryObjectui64vEXT(id: TGLuint, pname: TGLenum, params: ptr TGLuint64) {.importc.} - proc glColor4x(red: TGLfixed, green: TGLfixed, blue: TGLfixed, alpha: TGLfixed) {.importc.} - proc glProgramUniformMatrix3x2dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glVertexAttribI4i(index: TGLuint, x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} - proc glVertexAttrib1f(index: TGLuint, x: TGLfloat) {.importc.} - proc glUnmapBufferOES(target: TGLenum): TGLboolean {.importc.} - proc glVertexStream2ivATI(stream: TGLenum, coords: ptr TGLint) {.importc.} - proc glBeginOcclusionQueryNV(id: TGLuint) {.importc.} - proc glVertex4sv(v: ptr TGLshort) {.importc.} - proc glEnablei(target: TGLenum, index: TGLuint) {.importc.} - proc glUseProgramObjectARB(programObj: TGLhandleARB) {.importc.} - proc glGetVertexAttribLdvEXT(index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glUniform2d(location: TGLint, x: TGLdouble, y: TGLdouble) {.importc.} - proc glMinmaxEXT(target: TGLenum, internalformat: TGLenum, sink: TGLboolean) {.importc.} - proc glTexImage3D(target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGenSymbolsEXT(datatype: TGLenum, storagetype: TGLenum, range: TGLenum, components: TGLuint): TGLuint {.importc.} - proc glVertexAttribI4svEXT(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glProgramEnvParameter4dvARB(target: TGLenum, index: TGLuint, params: ptr TGLdouble) {.importc.} - proc glProgramUniformMatrix4dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glGetSamplerParameterfv(sampler: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} + proc glGetNamedBufferParameterui64vNV(buffer: GLuint, pname: GLenum, params: ptr GLuint64EXT) {.importc.} + proc glGetVertexArrayIntegeri_vEXT(vaobj: GLuint, index: GLuint, pname: GLenum, param: ptr GLint) {.importc.} + proc glReadnPixelsEXT(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, bufSize: GLsizei, data: pointer) {.importc.} + proc glMultiTexImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetVaryingLocationNV(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glMultiTexCoord4fvARB(target: GLenum, v: ptr GLfloat) {.importc.} + proc glMultiTexCoord3iv(target: GLenum, v: ptr GLint) {.importc.} + proc glVertexAttribL2dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} + proc glTexParameterxOES(target: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glSecondaryColor3uivEXT(v: ptr GLuint) {.importc.} + proc glReadnPixelsARB(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, bufSize: GLsizei, data: pointer) {.importc.} + proc glCopyTexSubImage1DEXT(target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glGetDoublei_vEXT(pname: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glVariantPointerEXT(id: GLuint, `type`: GLenum, stride: GLuint, `addr`: pointer) {.importc.} + proc glProgramUniform3ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} + proc glTexCoord2fColor3fVertex3fvSUN(tc: ptr GLfloat, c: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glProgramUniform3fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glBindFragDataLocationIndexed(program: GLuint, colorNumber: GLuint, index: GLuint, name: ptr GLchar) {.importc.} + proc glGetnSeparableFilterARB(target: GLenum, format: GLenum, `type`: GLenum, rowBufSize: GLsizei, row: pointer, columnBufSize: GLsizei, column: pointer, span: pointer) {.importc.} + proc glTextureParameteriEXT(texture: GLuint, target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glGetUniformuivEXT(program: GLuint, location: GLint, params: ptr GLuint) {.importc.} + proc glFragmentMaterialivSGIX(face: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMultiTexCoord1svARB(target: GLenum, v: ptr GLshort) {.importc.} + proc glClientActiveTextureARB(texture: GLenum) {.importc.} + proc glVertexAttrib1fARB(index: GLuint, x: GLfloat) {.importc.} + proc glVertexAttrib4NbvARB(index: GLuint, v: ptr GLbyte) {.importc.} + proc glRasterPos2d(x: GLdouble, y: GLdouble) {.importc.} + proc glMultiTexCoord4iARB(target: GLenum, s: GLint, t: GLint, r: GLint, q: GLint) {.importc.} + proc glGetPixelTexGenParameterfvSGIS(pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttribL2dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glGetProgramStringARB(target: GLenum, pname: GLenum, string: pointer) {.importc.} + proc glRasterPos2i(x: GLint, y: GLint) {.importc.} + proc glTexCoord2fColor4fNormal3fVertex3fvSUN(tc: ptr GLfloat, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glMultiTexCoord3s(target: GLenum, s: GLshort, t: GLshort, r: GLshort) {.importc.} + proc glMultTransposeMatrixd(m: ptr GLdouble) {.importc.} + proc glActiveVaryingNV(program: GLuint, name: ptr GLchar) {.importc.} + proc glProgramUniform1f(program: GLuint, location: GLint, v0: GLfloat) {.importc.} + proc glGetActiveSubroutineName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} + proc glClipPlanex(plane: GLenum, equation: ptr GLfixed) {.importc.} + proc glMultiTexCoord4iv(target: GLenum, v: ptr GLint) {.importc.} + proc glTransformFeedbackVaryingsEXT(program: GLuint, count: GLsizei, varyings: ptr ptr GLchar, bufferMode: GLenum) {.importc.} + proc glBlendEquationSeparateiARB(buf: GLuint, modeRGB: GLenum, modeAlpha: GLenum) {.importc.} + proc glVertex2sv(v: ptr GLshort) {.importc.} + proc glAccumxOES(op: GLenum, value: GLfixed) {.importc.} + proc glProgramLocalParameter4dARB(target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glIsRenderbufferEXT(renderbuffer: GLuint): TGLboolean {.importc.} + proc glMultiDrawElementsIndirectAMD(mode: GLenum, `type`: GLenum, indirect: pointer, primcount: GLsizei, stride: GLsizei) {.importc.} + proc glVertexAttribI4uiEXT(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} + proc glVertex4fv(v: ptr GLfloat) {.importc.} + proc glGenerateMipmapEXT(target: GLenum) {.importc.} + proc glVertexP3ui(`type`: GLenum, value: GLuint) {.importc.} + proc glTexCoord2dv(v: ptr GLdouble) {.importc.} + proc glFlushMappedBufferRange(target: GLenum, offset: GLintptr, length: GLsizeiptr) {.importc.} + proc glTrackMatrixNV(target: GLenum, address: GLuint, matrix: GLenum, transform: GLenum) {.importc.} + proc glFragmentLightModeliSGIX(pname: GLenum, param: GLint) {.importc.} + proc glVertexAttrib4Nusv(index: GLuint, v: ptr GLushort) {.importc.} + proc glScalef(x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glLightxvOES(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glTextureParameterivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glCompressedMultiTexImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} + proc glVertexAttribL1d(index: GLuint, x: GLdouble) {.importc.} + proc glVertexAttrib3fARB(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glVertexAttrib3hvNV(index: GLuint, v: ptr GLhalfNV) {.importc.} + proc glSpriteParameteriSGIX(pname: GLenum, param: GLint) {.importc.} + proc glFrustumxOES(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} + proc glGetnMapdvARB(target: GLenum, query: GLenum, bufSize: GLsizei, v: ptr GLdouble) {.importc.} + proc glGetMinmaxEXT(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, values: pointer) {.importc.} + proc glProgramUniformHandleui64NV(program: GLuint, location: GLint, value: GLuint64) {.importc.} + proc glWindowPos4fvMESA(v: ptr GLfloat) {.importc.} + proc glExtGetTexturesQCOM(textures: ptr GLuint, maxTextures: GLint, numTextures: ptr GLint) {.importc.} + proc glProgramSubroutineParametersuivNV(target: GLenum, count: GLsizei, params: ptr GLuint) {.importc.} + proc glSampleCoveragexOES(value: GLclampx, invert: GLboolean) {.importc.} + proc glMultiTexEnvivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetFinalCombinerInputParameterfvNV(variable: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glLightModeliv(pname: GLenum, params: ptr GLint) {.importc.} + proc glUniform4f(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat, v3: GLfloat) {.importc.} + proc glDepthRange(near: GLdouble, far: GLdouble) {.importc.} + proc glProgramUniformMatrix4x3dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glProgramUniform4fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glGetTexParameterIiv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttribs4dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glConvolutionParameteri(target: GLenum, pname: GLenum, params: GLint) {.importc.} + proc glVertexAttribI4uiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glEvalCoord1dv(u: ptr GLdouble) {.importc.} + proc glIsFramebuffer(framebuffer: GLuint): TGLboolean {.importc.} + proc glEvalCoord2d(u: GLdouble, v: GLdouble) {.importc.} + proc glClearDepthf(d: GLfloat) {.importc.} + proc glCompressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, data: pointer) {.importc.} + proc glProgramUniformMatrix3x2dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glGetTexParameterxv(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glBinormal3fEXT(bx: GLfloat, by: GLfloat, bz: GLfloat) {.importc.} + proc glProgramParameteriARB(program: GLuint, pname: GLenum, value: GLint) {.importc.} + proc glWindowPos3ivMESA(v: ptr GLint) {.importc.} + proc glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc: ptr GLuint, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glPresentFrameDualFillNV(video_slot: GLuint, minPresentTime: GLuint64EXT, beginPresentTimeId: GLuint, presentDurationId: GLuint, `type`: GLenum, target0: GLenum, fill0: GLuint, target1: GLenum, fill1: GLuint, target2: GLenum, fill2: GLuint, target3: GLenum, fill3: GLuint) {.importc.} + proc glIndexPointerListIBM(`type`: GLenum, stride: GLint, `pointer`: ptr pointer, ptrstride: GLint) {.importc.} + proc glVertexStream2dATI(stream: GLenum, x: GLdouble, y: GLdouble) {.importc.} + proc glUniformMatrix3x4dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glMapNamedBufferRangeEXT(buffer: GLuint, offset: GLintptr, length: GLsizeiptr, access: GLbitfield) {.importc.} + proc glColor4sv(v: ptr GLshort) {.importc.} + proc glStencilFillPathNV(path: GLuint, fillMode: GLenum, mask: GLuint) {.importc.} + proc glGetVertexAttribfvARB(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glWindowPos3dv(v: ptr GLdouble) {.importc.} + proc glHintPGI(target: GLenum, mode: GLint) {.importc.} + proc glVertexAttribs3hvNV(index: GLuint, n: GLsizei, v: ptr GLhalfNV) {.importc.} + proc glProgramUniform1i64NV(program: GLuint, location: GLint, x: GLint64EXT) {.importc.} + proc glReplacementCodeuiColor3fVertex3fSUN(rc: GLuint, r: GLfloat, g: GLfloat, b: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glUniform2iARB(location: GLint, v0: GLint, v1: GLint) {.importc.} + proc glViewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glBlendFuncSeparateIndexedAMD(buf: GLuint, srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) {.importc.} + proc glColor3us(red: GLushort, green: GLushort, blue: GLushort) {.importc.} + proc glVertexAttrib2hvNV(index: GLuint, v: ptr GLhalfNV) {.importc.} + proc glGenerateMipmap(target: GLenum) {.importc.} + proc glGetProgramEnvParameterIuivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} + proc glBlendEquationiARB(buf: GLuint, mode: GLenum) {.importc.} + proc glReadBufferNV(mode: GLenum) {.importc.} + proc glProvokingVertexEXT(mode: GLenum) {.importc.} + proc glPointParameterivNV(pname: GLenum, params: ptr GLint) {.importc.} + proc glBlitFramebufferANGLE(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} + proc glGetObjectParameterivARB(obj: GLhandleARB, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetSubroutineIndex(program: GLuint, shadertype: GLenum, name: ptr GLchar): TGLuint {.importc.} + proc glMap2d(target: GLenum, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: ptr GLdouble) {.importc.} + proc glRectfv(v1: ptr GLfloat, v2: ptr GLfloat) {.importc.} + proc glDepthRangeArrayv(first: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glMultiTexParameteriEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLint) {.importc.} + proc glTexStorageSparseAMD(target: GLenum, internalFormat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, layers: GLsizei, flags: GLbitfield) {.importc.} + proc glGenerateTextureMipmapEXT(texture: GLuint, target: GLenum) {.importc.} + proc glCopyConvolutionFilter1D(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glVertex4d(x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} + proc glGetPathParameterfvNV(path: GLuint, pname: GLenum, value: ptr GLfloat) {.importc.} + proc glDetachShader(program: GLuint, shader: GLuint) {.importc.} + proc glGetColorTableSGI(target: GLenum, format: GLenum, `type`: GLenum, table: pointer) {.importc.} + proc glPixelTransformParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glBufferSubDataARB(target: GLenum, offset: GLintptrARB, size: GLsizeiptrARB, data: pointer) {.importc.} + proc glVertexAttrib4ubvNV(index: GLuint, v: ptr GLubyte) {.importc.} + proc glCopyTextureImage1DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, border: GLint) {.importc.} + proc glGetQueryivARB(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glVertexAttribIPointerEXT(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glVertexAttribL3dEXT(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glGetQueryObjectui64vEXT(id: GLuint, pname: GLenum, params: ptr GLuint64) {.importc.} + proc glColor4x(red: GLfixed, green: GLfixed, blue: GLfixed, alpha: GLfixed) {.importc.} + proc glProgramUniformMatrix3x2dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glVertexAttribI4i(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glVertexAttrib1f(index: GLuint, x: GLfloat) {.importc.} + proc glUnmapBufferOES(target: GLenum): TGLboolean {.importc.} + proc glVertexStream2ivATI(stream: GLenum, coords: ptr GLint) {.importc.} + proc glBeginOcclusionQueryNV(id: GLuint) {.importc.} + proc glVertex4sv(v: ptr GLshort) {.importc.} + proc glEnablei(target: GLenum, index: GLuint) {.importc.} + proc glUseProgramObjectARB(programObj: GLhandleARB) {.importc.} + proc glGetVertexAttribLdvEXT(index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glUniform2d(location: GLint, x: GLdouble, y: GLdouble) {.importc.} + proc glMinmaxEXT(target: GLenum, internalformat: GLenum, sink: GLboolean) {.importc.} + proc glTexImage3D(target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGenSymbolsEXT(datatype: GLenum, storagetype: GLenum, range: GLenum, components: GLuint): TGLuint {.importc.} + proc glVertexAttribI4svEXT(index: GLuint, v: ptr GLshort) {.importc.} + proc glProgramEnvParameter4dvARB(target: GLenum, index: GLuint, params: ptr GLdouble) {.importc.} + proc glProgramUniformMatrix4dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glGetSamplerParameterfv(sampler: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} proc glPopClientAttrib() {.importc.} - proc glHistogram(target: TGLenum, width: TGLsizei, internalformat: TGLenum, sink: TGLboolean) {.importc.} - proc glTexEnvfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glMultiTexCoord1dvARB(target: TGLenum, v: ptr TGLdouble) {.importc.} - proc glGetTexGenivOES(coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glUniform1ivARB(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glTexCoord3fv(v: ptr TGLfloat) {.importc.} - proc glVertex2xvOES(coords: ptr TGLfixed) {.importc.} - proc glTexCoord4fVertex4fvSUN(tc: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glUniform2uiv(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glMultiTexEnvfvEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glGetTextureParameterIivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glMemoryBarrierEXT(barriers: TGLbitfield) {.importc.} - proc glGetTexParameterPointervAPPLE(target: TGLenum, pname: TGLenum, params: ptr pointer) {.importc.} - proc glWindowPos2svARB(v: ptr TGLshort) {.importc.} - proc glEndQuery(target: TGLenum) {.importc.} - proc glBlitFramebufferEXT(srcX0: TGLint, srcY0: TGLint, srcX1: TGLint, srcY1: TGLint, dstX0: TGLint, dstY0: TGLint, dstX1: TGLint, dstY1: TGLint, mask: TGLbitfield, filter: TGLenum) {.importc.} - proc glProgramEnvParametersI4uivNV(target: TGLenum, index: TGLuint, count: TGLsizei, params: ptr TGLuint) {.importc.} - proc glGetActiveUniform(program: TGLuint, index: TGLuint, bufSize: TGLsizei, length: ptr TGLsizei, size: ptr TGLint, `type`: ptr TGLenum, name: ptr TGLchar) {.importc.} - proc glGenAsyncMarkersSGIX(range: TGLsizei): TGLuint {.importc.} - proc glClipControlARB(origin: TGLenum, depth: TGLenum) {.importc.} - proc glDrawElementsInstancedEXT(mode: TGLenum, count: TGLsizei, `type`: TGLenum, indices: pointer, primcount: TGLsizei) {.importc.} - proc glGetFragmentMaterialivSGIX(face: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glSwizzleEXT(res: TGLuint, `in`: TGLuint, outX: TGLenum, outY: TGLenum, outZ: TGLenum, outW: TGLenum) {.importc.} - proc glMultiTexCoord1bOES(texture: TGLenum, s: TGLbyte) {.importc.} - proc glProgramParameters4dvNV(target: TGLenum, index: TGLuint, count: TGLsizei, v: ptr TGLdouble) {.importc.} - proc glWindowPos2s(x: TGLshort, y: TGLshort) {.importc.} - proc glBlendFuncSeparatei(buf: TGLuint, srcRGB: TGLenum, dstRGB: TGLenum, srcAlpha: TGLenum, dstAlpha: TGLenum) {.importc.} - proc glMultiModeDrawElementsIBM(mode: ptr TGLenum, count: ptr TGLsizei, `type`: TGLenum, indices: ptr pointer, primcount: TGLsizei, modestride: TGLint) {.importc.} - proc glNormal3x(nx: TGLfixed, ny: TGLfixed, nz: TGLfixed) {.importc.} - proc glProgramUniform1fvEXT(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLfloat) {.importc.} - proc glTexCoord2hNV(s: TGLhalfNV, t: TGLhalfNV) {.importc.} - proc glViewportIndexedfv(index: TGLuint, v: ptr TGLfloat) {.importc.} - proc glDrawTexxOES(x: TGLfixed, y: TGLfixed, z: TGLfixed, width: TGLfixed, height: TGLfixed) {.importc.} - proc glProgramParameter4dvNV(target: TGLenum, index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glDeleteBuffers(n: TGLsizei, buffers: ptr TGLuint) {.importc.} - proc glGetVertexArrayIntegervEXT(vaobj: TGLuint, pname: TGLenum, param: ptr TGLint) {.importc.} - proc glBindFragDataLocationEXT(program: TGLuint, color: TGLuint, name: ptr TGLchar) {.importc.} - proc glGenProgramsNV(n: TGLsizei, programs: ptr TGLuint) {.importc.} - proc glMultiTexCoord1i(target: TGLenum, s: TGLint) {.importc.} - proc glCompressedTexImage3DOES(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glGetQueryivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glExtGetBufferPointervQCOM(target: TGLenum, params: ptr pointer) {.importc.} - proc glVertex3iv(v: ptr TGLint) {.importc.} - proc glVertexAttribL1dvEXT(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glValidateProgramPipeline(pipeline: TGLuint) {.importc.} - proc glBindVertexArray(`array`: TGLuint) {.importc.} - proc glUniform2uiEXT(location: TGLint, v0: TGLuint, v1: TGLuint) {.importc.} - proc glUniform3i(location: TGLint, v0: TGLint, v1: TGLint, v2: TGLint) {.importc.} - proc glGetVertexAttribIuiv(index: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glVertexArrayParameteriAPPLE(pname: TGLenum, param: TGLint) {.importc.} - proc glVertexAttribL2i64NV(index: TGLuint, x: TGLint64EXT, y: TGLint64EXT) {.importc.} - proc glTexGenivOES(coord: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glIsFramebufferOES(framebuffer: TGLuint): TGLboolean {.importc.} - proc glColor4ubv(v: ptr TGLubyte) {.importc.} - proc glDeleteNamedStringARB(namelen: TGLint, name: ptr TGLchar) {.importc.} - proc glCopyConvolutionFilter1DEXT(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei) {.importc.} - proc glBufferStorage(target: TGLenum, size: TGLsizeiptr, data: ptr pointer, flags: TGLbitfield) {.importc.} - proc glDrawTexiOES(x: TGLint, y: TGLint, z: TGLint, width: TGLint, height: TGLint) {.importc.} - proc glRasterPos3dv(v: ptr TGLdouble) {.importc.} - proc glIndexMaterialEXT(face: TGLenum, mode: TGLenum) {.importc.} - proc glGetClipPlanex(plane: TGLenum, equation: ptr TGLfixed) {.importc.} - proc glIsVertexArrayOES(`array`: TGLuint): TGLboolean {.importc.} - proc glColorTableEXT(target: TGLenum, internalFormat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} - proc glCompressedTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, border: TGLint, imageSize: TGLsizei, data: pointer) {.importc.} - proc glLightx(light: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glGetTexParameterfv(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVertexAttrib4NsvARB(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glInterleavedArrays(format: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glProgramLocalParameter4fARB(target: TGLenum, index: TGLuint, x: TGLfloat, y: TGLfloat, z: TGLfloat, w: TGLfloat) {.importc.} + proc glHistogram(target: GLenum, width: GLsizei, internalformat: GLenum, sink: GLboolean) {.importc.} + proc glTexEnvfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glMultiTexCoord1dvARB(target: GLenum, v: ptr GLdouble) {.importc.} + proc glGetTexGenivOES(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glUniform1ivARB(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glTexCoord3fv(v: ptr GLfloat) {.importc.} + proc glVertex2xvOES(coords: ptr GLfixed) {.importc.} + proc glTexCoord4fVertex4fvSUN(tc: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glUniform2uiv(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glMultiTexEnvfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glGetTextureParameterIivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMemoryBarrierEXT(barriers: GLbitfield) {.importc.} + proc glGetTexParameterPointervAPPLE(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} + proc glWindowPos2svARB(v: ptr GLshort) {.importc.} + proc glEndQuery(target: GLenum) {.importc.} + proc glBlitFramebufferEXT(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} + proc glProgramEnvParametersI4uivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} + proc glGetActiveUniform(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGenAsyncMarkersSGIX(range: GLsizei): TGLuint {.importc.} + proc glClipControlARB(origin: GLenum, depth: GLenum) {.importc.} + proc glDrawElementsInstancedEXT(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, primcount: GLsizei) {.importc.} + proc glGetFragmentMaterialivSGIX(face: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glSwizzleEXT(res: GLuint, `in`: GLuint, outX: GLenum, outY: GLenum, outZ: GLenum, outW: GLenum) {.importc.} + proc glMultiTexCoord1bOES(texture: GLenum, s: GLbyte) {.importc.} + proc glProgramParameters4dvNV(target: GLenum, index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} + proc glWindowPos2s(x: GLshort, y: GLshort) {.importc.} + proc glBlendFuncSeparatei(buf: GLuint, srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) {.importc.} + proc glMultiModeDrawElementsIBM(mode: ptr GLenum, count: ptr GLsizei, `type`: GLenum, indices: ptr pointer, primcount: GLsizei, modestride: GLint) {.importc.} + proc glNormal3x(nx: GLfixed, ny: GLfixed, nz: GLfixed) {.importc.} + proc glProgramUniform1fvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} + proc glTexCoord2hNV(s: GLhalfNV, t: GLhalfNV) {.importc.} + proc glViewportIndexedfv(index: GLuint, v: ptr GLfloat) {.importc.} + proc glDrawTexxOES(x: GLfixed, y: GLfixed, z: GLfixed, width: GLfixed, height: GLfixed) {.importc.} + proc glProgramParameter4dvNV(target: GLenum, index: GLuint, v: ptr GLdouble) {.importc.} + proc glDeleteBuffers(n: GLsizei, buffers: ptr GLuint) {.importc.} + proc glGetVertexArrayIntegervEXT(vaobj: GLuint, pname: GLenum, param: ptr GLint) {.importc.} + proc glBindFragDataLocationEXT(program: GLuint, color: GLuint, name: ptr GLchar) {.importc.} + proc glGenProgramsNV(n: GLsizei, programs: ptr GLuint) {.importc.} + proc glMultiTexCoord1i(target: GLenum, s: GLint) {.importc.} + proc glCompressedTexImage3DOES(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glGetQueryivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glExtGetBufferPointervQCOM(target: GLenum, params: ptr pointer) {.importc.} + proc glVertex3iv(v: ptr GLint) {.importc.} + proc glVertexAttribL1dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} + proc glValidateProgramPipeline(pipeline: GLuint) {.importc.} + proc glBindVertexArray(`array`: GLuint) {.importc.} + proc glUniform2uiEXT(location: GLint, v0: GLuint, v1: GLuint) {.importc.} + proc glUniform3i(location: GLint, v0: GLint, v1: GLint, v2: GLint) {.importc.} + proc glGetVertexAttribIuiv(index: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glVertexArrayParameteriAPPLE(pname: GLenum, param: GLint) {.importc.} + proc glVertexAttribL2i64NV(index: GLuint, x: GLint64EXT, y: GLint64EXT) {.importc.} + proc glTexGenivOES(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glIsFramebufferOES(framebuffer: GLuint): TGLboolean {.importc.} + proc glColor4ubv(v: ptr GLubyte) {.importc.} + proc glDeleteNamedStringARB(namelen: GLint, name: ptr GLchar) {.importc.} + proc glCopyConvolutionFilter1DEXT(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} + proc glBufferStorage(target: GLenum, size: GLsizeiptr, data: ptr pointer, flags: GLbitfield) {.importc.} + proc glDrawTexiOES(x: GLint, y: GLint, z: GLint, width: GLint, height: GLint) {.importc.} + proc glRasterPos3dv(v: ptr GLdouble) {.importc.} + proc glIndexMaterialEXT(face: GLenum, mode: GLenum) {.importc.} + proc glGetClipPlanex(plane: GLenum, equation: ptr GLfixed) {.importc.} + proc glIsVertexArrayOES(`array`: GLuint): TGLboolean {.importc.} + proc glColorTableEXT(target: GLenum, internalFormat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, table: pointer) {.importc.} + proc glCompressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} + proc glLightx(light: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glGetTexParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttrib4NsvARB(index: GLuint, v: ptr GLshort) {.importc.} + proc glInterleavedArrays(format: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glProgramLocalParameter4fARB(target: GLenum, index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} proc glPopDebugGroupKHR() {.importc.} - proc glVDPAUUnregisterSurfaceNV(surface: TGLvdpauSurfaceNV) {.importc.} - proc glTexCoord1s(s: TGLshort) {.importc.} - proc glFramebufferTexture2DMultisampleIMG(target: TGLenum, attachment: TGLenum, textarget: TGLenum, texture: TGLuint, level: TGLint, samples: TGLsizei) {.importc.} - proc glShaderBinary(count: TGLsizei, shaders: ptr TGLuint, binaryformat: TGLenum, binary: pointer, length: TGLsizei) {.importc.} - proc glVertexAttrib2dv(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glUniformMatrix4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glWeightivARB(size: TGLint, weights: ptr TGLint) {.importc.} - proc glGetMultiTexParameterIivEXT(texunit: TGLenum, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glCopyConvolutionFilter2DEXT(target: TGLenum, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei) {.importc.} - proc glSecondaryColor3hNV(red: TGLhalfNV, green: TGLhalfNV, blue: TGLhalfNV) {.importc.} - proc glVertexAttrib1sv(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glFrustumfOES(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} - proc glVertexStream2iATI(stream: TGLenum, x: TGLint, y: TGLint) {.importc.} - proc glNormalStream3bATI(stream: TGLenum, nx: TGLbyte, ny: TGLbyte, nz: TGLbyte) {.importc.} - proc glVertexArrayTexCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glGetQueryiv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glTransformFeedbackStreamAttribsNV(count: TGLsizei, attribs: ptr TGLint, nbuffers: TGLsizei, bufstreams: ptr TGLint, bufferMode: TGLenum) {.importc.} - proc glTextureStorage3DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei) {.importc.} - proc glWindowPos3dvMESA(v: ptr TGLdouble) {.importc.} - proc glUniform2uivEXT(location: TGLint, count: TGLsizei, value: ptr TGLuint) {.importc.} - proc glTextureStorage2DEXT(texture: TGLuint, target: TGLenum, levels: TGLsizei, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glVertexArrayMultiTexCoordOffsetEXT(vaobj: TGLuint, buffer: TGLuint, texunit: TGLenum, size: TGLint, `type`: TGLenum, stride: TGLsizei, offset: TGLintptr) {.importc.} - proc glVertexStream1dvATI(stream: TGLenum, coords: ptr TGLdouble) {.importc.} - proc glCopyImageSubData(srcName: TGLuint, srcTarget: TGLenum, srcLevel: TGLint, srcX: TGLint, srcY: TGLint, srcZ: TGLint, dstName: TGLuint, dstTarget: TGLenum, dstLevel: TGLint, dstX: TGLint, dstY: TGLint, dstZ: TGLint, srcWidth: TGLsizei, srcHeight: TGLsizei, srcDepth: TGLsizei) {.importc.} - proc glClearNamedBufferSubDataEXT(buffer: TGLuint, internalformat: TGLenum, format: TGLenum, `type`: TGLenum, offset: TGLsizeiptr, size: TGLsizeiptr, data: ptr pointer) {.importc.} - proc glBindBuffersRange(target: TGLenum, first: TGLuint, count: TGLsizei, buffers: ptr TGLuint, offsets: ptr TGLintptr, sizes: ptr TGLsizeiptr) {.importc.} - proc glGetVertexAttribIuivEXT(index: TGLuint, pname: TGLenum, params: ptr TGLuint) {.importc.} - proc glLoadMatrixx(m: ptr TGLfixed) {.importc.} - proc glTransformFeedbackVaryingsNV(program: TGLuint, count: TGLsizei, locations: ptr TGLint, bufferMode: TGLenum) {.importc.} - proc glUniform1i64vNV(location: TGLint, count: TGLsizei, value: ptr TGLint64EXT) {.importc.} - proc glVertexArrayVertexAttribLFormatEXT(vaobj: TGLuint, attribindex: TGLuint, size: TGLint, `type`: TGLenum, relativeoffset: TGLuint) {.importc.} - proc glClearBufferuiv(buffer: TGLenum, drawbuffer: TGLint, value: ptr TGLuint) {.importc.} - proc glCombinerOutputNV(stage: TGLenum, portion: TGLenum, abOutput: TGLenum, cdOutput: TGLenum, sumOutput: TGLenum, scale: TGLenum, bias: TGLenum, abDotProduct: TGLboolean, cdDotProduct: TGLboolean, muxSum: TGLboolean) {.importc.} - proc glTexImage3DEXT(target: TGLenum, level: TGLint, internalformat: TGLenum, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glPixelTransformParameterivEXT(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glActiveStencilFaceEXT(face: TGLenum) {.importc.} - proc glCreateShaderObjectARB(shaderType: TGLenum): TGLhandleARB {.importc.} - proc glGetTextureParameterivEXT(texture: TGLuint, target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glCopyTextureLevelsAPPLE(destinationTexture: TGLuint, sourceTexture: TGLuint, sourceBaseLevel: TGLint, sourceLevelCount: TGLsizei) {.importc.} - proc glVertexAttrib4Nuiv(index: TGLuint, v: ptr TGLuint) {.importc.} - proc glDrawPixels(width: TGLsizei, height: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glWindowPos3dvARB(v: ptr TGLdouble) {.importc.} - proc glProgramLocalParameterI4ivNV(target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} - proc glRasterPos4s(x: TGLshort, y: TGLshort, z: TGLshort, w: TGLshort) {.importc.} - proc glTexCoord2fVertex3fvSUN(tc: ptr TGLfloat, v: ptr TGLfloat) {.importc.} - proc glGetPathMetricsNV(metricQueryMask: TGLbitfield, numPaths: TGLsizei, pathNameType: TGLenum, paths: pointer, pathBase: TGLuint, stride: TGLsizei, metrics: ptr TGLfloat) {.importc.} - proc glMultiTexCoord4bOES(texture: TGLenum, s: TGLbyte, t: TGLbyte, r: TGLbyte, q: TGLbyte) {.importc.} - proc glTextureBufferEXT(texture: TGLuint, target: TGLenum, internalformat: TGLenum, buffer: TGLuint) {.importc.} - proc glSecondaryColor3fv(v: ptr TGLfloat) {.importc.} - proc glMultiTexCoord3fv(target: TGLenum, v: ptr TGLfloat) {.importc.} - proc glGetTexParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glMap2xOES(target: TGLenum, u1: TGLfixed, u2: TGLfixed, ustride: TGLint, uorder: TGLint, v1: TGLfixed, v2: TGLfixed, vstride: TGLint, vorder: TGLint, points: TGLfixed) {.importc.} - proc glFlushVertexArrayRangeAPPLE(length: TGLsizei, `pointer`: pointer) {.importc.} - proc glActiveTextureARB(texture: TGLenum) {.importc.} - proc glGetVertexAttribLi64vNV(index: TGLuint, pname: TGLenum, params: ptr TGLint64EXT) {.importc.} - proc glNormal3bv(v: ptr TGLbyte) {.importc.} - proc glCreateSyncFromCLeventARB(context: ptr TCL_context, event: ptr TCL_context, flags: TGLbitfield): TGLsync {.importc.} - proc glRenderbufferStorageEXT(target: TGLenum, internalformat: TGLenum, width: TGLsizei, height: TGLsizei) {.importc.} - proc glGetCompressedTextureImageEXT(texture: TGLuint, target: TGLenum, lod: TGLint, img: pointer) {.importc.} - proc glColorFragmentOp2ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint, arg2: TGLuint, arg2Rep: TGLuint, arg2Mod: TGLuint) {.importc.} - proc glPixelMapusv(map: TGLenum, mapsize: TGLsizei, values: ptr TGLushort) {.importc.} - proc glGlobalAlphaFactorsSUN(factor: TGLshort) {.importc.} - proc glTexParameterxv(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glEvalCoord2xOES(u: TGLfixed, v: TGLfixed) {.importc.} - proc glIsList(list: TGLuint): TGLboolean {.importc.} - proc glVertexAttrib3d(index: TGLuint, x: TGLdouble, y: TGLdouble, z: TGLdouble) {.importc.} - proc glSpriteParameterfSGIX(pname: TGLenum, param: TGLfloat) {.importc.} - proc glPathGlyphRangeNV(firstPathName: TGLuint, fontTarget: TGLenum, fontName: pointer, fontStyle: TGLbitfield, firstGlyph: TGLuint, numGlyphs: TGLsizei, handleMissingGlyphs: TGLenum, pathParameterTemplate: TGLuint, emScale: TGLfloat) {.importc.} - proc glUniform3iv(location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glClearBufferfi(buffer: TGLenum, drawbuffer: TGLint, depth: TGLfloat, stencil: TGLint) {.importc.} - proc glWindowPos3sMESA(x: TGLshort, y: TGLshort, z: TGLshort) {.importc.} - proc glGetMapParameterfvNV(target: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glBindFragmentShaderATI(id: TGLuint) {.importc.} - proc glTexCoord4s(s: TGLshort, t: TGLshort, r: TGLshort, q: TGLshort) {.importc.} - proc glGetMultiTexGenfvEXT(texunit: TGLenum, coord: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glColorMaterial(face: TGLenum, mode: TGLenum) {.importc.} - proc glVertexAttribs1svNV(index: TGLuint, count: TGLsizei, v: ptr TGLshort) {.importc.} - proc glEnableVertexAttribAPPLE(index: TGLuint, pname: TGLenum) {.importc.} - proc glGetDoubleIndexedvEXT(target: TGLenum, index: TGLuint, data: ptr TGLdouble) {.importc.} - proc glOrthof(l: TGLfloat, r: TGLfloat, b: TGLfloat, t: TGLfloat, n: TGLfloat, f: TGLfloat) {.importc.} - proc glVertexBlendEnvfATI(pname: TGLenum, param: TGLfloat) {.importc.} - proc glUniformMatrix2x4dv(location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glPrioritizeTexturesxOES(n: TGLsizei, textures: ptr TGLuint, priorities: ptr TGLfixed) {.importc.} - proc glGetTextureSamplerHandleNV(texture: TGLuint, sampler: TGLuint): TGLuint64 {.importc.} - proc glDeleteVertexArrays(n: TGLsizei, arrays: ptr TGLuint) {.importc.} - proc glMultiTexCoord1xOES(texture: TGLenum, s: TGLfixed) {.importc.} - proc glGlobalAlphaFactorusSUN(factor: TGLushort) {.importc.} - proc glGetConvolutionParameterxvOES(target: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glProgramUniform4fEXT(program: TGLuint, location: TGLint, v0: TGLfloat, v1: TGLfloat, v2: TGLfloat, v3: TGLfloat) {.importc.} - proc glProgramUniformMatrix3x4dvEXT(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} - proc glBindVertexBuffer(bindingindex: TGLuint, buffer: TGLuint, offset: TGLintptr, stride: TGLsizei) {.importc.} - proc glGetHistogramParameteriv(target: TGLenum, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glGetShaderPrecisionFormat(shadertype: TGLenum, precisiontype: TGLenum, range: ptr TGLint, precision: ptr TGLint) {.importc.} - proc glTextureMaterialEXT(face: TGLenum, mode: TGLenum) {.importc.} - proc glEvalCoord2xvOES(coords: ptr TGLfixed) {.importc.} - proc glWeightuivARB(size: TGLint, weights: ptr TGLuint) {.importc.} - proc glGetTextureLevelParameterfvEXT(texture: TGLuint, target: TGLenum, level: TGLint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glVertexAttribP3uiv(index: TGLuint, `type`: TGLenum, normalized: TGLboolean, value: ptr TGLuint) {.importc.} - proc glProgramEnvParameterI4ivNV(target: TGLenum, index: TGLuint, params: ptr TGLint) {.importc.} - proc glFogi(pname: TGLenum, param: TGLint) {.importc.} - proc glTexCoord1iv(v: ptr TGLint) {.importc.} - proc glReplacementCodeuiColor4ubVertex3fvSUN(rc: ptr TGLuint, c: ptr TGLubyte, v: ptr TGLfloat) {.importc.} - proc glProgramUniform1ui(program: TGLuint, location: TGLint, v0: TGLuint) {.importc.} - proc glMultiTexCoord3d(target: TGLenum, s: TGLdouble, t: TGLdouble, r: TGLdouble) {.importc.} - proc glBeginVideoCaptureNV(video_capture_slot: TGLuint) {.importc.} - proc glEvalCoord1f(u: TGLfloat) {.importc.} - proc glMultiTexCoord1hvNV(target: TGLenum, v: ptr TGLhalfNV) {.importc.} - proc glSecondaryColor3sEXT(red: TGLshort, green: TGLshort, blue: TGLshort) {.importc.} - proc glTextureImage3DEXT(texture: TGLuint, target: TGLenum, level: TGLint, internalformat: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, border: TGLint, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glCopyTexImage2D(target: TGLenum, level: TGLint, internalformat: TGLenum, x: TGLint, y: TGLint, width: TGLsizei, height: TGLsizei, border: TGLint) {.importc.} - proc glFinishFenceAPPLE(fence: TGLuint) {.importc.} - proc glVertexArrayRangeNV(length: TGLsizei, `pointer`: pointer) {.importc.} - proc glLightModelf(pname: TGLenum, param: TGLfloat) {.importc.} - proc glVertexAttribL1ui64ARB(index: TGLuint, x: TGLuint64EXT) {.importc.} - proc glPolygonOffset(factor: TGLfloat, units: TGLfloat) {.importc.} - proc glRasterPos4xOES(x: TGLfixed, y: TGLfixed, z: TGLfixed, w: TGLfixed) {.importc.} - proc glVertexAttrib3dvNV(index: TGLuint, v: ptr TGLdouble) {.importc.} - proc glBeginQuery(target: TGLenum, id: TGLuint) {.importc.} - proc glWeightfvARB(size: TGLint, weights: ptr TGLfloat) {.importc.} - proc glGetUniformuiv(program: TGLuint, location: TGLint, params: ptr TGLuint) {.importc.} - proc glIsTextureEXT(texture: TGLuint): TGLboolean {.importc.} - proc glGetClipPlanef(plane: TGLenum, equation: ptr TGLfloat) {.importc.} - proc glTexGenxOES(coord: TGLenum, pname: TGLenum, param: TGLfixed) {.importc.} - proc glFramebufferTextureFaceEXT(target: TGLenum, attachment: TGLenum, texture: TGLuint, level: TGLint, face: TGLenum) {.importc.} - proc glDisableClientState(`array`: TGLenum) {.importc.} - proc glTexPageCommitmentARB(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, resident: TGLboolean) {.importc.} - proc glRasterPos4dv(v: ptr TGLdouble) {.importc.} - proc glGetLightx(light: TGLenum, pname: TGLenum, params: ptr TGLfixed) {.importc.} - proc glVertexAttrib1hvNV(index: TGLuint, v: ptr TGLhalfNV) {.importc.} - proc glMultiTexCoord2s(target: TGLenum, s: TGLshort, t: TGLshort) {.importc.} - proc glProgramUniform2iv(program: TGLuint, location: TGLint, count: TGLsizei, value: ptr TGLint) {.importc.} - proc glGetListParameterivSGIX(list: TGLuint, pname: TGLenum, params: ptr TGLint) {.importc.} - proc glColorFragmentOp1ATI(op: TGLenum, dst: TGLuint, dstMask: TGLuint, dstMod: TGLuint, arg1: TGLuint, arg1Rep: TGLuint, arg1Mod: TGLuint) {.importc.} - proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc: TGLuint, s: TGLfloat, t: TGLfloat, r: TGLfloat, g: TGLfloat, b: TGLfloat, a: TGLfloat, nx: TGLfloat, ny: TGLfloat, nz: TGLfloat, x: TGLfloat, y: TGLfloat, z: TGLfloat) {.importc.} - proc glSampleMapATI(dst: TGLuint, interp: TGLuint, swizzle: TGLenum) {.importc.} - proc glProgramUniform1d(program: TGLuint, location: TGLint, v0: TGLdouble) {.importc.} - proc glBindAttribLocation(program: TGLuint, index: TGLuint, name: ptr TGLchar) {.importc.} - proc glGetCombinerStageParameterfvNV(stage: TGLenum, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glTexSubImage4DSGIS(target: TGLenum, level: TGLint, xoffset: TGLint, yoffset: TGLint, zoffset: TGLint, woffset: TGLint, width: TGLsizei, height: TGLsizei, depth: TGLsizei, size4d: TGLsizei, format: TGLenum, `type`: TGLenum, pixels: pointer) {.importc.} - proc glGetMapAttribParameterfvNV(target: TGLenum, index: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glNewObjectBufferATI(size: TGLsizei, `pointer`: pointer, usage: TGLenum): TGLuint {.importc.} - proc glWindowPos4iMESA(x: TGLint, y: TGLint, z: TGLint, w: TGLint) {.importc.} - proc glNewList(list: TGLuint, mode: TGLenum) {.importc.} - proc glUniform1i64NV(location: TGLint, x: TGLint64EXT) {.importc.} - proc glTexCoordP3ui(`type`: TGLenum, coords: TGLuint) {.importc.} - proc glEndQueryEXT(target: TGLenum) {.importc.} - proc glGetVertexAttribLdv(index: TGLuint, pname: TGLenum, params: ptr TGLdouble) {.importc.} - proc glStencilMask(mask: TGLuint) {.importc.} - proc glVertexAttrib4sv(index: TGLuint, v: ptr TGLshort) {.importc.} - proc glRectsv(v1: ptr TGLshort, v2: ptr TGLshort) {.importc.} - proc glGetVariantArrayObjectfvATI(id: TGLuint, pname: TGLenum, params: ptr TGLfloat) {.importc.} - proc glTexCoord3hvNV(v: ptr TGLhalfNV) {.importc.} - proc glGetUniformdv(program: TGLuint, location: TGLint, params: ptr TGLdouble) {.importc.} - proc glSecondaryColor3fvEXT(v: ptr TGLfloat) {.importc.} - proc glAlphaFuncx(func: TGLenum, `ref`: TGLfixed) {.importc.} - proc glVertexAttribPointerNV(index: TGLuint, fsize: TGLint, `type`: TGLenum, stride: TGLsizei, `pointer`: pointer) {.importc.} - proc glColorTable(target: TGLenum, internalformat: TGLenum, width: TGLsizei, format: TGLenum, `type`: TGLenum, table: pointer) {.importc.} - proc glProgramUniformMatrix2x3dv(program: TGLuint, location: TGLint, count: TGLsizei, transpose: TGLboolean, value: ptr TGLdouble) {.importc.} + proc glVDPAUUnregisterSurfaceNV(surface: GLvdpauSurfaceNV) {.importc.} + proc glTexCoord1s(s: GLshort) {.importc.} + proc glFramebufferTexture2DMultisampleIMG(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, samples: GLsizei) {.importc.} + proc glShaderBinary(count: GLsizei, shaders: ptr GLuint, binaryformat: GLenum, binary: pointer, length: GLsizei) {.importc.} + proc glVertexAttrib2dv(index: GLuint, v: ptr GLdouble) {.importc.} + proc glUniformMatrix4dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glWeightivARB(size: GLint, weights: ptr GLint) {.importc.} + proc glGetMultiTexParameterIivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glCopyConvolutionFilter2DEXT(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} + proc glSecondaryColor3hNV(red: GLhalfNV, green: GLhalfNV, blue: GLhalfNV) {.importc.} + proc glVertexAttrib1sv(index: GLuint, v: ptr GLshort) {.importc.} + proc glFrustumfOES(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} + proc glVertexStream2iATI(stream: GLenum, x: GLint, y: GLint) {.importc.} + proc glNormalStream3bATI(stream: GLenum, nx: GLbyte, ny: GLbyte, nz: GLbyte) {.importc.} + proc glVertexArrayTexCoordOffsetEXT(vaobj: GLuint, buffer: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glGetQueryiv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glTransformFeedbackStreamAttribsNV(count: GLsizei, attribs: ptr GLint, nbuffers: GLsizei, bufstreams: ptr GLint, bufferMode: GLenum) {.importc.} + proc glTextureStorage3DEXT(texture: GLuint, target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} + proc glWindowPos3dvMESA(v: ptr GLdouble) {.importc.} + proc glUniform2uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} + proc glTextureStorage2DEXT(texture: GLuint, target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glVertexArrayMultiTexCoordOffsetEXT(vaobj: GLuint, buffer: GLuint, texunit: GLenum, size: GLint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} + proc glVertexStream1dvATI(stream: GLenum, coords: ptr GLdouble) {.importc.} + proc glCopyImageSubData(srcName: GLuint, srcTarget: GLenum, srcLevel: GLint, srcX: GLint, srcY: GLint, srcZ: GLint, dstName: GLuint, dstTarget: GLenum, dstLevel: GLint, dstX: GLint, dstY: GLint, dstZ: GLint, srcWidth: GLsizei, srcHeight: GLsizei, srcDepth: GLsizei) {.importc.} + proc glClearNamedBufferSubDataEXT(buffer: GLuint, internalformat: GLenum, format: GLenum, `type`: GLenum, offset: GLsizeiptr, size: GLsizeiptr, data: ptr pointer) {.importc.} + proc glBindBuffersRange(target: GLenum, first: GLuint, count: GLsizei, buffers: ptr GLuint, offsets: ptr GLintptr, sizes: ptr GLsizeiptr) {.importc.} + proc glGetVertexAttribIuivEXT(index: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} + proc glLoadMatrixx(m: ptr GLfixed) {.importc.} + proc glTransformFeedbackVaryingsNV(program: GLuint, count: GLsizei, locations: ptr GLint, bufferMode: GLenum) {.importc.} + proc glUniform1i64vNV(location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} + proc glVertexArrayVertexAttribLFormatEXT(vaobj: GLuint, attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} + proc glClearBufferuiv(buffer: GLenum, drawbuffer: GLint, value: ptr GLuint) {.importc.} + proc glCombinerOutputNV(stage: GLenum, portion: GLenum, abOutput: GLenum, cdOutput: GLenum, sumOutput: GLenum, scale: GLenum, bias: GLenum, abDotProduct: GLboolean, cdDotProduct: GLboolean, muxSum: GLboolean) {.importc.} + proc glTexImage3DEXT(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glPixelTransformParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glActiveStencilFaceEXT(face: GLenum) {.importc.} + proc glCreateShaderObjectARB(shaderType: GLenum): TGLhandleARB {.importc.} + proc glGetTextureParameterivEXT(texture: GLuint, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glCopyTextureLevelsAPPLE(destinationTexture: GLuint, sourceTexture: GLuint, sourceBaseLevel: GLint, sourceLevelCount: GLsizei) {.importc.} + proc glVertexAttrib4Nuiv(index: GLuint, v: ptr GLuint) {.importc.} + proc glDrawPixels(width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glWindowPos3dvARB(v: ptr GLdouble) {.importc.} + proc glProgramLocalParameterI4ivNV(target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glRasterPos4s(x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} + proc glTexCoord2fVertex3fvSUN(tc: ptr GLfloat, v: ptr GLfloat) {.importc.} + proc glGetPathMetricsNV(metricQueryMask: GLbitfield, numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, stride: GLsizei, metrics: ptr GLfloat) {.importc.} + proc glMultiTexCoord4bOES(texture: GLenum, s: GLbyte, t: GLbyte, r: GLbyte, q: GLbyte) {.importc.} + proc glTextureBufferEXT(texture: GLuint, target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} + proc glSecondaryColor3fv(v: ptr GLfloat) {.importc.} + proc glMultiTexCoord3fv(target: GLenum, v: ptr GLfloat) {.importc.} + proc glGetTexParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glMap2xOES(target: GLenum, u1: GLfixed, u2: GLfixed, ustride: GLint, uorder: GLint, v1: GLfixed, v2: GLfixed, vstride: GLint, vorder: GLint, points: GLfixed) {.importc.} + proc glFlushVertexArrayRangeAPPLE(length: GLsizei, `pointer`: pointer) {.importc.} + proc glActiveTextureARB(texture: GLenum) {.importc.} + proc glGetVertexAttribLi64vNV(index: GLuint, pname: GLenum, params: ptr GLint64EXT) {.importc.} + proc glNormal3bv(v: ptr GLbyte) {.importc.} + proc glCreateSyncFromCLeventARB(context: ptr TCL_context, event: ptr TCL_context, flags: GLbitfield): TGLsync {.importc.} + proc glRenderbufferStorageEXT(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} + proc glGetCompressedTextureImageEXT(texture: GLuint, target: GLenum, lod: GLint, img: pointer) {.importc.} + proc glColorFragmentOp2ATI(op: GLenum, dst: GLuint, dstMask: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint) {.importc.} + proc glPixelMapusv(map: GLenum, mapsize: GLsizei, values: ptr GLushort) {.importc.} + proc glGlobalAlphaFactorsSUN(factor: GLshort) {.importc.} + proc glTexParameterxv(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glEvalCoord2xOES(u: GLfixed, v: GLfixed) {.importc.} + proc glIsList(list: GLuint): TGLboolean {.importc.} + proc glVertexAttrib3d(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} + proc glSpriteParameterfSGIX(pname: GLenum, param: GLfloat) {.importc.} + proc glPathGlyphRangeNV(firstPathName: GLuint, fontTarget: GLenum, fontName: pointer, fontStyle: GLbitfield, firstGlyph: GLuint, numGlyphs: GLsizei, handleMissingGlyphs: GLenum, pathParameterTemplate: GLuint, emScale: GLfloat) {.importc.} + proc glUniform3iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glClearBufferfi(buffer: GLenum, drawbuffer: GLint, depth: GLfloat, stencil: GLint) {.importc.} + proc glWindowPos3sMESA(x: GLshort, y: GLshort, z: GLshort) {.importc.} + proc glGetMapParameterfvNV(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glBindFragmentShaderATI(id: GLuint) {.importc.} + proc glTexCoord4s(s: GLshort, t: GLshort, r: GLshort, q: GLshort) {.importc.} + proc glGetMultiTexGenfvEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glColorMaterial(face: GLenum, mode: GLenum) {.importc.} + proc glVertexAttribs1svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} + proc glEnableVertexAttribAPPLE(index: GLuint, pname: GLenum) {.importc.} + proc glGetDoubleIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLdouble) {.importc.} + proc glOrthof(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} + proc glVertexBlendEnvfATI(pname: GLenum, param: GLfloat) {.importc.} + proc glUniformMatrix2x4dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glPrioritizeTexturesxOES(n: GLsizei, textures: ptr GLuint, priorities: ptr GLfixed) {.importc.} + proc glGetTextureSamplerHandleNV(texture: GLuint, sampler: GLuint): TGLuint64 {.importc.} + proc glDeleteVertexArrays(n: GLsizei, arrays: ptr GLuint) {.importc.} + proc glMultiTexCoord1xOES(texture: GLenum, s: GLfixed) {.importc.} + proc glGlobalAlphaFactorusSUN(factor: GLushort) {.importc.} + proc glGetConvolutionParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glProgramUniform4fEXT(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat, v3: GLfloat) {.importc.} + proc glProgramUniformMatrix3x4dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} + proc glBindVertexBuffer(bindingindex: GLuint, buffer: GLuint, offset: GLintptr, stride: GLsizei) {.importc.} + proc glGetHistogramParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetShaderPrecisionFormat(shadertype: GLenum, precisiontype: GLenum, range: ptr GLint, precision: ptr GLint) {.importc.} + proc glTextureMaterialEXT(face: GLenum, mode: GLenum) {.importc.} + proc glEvalCoord2xvOES(coords: ptr GLfixed) {.importc.} + proc glWeightuivARB(size: GLint, weights: ptr GLuint) {.importc.} + proc glGetTextureLevelParameterfvEXT(texture: GLuint, target: GLenum, level: GLint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glVertexAttribP3uiv(index: GLuint, `type`: GLenum, normalized: GLboolean, value: ptr GLuint) {.importc.} + proc glProgramEnvParameterI4ivNV(target: GLenum, index: GLuint, params: ptr GLint) {.importc.} + proc glFogi(pname: GLenum, param: GLint) {.importc.} + proc glTexCoord1iv(v: ptr GLint) {.importc.} + proc glReplacementCodeuiColor4ubVertex3fvSUN(rc: ptr GLuint, c: ptr GLubyte, v: ptr GLfloat) {.importc.} + proc glProgramUniform1ui(program: GLuint, location: GLint, v0: GLuint) {.importc.} + proc glMultiTexCoord3d(target: GLenum, s: GLdouble, t: GLdouble, r: GLdouble) {.importc.} + proc glBeginVideoCaptureNV(video_capture_slot: GLuint) {.importc.} + proc glEvalCoord1f(u: GLfloat) {.importc.} + proc glMultiTexCoord1hvNV(target: GLenum, v: ptr GLhalfNV) {.importc.} + proc glSecondaryColor3sEXT(red: GLshort, green: GLshort, blue: GLshort) {.importc.} + proc glTextureImage3DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glCopyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) {.importc.} + proc glFinishFenceAPPLE(fence: GLuint) {.importc.} + proc glVertexArrayRangeNV(length: GLsizei, `pointer`: pointer) {.importc.} + proc glLightModelf(pname: GLenum, param: GLfloat) {.importc.} + proc glVertexAttribL1ui64ARB(index: GLuint, x: GLuint64EXT) {.importc.} + proc glPolygonOffset(factor: GLfloat, units: GLfloat) {.importc.} + proc glRasterPos4xOES(x: GLfixed, y: GLfixed, z: GLfixed, w: GLfixed) {.importc.} + proc glVertexAttrib3dvNV(index: GLuint, v: ptr GLdouble) {.importc.} + proc glBeginQuery(target: GLenum, id: GLuint) {.importc.} + proc glWeightfvARB(size: GLint, weights: ptr GLfloat) {.importc.} + proc glGetUniformuiv(program: GLuint, location: GLint, params: ptr GLuint) {.importc.} + proc glIsTextureEXT(texture: GLuint): TGLboolean {.importc.} + proc glGetClipPlanef(plane: GLenum, equation: ptr GLfloat) {.importc.} + proc glTexGenxOES(coord: GLenum, pname: GLenum, param: GLfixed) {.importc.} + proc glFramebufferTextureFaceEXT(target: GLenum, attachment: GLenum, texture: GLuint, level: GLint, face: GLenum) {.importc.} + proc glDisableClientState(`array`: GLenum) {.importc.} + proc glTexPageCommitmentARB(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, resident: GLboolean) {.importc.} + proc glRasterPos4dv(v: ptr GLdouble) {.importc.} + proc glGetLightx(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} + proc glVertexAttrib1hvNV(index: GLuint, v: ptr GLhalfNV) {.importc.} + proc glMultiTexCoord2s(target: GLenum, s: GLshort, t: GLshort) {.importc.} + proc glProgramUniform2iv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint) {.importc.} + proc glGetListParameterivSGIX(list: GLuint, pname: GLenum, params: ptr GLint) {.importc.} + proc glColorFragmentOp1ATI(op: GLenum, dst: GLuint, dstMask: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint) {.importc.} + proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} + proc glSampleMapATI(dst: GLuint, interp: GLuint, swizzle: GLenum) {.importc.} + proc glProgramUniform1d(program: GLuint, location: GLint, v0: GLdouble) {.importc.} + proc glBindAttribLocation(program: GLuint, index: GLuint, name: ptr GLchar) {.importc.} + proc glGetCombinerStageParameterfvNV(stage: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexSubImage4DSGIS(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, woffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, size4d: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} + proc glGetMapAttribParameterfvNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glNewObjectBufferATI(size: GLsizei, `pointer`: pointer, usage: GLenum): TGLuint {.importc.} + proc glWindowPos4iMESA(x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} + proc glNewList(list: GLuint, mode: GLenum) {.importc.} + proc glUniform1i64NV(location: GLint, x: GLint64EXT) {.importc.} + proc glTexCoordP3ui(`type`: GLenum, coords: GLuint) {.importc.} + proc glEndQueryEXT(target: GLenum) {.importc.} + proc glGetVertexAttribLdv(index: GLuint, pname: GLenum, params: ptr GLdouble) {.importc.} + proc glStencilMask(mask: GLuint) {.importc.} + proc glVertexAttrib4sv(index: GLuint, v: ptr GLshort) {.importc.} + proc glRectsv(v1: ptr GLshort, v2: ptr GLshort) {.importc.} + proc glGetVariantArrayObjectfvATI(id: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} + proc glTexCoord3hvNV(v: ptr GLhalfNV) {.importc.} + proc glGetUniformdv(program: GLuint, location: GLint, params: ptr GLdouble) {.importc.} + proc glSecondaryColor3fvEXT(v: ptr GLfloat) {.importc.} + proc glAlphaFuncx(func: GLenum, `ref`: GLfixed) {.importc.} + proc glVertexAttribPointerNV(index: GLuint, fsize: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} + proc glColorTable(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, table: pointer) {.importc.} + proc glProgramUniformMatrix2x3dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} {.pop.} # stdcall, hint[XDeclaredButNotUsed]: off. const @@ -3138,7 +3225,7 @@ const GL_PIXEL_MAP_B_TO_B* = 0x0C78 cGL_VERTEX_BLEND_ARB* = 0x86A7 GL_LIGHT2* = 0x4002 - GL_BYTE* = 0x1400 + cGL_BYTE* = 0x1400 GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS* = 0x92D3 GL_DOMAIN* = 0x0A02 GL_PROGRAM_NATIVE_TEMPORARIES_ARB* = 0x88A6 @@ -3701,7 +3788,7 @@ const GL_RGB16F_ARB* = 0x881B GL_ANY_SAMPLES_PASSED_CONSERVATIVE* = 0x8D6A GL_BLUE_MAX_CLAMP_INGR* = 0x8566 - GL_FLOAT* = 0x1406 + cGL_FLOAT* = 0x1406 GL_STENCIL_INDEX8_EXT* = 0x8D48 GL_POINT_SIZE_ARRAY_OES* = 0x8B9C GL_INT16_NV* = 0x8FE4 @@ -4348,7 +4435,7 @@ const GL_BUFFER_IMMUTABLE_STORAGE* = 0x821F GL_FLOAT_R16_NV* = 0x8884 GL_GREEN_INTEGER_EXT* = 0x8D95 - GL_FIXED* = 0x140C + cGL_FIXED* = 0x140C GL_LIST_PRIORITY_SGIX* = 0x8182 GL_DRAW_BUFFER6_EXT* = 0x882B GL_OFFSET_TEXTURE_BIAS_NV* = 0x86E3 @@ -6586,7 +6673,7 @@ const GL_DEBUG_SOURCE_THIRD_PARTY_ARB* = 0x8249 GL_R8_EXT* = 0x8229 cGL_GENERATE_MIPMAP* = 0x8191 - GL_SHORT* = 0x1402 + cGL_SHORT* = 0x1402 GL_PACK_REVERSE_ROW_ORDER_ANGLE* = 0x93A4 GL_PATH_DASH_OFFSET_RESET_NV* = 0x90B4 GL_PACK_SKIP_VOLUMES_SGIS* = 0x8130 @@ -7640,7 +7727,7 @@ const GL_VERTEX_SHADER_BINDING_EXT* = 0x8781 GL_BLEND_DST_RGB_EXT* = 0x80C8 GL_QUADS* = 0x0007 - GL_INT* = 0x1404 + cGL_INT* = 0x1404 GL_PIXEL_TEX_GEN_MODE_SGIX* = 0x832B GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB* = 0x8E8F GL_SAMPLE_ALPHA_TO_ONE_ARB* = 0x809F @@ -7840,7 +7927,7 @@ const GL_DEBUG_SOURCE_APPLICATION_KHR* = 0x824A GL_COMPRESSED_RGB_S3TC_DXT1_EXT* = 0x83F0 GL_DEBUG_SOURCE_OTHER_ARB* = 0x824B - GL_DOUBLE* = 0x140A + cGL_DOUBLE* = 0x140A GL_STENCIL_TEST_TWO_SIDE_EXT* = 0x8910 GL_MIN_PROGRAM_TEXEL_OFFSET* = 0x8904 GL_3DC_X_AMD* = 0x87F9 From ea4a1ac9b47a1cd88fc4b0d9c568ca93940e17e6 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Wed, 16 Apr 2014 00:39:06 +0200 Subject: [PATCH 11/18] Add old name for constant. --- lib/opengl.nim | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/opengl.nim b/lib/opengl.nim index ead7c64..364e47f 100644 --- a/lib/opengl.nim +++ b/lib/opengl.nim @@ -3164,6 +3164,7 @@ wrapErrorChecking: {.pop.} # stdcall, hint[XDeclaredButNotUsed]: off. const + cGL_UNSIGNED_BYTE = 0x1401 GL_2X_BIT_ATI* = 0x00000001 GL_MODELVIEW6_ARB* = 0x8726 GL_CULL_FACE_MODE* = 0x0B45 From 5bf3cb3f128b27231e863cb629b86a20c15a9467 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Wed, 16 Apr 2014 00:51:24 +0200 Subject: [PATCH 12/18] Revert... --- opengl.babel | 2 +- {lib => src}/glext.nim | 0 {lib => src}/glu.nim | 0 {lib => src}/glut.nim | 0 {lib => src}/glx.nim | 0 {lib => src}/opengl.nim | 0 {lib => src}/wingl.nim | 0 7 files changed, 1 insertion(+), 1 deletion(-) rename {lib => src}/glext.nim (100%) rename {lib => src}/glu.nim (100%) rename {lib => src}/glut.nim (100%) rename {lib => src}/glx.nim (100%) rename {lib => src}/opengl.nim (100%) rename {lib => src}/wingl.nim (100%) diff --git a/opengl.babel b/opengl.babel index 7f22fd8..a5dfe9c 100644 --- a/opengl.babel +++ b/opengl.babel @@ -5,7 +5,7 @@ author: "Andreas Rumpf" description: "High-level and low-level wrapper for OpenGL" license: "MIT" -srcDir: "lib" +srcDir: "src" [Deps] requires: "nimrod > 0.9.2, x11" diff --git a/lib/glext.nim b/src/glext.nim similarity index 100% rename from lib/glext.nim rename to src/glext.nim diff --git a/lib/glu.nim b/src/glu.nim similarity index 100% rename from lib/glu.nim rename to src/glu.nim diff --git a/lib/glut.nim b/src/glut.nim similarity index 100% rename from lib/glut.nim rename to src/glut.nim diff --git a/lib/glx.nim b/src/glx.nim similarity index 100% rename from lib/glx.nim rename to src/glx.nim diff --git a/lib/opengl.nim b/src/opengl.nim similarity index 100% rename from lib/opengl.nim rename to src/opengl.nim diff --git a/lib/wingl.nim b/src/wingl.nim similarity index 100% rename from lib/wingl.nim rename to src/wingl.nim From 923a2f770c74dda039b170ac56eec83ff4fc2da3 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Wed, 16 Apr 2014 01:00:24 +0200 Subject: [PATCH 13/18] Forgot to export symbol. --- src/opengl.nim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/opengl.nim b/src/opengl.nim index 364e47f..cd8a24c 100644 --- a/src/opengl.nim +++ b/src/opengl.nim @@ -3164,7 +3164,7 @@ wrapErrorChecking: {.pop.} # stdcall, hint[XDeclaredButNotUsed]: off. const - cGL_UNSIGNED_BYTE = 0x1401 + cGL_UNSIGNED_BYTE* = 0x1401 GL_2X_BIT_ATI* = 0x00000001 GL_MODELVIEW6_ARB* = 0x8726 GL_CULL_FACE_MODE* = 0x0B45 From dcb63e1d2d3b8e700370271b719f83f84eb96e34 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Wed, 16 Apr 2014 01:04:14 +0200 Subject: [PATCH 14/18] Add another old alias. --- src/opengl.nim | 1 + 1 file changed, 1 insertion(+) diff --git a/src/opengl.nim b/src/opengl.nim index cd8a24c..55ef6bd 100644 --- a/src/opengl.nim +++ b/src/opengl.nim @@ -110,6 +110,7 @@ type GLubyte* = uint8 GLushort* = uint16 GLuint* = uint32 + GLhandle* = GLuint GLsizei* = int32 GLfloat* = float32 GLclampf* = float32 From ff47db4a77a0fb46ea68efb4fa98e82c8d35c9e7 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Wed, 16 Apr 2014 01:28:24 +0200 Subject: [PATCH 15/18] ptr GLchar -> cstring; ptr ptr GLchar -> cstringArray --- src/opengl.nim | 172 ++++++++++++++++++++++++------------------------- 1 file changed, 86 insertions(+), 86 deletions(-) diff --git a/src/opengl.nim b/src/opengl.nim index 55ef6bd..365c6b7 100644 --- a/src/opengl.nim +++ b/src/opengl.nim @@ -116,9 +116,9 @@ type GLclampf* = float32 GLdouble* = float64 GLclampd* = float64 - GLeglImageOES* = pointer + GLeglImageOES* = distinct pointer GLchar* = char - GLcharARB* = cchar + GLcharARB* = char GLfixed* = int32 GLhalfNV* = uint16 GLvdpauSurfaceNV* = uint @@ -129,7 +129,7 @@ type GLint64* = int64 GLsizeiptrARB* = int32 GLsizeiptr* = int32 - GLsync* = pointer + GLsync* = distinct pointer GLuint64* = uint64 TGLenum* = uint32 @@ -148,9 +148,9 @@ type TGLclampf* = float32 TGLdouble* = float64 TGLclampd* = float64 - TGLeglImageOES* = pointer + TGLeglImageOES* = distinct pointer TGLchar* = char - TGLcharARB* = cchar + TGLcharARB* = char TGLfixed* = int32 TGLhalfNV* = uint16 TGLvdpauSurfaceNV* = uint @@ -161,7 +161,7 @@ type TGLint64* = int64 TGLsizeiptrARB* = int32 TGLsizeiptr* = int32 - TGLsync* = pointer + TGLsync* = distinct pointer TGLuint64* = uint64 TCL_context* = distinct pointer @@ -358,7 +358,7 @@ wrapErrorChecking: proc glColor4dv(v: ptr GLdouble) {.importc.} proc glColor3fv(v: ptr GLfloat) {.importc.} proc glVertexAttribI1uiEXT(index: GLuint, x: GLuint) {.importc.} - proc glGetDebugMessageLogKHR(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} + proc glGetDebugMessageLogKHR(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): TGLuint {.importc.} proc glVertexAttribI2iv(index: GLuint, v: ptr GLint) {.importc.} proc glTexCoord1xvOES(coords: ptr GLfixed) {.importc.} proc glVertex3hNV(x: GLhalfNV, y: GLhalfNV, z: GLhalfNV) {.importc.} @@ -446,7 +446,7 @@ wrapErrorChecking: proc glImageTransformParameterfvHP(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glUniform3uiEXT(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} proc glGetInvariantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} - proc glGetTransformFeedbackVaryingEXT(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGetTransformFeedbackVaryingEXT(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} proc glSamplerParameterIuiv(sampler: GLuint, pname: GLenum, param: ptr GLuint) {.importc.} proc glProgramUniform2fEXT(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} proc glMultiTexCoord2hvNV(target: GLenum, v: ptr GLhalfNV) {.importc.} @@ -457,14 +457,14 @@ wrapErrorChecking: proc glFenceSyncAPPLE(condition: GLenum, flags: GLbitfield): TGLsync {.importc.} proc glGetVariantArrayObjectivATI(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glProgramUniform4dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} - proc glPushDebugGroupKHR(source: GLenum, id: GLuint, length: GLsizei, message: ptr GLchar) {.importc.} + proc glPushDebugGroupKHR(source: GLenum, id: GLuint, length: GLsizei, message: cstring) {.importc.} proc glFragmentLightivSGIX(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glFramebufferTexture2DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} proc glGetActiveSubroutineUniformiv(program: GLuint, shadertype: GLenum, index: GLuint, pname: GLenum, values: ptr GLint) {.importc.} proc glFrustumf(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} proc glEndQueryIndexed(target: GLenum, index: GLuint) {.importc.} proc glCompressedTextureSubImage3DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} - proc glGetProgramPipelineInfoLogEXT(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetProgramPipelineInfoLogEXT(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} proc glGetVertexAttribfvNV(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} proc glVertexArrayIndexOffsetEXT(vaobj: GLuint, buffer: GLuint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} proc glDrawTexsvOES(coords: ptr GLshort) {.importc.} @@ -484,7 +484,7 @@ wrapErrorChecking: proc glColor3bv(v: ptr GLbyte) {.importc.} proc glNamedProgramLocalParameter4dEXT(program: GLuint, target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} proc glVertexPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} - proc glGetObjectLabelKHR(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glGetObjectLabelKHR(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} proc glCombinerStageParameterfvNV(stage: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glNormal3hvNV(v: ptr GLhalfNV) {.importc.} proc glUniform2i64NV(location: GLint, x: GLint64EXT, y: GLint64EXT) {.importc.} @@ -553,9 +553,9 @@ wrapErrorChecking: proc glFlushMappedBufferRangeEXT(target: GLenum, offset: GLintptr, length: GLsizeiptr) {.importc.} proc glNormal3dv(v: ptr GLdouble) {.importc.} proc glProgramUniform4d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble, v2: GLdouble, v3: GLdouble) {.importc.} - proc glCreateShaderProgramEXT(`type`: GLenum, string: ptr GLchar): TGLuint {.importc.} + proc glCreateShaderProgramEXT(`type`: GLenum, string: cstring): TGLuint {.importc.} proc glGetLightxvOES(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} - proc glGetObjectPtrLabelKHR(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glGetObjectPtrLabelKHR(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} proc glTransformPathNV(resultPath: GLuint, srcPath: GLuint, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} proc glMultTransposeMatrixf(m: ptr GLfloat) {.importc.} proc glMapVertexAttrib2dAPPLE(index: GLuint, size: GLuint, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: ptr GLdouble) {.importc.} @@ -575,7 +575,7 @@ wrapErrorChecking: proc glMultiTexEnviEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLint) {.importc.} proc glProgramUniform1fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} proc glDrawBuffersARB(n: GLsizei, bufs: ptr GLenum) {.importc.} - proc glGetUniformLocationARB(programObj: GLhandleARB, name: ptr GLcharARB): TGLint {.importc.} + proc glGetUniformLocationARB(programObj: GLhandleARB, name: cstring): TGLint {.importc.} proc glResumeTransformFeedback() {.importc.} proc glMap1f(target: GLenum, u1: GLfloat, u2: GLfloat, stride: GLint, order: GLint, points: ptr GLfloat) {.importc.} proc glVertex3xOES(x: GLfixed, y: GLfixed) {.importc.} @@ -587,7 +587,7 @@ wrapErrorChecking: proc glGetVertexArrayPointeri_vEXT(vaobj: GLuint, index: GLuint, pname: GLenum, param: ptr pointer) {.importc.} proc glProgramParameter4fvNV(target: GLenum, index: GLuint, v: ptr GLfloat) {.importc.} proc glDiscardFramebufferEXT(target: GLenum, numAttachments: GLsizei, attachments: ptr GLenum) {.importc.} - proc glGetDebugMessageLogARB(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} + proc glGetDebugMessageLogARB(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): TGLuint {.importc.} proc glResolveMultisampleFramebufferAPPLE() {.importc.} proc glGetIntegeri_vEXT(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} proc glDepthBoundsdNV(zmin: GLdouble, zmax: GLdouble) {.importc.} @@ -642,7 +642,7 @@ wrapErrorChecking: proc glVertexAttribL4i64vNV(index: GLuint, v: ptr GLint64EXT) {.importc.} proc glEnableVariantClientStateEXT(id: GLuint) {.importc.} proc glSyncTextureINTEL(texture: GLuint) {.importc.} - proc glGetObjectPtrLabel(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glGetObjectPtrLabel(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} proc glCopyTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} proc glOrthofOES(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} proc glWindowPos3sARB(x: GLshort, y: GLshort, z: GLshort) {.importc.} @@ -665,7 +665,7 @@ wrapErrorChecking: proc glVertexP2ui(`type`: GLenum, value: GLuint) {.importc.} proc glGenQueries(n: GLsizei, ids: ptr GLuint) {.importc.} proc glBindBufferOffsetNV(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr) {.importc.} - proc glGetFragDataLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetFragDataLocation(program: GLuint, name: cstring): TGLint {.importc.} proc glVertexAttribs2svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} proc glGetPathLengthNV(path: GLuint, startSegment: GLsizei, numSegments: GLsizei): TGLfloat {.importc.} proc glVertexAttrib3dARB(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} @@ -731,7 +731,7 @@ wrapErrorChecking: proc glGetFixedv(pname: GLenum, params: ptr GLfixed) {.importc.} proc glMaterialf(face: GLenum, pname: GLenum, param: GLfloat) {.importc.} proc glVideoCaptureStreamParameterfvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetDebugMessageLogAMD(count: GLuint, bufsize: GLsizei, categories: ptr GLenum, severities: ptr GLuint, ids: ptr GLuint, lengths: ptr GLsizei, message: ptr GLchar): TGLuint {.importc.} + proc glGetDebugMessageLogAMD(count: GLuint, bufsize: GLsizei, categories: ptr GLenum, severities: ptr GLuint, ids: ptr GLuint, lengths: ptr GLsizei, message: cstring): TGLuint {.importc.} proc glProgramUniform2uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glMatrixMultTransposedEXT(mode: GLenum, m: ptr GLdouble) {.importc.} proc glIsPointInStrokePathNV(path: GLuint, x: GLfloat, y: GLfloat): TGLboolean {.importc.} @@ -767,7 +767,7 @@ wrapErrorChecking: proc glTexStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} proc glMultiTexCoord2xOES(texture: GLenum, s: GLfixed, t: GLfixed) {.importc.} proc glWindowPos2fARB(x: GLfloat, y: GLfloat) {.importc.} - proc glGetProgramResourceIndex(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLuint {.importc.} + proc glGetProgramResourceIndex(program: GLuint, programInterface: GLenum, name: cstring): TGLuint {.importc.} proc glProgramUniform2uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glMakeImageHandleNonResidentNV(handle: GLuint64) {.importc.} proc glNamedProgramLocalParameter4fvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} @@ -793,7 +793,7 @@ wrapErrorChecking: proc glProgramLocalParameterI4uivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} proc glRenderMode(mode: GLenum): TGLint {.importc.} proc glVertexStream4fATI(stream: GLenum, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} - proc glGetObjectLabelEXT(`type`: GLenum, `object`: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glGetObjectLabelEXT(`type`: GLenum, `object`: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} proc glNamedFramebufferTexture3DEXT(framebuffer: GLuint, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} proc glLoadMatrixf(m: ptr GLfloat) {.importc.} proc glGetQueryObjectuivEXT(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} @@ -803,7 +803,7 @@ wrapErrorChecking: proc glTexGenxvOES(coord: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} proc glMatrixMode(mode: GLenum) {.importc.} proc glColorTableParameterivSGI(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} - proc glGetProgramInfoLog(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetProgramInfoLog(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} proc glGetSeparableFilter(target: GLenum, format: GLenum, `type`: GLenum, row: pointer, column: pointer, span: pointer) {.importc.} proc glFogfv(pname: GLenum, params: ptr GLfloat) {.importc.} proc glDrawTexfvOES(coords: ptr GLfloat) {.importc.} @@ -829,7 +829,7 @@ wrapErrorChecking: proc glBeginConditionalRender(id: GLuint, mode: GLenum) {.importc.} proc glVertexAttribI3uiEXT(index: GLuint, x: GLuint, y: GLuint, z: GLuint) {.importc.} proc glVDPAUMapSurfacesNV(numSurfaces: GLsizei, surfaces: ptr GLvdpauSurfaceNV) {.importc.} - proc glGetProgramResourceName(program: GLuint, programInterface: GLenum, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} + proc glGetProgramResourceName(program: GLuint, programInterface: GLenum, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} proc glMultiTexCoord4f(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} proc glVertexAttrib2hNV(index: GLuint, x: GLhalfNV, y: GLhalfNV) {.importc.} proc glDrawArraysInstancedNV(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei) {.importc.} @@ -850,7 +850,7 @@ wrapErrorChecking: proc glReferencePlaneSGIX(equation: ptr GLdouble) {.importc.} proc glNormalStream3iATI(stream: GLenum, nx: GLint, ny: GLint, nz: GLint) {.importc.} proc glGetColorTableParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetAttribLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetAttribLocation(program: GLuint, name: cstring): TGLint {.importc.} proc glMultiTexParameterfEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLfloat) {.importc.} proc glGenFencesNV(n: GLsizei, fences: ptr GLuint) {.importc.} proc glUniform4dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} @@ -877,7 +877,7 @@ wrapErrorChecking: proc glMultiTexCoord3fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} proc glRasterPos3xOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} proc glEGLImageTargetRenderbufferStorageOES(target: GLenum, image: GLeglImageOES) {.importc.} - proc glGetAttribLocationARB(programObj: GLhandleARB, name: ptr GLcharARB): TGLint {.importc.} + proc glGetAttribLocationARB(programObj: GLhandleARB, name: cstring): TGLint {.importc.} proc glProgramNamedParameter4dvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, v: ptr GLdouble) {.importc.} proc glProgramLocalParameterI4uiNV(target: GLenum, index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} proc glNamedFramebufferTextureFaceEXT(framebuffer: GLuint, attachment: GLenum, texture: GLuint, level: GLint, face: GLenum) {.importc.} @@ -954,7 +954,7 @@ wrapErrorChecking: proc glGetPixelTexGenParameterivSGIS(pname: GLenum, params: ptr GLint) {.importc.} proc glVariantuivEXT(id: GLuint, `addr`: ptr GLuint) {.importc.} proc glTexParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetSubroutineUniformLocation(program: GLuint, shadertype: GLenum, name: ptr GLchar): TGLint {.importc.} + proc glGetSubroutineUniformLocation(program: GLuint, shadertype: GLenum, name: cstring): TGLint {.importc.} proc glProgramUniformMatrix3fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} proc glDrawBuffersATI(n: GLsizei, bufs: ptr GLenum) {.importc.} proc glGetVertexAttribivNV(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} @@ -995,7 +995,7 @@ wrapErrorChecking: proc glTexCoord3f(s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} proc glMultiTexCoord1fARB(target: GLenum, s: GLfloat) {.importc.} proc glVertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} - proc glGetFragDataLocationEXT(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetFragDataLocationEXT(program: GLuint, name: cstring): TGLint {.importc.} proc glFlushMappedNamedBufferRangeEXT(buffer: GLuint, offset: GLintptr, length: GLsizeiptr) {.importc.} proc glVertexAttrib1sARB(index: GLuint, x: GLshort) {.importc.} proc glBitmapxOES(width: GLsizei, height: GLsizei, xorig: GLfixed, yorig: GLfixed, xmove: GLfixed, ymove: GLfixed, bitmap: ptr GLubyte) {.importc.} @@ -1024,7 +1024,7 @@ wrapErrorChecking: proc glEnableDriverControlQCOM(driverControl: GLuint) {.importc.} proc glPointParameteri(pname: GLenum, param: GLint) {.importc.} proc glVertexAttribI2i(index: GLuint, x: GLint, y: GLint) {.importc.} - proc glGetDriverControlStringQCOM(driverControl: GLuint, bufSize: GLsizei, length: ptr GLsizei, driverControlString: ptr GLchar) {.importc.} + proc glGetDriverControlStringQCOM(driverControl: GLuint, bufSize: GLsizei, length: ptr GLsizei, driverControlString: cstring) {.importc.} proc glGetTexLevelParameteriv(target: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} proc glGetHandleARB(pname: GLenum): TGLhandleARB {.importc.} proc glIndexubv(c: ptr GLubyte) {.importc.} @@ -1058,7 +1058,7 @@ wrapErrorChecking: proc glVertexAttribI1iEXT(index: GLuint, x: GLint) {.importc.} proc glFramebufferTexture1D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} proc glVertexAttribI2uiv(index: GLuint, v: ptr GLuint) {.importc.} - proc glBindFragDataLocation(program: GLuint, color: GLuint, name: ptr GLchar) {.importc.} + proc glBindFragDataLocation(program: GLuint, color: GLuint, name: cstring) {.importc.} proc glClearStencil(s: GLint) {.importc.} proc glVertexAttrib4Nubv(index: GLuint, v: ptr GLubyte) {.importc.} proc glConvolutionFilter2DEXT(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} @@ -1103,7 +1103,7 @@ wrapErrorChecking: proc glGetMinmaxParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glColor4fNormal3fVertex3fSUN(r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glWindowPos2d(x: GLdouble, y: GLdouble) {.importc.} - proc glGetPerfMonitorGroupStringAMD(group: GLuint, bufSize: GLsizei, length: ptr GLsizei, groupString: ptr GLchar) {.importc.} + proc glGetPerfMonitorGroupStringAMD(group: GLuint, bufSize: GLsizei, length: ptr GLsizei, groupString: cstring) {.importc.} proc glUniformHandleui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64) {.importc.} proc glBlendEquation(mode: GLenum) {.importc.} proc glMapBufferARB(target: GLenum, access: GLenum) {.importc.} @@ -1145,7 +1145,7 @@ wrapErrorChecking: proc glVertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat) {.importc.} proc glMultiTexGenivEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glUniformui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} - proc glGetInfoLogARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, infoLog: ptr GLcharARB) {.importc.} + proc glGetInfoLogARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} proc glGetNamedProgramLocalParameterIivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLint) {.importc.} proc glVertexAttrib4s(index: GLuint, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} proc glUniformMatrix4x2dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} @@ -1162,7 +1162,7 @@ wrapErrorChecking: proc glTexParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetArrayObjectivATI(`array`: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetTexParameterIuiv(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} - proc glGetProgramPipelineInfoLog(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetProgramPipelineInfoLog(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} proc glGetOcclusionQueryuivNV(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} proc glVertexAttrib4bvARB(index: GLuint, v: ptr GLbyte) {.importc.} proc glListParameterfvSGIX(list: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} @@ -1206,7 +1206,7 @@ wrapErrorChecking: proc glProgramUniform2dEXT(program: GLuint, location: GLint, x: GLdouble, y: GLdouble) {.importc.} proc glCompressedMultiTexImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} proc glDeleteSyncAPPLE(sync: GLsync) {.importc.} - proc glDebugMessageInsertAMD(category: GLenum, severity: GLenum, id: GLuint, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glDebugMessageInsertAMD(category: GLenum, severity: GLenum, id: GLuint, length: GLsizei, buf: cstring) {.importc.} proc glSecondaryColorPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glTextureImage2DMultisampleNV(texture: GLuint, target: GLenum, samples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, fixedSampleLocations: GLboolean) {.importc.} proc glBeginFragmentShaderATI() {.importc.} @@ -1247,7 +1247,7 @@ wrapErrorChecking: proc glFinish() {.importc.} proc glDeleteVertexShaderEXT(id: GLuint) {.importc.} proc glFinishObjectAPPLE(`object`: GLenum, name: GLint) {.importc.} - proc glGetActiveAttribARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLcharARB) {.importc.} + proc glGetActiveAttribARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} proc glPointParameterx(pname: GLenum, param: GLfixed) {.importc.} proc glProgramUniformui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} proc glSecondaryColor3ubv(v: ptr GLubyte) {.importc.} @@ -1273,7 +1273,7 @@ wrapErrorChecking: proc glUniform1i(location: GLint, v0: GLint) {.importc.} proc glVertexAttribL2d(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} proc glTestObjectAPPLE(`object`: GLenum, name: GLuint): TGLboolean {.importc.} - proc glGetTransformFeedbackVarying(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGetTransformFeedbackVarying(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} proc glFramebufferRenderbufferOES(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} proc glVertexStream3iATI(stream: GLenum, x: GLint, y: GLint, z: GLint) {.importc.} proc glMakeTextureHandleNonResidentNV(handle: GLuint64) {.importc.} @@ -1320,7 +1320,7 @@ wrapErrorChecking: proc glVertexAttribL4i64NV(index: GLuint, x: GLint64EXT, y: GLint64EXT, z: GLint64EXT, w: GLint64EXT) {.importc.} proc glDebugMessageCallbackARB(callback: GLDEBUGPROCARB, userParam: ptr pointer) {.importc.} proc glMultiTexCoordP1uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} - proc glLabelObjectEXT(`type`: GLenum, `object`: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} + proc glLabelObjectEXT(`type`: GLenum, `object`: GLuint, length: GLsizei, label: cstring) {.importc.} proc glGetnPolygonStippleARB(bufSize: GLsizei, pattern: ptr GLubyte) {.importc.} proc glTexCoord3xOES(s: GLfixed, t: GLfixed, r: GLfixed) {.importc.} proc glCopyPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, `type`: GLenum) {.importc.} @@ -1367,7 +1367,7 @@ wrapErrorChecking: proc glBlendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum) {.importc.} proc glGetColorTableParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glQueryCounterEXT(id: GLuint, target: GLenum) {.importc.} - proc glExtGetProgramBinarySourceQCOM(program: GLuint, shadertype: GLenum, source: ptr GLchar, length: ptr GLint) {.importc.} + proc glExtGetProgramBinarySourceQCOM(program: GLuint, shadertype: GLenum, source: cstring, length: ptr GLint) {.importc.} proc glGetConvolutionParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glIsProgramPipeline(pipeline: GLuint): TGLboolean {.importc.} proc glVertexWeightfvEXT(weight: ptr GLfloat) {.importc.} @@ -1413,7 +1413,7 @@ wrapErrorChecking: proc glUniform4uiEXT(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} proc glGetShaderiv(shader: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glGetQueryIndexediv(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} - proc glDebugMessageInsert(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glDebugMessageInsert(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} proc glVertexAttribs2dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} proc glGetFixedvOES(pname: GLenum, params: ptr GLfixed) {.importc.} proc glUniform2iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} @@ -1433,13 +1433,13 @@ wrapErrorChecking: proc glGetIntegeri_v(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} proc glProgramUniform3uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glGetActiveUniformBlockiv(program: GLuint, uniformBlockIndex: GLuint, pname: GLenum, params: ptr GLint) {.importc.} - proc glCreateShaderProgramv(`type`: GLenum, count: GLsizei, strings: ptr ptr GLchar): TGLuint {.importc.} + proc glCreateShaderProgramv(`type`: GLenum, count: GLsizei, strings: cstringArray): TGLuint {.importc.} proc glUniform2fARB(location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} proc glVertexStream4ivATI(stream: GLenum, coords: ptr GLint) {.importc.} proc glNormalP3uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} proc glVertexAttribLFormat(attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} proc glTexCoord2bvOES(coords: ptr GLbyte) {.importc.} - proc glGetActiveUniformName(program: GLuint, uniformIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformName: ptr GLchar) {.importc.} + proc glGetActiveUniformName(program: GLuint, uniformIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformName: cstring) {.importc.} proc glTexCoord2sv(v: ptr GLshort) {.importc.} proc glVertexAttrib2dNV(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} proc glGetFogFuncSGIS(points: ptr GLfloat) {.importc.} @@ -1464,7 +1464,7 @@ wrapErrorChecking: proc glUniform2fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} proc glFogf(pname: GLenum, param: GLfloat) {.importc.} proc glMultiTexCoord1iARB(target: GLenum, s: GLint) {.importc.} - proc glGetActiveUniformARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLcharARB) {.importc.} + proc glGetActiveUniformARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} proc glMapGrid1xOES(n: GLint, u1: GLfixed, u2: GLfixed) {.importc.} proc glIndexsv(c: ptr GLshort) {.importc.} proc glFragmentMaterialfSGIX(face: GLenum, pname: GLenum, param: GLfloat) {.importc.} @@ -1510,7 +1510,7 @@ wrapErrorChecking: proc glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: GLuint, coverageSamples: GLsizei, colorSamples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} proc glVertexAttribI3iEXT(index: GLuint, x: GLint, y: GLint, z: GLint) {.importc.} proc glUniform4uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} - proc glGetUniformLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetUniformLocation(program: GLuint, name: cstring): TGLint {.importc.} proc glCurrentPaletteMatrixARB(index: GLint) {.importc.} proc glVertexAttribLPointerEXT(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glFogCoorddvEXT(coord: ptr GLdouble) {.importc.} @@ -1538,7 +1538,7 @@ wrapErrorChecking: proc glGetStringi(name: GLenum, index: GLuint): TGLubyte {.importc.} proc glMakeBufferNonResidentNV(target: GLenum) {.importc.} proc glVertex4bOES(x: GLbyte, y: GLbyte, z: GLbyte) {.importc.} - proc glGetObjectLabel(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glGetObjectLabel(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} proc glClipPlanexOES(plane: GLenum, equation: ptr GLfixed) {.importc.} proc glElementPointerAPPLE(`type`: GLenum, `pointer`: pointer) {.importc.} proc glIsAsyncMarkerSGIX(marker: GLuint): TGLboolean {.importc.} @@ -1567,13 +1567,13 @@ wrapErrorChecking: proc glGetFloatIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLfloat) {.importc.} proc glTexCoord1xOES(s: GLfixed) {.importc.} proc glTexCoord4f(s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} - proc glShaderSource(shader: GLuint, count: GLsizei, string: ptr ptr GLchar, length: ptr GLint) {.importc.} + proc glShaderSource(shader: GLuint, count: GLsizei, string: cstringArray, length: ptr GLint) {.importc.} proc glGetDetailTexFuncSGIS(target: GLenum, points: ptr GLfloat) {.importc.} proc glResetHistogram(target: GLenum) {.importc.} proc glVertexAttribP2ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} proc glDrawTransformFeedbackNV(mode: GLenum, id: GLuint) {.importc.} proc glWindowPos2fMESA(x: GLfloat, y: GLfloat) {.importc.} - proc glObjectLabelKHR(identifier: GLenum, name: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} + proc glObjectLabelKHR(identifier: GLenum, name: GLuint, length: GLsizei, label: cstring) {.importc.} proc glMultiTexCoord2iARB(target: GLenum, s: GLint, t: GLint) {.importc.} proc glVertexAttrib4usv(index: GLuint, v: ptr GLushort) {.importc.} proc glGetGraphicsResetStatusARB(): TGLenum {.importc.} @@ -1593,7 +1593,7 @@ wrapErrorChecking: proc glMatrixTranslatefEXT(mode: GLenum, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glColor4iv(v: ptr GLint) {.importc.} proc glSecondaryColor3ivEXT(v: ptr GLint) {.importc.} - proc glIsNamedStringARB(namelen: GLint, name: ptr GLchar): TGLboolean {.importc.} + proc glIsNamedStringARB(namelen: GLint, name: cstring): TGLboolean {.importc.} proc glVertexAttribL4dv(index: GLuint, v: ptr GLdouble) {.importc.} proc glEndTransformFeedback() {.importc.} proc glVertexStream3fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} @@ -1607,7 +1607,7 @@ wrapErrorChecking: proc glMultiTexCoord3sv(target: GLenum, v: ptr GLshort) {.importc.} proc glVertexAttrib4Nub(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, w: GLubyte) {.importc.} proc glColor3d(red: GLdouble, green: GLdouble, blue: GLdouble) {.importc.} - proc glGetActiveAttrib(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGetActiveAttrib(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} proc glConvolutionParameterfEXT(target: GLenum, pname: GLenum, params: GLfloat) {.importc.} proc glTexSubImage2DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} proc glBinormal3fvEXT(v: ptr GLfloat) {.importc.} @@ -1690,12 +1690,12 @@ wrapErrorChecking: proc glStartTilingQCOM(x: GLuint, y: GLuint, width: GLuint, height: GLuint, preserveMask: GLbitfield) {.importc.} proc glVariantivEXT(id: GLuint, `addr`: ptr GLint) {.importc.} proc glGetnMinmaxARB(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, bufSize: GLsizei, values: pointer) {.importc.} - proc glTransformFeedbackVaryings(program: GLuint, count: GLsizei, varyings: ptr ptr GLchar, bufferMode: GLenum) {.importc.} + proc glTransformFeedbackVaryings(program: GLuint, count: GLsizei, varyings: cstringArray, bufferMode: GLenum) {.importc.} proc glShaderOp2EXT(op: GLenum, res: GLuint, arg1: GLuint, arg2: GLuint) {.importc.} proc glVertexAttribPointer(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, `pointer`: pointer) {.importc.} proc glMultiTexCoord4dvARB(target: GLenum, v: ptr GLdouble) {.importc.} proc glProgramUniform1ui64NV(program: GLuint, location: GLint, x: GLuint64EXT) {.importc.} - proc glGetShaderSourceARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, source: ptr GLcharARB) {.importc.} + proc glGetShaderSourceARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} proc glGetBufferSubDataARB(target: GLenum, offset: GLintptrARB, size: GLsizeiptrARB, data: pointer) {.importc.} proc glCopyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} proc glProgramEnvParameterI4iNV(target: GLenum, index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} @@ -1805,7 +1805,7 @@ wrapErrorChecking: proc glVertexAttribs4fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} proc glVertexAttribL3dv(index: GLuint, v: ptr GLdouble) {.importc.} proc glTexEnvi(target: GLenum, pname: GLenum, param: GLint) {.importc.} - proc glObjectPtrLabel(`ptr`: ptr pointer, length: GLsizei, label: ptr GLchar) {.importc.} + proc glObjectPtrLabel(`ptr`: ptr pointer, length: GLsizei, label: cstring) {.importc.} proc glGetTexGenfv(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glMapVertexAttrib1dAPPLE(index: GLuint, size: GLuint, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: ptr GLdouble) {.importc.} proc glTexCoord3dv(v: ptr GLdouble) {.importc.} @@ -1814,7 +1814,7 @@ wrapErrorChecking: proc glMatrixIndexPointerARB(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glUniformHandleui64ARB(location: GLint, value: GLuint64) {.importc.} proc glUniform1fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} - proc glGetActiveSubroutineUniformName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} + proc glGetActiveSubroutineUniformName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} proc glProgramUniformMatrix4x2fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} proc glMultiTexCoord4fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} proc glGetDriverControlsQCOM(num: ptr GLint, size: GLsizei, driverControls: ptr GLuint) {.importc.} @@ -1857,7 +1857,7 @@ wrapErrorChecking: proc glVertexAttrib4dARB(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} proc glUniform3fARB(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} proc glWindowPos2ivARB(v: ptr GLint) {.importc.} - proc glCreateShaderProgramvEXT(`type`: GLenum, count: GLsizei, strings: ptr ptr GLchar): TGLuint {.importc.} + proc glCreateShaderProgramvEXT(`type`: GLenum, count: GLsizei, strings: cstringArray): TGLuint {.importc.} proc glListParameterivSGIX(list: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glGetGraphicsResetStatusEXT(): TGLenum {.importc.} proc glActiveShaderProgramEXT(pipeline: GLuint, program: GLuint) {.importc.} @@ -1901,7 +1901,7 @@ wrapErrorChecking: proc glFramebufferTexture1DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} proc glTangent3fEXT(tx: GLfloat, ty: GLfloat, tz: GLfloat) {.importc.} proc glIsVertexAttribEnabledAPPLE(index: GLuint, pname: GLenum): TGLboolean {.importc.} - proc glGetShaderInfoLog(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetShaderInfoLog(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} proc glFrustumx(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} proc glTexGenfv(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glCompressedTexImage2DARB(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} @@ -2026,7 +2026,7 @@ wrapErrorChecking: proc glBeginConditionalRenderNV(id: GLuint, mode: GLenum) {.importc.} proc glEdgeFlagv(flag: ptr GLboolean) {.importc.} proc glReplacementCodeubSUN(code: GLubyte) {.importc.} - proc glObjectLabel(identifier: GLenum, name: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} + proc glObjectLabel(identifier: GLenum, name: GLuint, length: GLsizei, label: cstring) {.importc.} proc glMultiTexCoord3xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} proc glNormal3iv(v: ptr GLint) {.importc.} proc glSamplerParameteri(sampler: GLuint, pname: GLenum, param: GLint) {.importc.} @@ -2123,7 +2123,7 @@ wrapErrorChecking: proc glFreeObjectBufferATI(buffer: GLuint) {.importc.} proc glGetVideouivNV(video_slot: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} proc glVertexAttribL4ui64NV(index: GLuint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT, w: GLuint64EXT) {.importc.} - proc glGetUniformBlockIndex(program: GLuint, uniformBlockName: ptr GLchar): TGLuint {.importc.} + proc glGetUniformBlockIndex(program: GLuint, uniformBlockName: cstring): TGLuint {.importc.} proc glCopyMultiTexSubImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} proc glVertex3bvOES(coords: ptr GLbyte) {.importc.} proc glMultiDrawElementArrayAPPLE(mode: GLenum, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei) {.importc.} @@ -2157,14 +2157,14 @@ wrapErrorChecking: proc glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glGetMultiTexEnvivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetFloatv(pname: GLenum, params: ptr GLfloat) {.importc.} - proc glInsertEventMarkerEXT(length: GLsizei, marker: ptr GLchar) {.importc.} + proc glInsertEventMarkerEXT(length: GLsizei, marker: cstring) {.importc.} proc glRasterPos3d(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} proc glNamedFramebufferRenderbufferEXT(framebuffer: GLuint, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} proc glGetConvolutionFilter(target: GLenum, format: GLenum, `type`: GLenum, image: pointer) {.importc.} proc glIsOcclusionQueryNV(id: GLuint): TGLboolean {.importc.} proc glGetnPixelMapuivARB(map: GLenum, bufSize: GLsizei, values: ptr GLuint) {.importc.} proc glMapParameterfvNV(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glPushDebugGroup(source: GLenum, id: GLuint, length: GLsizei, message: ptr GLchar) {.importc.} + proc glPushDebugGroup(source: GLenum, id: GLuint, length: GLsizei, message: cstring) {.importc.} proc glMakeImageHandleResidentARB(handle: GLuint64, access: GLenum) {.importc.} proc glProgramUniformMatrix2fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} proc glUniform3i64vNV(location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} @@ -2177,7 +2177,7 @@ wrapErrorChecking: proc glGetRenderbufferParameterivOES(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetBufferPointerv(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} proc glSecondaryColor3ui(red: GLuint, green: GLuint, blue: GLuint) {.importc.} - proc glGetDebugMessageLog(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} + proc glGetDebugMessageLog(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): TGLuint {.importc.} proc glNormal3i(nx: GLint, ny: GLint, nz: GLint) {.importc.} proc glTestFenceNV(fence: GLuint): TGLboolean {.importc.} proc glSecondaryColor3usv(v: ptr GLushort) {.importc.} @@ -2289,7 +2289,7 @@ wrapErrorChecking: proc glTranslated(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} proc glColorPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glDrawElementsInstancedBaseVertex(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, instancecount: GLsizei, basevertex: GLint) {.importc.} - proc glBindAttribLocationARB(programObj: GLhandleARB, index: GLuint, name: ptr GLcharARB) {.importc.} + proc glBindAttribLocationARB(programObj: GLhandleARB, index: GLuint, name: cstring) {.importc.} proc glTexGendv(coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} proc glGetPathCoordsNV(path: GLuint, coords: ptr GLfloat) {.importc.} proc glGetMapParameterivNV(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} @@ -2322,7 +2322,7 @@ wrapErrorChecking: proc glGetBufferPointervARB(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} proc glGetMultiTexLevelParameterfvEXT(texunit: GLenum, target: GLenum, level: GLint, pname: GLenum, params: ptr GLfloat) {.importc.} proc glMultiTexParameterIuivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} - proc glGetShaderSource(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, source: ptr GLchar) {.importc.} + proc glGetShaderSource(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} proc glStencilFunc(func: GLenum, `ref`: GLint, mask: GLuint) {.importc.} proc glVertexAttribI4bvEXT(index: GLuint, v: ptr GLbyte) {.importc.} proc glVertexAttrib4NuivARB(index: GLuint, v: ptr GLuint) {.importc.} @@ -2337,7 +2337,7 @@ wrapErrorChecking: proc glTextureStorage2DMultisampleEXT(texture: GLuint, target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, fixedsamplelocations: GLboolean) {.importc.} proc glGetHistogramParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} proc glVertexAttrib4dNV(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} - proc glGetPerfMonitorCounterStringAMD(group: GLuint, counter: GLuint, bufSize: GLsizei, length: ptr GLsizei, counterString: ptr GLchar) {.importc.} + proc glGetPerfMonitorCounterStringAMD(group: GLuint, counter: GLuint, bufSize: GLsizei, length: ptr GLsizei, counterString: cstring) {.importc.} proc glMultiTexCoord2sARB(target: GLenum, s: GLshort, t: GLshort) {.importc.} proc glSpriteParameterivSGIX(pname: GLenum, params: ptr GLint) {.importc.} proc glCompressedTextureImage3DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} @@ -2348,7 +2348,7 @@ wrapErrorChecking: proc glProgramParameteri(program: GLuint, pname: GLenum, value: GLint) {.importc.} proc glGetLocalConstantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} proc glFragmentMaterialiSGIX(face: GLenum, pname: GLenum, param: GLint) {.importc.} - proc glGetNamedStringivARB(namelen: GLint, name: ptr GLchar, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetNamedStringivARB(namelen: GLint, name: cstring, pname: GLenum, params: ptr GLint) {.importc.} proc glBinormal3ivEXT(v: ptr GLint) {.importc.} proc glCheckFramebufferStatusEXT(target: GLenum): TGLenum {.importc.} proc glVertexAttrib1fNV(index: GLuint, x: GLfloat) {.importc.} @@ -2362,7 +2362,7 @@ wrapErrorChecking: proc glBeginTransformFeedbackEXT(primitiveMode: GLenum) {.importc.} proc glBufferAddressRangeNV(pname: GLenum, index: GLuint, address: GLuint64EXT, length: GLsizeiptr) {.importc.} proc glPointParameterfvARB(pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetActiveVaryingNV(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGetActiveVaryingNV(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} proc glIndexMask(mask: GLuint) {.importc.} proc glVertexAttribBinding(attribindex: GLuint, bindingindex: GLuint) {.importc.} proc glDeleteFencesNV(n: GLsizei, fences: ptr GLuint) {.importc.} @@ -2432,7 +2432,7 @@ wrapErrorChecking: proc glMapControlPointsNV(target: GLenum, index: GLuint, `type`: GLenum, ustride: GLsizei, vstride: GLsizei, uorder: GLint, vorder: GLint, packed: GLboolean, points: pointer) {.importc.} proc glGetBufferParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glUnmapObjectBufferATI(buffer: GLuint) {.importc.} - proc glGetProgramResourceLocation(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLint {.importc.} + proc glGetProgramResourceLocation(program: GLuint, programInterface: GLenum, name: cstring): TGLint {.importc.} proc glUniform4i64vNV(location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} proc glImageTransformParameterfHP(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} proc glArrayObjectATI(`array`: GLenum, size: GLint, `type`: GLenum, stride: GLsizei, buffer: GLuint, offset: GLuint) {.importc.} @@ -2442,7 +2442,7 @@ wrapErrorChecking: proc glListParameteriSGIX(list: GLuint, pname: GLenum, param: GLint) {.importc.} proc glProgramUniformMatrix2dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} proc glProgramUniform2i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} - proc glObjectPtrLabelKHR(`ptr`: ptr pointer, length: GLsizei, label: ptr GLchar) {.importc.} + proc glObjectPtrLabelKHR(`ptr`: ptr pointer, length: GLsizei, label: cstring) {.importc.} proc glVertexAttribL1i64NV(index: GLuint, x: GLint64EXT) {.importc.} proc glMultiTexBufferEXT(texunit: GLenum, target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} proc glCoverFillPathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, coverMode: GLenum, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} @@ -2461,7 +2461,7 @@ wrapErrorChecking: proc glGetBooleanv(pname: GLenum, params: ptr GLboolean) {.importc.} proc glTangent3ivEXT(v: ptr GLint) {.importc.} proc glTexImage3DMultisample(target: GLenum, samples: GLsizei, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedsamplelocations: GLboolean) {.importc.} - proc glGetUniformIndices(program: GLuint, uniformCount: GLsizei, uniformNames: ptr ptr GLchar, uniformIndices: ptr GLuint) {.importc.} + proc glGetUniformIndices(program: GLuint, uniformCount: GLsizei, uniformNames: cstringArray, uniformIndices: ptr GLuint) {.importc.} proc glVDPAUInitNV(vdpDevice: pointer, getProcAddress: pointer) {.importc.} proc glGetMinmaxParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glMultiTexCoord2fvARB(target: GLenum, v: ptr GLfloat) {.importc.} @@ -2473,18 +2473,18 @@ wrapErrorChecking: proc glGetInstrumentsSGIX(): TGLint {.importc.} proc glFramebufferParameteri(target: GLenum, pname: GLenum, param: GLint) {.importc.} proc glPathCoverDepthFuncNV(func: GLenum) {.importc.} - proc glGetTranslatedShaderSourceANGLE(shader: GLuint, bufsize: GLsizei, length: ptr GLsizei, source: ptr GLchar) {.importc.} + proc glGetTranslatedShaderSourceANGLE(shader: GLuint, bufsize: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} proc glIndexfv(c: ptr GLfloat) {.importc.} - proc glGetActiveUniformBlockName(program: GLuint, uniformBlockIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformBlockName: ptr GLchar) {.importc.} + proc glGetActiveUniformBlockName(program: GLuint, uniformBlockIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformBlockName: cstring) {.importc.} proc glNormal3s(nx: GLshort, ny: GLshort, nz: GLshort) {.importc.} proc glColorFragmentOp3ATI(op: GLenum, dst: GLuint, dstMask: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint, arg3: GLuint, arg3Rep: GLuint, arg3Mod: GLuint) {.importc.} - proc glGetProgramResourceLocationIndex(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLint {.importc.} + proc glGetProgramResourceLocationIndex(program: GLuint, programInterface: GLenum, name: cstring): TGLint {.importc.} proc glGetBooleanIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLboolean) {.importc.} proc glGenPerfMonitorsAMD(n: GLsizei, monitors: ptr GLuint) {.importc.} proc glDrawRangeElementsEXT(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei, `type`: GLenum, indices: pointer) {.importc.} proc glFramebufferTexture3D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} proc glGetTexParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} - proc glCompileShaderIncludeARB(shader: GLuint, count: GLsizei, path: ptr ptr GLchar, length: ptr GLint) {.importc.} + proc glCompileShaderIncludeARB(shader: GLuint, count: GLsizei, path: cstringArray, length: ptr GLint) {.importc.} proc glGetMultiTexParameterfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glEvalPoint2(i: GLint, j: GLint) {.importc.} proc glGetProgramivNV(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} @@ -2498,7 +2498,7 @@ wrapErrorChecking: proc glProgramUniformMatrix3x4dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} proc glGetFloati_vEXT(pname: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} proc glGetObjectParameterivAPPLE(objectType: GLenum, name: GLuint, pname: GLenum, params: ptr GLint) {.importc.} - proc glPushGroupMarkerEXT(length: GLsizei, marker: ptr GLchar) {.importc.} + proc glPushGroupMarkerEXT(length: GLsizei, marker: cstring) {.importc.} proc glProgramUniform4uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glReplacementCodeuiVertex3fSUN(rc: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glTexSubImage1DEXT(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} @@ -2571,7 +2571,7 @@ wrapErrorChecking: proc glTexCoord4bOES(s: GLbyte, t: GLbyte, r: GLbyte, q: GLbyte) {.importc.} proc glSecondaryColor3us(red: GLushort, green: GLushort, blue: GLushort) {.importc.} proc glGlobalAlphaFactorubSUN(factor: GLubyte) {.importc.} - proc glNamedStringARB(`type`: GLenum, namelen: GLint, name: ptr GLchar, stringlen: GLint, string: ptr GLchar) {.importc.} + proc glNamedStringARB(`type`: GLenum, namelen: GLint, name: cstring, stringlen: GLint, string: cstring) {.importc.} proc glGetAttachedShaders(program: GLuint, maxCount: GLsizei, count: ptr GLsizei, shaders: ptr GLuint) {.importc.} proc glMatrixRotatefEXT(mode: GLenum, angle: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glVertexStream3ivATI(stream: GLenum, coords: ptr GLint) {.importc.} @@ -2643,12 +2643,12 @@ wrapErrorChecking: proc glIsQuery(id: GLuint): TGLboolean {.importc.} proc glFogxv(pname: GLenum, param: ptr GLfixed) {.importc.} proc glAreProgramsResidentNV(n: GLsizei, programs: ptr GLuint, residences: ptr GLboolean): TGLboolean {.importc.} - proc glShaderSourceARB(shaderObj: GLhandleARB, count: GLsizei, string: ptr ptr GLcharARB, length: ptr GLint) {.importc.} + proc glShaderSourceARB(shaderObj: GLhandleARB, count: GLsizei, string: cstringArray, length: ptr GLint) {.importc.} proc glPointSizexOES(size: GLfixed) {.importc.} proc glPixelTransferf(pname: GLenum, param: GLfloat) {.importc.} proc glExtractComponentEXT(res: GLuint, src: GLuint, num: GLuint) {.importc.} proc glUniform1fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} - proc glGetNamedStringARB(namelen: GLint, name: ptr GLchar, bufSize: GLsizei, stringlen: ptr GLint, string: ptr GLchar) {.importc.} + proc glGetNamedStringARB(namelen: GLint, name: cstring, bufSize: GLsizei, stringlen: ptr GLint, string: cstring) {.importc.} proc glGetProgramBinaryOES(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, binaryFormat: ptr GLenum, binary: pointer) {.importc.} proc glDeleteOcclusionQueriesNV(n: GLsizei, ids: ptr GLuint) {.importc.} proc glEnableClientState(`array`: GLenum) {.importc.} @@ -2693,14 +2693,14 @@ wrapErrorChecking: proc glIndexub(c: GLubyte) {.importc.} proc glVertexP2uiv(`type`: GLenum, value: ptr GLuint) {.importc.} proc glProgramUniform1uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} - proc glDebugMessageInsertKHR(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glDebugMessageInsertKHR(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} proc glColor4b(red: GLbyte, green: GLbyte, blue: GLbyte, alpha: GLbyte) {.importc.} proc glRenderbufferStorageMultisampleAPPLE(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} proc glMinSampleShading(value: GLfloat) {.importc.} proc glBindProgramNV(target: GLenum, id: GLuint) {.importc.} proc glWindowPos3dMESA(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} proc glEdgeFlagPointer(stride: GLsizei, `pointer`: pointer) {.importc.} - proc glGetFragDataIndex(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetFragDataIndex(program: GLuint, name: cstring): TGLint {.importc.} proc glTexCoord3hNV(s: GLhalfNV, t: GLhalfNV, r: GLhalfNV) {.importc.} proc glMultiDrawArraysIndirectAMD(mode: GLenum, indirect: pointer, primcount: GLsizei, stride: GLsizei) {.importc.} proc glFragmentColorMaterialSGIX(face: GLenum, mode: GLenum) {.importc.} @@ -2746,7 +2746,7 @@ wrapErrorChecking: proc glWindowPos3iv(v: ptr GLint) {.importc.} proc glProgramUniform4ui64NV(program: GLuint, location: GLint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT, w: GLuint64EXT) {.importc.} proc glProgramUniform2d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble) {.importc.} - proc glDebugMessageInsertARB(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glDebugMessageInsertARB(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} proc glMultiTexSubImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} proc glMap1d(target: GLenum, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: ptr GLdouble) {.importc.} proc glDeleteShader(shader: GLuint) {.importc.} @@ -2778,7 +2778,7 @@ wrapErrorChecking: proc glGetVertexArrayIntegeri_vEXT(vaobj: GLuint, index: GLuint, pname: GLenum, param: ptr GLint) {.importc.} proc glReadnPixelsEXT(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, bufSize: GLsizei, data: pointer) {.importc.} proc glMultiTexImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} - proc glGetVaryingLocationNV(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetVaryingLocationNV(program: GLuint, name: cstring): TGLint {.importc.} proc glMultiTexCoord4fvARB(target: GLenum, v: ptr GLfloat) {.importc.} proc glMultiTexCoord3iv(target: GLenum, v: ptr GLint) {.importc.} proc glVertexAttribL2dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} @@ -2791,7 +2791,7 @@ wrapErrorChecking: proc glProgramUniform3ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} proc glTexCoord2fColor3fVertex3fvSUN(tc: ptr GLfloat, c: ptr GLfloat, v: ptr GLfloat) {.importc.} proc glProgramUniform3fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} - proc glBindFragDataLocationIndexed(program: GLuint, colorNumber: GLuint, index: GLuint, name: ptr GLchar) {.importc.} + proc glBindFragDataLocationIndexed(program: GLuint, colorNumber: GLuint, index: GLuint, name: cstring) {.importc.} proc glGetnSeparableFilterARB(target: GLenum, format: GLenum, `type`: GLenum, rowBufSize: GLsizei, row: pointer, columnBufSize: GLsizei, column: pointer, span: pointer) {.importc.} proc glTextureParameteriEXT(texture: GLuint, target: GLenum, pname: GLenum, param: GLint) {.importc.} proc glGetUniformuivEXT(program: GLuint, location: GLint, params: ptr GLuint) {.importc.} @@ -2809,12 +2809,12 @@ wrapErrorChecking: proc glTexCoord2fColor4fNormal3fVertex3fvSUN(tc: ptr GLfloat, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} proc glMultiTexCoord3s(target: GLenum, s: GLshort, t: GLshort, r: GLshort) {.importc.} proc glMultTransposeMatrixd(m: ptr GLdouble) {.importc.} - proc glActiveVaryingNV(program: GLuint, name: ptr GLchar) {.importc.} + proc glActiveVaryingNV(program: GLuint, name: cstring) {.importc.} proc glProgramUniform1f(program: GLuint, location: GLint, v0: GLfloat) {.importc.} - proc glGetActiveSubroutineName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} + proc glGetActiveSubroutineName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} proc glClipPlanex(plane: GLenum, equation: ptr GLfixed) {.importc.} proc glMultiTexCoord4iv(target: GLenum, v: ptr GLint) {.importc.} - proc glTransformFeedbackVaryingsEXT(program: GLuint, count: GLsizei, varyings: ptr ptr GLchar, bufferMode: GLenum) {.importc.} + proc glTransformFeedbackVaryingsEXT(program: GLuint, count: GLsizei, varyings: cstringArray, bufferMode: GLenum) {.importc.} proc glBlendEquationSeparateiARB(buf: GLuint, modeRGB: GLenum, modeAlpha: GLenum) {.importc.} proc glVertex2sv(v: ptr GLshort) {.importc.} proc glAccumxOES(op: GLenum, value: GLfixed) {.importc.} @@ -2894,7 +2894,7 @@ wrapErrorChecking: proc glPointParameterivNV(pname: GLenum, params: ptr GLint) {.importc.} proc glBlitFramebufferANGLE(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} proc glGetObjectParameterivARB(obj: GLhandleARB, pname: GLenum, params: ptr GLint) {.importc.} - proc glGetSubroutineIndex(program: GLuint, shadertype: GLenum, name: ptr GLchar): TGLuint {.importc.} + proc glGetSubroutineIndex(program: GLuint, shadertype: GLenum, name: cstring): TGLuint {.importc.} proc glMap2d(target: GLenum, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: ptr GLdouble) {.importc.} proc glRectfv(v1: ptr GLfloat, v2: ptr GLfloat) {.importc.} proc glDepthRangeArrayv(first: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} @@ -2951,7 +2951,7 @@ wrapErrorChecking: proc glEndQuery(target: GLenum) {.importc.} proc glBlitFramebufferEXT(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} proc glProgramEnvParametersI4uivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} - proc glGetActiveUniform(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGetActiveUniform(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} proc glGenAsyncMarkersSGIX(range: GLsizei): TGLuint {.importc.} proc glClipControlARB(origin: GLenum, depth: GLenum) {.importc.} proc glDrawElementsInstancedEXT(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, primcount: GLsizei) {.importc.} @@ -2970,7 +2970,7 @@ wrapErrorChecking: proc glProgramParameter4dvNV(target: GLenum, index: GLuint, v: ptr GLdouble) {.importc.} proc glDeleteBuffers(n: GLsizei, buffers: ptr GLuint) {.importc.} proc glGetVertexArrayIntegervEXT(vaobj: GLuint, pname: GLenum, param: ptr GLint) {.importc.} - proc glBindFragDataLocationEXT(program: GLuint, color: GLuint, name: ptr GLchar) {.importc.} + proc glBindFragDataLocationEXT(program: GLuint, color: GLuint, name: cstring) {.importc.} proc glGenProgramsNV(n: GLsizei, programs: ptr GLuint) {.importc.} proc glMultiTexCoord1i(target: GLenum, s: GLint) {.importc.} proc glCompressedTexImage3DOES(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} @@ -2988,7 +2988,7 @@ wrapErrorChecking: proc glTexGenivOES(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glIsFramebufferOES(framebuffer: GLuint): TGLboolean {.importc.} proc glColor4ubv(v: ptr GLubyte) {.importc.} - proc glDeleteNamedStringARB(namelen: GLint, name: ptr GLchar) {.importc.} + proc glDeleteNamedStringARB(namelen: GLint, name: cstring) {.importc.} proc glCopyConvolutionFilter1DEXT(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} proc glBufferStorage(target: GLenum, size: GLsizeiptr, data: ptr pointer, flags: GLbitfield) {.importc.} proc glDrawTexiOES(x: GLint, y: GLint, z: GLint, width: GLint, height: GLint) {.importc.} @@ -3140,7 +3140,7 @@ wrapErrorChecking: proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glSampleMapATI(dst: GLuint, interp: GLuint, swizzle: GLenum) {.importc.} proc glProgramUniform1d(program: GLuint, location: GLint, v0: GLdouble) {.importc.} - proc glBindAttribLocation(program: GLuint, index: GLuint, name: ptr GLchar) {.importc.} + proc glBindAttribLocation(program: GLuint, index: GLuint, name: cstring) {.importc.} proc glGetCombinerStageParameterfvNV(stage: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glTexSubImage4DSGIS(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, woffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, size4d: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} proc glGetMapAttribParameterfvNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} From 046298b8b9733e5e9a136f7b78978adc2a325b6c Mon Sep 17 00:00:00 2001 From: EXetoC Date: Wed, 16 Apr 2014 01:44:10 +0200 Subject: [PATCH 16/18] Revert changes. This might break code. --- src/opengl.nim | 163 +++++++++++++++++++++++++------------------------ 1 file changed, 82 insertions(+), 81 deletions(-) diff --git a/src/opengl.nim b/src/opengl.nim index 365c6b7..b53152b 100644 --- a/src/opengl.nim +++ b/src/opengl.nim @@ -358,7 +358,7 @@ wrapErrorChecking: proc glColor4dv(v: ptr GLdouble) {.importc.} proc glColor3fv(v: ptr GLfloat) {.importc.} proc glVertexAttribI1uiEXT(index: GLuint, x: GLuint) {.importc.} - proc glGetDebugMessageLogKHR(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): TGLuint {.importc.} + proc glGetDebugMessageLogKHR(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} proc glVertexAttribI2iv(index: GLuint, v: ptr GLint) {.importc.} proc glTexCoord1xvOES(coords: ptr GLfixed) {.importc.} proc glVertex3hNV(x: GLhalfNV, y: GLhalfNV, z: GLhalfNV) {.importc.} @@ -446,7 +446,7 @@ wrapErrorChecking: proc glImageTransformParameterfvHP(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glUniform3uiEXT(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} proc glGetInvariantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} - proc glGetTransformFeedbackVaryingEXT(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} + proc glGetTransformFeedbackVaryingEXT(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} proc glSamplerParameterIuiv(sampler: GLuint, pname: GLenum, param: ptr GLuint) {.importc.} proc glProgramUniform2fEXT(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} proc glMultiTexCoord2hvNV(target: GLenum, v: ptr GLhalfNV) {.importc.} @@ -457,14 +457,14 @@ wrapErrorChecking: proc glFenceSyncAPPLE(condition: GLenum, flags: GLbitfield): TGLsync {.importc.} proc glGetVariantArrayObjectivATI(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glProgramUniform4dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} - proc glPushDebugGroupKHR(source: GLenum, id: GLuint, length: GLsizei, message: cstring) {.importc.} + proc glPushDebugGroupKHR(source: GLenum, id: GLuint, length: GLsizei, message: ptr GLchar) {.importc.} proc glFragmentLightivSGIX(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glFramebufferTexture2DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} proc glGetActiveSubroutineUniformiv(program: GLuint, shadertype: GLenum, index: GLuint, pname: GLenum, values: ptr GLint) {.importc.} proc glFrustumf(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} proc glEndQueryIndexed(target: GLenum, index: GLuint) {.importc.} proc glCompressedTextureSubImage3DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} - proc glGetProgramPipelineInfoLogEXT(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} + proc glGetProgramPipelineInfoLogEXT(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} proc glGetVertexAttribfvNV(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} proc glVertexArrayIndexOffsetEXT(vaobj: GLuint, buffer: GLuint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} proc glDrawTexsvOES(coords: ptr GLshort) {.importc.} @@ -484,7 +484,7 @@ wrapErrorChecking: proc glColor3bv(v: ptr GLbyte) {.importc.} proc glNamedProgramLocalParameter4dEXT(program: GLuint, target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} proc glVertexPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} - proc glGetObjectLabelKHR(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} + proc glGetObjectLabelKHR(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} proc glCombinerStageParameterfvNV(stage: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glNormal3hvNV(v: ptr GLhalfNV) {.importc.} proc glUniform2i64NV(location: GLint, x: GLint64EXT, y: GLint64EXT) {.importc.} @@ -553,9 +553,9 @@ wrapErrorChecking: proc glFlushMappedBufferRangeEXT(target: GLenum, offset: GLintptr, length: GLsizeiptr) {.importc.} proc glNormal3dv(v: ptr GLdouble) {.importc.} proc glProgramUniform4d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble, v2: GLdouble, v3: GLdouble) {.importc.} - proc glCreateShaderProgramEXT(`type`: GLenum, string: cstring): TGLuint {.importc.} + proc glCreateShaderProgramEXT(`type`: GLenum, string: ptr GLchar): TGLuint {.importc.} proc glGetLightxvOES(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} - proc glGetObjectPtrLabelKHR(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} + proc glGetObjectPtrLabelKHR(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} proc glTransformPathNV(resultPath: GLuint, srcPath: GLuint, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} proc glMultTransposeMatrixf(m: ptr GLfloat) {.importc.} proc glMapVertexAttrib2dAPPLE(index: GLuint, size: GLuint, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: ptr GLdouble) {.importc.} @@ -575,7 +575,7 @@ wrapErrorChecking: proc glMultiTexEnviEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLint) {.importc.} proc glProgramUniform1fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} proc glDrawBuffersARB(n: GLsizei, bufs: ptr GLenum) {.importc.} - proc glGetUniformLocationARB(programObj: GLhandleARB, name: cstring): TGLint {.importc.} + proc glGetUniformLocationARB(programObj: GLhandleARB, name: ptr GLcharARB): TGLint {.importc.} proc glResumeTransformFeedback() {.importc.} proc glMap1f(target: GLenum, u1: GLfloat, u2: GLfloat, stride: GLint, order: GLint, points: ptr GLfloat) {.importc.} proc glVertex3xOES(x: GLfixed, y: GLfixed) {.importc.} @@ -587,7 +587,7 @@ wrapErrorChecking: proc glGetVertexArrayPointeri_vEXT(vaobj: GLuint, index: GLuint, pname: GLenum, param: ptr pointer) {.importc.} proc glProgramParameter4fvNV(target: GLenum, index: GLuint, v: ptr GLfloat) {.importc.} proc glDiscardFramebufferEXT(target: GLenum, numAttachments: GLsizei, attachments: ptr GLenum) {.importc.} - proc glGetDebugMessageLogARB(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): TGLuint {.importc.} + proc glGetDebugMessageLogARB(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} proc glResolveMultisampleFramebufferAPPLE() {.importc.} proc glGetIntegeri_vEXT(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} proc glDepthBoundsdNV(zmin: GLdouble, zmax: GLdouble) {.importc.} @@ -642,7 +642,7 @@ wrapErrorChecking: proc glVertexAttribL4i64vNV(index: GLuint, v: ptr GLint64EXT) {.importc.} proc glEnableVariantClientStateEXT(id: GLuint) {.importc.} proc glSyncTextureINTEL(texture: GLuint) {.importc.} - proc glGetObjectPtrLabel(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} + proc glGetObjectPtrLabel(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} proc glCopyTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} proc glOrthofOES(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} proc glWindowPos3sARB(x: GLshort, y: GLshort, z: GLshort) {.importc.} @@ -665,7 +665,7 @@ wrapErrorChecking: proc glVertexP2ui(`type`: GLenum, value: GLuint) {.importc.} proc glGenQueries(n: GLsizei, ids: ptr GLuint) {.importc.} proc glBindBufferOffsetNV(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr) {.importc.} - proc glGetFragDataLocation(program: GLuint, name: cstring): TGLint {.importc.} + proc glGetFragDataLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} proc glVertexAttribs2svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} proc glGetPathLengthNV(path: GLuint, startSegment: GLsizei, numSegments: GLsizei): TGLfloat {.importc.} proc glVertexAttrib3dARB(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} @@ -731,7 +731,7 @@ wrapErrorChecking: proc glGetFixedv(pname: GLenum, params: ptr GLfixed) {.importc.} proc glMaterialf(face: GLenum, pname: GLenum, param: GLfloat) {.importc.} proc glVideoCaptureStreamParameterfvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetDebugMessageLogAMD(count: GLuint, bufsize: GLsizei, categories: ptr GLenum, severities: ptr GLuint, ids: ptr GLuint, lengths: ptr GLsizei, message: cstring): TGLuint {.importc.} + proc glGetDebugMessageLogAMD(count: GLuint, bufsize: GLsizei, categories: ptr GLenum, severities: ptr GLuint, ids: ptr GLuint, lengths: ptr GLsizei, message: ptr GLchar): TGLuint {.importc.} proc glProgramUniform2uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glMatrixMultTransposedEXT(mode: GLenum, m: ptr GLdouble) {.importc.} proc glIsPointInStrokePathNV(path: GLuint, x: GLfloat, y: GLfloat): TGLboolean {.importc.} @@ -767,7 +767,7 @@ wrapErrorChecking: proc glTexStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} proc glMultiTexCoord2xOES(texture: GLenum, s: GLfixed, t: GLfixed) {.importc.} proc glWindowPos2fARB(x: GLfloat, y: GLfloat) {.importc.} - proc glGetProgramResourceIndex(program: GLuint, programInterface: GLenum, name: cstring): TGLuint {.importc.} + proc glGetProgramResourceIndex(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLuint {.importc.} proc glProgramUniform2uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glMakeImageHandleNonResidentNV(handle: GLuint64) {.importc.} proc glNamedProgramLocalParameter4fvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} @@ -793,7 +793,7 @@ wrapErrorChecking: proc glProgramLocalParameterI4uivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} proc glRenderMode(mode: GLenum): TGLint {.importc.} proc glVertexStream4fATI(stream: GLenum, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} - proc glGetObjectLabelEXT(`type`: GLenum, `object`: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} + proc glGetObjectLabelEXT(`type`: GLenum, `object`: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} proc glNamedFramebufferTexture3DEXT(framebuffer: GLuint, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} proc glLoadMatrixf(m: ptr GLfloat) {.importc.} proc glGetQueryObjectuivEXT(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} @@ -803,7 +803,7 @@ wrapErrorChecking: proc glTexGenxvOES(coord: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} proc glMatrixMode(mode: GLenum) {.importc.} proc glColorTableParameterivSGI(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} - proc glGetProgramInfoLog(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} + proc glGetProgramInfoLog(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} proc glGetSeparableFilter(target: GLenum, format: GLenum, `type`: GLenum, row: pointer, column: pointer, span: pointer) {.importc.} proc glFogfv(pname: GLenum, params: ptr GLfloat) {.importc.} proc glDrawTexfvOES(coords: ptr GLfloat) {.importc.} @@ -829,7 +829,7 @@ wrapErrorChecking: proc glBeginConditionalRender(id: GLuint, mode: GLenum) {.importc.} proc glVertexAttribI3uiEXT(index: GLuint, x: GLuint, y: GLuint, z: GLuint) {.importc.} proc glVDPAUMapSurfacesNV(numSurfaces: GLsizei, surfaces: ptr GLvdpauSurfaceNV) {.importc.} - proc glGetProgramResourceName(program: GLuint, programInterface: GLenum, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} + proc glGetProgramResourceName(program: GLuint, programInterface: GLenum, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} proc glMultiTexCoord4f(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} proc glVertexAttrib2hNV(index: GLuint, x: GLhalfNV, y: GLhalfNV) {.importc.} proc glDrawArraysInstancedNV(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei) {.importc.} @@ -850,7 +850,7 @@ wrapErrorChecking: proc glReferencePlaneSGIX(equation: ptr GLdouble) {.importc.} proc glNormalStream3iATI(stream: GLenum, nx: GLint, ny: GLint, nz: GLint) {.importc.} proc glGetColorTableParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetAttribLocation(program: GLuint, name: cstring): TGLint {.importc.} + proc glGetAttribLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} proc glMultiTexParameterfEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLfloat) {.importc.} proc glGenFencesNV(n: GLsizei, fences: ptr GLuint) {.importc.} proc glUniform4dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} @@ -877,7 +877,7 @@ wrapErrorChecking: proc glMultiTexCoord3fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} proc glRasterPos3xOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} proc glEGLImageTargetRenderbufferStorageOES(target: GLenum, image: GLeglImageOES) {.importc.} - proc glGetAttribLocationARB(programObj: GLhandleARB, name: cstring): TGLint {.importc.} + proc glGetAttribLocationARB(programObj: GLhandleARB, name: ptr GLcharARB): TGLint {.importc.} proc glProgramNamedParameter4dvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, v: ptr GLdouble) {.importc.} proc glProgramLocalParameterI4uiNV(target: GLenum, index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} proc glNamedFramebufferTextureFaceEXT(framebuffer: GLuint, attachment: GLenum, texture: GLuint, level: GLint, face: GLenum) {.importc.} @@ -954,7 +954,7 @@ wrapErrorChecking: proc glGetPixelTexGenParameterivSGIS(pname: GLenum, params: ptr GLint) {.importc.} proc glVariantuivEXT(id: GLuint, `addr`: ptr GLuint) {.importc.} proc glTexParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetSubroutineUniformLocation(program: GLuint, shadertype: GLenum, name: cstring): TGLint {.importc.} + proc glGetSubroutineUniformLocation(program: GLuint, shadertype: GLenum, name: ptr GLchar): TGLint {.importc.} proc glProgramUniformMatrix3fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} proc glDrawBuffersATI(n: GLsizei, bufs: ptr GLenum) {.importc.} proc glGetVertexAttribivNV(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} @@ -995,7 +995,7 @@ wrapErrorChecking: proc glTexCoord3f(s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} proc glMultiTexCoord1fARB(target: GLenum, s: GLfloat) {.importc.} proc glVertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} - proc glGetFragDataLocationEXT(program: GLuint, name: cstring): TGLint {.importc.} + proc glGetFragDataLocationEXT(program: GLuint, name: ptr GLchar): TGLint {.importc.} proc glFlushMappedNamedBufferRangeEXT(buffer: GLuint, offset: GLintptr, length: GLsizeiptr) {.importc.} proc glVertexAttrib1sARB(index: GLuint, x: GLshort) {.importc.} proc glBitmapxOES(width: GLsizei, height: GLsizei, xorig: GLfixed, yorig: GLfixed, xmove: GLfixed, ymove: GLfixed, bitmap: ptr GLubyte) {.importc.} @@ -1024,7 +1024,7 @@ wrapErrorChecking: proc glEnableDriverControlQCOM(driverControl: GLuint) {.importc.} proc glPointParameteri(pname: GLenum, param: GLint) {.importc.} proc glVertexAttribI2i(index: GLuint, x: GLint, y: GLint) {.importc.} - proc glGetDriverControlStringQCOM(driverControl: GLuint, bufSize: GLsizei, length: ptr GLsizei, driverControlString: cstring) {.importc.} + proc glGetDriverControlStringQCOM(driverControl: GLuint, bufSize: GLsizei, length: ptr GLsizei, driverControlString: ptr GLchar) {.importc.} proc glGetTexLevelParameteriv(target: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} proc glGetHandleARB(pname: GLenum): TGLhandleARB {.importc.} proc glIndexubv(c: ptr GLubyte) {.importc.} @@ -1058,7 +1058,7 @@ wrapErrorChecking: proc glVertexAttribI1iEXT(index: GLuint, x: GLint) {.importc.} proc glFramebufferTexture1D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} proc glVertexAttribI2uiv(index: GLuint, v: ptr GLuint) {.importc.} - proc glBindFragDataLocation(program: GLuint, color: GLuint, name: cstring) {.importc.} + proc glBindFragDataLocation(program: GLuint, color: GLuint, name: ptr GLchar) {.importc.} proc glClearStencil(s: GLint) {.importc.} proc glVertexAttrib4Nubv(index: GLuint, v: ptr GLubyte) {.importc.} proc glConvolutionFilter2DEXT(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} @@ -1103,7 +1103,7 @@ wrapErrorChecking: proc glGetMinmaxParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glColor4fNormal3fVertex3fSUN(r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glWindowPos2d(x: GLdouble, y: GLdouble) {.importc.} - proc glGetPerfMonitorGroupStringAMD(group: GLuint, bufSize: GLsizei, length: ptr GLsizei, groupString: cstring) {.importc.} + proc glGetPerfMonitorGroupStringAMD(group: GLuint, bufSize: GLsizei, length: ptr GLsizei, groupString: ptr GLchar) {.importc.} proc glUniformHandleui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64) {.importc.} proc glBlendEquation(mode: GLenum) {.importc.} proc glMapBufferARB(target: GLenum, access: GLenum) {.importc.} @@ -1145,7 +1145,7 @@ wrapErrorChecking: proc glVertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat) {.importc.} proc glMultiTexGenivEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glUniformui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} - proc glGetInfoLogARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} + proc glGetInfoLogARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, infoLog: ptr GLcharARB) {.importc.} proc glGetNamedProgramLocalParameterIivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLint) {.importc.} proc glVertexAttrib4s(index: GLuint, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} proc glUniformMatrix4x2dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} @@ -1162,7 +1162,7 @@ wrapErrorChecking: proc glTexParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetArrayObjectivATI(`array`: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetTexParameterIuiv(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} - proc glGetProgramPipelineInfoLog(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} + proc glGetProgramPipelineInfoLog(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} proc glGetOcclusionQueryuivNV(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} proc glVertexAttrib4bvARB(index: GLuint, v: ptr GLbyte) {.importc.} proc glListParameterfvSGIX(list: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} @@ -1206,7 +1206,7 @@ wrapErrorChecking: proc glProgramUniform2dEXT(program: GLuint, location: GLint, x: GLdouble, y: GLdouble) {.importc.} proc glCompressedMultiTexImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} proc glDeleteSyncAPPLE(sync: GLsync) {.importc.} - proc glDebugMessageInsertAMD(category: GLenum, severity: GLenum, id: GLuint, length: GLsizei, buf: cstring) {.importc.} + proc glDebugMessageInsertAMD(category: GLenum, severity: GLenum, id: GLuint, length: GLsizei, buf: ptr GLchar) {.importc.} proc glSecondaryColorPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glTextureImage2DMultisampleNV(texture: GLuint, target: GLenum, samples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, fixedSampleLocations: GLboolean) {.importc.} proc glBeginFragmentShaderATI() {.importc.} @@ -1247,7 +1247,7 @@ wrapErrorChecking: proc glFinish() {.importc.} proc glDeleteVertexShaderEXT(id: GLuint) {.importc.} proc glFinishObjectAPPLE(`object`: GLenum, name: GLint) {.importc.} - proc glGetActiveAttribARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} + proc glGetActiveAttribARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLcharARB) {.importc.} proc glPointParameterx(pname: GLenum, param: GLfixed) {.importc.} proc glProgramUniformui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} proc glSecondaryColor3ubv(v: ptr GLubyte) {.importc.} @@ -1273,7 +1273,7 @@ wrapErrorChecking: proc glUniform1i(location: GLint, v0: GLint) {.importc.} proc glVertexAttribL2d(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} proc glTestObjectAPPLE(`object`: GLenum, name: GLuint): TGLboolean {.importc.} - proc glGetTransformFeedbackVarying(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} + proc glGetTransformFeedbackVarying(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} proc glFramebufferRenderbufferOES(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} proc glVertexStream3iATI(stream: GLenum, x: GLint, y: GLint, z: GLint) {.importc.} proc glMakeTextureHandleNonResidentNV(handle: GLuint64) {.importc.} @@ -1320,7 +1320,7 @@ wrapErrorChecking: proc glVertexAttribL4i64NV(index: GLuint, x: GLint64EXT, y: GLint64EXT, z: GLint64EXT, w: GLint64EXT) {.importc.} proc glDebugMessageCallbackARB(callback: GLDEBUGPROCARB, userParam: ptr pointer) {.importc.} proc glMultiTexCoordP1uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} - proc glLabelObjectEXT(`type`: GLenum, `object`: GLuint, length: GLsizei, label: cstring) {.importc.} + proc glLabelObjectEXT(`type`: GLenum, `object`: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} proc glGetnPolygonStippleARB(bufSize: GLsizei, pattern: ptr GLubyte) {.importc.} proc glTexCoord3xOES(s: GLfixed, t: GLfixed, r: GLfixed) {.importc.} proc glCopyPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, `type`: GLenum) {.importc.} @@ -1367,7 +1367,7 @@ wrapErrorChecking: proc glBlendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum) {.importc.} proc glGetColorTableParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glQueryCounterEXT(id: GLuint, target: GLenum) {.importc.} - proc glExtGetProgramBinarySourceQCOM(program: GLuint, shadertype: GLenum, source: cstring, length: ptr GLint) {.importc.} + proc glExtGetProgramBinarySourceQCOM(program: GLuint, shadertype: GLenum, source: ptr GLchar, length: ptr GLint) {.importc.} proc glGetConvolutionParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glIsProgramPipeline(pipeline: GLuint): TGLboolean {.importc.} proc glVertexWeightfvEXT(weight: ptr GLfloat) {.importc.} @@ -1413,7 +1413,7 @@ wrapErrorChecking: proc glUniform4uiEXT(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} proc glGetShaderiv(shader: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glGetQueryIndexediv(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} - proc glDebugMessageInsert(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} + proc glDebugMessageInsert(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} proc glVertexAttribs2dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} proc glGetFixedvOES(pname: GLenum, params: ptr GLfixed) {.importc.} proc glUniform2iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} @@ -1433,13 +1433,13 @@ wrapErrorChecking: proc glGetIntegeri_v(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} proc glProgramUniform3uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glGetActiveUniformBlockiv(program: GLuint, uniformBlockIndex: GLuint, pname: GLenum, params: ptr GLint) {.importc.} - proc glCreateShaderProgramv(`type`: GLenum, count: GLsizei, strings: cstringArray): TGLuint {.importc.} + proc glCreateShaderProgramv(`type`: GLenum, count: GLsizei, strings: ptr ptr GLchar): TGLuint {.importc.} proc glUniform2fARB(location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} proc glVertexStream4ivATI(stream: GLenum, coords: ptr GLint) {.importc.} proc glNormalP3uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} proc glVertexAttribLFormat(attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} proc glTexCoord2bvOES(coords: ptr GLbyte) {.importc.} - proc glGetActiveUniformName(program: GLuint, uniformIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformName: cstring) {.importc.} + proc glGetActiveUniformName(program: GLuint, uniformIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformName: ptr GLchar) {.importc.} proc glTexCoord2sv(v: ptr GLshort) {.importc.} proc glVertexAttrib2dNV(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} proc glGetFogFuncSGIS(points: ptr GLfloat) {.importc.} @@ -1464,7 +1464,7 @@ wrapErrorChecking: proc glUniform2fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} proc glFogf(pname: GLenum, param: GLfloat) {.importc.} proc glMultiTexCoord1iARB(target: GLenum, s: GLint) {.importc.} - proc glGetActiveUniformARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} + proc glGetActiveUniformARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLcharARB) {.importc.} proc glMapGrid1xOES(n: GLint, u1: GLfixed, u2: GLfixed) {.importc.} proc glIndexsv(c: ptr GLshort) {.importc.} proc glFragmentMaterialfSGIX(face: GLenum, pname: GLenum, param: GLfloat) {.importc.} @@ -1510,7 +1510,7 @@ wrapErrorChecking: proc glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: GLuint, coverageSamples: GLsizei, colorSamples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} proc glVertexAttribI3iEXT(index: GLuint, x: GLint, y: GLint, z: GLint) {.importc.} proc glUniform4uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} - proc glGetUniformLocation(program: GLuint, name: cstring): TGLint {.importc.} + proc glGetUniformLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} proc glCurrentPaletteMatrixARB(index: GLint) {.importc.} proc glVertexAttribLPointerEXT(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glFogCoorddvEXT(coord: ptr GLdouble) {.importc.} @@ -1538,7 +1538,7 @@ wrapErrorChecking: proc glGetStringi(name: GLenum, index: GLuint): TGLubyte {.importc.} proc glMakeBufferNonResidentNV(target: GLenum) {.importc.} proc glVertex4bOES(x: GLbyte, y: GLbyte, z: GLbyte) {.importc.} - proc glGetObjectLabel(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} + proc glGetObjectLabel(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} proc glClipPlanexOES(plane: GLenum, equation: ptr GLfixed) {.importc.} proc glElementPointerAPPLE(`type`: GLenum, `pointer`: pointer) {.importc.} proc glIsAsyncMarkerSGIX(marker: GLuint): TGLboolean {.importc.} @@ -1567,13 +1567,13 @@ wrapErrorChecking: proc glGetFloatIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLfloat) {.importc.} proc glTexCoord1xOES(s: GLfixed) {.importc.} proc glTexCoord4f(s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} - proc glShaderSource(shader: GLuint, count: GLsizei, string: cstringArray, length: ptr GLint) {.importc.} + proc glShaderSource(shader: GLuint, count: GLsizei, string: ptr ptr GLchar, length: ptr GLint) {.importc.} proc glGetDetailTexFuncSGIS(target: GLenum, points: ptr GLfloat) {.importc.} proc glResetHistogram(target: GLenum) {.importc.} proc glVertexAttribP2ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} proc glDrawTransformFeedbackNV(mode: GLenum, id: GLuint) {.importc.} proc glWindowPos2fMESA(x: GLfloat, y: GLfloat) {.importc.} - proc glObjectLabelKHR(identifier: GLenum, name: GLuint, length: GLsizei, label: cstring) {.importc.} + proc glObjectLabelKHR(identifier: GLenum, name: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} proc glMultiTexCoord2iARB(target: GLenum, s: GLint, t: GLint) {.importc.} proc glVertexAttrib4usv(index: GLuint, v: ptr GLushort) {.importc.} proc glGetGraphicsResetStatusARB(): TGLenum {.importc.} @@ -1593,7 +1593,7 @@ wrapErrorChecking: proc glMatrixTranslatefEXT(mode: GLenum, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glColor4iv(v: ptr GLint) {.importc.} proc glSecondaryColor3ivEXT(v: ptr GLint) {.importc.} - proc glIsNamedStringARB(namelen: GLint, name: cstring): TGLboolean {.importc.} + proc glIsNamedStringARB(namelen: GLint, name: ptr GLchar): TGLboolean {.importc.} proc glVertexAttribL4dv(index: GLuint, v: ptr GLdouble) {.importc.} proc glEndTransformFeedback() {.importc.} proc glVertexStream3fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} @@ -1607,7 +1607,7 @@ wrapErrorChecking: proc glMultiTexCoord3sv(target: GLenum, v: ptr GLshort) {.importc.} proc glVertexAttrib4Nub(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, w: GLubyte) {.importc.} proc glColor3d(red: GLdouble, green: GLdouble, blue: GLdouble) {.importc.} - proc glGetActiveAttrib(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} + proc glGetActiveAttrib(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLchar) {.importc.} proc glConvolutionParameterfEXT(target: GLenum, pname: GLenum, params: GLfloat) {.importc.} proc glTexSubImage2DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} proc glBinormal3fvEXT(v: ptr GLfloat) {.importc.} @@ -1690,12 +1690,12 @@ wrapErrorChecking: proc glStartTilingQCOM(x: GLuint, y: GLuint, width: GLuint, height: GLuint, preserveMask: GLbitfield) {.importc.} proc glVariantivEXT(id: GLuint, `addr`: ptr GLint) {.importc.} proc glGetnMinmaxARB(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, bufSize: GLsizei, values: pointer) {.importc.} - proc glTransformFeedbackVaryings(program: GLuint, count: GLsizei, varyings: cstringArray, bufferMode: GLenum) {.importc.} + proc glTransformFeedbackVaryings(program: GLuint, count: GLsizei, varyings: ptr ptr GLchar, bufferMode: GLenum) {.importc.} proc glShaderOp2EXT(op: GLenum, res: GLuint, arg1: GLuint, arg2: GLuint) {.importc.} proc glVertexAttribPointer(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, `pointer`: pointer) {.importc.} proc glMultiTexCoord4dvARB(target: GLenum, v: ptr GLdouble) {.importc.} proc glProgramUniform1ui64NV(program: GLuint, location: GLint, x: GLuint64EXT) {.importc.} - proc glGetShaderSourceARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} + proc glGetShaderSourceARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, source: ptr GLcharARB) {.importc.} proc glGetBufferSubDataARB(target: GLenum, offset: GLintptrARB, size: GLsizeiptrARB, data: pointer) {.importc.} proc glCopyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} proc glProgramEnvParameterI4iNV(target: GLenum, index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} @@ -1805,7 +1805,7 @@ wrapErrorChecking: proc glVertexAttribs4fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} proc glVertexAttribL3dv(index: GLuint, v: ptr GLdouble) {.importc.} proc glTexEnvi(target: GLenum, pname: GLenum, param: GLint) {.importc.} - proc glObjectPtrLabel(`ptr`: ptr pointer, length: GLsizei, label: cstring) {.importc.} + proc glObjectPtrLabel(`ptr`: ptr pointer, length: GLsizei, label: ptr GLchar) {.importc.} proc glGetTexGenfv(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glMapVertexAttrib1dAPPLE(index: GLuint, size: GLuint, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: ptr GLdouble) {.importc.} proc glTexCoord3dv(v: ptr GLdouble) {.importc.} @@ -1814,7 +1814,7 @@ wrapErrorChecking: proc glMatrixIndexPointerARB(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glUniformHandleui64ARB(location: GLint, value: GLuint64) {.importc.} proc glUniform1fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} - proc glGetActiveSubroutineUniformName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} + proc glGetActiveSubroutineUniformName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} proc glProgramUniformMatrix4x2fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} proc glMultiTexCoord4fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} proc glGetDriverControlsQCOM(num: ptr GLint, size: GLsizei, driverControls: ptr GLuint) {.importc.} @@ -1857,7 +1857,7 @@ wrapErrorChecking: proc glVertexAttrib4dARB(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} proc glUniform3fARB(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} proc glWindowPos2ivARB(v: ptr GLint) {.importc.} - proc glCreateShaderProgramvEXT(`type`: GLenum, count: GLsizei, strings: cstringArray): TGLuint {.importc.} + proc glCreateShaderProgramvEXT(`type`: GLenum, count: GLsizei, strings: ptr ptr GLchar): TGLuint {.importc.} proc glListParameterivSGIX(list: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glGetGraphicsResetStatusEXT(): TGLenum {.importc.} proc glActiveShaderProgramEXT(pipeline: GLuint, program: GLuint) {.importc.} @@ -1901,7 +1901,7 @@ wrapErrorChecking: proc glFramebufferTexture1DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} proc glTangent3fEXT(tx: GLfloat, ty: GLfloat, tz: GLfloat) {.importc.} proc glIsVertexAttribEnabledAPPLE(index: GLuint, pname: GLenum): TGLboolean {.importc.} - proc glGetShaderInfoLog(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} + proc glGetShaderInfoLog(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} proc glFrustumx(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} proc glTexGenfv(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glCompressedTexImage2DARB(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} @@ -2026,7 +2026,7 @@ wrapErrorChecking: proc glBeginConditionalRenderNV(id: GLuint, mode: GLenum) {.importc.} proc glEdgeFlagv(flag: ptr GLboolean) {.importc.} proc glReplacementCodeubSUN(code: GLubyte) {.importc.} - proc glObjectLabel(identifier: GLenum, name: GLuint, length: GLsizei, label: cstring) {.importc.} + proc glObjectLabel(identifier: GLenum, name: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} proc glMultiTexCoord3xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} proc glNormal3iv(v: ptr GLint) {.importc.} proc glSamplerParameteri(sampler: GLuint, pname: GLenum, param: GLint) {.importc.} @@ -2123,7 +2123,7 @@ wrapErrorChecking: proc glFreeObjectBufferATI(buffer: GLuint) {.importc.} proc glGetVideouivNV(video_slot: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} proc glVertexAttribL4ui64NV(index: GLuint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT, w: GLuint64EXT) {.importc.} - proc glGetUniformBlockIndex(program: GLuint, uniformBlockName: cstring): TGLuint {.importc.} + proc glGetUniformBlockIndex(program: GLuint, uniformBlockName: ptr GLchar): TGLuint {.importc.} proc glCopyMultiTexSubImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} proc glVertex3bvOES(coords: ptr GLbyte) {.importc.} proc glMultiDrawElementArrayAPPLE(mode: GLenum, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei) {.importc.} @@ -2157,14 +2157,14 @@ wrapErrorChecking: proc glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glGetMultiTexEnvivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetFloatv(pname: GLenum, params: ptr GLfloat) {.importc.} - proc glInsertEventMarkerEXT(length: GLsizei, marker: cstring) {.importc.} + proc glInsertEventMarkerEXT(length: GLsizei, marker: ptr GLchar) {.importc.} proc glRasterPos3d(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} proc glNamedFramebufferRenderbufferEXT(framebuffer: GLuint, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} proc glGetConvolutionFilter(target: GLenum, format: GLenum, `type`: GLenum, image: pointer) {.importc.} proc glIsOcclusionQueryNV(id: GLuint): TGLboolean {.importc.} proc glGetnPixelMapuivARB(map: GLenum, bufSize: GLsizei, values: ptr GLuint) {.importc.} proc glMapParameterfvNV(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glPushDebugGroup(source: GLenum, id: GLuint, length: GLsizei, message: cstring) {.importc.} + proc glPushDebugGroup(source: GLenum, id: GLuint, length: GLsizei, message: ptr GLchar) {.importc.} proc glMakeImageHandleResidentARB(handle: GLuint64, access: GLenum) {.importc.} proc glProgramUniformMatrix2fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} proc glUniform3i64vNV(location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} @@ -2177,7 +2177,7 @@ wrapErrorChecking: proc glGetRenderbufferParameterivOES(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetBufferPointerv(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} proc glSecondaryColor3ui(red: GLuint, green: GLuint, blue: GLuint) {.importc.} - proc glGetDebugMessageLog(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): TGLuint {.importc.} + proc glGetDebugMessageLog(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} proc glNormal3i(nx: GLint, ny: GLint, nz: GLint) {.importc.} proc glTestFenceNV(fence: GLuint): TGLboolean {.importc.} proc glSecondaryColor3usv(v: ptr GLushort) {.importc.} @@ -2289,7 +2289,7 @@ wrapErrorChecking: proc glTranslated(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} proc glColorPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glDrawElementsInstancedBaseVertex(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, instancecount: GLsizei, basevertex: GLint) {.importc.} - proc glBindAttribLocationARB(programObj: GLhandleARB, index: GLuint, name: cstring) {.importc.} + proc glBindAttribLocationARB(programObj: GLhandleARB, index: GLuint, name: ptr GLcharARB) {.importc.} proc glTexGendv(coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} proc glGetPathCoordsNV(path: GLuint, coords: ptr GLfloat) {.importc.} proc glGetMapParameterivNV(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} @@ -2322,7 +2322,7 @@ wrapErrorChecking: proc glGetBufferPointervARB(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} proc glGetMultiTexLevelParameterfvEXT(texunit: GLenum, target: GLenum, level: GLint, pname: GLenum, params: ptr GLfloat) {.importc.} proc glMultiTexParameterIuivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} - proc glGetShaderSource(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} + proc glGetShaderSource(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, source: ptr GLchar) {.importc.} proc glStencilFunc(func: GLenum, `ref`: GLint, mask: GLuint) {.importc.} proc glVertexAttribI4bvEXT(index: GLuint, v: ptr GLbyte) {.importc.} proc glVertexAttrib4NuivARB(index: GLuint, v: ptr GLuint) {.importc.} @@ -2337,7 +2337,7 @@ wrapErrorChecking: proc glTextureStorage2DMultisampleEXT(texture: GLuint, target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, fixedsamplelocations: GLboolean) {.importc.} proc glGetHistogramParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} proc glVertexAttrib4dNV(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} - proc glGetPerfMonitorCounterStringAMD(group: GLuint, counter: GLuint, bufSize: GLsizei, length: ptr GLsizei, counterString: cstring) {.importc.} + proc glGetPerfMonitorCounterStringAMD(group: GLuint, counter: GLuint, bufSize: GLsizei, length: ptr GLsizei, counterString: ptr GLchar) {.importc.} proc glMultiTexCoord2sARB(target: GLenum, s: GLshort, t: GLshort) {.importc.} proc glSpriteParameterivSGIX(pname: GLenum, params: ptr GLint) {.importc.} proc glCompressedTextureImage3DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} @@ -2348,7 +2348,7 @@ wrapErrorChecking: proc glProgramParameteri(program: GLuint, pname: GLenum, value: GLint) {.importc.} proc glGetLocalConstantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} proc glFragmentMaterialiSGIX(face: GLenum, pname: GLenum, param: GLint) {.importc.} - proc glGetNamedStringivARB(namelen: GLint, name: cstring, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetNamedStringivARB(namelen: GLint, name: ptr GLchar, pname: GLenum, params: ptr GLint) {.importc.} proc glBinormal3ivEXT(v: ptr GLint) {.importc.} proc glCheckFramebufferStatusEXT(target: GLenum): TGLenum {.importc.} proc glVertexAttrib1fNV(index: GLuint, x: GLfloat) {.importc.} @@ -2362,7 +2362,7 @@ wrapErrorChecking: proc glBeginTransformFeedbackEXT(primitiveMode: GLenum) {.importc.} proc glBufferAddressRangeNV(pname: GLenum, index: GLuint, address: GLuint64EXT, length: GLsizeiptr) {.importc.} proc glPointParameterfvARB(pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetActiveVaryingNV(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} + proc glGetActiveVaryingNV(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} proc glIndexMask(mask: GLuint) {.importc.} proc glVertexAttribBinding(attribindex: GLuint, bindingindex: GLuint) {.importc.} proc glDeleteFencesNV(n: GLsizei, fences: ptr GLuint) {.importc.} @@ -2432,7 +2432,7 @@ wrapErrorChecking: proc glMapControlPointsNV(target: GLenum, index: GLuint, `type`: GLenum, ustride: GLsizei, vstride: GLsizei, uorder: GLint, vorder: GLint, packed: GLboolean, points: pointer) {.importc.} proc glGetBufferParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glUnmapObjectBufferATI(buffer: GLuint) {.importc.} - proc glGetProgramResourceLocation(program: GLuint, programInterface: GLenum, name: cstring): TGLint {.importc.} + proc glGetProgramResourceLocation(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLint {.importc.} proc glUniform4i64vNV(location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} proc glImageTransformParameterfHP(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} proc glArrayObjectATI(`array`: GLenum, size: GLint, `type`: GLenum, stride: GLsizei, buffer: GLuint, offset: GLuint) {.importc.} @@ -2442,7 +2442,7 @@ wrapErrorChecking: proc glListParameteriSGIX(list: GLuint, pname: GLenum, param: GLint) {.importc.} proc glProgramUniformMatrix2dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} proc glProgramUniform2i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} - proc glObjectPtrLabelKHR(`ptr`: ptr pointer, length: GLsizei, label: cstring) {.importc.} + proc glObjectPtrLabelKHR(`ptr`: ptr pointer, length: GLsizei, label: ptr GLchar) {.importc.} proc glVertexAttribL1i64NV(index: GLuint, x: GLint64EXT) {.importc.} proc glMultiTexBufferEXT(texunit: GLenum, target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} proc glCoverFillPathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, coverMode: GLenum, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} @@ -2461,7 +2461,7 @@ wrapErrorChecking: proc glGetBooleanv(pname: GLenum, params: ptr GLboolean) {.importc.} proc glTangent3ivEXT(v: ptr GLint) {.importc.} proc glTexImage3DMultisample(target: GLenum, samples: GLsizei, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedsamplelocations: GLboolean) {.importc.} - proc glGetUniformIndices(program: GLuint, uniformCount: GLsizei, uniformNames: cstringArray, uniformIndices: ptr GLuint) {.importc.} + proc glGetUniformIndices(program: GLuint, uniformCount: GLsizei, uniformNames: ptr ptr GLchar, uniformIndices: ptr GLuint) {.importc.} proc glVDPAUInitNV(vdpDevice: pointer, getProcAddress: pointer) {.importc.} proc glGetMinmaxParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glMultiTexCoord2fvARB(target: GLenum, v: ptr GLfloat) {.importc.} @@ -2473,18 +2473,18 @@ wrapErrorChecking: proc glGetInstrumentsSGIX(): TGLint {.importc.} proc glFramebufferParameteri(target: GLenum, pname: GLenum, param: GLint) {.importc.} proc glPathCoverDepthFuncNV(func: GLenum) {.importc.} - proc glGetTranslatedShaderSourceANGLE(shader: GLuint, bufsize: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} + proc glGetTranslatedShaderSourceANGLE(shader: GLuint, bufsize: GLsizei, length: ptr GLsizei, source: ptr GLchar) {.importc.} proc glIndexfv(c: ptr GLfloat) {.importc.} - proc glGetActiveUniformBlockName(program: GLuint, uniformBlockIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformBlockName: cstring) {.importc.} + proc glGetActiveUniformBlockName(program: GLuint, uniformBlockIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformBlockName: ptr GLchar) {.importc.} proc glNormal3s(nx: GLshort, ny: GLshort, nz: GLshort) {.importc.} proc glColorFragmentOp3ATI(op: GLenum, dst: GLuint, dstMask: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint, arg3: GLuint, arg3Rep: GLuint, arg3Mod: GLuint) {.importc.} - proc glGetProgramResourceLocationIndex(program: GLuint, programInterface: GLenum, name: cstring): TGLint {.importc.} + proc glGetProgramResourceLocationIndex(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLint {.importc.} proc glGetBooleanIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLboolean) {.importc.} proc glGenPerfMonitorsAMD(n: GLsizei, monitors: ptr GLuint) {.importc.} proc glDrawRangeElementsEXT(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei, `type`: GLenum, indices: pointer) {.importc.} proc glFramebufferTexture3D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} proc glGetTexParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} - proc glCompileShaderIncludeARB(shader: GLuint, count: GLsizei, path: cstringArray, length: ptr GLint) {.importc.} + proc glCompileShaderIncludeARB(shader: GLuint, count: GLsizei, path: ptr ptr GLchar, length: ptr GLint) {.importc.} proc glGetMultiTexParameterfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glEvalPoint2(i: GLint, j: GLint) {.importc.} proc glGetProgramivNV(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} @@ -2498,7 +2498,7 @@ wrapErrorChecking: proc glProgramUniformMatrix3x4dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} proc glGetFloati_vEXT(pname: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} proc glGetObjectParameterivAPPLE(objectType: GLenum, name: GLuint, pname: GLenum, params: ptr GLint) {.importc.} - proc glPushGroupMarkerEXT(length: GLsizei, marker: cstring) {.importc.} + proc glPushGroupMarkerEXT(length: GLsizei, marker: ptr GLchar) {.importc.} proc glProgramUniform4uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glReplacementCodeuiVertex3fSUN(rc: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glTexSubImage1DEXT(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} @@ -2571,7 +2571,7 @@ wrapErrorChecking: proc glTexCoord4bOES(s: GLbyte, t: GLbyte, r: GLbyte, q: GLbyte) {.importc.} proc glSecondaryColor3us(red: GLushort, green: GLushort, blue: GLushort) {.importc.} proc glGlobalAlphaFactorubSUN(factor: GLubyte) {.importc.} - proc glNamedStringARB(`type`: GLenum, namelen: GLint, name: cstring, stringlen: GLint, string: cstring) {.importc.} + proc glNamedStringARB(`type`: GLenum, namelen: GLint, name: ptr GLchar, stringlen: GLint, string: ptr GLchar) {.importc.} proc glGetAttachedShaders(program: GLuint, maxCount: GLsizei, count: ptr GLsizei, shaders: ptr GLuint) {.importc.} proc glMatrixRotatefEXT(mode: GLenum, angle: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glVertexStream3ivATI(stream: GLenum, coords: ptr GLint) {.importc.} @@ -2643,12 +2643,12 @@ wrapErrorChecking: proc glIsQuery(id: GLuint): TGLboolean {.importc.} proc glFogxv(pname: GLenum, param: ptr GLfixed) {.importc.} proc glAreProgramsResidentNV(n: GLsizei, programs: ptr GLuint, residences: ptr GLboolean): TGLboolean {.importc.} - proc glShaderSourceARB(shaderObj: GLhandleARB, count: GLsizei, string: cstringArray, length: ptr GLint) {.importc.} + proc glShaderSourceARB(shaderObj: GLhandleARB, count: GLsizei, string: ptr ptr GLcharARB, length: ptr GLint) {.importc.} proc glPointSizexOES(size: GLfixed) {.importc.} proc glPixelTransferf(pname: GLenum, param: GLfloat) {.importc.} proc glExtractComponentEXT(res: GLuint, src: GLuint, num: GLuint) {.importc.} proc glUniform1fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} - proc glGetNamedStringARB(namelen: GLint, name: cstring, bufSize: GLsizei, stringlen: ptr GLint, string: cstring) {.importc.} + proc glGetNamedStringARB(namelen: GLint, name: ptr GLchar, bufSize: GLsizei, stringlen: ptr GLint, string: ptr GLchar) {.importc.} proc glGetProgramBinaryOES(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, binaryFormat: ptr GLenum, binary: pointer) {.importc.} proc glDeleteOcclusionQueriesNV(n: GLsizei, ids: ptr GLuint) {.importc.} proc glEnableClientState(`array`: GLenum) {.importc.} @@ -2693,14 +2693,14 @@ wrapErrorChecking: proc glIndexub(c: GLubyte) {.importc.} proc glVertexP2uiv(`type`: GLenum, value: ptr GLuint) {.importc.} proc glProgramUniform1uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} - proc glDebugMessageInsertKHR(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} + proc glDebugMessageInsertKHR(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} proc glColor4b(red: GLbyte, green: GLbyte, blue: GLbyte, alpha: GLbyte) {.importc.} proc glRenderbufferStorageMultisampleAPPLE(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} proc glMinSampleShading(value: GLfloat) {.importc.} proc glBindProgramNV(target: GLenum, id: GLuint) {.importc.} proc glWindowPos3dMESA(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} proc glEdgeFlagPointer(stride: GLsizei, `pointer`: pointer) {.importc.} - proc glGetFragDataIndex(program: GLuint, name: cstring): TGLint {.importc.} + proc glGetFragDataIndex(program: GLuint, name: ptr GLchar): TGLint {.importc.} proc glTexCoord3hNV(s: GLhalfNV, t: GLhalfNV, r: GLhalfNV) {.importc.} proc glMultiDrawArraysIndirectAMD(mode: GLenum, indirect: pointer, primcount: GLsizei, stride: GLsizei) {.importc.} proc glFragmentColorMaterialSGIX(face: GLenum, mode: GLenum) {.importc.} @@ -2746,7 +2746,7 @@ wrapErrorChecking: proc glWindowPos3iv(v: ptr GLint) {.importc.} proc glProgramUniform4ui64NV(program: GLuint, location: GLint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT, w: GLuint64EXT) {.importc.} proc glProgramUniform2d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble) {.importc.} - proc glDebugMessageInsertARB(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} + proc glDebugMessageInsertARB(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} proc glMultiTexSubImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} proc glMap1d(target: GLenum, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: ptr GLdouble) {.importc.} proc glDeleteShader(shader: GLuint) {.importc.} @@ -2778,7 +2778,7 @@ wrapErrorChecking: proc glGetVertexArrayIntegeri_vEXT(vaobj: GLuint, index: GLuint, pname: GLenum, param: ptr GLint) {.importc.} proc glReadnPixelsEXT(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, bufSize: GLsizei, data: pointer) {.importc.} proc glMultiTexImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} - proc glGetVaryingLocationNV(program: GLuint, name: cstring): TGLint {.importc.} + proc glGetVaryingLocationNV(program: GLuint, name: ptr GLchar): TGLint {.importc.} proc glMultiTexCoord4fvARB(target: GLenum, v: ptr GLfloat) {.importc.} proc glMultiTexCoord3iv(target: GLenum, v: ptr GLint) {.importc.} proc glVertexAttribL2dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} @@ -2791,7 +2791,7 @@ wrapErrorChecking: proc glProgramUniform3ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} proc glTexCoord2fColor3fVertex3fvSUN(tc: ptr GLfloat, c: ptr GLfloat, v: ptr GLfloat) {.importc.} proc glProgramUniform3fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} - proc glBindFragDataLocationIndexed(program: GLuint, colorNumber: GLuint, index: GLuint, name: cstring) {.importc.} + proc glBindFragDataLocationIndexed(program: GLuint, colorNumber: GLuint, index: GLuint, name: ptr GLchar) {.importc.} proc glGetnSeparableFilterARB(target: GLenum, format: GLenum, `type`: GLenum, rowBufSize: GLsizei, row: pointer, columnBufSize: GLsizei, column: pointer, span: pointer) {.importc.} proc glTextureParameteriEXT(texture: GLuint, target: GLenum, pname: GLenum, param: GLint) {.importc.} proc glGetUniformuivEXT(program: GLuint, location: GLint, params: ptr GLuint) {.importc.} @@ -2809,12 +2809,12 @@ wrapErrorChecking: proc glTexCoord2fColor4fNormal3fVertex3fvSUN(tc: ptr GLfloat, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} proc glMultiTexCoord3s(target: GLenum, s: GLshort, t: GLshort, r: GLshort) {.importc.} proc glMultTransposeMatrixd(m: ptr GLdouble) {.importc.} - proc glActiveVaryingNV(program: GLuint, name: cstring) {.importc.} + proc glActiveVaryingNV(program: GLuint, name: ptr GLchar) {.importc.} proc glProgramUniform1f(program: GLuint, location: GLint, v0: GLfloat) {.importc.} - proc glGetActiveSubroutineName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} + proc glGetActiveSubroutineName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} proc glClipPlanex(plane: GLenum, equation: ptr GLfixed) {.importc.} proc glMultiTexCoord4iv(target: GLenum, v: ptr GLint) {.importc.} - proc glTransformFeedbackVaryingsEXT(program: GLuint, count: GLsizei, varyings: cstringArray, bufferMode: GLenum) {.importc.} + proc glTransformFeedbackVaryingsEXT(program: GLuint, count: GLsizei, varyings: ptr ptr GLchar, bufferMode: GLenum) {.importc.} proc glBlendEquationSeparateiARB(buf: GLuint, modeRGB: GLenum, modeAlpha: GLenum) {.importc.} proc glVertex2sv(v: ptr GLshort) {.importc.} proc glAccumxOES(op: GLenum, value: GLfixed) {.importc.} @@ -2894,7 +2894,7 @@ wrapErrorChecking: proc glPointParameterivNV(pname: GLenum, params: ptr GLint) {.importc.} proc glBlitFramebufferANGLE(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} proc glGetObjectParameterivARB(obj: GLhandleARB, pname: GLenum, params: ptr GLint) {.importc.} - proc glGetSubroutineIndex(program: GLuint, shadertype: GLenum, name: cstring): TGLuint {.importc.} + proc glGetSubroutineIndex(program: GLuint, shadertype: GLenum, name: ptr GLchar): TGLuint {.importc.} proc glMap2d(target: GLenum, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: ptr GLdouble) {.importc.} proc glRectfv(v1: ptr GLfloat, v2: ptr GLfloat) {.importc.} proc glDepthRangeArrayv(first: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} @@ -2951,7 +2951,7 @@ wrapErrorChecking: proc glEndQuery(target: GLenum) {.importc.} proc glBlitFramebufferEXT(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} proc glProgramEnvParametersI4uivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} - proc glGetActiveUniform(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} + proc glGetActiveUniform(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLchar) {.importc.} proc glGenAsyncMarkersSGIX(range: GLsizei): TGLuint {.importc.} proc glClipControlARB(origin: GLenum, depth: GLenum) {.importc.} proc glDrawElementsInstancedEXT(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, primcount: GLsizei) {.importc.} @@ -2970,7 +2970,7 @@ wrapErrorChecking: proc glProgramParameter4dvNV(target: GLenum, index: GLuint, v: ptr GLdouble) {.importc.} proc glDeleteBuffers(n: GLsizei, buffers: ptr GLuint) {.importc.} proc glGetVertexArrayIntegervEXT(vaobj: GLuint, pname: GLenum, param: ptr GLint) {.importc.} - proc glBindFragDataLocationEXT(program: GLuint, color: GLuint, name: cstring) {.importc.} + proc glBindFragDataLocationEXT(program: GLuint, color: GLuint, name: ptr GLchar) {.importc.} proc glGenProgramsNV(n: GLsizei, programs: ptr GLuint) {.importc.} proc glMultiTexCoord1i(target: GLenum, s: GLint) {.importc.} proc glCompressedTexImage3DOES(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} @@ -2988,7 +2988,7 @@ wrapErrorChecking: proc glTexGenivOES(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glIsFramebufferOES(framebuffer: GLuint): TGLboolean {.importc.} proc glColor4ubv(v: ptr GLubyte) {.importc.} - proc glDeleteNamedStringARB(namelen: GLint, name: cstring) {.importc.} + proc glDeleteNamedStringARB(namelen: GLint, name: ptr GLchar) {.importc.} proc glCopyConvolutionFilter1DEXT(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} proc glBufferStorage(target: GLenum, size: GLsizeiptr, data: ptr pointer, flags: GLbitfield) {.importc.} proc glDrawTexiOES(x: GLint, y: GLint, z: GLint, width: GLint, height: GLint) {.importc.} @@ -3140,7 +3140,7 @@ wrapErrorChecking: proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glSampleMapATI(dst: GLuint, interp: GLuint, swizzle: GLenum) {.importc.} proc glProgramUniform1d(program: GLuint, location: GLint, v0: GLdouble) {.importc.} - proc glBindAttribLocation(program: GLuint, index: GLuint, name: cstring) {.importc.} + proc glBindAttribLocation(program: GLuint, index: GLuint, name: ptr GLchar) {.importc.} proc glGetCombinerStageParameterfvNV(stage: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glTexSubImage4DSGIS(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, woffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, size4d: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} proc glGetMapAttribParameterfvNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} @@ -3163,9 +3163,10 @@ wrapErrorChecking: proc glColorTable(target: GLenum, internalformat: GLenum, width: GLsizei, format: GLenum, `type`: GLenum, table: pointer) {.importc.} proc glProgramUniformMatrix2x3dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} {.pop.} # stdcall, hint[XDeclaredButNotUsed]: off. - const cGL_UNSIGNED_BYTE* = 0x1401 + cGL_UNSIGNED_SHORT* = 0x1403 + GL_2X_BIT_ATI* = 0x00000001 GL_MODELVIEW6_ARB* = 0x8726 GL_CULL_FACE_MODE* = 0x0B45 From c93a329c0c6977d6d4f95c4a3cc33088f152ea96 Mon Sep 17 00:00:00 2001 From: EXetoC Date: Wed, 16 Apr 2014 01:58:27 +0200 Subject: [PATCH 17/18] No, I think that actually is correct. --- src/opengl.nim | 160 ++++++++++++++++++++++++------------------------- 1 file changed, 80 insertions(+), 80 deletions(-) diff --git a/src/opengl.nim b/src/opengl.nim index b53152b..84119cb 100644 --- a/src/opengl.nim +++ b/src/opengl.nim @@ -358,7 +358,7 @@ wrapErrorChecking: proc glColor4dv(v: ptr GLdouble) {.importc.} proc glColor3fv(v: ptr GLfloat) {.importc.} proc glVertexAttribI1uiEXT(index: GLuint, x: GLuint) {.importc.} - proc glGetDebugMessageLogKHR(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} + proc glGetDebugMessageLogKHR(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): TGLuint {.importc.} proc glVertexAttribI2iv(index: GLuint, v: ptr GLint) {.importc.} proc glTexCoord1xvOES(coords: ptr GLfixed) {.importc.} proc glVertex3hNV(x: GLhalfNV, y: GLhalfNV, z: GLhalfNV) {.importc.} @@ -446,7 +446,7 @@ wrapErrorChecking: proc glImageTransformParameterfvHP(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glUniform3uiEXT(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint) {.importc.} proc glGetInvariantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} - proc glGetTransformFeedbackVaryingEXT(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGetTransformFeedbackVaryingEXT(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} proc glSamplerParameterIuiv(sampler: GLuint, pname: GLenum, param: ptr GLuint) {.importc.} proc glProgramUniform2fEXT(program: GLuint, location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} proc glMultiTexCoord2hvNV(target: GLenum, v: ptr GLhalfNV) {.importc.} @@ -457,14 +457,14 @@ wrapErrorChecking: proc glFenceSyncAPPLE(condition: GLenum, flags: GLbitfield): TGLsync {.importc.} proc glGetVariantArrayObjectivATI(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glProgramUniform4dvEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} - proc glPushDebugGroupKHR(source: GLenum, id: GLuint, length: GLsizei, message: ptr GLchar) {.importc.} + proc glPushDebugGroupKHR(source: GLenum, id: GLuint, length: GLsizei, message: cstring) {.importc.} proc glFragmentLightivSGIX(light: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glFramebufferTexture2DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} proc glGetActiveSubroutineUniformiv(program: GLuint, shadertype: GLenum, index: GLuint, pname: GLenum, values: ptr GLint) {.importc.} proc glFrustumf(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} proc glEndQueryIndexed(target: GLenum, index: GLuint) {.importc.} proc glCompressedTextureSubImage3DEXT(texture: GLuint, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, bits: pointer) {.importc.} - proc glGetProgramPipelineInfoLogEXT(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetProgramPipelineInfoLogEXT(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} proc glGetVertexAttribfvNV(index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} proc glVertexArrayIndexOffsetEXT(vaobj: GLuint, buffer: GLuint, `type`: GLenum, stride: GLsizei, offset: GLintptr) {.importc.} proc glDrawTexsvOES(coords: ptr GLshort) {.importc.} @@ -484,7 +484,7 @@ wrapErrorChecking: proc glColor3bv(v: ptr GLbyte) {.importc.} proc glNamedProgramLocalParameter4dEXT(program: GLuint, target: GLenum, index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} proc glVertexPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} - proc glGetObjectLabelKHR(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glGetObjectLabelKHR(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} proc glCombinerStageParameterfvNV(stage: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glNormal3hvNV(v: ptr GLhalfNV) {.importc.} proc glUniform2i64NV(location: GLint, x: GLint64EXT, y: GLint64EXT) {.importc.} @@ -553,9 +553,9 @@ wrapErrorChecking: proc glFlushMappedBufferRangeEXT(target: GLenum, offset: GLintptr, length: GLsizeiptr) {.importc.} proc glNormal3dv(v: ptr GLdouble) {.importc.} proc glProgramUniform4d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble, v2: GLdouble, v3: GLdouble) {.importc.} - proc glCreateShaderProgramEXT(`type`: GLenum, string: ptr GLchar): TGLuint {.importc.} + proc glCreateShaderProgramEXT(`type`: GLenum, string: cstring): TGLuint {.importc.} proc glGetLightxvOES(light: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} - proc glGetObjectPtrLabelKHR(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glGetObjectPtrLabelKHR(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} proc glTransformPathNV(resultPath: GLuint, srcPath: GLuint, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} proc glMultTransposeMatrixf(m: ptr GLfloat) {.importc.} proc glMapVertexAttrib2dAPPLE(index: GLuint, size: GLuint, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: ptr GLdouble) {.importc.} @@ -575,7 +575,7 @@ wrapErrorChecking: proc glMultiTexEnviEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLint) {.importc.} proc glProgramUniform1fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} proc glDrawBuffersARB(n: GLsizei, bufs: ptr GLenum) {.importc.} - proc glGetUniformLocationARB(programObj: GLhandleARB, name: ptr GLcharARB): TGLint {.importc.} + proc glGetUniformLocationARB(programObj: GLhandleARB, name: cstring): TGLint {.importc.} proc glResumeTransformFeedback() {.importc.} proc glMap1f(target: GLenum, u1: GLfloat, u2: GLfloat, stride: GLint, order: GLint, points: ptr GLfloat) {.importc.} proc glVertex3xOES(x: GLfixed, y: GLfixed) {.importc.} @@ -587,7 +587,7 @@ wrapErrorChecking: proc glGetVertexArrayPointeri_vEXT(vaobj: GLuint, index: GLuint, pname: GLenum, param: ptr pointer) {.importc.} proc glProgramParameter4fvNV(target: GLenum, index: GLuint, v: ptr GLfloat) {.importc.} proc glDiscardFramebufferEXT(target: GLenum, numAttachments: GLsizei, attachments: ptr GLenum) {.importc.} - proc glGetDebugMessageLogARB(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} + proc glGetDebugMessageLogARB(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): TGLuint {.importc.} proc glResolveMultisampleFramebufferAPPLE() {.importc.} proc glGetIntegeri_vEXT(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} proc glDepthBoundsdNV(zmin: GLdouble, zmax: GLdouble) {.importc.} @@ -642,7 +642,7 @@ wrapErrorChecking: proc glVertexAttribL4i64vNV(index: GLuint, v: ptr GLint64EXT) {.importc.} proc glEnableVariantClientStateEXT(id: GLuint) {.importc.} proc glSyncTextureINTEL(texture: GLuint) {.importc.} - proc glGetObjectPtrLabel(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glGetObjectPtrLabel(`ptr`: ptr pointer, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} proc glCopyTexSubImage1D(target: GLenum, level: GLint, xoffset: GLint, x: GLint, y: GLint, width: GLsizei) {.importc.} proc glOrthofOES(l: GLfloat, r: GLfloat, b: GLfloat, t: GLfloat, n: GLfloat, f: GLfloat) {.importc.} proc glWindowPos3sARB(x: GLshort, y: GLshort, z: GLshort) {.importc.} @@ -665,7 +665,7 @@ wrapErrorChecking: proc glVertexP2ui(`type`: GLenum, value: GLuint) {.importc.} proc glGenQueries(n: GLsizei, ids: ptr GLuint) {.importc.} proc glBindBufferOffsetNV(target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr) {.importc.} - proc glGetFragDataLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetFragDataLocation(program: GLuint, name: cstring): TGLint {.importc.} proc glVertexAttribs2svNV(index: GLuint, count: GLsizei, v: ptr GLshort) {.importc.} proc glGetPathLengthNV(path: GLuint, startSegment: GLsizei, numSegments: GLsizei): TGLfloat {.importc.} proc glVertexAttrib3dARB(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} @@ -731,7 +731,7 @@ wrapErrorChecking: proc glGetFixedv(pname: GLenum, params: ptr GLfixed) {.importc.} proc glMaterialf(face: GLenum, pname: GLenum, param: GLfloat) {.importc.} proc glVideoCaptureStreamParameterfvNV(video_capture_slot: GLuint, stream: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetDebugMessageLogAMD(count: GLuint, bufsize: GLsizei, categories: ptr GLenum, severities: ptr GLuint, ids: ptr GLuint, lengths: ptr GLsizei, message: ptr GLchar): TGLuint {.importc.} + proc glGetDebugMessageLogAMD(count: GLuint, bufsize: GLsizei, categories: ptr GLenum, severities: ptr GLuint, ids: ptr GLuint, lengths: ptr GLsizei, message: cstring): TGLuint {.importc.} proc glProgramUniform2uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glMatrixMultTransposedEXT(mode: GLenum, m: ptr GLdouble) {.importc.} proc glIsPointInStrokePathNV(path: GLuint, x: GLfloat, y: GLfloat): TGLboolean {.importc.} @@ -767,7 +767,7 @@ wrapErrorChecking: proc glTexStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei) {.importc.} proc glMultiTexCoord2xOES(texture: GLenum, s: GLfixed, t: GLfixed) {.importc.} proc glWindowPos2fARB(x: GLfloat, y: GLfloat) {.importc.} - proc glGetProgramResourceIndex(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLuint {.importc.} + proc glGetProgramResourceIndex(program: GLuint, programInterface: GLenum, name: cstring): TGLuint {.importc.} proc glProgramUniform2uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glMakeImageHandleNonResidentNV(handle: GLuint64) {.importc.} proc glNamedProgramLocalParameter4fvEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} @@ -793,7 +793,7 @@ wrapErrorChecking: proc glProgramLocalParameterI4uivNV(target: GLenum, index: GLuint, params: ptr GLuint) {.importc.} proc glRenderMode(mode: GLenum): TGLint {.importc.} proc glVertexStream4fATI(stream: GLenum, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} - proc glGetObjectLabelEXT(`type`: GLenum, `object`: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glGetObjectLabelEXT(`type`: GLenum, `object`: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} proc glNamedFramebufferTexture3DEXT(framebuffer: GLuint, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} proc glLoadMatrixf(m: ptr GLfloat) {.importc.} proc glGetQueryObjectuivEXT(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} @@ -803,7 +803,7 @@ wrapErrorChecking: proc glTexGenxvOES(coord: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} proc glMatrixMode(mode: GLenum) {.importc.} proc glColorTableParameterivSGI(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} - proc glGetProgramInfoLog(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetProgramInfoLog(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} proc glGetSeparableFilter(target: GLenum, format: GLenum, `type`: GLenum, row: pointer, column: pointer, span: pointer) {.importc.} proc glFogfv(pname: GLenum, params: ptr GLfloat) {.importc.} proc glDrawTexfvOES(coords: ptr GLfloat) {.importc.} @@ -829,7 +829,7 @@ wrapErrorChecking: proc glBeginConditionalRender(id: GLuint, mode: GLenum) {.importc.} proc glVertexAttribI3uiEXT(index: GLuint, x: GLuint, y: GLuint, z: GLuint) {.importc.} proc glVDPAUMapSurfacesNV(numSurfaces: GLsizei, surfaces: ptr GLvdpauSurfaceNV) {.importc.} - proc glGetProgramResourceName(program: GLuint, programInterface: GLenum, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} + proc glGetProgramResourceName(program: GLuint, programInterface: GLenum, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} proc glMultiTexCoord4f(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} proc glVertexAttrib2hNV(index: GLuint, x: GLhalfNV, y: GLhalfNV) {.importc.} proc glDrawArraysInstancedNV(mode: GLenum, first: GLint, count: GLsizei, primcount: GLsizei) {.importc.} @@ -850,7 +850,7 @@ wrapErrorChecking: proc glReferencePlaneSGIX(equation: ptr GLdouble) {.importc.} proc glNormalStream3iATI(stream: GLenum, nx: GLint, ny: GLint, nz: GLint) {.importc.} proc glGetColorTableParameterfvEXT(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetAttribLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetAttribLocation(program: GLuint, name: cstring): TGLint {.importc.} proc glMultiTexParameterfEXT(texunit: GLenum, target: GLenum, pname: GLenum, param: GLfloat) {.importc.} proc glGenFencesNV(n: GLsizei, fences: ptr GLuint) {.importc.} proc glUniform4dv(location: GLint, count: GLsizei, value: ptr GLdouble) {.importc.} @@ -877,7 +877,7 @@ wrapErrorChecking: proc glMultiTexCoord3fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} proc glRasterPos3xOES(x: GLfixed, y: GLfixed, z: GLfixed) {.importc.} proc glEGLImageTargetRenderbufferStorageOES(target: GLenum, image: GLeglImageOES) {.importc.} - proc glGetAttribLocationARB(programObj: GLhandleARB, name: ptr GLcharARB): TGLint {.importc.} + proc glGetAttribLocationARB(programObj: GLhandleARB, name: cstring): TGLint {.importc.} proc glProgramNamedParameter4dvNV(id: GLuint, len: GLsizei, name: ptr GLubyte, v: ptr GLdouble) {.importc.} proc glProgramLocalParameterI4uiNV(target: GLenum, index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint) {.importc.} proc glNamedFramebufferTextureFaceEXT(framebuffer: GLuint, attachment: GLenum, texture: GLuint, level: GLint, face: GLenum) {.importc.} @@ -954,7 +954,7 @@ wrapErrorChecking: proc glGetPixelTexGenParameterivSGIS(pname: GLenum, params: ptr GLint) {.importc.} proc glVariantuivEXT(id: GLuint, `addr`: ptr GLuint) {.importc.} proc glTexParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetSubroutineUniformLocation(program: GLuint, shadertype: GLenum, name: ptr GLchar): TGLint {.importc.} + proc glGetSubroutineUniformLocation(program: GLuint, shadertype: GLenum, name: cstring): TGLint {.importc.} proc glProgramUniformMatrix3fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} proc glDrawBuffersATI(n: GLsizei, bufs: ptr GLenum) {.importc.} proc glGetVertexAttribivNV(index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} @@ -995,7 +995,7 @@ wrapErrorChecking: proc glTexCoord3f(s: GLfloat, t: GLfloat, r: GLfloat) {.importc.} proc glMultiTexCoord1fARB(target: GLenum, s: GLfloat) {.importc.} proc glVertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) {.importc.} - proc glGetFragDataLocationEXT(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetFragDataLocationEXT(program: GLuint, name: cstring): TGLint {.importc.} proc glFlushMappedNamedBufferRangeEXT(buffer: GLuint, offset: GLintptr, length: GLsizeiptr) {.importc.} proc glVertexAttrib1sARB(index: GLuint, x: GLshort) {.importc.} proc glBitmapxOES(width: GLsizei, height: GLsizei, xorig: GLfixed, yorig: GLfixed, xmove: GLfixed, ymove: GLfixed, bitmap: ptr GLubyte) {.importc.} @@ -1024,7 +1024,7 @@ wrapErrorChecking: proc glEnableDriverControlQCOM(driverControl: GLuint) {.importc.} proc glPointParameteri(pname: GLenum, param: GLint) {.importc.} proc glVertexAttribI2i(index: GLuint, x: GLint, y: GLint) {.importc.} - proc glGetDriverControlStringQCOM(driverControl: GLuint, bufSize: GLsizei, length: ptr GLsizei, driverControlString: ptr GLchar) {.importc.} + proc glGetDriverControlStringQCOM(driverControl: GLuint, bufSize: GLsizei, length: ptr GLsizei, driverControlString: cstring) {.importc.} proc glGetTexLevelParameteriv(target: GLenum, level: GLint, pname: GLenum, params: ptr GLint) {.importc.} proc glGetHandleARB(pname: GLenum): TGLhandleARB {.importc.} proc glIndexubv(c: ptr GLubyte) {.importc.} @@ -1058,7 +1058,7 @@ wrapErrorChecking: proc glVertexAttribI1iEXT(index: GLuint, x: GLint) {.importc.} proc glFramebufferTexture1D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} proc glVertexAttribI2uiv(index: GLuint, v: ptr GLuint) {.importc.} - proc glBindFragDataLocation(program: GLuint, color: GLuint, name: ptr GLchar) {.importc.} + proc glBindFragDataLocation(program: GLuint, color: GLuint, name: cstring) {.importc.} proc glClearStencil(s: GLint) {.importc.} proc glVertexAttrib4Nubv(index: GLuint, v: ptr GLubyte) {.importc.} proc glConvolutionFilter2DEXT(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, image: pointer) {.importc.} @@ -1103,7 +1103,7 @@ wrapErrorChecking: proc glGetMinmaxParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glColor4fNormal3fVertex3fSUN(r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glWindowPos2d(x: GLdouble, y: GLdouble) {.importc.} - proc glGetPerfMonitorGroupStringAMD(group: GLuint, bufSize: GLsizei, length: ptr GLsizei, groupString: ptr GLchar) {.importc.} + proc glGetPerfMonitorGroupStringAMD(group: GLuint, bufSize: GLsizei, length: ptr GLsizei, groupString: cstring) {.importc.} proc glUniformHandleui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64) {.importc.} proc glBlendEquation(mode: GLenum) {.importc.} proc glMapBufferARB(target: GLenum, access: GLenum) {.importc.} @@ -1145,7 +1145,7 @@ wrapErrorChecking: proc glVertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat) {.importc.} proc glMultiTexGenivEXT(texunit: GLenum, coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glUniformui64vNV(location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} - proc glGetInfoLogARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, infoLog: ptr GLcharARB) {.importc.} + proc glGetInfoLogARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} proc glGetNamedProgramLocalParameterIivEXT(program: GLuint, target: GLenum, index: GLuint, params: ptr GLint) {.importc.} proc glVertexAttrib4s(index: GLuint, x: GLshort, y: GLshort, z: GLshort, w: GLshort) {.importc.} proc glUniformMatrix4x2dv(location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} @@ -1162,7 +1162,7 @@ wrapErrorChecking: proc glTexParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetArrayObjectivATI(`array`: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetTexParameterIuiv(target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} - proc glGetProgramPipelineInfoLog(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetProgramPipelineInfoLog(pipeline: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} proc glGetOcclusionQueryuivNV(id: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} proc glVertexAttrib4bvARB(index: GLuint, v: ptr GLbyte) {.importc.} proc glListParameterfvSGIX(list: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} @@ -1206,7 +1206,7 @@ wrapErrorChecking: proc glProgramUniform2dEXT(program: GLuint, location: GLint, x: GLdouble, y: GLdouble) {.importc.} proc glCompressedMultiTexImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} proc glDeleteSyncAPPLE(sync: GLsync) {.importc.} - proc glDebugMessageInsertAMD(category: GLenum, severity: GLenum, id: GLuint, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glDebugMessageInsertAMD(category: GLenum, severity: GLenum, id: GLuint, length: GLsizei, buf: cstring) {.importc.} proc glSecondaryColorPointerEXT(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glTextureImage2DMultisampleNV(texture: GLuint, target: GLenum, samples: GLsizei, internalFormat: GLint, width: GLsizei, height: GLsizei, fixedSampleLocations: GLboolean) {.importc.} proc glBeginFragmentShaderATI() {.importc.} @@ -1247,7 +1247,7 @@ wrapErrorChecking: proc glFinish() {.importc.} proc glDeleteVertexShaderEXT(id: GLuint) {.importc.} proc glFinishObjectAPPLE(`object`: GLenum, name: GLint) {.importc.} - proc glGetActiveAttribARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLcharARB) {.importc.} + proc glGetActiveAttribARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} proc glPointParameterx(pname: GLenum, param: GLfixed) {.importc.} proc glProgramUniformui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} proc glSecondaryColor3ubv(v: ptr GLubyte) {.importc.} @@ -1273,7 +1273,7 @@ wrapErrorChecking: proc glUniform1i(location: GLint, v0: GLint) {.importc.} proc glVertexAttribL2d(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} proc glTestObjectAPPLE(`object`: GLenum, name: GLuint): TGLboolean {.importc.} - proc glGetTransformFeedbackVarying(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGetTransformFeedbackVarying(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} proc glFramebufferRenderbufferOES(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} proc glVertexStream3iATI(stream: GLenum, x: GLint, y: GLint, z: GLint) {.importc.} proc glMakeTextureHandleNonResidentNV(handle: GLuint64) {.importc.} @@ -1320,7 +1320,7 @@ wrapErrorChecking: proc glVertexAttribL4i64NV(index: GLuint, x: GLint64EXT, y: GLint64EXT, z: GLint64EXT, w: GLint64EXT) {.importc.} proc glDebugMessageCallbackARB(callback: GLDEBUGPROCARB, userParam: ptr pointer) {.importc.} proc glMultiTexCoordP1uiv(texture: GLenum, `type`: GLenum, coords: ptr GLuint) {.importc.} - proc glLabelObjectEXT(`type`: GLenum, `object`: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} + proc glLabelObjectEXT(`type`: GLenum, `object`: GLuint, length: GLsizei, label: cstring) {.importc.} proc glGetnPolygonStippleARB(bufSize: GLsizei, pattern: ptr GLubyte) {.importc.} proc glTexCoord3xOES(s: GLfixed, t: GLfixed, r: GLfixed) {.importc.} proc glCopyPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, `type`: GLenum) {.importc.} @@ -1367,7 +1367,7 @@ wrapErrorChecking: proc glBlendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum) {.importc.} proc glGetColorTableParameterfv(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glQueryCounterEXT(id: GLuint, target: GLenum) {.importc.} - proc glExtGetProgramBinarySourceQCOM(program: GLuint, shadertype: GLenum, source: ptr GLchar, length: ptr GLint) {.importc.} + proc glExtGetProgramBinarySourceQCOM(program: GLuint, shadertype: GLenum, source: cstring, length: ptr GLint) {.importc.} proc glGetConvolutionParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glIsProgramPipeline(pipeline: GLuint): TGLboolean {.importc.} proc glVertexWeightfvEXT(weight: ptr GLfloat) {.importc.} @@ -1413,7 +1413,7 @@ wrapErrorChecking: proc glUniform4uiEXT(location: GLint, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint) {.importc.} proc glGetShaderiv(shader: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glGetQueryIndexediv(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLint) {.importc.} - proc glDebugMessageInsert(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glDebugMessageInsert(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} proc glVertexAttribs2dvNV(index: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} proc glGetFixedvOES(pname: GLenum, params: ptr GLfixed) {.importc.} proc glUniform2iv(location: GLint, count: GLsizei, value: ptr GLint) {.importc.} @@ -1433,13 +1433,13 @@ wrapErrorChecking: proc glGetIntegeri_v(target: GLenum, index: GLuint, data: ptr GLint) {.importc.} proc glProgramUniform3uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glGetActiveUniformBlockiv(program: GLuint, uniformBlockIndex: GLuint, pname: GLenum, params: ptr GLint) {.importc.} - proc glCreateShaderProgramv(`type`: GLenum, count: GLsizei, strings: ptr ptr GLchar): TGLuint {.importc.} + proc glCreateShaderProgramv(`type`: GLenum, count: GLsizei, strings: cstringArray): TGLuint {.importc.} proc glUniform2fARB(location: GLint, v0: GLfloat, v1: GLfloat) {.importc.} proc glVertexStream4ivATI(stream: GLenum, coords: ptr GLint) {.importc.} proc glNormalP3uiv(`type`: GLenum, coords: ptr GLuint) {.importc.} proc glVertexAttribLFormat(attribindex: GLuint, size: GLint, `type`: GLenum, relativeoffset: GLuint) {.importc.} proc glTexCoord2bvOES(coords: ptr GLbyte) {.importc.} - proc glGetActiveUniformName(program: GLuint, uniformIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformName: ptr GLchar) {.importc.} + proc glGetActiveUniformName(program: GLuint, uniformIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformName: cstring) {.importc.} proc glTexCoord2sv(v: ptr GLshort) {.importc.} proc glVertexAttrib2dNV(index: GLuint, x: GLdouble, y: GLdouble) {.importc.} proc glGetFogFuncSGIS(points: ptr GLfloat) {.importc.} @@ -1464,7 +1464,7 @@ wrapErrorChecking: proc glUniform2fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} proc glFogf(pname: GLenum, param: GLfloat) {.importc.} proc glMultiTexCoord1iARB(target: GLenum, s: GLint) {.importc.} - proc glGetActiveUniformARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLcharARB) {.importc.} + proc glGetActiveUniformARB(programObj: GLhandleARB, index: GLuint, maxLength: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} proc glMapGrid1xOES(n: GLint, u1: GLfixed, u2: GLfixed) {.importc.} proc glIndexsv(c: ptr GLshort) {.importc.} proc glFragmentMaterialfSGIX(face: GLenum, pname: GLenum, param: GLfloat) {.importc.} @@ -1510,7 +1510,7 @@ wrapErrorChecking: proc glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: GLuint, coverageSamples: GLsizei, colorSamples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} proc glVertexAttribI3iEXT(index: GLuint, x: GLint, y: GLint, z: GLint) {.importc.} proc glUniform4uivEXT(location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} - proc glGetUniformLocation(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetUniformLocation(program: GLuint, name: cstring): TGLint {.importc.} proc glCurrentPaletteMatrixARB(index: GLint) {.importc.} proc glVertexAttribLPointerEXT(index: GLuint, size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glFogCoorddvEXT(coord: ptr GLdouble) {.importc.} @@ -1538,7 +1538,7 @@ wrapErrorChecking: proc glGetStringi(name: GLenum, index: GLuint): TGLubyte {.importc.} proc glMakeBufferNonResidentNV(target: GLenum) {.importc.} proc glVertex4bOES(x: GLbyte, y: GLbyte, z: GLbyte) {.importc.} - proc glGetObjectLabel(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: ptr GLchar) {.importc.} + proc glGetObjectLabel(identifier: GLenum, name: GLuint, bufSize: GLsizei, length: ptr GLsizei, label: cstring) {.importc.} proc glClipPlanexOES(plane: GLenum, equation: ptr GLfixed) {.importc.} proc glElementPointerAPPLE(`type`: GLenum, `pointer`: pointer) {.importc.} proc glIsAsyncMarkerSGIX(marker: GLuint): TGLboolean {.importc.} @@ -1567,13 +1567,13 @@ wrapErrorChecking: proc glGetFloatIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLfloat) {.importc.} proc glTexCoord1xOES(s: GLfixed) {.importc.} proc glTexCoord4f(s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} - proc glShaderSource(shader: GLuint, count: GLsizei, string: ptr ptr GLchar, length: ptr GLint) {.importc.} + proc glShaderSource(shader: GLuint, count: GLsizei, string: cstringArray, length: ptr GLint) {.importc.} proc glGetDetailTexFuncSGIS(target: GLenum, points: ptr GLfloat) {.importc.} proc glResetHistogram(target: GLenum) {.importc.} proc glVertexAttribP2ui(index: GLuint, `type`: GLenum, normalized: GLboolean, value: GLuint) {.importc.} proc glDrawTransformFeedbackNV(mode: GLenum, id: GLuint) {.importc.} proc glWindowPos2fMESA(x: GLfloat, y: GLfloat) {.importc.} - proc glObjectLabelKHR(identifier: GLenum, name: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} + proc glObjectLabelKHR(identifier: GLenum, name: GLuint, length: GLsizei, label: cstring) {.importc.} proc glMultiTexCoord2iARB(target: GLenum, s: GLint, t: GLint) {.importc.} proc glVertexAttrib4usv(index: GLuint, v: ptr GLushort) {.importc.} proc glGetGraphicsResetStatusARB(): TGLenum {.importc.} @@ -1593,7 +1593,7 @@ wrapErrorChecking: proc glMatrixTranslatefEXT(mode: GLenum, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glColor4iv(v: ptr GLint) {.importc.} proc glSecondaryColor3ivEXT(v: ptr GLint) {.importc.} - proc glIsNamedStringARB(namelen: GLint, name: ptr GLchar): TGLboolean {.importc.} + proc glIsNamedStringARB(namelen: GLint, name: cstring): TGLboolean {.importc.} proc glVertexAttribL4dv(index: GLuint, v: ptr GLdouble) {.importc.} proc glEndTransformFeedback() {.importc.} proc glVertexStream3fvATI(stream: GLenum, coords: ptr GLfloat) {.importc.} @@ -1607,7 +1607,7 @@ wrapErrorChecking: proc glMultiTexCoord3sv(target: GLenum, v: ptr GLshort) {.importc.} proc glVertexAttrib4Nub(index: GLuint, x: GLubyte, y: GLubyte, z: GLubyte, w: GLubyte) {.importc.} proc glColor3d(red: GLdouble, green: GLdouble, blue: GLdouble) {.importc.} - proc glGetActiveAttrib(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGetActiveAttrib(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} proc glConvolutionParameterfEXT(target: GLenum, pname: GLenum, params: GLfloat) {.importc.} proc glTexSubImage2DEXT(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} proc glBinormal3fvEXT(v: ptr GLfloat) {.importc.} @@ -1690,12 +1690,12 @@ wrapErrorChecking: proc glStartTilingQCOM(x: GLuint, y: GLuint, width: GLuint, height: GLuint, preserveMask: GLbitfield) {.importc.} proc glVariantivEXT(id: GLuint, `addr`: ptr GLint) {.importc.} proc glGetnMinmaxARB(target: GLenum, reset: GLboolean, format: GLenum, `type`: GLenum, bufSize: GLsizei, values: pointer) {.importc.} - proc glTransformFeedbackVaryings(program: GLuint, count: GLsizei, varyings: ptr ptr GLchar, bufferMode: GLenum) {.importc.} + proc glTransformFeedbackVaryings(program: GLuint, count: GLsizei, varyings: cstringArray, bufferMode: GLenum) {.importc.} proc glShaderOp2EXT(op: GLenum, res: GLuint, arg1: GLuint, arg2: GLuint) {.importc.} proc glVertexAttribPointer(index: GLuint, size: GLint, `type`: GLenum, normalized: GLboolean, stride: GLsizei, `pointer`: pointer) {.importc.} proc glMultiTexCoord4dvARB(target: GLenum, v: ptr GLdouble) {.importc.} proc glProgramUniform1ui64NV(program: GLuint, location: GLint, x: GLuint64EXT) {.importc.} - proc glGetShaderSourceARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, source: ptr GLcharARB) {.importc.} + proc glGetShaderSourceARB(obj: GLhandleARB, maxLength: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} proc glGetBufferSubDataARB(target: GLenum, offset: GLintptrARB, size: GLsizeiptrARB, data: pointer) {.importc.} proc glCopyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} proc glProgramEnvParameterI4iNV(target: GLenum, index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint) {.importc.} @@ -1805,7 +1805,7 @@ wrapErrorChecking: proc glVertexAttribs4fvNV(index: GLuint, count: GLsizei, v: ptr GLfloat) {.importc.} proc glVertexAttribL3dv(index: GLuint, v: ptr GLdouble) {.importc.} proc glTexEnvi(target: GLenum, pname: GLenum, param: GLint) {.importc.} - proc glObjectPtrLabel(`ptr`: ptr pointer, length: GLsizei, label: ptr GLchar) {.importc.} + proc glObjectPtrLabel(`ptr`: ptr pointer, length: GLsizei, label: cstring) {.importc.} proc glGetTexGenfv(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glMapVertexAttrib1dAPPLE(index: GLuint, size: GLuint, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: ptr GLdouble) {.importc.} proc glTexCoord3dv(v: ptr GLdouble) {.importc.} @@ -1814,7 +1814,7 @@ wrapErrorChecking: proc glMatrixIndexPointerARB(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glUniformHandleui64ARB(location: GLint, value: GLuint64) {.importc.} proc glUniform1fvARB(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} - proc glGetActiveSubroutineUniformName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} + proc glGetActiveSubroutineUniformName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} proc glProgramUniformMatrix4x2fvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} proc glMultiTexCoord4fARB(target: GLenum, s: GLfloat, t: GLfloat, r: GLfloat, q: GLfloat) {.importc.} proc glGetDriverControlsQCOM(num: ptr GLint, size: GLsizei, driverControls: ptr GLuint) {.importc.} @@ -1857,7 +1857,7 @@ wrapErrorChecking: proc glVertexAttrib4dARB(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} proc glUniform3fARB(location: GLint, v0: GLfloat, v1: GLfloat, v2: GLfloat) {.importc.} proc glWindowPos2ivARB(v: ptr GLint) {.importc.} - proc glCreateShaderProgramvEXT(`type`: GLenum, count: GLsizei, strings: ptr ptr GLchar): TGLuint {.importc.} + proc glCreateShaderProgramvEXT(`type`: GLenum, count: GLsizei, strings: cstringArray): TGLuint {.importc.} proc glListParameterivSGIX(list: GLuint, pname: GLenum, params: ptr GLint) {.importc.} proc glGetGraphicsResetStatusEXT(): TGLenum {.importc.} proc glActiveShaderProgramEXT(pipeline: GLuint, program: GLuint) {.importc.} @@ -1901,7 +1901,7 @@ wrapErrorChecking: proc glFramebufferTexture1DEXT(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint) {.importc.} proc glTangent3fEXT(tx: GLfloat, ty: GLfloat, tz: GLfloat) {.importc.} proc glIsVertexAttribEnabledAPPLE(index: GLuint, pname: GLenum): TGLboolean {.importc.} - proc glGetShaderInfoLog(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: ptr GLchar) {.importc.} + proc glGetShaderInfoLog(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, infoLog: cstring) {.importc.} proc glFrustumx(l: GLfixed, r: GLfixed, b: GLfixed, t: GLfixed, n: GLfixed, f: GLfixed) {.importc.} proc glTexGenfv(coord: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glCompressedTexImage2DARB(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} @@ -2026,7 +2026,7 @@ wrapErrorChecking: proc glBeginConditionalRenderNV(id: GLuint, mode: GLenum) {.importc.} proc glEdgeFlagv(flag: ptr GLboolean) {.importc.} proc glReplacementCodeubSUN(code: GLubyte) {.importc.} - proc glObjectLabel(identifier: GLenum, name: GLuint, length: GLsizei, label: ptr GLchar) {.importc.} + proc glObjectLabel(identifier: GLenum, name: GLuint, length: GLsizei, label: cstring) {.importc.} proc glMultiTexCoord3xvOES(texture: GLenum, coords: ptr GLfixed) {.importc.} proc glNormal3iv(v: ptr GLint) {.importc.} proc glSamplerParameteri(sampler: GLuint, pname: GLenum, param: GLint) {.importc.} @@ -2123,7 +2123,7 @@ wrapErrorChecking: proc glFreeObjectBufferATI(buffer: GLuint) {.importc.} proc glGetVideouivNV(video_slot: GLuint, pname: GLenum, params: ptr GLuint) {.importc.} proc glVertexAttribL4ui64NV(index: GLuint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT, w: GLuint64EXT) {.importc.} - proc glGetUniformBlockIndex(program: GLuint, uniformBlockName: ptr GLchar): TGLuint {.importc.} + proc glGetUniformBlockIndex(program: GLuint, uniformBlockName: cstring): TGLuint {.importc.} proc glCopyMultiTexSubImage2DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {.importc.} proc glVertex3bvOES(coords: ptr GLbyte) {.importc.} proc glMultiDrawElementArrayAPPLE(mode: GLenum, first: ptr GLint, count: ptr GLsizei, primcount: GLsizei) {.importc.} @@ -2157,14 +2157,14 @@ wrapErrorChecking: proc glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glGetMultiTexEnvivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetFloatv(pname: GLenum, params: ptr GLfloat) {.importc.} - proc glInsertEventMarkerEXT(length: GLsizei, marker: ptr GLchar) {.importc.} + proc glInsertEventMarkerEXT(length: GLsizei, marker: cstring) {.importc.} proc glRasterPos3d(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} proc glNamedFramebufferRenderbufferEXT(framebuffer: GLuint, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLuint) {.importc.} proc glGetConvolutionFilter(target: GLenum, format: GLenum, `type`: GLenum, image: pointer) {.importc.} proc glIsOcclusionQueryNV(id: GLuint): TGLboolean {.importc.} proc glGetnPixelMapuivARB(map: GLenum, bufSize: GLsizei, values: ptr GLuint) {.importc.} proc glMapParameterfvNV(target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} - proc glPushDebugGroup(source: GLenum, id: GLuint, length: GLsizei, message: ptr GLchar) {.importc.} + proc glPushDebugGroup(source: GLenum, id: GLuint, length: GLsizei, message: cstring) {.importc.} proc glMakeImageHandleResidentARB(handle: GLuint64, access: GLenum) {.importc.} proc glProgramUniformMatrix2fv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLfloat) {.importc.} proc glUniform3i64vNV(location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} @@ -2177,7 +2177,7 @@ wrapErrorChecking: proc glGetRenderbufferParameterivOES(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glGetBufferPointerv(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} proc glSecondaryColor3ui(red: GLuint, green: GLuint, blue: GLuint) {.importc.} - proc glGetDebugMessageLog(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: ptr GLchar): TGLuint {.importc.} + proc glGetDebugMessageLog(count: GLuint, bufsize: GLsizei, sources: ptr GLenum, types: ptr GLenum, ids: ptr GLuint, severities: ptr GLenum, lengths: ptr GLsizei, messageLog: cstring): TGLuint {.importc.} proc glNormal3i(nx: GLint, ny: GLint, nz: GLint) {.importc.} proc glTestFenceNV(fence: GLuint): TGLboolean {.importc.} proc glSecondaryColor3usv(v: ptr GLushort) {.importc.} @@ -2289,7 +2289,7 @@ wrapErrorChecking: proc glTranslated(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} proc glColorPointer(size: GLint, `type`: GLenum, stride: GLsizei, `pointer`: pointer) {.importc.} proc glDrawElementsInstancedBaseVertex(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, instancecount: GLsizei, basevertex: GLint) {.importc.} - proc glBindAttribLocationARB(programObj: GLhandleARB, index: GLuint, name: ptr GLcharARB) {.importc.} + proc glBindAttribLocationARB(programObj: GLhandleARB, index: GLuint, name: cstring) {.importc.} proc glTexGendv(coord: GLenum, pname: GLenum, params: ptr GLdouble) {.importc.} proc glGetPathCoordsNV(path: GLuint, coords: ptr GLfloat) {.importc.} proc glGetMapParameterivNV(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} @@ -2322,7 +2322,7 @@ wrapErrorChecking: proc glGetBufferPointervARB(target: GLenum, pname: GLenum, params: ptr pointer) {.importc.} proc glGetMultiTexLevelParameterfvEXT(texunit: GLenum, target: GLenum, level: GLint, pname: GLenum, params: ptr GLfloat) {.importc.} proc glMultiTexParameterIuivEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLuint) {.importc.} - proc glGetShaderSource(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, source: ptr GLchar) {.importc.} + proc glGetShaderSource(shader: GLuint, bufSize: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} proc glStencilFunc(func: GLenum, `ref`: GLint, mask: GLuint) {.importc.} proc glVertexAttribI4bvEXT(index: GLuint, v: ptr GLbyte) {.importc.} proc glVertexAttrib4NuivARB(index: GLuint, v: ptr GLuint) {.importc.} @@ -2337,7 +2337,7 @@ wrapErrorChecking: proc glTextureStorage2DMultisampleEXT(texture: GLuint, target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, fixedsamplelocations: GLboolean) {.importc.} proc glGetHistogramParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} proc glVertexAttrib4dNV(index: GLuint, x: GLdouble, y: GLdouble, z: GLdouble, w: GLdouble) {.importc.} - proc glGetPerfMonitorCounterStringAMD(group: GLuint, counter: GLuint, bufSize: GLsizei, length: ptr GLsizei, counterString: ptr GLchar) {.importc.} + proc glGetPerfMonitorCounterStringAMD(group: GLuint, counter: GLuint, bufSize: GLsizei, length: ptr GLsizei, counterString: cstring) {.importc.} proc glMultiTexCoord2sARB(target: GLenum, s: GLshort, t: GLshort) {.importc.} proc glSpriteParameterivSGIX(pname: GLenum, params: ptr GLint) {.importc.} proc glCompressedTextureImage3DEXT(texture: GLuint, target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, bits: pointer) {.importc.} @@ -2348,7 +2348,7 @@ wrapErrorChecking: proc glProgramParameteri(program: GLuint, pname: GLenum, value: GLint) {.importc.} proc glGetLocalConstantIntegervEXT(id: GLuint, value: GLenum, data: ptr GLint) {.importc.} proc glFragmentMaterialiSGIX(face: GLenum, pname: GLenum, param: GLint) {.importc.} - proc glGetNamedStringivARB(namelen: GLint, name: ptr GLchar, pname: GLenum, params: ptr GLint) {.importc.} + proc glGetNamedStringivARB(namelen: GLint, name: cstring, pname: GLenum, params: ptr GLint) {.importc.} proc glBinormal3ivEXT(v: ptr GLint) {.importc.} proc glCheckFramebufferStatusEXT(target: GLenum): TGLenum {.importc.} proc glVertexAttrib1fNV(index: GLuint, x: GLfloat) {.importc.} @@ -2362,7 +2362,7 @@ wrapErrorChecking: proc glBeginTransformFeedbackEXT(primitiveMode: GLenum) {.importc.} proc glBufferAddressRangeNV(pname: GLenum, index: GLuint, address: GLuint64EXT, length: GLsizeiptr) {.importc.} proc glPointParameterfvARB(pname: GLenum, params: ptr GLfloat) {.importc.} - proc glGetActiveVaryingNV(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGetActiveVaryingNV(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLsizei, `type`: ptr GLenum, name: cstring) {.importc.} proc glIndexMask(mask: GLuint) {.importc.} proc glVertexAttribBinding(attribindex: GLuint, bindingindex: GLuint) {.importc.} proc glDeleteFencesNV(n: GLsizei, fences: ptr GLuint) {.importc.} @@ -2432,7 +2432,7 @@ wrapErrorChecking: proc glMapControlPointsNV(target: GLenum, index: GLuint, `type`: GLenum, ustride: GLsizei, vstride: GLsizei, uorder: GLint, vorder: GLint, packed: GLboolean, points: pointer) {.importc.} proc glGetBufferParameteriv(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glUnmapObjectBufferATI(buffer: GLuint) {.importc.} - proc glGetProgramResourceLocation(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLint {.importc.} + proc glGetProgramResourceLocation(program: GLuint, programInterface: GLenum, name: cstring): TGLint {.importc.} proc glUniform4i64vNV(location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} proc glImageTransformParameterfHP(target: GLenum, pname: GLenum, param: GLfloat) {.importc.} proc glArrayObjectATI(`array`: GLenum, size: GLint, `type`: GLenum, stride: GLsizei, buffer: GLuint, offset: GLuint) {.importc.} @@ -2442,7 +2442,7 @@ wrapErrorChecking: proc glListParameteriSGIX(list: GLuint, pname: GLenum, param: GLint) {.importc.} proc glProgramUniformMatrix2dvEXT(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} proc glProgramUniform2i64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLint64EXT) {.importc.} - proc glObjectPtrLabelKHR(`ptr`: ptr pointer, length: GLsizei, label: ptr GLchar) {.importc.} + proc glObjectPtrLabelKHR(`ptr`: ptr pointer, length: GLsizei, label: cstring) {.importc.} proc glVertexAttribL1i64NV(index: GLuint, x: GLint64EXT) {.importc.} proc glMultiTexBufferEXT(texunit: GLenum, target: GLenum, internalformat: GLenum, buffer: GLuint) {.importc.} proc glCoverFillPathInstancedNV(numPaths: GLsizei, pathNameType: GLenum, paths: pointer, pathBase: GLuint, coverMode: GLenum, transformType: GLenum, transformValues: ptr GLfloat) {.importc.} @@ -2461,7 +2461,7 @@ wrapErrorChecking: proc glGetBooleanv(pname: GLenum, params: ptr GLboolean) {.importc.} proc glTangent3ivEXT(v: ptr GLint) {.importc.} proc glTexImage3DMultisample(target: GLenum, samples: GLsizei, internalformat: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, fixedsamplelocations: GLboolean) {.importc.} - proc glGetUniformIndices(program: GLuint, uniformCount: GLsizei, uniformNames: ptr ptr GLchar, uniformIndices: ptr GLuint) {.importc.} + proc glGetUniformIndices(program: GLuint, uniformCount: GLsizei, uniformNames: cstringArray, uniformIndices: ptr GLuint) {.importc.} proc glVDPAUInitNV(vdpDevice: pointer, getProcAddress: pointer) {.importc.} proc glGetMinmaxParameterivEXT(target: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glMultiTexCoord2fvARB(target: GLenum, v: ptr GLfloat) {.importc.} @@ -2473,18 +2473,18 @@ wrapErrorChecking: proc glGetInstrumentsSGIX(): TGLint {.importc.} proc glFramebufferParameteri(target: GLenum, pname: GLenum, param: GLint) {.importc.} proc glPathCoverDepthFuncNV(func: GLenum) {.importc.} - proc glGetTranslatedShaderSourceANGLE(shader: GLuint, bufsize: GLsizei, length: ptr GLsizei, source: ptr GLchar) {.importc.} + proc glGetTranslatedShaderSourceANGLE(shader: GLuint, bufsize: GLsizei, length: ptr GLsizei, source: cstring) {.importc.} proc glIndexfv(c: ptr GLfloat) {.importc.} - proc glGetActiveUniformBlockName(program: GLuint, uniformBlockIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformBlockName: ptr GLchar) {.importc.} + proc glGetActiveUniformBlockName(program: GLuint, uniformBlockIndex: GLuint, bufSize: GLsizei, length: ptr GLsizei, uniformBlockName: cstring) {.importc.} proc glNormal3s(nx: GLshort, ny: GLshort, nz: GLshort) {.importc.} proc glColorFragmentOp3ATI(op: GLenum, dst: GLuint, dstMask: GLuint, dstMod: GLuint, arg1: GLuint, arg1Rep: GLuint, arg1Mod: GLuint, arg2: GLuint, arg2Rep: GLuint, arg2Mod: GLuint, arg3: GLuint, arg3Rep: GLuint, arg3Mod: GLuint) {.importc.} - proc glGetProgramResourceLocationIndex(program: GLuint, programInterface: GLenum, name: ptr GLchar): TGLint {.importc.} + proc glGetProgramResourceLocationIndex(program: GLuint, programInterface: GLenum, name: cstring): TGLint {.importc.} proc glGetBooleanIndexedvEXT(target: GLenum, index: GLuint, data: ptr GLboolean) {.importc.} proc glGenPerfMonitorsAMD(n: GLsizei, monitors: ptr GLuint) {.importc.} proc glDrawRangeElementsEXT(mode: GLenum, start: GLuint, `end`: GLuint, count: GLsizei, `type`: GLenum, indices: pointer) {.importc.} proc glFramebufferTexture3D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLuint, level: GLint, zoffset: GLint) {.importc.} proc glGetTexParameterxvOES(target: GLenum, pname: GLenum, params: ptr GLfixed) {.importc.} - proc glCompileShaderIncludeARB(shader: GLuint, count: GLsizei, path: ptr ptr GLchar, length: ptr GLint) {.importc.} + proc glCompileShaderIncludeARB(shader: GLuint, count: GLsizei, path: cstringArray, length: ptr GLint) {.importc.} proc glGetMultiTexParameterfvEXT(texunit: GLenum, target: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glEvalPoint2(i: GLint, j: GLint) {.importc.} proc glGetProgramivNV(id: GLuint, pname: GLenum, params: ptr GLint) {.importc.} @@ -2498,7 +2498,7 @@ wrapErrorChecking: proc glProgramUniformMatrix3x4dv(program: GLuint, location: GLint, count: GLsizei, transpose: GLboolean, value: ptr GLdouble) {.importc.} proc glGetFloati_vEXT(pname: GLenum, index: GLuint, params: ptr GLfloat) {.importc.} proc glGetObjectParameterivAPPLE(objectType: GLenum, name: GLuint, pname: GLenum, params: ptr GLint) {.importc.} - proc glPushGroupMarkerEXT(length: GLsizei, marker: ptr GLchar) {.importc.} + proc glPushGroupMarkerEXT(length: GLsizei, marker: cstring) {.importc.} proc glProgramUniform4uivEXT(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} proc glReplacementCodeuiVertex3fSUN(rc: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glTexSubImage1DEXT(target: GLenum, level: GLint, xoffset: GLint, width: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} @@ -2571,7 +2571,7 @@ wrapErrorChecking: proc glTexCoord4bOES(s: GLbyte, t: GLbyte, r: GLbyte, q: GLbyte) {.importc.} proc glSecondaryColor3us(red: GLushort, green: GLushort, blue: GLushort) {.importc.} proc glGlobalAlphaFactorubSUN(factor: GLubyte) {.importc.} - proc glNamedStringARB(`type`: GLenum, namelen: GLint, name: ptr GLchar, stringlen: GLint, string: ptr GLchar) {.importc.} + proc glNamedStringARB(`type`: GLenum, namelen: GLint, name: cstring, stringlen: GLint, string: cstring) {.importc.} proc glGetAttachedShaders(program: GLuint, maxCount: GLsizei, count: ptr GLsizei, shaders: ptr GLuint) {.importc.} proc glMatrixRotatefEXT(mode: GLenum, angle: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glVertexStream3ivATI(stream: GLenum, coords: ptr GLint) {.importc.} @@ -2643,12 +2643,12 @@ wrapErrorChecking: proc glIsQuery(id: GLuint): TGLboolean {.importc.} proc glFogxv(pname: GLenum, param: ptr GLfixed) {.importc.} proc glAreProgramsResidentNV(n: GLsizei, programs: ptr GLuint, residences: ptr GLboolean): TGLboolean {.importc.} - proc glShaderSourceARB(shaderObj: GLhandleARB, count: GLsizei, string: ptr ptr GLcharARB, length: ptr GLint) {.importc.} + proc glShaderSourceARB(shaderObj: GLhandleARB, count: GLsizei, string: cstringArray, length: ptr GLint) {.importc.} proc glPointSizexOES(size: GLfixed) {.importc.} proc glPixelTransferf(pname: GLenum, param: GLfloat) {.importc.} proc glExtractComponentEXT(res: GLuint, src: GLuint, num: GLuint) {.importc.} proc glUniform1fv(location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} - proc glGetNamedStringARB(namelen: GLint, name: ptr GLchar, bufSize: GLsizei, stringlen: ptr GLint, string: ptr GLchar) {.importc.} + proc glGetNamedStringARB(namelen: GLint, name: cstring, bufSize: GLsizei, stringlen: ptr GLint, string: cstring) {.importc.} proc glGetProgramBinaryOES(program: GLuint, bufSize: GLsizei, length: ptr GLsizei, binaryFormat: ptr GLenum, binary: pointer) {.importc.} proc glDeleteOcclusionQueriesNV(n: GLsizei, ids: ptr GLuint) {.importc.} proc glEnableClientState(`array`: GLenum) {.importc.} @@ -2693,14 +2693,14 @@ wrapErrorChecking: proc glIndexub(c: GLubyte) {.importc.} proc glVertexP2uiv(`type`: GLenum, value: ptr GLuint) {.importc.} proc glProgramUniform1uiv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint) {.importc.} - proc glDebugMessageInsertKHR(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glDebugMessageInsertKHR(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} proc glColor4b(red: GLbyte, green: GLbyte, blue: GLbyte, alpha: GLbyte) {.importc.} proc glRenderbufferStorageMultisampleAPPLE(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei) {.importc.} proc glMinSampleShading(value: GLfloat) {.importc.} proc glBindProgramNV(target: GLenum, id: GLuint) {.importc.} proc glWindowPos3dMESA(x: GLdouble, y: GLdouble, z: GLdouble) {.importc.} proc glEdgeFlagPointer(stride: GLsizei, `pointer`: pointer) {.importc.} - proc glGetFragDataIndex(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetFragDataIndex(program: GLuint, name: cstring): TGLint {.importc.} proc glTexCoord3hNV(s: GLhalfNV, t: GLhalfNV, r: GLhalfNV) {.importc.} proc glMultiDrawArraysIndirectAMD(mode: GLenum, indirect: pointer, primcount: GLsizei, stride: GLsizei) {.importc.} proc glFragmentColorMaterialSGIX(face: GLenum, mode: GLenum) {.importc.} @@ -2746,7 +2746,7 @@ wrapErrorChecking: proc glWindowPos3iv(v: ptr GLint) {.importc.} proc glProgramUniform4ui64NV(program: GLuint, location: GLint, x: GLuint64EXT, y: GLuint64EXT, z: GLuint64EXT, w: GLuint64EXT) {.importc.} proc glProgramUniform2d(program: GLuint, location: GLint, v0: GLdouble, v1: GLdouble) {.importc.} - proc glDebugMessageInsertARB(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: ptr GLchar) {.importc.} + proc glDebugMessageInsertARB(source: GLenum, `type`: GLenum, id: GLuint, severity: GLenum, length: GLsizei, buf: cstring) {.importc.} proc glMultiTexSubImage3DEXT(texunit: GLenum, target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} proc glMap1d(target: GLenum, u1: GLdouble, u2: GLdouble, stride: GLint, order: GLint, points: ptr GLdouble) {.importc.} proc glDeleteShader(shader: GLuint) {.importc.} @@ -2778,7 +2778,7 @@ wrapErrorChecking: proc glGetVertexArrayIntegeri_vEXT(vaobj: GLuint, index: GLuint, pname: GLenum, param: ptr GLint) {.importc.} proc glReadnPixelsEXT(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, `type`: GLenum, bufSize: GLsizei, data: pointer) {.importc.} proc glMultiTexImage1DEXT(texunit: GLenum, target: GLenum, level: GLint, internalformat: GLint, width: GLsizei, border: GLint, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} - proc glGetVaryingLocationNV(program: GLuint, name: ptr GLchar): TGLint {.importc.} + proc glGetVaryingLocationNV(program: GLuint, name: cstring): TGLint {.importc.} proc glMultiTexCoord4fvARB(target: GLenum, v: ptr GLfloat) {.importc.} proc glMultiTexCoord3iv(target: GLenum, v: ptr GLint) {.importc.} proc glVertexAttribL2dvEXT(index: GLuint, v: ptr GLdouble) {.importc.} @@ -2791,7 +2791,7 @@ wrapErrorChecking: proc glProgramUniform3ui64vNV(program: GLuint, location: GLint, count: GLsizei, value: ptr GLuint64EXT) {.importc.} proc glTexCoord2fColor3fVertex3fvSUN(tc: ptr GLfloat, c: ptr GLfloat, v: ptr GLfloat) {.importc.} proc glProgramUniform3fv(program: GLuint, location: GLint, count: GLsizei, value: ptr GLfloat) {.importc.} - proc glBindFragDataLocationIndexed(program: GLuint, colorNumber: GLuint, index: GLuint, name: ptr GLchar) {.importc.} + proc glBindFragDataLocationIndexed(program: GLuint, colorNumber: GLuint, index: GLuint, name: cstring) {.importc.} proc glGetnSeparableFilterARB(target: GLenum, format: GLenum, `type`: GLenum, rowBufSize: GLsizei, row: pointer, columnBufSize: GLsizei, column: pointer, span: pointer) {.importc.} proc glTextureParameteriEXT(texture: GLuint, target: GLenum, pname: GLenum, param: GLint) {.importc.} proc glGetUniformuivEXT(program: GLuint, location: GLint, params: ptr GLuint) {.importc.} @@ -2809,12 +2809,12 @@ wrapErrorChecking: proc glTexCoord2fColor4fNormal3fVertex3fvSUN(tc: ptr GLfloat, c: ptr GLfloat, n: ptr GLfloat, v: ptr GLfloat) {.importc.} proc glMultiTexCoord3s(target: GLenum, s: GLshort, t: GLshort, r: GLshort) {.importc.} proc glMultTransposeMatrixd(m: ptr GLdouble) {.importc.} - proc glActiveVaryingNV(program: GLuint, name: ptr GLchar) {.importc.} + proc glActiveVaryingNV(program: GLuint, name: cstring) {.importc.} proc glProgramUniform1f(program: GLuint, location: GLint, v0: GLfloat) {.importc.} - proc glGetActiveSubroutineName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: ptr GLchar) {.importc.} + proc glGetActiveSubroutineName(program: GLuint, shadertype: GLenum, index: GLuint, bufsize: GLsizei, length: ptr GLsizei, name: cstring) {.importc.} proc glClipPlanex(plane: GLenum, equation: ptr GLfixed) {.importc.} proc glMultiTexCoord4iv(target: GLenum, v: ptr GLint) {.importc.} - proc glTransformFeedbackVaryingsEXT(program: GLuint, count: GLsizei, varyings: ptr ptr GLchar, bufferMode: GLenum) {.importc.} + proc glTransformFeedbackVaryingsEXT(program: GLuint, count: GLsizei, varyings: cstringArray, bufferMode: GLenum) {.importc.} proc glBlendEquationSeparateiARB(buf: GLuint, modeRGB: GLenum, modeAlpha: GLenum) {.importc.} proc glVertex2sv(v: ptr GLshort) {.importc.} proc glAccumxOES(op: GLenum, value: GLfixed) {.importc.} @@ -2894,7 +2894,7 @@ wrapErrorChecking: proc glPointParameterivNV(pname: GLenum, params: ptr GLint) {.importc.} proc glBlitFramebufferANGLE(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} proc glGetObjectParameterivARB(obj: GLhandleARB, pname: GLenum, params: ptr GLint) {.importc.} - proc glGetSubroutineIndex(program: GLuint, shadertype: GLenum, name: ptr GLchar): TGLuint {.importc.} + proc glGetSubroutineIndex(program: GLuint, shadertype: GLenum, name: cstring): TGLuint {.importc.} proc glMap2d(target: GLenum, u1: GLdouble, u2: GLdouble, ustride: GLint, uorder: GLint, v1: GLdouble, v2: GLdouble, vstride: GLint, vorder: GLint, points: ptr GLdouble) {.importc.} proc glRectfv(v1: ptr GLfloat, v2: ptr GLfloat) {.importc.} proc glDepthRangeArrayv(first: GLuint, count: GLsizei, v: ptr GLdouble) {.importc.} @@ -2951,7 +2951,7 @@ wrapErrorChecking: proc glEndQuery(target: GLenum) {.importc.} proc glBlitFramebufferEXT(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum) {.importc.} proc glProgramEnvParametersI4uivNV(target: GLenum, index: GLuint, count: GLsizei, params: ptr GLuint) {.importc.} - proc glGetActiveUniform(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: ptr GLchar) {.importc.} + proc glGetActiveUniform(program: GLuint, index: GLuint, bufSize: GLsizei, length: ptr GLsizei, size: ptr GLint, `type`: ptr GLenum, name: cstring) {.importc.} proc glGenAsyncMarkersSGIX(range: GLsizei): TGLuint {.importc.} proc glClipControlARB(origin: GLenum, depth: GLenum) {.importc.} proc glDrawElementsInstancedEXT(mode: GLenum, count: GLsizei, `type`: GLenum, indices: pointer, primcount: GLsizei) {.importc.} @@ -2970,7 +2970,7 @@ wrapErrorChecking: proc glProgramParameter4dvNV(target: GLenum, index: GLuint, v: ptr GLdouble) {.importc.} proc glDeleteBuffers(n: GLsizei, buffers: ptr GLuint) {.importc.} proc glGetVertexArrayIntegervEXT(vaobj: GLuint, pname: GLenum, param: ptr GLint) {.importc.} - proc glBindFragDataLocationEXT(program: GLuint, color: GLuint, name: ptr GLchar) {.importc.} + proc glBindFragDataLocationEXT(program: GLuint, color: GLuint, name: cstring) {.importc.} proc glGenProgramsNV(n: GLsizei, programs: ptr GLuint) {.importc.} proc glMultiTexCoord1i(target: GLenum, s: GLint) {.importc.} proc glCompressedTexImage3DOES(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, data: pointer) {.importc.} @@ -2988,7 +2988,7 @@ wrapErrorChecking: proc glTexGenivOES(coord: GLenum, pname: GLenum, params: ptr GLint) {.importc.} proc glIsFramebufferOES(framebuffer: GLuint): TGLboolean {.importc.} proc glColor4ubv(v: ptr GLubyte) {.importc.} - proc glDeleteNamedStringARB(namelen: GLint, name: ptr GLchar) {.importc.} + proc glDeleteNamedStringARB(namelen: GLint, name: cstring) {.importc.} proc glCopyConvolutionFilter1DEXT(target: GLenum, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei) {.importc.} proc glBufferStorage(target: GLenum, size: GLsizeiptr, data: ptr pointer, flags: GLbitfield) {.importc.} proc glDrawTexiOES(x: GLint, y: GLint, z: GLint, width: GLint, height: GLint) {.importc.} @@ -3140,7 +3140,7 @@ wrapErrorChecking: proc glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc: GLuint, s: GLfloat, t: GLfloat, r: GLfloat, g: GLfloat, b: GLfloat, a: GLfloat, nx: GLfloat, ny: GLfloat, nz: GLfloat, x: GLfloat, y: GLfloat, z: GLfloat) {.importc.} proc glSampleMapATI(dst: GLuint, interp: GLuint, swizzle: GLenum) {.importc.} proc glProgramUniform1d(program: GLuint, location: GLint, v0: GLdouble) {.importc.} - proc glBindAttribLocation(program: GLuint, index: GLuint, name: ptr GLchar) {.importc.} + proc glBindAttribLocation(program: GLuint, index: GLuint, name: cstring) {.importc.} proc glGetCombinerStageParameterfvNV(stage: GLenum, pname: GLenum, params: ptr GLfloat) {.importc.} proc glTexSubImage4DSGIS(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, woffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, size4d: GLsizei, format: GLenum, `type`: GLenum, pixels: pointer) {.importc.} proc glGetMapAttribParameterfvNV(target: GLenum, index: GLuint, pname: GLenum, params: ptr GLfloat) {.importc.} From 53716cae85fb728f614f86d1536a897e66fba0bb Mon Sep 17 00:00:00 2001 From: EXetoC Date: Thu, 17 Apr 2014 00:33:22 +0200 Subject: [PATCH 18/18] Export symbols; document the public interface. --- src/opengl.nim | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-) diff --git a/src/opengl.nim b/src/opengl.nim index 84119cb..119b214 100644 --- a/src/opengl.nim +++ b/src/opengl.nim @@ -269,37 +269,48 @@ type gleOutOfMem = (0x0505, "out of memory") gleInvalidFramebufferOperation = (0x0506, "invalid framebuffer operation") gleTableTooLarge = (0x8031, "table too large") - gleUnknown = (0x384623812, "unknown") proc glGetError*: TGLenum {.stdcall, importc, ogl.} proc getGlError*: TGlError = glGetError().TGlError + ## Like `glGetError` but returns an enumerator instead. type E_GL* = object of E_Base - code*: TGlError + ## An exception for OpenGL errors. + code*: TGlError ## The error code. This might be invalid for two reasons: + ## an outdated list of errors or a bad driver. -proc checkGlError = +proc checkGlError* = + ## Raise `E_GL` if the last call to an OpenGL function generated an error. + ## You might want to call this once every frame for example if automatic + ## error checking has been disabled. let error = getGlError() if error == gleNoError: return var exc = new(E_GL) - exc.code = gleUnknown - exc.msg = "OpenGL error: unknown" for e in TGlError: - if e == error and e != gleUnknown: + if e == error: exc.msg = "OpenGL error: " & $e - exc.code = e - break + raise exc + exc.code = error + exc.msg = "OpenGL error: unknown (" & $error & ")" raise exc -const NoGlAutoErrorCheck = defined(noGlAutoErrorCheck) +const + NoGlAutoErrorCheck* = defined(noGlAutoErrorCheck) #\ + ## This determines whether an exception should be raised if an OpenGL call + ## generates an error. No additional code will be generated when + ## `noGlAutoErrorCheck` has been defined. var glAutoErrorCheck = true proc enableGlAutoErrorCheck*(yes: bool) = + ## This determines whether an exception should be raised if an OpenGL call + ## generates an error. This has no effect when + ## ``NoGlAutoErrorCheck == true``. glAutoErrorCheck = yes macro wrapErrorChecking(f: stmt): stmt =