(*************************************************************)
(*                                                           *)
(*   This unit was generated using the following program:    *)
(*                                                           *)
(*  program name : Extension Header to Unit Converter v0.3   *)
(*  part of      : Freestanding                              *)
(*  author       : Danubius / Danube                         *)
(*  date         : 04-16-2005                                *)
(*                                                           *)
(*************************************************************)

unit WGLext;

(***) interface (***)

uses Windows, GL;

type
  PGLvoid = Pointer;
  PPGLvoid = ^PGLvoid;

function wglGetProcAddress(proc: PChar): Pointer; stdcall; external 'OpenGL32.dll';

(*************************************************************)
(*                  T   O   K   E   N   S                    *)
(*************************************************************)

const

(*** WGL_ARB_buffer_region ***)
  WGL_FRONT_COLOR_BUFFER_BIT_ARB = $00000001;
  WGL_BACK_COLOR_BUFFER_BIT_ARB  = $00000002;
  WGL_DEPTH_BUFFER_BIT_ARB       = $00000004;
  WGL_STENCIL_BUFFER_BIT_ARB     = $00000008;

(*** WGL_ARB_multisample ***)
  WGL_SAMPLE_BUFFERS_ARB         = $2041;
  WGL_SAMPLES_ARB                = $2042;

(*** WGL_ARB_extensions_string ***)

(*** WGL_ARB_pixel_format ***)
  WGL_NUMBER_PIXEL_FORMATS_ARB   = $2000;
  WGL_DRAW_TO_WINDOW_ARB         = $2001;
  WGL_DRAW_TO_BITMAP_ARB         = $2002;
  WGL_ACCELERATION_ARB           = $2003;
  WGL_NEED_PALETTE_ARB           = $2004;
  WGL_NEED_SYSTEM_PALETTE_ARB    = $2005;
  WGL_SWAP_LAYER_BUFFERS_ARB     = $2006;
  WGL_SWAP_METHOD_ARB            = $2007;
  WGL_NUMBER_OVERLAYS_ARB        = $2008;
  WGL_NUMBER_UNDERLAYS_ARB       = $2009;
  WGL_TRANSPARENT_ARB            = $200A;
  WGL_TRANSPARENT_RED_VALUE_ARB  = $2037;
  WGL_TRANSPARENT_GREEN_VALUE_ARB = $2038;
  WGL_TRANSPARENT_BLUE_VALUE_ARB = $2039;
  WGL_TRANSPARENT_ALPHA_VALUE_ARB = $203A;
  WGL_TRANSPARENT_INDEX_VALUE_ARB = $203B;
  WGL_SHARE_DEPTH_ARB            = $200C;
  WGL_SHARE_STENCIL_ARB          = $200D;
  WGL_SHARE_ACCUM_ARB            = $200E;
  WGL_SUPPORT_GDI_ARB            = $200F;
  WGL_SUPPORT_OPENGL_ARB         = $2010;
  WGL_DOUBLE_BUFFER_ARB          = $2011;
  WGL_STEREO_ARB                 = $2012;
  WGL_PIXEL_TYPE_ARB             = $2013;
  WGL_COLOR_BITS_ARB             = $2014;
  WGL_RED_BITS_ARB               = $2015;
  WGL_RED_SHIFT_ARB              = $2016;
  WGL_GREEN_BITS_ARB             = $2017;
  WGL_GREEN_SHIFT_ARB            = $2018;
  WGL_BLUE_BITS_ARB              = $2019;
  WGL_BLUE_SHIFT_ARB             = $201A;
  WGL_ALPHA_BITS_ARB             = $201B;
  WGL_ALPHA_SHIFT_ARB            = $201C;
  WGL_ACCUM_BITS_ARB             = $201D;
  WGL_ACCUM_RED_BITS_ARB         = $201E;
  WGL_ACCUM_GREEN_BITS_ARB       = $201F;
  WGL_ACCUM_BLUE_BITS_ARB        = $2020;
  WGL_ACCUM_ALPHA_BITS_ARB       = $2021;
  WGL_DEPTH_BITS_ARB             = $2022;
  WGL_STENCIL_BITS_ARB           = $2023;
  WGL_AUX_BUFFERS_ARB            = $2024;
  WGL_NO_ACCELERATION_ARB        = $2025;
  WGL_GENERIC_ACCELERATION_ARB   = $2026;
  WGL_FULL_ACCELERATION_ARB      = $2027;
  WGL_SWAP_EXCHANGE_ARB          = $2028;
  WGL_SWAP_COPY_ARB              = $2029;
  WGL_SWAP_UNDEFINED_ARB         = $202A;
  WGL_TYPE_RGBA_ARB              = $202B;
  WGL_TYPE_COLORINDEX_ARB        = $202C;

(*** WGL_ARB_make_current_read ***)
  ERROR_INVALID_PIXEL_TYPE_ARB   = $2043;
  ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = $2054;

(*** WGL_ARB_pbuffer ***)
  WGL_DRAW_TO_PBUFFER_ARB        = $202D;
  WGL_MAX_PBUFFER_PIXELS_ARB     = $202E;
  WGL_MAX_PBUFFER_WIDTH_ARB      = $202F;
  WGL_MAX_PBUFFER_HEIGHT_ARB     = $2030;
  WGL_PBUFFER_LARGEST_ARB        = $2033;
  WGL_PBUFFER_WIDTH_ARB          = $2034;
  WGL_PBUFFER_HEIGHT_ARB         = $2035;
  WGL_PBUFFER_LOST_ARB           = $2036;

(*** WGL_ARB_render_texture ***)
  WGL_BIND_TO_TEXTURE_RGB_ARB    = $2070;
  WGL_BIND_TO_TEXTURE_RGBA_ARB   = $2071;
  WGL_TEXTURE_FORMAT_ARB         = $2072;
  WGL_TEXTURE_TARGET_ARB         = $2073;
  WGL_MIPMAP_TEXTURE_ARB         = $2074;
  WGL_TEXTURE_RGB_ARB            = $2075;
  WGL_TEXTURE_RGBA_ARB           = $2076;
  WGL_NO_TEXTURE_ARB             = $2077;
  WGL_TEXTURE_CUBE_MAP_ARB       = $2078;
  WGL_TEXTURE_1D_ARB             = $2079;
  WGL_TEXTURE_2D_ARB             = $207A;
  WGL_MIPMAP_LEVEL_ARB           = $207B;
  WGL_CUBE_MAP_FACE_ARB          = $207C;
  WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $207D;
  WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $207E;
  WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $207F;
  WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $2080;
  WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $2081;
  WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $2082;
  WGL_FRONT_LEFT_ARB             = $2083;
  WGL_FRONT_RIGHT_ARB            = $2084;
  WGL_BACK_LEFT_ARB              = $2085;
  WGL_BACK_RIGHT_ARB             = $2086;
  WGL_AUX0_ARB                   = $2087;
  WGL_AUX1_ARB                   = $2088;
  WGL_AUX2_ARB                   = $2089;
  WGL_AUX3_ARB                   = $208A;
  WGL_AUX4_ARB                   = $208B;
  WGL_AUX5_ARB                   = $208C;
  WGL_AUX6_ARB                   = $208D;
  WGL_AUX7_ARB                   = $208E;
  WGL_AUX8_ARB                   = $208F;
  WGL_AUX9_ARB                   = $2090;

(*** WGL_ARB_pixel_format_float ***)
  WGL_TYPE_RGBA_FLOAT_ARB        = $21A0;

(*** WGL_EXT_make_current_read ***)
  ERROR_INVALID_PIXEL_TYPE_EXT   = $2043;

(*** WGL_EXT_pixel_format ***)
  WGL_NUMBER_PIXEL_FORMATS_EXT   = $2000;
  WGL_DRAW_TO_WINDOW_EXT         = $2001;
  WGL_DRAW_TO_BITMAP_EXT         = $2002;
  WGL_ACCELERATION_EXT           = $2003;
  WGL_NEED_PALETTE_EXT           = $2004;
  WGL_NEED_SYSTEM_PALETTE_EXT    = $2005;
  WGL_SWAP_LAYER_BUFFERS_EXT     = $2006;
  WGL_SWAP_METHOD_EXT            = $2007;
  WGL_NUMBER_OVERLAYS_EXT        = $2008;
  WGL_NUMBER_UNDERLAYS_EXT       = $2009;
  WGL_TRANSPARENT_EXT            = $200A;
  WGL_TRANSPARENT_VALUE_EXT      = $200B;
  WGL_SHARE_DEPTH_EXT            = $200C;
  WGL_SHARE_STENCIL_EXT          = $200D;
  WGL_SHARE_ACCUM_EXT            = $200E;
  WGL_SUPPORT_GDI_EXT            = $200F;
  WGL_SUPPORT_OPENGL_EXT         = $2010;
  WGL_DOUBLE_BUFFER_EXT          = $2011;
  WGL_STEREO_EXT                 = $2012;
  WGL_PIXEL_TYPE_EXT             = $2013;
  WGL_COLOR_BITS_EXT             = $2014;
  WGL_RED_BITS_EXT               = $2015;
  WGL_RED_SHIFT_EXT              = $2016;
  WGL_GREEN_BITS_EXT             = $2017;
  WGL_GREEN_SHIFT_EXT            = $2018;
  WGL_BLUE_BITS_EXT              = $2019;
  WGL_BLUE_SHIFT_EXT             = $201A;
  WGL_ALPHA_BITS_EXT             = $201B;
  WGL_ALPHA_SHIFT_EXT            = $201C;
  WGL_ACCUM_BITS_EXT             = $201D;
  WGL_ACCUM_RED_BITS_EXT         = $201E;
  WGL_ACCUM_GREEN_BITS_EXT       = $201F;
  WGL_ACCUM_BLUE_BITS_EXT        = $2020;
  WGL_ACCUM_ALPHA_BITS_EXT       = $2021;
  WGL_DEPTH_BITS_EXT             = $2022;
  WGL_STENCIL_BITS_EXT           = $2023;
  WGL_AUX_BUFFERS_EXT            = $2024;
  WGL_NO_ACCELERATION_EXT        = $2025;
  WGL_GENERIC_ACCELERATION_EXT   = $2026;
  WGL_FULL_ACCELERATION_EXT      = $2027;
  WGL_SWAP_EXCHANGE_EXT          = $2028;
  WGL_SWAP_COPY_EXT              = $2029;
  WGL_SWAP_UNDEFINED_EXT         = $202A;
  WGL_TYPE_RGBA_EXT              = $202B;
  WGL_TYPE_COLORINDEX_EXT        = $202C;

(*** WGL_EXT_pbuffer ***)
  WGL_DRAW_TO_PBUFFER_EXT        = $202D;
  WGL_MAX_PBUFFER_PIXELS_EXT     = $202E;
  WGL_MAX_PBUFFER_WIDTH_EXT      = $202F;
  WGL_MAX_PBUFFER_HEIGHT_EXT     = $2030;
  WGL_OPTIMAL_PBUFFER_WIDTH_EXT  = $2031;
  WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = $2032;
  WGL_PBUFFER_LARGEST_EXT        = $2033;
  WGL_PBUFFER_WIDTH_EXT          = $2034;
  WGL_PBUFFER_HEIGHT_EXT         = $2035;

(*** WGL_EXT_depth_float ***)
  WGL_DEPTH_FLOAT_EXT            = $2040;

(*** WGL_3DFX_multisample ***)
  WGL_SAMPLE_BUFFERS_3DFX        = $2060;
  WGL_SAMPLES_3DFX               = $2061;

(*** WGL_EXT_multisample ***)
  WGL_SAMPLE_BUFFERS_EXT         = $2041;
  WGL_SAMPLES_EXT                = $2042;

(*** WGL_I3D_digital_video_control ***)
  WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = $2050;
  WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = $2051;
  WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = $2052;
  WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = $2053;

(*** WGL_I3D_gamma ***)
  WGL_GAMMA_TABLE_SIZE_I3D       = $204E;
  WGL_GAMMA_EXCLUDE_DESKTOP_I3D  = $204F;

(*** WGL_I3D_genlock ***)
  WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = $2044;
  WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = $2045;
  WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = $2046;
  WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = $2047;
  WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = $2048;
  WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = $2049;
  WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = $204A;
  WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = $204B;
  WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = $204C;

(*** WGL_I3D_image_buffer ***)
  WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = $00000001;
  WGL_IMAGE_BUFFER_LOCK_I3D      = $00000002;

(*** WGL_I3D_swap_frame_lock ***)

(*** WGL_NV_render_depth_texture ***)
  WGL_BIND_TO_TEXTURE_DEPTH_NV   = $20A3;
  WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = $20A4;
  WGL_DEPTH_TEXTURE_FORMAT_NV    = $20A5;
  WGL_TEXTURE_DEPTH_COMPONENT_NV = $20A6;
  WGL_DEPTH_COMPONENT_NV         = $20A7;

(*** WGL_NV_render_texture_rectangle ***)
  WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = $20A0;
  WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = $20A1;
  WGL_TEXTURE_RECTANGLE_NV       = $20A2;

(*** WGL_ATI_pixel_format_float ***)
  WGL_TYPE_RGBA_FLOAT_ATI        = $21A0;

(*** WGL_NV_float_buffer ***)
  WGL_FLOAT_COMPONENTS_NV        = $20B0;
  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = $20B1;
  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = $20B2;
  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = $20B3;
  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = $20B4;
  WGL_TEXTURE_FLOAT_R_NV         = $20B5;
  WGL_TEXTURE_FLOAT_RG_NV        = $20B6;
  WGL_TEXTURE_FLOAT_RGB_NV       = $20B7;
  WGL_TEXTURE_FLOAT_RGBA_NV      = $20B8;

(*************************************************************)
(*                    T   Y   P   E   S                      *)
(*************************************************************)

type

(*** WGL_ARB_pbuffer ***)
  HPBUFFERARB = cardinal;

(*** WGL_EXT_pbuffer ***)
  HPBUFFEREXT = cardinal;

(*************************************************************)
(*            F   U   N   C   T   I   O   N   S              *)
(*************************************************************)

var

(*** WGL_ARB_buffer_region ***)
  WGLCREATEBUFFERREGIONARB: function(hDC: HDC; iLayerPlane: GLint; uType: GLuint): GLuint; stdcall;
  WGLDELETEBUFFERREGIONARB: procedure(hRegion: GLuint); stdcall;
  WGLSAVEBUFFERREGIONARB: function(hRegion: GLuint; x: GLint; y: GLint; width: GLint; height: GLint): GLboolean; stdcall;
  WGLRESTOREBUFFERREGIONARB: function(hRegion: GLuint; x: GLint; y: GLint; width: GLint; height: GLint; xSrc: GLint; ySrc: GLint): GLboolean; stdcall;

(*** WGL_ARB_multisample ***)

(*** WGL_ARB_extensions_string ***)
  WGLGETEXTENSIONSSTRINGARB: function(hdc: HDC): PChar; stdcall;

(*** WGL_ARB_pixel_format ***)
  WGLGETPIXELFORMATATTRIBIVARB: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; piValues: PGLint): GLboolean; stdcall;
  WGLGETPIXELFORMATATTRIBFVARB: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; pfValues: PGLfloat): GLboolean; stdcall;
  WGLCHOOSEPIXELFORMATARB: function(hdc: HDC; piAttribIList: PGLint; pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): GLboolean; stdcall;

(*** WGL_ARB_make_current_read ***)
  WGLMAKECONTEXTCURRENTARB: function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): GLboolean; stdcall;
  WGLGETCURRENTREADDCARB: function: HDC; stdcall;

(*** WGL_ARB_pbuffer ***)
  WGLCREATEPBUFFERARB: function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; piAttribList: PGLint): HPBUFFERARB; stdcall;
  WGLGETPBUFFERDCARB: function(hPbuffer: HPBUFFERARB): HDC; stdcall;
  WGLRELEASEPBUFFERDCARB: function(hPbuffer: HPBUFFERARB; hDC: HDC): GLint; stdcall;
  WGLDESTROYPBUFFERARB: function(hPbuffer: HPBUFFERARB): GLboolean; stdcall;
  WGLQUERYPBUFFERARB: function(hPbuffer: HPBUFFERARB; iAttribute: GLint; piValue: PGLint): GLboolean; stdcall;

(*** WGL_ARB_render_texture ***)
  WGLBINDTEXIMAGEARB: function(hPbuffer: HPBUFFERARB; iBuffer: GLint): GLboolean; stdcall;
  WGLRELEASETEXIMAGEARB: function(hPbuffer: HPBUFFERARB; iBuffer: GLint): GLboolean; stdcall;
  WGLSETPBUFFERATTRIBARB: function(hPbuffer: HPBUFFERARB; piAttribList: PGLint): GLboolean; stdcall;

(*** WGL_ARB_pixel_format_float ***)

(*** WGL_EXT_display_color_table ***)
  WGLCREATEDISPLAYCOLORTABLEEXT: function(id: GLushort): GLboolean; stdcall;
  WGLLOADDISPLAYCOLORTABLEEXT: function(table: PGLushort; length: GLuint): GLboolean; stdcall;
  WGLBINDDISPLAYCOLORTABLEEXT: function(id: GLushort): GLboolean; stdcall;
  WGLDESTROYDISPLAYCOLORTABLEEXT: procedure(id: GLushort); stdcall;

(*** WGL_EXT_extensions_string ***)
  WGLGETEXTENSIONSSTRINGEXT: function: PChar; stdcall;

(*** WGL_EXT_make_current_read ***)
  WGLMAKECONTEXTCURRENTEXT: function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): GLboolean; stdcall;
  WGLGETCURRENTREADDCEXT: function: HDC; stdcall;

(*** WGL_EXT_pbuffer ***)
  WGLCREATEPBUFFEREXT: function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; piAttribList: PGLint): HPBUFFEREXT; stdcall;
  WGLGETPBUFFERDCEXT: function(hPbuffer: HPBUFFEREXT): HDC; stdcall;
  WGLRELEASEPBUFFERDCEXT: function(hPbuffer: HPBUFFEREXT; hDC: HDC): GLint; stdcall;
  WGLDESTROYPBUFFEREXT: function(hPbuffer: HPBUFFEREXT): GLboolean; stdcall;
  WGLQUERYPBUFFEREXT: function(hPbuffer: HPBUFFEREXT; iAttribute: GLint; piValue: PGLint): GLboolean; stdcall;

(*** WGL_EXT_pixel_format ***)
  WGLGETPIXELFORMATATTRIBIVEXT: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; piValues: PGLint): GLboolean; stdcall;
  WGLGETPIXELFORMATATTRIBFVEXT: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; pfValues: PGLfloat): GLboolean; stdcall;
  WGLCHOOSEPIXELFORMATEXT: function(hdc: HDC; piAttribIList: PGLint; pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): GLboolean; stdcall;

(*** WGL_EXT_swap_control ***)
  WGLSWAPINTERVALEXT: function(interval: GLint): GLboolean; stdcall;
  WGLGETSWAPINTERVALEXT: function: GLint; stdcall;

(*** WGL_EXT_depth_float ***)

(*** WGL_NV_vertex_array_range ***)
  WGLALLOCATEMEMORYNV: function(size: GLsizei; readfreq: GLfloat; writefreq: GLfloat; priority: GLfloat): PGLvoid; stdcall;
  WGLFREEMEMORYNV: procedure(pointer: PGLvoid); stdcall;

(*** WGL_3DFX_multisample ***)

(*** WGL_EXT_multisample ***)

(*** WGL_OML_sync_control ***)
  WGLGETSYNCVALUESOML: function(hdc: HDC; ust: PINT64; msc: PINT64; sbc: PINT64): GLboolean; stdcall;
  WGLGETMSCRATEOML: function(hdc: HDC; numerator: PGLint; denominator: PGLint): GLboolean; stdcall;
  WGLSWAPBUFFERSMSCOML: function(hdc: HDC; target_msc: INT64; divisor: INT64; remainder: INT64): INT64; stdcall;
  WGLSWAPLAYERBUFFERSMSCOML: function(hdc: HDC; fuPlanes: GLint; target_msc: INT64; divisor: INT64; remainder: INT64): INT64; stdcall;
  WGLWAITFORMSCOML: function(hdc: HDC; target_msc: INT64; divisor: INT64; remainder: INT64; ust: PINT64; msc: PINT64; sbc: PINT64): GLboolean; stdcall;
  WGLWAITFORSBCOML: function(hdc: HDC; target_sbc: INT64; ust: PINT64; msc: PINT64; sbc: PINT64): GLboolean; stdcall;

(*** WGL_I3D_digital_video_control ***)
  WGLGETDIGITALVIDEOPARAMETERSI3D: function(hDC: HDC; iAttribute: GLint; piValue: PGLint): GLboolean; stdcall;
  WGLSETDIGITALVIDEOPARAMETERSI3D: function(hDC: HDC; iAttribute: GLint; piValue: PGLint): GLboolean; stdcall;

(*** WGL_I3D_gamma ***)
  WGLGETGAMMATABLEPARAMETERSI3D: function(hDC: HDC; iAttribute: GLint; piValue: PGLint): GLboolean; stdcall;
  WGLSETGAMMATABLEPARAMETERSI3D: function(hDC: HDC; iAttribute: GLint; piValue: PGLint): GLboolean; stdcall;
  WGLGETGAMMATABLEI3D: function(hDC: HDC; iEntries: GLint; puRed: PGLushort; puGreen: PGLushort; puBlue: PGLushort): GLboolean; stdcall;
  WGLSETGAMMATABLEI3D: function(hDC: HDC; iEntries: GLint; puRed: PGLushort; puGreen: PGLushort; puBlue: PGLushort): GLboolean; stdcall;

(*** WGL_I3D_genlock ***)
  WGLENABLEGENLOCKI3D: function(hDC: HDC): GLboolean; stdcall;
  WGLDISABLEGENLOCKI3D: function(hDC: HDC): GLboolean; stdcall;
  WGLISENABLEDGENLOCKI3D: function(hDC: HDC; pFlag: PGLboolean): GLboolean; stdcall;
  WGLGENLOCKSOURCEI3D: function(hDC: HDC; uSource: GLuint): GLboolean; stdcall;
  WGLGETGENLOCKSOURCEI3D: function(hDC: HDC; uSource: PGLuint): GLboolean; stdcall;
  WGLGENLOCKSOURCEEDGEI3D: function(hDC: HDC; uEdge: GLuint): GLboolean; stdcall;
  WGLGETGENLOCKSOURCEEDGEI3D: function(hDC: HDC; uEdge: PGLuint): GLboolean; stdcall;
  WGLGENLOCKSAMPLERATEI3D: function(hDC: HDC; uRate: GLuint): GLboolean; stdcall;
  WGLGETGENLOCKSAMPLERATEI3D: function(hDC: HDC; uRate: PGLuint): GLboolean; stdcall;
  WGLGENLOCKSOURCEDELAYI3D: function(hDC: HDC; uDelay: GLuint): GLboolean; stdcall;
  WGLGETGENLOCKSOURCEDELAYI3D: function(hDC: HDC; uDelay: PGLuint): GLboolean; stdcall;
  WGLQUERYGENLOCKMAXSOURCEDELAYI3D: function(hDC: HDC; uMaxLineDelay: PGLuint; uMaxPixelDelay: PGLuint): GLboolean; stdcall;

(*** WGL_I3D_image_buffer ***)
  WGLCREATEIMAGEBUFFERI3D: function(hDC: HDC; dwSize: DWORD; uFlags: GLuint): PGLvoid; stdcall;
  WGLDESTROYIMAGEBUFFERI3D: function(hDC: HDC; pAddress: PGLvoid): GLboolean; stdcall;
  WGLASSOCIATEIMAGEBUFFEREVENTSI3D: function(hDC: HDC; pEvent: PGLuint; pAddress: PPGLvoid; pSize: PDWORD; count: GLuint): GLboolean; stdcall;
  WGLRELEASEIMAGEBUFFEREVENTSI3D: function(hDC: HDC; pAddress: PPGLvoid; count: GLuint): GLboolean; stdcall;

(*** WGL_I3D_swap_frame_lock ***)
  WGLENABLEFRAMELOCKI3D: function: GLboolean; stdcall;
  WGLDISABLEFRAMELOCKI3D: function: GLboolean; stdcall;
  WGLISENABLEDFRAMELOCKI3D: function(pFlag: PGLboolean): GLboolean; stdcall;
  WGLQUERYFRAMELOCKMASTERI3D: function(pFlag: PGLboolean): GLboolean; stdcall;

(*** WGL_I3D_swap_frame_usage ***)
  WGLGETFRAMEUSAGEI3D: function(pUsage: PGLfloat): GLboolean; stdcall;
  WGLBEGINFRAMETRACKINGI3D: function: GLboolean; stdcall;
  WGLENDFRAMETRACKINGI3D: function: GLboolean; stdcall;
  WGLQUERYFRAMETRACKINGI3D: function(pFrameCount: PDWORD; pMissedFrames: PDWORD; pLastMissedUsage: PGLfloat): GLboolean; stdcall;

(*** WGL_ATI_pixel_format_float ***)

(*** WGL_NV_float_buffer ***)

function Load_WGL_ARB_buffer_region: boolean;
function Load_WGL_ARB_multisample: boolean;
function Load_WGL_ARB_extensions_string: boolean;
function Load_WGL_ARB_pixel_format: boolean;
function Load_WGL_ARB_make_current_read: boolean;
function Load_WGL_ARB_pbuffer: boolean;
function Load_WGL_ARB_render_texture: boolean;
function Load_WGL_ARB_pixel_format_float: boolean;
function Load_WGL_EXT_display_color_table: boolean;
function Load_WGL_EXT_extensions_string: boolean;
function Load_WGL_EXT_make_current_read: boolean;
function Load_WGL_EXT_pbuffer: boolean;
function Load_WGL_EXT_pixel_format: boolean;
function Load_WGL_EXT_swap_control: boolean;
function Load_WGL_EXT_depth_float: boolean;
function Load_WGL_NV_vertex_array_range: boolean;
function Load_WGL_3DFX_multisample: boolean;
function Load_WGL_EXT_multisample: boolean;
function Load_WGL_OML_sync_control: boolean;
function Load_WGL_I3D_digital_video_control: boolean;
function Load_WGL_I3D_gamma: boolean;
function Load_WGL_I3D_genlock: boolean;
function Load_WGL_I3D_image_buffer: boolean;
function Load_WGL_I3D_swap_frame_lock: boolean;
function Load_WGL_I3D_swap_frame_usage: boolean;
function Load_WGL_ATI_pixel_format_float: boolean;
function Load_WGL_NV_float_buffer: boolean;

(***) implementation (***)

(*** WGL_ARB_buffer_region ***)
function Load_WGL_ARB_buffer_region: boolean;
begin
  result := false;
  wglCreateBufferRegionARB := wglGetProcAddress('wglCreateBufferRegionARB');
  if not Assigned(wglCreateBufferRegionARB) then exit;
  wglDeleteBufferRegionARB := wglGetProcAddress('wglDeleteBufferRegionARB');
  if not Assigned(wglDeleteBufferRegionARB) then exit;
  wglSaveBufferRegionARB := wglGetProcAddress('wglSaveBufferRegionARB');
  if not Assigned(wglSaveBufferRegionARB) then exit;
  wglRestoreBufferRegionARB := wglGetProcAddress('wglRestoreBufferRegionARB');
  if not Assigned(wglRestoreBufferRegionARB) then exit;
  result := true;
end;

(*** WGL_ARB_multisample ***)
function Load_WGL_ARB_multisample: boolean;
begin
  result := false;
  result := true;
end;

(*** WGL_ARB_extensions_string ***)
function Load_WGL_ARB_extensions_string: boolean;
begin
  result := false;
  wglGetExtensionsStringARB := wglGetProcAddress('wglGetExtensionsStringARB');
  if not Assigned(wglGetExtensionsStringARB) then exit;
  result := true;
end;

(*** WGL_ARB_pixel_format ***)
function Load_WGL_ARB_pixel_format: boolean;
begin
  result := false;
  wglGetPixelFormatAttribivARB := wglGetProcAddress('wglGetPixelFormatAttribivARB');
  if not Assigned(wglGetPixelFormatAttribivARB) then exit;
  wglGetPixelFormatAttribfvARB := wglGetProcAddress('wglGetPixelFormatAttribfvARB');
  if not Assigned(wglGetPixelFormatAttribfvARB) then exit;
  wglChoosePixelFormatARB := wglGetProcAddress('wglChoosePixelFormatARB');
  if not Assigned(wglChoosePixelFormatARB) then exit;
  result := true;
end;

(*** WGL_ARB_make_current_read ***)
function Load_WGL_ARB_make_current_read: boolean;
begin
  result := false;
  wglMakeContextCurrentARB := wglGetProcAddress('wglMakeContextCurrentARB');
  if not Assigned(wglMakeContextCurrentARB) then exit;
  wglGetCurrentReadDCARB := wglGetProcAddress('wglGetCurrentReadDCARB');
  if not Assigned(wglGetCurrentReadDCARB) then exit;
  result := true;
end;

(*** WGL_ARB_pbuffer ***)
function Load_WGL_ARB_pbuffer: boolean;
begin
  result := false;
  wglCreatePbufferARB := wglGetProcAddress('wglCreatePbufferARB');
  if not Assigned(wglCreatePbufferARB) then exit;
  wglGetPbufferDCARB := wglGetProcAddress('wglGetPbufferDCARB');
  if not Assigned(wglGetPbufferDCARB) then exit;
  wglReleasePbufferDCARB := wglGetProcAddress('wglReleasePbufferDCARB');
  if not Assigned(wglReleasePbufferDCARB) then exit;
  wglDestroyPbufferARB := wglGetProcAddress('wglDestroyPbufferARB');
  if not Assigned(wglDestroyPbufferARB) then exit;
  wglQueryPbufferARB := wglGetProcAddress('wglQueryPbufferARB');
  if not Assigned(wglQueryPbufferARB) then exit;
  result := true;
end;

(*** WGL_ARB_render_texture ***)
function Load_WGL_ARB_render_texture: boolean;
begin
  result := false;
  wglBindTexImageARB := wglGetProcAddress('wglBindTexImageARB');
  if not Assigned(wglBindTexImageARB) then exit;
  wglReleaseTexImageARB := wglGetProcAddress('wglReleaseTexImageARB');
  if not Assigned(wglReleaseTexImageARB) then exit;
  wglSetPbufferAttribARB := wglGetProcAddress('wglSetPbufferAttribARB');
  if not Assigned(wglSetPbufferAttribARB) then exit;
  result := true;
end;

(*** WGL_ARB_pixel_format_float ***)
function Load_WGL_ARB_pixel_format_float: boolean;
begin
  result := false;
  result := true;
end;

(*** WGL_EXT_display_color_table ***)
function Load_WGL_EXT_display_color_table: boolean;
begin
  result := false;
  wglCreateDisplayColorTableEXT := wglGetProcAddress('wglCreateDisplayColorTableEXT');
  if not Assigned(wglCreateDisplayColorTableEXT) then exit;
  wglLoadDisplayColorTableEXT := wglGetProcAddress('wglLoadDisplayColorTableEXT');
  if not Assigned(wglLoadDisplayColorTableEXT) then exit;
  wglBindDisplayColorTableEXT := wglGetProcAddress('wglBindDisplayColorTableEXT');
  if not Assigned(wglBindDisplayColorTableEXT) then exit;
  wglDestroyDisplayColorTableEXT := wglGetProcAddress('wglDestroyDisplayColorTableEXT');
  if not Assigned(wglDestroyDisplayColorTableEXT) then exit;
  result := true;
end;

(*** WGL_EXT_extensions_string ***)
function Load_WGL_EXT_extensions_string: boolean;
begin
  result := false;
  wglGetExtensionsStringEXT := wglGetProcAddress('wglGetExtensionsStringEXT');
  if not Assigned(wglGetExtensionsStringEXT) then exit;
  result := true;
end;

(*** WGL_EXT_make_current_read ***)
function Load_WGL_EXT_make_current_read: boolean;
begin
  result := false;
  wglMakeContextCurrentEXT := wglGetProcAddress('wglMakeContextCurrentEXT');
  if not Assigned(wglMakeContextCurrentEXT) then exit;
  wglGetCurrentReadDCEXT := wglGetProcAddress('wglGetCurrentReadDCEXT');
  if not Assigned(wglGetCurrentReadDCEXT) then exit;
  result := true;
end;

(*** WGL_EXT_pbuffer ***)
function Load_WGL_EXT_pbuffer: boolean;
begin
  result := false;
  wglCreatePbufferEXT := wglGetProcAddress('wglCreatePbufferEXT');
  if not Assigned(wglCreatePbufferEXT) then exit;
  wglGetPbufferDCEXT := wglGetProcAddress('wglGetPbufferDCEXT');
  if not Assigned(wglGetPbufferDCEXT) then exit;
  wglReleasePbufferDCEXT := wglGetProcAddress('wglReleasePbufferDCEXT');
  if not Assigned(wglReleasePbufferDCEXT) then exit;
  wglDestroyPbufferEXT := wglGetProcAddress('wglDestroyPbufferEXT');
  if not Assigned(wglDestroyPbufferEXT) then exit;
  wglQueryPbufferEXT := wglGetProcAddress('wglQueryPbufferEXT');
  if not Assigned(wglQueryPbufferEXT) then exit;
  result := true;
end;

(*** WGL_EXT_pixel_format ***)
function Load_WGL_EXT_pixel_format: boolean;
begin
  result := false;
  wglGetPixelFormatAttribivEXT := wglGetProcAddress('wglGetPixelFormatAttribivEXT');
  if not Assigned(wglGetPixelFormatAttribivEXT) then exit;
  wglGetPixelFormatAttribfvEXT := wglGetProcAddress('wglGetPixelFormatAttribfvEXT');
  if not Assigned(wglGetPixelFormatAttribfvEXT) then exit;
  wglChoosePixelFormatEXT := wglGetProcAddress('wglChoosePixelFormatEXT');
  if not Assigned(wglChoosePixelFormatEXT) then exit;
  result := true;
end;

(*** WGL_EXT_swap_control ***)
function Load_WGL_EXT_swap_control: boolean;
begin
  result := false;
  wglSwapIntervalEXT := wglGetProcAddress('wglSwapIntervalEXT');
  if not Assigned(wglSwapIntervalEXT) then exit;
  wglGetSwapIntervalEXT := wglGetProcAddress('wglGetSwapIntervalEXT');
  if not Assigned(wglGetSwapIntervalEXT) then exit;
  result := true;
end;

(*** WGL_EXT_depth_float ***)
function Load_WGL_EXT_depth_float: boolean;
begin
  result := false;
  result := true;
end;

(*** WGL_NV_vertex_array_range ***)
function Load_WGL_NV_vertex_array_range: boolean;
begin
  result := false;
  wglAllocateMemoryNV := wglGetProcAddress('wglAllocateMemoryNV');
  if not Assigned(wglAllocateMemoryNV) then exit;
  wglFreeMemoryNV := wglGetProcAddress('wglFreeMemoryNV');
  if not Assigned(wglFreeMemoryNV) then exit;
  result := true;
end;

(*** WGL_3DFX_multisample ***)
function Load_WGL_3DFX_multisample: boolean;
begin
  result := false;
  result := true;
end;

(*** WGL_EXT_multisample ***)
function Load_WGL_EXT_multisample: boolean;
begin
  result := false;
  result := true;
end;

(*** WGL_OML_sync_control ***)
function Load_WGL_OML_sync_control: boolean;
begin
  result := false;
  wglGetSyncValuesOML := wglGetProcAddress('wglGetSyncValuesOML');
  if not Assigned(wglGetSyncValuesOML) then exit;
  wglGetMscRateOML := wglGetProcAddress('wglGetMscRateOML');
  if not Assigned(wglGetMscRateOML) then exit;
  wglSwapBuffersMscOML := wglGetProcAddress('wglSwapBuffersMscOML');
  if not Assigned(wglSwapBuffersMscOML) then exit;
  wglSwapLayerBuffersMscOML := wglGetProcAddress('wglSwapLayerBuffersMscOML');
  if not Assigned(wglSwapLayerBuffersMscOML) then exit;
  wglWaitForMscOML := wglGetProcAddress('wglWaitForMscOML');
  if not Assigned(wglWaitForMscOML) then exit;
  wglWaitForSbcOML := wglGetProcAddress('wglWaitForSbcOML');
  if not Assigned(wglWaitForSbcOML) then exit;
  result := true;
end;

(*** WGL_I3D_digital_video_control ***)
function Load_WGL_I3D_digital_video_control: boolean;
begin
  result := false;
  wglGetDigitalVideoParametersI3D := wglGetProcAddress('wglGetDigitalVideoParametersI3D');
  if not Assigned(wglGetDigitalVideoParametersI3D) then exit;
  wglSetDigitalVideoParametersI3D := wglGetProcAddress('wglSetDigitalVideoParametersI3D');
  if not Assigned(wglSetDigitalVideoParametersI3D) then exit;
  result := true;
end;

(*** WGL_I3D_gamma ***)
function Load_WGL_I3D_gamma: boolean;
begin
  result := false;
  wglGetGammaTableParametersI3D := wglGetProcAddress('wglGetGammaTableParametersI3D');
  if not Assigned(wglGetGammaTableParametersI3D) then exit;
  wglSetGammaTableParametersI3D := wglGetProcAddress('wglSetGammaTableParametersI3D');
  if not Assigned(wglSetGammaTableParametersI3D) then exit;
  wglGetGammaTableI3D := wglGetProcAddress('wglGetGammaTableI3D');
  if not Assigned(wglGetGammaTableI3D) then exit;
  wglSetGammaTableI3D := wglGetProcAddress('wglSetGammaTableI3D');
  if not Assigned(wglSetGammaTableI3D) then exit;
  result := true;
end;

(*** WGL_I3D_genlock ***)
function Load_WGL_I3D_genlock: boolean;
begin
  result := false;
  wglEnableGenlockI3D := wglGetProcAddress('wglEnableGenlockI3D');
  if not Assigned(wglEnableGenlockI3D) then exit;
  wglDisableGenlockI3D := wglGetProcAddress('wglDisableGenlockI3D');
  if not Assigned(wglDisableGenlockI3D) then exit;
  wglIsEnabledGenlockI3D := wglGetProcAddress('wglIsEnabledGenlockI3D');
  if not Assigned(wglIsEnabledGenlockI3D) then exit;
  wglGenlockSourceI3D := wglGetProcAddress('wglGenlockSourceI3D');
  if not Assigned(wglGenlockSourceI3D) then exit;
  wglGetGenlockSourceI3D := wglGetProcAddress('wglGetGenlockSourceI3D');
  if not Assigned(wglGetGenlockSourceI3D) then exit;
  wglGenlockSourceEdgeI3D := wglGetProcAddress('wglGenlockSourceEdgeI3D');
  if not Assigned(wglGenlockSourceEdgeI3D) then exit;
  wglGetGenlockSourceEdgeI3D := wglGetProcAddress('wglGetGenlockSourceEdgeI3D');
  if not Assigned(wglGetGenlockSourceEdgeI3D) then exit;
  wglGenlockSampleRateI3D := wglGetProcAddress('wglGenlockSampleRateI3D');
  if not Assigned(wglGenlockSampleRateI3D) then exit;
  wglGetGenlockSampleRateI3D := wglGetProcAddress('wglGetGenlockSampleRateI3D');
  if not Assigned(wglGetGenlockSampleRateI3D) then exit;
  wglGenlockSourceDelayI3D := wglGetProcAddress('wglGenlockSourceDelayI3D');
  if not Assigned(wglGenlockSourceDelayI3D) then exit;
  wglGetGenlockSourceDelayI3D := wglGetProcAddress('wglGetGenlockSourceDelayI3D');
  if not Assigned(wglGetGenlockSourceDelayI3D) then exit;
  wglQueryGenlockMaxSourceDelayI3D := wglGetProcAddress('wglQueryGenlockMaxSourceDelayI3D');
  if not Assigned(wglQueryGenlockMaxSourceDelayI3D) then exit;
  result := true;
end;

(*** WGL_I3D_image_buffer ***)
function Load_WGL_I3D_image_buffer: boolean;
begin
  result := false;
  wglCreateImageBufferI3D := wglGetProcAddress('wglCreateImageBufferI3D');
  if not Assigned(wglCreateImageBufferI3D) then exit;
  wglDestroyImageBufferI3D := wglGetProcAddress('wglDestroyImageBufferI3D');
  if not Assigned(wglDestroyImageBufferI3D) then exit;
  wglAssociateImageBufferEventsI3D := wglGetProcAddress('wglAssociateImageBufferEventsI3D');
  if not Assigned(wglAssociateImageBufferEventsI3D) then exit;
  wglReleaseImageBufferEventsI3D := wglGetProcAddress('wglReleaseImageBufferEventsI3D');
  if not Assigned(wglReleaseImageBufferEventsI3D) then exit;
  result := true;
end;

(*** WGL_I3D_swap_frame_lock ***)
function Load_WGL_I3D_swap_frame_lock: boolean;
begin
  result := false;
  wglEnableFrameLockI3D := wglGetProcAddress('wglEnableFrameLockI3D');
  if not Assigned(wglEnableFrameLockI3D) then exit;
  wglDisableFrameLockI3D := wglGetProcAddress('wglDisableFrameLockI3D');
  if not Assigned(wglDisableFrameLockI3D) then exit;
  wglIsEnabledFrameLockI3D := wglGetProcAddress('wglIsEnabledFrameLockI3D');
  if not Assigned(wglIsEnabledFrameLockI3D) then exit;
  wglQueryFrameLockMasterI3D := wglGetProcAddress('wglQueryFrameLockMasterI3D');
  if not Assigned(wglQueryFrameLockMasterI3D) then exit;
  result := true;
end;

(*** WGL_I3D_swap_frame_usage ***)
function Load_WGL_I3D_swap_frame_usage: boolean;
begin
  result := false;
  wglGetFrameUsageI3D := wglGetProcAddress('wglGetFrameUsageI3D');
  if not Assigned(wglGetFrameUsageI3D) then exit;
  wglBeginFrameTrackingI3D := wglGetProcAddress('wglBeginFrameTrackingI3D');
  if not Assigned(wglBeginFrameTrackingI3D) then exit;
  wglEndFrameTrackingI3D := wglGetProcAddress('wglEndFrameTrackingI3D');
  if not Assigned(wglEndFrameTrackingI3D) then exit;
  wglQueryFrameTrackingI3D := wglGetProcAddress('wglQueryFrameTrackingI3D');
  if not Assigned(wglQueryFrameTrackingI3D) then exit;
  result := true;
end;

(*** WGL_ATI_pixel_format_float ***)
function Load_WGL_ATI_pixel_format_float: boolean;
begin
  result := false;
  result := true;
end;

(*** WGL_NV_float_buffer ***)
function Load_WGL_NV_float_buffer: boolean;
begin
  result := false;
  result := true;
end;

end.
